优化树结构

src/board/core/base/entity-map.ts

@@ -5,6 +5,7 @@ import {
   EntityShape,
   EntityTree,
   EntityType,
+  EntityTypeInstance,
 } from "./entity";
 import { SingleEntityFactory, singleEntityFactory } from "./factory";
 
@@ -12,11 +13,14 @@ export type EntityMapTypes<T> = {
   [key in keyof T]: EntityType;
 };
 
-export type NEntityMapTypes<T extends EntityMapTypes<any>> = {
+export type NEntityMapTypes<
+  T extends EntityMapTypes<any>,
+  P extends Entity = Entity
+> = {
   [key in keyof T]: EntityType<
     EntityMapData<T>[key],
     EntityShape,
-    EntityMapTree<T>
+    EntityMapTree<T, P>
   >;
 };
 
@@ -24,31 +28,36 @@ export type EntityMapData<T extends EntityMapTypes<any>> = {
   [key in keyof T]?: T[key] extends EntityType<infer D> ? D : never;
 };
 
-type EntityMapTree<T extends EntityMapTypes<any>> = EntityTree<
-  EntityMap<T>,
-  InstanceType<T[keyof T]>
->;
+type EntityMapTree<
+  T extends EntityMapTypes<any>,
+  P extends Entity = Entity
+> = EntityTree<EntityMap<T, P>, EntityTypeInstance<T[keyof T]>>;
 
-export type EntityMapEntries<T extends EntityMapTypes<any>> = {
-  [key in keyof T]?: InstanceType<T[key]>;
+export type EntityMapEntries<T extends NEntityMapTypes<any>> = {
+  [key in keyof T]?: EntityTypeInstance<T[key]>;
 };
 
-export class EntityMap<Types extends EntityMapTypes<any>> extends Entity<
+export class EntityMap<
+  Types extends EntityMapTypes<any>,
+  P extends Entity = Entity
+> extends Entity<
   EntityMapData<Types>,
   Group,
-  EntityTree<Entity, EntityMap<Types>>
+  EntityTree<P, EntityMap<Types, P>>
 > {
-  private entries: EntityMapEntries<NEntityMapTypes<Types>> = {};
+  entries: EntityMapEntries<NEntityMapTypes<Types, P>> = {};
   private mapEntityFactory = {} as {
     [key in keyof Types]: SingleEntityFactory<
-      EntityMap<Types>,
+      EntityMap<Types, P>,
       EntityMapData<Types>[key],
-      NEntityMapTypes<Types>[key]
+      NEntityMapTypes<Types, P>[key]
     >;
   };
 
   constructor(
-    props: EntityProps<EntityMapData<Types>> & { types: NEntityMapTypes<Types> }
+    props: EntityProps<EntityMapData<Types>> & {
+      types: NEntityMapTypes<Types, P>;
+    }
   ) {
     super(props);
     for (const key in props.types) {
@@ -62,9 +71,9 @@ export class EntityMap<Types extends EntityMapTypes<any>> extends Entity<
   diffRedraw() {
     const result = {} as {
       [key in keyof Types]?: {
-        add?: InstanceType<NEntityMapTypes<Types>[key]>;
-        del?: InstanceType<NEntityMapTypes<Types>[key]>;
-        upd?: InstanceType<NEntityMapTypes<Types>[key]>;
+        add?: EntityTypeInstance<NEntityMapTypes<Types, P>[key]>;
+        del?: EntityTypeInstance<NEntityMapTypes<Types, P>[key]>;
+        upd?: EntityTypeInstance<NEntityMapTypes<Types, P>[key]>;
       };
     };
     for (const key in this.attrib) {

src/board/core/base/entity-root.ts

@@ -1,5 +1,5 @@
 import { Layer } from "konva/lib/Layer";
-import { Entity, EntityEvent, EntityProps, EntityTree } from "./entity";
+import { Entity, EntityEvent, EntityTree } from "./entity";
 import {
   EntityMap,
   EntityMapData,
@@ -7,6 +7,7 @@ import {
   NEntityMapTypes,
 } from "./entity-map";
 import { Stage } from "konva/lib/Stage";
+import { entityFactoryAfter } from "./factory";
 
 export type RootEvent = EntityEvent & {
   dataChange: void;
@@ -22,7 +23,7 @@ export class Root<
   Layer,
   EntityTree<never, EntityMap<Types>>
 > {
-  private entityMap: EntityMap<Types>;
+  private entityMap: EntityMap<Types, Root<Types>>;
   container?: HTMLDivElement;
   stage: Stage;
   tempLayer: Layer;
@@ -35,7 +36,7 @@ export class Root<
     this.entityMap = new EntityMap({
       types,
       attrib: {},
-    });
+    }) as EntityMap<Types, Root<Types>>;
   }
 
   setContainer(dom: HTMLDivElement) {
@@ -54,11 +55,11 @@ export class Root<
         width: this.container.offsetWidth,
         height: this.container.offsetHeight,
       });
+      this.stage.add(this.shape);
+      this.mounted();
     } else {
       this.stage.setContainer(this.container);
     }
-    this.stage.add(this.shape);
-    this.mounted();
   }
 
   setAttrib(newAttrib: Partial<EntityMapData<Types>>): void {
@@ -72,4 +73,11 @@ export class Root<
   initShape(): Layer {
     return new Layer();
   }
+
+  geta() {}
+
+  init(this: Root<Types>): void {
+    super.init();
+    entityFactoryAfter(this.entityMap, this);
+  }
 }

src/board/core/base/entity.ts

@@ -39,6 +39,14 @@ export type EntityType<
   TR extends EntityTree = EntityTree
 > = typeof Entity<T, S, TR>;
 
+export type EntityTypeInstance<P extends EntityType> = P extends EntityType<
+  infer T1,
+  infer T2,
+  infer T3
+>
+  ? Entity<T1, T2, T3>
+  : never;
+
 export type EntityTree<
   P extends Entity = Entity,
   C extends Entity = Entity,

src/board/core/base/factory.ts

@@ -5,6 +5,7 @@ import {
   EntityTransmit,
   EntityTree,
   EntityType,
+  EntityTypeInstance,
 } from "./entity";
 
 const getEntityTransmitProps = (parent: Entity): EntityTransmit => {
@@ -13,26 +14,13 @@ const getEntityTransmitProps = (parent: Entity): EntityTransmit => {
   };
 };
 
-export const entityFactory = <
+export const entityFactoryAfter = <
   P extends Entity,
-  T,
-  S extends EntityShape,
-  C extends EntityType<T, S, EntityTree<P>>
+  C extends Entity<any, EntityShape, EntityTree<P, C>>
 >(
-  attrib: T,
-  key: string,
-  Type: C,
-  parent?: P,
-  extra?: (self: InstanceType<C>) => void,
-  created?: (self: InstanceType<C>) => void
-): InstanceType<C> => {
-  const entity = new Type({
-    attrib,
-    key,
-  }) as InstanceType<C>;
-
-  extra && extra(entity);
-
+  entity: C,
+  parent?: P
+) => {
   if (parent) {
     const transmit = getEntityTransmitProps(parent);
     for (const key in transmit) {
@@ -46,7 +34,28 @@ export const entityFactory = <
   if (parent?.isMounted) {
     entity.mounted();
   }
+};
 
+export const entityFactory = <
+  P extends Entity,
+  T,
+  S extends EntityShape,
+  C extends EntityType<T, S, EntityTree<P>>
+>(
+  attrib: T,
+  key: string,
+  Type: C,
+  parent?: P,
+  extra?: (self: EntityTypeInstance<C>) => void,
+  created?: (self: EntityTypeInstance<C>) => void
+): EntityTypeInstance<C> => {
+  const entity = new Type({
+    attrib,
+    key,
+  }) as EntityTypeInstance<C>;
+
+  extra && extra(entity);
+  entityFactoryAfter(entity as any, parent);
   created && created(entity);
   return entity;
 };
@@ -57,9 +66,9 @@ export type IncEntitys<
   C extends EntityType<T, S, EntityTree<P>>,
   S extends EntityShape
 > = {
-  adds: InstanceType<C>[];
-  dels: InstanceType<C>[];
-  upds: InstanceType<C>[];
+  adds: EntityTypeInstance<C>[];
+  dels: EntityTypeInstance<C>[];
+  upds: EntityTypeInstance<C>[];
 };
 
 export type IncEntitysFactory<
@@ -78,14 +87,14 @@ export const incEntitysFactoryGenerate = <
 >(
   Type: C,
   parent?: P,
-  extra?: (self: InstanceType<C>) => void,
-  created?: (self: InstanceType<C>) => void
+  extra?: (self: EntityTypeInstance<C>) => void,
+  created?: (self: EntityTypeInstance<C>) => void
 ): IncEntitysFactory<P, T, C, S> => {
   let oldKeys: string[] = [];
   let useIndex = false;
   let inited = false;
 
-  const cache: { [key in string]: InstanceType<C> } = {};
+  const cache: { [key in string]: EntityTypeInstance<C> } = {};
 
   const findAttrib = (attribs: any[], key: string) => {
     if (useIndex) {
@@ -156,9 +165,9 @@ export type SingleEntity<
   C extends EntityType<T, S, EntityTree<P>>,
   S extends EntityShape
 > = {
-  add?: InstanceType<C>;
-  del?: InstanceType<C>;
-  upd?: InstanceType<C>;
+  add?: EntityTypeInstance<C>;
+  del?: EntityTypeInstance<C>;
+  upd?: EntityTypeInstance<C>;
 };
 
 export type SingleEntityFactory<
@@ -176,10 +185,10 @@ export const singleEntityFactory = <
 >(
   Type: C,
   parent?: P,
-  extra?: (self: InstanceType<C>) => void,
-  created?: (self: InstanceType<C>) => void
+  extra?: (self: EntityTypeInstance<C>) => void,
+  created?: (self: EntityTypeInstance<C>) => void
 ): SingleEntityFactory<P, T, C, S> => {
-  let entity: InstanceType<C> | null = null;
+  let entity: EntityTypeInstance<C> | null = null;
 
   return ({ attrib, key }) => {
     const result: SingleEntity<P, T, C, S> = {};