@flowgram.ai/variable-core 0.1.0-alpha.2

package/dist/index.js

@@ -0,0 +1,2072 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ASTFactory: () => ASTFactory,
+  ASTKind: () => ASTKind,
+  ASTNode: () => ASTNode,
+  ASTNodeFlags: () => ASTNodeFlags,
+  ASTRegisters: () => ASTRegisters,
+  ArrayType: () => ArrayType,
+  BaseExpression: () => BaseExpression,
+  BaseType: () => BaseType,
+  BaseVariableField: () => BaseVariableField,
+  BooleanType: () => BooleanType,
+  DataNode: () => DataNode,
+  EnumerateExpression: () => EnumerateExpression,
+  ExpressionList: () => ExpressionList,
+  IntegerType: () => IntegerType,
+  KeyPathExpression: () => KeyPathExpression,
+  KeyPathExpressionV2: () => KeyPathExpressionV2,
+  ListNode: () => ListNode,
+  MapNode: () => MapNode,
+  MapType: () => MapType,
+  NumberType: () => NumberType,
+  ObjectType: () => ObjectType,
+  Property: () => Property,
+  Scope: () => Scope,
+  ScopeChain: () => ScopeChain,
+  ScopeOutputData: () => ScopeOutputData,
+  ScopeProvider: () => ScopeProvider,
+  StringType: () => StringType,
+  VariableContainerModule: () => VariableContainerModule,
+  VariableDeclaration: () => VariableDeclaration,
+  VariableDeclarationList: () => VariableDeclarationList,
+  VariableEngine: () => VariableEngine,
+  VariableEngineProvider: () => VariableEngineProvider,
+  VariableFieldKeyRenameService: () => VariableFieldKeyRenameService,
+  VariableTable: () => VariableTable,
+  injectToAST: () => injectToAST,
+  isMatchAST: () => isMatchAST,
+  postConstructAST: () => postConstructAST,
+  useAvailableVariables: () => useAvailableVariables,
+  useCurrentScope: () => useCurrentScope,
+  useScopeAvailable: () => useScopeAvailable,
+  useScopeContext: () => useScopeContext
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/variable-container-module.ts
+var import_inversify7 = require("inversify");
+
+// src/variable-engine.ts
+var import_rxjs6 = require("rxjs");
+var import_inversify5 = require("inversify");
+var import_utils10 = require("@flowgram.ai/utils");
+var import_utils11 = require("@flowgram.ai/utils");
+
+// src/utils/toDisposable.tsx
+var import_utils = require("@flowgram.ai/utils");
+function subsToDisposable(subscription) {
+  return import_utils.Disposable.create(() => subscription.unsubscribe());
+}
+
+// src/utils/memo.ts
+var createMemo = () => {
+  const _memoCache = /* @__PURE__ */ new Map();
+  const memo = (key, fn) => {
+    if (_memoCache.has(key)) {
+      return _memoCache.get(key);
+    }
+    const data = fn();
+    _memoCache.set(key, data);
+    return data;
+  };
+  const clear = (key) => {
+    if (key) {
+      _memoCache.delete(key);
+    } else {
+      _memoCache.clear();
+    }
+  };
+  memo.clear = clear;
+  return memo;
+};
+
+// src/scope/scope-chain.ts
+var import_inversify = require("inversify");
+var import_utils2 = require("@flowgram.ai/utils");
+
+// src/providers.ts
+var VariableEngineProvider = Symbol("DynamicVariableEngine");
+var ContainerProvider = Symbol("ContainerProvider");
+
+// src/scope/scope-chain.ts
+var ScopeChain = class {
+  constructor() {
+    this.toDispose = new import_utils2.DisposableCollection();
+  }
+  get variableEngine() {
+    return this.variableEngineProvider();
+  }
+  /**
+   * 所有作用域依赖关系刷新
+   */
+  refreshAllChange() {
+    this.variableEngine.getAllScopes().forEach((_scope) => {
+      _scope.refreshCovers();
+      _scope.refreshDeps();
+    });
+  }
+  dispose() {
+    this.toDispose.dispose();
+  }
+  get disposed() {
+    return this.toDispose.disposed;
+  }
+  get onDispose() {
+    return this.toDispose.onDispose;
+  }
+};
+__decorateClass([
+  (0, import_inversify.inject)(VariableEngineProvider)
+], ScopeChain.prototype, "variableEngineProvider", 2);
+ScopeChain = __decorateClass([
+  (0, import_inversify.injectable)()
+], ScopeChain);
+
+// src/scope/scope.ts
+var import_utils9 = require("@flowgram.ai/utils");
+
+// src/ast/types.ts
+var ASTKind = /* @__PURE__ */ ((ASTKind2) => {
+  ASTKind2["String"] = "String";
+  ASTKind2["Number"] = "Number";
+  ASTKind2["Integer"] = "Integer";
+  ASTKind2["Boolean"] = "Boolean";
+  ASTKind2["Object"] = "Object";
+  ASTKind2["Array"] = "Array";
+  ASTKind2["Map"] = "Map";
+  ASTKind2["Union"] = "Union";
+  ASTKind2["Any"] = "Any";
+  ASTKind2["Property"] = "Property";
+  ASTKind2["VariableDeclaration"] = "VariableDeclaration";
+  ASTKind2["VariableDeclarationList"] = "VariableDeclarationList";
+  ASTKind2["KeyPathExpression"] = "KeyPathExpression";
+  ASTKind2["EnumerateExpression"] = "EnumerateExpression";
+  ASTKind2["ExpressionList"] = "ExpressionList";
+  ASTKind2["ListNode"] = "ListNode";
+  ASTKind2["DataNode"] = "DataNode";
+  ASTKind2["MapNode"] = "MapNode";
+  return ASTKind2;
+})(ASTKind || {});
+
+// src/ast/ast-registers.ts
+var import_lodash3 = require("lodash");
+var import_inversify2 = require("inversify");
+
+// src/ast/utils/inversify.ts
+var injectToAST = (serviceIdentifier) => function(target, propertyKey) {
+  if (!serviceIdentifier) {
+    throw new Error(
+      `ServiceIdentifier ${serviceIdentifier} in @lazyInject is Empty, it might be caused by file circular dependency, please check it.`
+    );
+  }
+  const descriptor = {
+    get() {
+      const container = this.scope.variableEngine.container;
+      return container.get(serviceIdentifier);
+    },
+    set() {
+    },
+    configurable: true,
+    enumerable: true
+  };
+  return descriptor;
+};
+var POST_CONSTRUCT_AST_SYMBOL = Symbol("post_construct_ast");
+var postConstructAST = () => (target, propertyKey) => {
+  if (!Reflect.hasMetadata(POST_CONSTRUCT_AST_SYMBOL, target)) {
+    Reflect.defineMetadata(POST_CONSTRUCT_AST_SYMBOL, propertyKey, target);
+  } else {
+    throw Error("Duplication Post Construct AST");
+  }
+};
+
+// src/ast/utils/helpers.ts
+function updateChildNodeHelper({
+  getChildNode,
+  updateChildNode,
+  removeChildNode,
+  nextJSON
+}) {
+  const currNode = getChildNode();
+  const isNewKind = currNode?.kind !== nextJSON?.kind;
+  const isNewKey = nextJSON?.key && nextJSON?.key !== currNode?.key;
+  if (isNewKind || isNewKey) {
+    if (currNode) {
+      currNode.dispose();
+      removeChildNode();
+    }
+    if (nextJSON) {
+      const newNode = this.createChildNode(nextJSON);
+      updateChildNode(newNode);
+      this.fireChange();
+      return newNode;
+    } else {
+      this.fireChange();
+    }
+  } else if (nextJSON) {
+    currNode?.fromJSON(nextJSON);
+  }
+  return currNode;
+}
+function parseTypeJsonOrKind(typeJSONOrKind) {
+  return typeof typeJSONOrKind === "string" ? { kind: typeJSONOrKind } : typeJSONOrKind;
+}
+function getAllChildren(ast) {
+  return [...ast.children, ...ast.children.map((_child) => getAllChildren(_child)).flat()];
+}
+function isMatchAST(node, targetType) {
+  return node?.kind === targetType?.kind;
+}
+
+// src/ast/flags.ts
+var ASTNodeFlags = /* @__PURE__ */ ((ASTNodeFlags2) => {
+  ASTNodeFlags2[ASTNodeFlags2["None"] = 0] = "None";
+  ASTNodeFlags2[ASTNodeFlags2["VariableField"] = 1] = "VariableField";
+  ASTNodeFlags2[ASTNodeFlags2["Expression"] = 4] = "Expression";
+  ASTNodeFlags2[ASTNodeFlags2["BasicType"] = 8] = "BasicType";
+  ASTNodeFlags2[ASTNodeFlags2["DrilldownType"] = 16] = "DrilldownType";
+  ASTNodeFlags2[ASTNodeFlags2["EnumerateType"] = 32] = "EnumerateType";
+  ASTNodeFlags2[ASTNodeFlags2["UnionType"] = 64] = "UnionType";
+  ASTNodeFlags2[ASTNodeFlags2["VariableType"] = 120] = "VariableType";
+  return ASTNodeFlags2;
+})(ASTNodeFlags || {});
+
+// src/ast/ast-node.ts
+var import_rxjs = require("rxjs");
+var import_nanoid = require("nanoid");
+var import_fast_equals = require("fast-equals");
+var import_utils3 = require("@flowgram.ai/utils");
+var ASTNode = class _ASTNode {
+  /**
+   * 构造函数
+   * @param createParams 创建 ASTNode 的必要参数
+   * @param injectOptions 依赖注入各种模块
+   */
+  constructor({ key, parent, scope }, opts) {
+    /**
+     * 节点 Flags，记录一些 Flag 信息
+     */
+    this.flags = 0 /* None */;
+    /**
+     * 节点的版本号，每 fireChange 一次 version + 1
+     */
+    this._version = 0;
+    /**
+     * 更新锁
+     */
+    this.changeLocked = false;
+    /**
+     * Batch Update 相关参数
+     */
+    this._batch = {
+      batching: false,
+      hasChangesInBatch: false
+    };
+    /**
+     * AST 节点变化事件，基于 Rxjs 实现
+     * - 使用了 BehaviorSubject, 在订阅时会自动触发一次事件，事件为当前值
+     */
+    this.value$ = new import_rxjs.BehaviorSubject(this);
+    /**
+     * 子节点
+     */
+    this._children = /* @__PURE__ */ new Set();
+    /**
+     * 删除节点处理事件列表
+     */
+    this.toDispose = new import_utils3.DisposableCollection(
+      import_utils3.Disposable.create(() => {
+        this.parent?.fireChange();
+        this.children.forEach((child) => child.dispose());
+      })
+    );
+    /**
+     * 销毁时触发的回调
+     */
+    this.onDispose = this.toDispose.onDispose;
+    this.scope = scope;
+    this.parent = parent;
+    this.opts = opts;
+    this.key = key || (0, import_nanoid.nanoid)();
+    this.fromJSON = this.withBatchUpdate(this.fromJSON.bind(this));
+    this.dispatchGlobalEvent({ type: "NewAST" });
+  }
+  /**
+   * AST 节点的类型
+   */
+  get kind() {
+    if (!this.constructor.kind) {
+      throw new Error(`ASTNode Registry need a kind: ${this.constructor.name}`);
+    }
+    return this.constructor.kind;
+  }
+  /**
+   * 获取当前节点所有子节点
+   */
+  get children() {
+    return Array.from(this._children);
+  }
+  /**
+   * 转化为 ASTNodeJSON
+   * @returns
+   */
+  toJSON() {
+    console.warn("[VariableEngine] Please Implement toJSON method for " + this.kind);
+    return {
+      kind: this.kind
+    };
+  }
+  /**
+   * 创建子节点
+   * @param json 子节点的 AST JSON
+   * @returns
+   */
+  createChildNode(json) {
+    const astRegisters = this.scope.variableEngine.astRegisters;
+    const child = astRegisters.createAST(json, {
+      parent: this,
+      scope: this.scope
+    });
+    this._children.add(child);
+    child.toDispose.push(
+      import_utils3.Disposable.create(() => {
+        this._children.delete(child);
+      })
+    );
+    return child;
+  }
+  /**
+   * 更新子节点，快速实现子节点更新消费逻辑
+   * @param keyInThis 当前对象上的指定 key
+   */
+  updateChildNodeByKey(keyInThis, nextJSON) {
+    this.withBatchUpdate(updateChildNodeHelper).call(this, {
+      getChildNode: () => this[keyInThis],
+      updateChildNode: (_node) => this[keyInThis] = _node,
+      removeChildNode: () => this[keyInThis] = void 0,
+      nextJSON
+    });
+  }
+  /**
+   * 批处理更新，批处理函数内所有的 fireChange 都合并成一个
+   * @param updater 批处理函数
+   * @returns
+   */
+  withBatchUpdate(updater) {
+    return (...args) => {
+      if (this._batch.batching) {
+        return updater.call(this, ...args);
+      }
+      this._batch.hasChangesInBatch = false;
+      this._batch.batching = true;
+      const res = updater.call(this, ...args);
+      this._batch.batching = false;
+      if (this._batch.hasChangesInBatch) {
+        this.fireChange();
+      }
+      this._batch.hasChangesInBatch = false;
+      return res;
+    };
+  }
+  /**
+   * 触发当前节点更新
+   */
+  fireChange() {
+    if (this.changeLocked || this.disposed) {
+      return;
+    }
+    if (this._batch.batching) {
+      this._batch.hasChangesInBatch = true;
+      return;
+    }
+    this._version++;
+    this.value$.next(this);
+    this.dispatchGlobalEvent({ type: "UpdateAST" });
+    this.parent?.fireChange();
+  }
+  /**
+   * 节点的版本值
+   * - 通过 NodeA === NodeB && versionA === versionB 可以比较两者是否相等
+   */
+  get version() {
+    return this._version;
+  }
+  /**
+   * 节点唯一 hash 值
+   */
+  get hash() {
+    return `${this._version}${this.kind}${this.key}`;
+  }
+  /**
+   * 监听 AST 节点的变化
+   * @param observer 监听回调
+   * @param selector 监听指定数据
+   * @returns
+   */
+  subscribe(observer, { selector, debounceAnimation, triggerOnInit } = {}) {
+    return subsToDisposable(
+      this.value$.pipe(
+        (0, import_rxjs.map)(() => selector ? selector(this) : this),
+        (0, import_rxjs.distinctUntilChanged)(
+          (a, b) => (0, import_fast_equals.shallowEqual)(a, b),
+          (value) => {
+            if (value instanceof _ASTNode) {
+              return value.hash;
+            }
+            return value;
+          }
+        ),
+        // 默认跳过 BehaviorSubject 第一次触发
+        triggerOnInit ? (0, import_rxjs.tap)(() => null) : (0, import_rxjs.skip)(1),
+        // 每个 animationFrame 内所有更新合并成一个
+        debounceAnimation ? (0, import_rxjs.debounceTime)(0, import_rxjs.animationFrameScheduler) : (0, import_rxjs.tap)(() => null)
+      ).subscribe(observer)
+    );
+  }
+  dispatchGlobalEvent(event) {
+    this.scope.event.dispatch({
+      ...event,
+      ast: this
+    });
+  }
+  /**
+   * 销毁
+   */
+  dispose() {
+    if (this.toDispose.disposed) {
+      return;
+    }
+    this.toDispose.dispose();
+    this.dispatchGlobalEvent({ type: "DisposeAST" });
+    this.value$.complete();
+    this.value$.unsubscribe();
+  }
+  get disposed() {
+    return this.toDispose.disposed;
+  }
+};
+
+// src/ast/type/base-type.ts
+var BaseType = class extends ASTNode {
+  constructor() {
+    super(...arguments);
+    this.flags = 8 /* BasicType */;
+  }
+  /**
+   * 类型是否一致，节点有额外信息判断，请参考 extraTypeInfoEqual
+   * @param targetTypeJSON
+   */
+  isTypeEqual(targetTypeJSONOrKind) {
+    const targetTypeJSON = parseTypeJsonOrKind(targetTypeJSONOrKind);
+    if (targetTypeJSON?.kind === "Union" /* Union */) {
+      return (targetTypeJSON?.types || [])?.some(
+        (_subType) => this.isTypeEqual(_subType)
+      );
+    }
+    return this.kind === targetTypeJSON?.kind;
+  }
+  /**
+   * 可下钻类型需实现
+   * @param keyPath
+   */
+  getByKeyPath(keyPath = []) {
+    throw new Error(`Get By Key Path is not implemented for Type: ${this.kind}`);
+  }
+  toJSON() {
+    return {
+      kind: this.kind
+    };
+  }
+};
+
+// src/ast/type/array.ts
+var ArrayType = class extends BaseType {
+  constructor() {
+    super(...arguments);
+    this.flags = 16 /* DrilldownType */ | 32 /* EnumerateType */;
+  }
+  fromJSON({ items }) {
+    this.updateChildNodeByKey("items", parseTypeJsonOrKind(items));
+  }
+  // items 类型是否可下钻
+  get canDrilldownItems() {
+    return !!(this.items?.flags & 16 /* DrilldownType */);
+  }
+  getByKeyPath(keyPath) {
+    const [curr, ...rest] = keyPath || [];
+    if (curr === "0" && this.canDrilldownItems) {
+      return this.items.getByKeyPath(rest);
+    }
+    return void 0;
+  }
+  isTypeEqual(targetTypeJSONOrKind) {
+    const targetTypeJSON = parseTypeJsonOrKind(targetTypeJSONOrKind);
+    const isSuperEqual = super.isTypeEqual(targetTypeJSONOrKind);
+    if (targetTypeJSON?.weak || targetTypeJSON?.kind === "Union" /* Union */) {
+      return isSuperEqual;
+    }
+    return targetTypeJSON && isSuperEqual && // 弱比较，只需要比较 Kind 即可
+    (targetTypeJSON?.weak || this.customStrongEqual(targetTypeJSON));
+  }
+  /**
+   * Array 强比较
+   * @param targetTypeJSON
+   * @returns
+   */
+  customStrongEqual(targetTypeJSON) {
+    if (!this.items) {
+      return !targetTypeJSON?.items;
+    }
+    return this.items?.isTypeEqual(targetTypeJSON.items);
+  }
+  toJSON() {
+    return {
+      kind: "Array" /* Array */,
+      items: this.items?.toJSON()
+    };
+  }
+};
+ArrayType.kind = "Array" /* Array */;
+
+// src/ast/type/string.ts
+var StringType = class extends BaseType {
+  constructor() {
+    super(...arguments);
+    this.flags = 8 /* BasicType */;
+  }
+  fromJSON() {
+  }
+};
+StringType.kind = "String" /* String */;
+
+// src/ast/type/integer.ts
+var IntegerType = class extends BaseType {
+  constructor() {
+    super(...arguments);
+    this.flags = 8 /* BasicType */;
+  }
+  fromJSON() {
+  }
+};
+IntegerType.kind = "Integer" /* Integer */;
+
+// src/ast/type/boolean.ts
+var BooleanType = class extends BaseType {
+  fromJSON() {
+  }
+};
+BooleanType.kind = "Boolean" /* Boolean */;
+
+// src/ast/type/number.ts
+var NumberType = class extends BaseType {
+  fromJSON() {
+  }
+};
+NumberType.kind = "Number" /* Number */;
+
+// src/ast/type/map.ts
+var MapType = class extends BaseType {
+  fromJSON({ keyType = "String" /* String */, valueType }) {
+    this.updateChildNodeByKey("keyType", parseTypeJsonOrKind(keyType));
+    this.updateChildNodeByKey("valueType", parseTypeJsonOrKind(valueType));
+  }
+  // Value 类型是否可下钻，后续实现
+  // get canDrilldownValue(): boolean {
+  //   return !!(this.valueType.flags & ASTNodeFlags.DrilldownType);
+  // }
+  // getByKeyPath(keyPath: string[]): BaseVariableField | undefined {
+  //   const [curr, ...rest] = keyPath || [];
+  //   if (curr === '*' && this.canDrilldownValue) {
+  //     return this.valueType.getByKeyPath(rest);
+  //   }
+  //   return undefined;
+  // }
+  isTypeEqual(targetTypeJSONOrKind) {
+    const targetTypeJSON = parseTypeJsonOrKind(targetTypeJSONOrKind);
+    const isSuperEqual = super.isTypeEqual(targetTypeJSONOrKind);
+    if (targetTypeJSON?.weak || targetTypeJSON?.kind === "Union" /* Union */) {
+      return isSuperEqual;
+    }
+    return targetTypeJSON && isSuperEqual && // 弱比较，只需要比较 Kind 即可
+    (targetTypeJSON?.weak || this.customStrongEqual(targetTypeJSON));
+  }
+  /**
+   * Map 强比较
+   * @param targetTypeJSON
+   * @returns
+   */
+  customStrongEqual(targetTypeJSON) {
+    const { keyType = "String" /* String */, valueType } = targetTypeJSON;
+    const isValueTypeEqual = !valueType && !this.valueType || this.valueType?.isTypeEqual(valueType);
+    return isValueTypeEqual && this.keyType?.isTypeEqual(keyType);
+  }
+  toJSON() {
+    return {
+      kind: "Map" /* Map */,
+      keyType: this.keyType?.toJSON(),
+      valueType: this.valueType?.toJSON()
+    };
+  }
+};
+// public flags: ASTNodeFlags = ASTNodeFlags.DrilldownType | ASTNodeFlags.EnumerateType;
+MapType.kind = "Map" /* Map */;
+
+// src/ast/type/object.ts
+var import_lodash = require("lodash");
+var ObjectType = class extends BaseType {
+  constructor() {
+    super(...arguments);
+    this.flags = 16 /* DrilldownType */;
+    this.propertyTable = /* @__PURE__ */ new Map();
+  }
+  fromJSON({ properties }) {
+    const removedKeys = new Set(this.propertyTable.keys());
+    const prev = [...this.properties || []];
+    this.properties = (properties || []).map((property) => {
+      const existProperty = this.propertyTable.get(property.key);
+      removedKeys.delete(property.key);
+      if (existProperty) {
+        existProperty.fromJSON(property);
+        return existProperty;
+      } else {
+        const newProperty = this.createChildNode({
+          ...property,
+          kind: "Property" /* Property */
+        });
+        this.fireChange();
+        this.propertyTable.set(property.key, newProperty);
+        return newProperty;
+      }
+    });
+    removedKeys.forEach((key) => {
+      const property = this.propertyTable.get(key);
+      property?.dispose();
+      this.propertyTable.delete(key);
+      this.fireChange();
+    });
+    this.dispatchGlobalEvent({
+      type: "ObjectPropertiesChange",
+      payload: {
+        prev,
+        next: [...this.properties]
+      }
+    });
+  }
+  toJSON() {
+    return {
+      kind: "Object" /* Object */,
+      properties: this.properties.map((_property) => _property.toJSON())
+    };
+  }
+  /**
+   * 根据 KeyPath 找到对应的变量
+   * @param keyPath 变量路径
+   * @returns
+   */
+  getByKeyPath(keyPath) {
+    const [curr, ...restKeyPath] = keyPath;
+    const property = this.propertyTable.get(curr);
+    if (!restKeyPath.length) {
+      return property;
+    }
+    if (property?.type && property?.type?.flags & 16 /* DrilldownType */) {
+      return property.type.getByKeyPath(restKeyPath);
+    }
+    return void 0;
+  }
+  isTypeEqual(targetTypeJSONOrKind) {
+    const targetTypeJSON = parseTypeJsonOrKind(targetTypeJSONOrKind);
+    const isSuperEqual = super.isTypeEqual(targetTypeJSONOrKind);
+    if (targetTypeJSON?.weak || targetTypeJSON?.kind === "Union" /* Union */) {
+      return isSuperEqual;
+    }
+    return targetTypeJSON && isSuperEqual && // 弱比较，只需要比较 Kind 即可
+    (targetTypeJSON?.weak || this.customStrongEqual(targetTypeJSON));
+  }
+  /**
+   * Object 类型强比较
+   * @param targetTypeJSON
+   * @returns
+   */
+  customStrongEqual(targetTypeJSON) {
+    const targetProperties = targetTypeJSON.properties || [];
+    const sourcePropertyKeys = Array.from(this.propertyTable.keys());
+    const targetPropertyKeys = targetProperties.map((_target) => _target.key);
+    const isKeyStrongEqual = !(0, import_lodash.xor)(sourcePropertyKeys, targetPropertyKeys).length;
+    return isKeyStrongEqual && targetProperties.every((targetProperty) => {
+      const sourceProperty = this.propertyTable.get(targetProperty.key);
+      return sourceProperty && sourceProperty.key === targetProperty.key && sourceProperty.type?.isTypeEqual(targetProperty?.type);
+    });
+  }
+};
+ObjectType.kind = "Object" /* Object */;
+
+// src/ast/expression/base-expression.ts
+var import_rxjs2 = require("rxjs");
+var import_fast_equals2 = require("fast-equals");
+
+// src/ast/utils/variable-field.ts
+function getParentFields(ast) {
+  let curr = ast.parent;
+  const res = [];
+  while (curr) {
+    if (curr.flags & 1 /* VariableField */) {
+      res.push(curr);
+    }
+    curr = curr.parent;
+  }
+  return res;
+}
+
+// src/ast/expression/base-expression.ts
+var BaseExpression = class extends ASTNode {
+  constructor(params, opts) {
+    super(params, opts);
+    this.flags = 4 /* Expression */;
+    /**
+     * 引用变量
+     */
+    this._refs = [];
+    this.refreshRefs$ = new import_rxjs2.Subject();
+    /**
+     * 监听引用变量变化
+     * 监听 [a.b.c] -> [a.b]
+     */
+    this.refs$ = this.refreshRefs$.pipe(
+      (0, import_rxjs2.map)(() => this.getRefFields()),
+      (0, import_rxjs2.distinctUntilChanged)(import_fast_equals2.shallowEqual),
+      (0, import_rxjs2.switchMap)(
+        (refs) => !refs?.length ? (0, import_rxjs2.of)([]) : (0, import_rxjs2.combineLatest)(
+          refs.map(
+            (ref) => ref ? ref.value$ : (0, import_rxjs2.of)(void 0)
+          )
+        )
+      ),
+      (0, import_rxjs2.share)()
+    );
+    this.toDispose.push(
+      subsToDisposable(
+        this.refs$.subscribe((_refs) => {
+          this._refs = _refs;
+          this.fireChange();
+        })
+      )
+    );
+  }
+  /**
+   * 获取全局变量表，方便表达式获取引用变量
+   */
+  get globalVariableTable() {
+    return this.scope.variableEngine.globalVariableTable;
+  }
+  /**
+   * 父变量字段，通过由近而远的方式进行排序
+   */
+  get parentFields() {
+    return getParentFields(this);
+  }
+  get refs() {
+    return this._refs;
+  }
+  /**
+   * 刷新变量引用
+   */
+  refreshRefs() {
+    this.refreshRefs$.next();
+  }
+};
+
+// src/ast/expression/expression-list.ts
+var ExpressionList = class extends ASTNode {
+  fromJSON({ expressions }) {
+    this.expressions = expressions.map((_expression, idx) => {
+      const prevExpression = this.expressions[idx];
+      if (prevExpression.kind !== _expression.kind) {
+        prevExpression.dispose();
+        this.fireChange();
+        return this.createChildNode(_expression);
+      }
+      prevExpression.fromJSON(_expression);
+      return prevExpression;
+    });
+  }
+  toJSON() {
+    return {
+      kind: "ExpressionList" /* ExpressionList */,
+      properties: this.expressions.map((_expression) => _expression.toJSON())
+    };
+  }
+};
+ExpressionList.kind = "ExpressionList" /* ExpressionList */;
+
+// src/ast/expression/keypath-expression.ts
+var import_fast_equals3 = require("fast-equals");
+var KeyPathExpression = class extends BaseExpression {
+  constructor(params, opts) {
+    super(params, opts);
+    this._keyPath = [];
+    this.toDispose.pushAll([
+      // 可以用变量列表变化时候 (有新增或者删除时)
+      this.scope.available.onVariableListChange(() => {
+        this.refreshRefs();
+      }),
+      // this._keyPath 指向的可引用变量发生变化时，刷新引用数据
+      this.scope.available.onAnyVariableChange((_v) => {
+        if (_v.key === this._keyPath[0]) {
+          this.refreshRefs();
+        }
+      })
+    ]);
+  }
+  get keyPath() {
+    return this._keyPath;
+  }
+  getRefFields() {
+    const ref = this.scope.available.getByKeyPath(this._keyPath);
+    return ref ? [ref] : [];
+  }
+  get returnType() {
+    const [refNode] = this._refs || [];
+    if (refNode && refNode.flags & 1 /* VariableField */) {
+      return refNode.type;
+    }
+    return;
+  }
+  /**
+   * 业务重改该方法可快速定制自己的 Path 表达式
+   * - 只需要将业务的 Path 解析为变量系统的 KeyPath 即可
+   * @param json 业务定义的 Path 表达式
+   * @returns
+   */
+  parseToKeyPath(json) {
+    return json.keyPath;
+  }
+  fromJSON(json) {
+    const keyPath = this.parseToKeyPath(json);
+    if (!(0, import_fast_equals3.shallowEqual)(keyPath, this._keyPath)) {
+      this._keyPath = keyPath;
+      this.refreshRefs();
+    }
+  }
+  toJSON() {
+    return {
+      kind: "KeyPathExpression" /* KeyPathExpression */,
+      keyPath: this._keyPath
+    };
+  }
+};
+KeyPathExpression.kind = "KeyPathExpression" /* KeyPathExpression */;
+
+// src/ast/expression/enumerate-expression.ts
+var EnumerateExpression = class extends BaseExpression {
+  get enumerateFor() {
+    return this._enumerateFor;
+  }
+  get returnType() {
+    const childReturnType = this.enumerateFor?.returnType;
+    if (childReturnType?.kind === "Array" /* Array */) {
+      return childReturnType.items;
+    }
+    return void 0;
+  }
+  getRefFields() {
+    return [];
+  }
+  fromJSON({ enumerateFor: expression }) {
+    this.updateChildNodeByKey("_enumerateFor", expression);
+  }
+  toJSON() {
+    return {
+      kind: "EnumerateExpression" /* EnumerateExpression */,
+      enumerateFor: this.enumerateFor?.toJSON()
+    };
+  }
+};
+EnumerateExpression.kind = "EnumerateExpression" /* EnumerateExpression */;
+
+// src/ast/expression/keypath-expression-v2.ts
+var import_fast_equals4 = require("fast-equals");
+
+// src/ast/utils/expression.ts
+var import_lodash2 = require("lodash");
+function getAllRefs(ast) {
+  return getAllChildren(ast).filter((_child) => _child.flags & 4 /* Expression */).map((_child) => _child.refs).flat().filter(Boolean);
+}
+function checkRefCycle(curr, refNodes) {
+  if ((0, import_lodash2.intersection)(curr.scope.coverScopes, refNodes.map((_ref) => _ref?.scope).filter(Boolean)).length === 0) {
+    return false;
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [...refNodes];
+  while (queue.length) {
+    const currNode = queue.shift();
+    visited.add(currNode);
+    for (const ref of getAllRefs(currNode).filter((_ref) => !visited.has(_ref))) {
+      queue.push(ref);
+    }
+  }
+  return (0, import_lodash2.intersection)(Array.from(visited), getParentFields(curr)).length > 0;
+}
+
+// src/ast/expression/keypath-expression-v2.ts
+var KeyPathExpressionV2 = class extends BaseExpression {
+  constructor(params, opts) {
+    super(params, opts);
+    this._keyPath = [];
+    this.toDispose.pushAll([
+      // 可以用变量列表变化时候 (有新增或者删除时)
+      this.scope.available.onVariableListChange(() => {
+        this.refreshRefs();
+      }),
+      // this._keyPath 指向的可引用变量发生变化时，刷新引用数据
+      this.scope.available.onAnyVariableChange((_v) => {
+        if (_v.key === this._keyPath[0]) {
+          this.refreshRefs();
+        }
+      }),
+      subsToDisposable(
+        this.refs$.subscribe((_type) => {
+          const [ref] = this._refs;
+          if (this.prevRefTypeHash !== ref?.type?.hash) {
+            this.prevRefTypeHash = ref?.type?.hash;
+            this.updateChildNodeByKey("_returnType", this.getReturnTypeJSONByRef(ref));
+          }
+        })
+      )
+    ]);
+  }
+  get keyPath() {
+    return this._keyPath;
+  }
+  getRefFields() {
+    const ref = this.scope.available.getByKeyPath(this._keyPath);
+    if (checkRefCycle(this, [ref])) {
+      console.warn(
+        "[CustomKeyPathExpression] checkRefCycle: Reference Cycle Existed",
+        this.parentFields.map((_field) => _field.key).reverse()
+      );
+      return [];
+    }
+    return ref ? [ref] : [];
+  }
+  get returnType() {
+    return this._returnType;
+  }
+  /**
+   * 业务重改该方法可快速定制自己的 Path 表达式
+   * - 只需要将业务的 Path 解析为变量系统的 KeyPath 即可
+   * @param json 业务定义的 Path 表达式
+   * @returns
+   */
+  parseToKeyPath(json) {
+    return json.keyPath;
+  }
+  fromJSON(json) {
+    const keyPath = this.parseToKeyPath(json);
+    if (!(0, import_fast_equals4.shallowEqual)(keyPath, this._keyPath)) {
+      this._keyPath = keyPath;
+      this.refreshRefs();
+    }
+  }
+  getReturnTypeJSONByRef(_ref) {
+    return _ref?.type?.toJSON();
+  }
+  toJSON() {
+    return {
+      kind: "KeyPathExpression" /* KeyPathExpression */,
+      keyPath: this._keyPath
+    };
+  }
+};
+KeyPathExpressionV2.kind = "KeyPathExpression" /* KeyPathExpression */;
+
+// src/ast/declaration/variable-declaration.ts
+var import_utils4 = require("@flowgram.ai/utils");
+
+// src/ast/declaration/base-variable-field.ts
+var import_fast_equals5 = require("fast-equals");
+var BaseVariableField = class extends ASTNode {
+  constructor() {
+    super(...arguments);
+    this.flags = 1 /* VariableField */;
+    this._meta = {};
+  }
+  /**
+   * 父变量字段，通过由近而远的方式进行排序
+   */
+  get parentFields() {
+    return getParentFields(this);
+  }
+  get meta() {
+    return this._meta;
+  }
+  get type() {
+    return this._initializer?.returnType || this._type;
+  }
+  get initializer() {
+    return this._initializer;
+  }
+  /**
+   * 解析 VariableDeclarationJSON 从而生成变量声明节点
+   */
+  fromJSON({ type, initializer, meta }) {
+    this.updateType(type);
+    this.updateInitializer(initializer);
+    this.updateMeta(meta);
+  }
+  updateType(type) {
+    const nextTypeJson = typeof type === "string" ? { kind: type } : type;
+    this.updateChildNodeByKey("_type", nextTypeJson);
+  }
+  updateInitializer(nextInitializer) {
+    this.updateChildNodeByKey("_initializer", nextInitializer);
+  }
+  updateMeta(nextMeta) {
+    if (!(0, import_fast_equals5.shallowEqual)(nextMeta, this._meta)) {
+      this._meta = nextMeta;
+      this.fireChange();
+    }
+  }
+  /**
+   * 根据 keyPath 去找下钻的变量字段
+   * @param keyPath
+   * @returns
+   */
+  getByKeyPath(keyPath) {
+    if (this.type?.flags & 16 /* DrilldownType */) {
+      return this.type.getByKeyPath(keyPath);
+    }
+    return void 0;
+  }
+  /**
+   * 监听类型变化
+   * @param observer
+   * @returns
+   */
+  onTypeChange(observer) {
+    return this.subscribe(observer, { selector: (curr) => curr.type });
+  }
+  /**
+   * 转换为 JSON
+   * @returns
+   */
+  toJSON() {
+    return {
+      kind: this.kind,
+      key: this.key,
+      type: this.type?.toJSON(),
+      initializer: this.initializer?.toJSON(),
+      meta: this._meta
+    };
+  }
+};
+
+// src/ast/declaration/variable-declaration.ts
+var VariableDeclaration = class extends BaseVariableField {
+  constructor(params) {
+    super(params);
+    this._order = 0;
+    this.scope.output.addVariableToTable(this);
+    this.toDispose.push(
+      import_utils4.Disposable.create(() => {
+        this.scope.output.setHasChanges();
+        this.scope.output.removeVariableFromTable(this.key);
+      })
+    );
+  }
+  get order() {
+    return this._order;
+  }
+  /**
+   * 解析 VariableDeclarationJSON 从而生成变量声明节点
+   */
+  fromJSON({ order, ...rest }) {
+    this.updateOrder(order);
+    super.fromJSON(rest);
+  }
+  updateOrder(order = 0) {
+    if (order !== this._order) {
+      this._order = order;
+      this.scope.output.setHasChanges();
+      this.fireChange();
+    }
+  }
+  // 监听类型变化
+  onTypeChange(observer) {
+    return this.subscribe(observer, { selector: (curr) => curr.type });
+  }
+};
+VariableDeclaration.kind = "VariableDeclaration" /* VariableDeclaration */;
+
+// src/ast/declaration/variable-declaration-list.ts
+var VariableDeclarationList = class extends ASTNode {
+  constructor() {
+    super(...arguments);
+    this.declarationTable = /* @__PURE__ */ new Map();
+  }
+  fromJSON({ declarations, startOrder }) {
+    const removedKeys = new Set(this.declarationTable.keys());
+    const prev = [...this.declarations || []];
+    this.declarations = (declarations || []).map(
+      (declaration, idx) => {
+        const order = (startOrder || 0) + idx;
+        const declarationKey = declaration.key || this.declarations?.[idx]?.key;
+        const existDeclaration = this.declarationTable.get(declarationKey);
+        if (declarationKey) {
+          removedKeys.delete(declarationKey);
+        }
+        if (existDeclaration) {
+          existDeclaration.fromJSON({ order, ...declaration });
+          return existDeclaration;
+        } else {
+          const newDeclaration = this.createChildNode({
+            order,
+            ...declaration,
+            kind: "VariableDeclaration" /* VariableDeclaration */
+          });
+          this.fireChange();
+          this.declarationTable.set(newDeclaration.key, newDeclaration);
+          return newDeclaration;
+        }
+      }
+    );
+    removedKeys.forEach((key) => {
+      const declaration = this.declarationTable.get(key);
+      declaration?.dispose();
+      this.declarationTable.delete(key);
+    });
+    this.dispatchGlobalEvent({
+      type: "VariableListChange",
+      payload: {
+        prev,
+        next: [...this.declarations]
+      }
+    });
+  }
+  toJSON() {
+    return {
+      kind: "VariableDeclarationList" /* VariableDeclarationList */,
+      properties: this.declarations.map((_declaration) => _declaration.toJSON())
+    };
+  }
+};
+VariableDeclarationList.kind = "VariableDeclarationList" /* VariableDeclarationList */;
+
+// src/ast/declaration/property.ts
+var Property = class extends BaseVariableField {
+};
+Property.kind = "Property" /* Property */;
+
+// src/ast/common/data-node.ts
+var import_fast_equals6 = require("fast-equals");
+var DataNode = class extends ASTNode {
+  get data() {
+    return this._data;
+  }
+  fromJSON(json) {
+    const { kind, ...restData } = json;
+    if (!(0, import_fast_equals6.shallowEqual)(restData, this._data)) {
+      this._data = restData;
+      this.fireChange();
+    }
+  }
+  toJSON() {
+    return {
+      kind: "DataNode" /* DataNode */,
+      ...this._data
+    };
+  }
+  partialUpdate(nextData) {
+    if (!(0, import_fast_equals6.shallowEqual)(nextData, this._data)) {
+      this._data = {
+        ...this._data,
+        ...nextData
+      };
+      this.fireChange();
+    }
+  }
+};
+DataNode.kind = "DataNode" /* DataNode */;
+
+// src/ast/common/list-node.ts
+var ListNode = class extends ASTNode {
+  get list() {
+    return this._list;
+  }
+  fromJSON({ list }) {
+    this._list.slice(list.length).forEach((_item) => {
+      _item.dispose();
+      this.fireChange();
+    });
+    this._list = list.map((_item, idx) => {
+      const prevItem = this._list[idx];
+      if (prevItem.kind !== _item.kind) {
+        prevItem.dispose();
+        this.fireChange();
+        return this.createChildNode(_item);
+      }
+      prevItem.fromJSON(_item);
+      return prevItem;
+    });
+  }
+  toJSON() {
+    return {
+      kind: "ListNode" /* ListNode */,
+      list: this._list.map((item) => item.toJSON())
+    };
+  }
+};
+ListNode.kind = "ListNode" /* ListNode */;
+
+// src/ast/common/map-node.ts
+var MapNode = class extends ASTNode {
+  constructor() {
+    super(...arguments);
+    this.map = /* @__PURE__ */ new Map();
+  }
+  fromJSON({ map: map4 }) {
+    const removedKeys = new Set(this.map.keys());
+    for (const [key, item] of map4 || []) {
+      removedKeys.delete(key);
+      this.set(key, item);
+    }
+    for (const removeKey of Array.from(removedKeys)) {
+      this.remove(removeKey);
+    }
+  }
+  toJSON() {
+    return {
+      kind: "MapNode" /* MapNode */,
+      map: Array.from(this.map.entries())
+    };
+  }
+  /**
+   * 往 Map 中设置 ASTNode
+   * @param key ASTNode 的索引，
+   * @param json
+   */
+  set(key, nextJSON) {
+    return this.withBatchUpdate(updateChildNodeHelper).call(this, {
+      getChildNode: () => this.get(key),
+      removeChildNode: () => this.map.delete(key),
+      updateChildNode: (nextNode) => this.map.set(key, nextNode),
+      nextJSON
+    });
+  }
+  /**
+   * 移除指定 ASTNode
+   * @param key
+   */
+  remove(key) {
+    this.get(key)?.dispose();
+    this.map.delete(key);
+    this.fireChange();
+  }
+  /**
+   * 获取 ASTNode
+   * @param key
+   * @returns
+   */
+  get(key) {
+    return this.map.get(key);
+  }
+};
+MapNode.kind = "MapNode" /* MapNode */;
+
+// src/ast/ast-registers.ts
+var ASTRegisters = class {
+  /**
+   * 核心 AST 节点注册
+   */
+  constructor() {
+    this.injectors = /* @__PURE__ */ new Map();
+    this.astMap = /* @__PURE__ */ new Map();
+    this.registerAST(StringType);
+    this.registerAST(NumberType);
+    this.registerAST(BooleanType);
+    this.registerAST(IntegerType);
+    this.registerAST(ObjectType);
+    this.registerAST(ArrayType);
+    this.registerAST(MapType);
+    this.registerAST(Property);
+    this.registerAST(VariableDeclaration);
+    this.registerAST(VariableDeclarationList);
+    this.registerAST(KeyPathExpression);
+    this.registerAST(EnumerateExpression);
+    this.registerAST(ExpressionList);
+    this.registerAST(MapNode);
+    this.registerAST(DataNode);
+  }
+  /**
+   * 创建 AST 节点
+   * @param param 创建参数
+   * @returns
+   */
+  createAST(json, { parent, scope }) {
+    const Registry = this.astMap.get(json.kind);
+    if (!Registry) {
+      throw Error(`ASTKind: ${String(json.kind)} can not find its ASTNode Registry`);
+    }
+    const injector = this.injectors.get(json.kind);
+    const node = new Registry(
+      {
+        key: json.key,
+        scope,
+        parent
+      },
+      injector?.() || {}
+    );
+    node.changeLocked = true;
+    node.fromJSON((0, import_lodash3.omit)(json, ["key", "kind"]));
+    node.changeLocked = false;
+    if (Reflect.hasMetadata(POST_CONSTRUCT_AST_SYMBOL, node)) {
+      const postConstructKey = Reflect.getMetadata(POST_CONSTRUCT_AST_SYMBOL, node);
+      node[postConstructKey]?.();
+    }
+    return node;
+  }
+  /**
+   * 根据 AST 节点类型获取节点 Registry
+   * @param kind
+   * @returns
+   */
+  getASTRegistryByKind(kind) {
+    return this.astMap.get(kind);
+  }
+  /**
+   * 注册 AST 节点
+   * @param ASTNode
+   * @param injector
+   */
+  registerAST(ASTNode2, injector) {
+    this.astMap.set(ASTNode2.kind, ASTNode2);
+    if (injector) {
+      this.injectors.set(ASTNode2.kind, injector);
+    }
+  }
+};
+ASTRegisters = __decorateClass([
+  (0, import_inversify2.injectable)()
+], ASTRegisters);
+
+// src/ast/factory.ts
+var ASTFactory;
+((ASTFactory2) => {
+  ASTFactory2.createString = () => ({ kind: "String" /* String */ });
+  ASTFactory2.createNumber = () => ({ kind: "Number" /* Number */ });
+  ASTFactory2.createBoolean = () => ({ kind: "Boolean" /* Boolean */ });
+  ASTFactory2.createInteger = () => ({ kind: "Integer" /* Integer */ });
+  ASTFactory2.createObject = (json) => ({
+    kind: "Object" /* Object */,
+    ...json
+  });
+  ASTFactory2.createArray = (json) => ({
+    kind: "Array" /* Array */,
+    ...json
+  });
+  ASTFactory2.createMap = (json) => ({
+    kind: "Map" /* Map */,
+    ...json
+  });
+  ASTFactory2.createUnion = (json) => ({
+    kind: "Union" /* Union */,
+    ...json
+  });
+  ASTFactory2.createVariableDeclaration = (json) => ({
+    kind: "VariableDeclaration" /* VariableDeclaration */,
+    ...json
+  });
+  ASTFactory2.createProperty = (json) => ({
+    kind: "Property" /* Property */,
+    ...json
+  });
+  ASTFactory2.createVariableDeclarationList = (json) => ({
+    kind: "VariableDeclarationList" /* VariableDeclarationList */,
+    ...json
+  });
+  ASTFactory2.createEnumerateExpression = (json) => ({
+    kind: "EnumerateExpression" /* EnumerateExpression */,
+    ...json
+  });
+  ASTFactory2.createKeyPathExpression = (json) => ({
+    kind: "KeyPathExpression" /* KeyPathExpression */,
+    ...json
+  });
+})(ASTFactory || (ASTFactory = {}));
+
+// src/scope/variable-table.ts
+var import_rxjs3 = require("rxjs");
+var import_utils5 = require("@flowgram.ai/utils");
+var import_utils6 = require("@flowgram.ai/utils");
+var VariableTable = class {
+  constructor(parentTable) {
+    this.parentTable = parentTable;
+    this.table = /* @__PURE__ */ new Map();
+    this.onDataChangeEmitter = new import_utils5.Emitter();
+    this.variables$ = new import_rxjs3.Subject();
+    // 监听变量列表中的单个变量变化
+    this.anyVariableChange$ = this.variables$.pipe(
+      (0, import_rxjs3.switchMap)(
+        (_variables) => (0, import_rxjs3.merge)(
+          ..._variables.map(
+            (_v) => _v.value$.pipe(
+              // 跳过 BehaviorSubject 第一个
+              (0, import_rxjs3.skip)(1)
+            )
+          )
+        )
+      ),
+      (0, import_rxjs3.share)()
+    );
+    this.onDataChange = this.onDataChangeEmitter.event;
+    this._version = 0;
+  }
+  /**
+   * 监听任意变量变化
+   * @param observer 监听器，变量变化时会吐出值
+   * @returns
+   */
+  onAnyVariableChange(observer) {
+    return subsToDisposable(this.anyVariableChange$.subscribe(observer));
+  }
+  /**
+   * 列表或者任意变量变化
+   * @param observer
+   */
+  onAnyChange(observer) {
+    const disposables = new import_utils6.DisposableCollection();
+    disposables.pushAll([this.onDataChange(observer), this.onAnyVariableChange(observer)]);
+    return disposables;
+  }
+  fireChange() {
+    this._version++;
+    this.onDataChangeEmitter.fire();
+    this.parentTable?.fireChange();
+  }
+  get version() {
+    return this._version;
+  }
+  get variables() {
+    return Array.from(this.table.values());
+  }
+  get variableKeys() {
+    return Array.from(this.table.keys());
+  }
+  /**
+   * 根据 keyPath 找到对应的变量，或 Property 节点
+   * @param keyPath
+   * @returns
+   */
+  getByKeyPath(keyPath) {
+    const [variableKey, ...propertyKeys] = keyPath || [];
+    if (!variableKey) {
+      return;
+    }
+    const variable = this.getVariableByKey(variableKey);
+    return propertyKeys.length ? variable?.getByKeyPath(propertyKeys) : variable;
+  }
+  /**
+   * 根据 key 值找到相应的变量
+   * @param key
+   * @returns
+   */
+  getVariableByKey(key) {
+    return this.table.get(key);
+  }
+  /**
+   * 往 variableTable 添加输出变量
+   * @param variable
+   */
+  addVariableToTable(variable) {
+    this.table.set(variable.key, variable);
+    if (this.parentTable) {
+      this.parentTable.addVariableToTable(variable);
+    }
+    this.variables$.next(this.variables);
+  }
+  /**
+   * 从 variableTable 中移除变量
+   * @param key
+   */
+  removeVariableFromTable(key) {
+    this.table.delete(key);
+    if (this.parentTable) {
+      this.parentTable.removeVariableFromTable(key);
+    }
+    this.variables$.next(this.variables);
+  }
+  dispose() {
+    this.variableKeys.forEach((_key) => this.parentTable?.removeVariableFromTable(_key));
+    this.onDataChangeEmitter.dispose();
+  }
+};
+
+// src/scope/datas/scope-output-data.ts
+var ScopeOutputData = class {
+  constructor(scope) {
+    this.scope = scope;
+    this.memo = createMemo();
+    this._hasChanges = false;
+    this.variableTable = new VariableTable(scope.variableEngine.globalVariableTable);
+    this.scope.toDispose.pushAll([
+      // AST 根节点更新时，检查在这次 AST 变化期间节点是否有变化
+      this.scope.ast.subscribe(() => {
+        if (this._hasChanges) {
+          this.memo.clear();
+          this.notifyCoversChange();
+          this.variableTable.fireChange();
+          this._hasChanges = false;
+        }
+      }),
+      this.variableTable
+    ]);
+  }
+  get variableEngine() {
+    return this.scope.variableEngine;
+  }
+  get globalVariableTable() {
+    return this.scope.variableEngine.globalVariableTable;
+  }
+  get onDataChange() {
+    return this.variableTable.onDataChange.bind(this.variableTable);
+  }
+  get onAnyVariableChange() {
+    return this.variableTable.onAnyVariableChange.bind(this.variableTable);
+  }
+  /**
+   * 作用域输出变量
+   */
+  get variables() {
+    return this.memo(
+      "variables",
+      () => this.variableTable.variables.sort((a, b) => a.order - b.order)
+    );
+  }
+  /**
+   * 输出的变量 keys
+   */
+  get variableKeys() {
+    return this.memo("variableKeys", () => this.variableTable.variableKeys);
+  }
+  addVariableToTable(variable) {
+    if (variable.scope !== this.scope) {
+      throw Error("VariableDeclaration must be a ast node in scope");
+    }
+    this.variableTable.addVariableToTable(variable);
+    this._hasChanges = true;
+  }
+  // 标记为发生了变化，用于变量排序变化的场景
+  setHasChanges() {
+    this._hasChanges = true;
+  }
+  removeVariableFromTable(key) {
+    this.variableTable.removeVariableFromTable(key);
+    this._hasChanges = true;
+  }
+  getVariableByKey(key) {
+    return this.variableTable.getVariableByKey(key);
+  }
+  // 通知覆盖作用域更新可用变量
+  notifyCoversChange() {
+    this.scope.coverScopes.forEach((scope) => scope.available.refresh());
+  }
+};
+
+// src/scope/datas/scope-available-data.ts
+var import_rxjs4 = require("rxjs");
+var import_lodash4 = require("lodash");
+var import_fast_equals7 = require("fast-equals");
+var import_utils7 = require("@flowgram.ai/utils");
+var import_utils8 = require("@flowgram.ai/utils");
+var ScopeAvailableData = class {
+  constructor(scope) {
+    this.scope = scope;
+    this.memo = createMemo();
+    this.refresh$ = new import_rxjs4.Subject();
+    this._variables = [];
+    /**
+     * 监听
+     */
+    this.variables$ = this.refresh$.pipe(
+      // 输出变量是否 version 发生变化
+      (0, import_rxjs4.map)(() => (0, import_lodash4.flatten)(this.depScopes.map((scope) => scope.output.variables || []))),
+      // 变量列表浅比较
+      (0, import_rxjs4.distinctUntilChanged)(import_fast_equals7.shallowEqual),
+      (0, import_rxjs4.share)()
+    );
+    // 监听变量列表中的单个变量变化
+    this.anyVariableChange$ = this.variables$.pipe(
+      (0, import_rxjs4.switchMap)(
+        (_variables) => (0, import_rxjs4.merge)(
+          ..._variables.map(
+            (_v) => _v.value$.pipe(
+              // 跳过 BehaviorSubject 第一个
+              (0, import_rxjs4.skip)(1)
+            )
+          )
+        )
+      ),
+      (0, import_rxjs4.share)()
+    );
+    this.onDataChangeEmitter = new import_utils8.Emitter();
+    /**
+     * 监听变量列表变化 + 任意子变量变化
+     */
+    this.onDataChange = this.onDataChangeEmitter.event;
+    this.scope.toDispose.pushAll([
+      this.onVariableListChange((_variables) => {
+        this._variables = _variables;
+        this.memo.clear();
+        this.onDataChangeEmitter.fire(this._variables);
+      }),
+      this.onAnyVariableChange(() => {
+        this.onDataChangeEmitter.fire(this._variables);
+      }),
+      import_utils7.Disposable.create(() => {
+        this.refresh$.complete();
+        this.refresh$.unsubscribe();
+      })
+    ]);
+  }
+  get globalVariableTable() {
+    return this.scope.variableEngine.globalVariableTable;
+  }
+  // 刷新可访问变量列表
+  refresh() {
+    if (this.scope.disposed) {
+      return;
+    }
+    this.refresh$.next();
+  }
+  /**
+   * 监听任意变量变化
+   * @param observer 监听器，变量变化时会吐出值
+   * @returns
+   */
+  onAnyVariableChange(observer) {
+    return subsToDisposable(this.anyVariableChange$.subscribe(observer));
+  }
+  /**
+   * 监听变量列表变化
+   * @param observer
+   * @returns
+   */
+  onVariableListChange(observer) {
+    return subsToDisposable(this.variables$.subscribe(observer));
+  }
+  /**
+   * 获取可消费变量
+   */
+  get variables() {
+    return this._variables;
+  }
+  /**
+   * 获取可访问的变量 keys
+   */
+  get variableKeys() {
+    return this.memo("availableKeys", () => this._variables.map((_v) => _v.key));
+  }
+  /**
+   * 返回依赖的作用域
+   */
+  get depScopes() {
+    return this.scope.depScopes;
+  }
+  /**
+   * 通过 keyPath 找到可用变量
+   * @param keyPath
+   * @returns
+   */
+  getByKeyPath(keyPath = []) {
+    if (!this.variableKeys.includes(keyPath[0])) {
+      return;
+    }
+    return this.globalVariableTable.getByKeyPath(keyPath);
+  }
+};
+
+// src/scope/datas/scope-event-data.ts
+var import_rxjs5 = require("rxjs");
+var ScopeEventData = class {
+  constructor(scope) {
+    this.scope = scope;
+    this.event$ = new import_rxjs5.Subject();
+    scope.toDispose.pushAll([
+      this.subscribe((_action) => {
+        scope.variableEngine.fireGlobalEvent(_action);
+      })
+    ]);
+  }
+  dispatch(action) {
+    if (this.scope.disposed) {
+      return;
+    }
+    this.event$.next(action);
+  }
+  subscribe(observer) {
+    return subsToDisposable(this.event$.subscribe(observer));
+  }
+  on(type, observer) {
+    return subsToDisposable(
+      this.event$.pipe((0, import_rxjs5.filter)((_action) => _action.type === type)).subscribe(observer)
+    );
+  }
+};
+
+// src/scope/scope.ts
+var Scope = class {
+  constructor(options) {
+    /**
+     * 数据缓存
+     */
+    this.memo = createMemo();
+    this.toDispose = new import_utils9.DisposableCollection();
+    this.onDispose = this.toDispose.onDispose;
+    this.id = options.id;
+    this.meta = options.meta || {};
+    this.variableEngine = options.variableEngine;
+    this.event = new ScopeEventData(this);
+    this.ast = this.variableEngine.astRegisters.createAST(
+      {
+        kind: "MapNode" /* MapNode */,
+        key: this.id
+      },
+      {
+        scope: this
+      }
+    );
+    this.output = new ScopeOutputData(this);
+    this.available = new ScopeAvailableData(this);
+  }
+  refreshCovers() {
+    this.memo.clear("covers");
+  }
+  refreshDeps() {
+    this.memo.clear("deps");
+    this.available.refresh();
+  }
+  get depScopes() {
+    return this.memo(
+      "deps",
+      () => this.variableEngine.chain.getDeps(this).filter((_scope) => Boolean(_scope) && !_scope?.disposed)
+    );
+  }
+  get coverScopes() {
+    return this.memo(
+      "covers",
+      () => this.variableEngine.chain.getCovers(this).filter((_scope) => Boolean(_scope) && !_scope?.disposed)
+    );
+  }
+  dispose() {
+    this.ast.dispose();
+    this.toDispose.dispose();
+    this.coverScopes.forEach((_scope) => _scope.refreshDeps());
+    this.depScopes.forEach((_scope) => _scope.refreshCovers());
+  }
+  get disposed() {
+    return this.toDispose.disposed;
+  }
+};
+
+// src/variable-engine.ts
+var VariableEngine = class {
+  constructor(chain, astRegisters) {
+    this.chain = chain;
+    this.astRegisters = astRegisters;
+    this.toDispose = new import_utils10.DisposableCollection();
+    this.memo = createMemo();
+    this.scopeMap = /* @__PURE__ */ new Map();
+    this.globalEvent$ = new import_rxjs6.Subject();
+    this.onScopeChangeEmitter = new import_utils11.Emitter();
+    this.globalVariableTable = new VariableTable();
+    this.onScopeChange = this.onScopeChangeEmitter.event;
+    this.toDispose.pushAll([
+      chain,
+      import_utils10.Disposable.create(() => {
+        this.getAllScopes().forEach((scope) => scope.dispose());
+        this.globalVariableTable.dispose();
+      })
+    ]);
+  }
+  get container() {
+    return this.containerProvider();
+  }
+  dispose() {
+    this.toDispose.dispose();
+  }
+  // 根据 scopeId 找到作用域
+  getScopeById(scopeId) {
+    return this.scopeMap.get(scopeId);
+  }
+  // 移除作用域
+  removeScopeById(scopeId) {
+    this.getScopeById(scopeId)?.dispose();
+  }
+  // 获取 Scope，如果 Scope 存在且类型相同，则会直接使用
+  createScope(id, meta) {
+    let scope = this.getScopeById(id);
+    if (!scope) {
+      scope = new Scope({ variableEngine: this, meta, id });
+      this.scopeMap.set(id, scope);
+      this.onScopeChangeEmitter.fire({ type: "add", scope });
+      scope.toDispose.pushAll([
+        scope.ast.subscribe(() => {
+          this.onScopeChangeEmitter.fire({ type: "update", scope });
+        }),
+        // 可用变量发生变化
+        scope.available.onDataChange(() => {
+          this.onScopeChangeEmitter.fire({ type: "available", scope });
+        })
+      ]);
+      scope.onDispose(() => {
+        this.scopeMap.delete(id);
+        this.onScopeChangeEmitter.fire({ type: "delete", scope });
+      });
+    }
+    return scope;
+  }
+  // 获取系统中所有的作用域
+  getAllScopes({
+    sort
+  } = {}) {
+    const allScopes = Array.from(this.scopeMap.values());
+    if (sort) {
+      const sortScopes = this.chain.sortAll();
+      const remainScopes = new Set(allScopes);
+      sortScopes.forEach((_scope) => remainScopes.delete(_scope));
+      return [...sortScopes, ...Array.from(remainScopes)];
+    }
+    return [...allScopes];
+  }
+  fireGlobalEvent(event) {
+    this.globalEvent$.next(event);
+  }
+  onGlobalEvent(type, observer) {
+    return subsToDisposable(
+      this.globalEvent$.subscribe((_action) => {
+        if (_action.type === type) {
+          observer(_action);
+        }
+      })
+    );
+  }
+};
+__decorateClass([
+  (0, import_inversify5.inject)(ContainerProvider)
+], VariableEngine.prototype, "containerProvider", 2);
+__decorateClass([
+  (0, import_inversify5.preDestroy)()
+], VariableEngine.prototype, "dispose", 1);
+VariableEngine = __decorateClass([
+  (0, import_inversify5.injectable)(),
+  __decorateParam(0, (0, import_inversify5.inject)(ScopeChain)),
+  __decorateParam(1, (0, import_inversify5.inject)(ASTRegisters))
+], VariableEngine);
+
+// src/services/variable-field-key-rename-service.ts
+var import_lodash5 = require("lodash");
+var import_inversify6 = require("inversify");
+var import_utils12 = require("@flowgram.ai/utils");
+var VariableFieldKeyRenameService = class {
+  constructor() {
+    this.toDispose = new import_utils12.DisposableCollection();
+    this.renameEmitter = new import_utils12.Emitter();
+    // 没有被 rename 的字段通过 disposeInList 透出，让业务区分变量是 rename 删除的，还是真正从列表中删除的
+    this.disposeInListEmitter = new import_utils12.Emitter();
+    this.onRename = this.renameEmitter.event;
+    this.onDisposeInList = this.disposeInListEmitter.event;
+  }
+  handleFieldListChange(ast, prev, next) {
+    if (!ast || !prev?.length || !next?.length) {
+      this.notifyFieldsDispose(prev, next);
+      return;
+    }
+    if (prev.length !== next.length) {
+      this.notifyFieldsDispose(prev, next);
+      return;
+    }
+    let renameNodeInfo = null;
+    let existFieldChanged = false;
+    for (const [index, prevField] of prev.entries()) {
+      const nextField = next[index];
+      if (prevField.key !== nextField.key) {
+        if (existFieldChanged) {
+          this.notifyFieldsDispose(prev, next);
+          return;
+        }
+        existFieldChanged = true;
+        if (prevField.type?.kind === nextField.type?.kind) {
+          renameNodeInfo = { before: prevField, after: nextField };
+        }
+      }
+    }
+    if (!renameNodeInfo) {
+      this.notifyFieldsDispose(prev, next);
+      return;
+    }
+    this.renameEmitter.fire(renameNodeInfo);
+  }
+  notifyFieldsDispose(prev, next) {
+    const removedFields = (0, import_lodash5.difference)(prev || [], next || []);
+    removedFields.forEach((_field) => this.disposeInListEmitter.fire(_field));
+  }
+  init() {
+    this.toDispose.pushAll([
+      this.variableEngine.onGlobalEvent(
+        "VariableListChange",
+        (_action) => {
+          this.handleFieldListChange(_action.ast, _action.payload?.prev, _action.payload?.next);
+        }
+      ),
+      this.variableEngine.onGlobalEvent(
+        "ObjectPropertiesChange",
+        (_action) => {
+          this.handleFieldListChange(_action.ast, _action.payload?.prev, _action.payload?.next);
+        }
+      )
+    ]);
+  }
+  dispose() {
+    this.toDispose.dispose();
+  }
+};
+__decorateClass([
+  (0, import_inversify6.inject)(VariableEngine)
+], VariableFieldKeyRenameService.prototype, "variableEngine", 2);
+__decorateClass([
+  (0, import_inversify6.postConstruct)()
+], VariableFieldKeyRenameService.prototype, "init", 1);
+__decorateClass([
+  (0, import_inversify6.preDestroy)()
+], VariableFieldKeyRenameService.prototype, "dispose", 1);
+VariableFieldKeyRenameService = __decorateClass([
+  (0, import_inversify6.injectable)()
+], VariableFieldKeyRenameService);
+
+// src/variable-container-module.ts
+var VariableContainerModule = new import_inversify7.ContainerModule((bind) => {
+  bind(VariableEngine).toSelf().inSingletonScope();
+  bind(ASTRegisters).toSelf().inSingletonScope();
+  bind(VariableFieldKeyRenameService).toSelf().inSingletonScope();
+  bind(VariableEngineProvider).toDynamicValue((ctx) => () => ctx.container.get(VariableEngine));
+  bind(ContainerProvider).toDynamicValue((ctx) => () => ctx.container);
+});
+
+// src/react/context.tsx
+var import_react = require("react");
+var ScopeContext = (0, import_react.createContext)(null);
+var ScopeProvider = ScopeContext.Provider;
+var useScopeContext = () => (0, import_react.useContext)(ScopeContext);
+var useCurrentScope = () => (0, import_react.useContext)(ScopeContext)?.scope;
+
+// src/react/hooks/useScopeAvailable.ts
+var import_react2 = require("react");
+var import_core = require("@flowgram.ai/core");
+function useScopeAvailable() {
+  const scope = useCurrentScope();
+  const refresh = (0, import_core.useRefresh)();
+  (0, import_react2.useEffect)(() => {
+    const disposable = scope.available.onDataChange(() => {
+      refresh();
+    });
+    return () => disposable.dispose();
+  }, []);
+  return scope.available;
+}
+
+// src/react/hooks/useAvailableVariables.ts
+var import_react3 = require("react");
+var import_core2 = require("@flowgram.ai/core");
+function useAvailableVariables() {
+  const scope = useCurrentScope();
+  const variableEngine = (0, import_core2.useService)(VariableEngine);
+  const refresh = (0, import_core2.useRefresh)();
+  (0, import_react3.useEffect)(() => {
+    if (!scope) {
+      const disposable2 = variableEngine.globalVariableTable.onAnyChange(() => {
+        refresh();
+      });
+      return () => disposable2.dispose();
+    }
+    const disposable = scope.available.onDataChange(() => {
+      refresh();
+    });
+    return () => disposable.dispose();
+  }, []);
+  return scope ? scope.available.variables : variableEngine.globalVariableTable.variables;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ASTFactory,
+  ASTKind,
+  ASTNode,
+  ASTNodeFlags,
+  ASTRegisters,
+  ArrayType,
+  BaseExpression,
+  BaseType,
+  BaseVariableField,
+  BooleanType,
+  DataNode,
+  EnumerateExpression,
+  ExpressionList,
+  IntegerType,
+  KeyPathExpression,
+  KeyPathExpressionV2,
+  ListNode,
+  MapNode,
+  MapType,
+  NumberType,
+  ObjectType,
+  Property,
+  Scope,
+  ScopeChain,
+  ScopeOutputData,
+  ScopeProvider,
+  StringType,
+  VariableContainerModule,
+  VariableDeclaration,
+  VariableDeclarationList,
+  VariableEngine,
+  VariableEngineProvider,
+  VariableFieldKeyRenameService,
+  VariableTable,
+  injectToAST,
+  isMatchAST,
+  postConstructAST,
+  useAvailableVariables,
+  useCurrentScope,
+  useScopeAvailable,
+  useScopeContext
+});
+//# sourceMappingURL=index.js.map