tidy(ui): rename some classes to better represent their responsibilities

invokeai/frontend/web/src/features/controlLayers/konva/CanvasEntityAdapterBase.ts

@@ -1,6 +1,6 @@
 import type { SerializableObject } from 'common/types';
 import { deepClone } from 'common/util/deepClone';
-import { CanvasEntityRenderer } from 'features/controlLayers/konva/CanvasEntityRenderer';
+import { CanvasEntityObjectRenderer } from 'features/controlLayers/konva/CanvasEntityObjectRenderer';
 import { CanvasEntityTransformer } from 'features/controlLayers/konva/CanvasEntityTransformer';
 import type { CanvasManager } from 'features/controlLayers/konva/CanvasManager';
 import { CanvasModuleBase } from 'features/controlLayers/konva/CanvasModuleBase';
@@ -39,7 +39,7 @@ export abstract class CanvasEntityAdapterBase<
   /**
    * The renderer for this entity adapter.
    */
-  renderer: CanvasEntityRenderer;
+  renderer: CanvasEntityObjectRenderer;
 
   constructor(entityIdentifier: CanvasEntityIdentifier<T['type']>, manager: CanvasManager, adapterType: string) {
     super();
@@ -61,7 +61,7 @@ export abstract class CanvasEntityAdapterBase<
       }),
     };
 
-    this.renderer = new CanvasEntityRenderer(this);
+    this.renderer = new CanvasEntityObjectRenderer(this);
     this.transformer = new CanvasEntityTransformer(this);
   }
 

invokeai/frontend/web/src/features/controlLayers/konva/CanvasEntityObjectRenderer.ts

@@ -2,10 +2,10 @@ import { rgbColorToString } from 'common/util/colorCodeTransformers';
 import type { CanvasEntityAdapterBase } from 'features/controlLayers/konva/CanvasEntityAdapterBase';
 import type { CanvasManager } from 'features/controlLayers/konva/CanvasManager';
 import { CanvasModuleBase } from 'features/controlLayers/konva/CanvasModuleBase';
-import { CanvasObjectBrushLineRenderer } from 'features/controlLayers/konva/CanvasObjectBrushLineRenderer';
-import { CanvasObjectEraserLineRenderer } from 'features/controlLayers/konva/CanvasObjectEraserLineRenderer';
-import { CanvasObjectImageRenderer } from 'features/controlLayers/konva/CanvasObjectImageRenderer';
-import { CanvasObjectRectRenderer } from 'features/controlLayers/konva/CanvasObjectRectRenderer';
+import { CanvasObjectBrushLine } from 'features/controlLayers/konva/CanvasObjectBrushLine';
+import { CanvasObjectEraserLine } from 'features/controlLayers/konva/CanvasObjectEraserLine';
+import { CanvasObjectImage } from 'features/controlLayers/konva/CanvasObjectImage';
+import { CanvasObjectRect } from 'features/controlLayers/konva/CanvasObjectRect';
 import { LightnessToAlphaFilter } from 'features/controlLayers/konva/filters';
 import { getPatternSVG } from 'features/controlLayers/konva/patterns/getPatternSVG';
 import {
@@ -47,10 +47,10 @@ function setFillPatternImage(shape: Konva.Shape, ...args: Parameters<typeof getP
  * Union of all object renderers.
  */
 type AnyObjectRenderer =
-  | CanvasObjectBrushLineRenderer
-  | CanvasObjectEraserLineRenderer
-  | CanvasObjectRectRenderer
-  | CanvasObjectImageRenderer;
+  | CanvasObjectBrushLine
+  | CanvasObjectEraserLine
+  | CanvasObjectRect
+  | CanvasObjectImage;
 /**
  * Union of all object states.
  */
@@ -59,8 +59,8 @@ type AnyObjectState = CanvasBrushLineState | CanvasEraserLineState | CanvasImage
 /**
  * Handles rendering of objects for a canvas entity.
  */
-export class CanvasEntityRenderer extends CanvasModuleBase {
-  readonly type = 'entity_renderer';
+export class CanvasEntityObjectRenderer extends CanvasModuleBase {
+  readonly type = 'object_renderer';
   readonly id: string;
   readonly path: string[];
   readonly parent: CanvasEntityAdapterBase;
@@ -296,40 +296,40 @@ export class CanvasEntityRenderer extends CanvasModuleBase {
     const isFirstRender = !renderer;
 
     if (objectState.type === 'brush_line') {
-      assert(renderer instanceof CanvasObjectBrushLineRenderer || !renderer);
+      assert(renderer instanceof CanvasObjectBrushLine || !renderer);
 
       if (!renderer) {
-        renderer = new CanvasObjectBrushLineRenderer(objectState, this);
+        renderer = new CanvasObjectBrushLine(objectState, this);
         this.renderers.set(renderer.id, renderer);
         this.konva.objectGroup.add(renderer.konva.group);
       }
 
       didRender = renderer.update(objectState, force || isFirstRender);
     } else if (objectState.type === 'eraser_line') {
-      assert(renderer instanceof CanvasObjectEraserLineRenderer || !renderer);
+      assert(renderer instanceof CanvasObjectEraserLine || !renderer);
 
       if (!renderer) {
-        renderer = new CanvasObjectEraserLineRenderer(objectState, this);
+        renderer = new CanvasObjectEraserLine(objectState, this);
         this.renderers.set(renderer.id, renderer);
         this.konva.objectGroup.add(renderer.konva.group);
       }
 
       didRender = renderer.update(objectState, force || isFirstRender);
     } else if (objectState.type === 'rect') {
-      assert(renderer instanceof CanvasObjectRectRenderer || !renderer);
+      assert(renderer instanceof CanvasObjectRect || !renderer);
 
       if (!renderer) {
-        renderer = new CanvasObjectRectRenderer(objectState, this);
+        renderer = new CanvasObjectRect(objectState, this);
         this.renderers.set(renderer.id, renderer);
         this.konva.objectGroup.add(renderer.konva.group);
       }
 
       didRender = renderer.update(objectState, force || isFirstRender);
     } else if (objectState.type === 'image') {
-      assert(renderer instanceof CanvasObjectImageRenderer || !renderer);
+      assert(renderer instanceof CanvasObjectImage || !renderer);
 
       if (!renderer) {
-        renderer = new CanvasObjectImageRenderer(objectState, this);
+        renderer = new CanvasObjectImage(objectState, this);
         this.renderers.set(renderer.id, renderer);
         this.konva.objectGroup.add(renderer.konva.group);
       }
@@ -356,37 +356,37 @@ export class CanvasEntityRenderer extends CanvasModuleBase {
     }
 
     if (this.bufferState.type === 'brush_line') {
-      assert(this.bufferRenderer instanceof CanvasObjectBrushLineRenderer || !this.bufferRenderer);
+      assert(this.bufferRenderer instanceof CanvasObjectBrushLine || !this.bufferRenderer);
 
       if (!this.bufferRenderer) {
-        this.bufferRenderer = new CanvasObjectBrushLineRenderer(this.bufferState, this);
+        this.bufferRenderer = new CanvasObjectBrushLine(this.bufferState, this);
         this.konva.bufferGroup.add(this.bufferRenderer.konva.group);
       }
 
       didRender = this.bufferRenderer.update(this.bufferState, true);
     } else if (this.bufferState.type === 'eraser_line') {
-      assert(this.bufferRenderer instanceof CanvasObjectEraserLineRenderer || !this.bufferRenderer);
+      assert(this.bufferRenderer instanceof CanvasObjectEraserLine || !this.bufferRenderer);
 
       if (!this.bufferRenderer) {
-        this.bufferRenderer = new CanvasObjectEraserLineRenderer(this.bufferState, this);
+        this.bufferRenderer = new CanvasObjectEraserLine(this.bufferState, this);
         this.konva.bufferGroup.add(this.bufferRenderer.konva.group);
       }
 
       didRender = this.bufferRenderer.update(this.bufferState, true);
     } else if (this.bufferState.type === 'rect') {
-      assert(this.bufferRenderer instanceof CanvasObjectRectRenderer || !this.bufferRenderer);
+      assert(this.bufferRenderer instanceof CanvasObjectRect || !this.bufferRenderer);
 
       if (!this.bufferRenderer) {
-        this.bufferRenderer = new CanvasObjectRectRenderer(this.bufferState, this);
+        this.bufferRenderer = new CanvasObjectRect(this.bufferState, this);
         this.konva.bufferGroup.add(this.bufferRenderer.konva.group);
       }
 
       didRender = this.bufferRenderer.update(this.bufferState, true);
     } else if (this.bufferState.type === 'image') {
-      assert(this.bufferRenderer instanceof CanvasObjectImageRenderer || !this.bufferRenderer);
+      assert(this.bufferRenderer instanceof CanvasObjectImage || !this.bufferRenderer);
 
       if (!this.bufferRenderer) {
-        this.bufferRenderer = new CanvasObjectImageRenderer(this.bufferState, this);
+        this.bufferRenderer = new CanvasObjectImage(this.bufferState, this);
         this.konva.bufferGroup.add(this.bufferRenderer.konva.group);
       }
       didRender = await this.bufferRenderer.update(this.bufferState, true);
@@ -492,9 +492,9 @@ export class CanvasEntityRenderer extends CanvasModuleBase {
   needsPixelBbox = (): boolean => {
     let needsPixelBbox = false;
     for (const renderer of this.renderers.values()) {
-      const isEraserLine = renderer instanceof CanvasObjectEraserLineRenderer;
-      const isImage = renderer instanceof CanvasObjectImageRenderer;
-      const hasClip = renderer instanceof CanvasObjectBrushLineRenderer && renderer.state.clip;
+      const isEraserLine = renderer instanceof CanvasObjectEraserLine;
+      const isImage = renderer instanceof CanvasObjectImage;
+      const hasClip = renderer instanceof CanvasObjectBrushLine && renderer.state.clip;
       if (isEraserLine || hasClip || isImage) {
         needsPixelBbox = true;
         break;

invokeai/frontend/web/src/features/controlLayers/konva/CanvasObjectBrushLine.ts

@@ -1,17 +1,17 @@
 import { rgbaColorToString } from 'common/util/colorCodeTransformers';
 import { deepClone } from 'common/util/deepClone';
-import type { CanvasEntityRenderer } from 'features/controlLayers/konva/CanvasEntityRenderer';
+import type { CanvasEntityObjectRenderer } from 'features/controlLayers/konva/CanvasEntityObjectRenderer';
 import type { CanvasManager } from 'features/controlLayers/konva/CanvasManager';
 import { CanvasModuleBase } from 'features/controlLayers/konva/CanvasModuleBase';
 import type { CanvasBrushLineState } from 'features/controlLayers/store/types';
 import Konva from 'konva';
 import type { Logger } from 'roarr';
 
-export class CanvasObjectBrushLineRenderer extends CanvasModuleBase {
-  readonly type = 'object_brush_line_renderer';
+export class CanvasObjectBrushLine extends CanvasModuleBase {
+  readonly type = 'object_brush_line';
   readonly id: string;
   readonly path: string[];
-  readonly parent: CanvasEntityRenderer;
+  readonly parent: CanvasEntityObjectRenderer;
   readonly manager: CanvasManager;
   readonly log: Logger;
 
@@ -21,7 +21,7 @@ export class CanvasObjectBrushLineRenderer extends CanvasModuleBase {
     line: Konva.Line;
   };
 
-  constructor(state: CanvasBrushLineState, parent: CanvasEntityRenderer) {
+  constructor(state: CanvasBrushLineState, parent: CanvasEntityObjectRenderer) {
     super();
     const { id, clip } = state;
     this.id = id;

invokeai/frontend/web/src/features/controlLayers/konva/CanvasObjectEraserLine.ts

@@ -1,16 +1,16 @@
 import { deepClone } from 'common/util/deepClone';
-import type { CanvasEntityRenderer } from 'features/controlLayers/konva/CanvasEntityRenderer';
+import type { CanvasEntityObjectRenderer } from 'features/controlLayers/konva/CanvasEntityObjectRenderer';
 import type { CanvasManager } from 'features/controlLayers/konva/CanvasManager';
 import { CanvasModuleBase } from 'features/controlLayers/konva/CanvasModuleBase';
 import type { CanvasEraserLineState } from 'features/controlLayers/store/types';
 import Konva from 'konva';
 import type { Logger } from 'roarr';
 
-export class CanvasObjectEraserLineRenderer extends CanvasModuleBase {
-  readonly type = 'object_eraser_line_renderer';
+export class CanvasObjectEraserLine extends CanvasModuleBase {
+  readonly type = 'object_eraser_line';
   readonly id: string;
   readonly path: string[];
-  readonly parent: CanvasEntityRenderer;
+  readonly parent: CanvasEntityObjectRenderer;
   readonly manager: CanvasManager;
   readonly log: Logger;
 
@@ -20,7 +20,7 @@ export class CanvasObjectEraserLineRenderer extends CanvasModuleBase {
     line: Konva.Line;
   };
 
-  constructor(state: CanvasEraserLineState, parent: CanvasEntityRenderer) {
+  constructor(state: CanvasEraserLineState, parent: CanvasEntityObjectRenderer) {
     super();
     this.id = state.id;
     this.parent = parent;

invokeai/frontend/web/src/features/controlLayers/konva/CanvasObjectImage.ts

@@ -1,6 +1,6 @@
 import { Mutex } from 'async-mutex';
 import { deepClone } from 'common/util/deepClone';
-import type { CanvasEntityRenderer } from 'features/controlLayers/konva/CanvasEntityRenderer';
+import type { CanvasEntityObjectRenderer } from 'features/controlLayers/konva/CanvasEntityObjectRenderer';
 import type { CanvasFilterModule } from 'features/controlLayers/konva/CanvasFilterModule';
 import type { CanvasManager } from 'features/controlLayers/konva/CanvasManager';
 import { CanvasModuleBase } from 'features/controlLayers/konva/CanvasModuleBase';
@@ -12,11 +12,11 @@ import Konva from 'konva';
 import type { Logger } from 'roarr';
 import { getImageDTO } from 'services/api/endpoints/images';
 
-export class CanvasObjectImageRenderer extends CanvasModuleBase {
-  readonly type = 'object_image_renderer';
+export class CanvasObjectImage extends CanvasModuleBase {
+  readonly type = 'object_image';
   readonly id: string;
   readonly path: string[];
-  readonly parent: CanvasEntityRenderer | CanvasStagingAreaModule | CanvasFilterModule;
+  readonly parent: CanvasEntityObjectRenderer | CanvasStagingAreaModule | CanvasFilterModule;
   readonly manager: CanvasManager;
   readonly log: Logger;
 
@@ -31,7 +31,7 @@ export class CanvasObjectImageRenderer extends CanvasModuleBase {
   isError: boolean = false;
   mutex = new Mutex();
 
-  constructor(state: CanvasImageState, parent: CanvasEntityRenderer | CanvasStagingAreaModule | CanvasFilterModule) {
+  constructor(state: CanvasImageState, parent: CanvasEntityObjectRenderer | CanvasStagingAreaModule | CanvasFilterModule) {
     super();
     this.id = state.id;
     this.parent = parent;

invokeai/frontend/web/src/features/controlLayers/konva/CanvasObjectRect.ts

@@ -1,17 +1,17 @@
 import { rgbaColorToString } from 'common/util/colorCodeTransformers';
 import { deepClone } from 'common/util/deepClone';
-import type { CanvasEntityRenderer } from 'features/controlLayers/konva/CanvasEntityRenderer';
+import type { CanvasEntityObjectRenderer } from 'features/controlLayers/konva/CanvasEntityObjectRenderer';
 import type { CanvasManager } from 'features/controlLayers/konva/CanvasManager';
 import { CanvasModuleBase } from 'features/controlLayers/konva/CanvasModuleBase';
 import type { CanvasRectState } from 'features/controlLayers/store/types';
 import Konva from 'konva';
 import type { Logger } from 'roarr';
 
-export class CanvasObjectRectRenderer extends CanvasModuleBase {
-  readonly type = 'object_rect_renderer';
+export class CanvasObjectRect extends CanvasModuleBase {
+  readonly type = 'object_rect';
   readonly id: string;
   readonly path: string[];
-  readonly parent: CanvasEntityRenderer;
+  readonly parent: CanvasEntityObjectRenderer;
   readonly manager: CanvasManager;
   readonly log: Logger;
 
@@ -22,7 +22,7 @@ export class CanvasObjectRectRenderer extends CanvasModuleBase {
   };
   isFirstRender: boolean = false;
 
-  constructor(state: CanvasRectState, parent: CanvasEntityRenderer) {
+  constructor(state: CanvasRectState, parent: CanvasEntityObjectRenderer) {
     super();
     this.id = state.id;
     this.parent = parent;

invokeai/frontend/web/src/features/controlLayers/konva/CanvasStagingAreaModule.ts

@@ -1,6 +1,6 @@
 import type { CanvasManager } from 'features/controlLayers/konva/CanvasManager';
 import { CanvasModuleBase } from 'features/controlLayers/konva/CanvasModuleBase';
-import { CanvasObjectImageRenderer } from 'features/controlLayers/konva/CanvasObjectImageRenderer';
+import { CanvasObjectImage } from 'features/controlLayers/konva/CanvasObjectImage';
 import { getPrefixedId } from 'features/controlLayers/konva/util';
 import { imageDTOToImageWithDims, type StagingAreaImage } from 'features/controlLayers/store/types';
 import Konva from 'konva';
@@ -17,7 +17,7 @@ export class CanvasStagingAreaModule extends CanvasModuleBase {
 
   subscriptions: Set<() => void> = new Set();
   konva: { group: Konva.Group };
-  image: CanvasObjectImageRenderer | null;
+  image: CanvasObjectImage | null;
   selectedImage: StagingAreaImage | null;
 
   $shouldShowStagedImage = atom<boolean>(true);
@@ -53,7 +53,7 @@ export class CanvasStagingAreaModule extends CanvasModuleBase {
 
       if (!this.image) {
         const { image_name } = imageDTO;
-        this.image = new CanvasObjectImageRenderer(
+        this.image = new CanvasObjectImage(
           {
             id: 'staging-area-image',
             type: 'image',