@flowgram-vue/core 0.2.0

package/src/core/pipeline/pipeline-entities-selector.ts

@@ -0,0 +1,200 @@
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+import { inject, injectable } from 'inversify';
+
+import { type Layer } from '../layer';
+import {
+  // AbleManager,
+  // type AbleRegistry,
+  type Entity,
+  type EntityData,
+  type EntityDataRegistry,
+  EntityManager,
+  type EntityRegistry,
+} from '../../common';
+
+type SelectorVersion = Map<string, number>;
+
+export interface LayerEntitiesSelector {
+  // lastAbleVersion?: SelectorVersion;
+  lastEntityVersion?: SelectorVersion;
+  lastDataVersion?: SelectorVersion;
+  entities: EntityRegistry[];
+  // ables: AbleRegistry[];
+  datas: [EntityRegistry, EntityDataRegistry][]; // entity-data
+}
+
+/**
+ * 选择器用来在 pipeline 绘制之前，筛选并注入 entities
+ */
+@injectable()
+export class PipelineEntitiesSelector {
+  protected layerEntitiesSelectorMap: WeakMap<Layer, LayerEntitiesSelector> = new WeakMap();
+
+  readonly entityLayerMap: Map<string, Set<Layer>> = new Map();
+
+  readonly ableLayerMap: Map<string, Set<Layer>> = new Map();
+
+  // @inject(AbleManager) ableManager: AbleManager;
+
+  @inject(EntityManager) entityManager: EntityManager;
+
+  /**
+   * 订阅关联的 entity，会影响 autorun
+   */
+  subscribeEntities(layer: Layer, entities: EntityRegistry[]): void {
+    const selector = this.getSelector(layer);
+    entities.forEach(e => {
+      if (!selector.entities.includes(e)) selector.entities.push(e);
+      let layers = this.entityLayerMap.get(e.type);
+      if (!layers) {
+        layers = new Set();
+        this.entityLayerMap.set(e.type, layers);
+      }
+      layers.add(layer);
+    });
+  }
+
+  // /**
+  //  * 订阅关联的 able, 会影响 autorun
+  //  */
+  // subscribeAbles(layer: Layer, ables: AbleRegistry[]): void {
+  //   const selector = this.getSelector(layer);
+  //   ables.forEach(able => {
+  //     if (!selector.ables.includes(able)) selector.ables.push(able);
+  //     let layers = this.ableLayerMap.get(able.type);
+  //     if (!layers) {
+  //       layers = new Set();
+  //       this.ableLayerMap.set(able.type, layers);
+  //     }
+  //     layers.add(layer);
+  //   });
+  // }
+
+  /**
+   * 订阅 data 数据
+   * @param layer
+   * @param entity
+   * @param data
+   */
+  subscribleEntityByData(layer: Layer, entity: EntityRegistry, data: EntityDataRegistry): void {
+    const selector = this.getSelector(layer);
+    // Entity 和 layer 做关联
+    let layers = this.entityLayerMap.get(entity.type);
+    if (!layers) {
+      layers = new Set();
+      this.entityLayerMap.set(entity.type, layers);
+    }
+    layers.add(layer);
+    const item: [EntityRegistry, EntityDataRegistry] = [entity, data];
+    if (!selector.datas.find(i => i[0] === entity && i[1] === data)) selector.datas.push(item);
+  }
+
+  protected getSelector(layer: Layer): LayerEntitiesSelector {
+    let selector = this.layerEntitiesSelectorMap.get(layer);
+    if (!selector) {
+      selector = { entities: [], datas: [] };
+      this.layerEntitiesSelectorMap.set(layer, selector);
+    }
+    return selector;
+  }
+
+  /**
+   * 查询 layer 关联的实体
+   */
+  getLayerEntities(layer: Layer): { entities: Entity[]; changed: boolean } {
+    const selector = this.layerEntitiesSelectorMap.get(layer);
+    /* v8 ignore next 1 */
+    if (!selector) return { entities: [], changed: false };
+    const allEntities: Set<Entity> = new Set();
+    const entityVersion: SelectorVersion = new Map();
+    let entityChanged = false;
+    selector.entities.forEach(registry => {
+      const entities = this.entityManager.getEntities(registry);
+      const version = this.entityManager.getEntityVersion(registry);
+      entityVersion.set(registry.type, version);
+      for (const item of entities) {
+        allEntities.add(item);
+      }
+    });
+    // selector.ables.forEach(registry => {
+    //   const entities = this.ableManager.getEntitiesByAble(registry);
+    //   for (const item of entities) {
+    //     if (!entityVersion.has(item.type)) {
+    //       const version = this.entityManager.getEntityVersion(item.type);
+    //       entityVersion.set(item.type, version);
+    //     }
+    //     allEntities.add(item);
+    //   }
+    // });
+    // To array
+    const result: Entity[] = [];
+    for (const item of allEntities.values()) {
+      result.push(item);
+    }
+    /**
+     * 检查版本变化
+     */
+    if (checkChanged(entityVersion, selector.lastEntityVersion)) {
+      selector.lastEntityVersion = entityVersion;
+      entityChanged = true;
+    }
+    return {
+      entities: result,
+      changed: entityChanged,
+    };
+  }
+
+  getLayerEntityDatas(layer: Layer): { datas: EntityData[]; changed: boolean } {
+    const selector = this.layerEntitiesSelectorMap.get(layer);
+    /* v8 ignore next 1 */
+    if (!selector) return { datas: [], changed: false };
+    const allDatas: EntityData[] = [];
+    const dataVersion: SelectorVersion = new Map();
+    let dataChanged = false;
+    selector.datas.forEach(registries => {
+      const [entityRegistry, entityDataRegistry] = registries;
+      const entityDatas = this.entityManager.getEntityDatas(entityRegistry, entityDataRegistry);
+      const version = this.entityManager.getEntityDataVersion(entityDataRegistry);
+      dataVersion.set(entityDataRegistry.type, version);
+      /* v8 ignore next 3 */
+      for (const item of entityDatas) {
+        allDatas.push(item);
+      }
+    });
+    if (checkChanged(dataVersion, selector.lastDataVersion)) {
+      selector.lastDataVersion = dataVersion;
+      dataChanged = true;
+    }
+    return {
+      datas: allDatas,
+      changed: dataChanged,
+    };
+  }
+
+  getLayerData(layer: Layer): {
+    observeEntities: Entity[];
+    observeDatas: EntityData[];
+    changed: boolean;
+  } {
+    const entitiesSelector = this.getLayerEntities(layer);
+    const datasSelector = this.getLayerEntityDatas(layer);
+    return {
+      observeEntities: entitiesSelector.entities,
+      observeDatas: datasSelector.datas,
+      changed: datasSelector.changed || entitiesSelector.changed,
+    };
+  }
+}
+
+function checkChanged(v1: SelectorVersion = new Map(), v2: SelectorVersion = new Map()): boolean {
+  if (v1.size !== v2.size) return true;
+  for (const key of v1.keys()) {
+    /* v8 ignore next 1 */
+    if (v1.get(key) !== v2.get(key)) return true;
+  }
+  return false;
+}

package/src/core/pipeline/pipeline-entities.ts

@@ -0,0 +1,230 @@
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+import {
+  // type AbleRegistry,
+  type ConfigEntity,
+  type Entity,
+  type EntityData,
+  type EntityManager,
+  type EntityRegistry,
+} from '../../common';
+
+/**
+ * 注入到 Layer 中的实体选择器
+ */
+export interface PipelineEntities extends Iterable<Entity> {
+  /**
+   * 获取单个实体，如果该实体是单例且被注册过，则会自动创建
+   * @param registry
+   */
+  get<T extends Entity>(registry: EntityRegistry, id?: string): T | undefined;
+  /**
+   * 获取多个实体
+   * @param registry
+   */
+  getEntities<T extends Entity>(registry: EntityRegistry): T[];
+
+  // /**
+  //  * 通过 Able 获取多个实体
+  //  * @param registry
+  //  */
+  // getEntitiesByAble<T extends Entity>(registry: AbleRegistry): T[];
+  // /**
+  //  * 通过多个 Ables 获取多个实体
+  //  * @param andAbles - 多个 able，条件且
+  //  * @param orAbles - 多个 able，条件或
+  //  */
+  // getEntitiesByAbles<T extends Entity>(andAbles: AbleRegistry[], orAbles?: AbleRegistry[]): T[];
+
+  /**
+   * 获取 entity
+   * @param entityRegistry
+   * @param dataRegistry
+   */
+  getEntityDatas<T extends EntityData>(entityRegistry: EntityRegistry, dataRegistry: T): T[];
+  /**
+   * 是否存在
+   * @param registry
+   */
+  has(registry: EntityRegistry): boolean;
+  /**
+   * 获取配置信息
+   * @param registry
+   */
+  getConfig<E extends ConfigEntity>(registry: EntityRegistry): E['config'] | undefined;
+  /**
+   * 更新配置数据
+   */
+  updateConfig<E extends ConfigEntity>(registry: EntityRegistry, props: Partial<E['config']>): void;
+
+  /**
+   * 创建实体
+   */
+  createEntity: <E extends Entity>(
+    registry: EntityRegistry,
+    opts?: Omit<E['__opts_type__'], 'entityManager'>,
+  ) => E;
+  /**
+   * 批量删除实体
+   */
+  removeEntities: (registry: EntityRegistry) => void;
+  /**
+   * 当前画布订阅的实体数目
+   */
+  readonly size: number;
+}
+
+export class PipelineEntitiesImpl implements PipelineEntities {
+  protected observeEntities: Entity[] = [];
+
+  protected observeDatas: EntityData[] = [];
+
+  // @Action 这里要加多个缓存的原因是，每次 decorator 触发都会频繁调用获取方法，"this.xxx" 也会触发 decorator 方法
+  protected entitiesTypeCache: Map<EntityRegistry, Entity[]> = new Map();
+
+  protected entitiesAbleCache: Map<string, Entity[]> = new Map();
+
+  protected entitiyDataCache: Map<string, EntityData[]> = new Map();
+
+  constructor(protected readonly entityManager: EntityManager) {}
+
+  get size(): number {
+    return this.observeEntities.length;
+  }
+
+  /**
+   * 加载订阅数据，会缓存到 layer 内部，layer 只能拿到订阅数据的子集
+   * @param observeEntites
+   * @param observeDatas
+   */
+  load(observeEntites: Entity[], observeDatas: EntityData[]): void {
+    this.observeEntities = observeEntites;
+    this.observeDatas = observeDatas;
+    // clear cache
+    this.entitiesTypeCache.clear();
+    this.entitiesAbleCache.clear();
+    this.entitiyDataCache.clear();
+  }
+
+  get<T extends Entity>(registry: EntityRegistry, id?: string): T | undefined {
+    const entities = this.getEntities(registry) as T[];
+    if (id !== undefined) {
+      return entities.find(e => e.id === id);
+    }
+    return entities[0];
+  }
+
+  has(registy: EntityRegistry): boolean {
+    return !!this.get(registy);
+  }
+
+  getEntities<T extends Entity>(registry: EntityRegistry): T[] {
+    let result = this.entitiesTypeCache.get(registry) as T[];
+    // 缓存查询结果
+    if (!result) {
+      result = [];
+      this.observeEntities.forEach(e => {
+        if (e.type === registry.type) result!.push(e as T);
+      });
+      this.entitiesTypeCache.set(registry, result);
+    }
+    // 可能会出现延迟更新
+    return result.filter(r => !r.disposed);
+  }
+
+  getEntityDatas<T extends EntityData = EntityData>(
+    entityRegistry: EntityRegistry,
+    dataRegistry: T,
+  ): T[] {
+    const dataKey = `${entityRegistry.type}:${dataRegistry.type}`;
+    let result = this.entitiyDataCache.get(dataKey) as T[];
+    if (result) {
+      return result;
+    }
+    result = this.observeDatas.filter(
+      data => data.type === dataRegistry.type && data.entity.type === entityRegistry.type,
+    ) as T[];
+    this.entitiyDataCache.set(dataKey, result);
+    return result;
+  }
+
+  // getEntitiesByAble<T extends Entity = Entity>(able: AbleRegistry): T[] {
+  //   return this.getEntitiesByAbles([able]);
+  // }
+
+  // getEntitiesByAbles<T extends Entity = Entity>(
+  //   andAbles: AbleRegistry[] = [],
+  //   orAbles: AbleRegistry[] = [],
+  // ): T[] {
+  //   const ableKey = `${andAbles.map(a => a.type).join(':')}_${orAbles.map(a => a.type).join(':')}`;
+  //   let result = this.entitiesAbleCache.get(ableKey) as T[];
+  //   // 缓存查询结果
+  //   if (!result) {
+  //     result = [];
+  //     this.observeEntities.forEach(entity => {
+  //       const checkAnd = andAbles.length === 0 || !andAbles.find(able => !entity.ables.has(able));
+  //       const checkOr = orAbles.length === 0 || orAbles.find(able => entity.ables.has(able));
+  //       if (checkAnd && checkOr) {
+  //         result.push(entity as T);
+  //       }
+  //     });
+  //     this.entitiesAbleCache.set(ableKey, result);
+  //   }
+  //   // 可能会出现延迟更新
+  //   return result.filter(r => !r.disposed);
+  // }
+
+  updateConfig<E extends ConfigEntity>(
+    registry: EntityRegistry,
+    props: Partial<E['config']>,
+  ): void {
+    const entity = this.get(registry) as ConfigEntity;
+    /* v8 ignore next 3 */
+    if (entity && entity.updateConfig) {
+      entity.updateConfig(props);
+    }
+  }
+
+  getConfig<E extends ConfigEntity>(registry: EntityRegistry): E['config'] | undefined {
+    const entity = this.get(registry) as ConfigEntity;
+    /* v8 ignore next 3 */
+    if (entity) {
+      return entity.config;
+    }
+  }
+
+  /**
+   * 创建实体
+   */
+  createEntity<E extends Entity>(
+    registry: EntityRegistry,
+    opts?: Omit<E['__opts_type__'], 'entityManager'>,
+  ): E {
+    return this.entityManager.createEntity<E>(registry, opts);
+  }
+
+  /**
+   * 批量删除实体
+   */
+  removeEntities(registry: EntityRegistry): void {
+    this.entityManager.removeEntities(registry);
+  }
+
+  [Symbol.iterator](): Iterator<Entity> {
+    let index = 0;
+    const len = this.observeEntities.length;
+    return {
+      next: () => {
+        const current = index++;
+        const done = current === len;
+        return {
+          value: this.observeEntities[current],
+          done,
+        };
+      },
+    };
+  }
+}