@flowgram.ai/variable-layout 0.1.0-alpha.2 → 0.1.0-alpha.21

package/dist/index.js

@@ -27,15 +27,20 @@ var __decorateClass = (decorators, target, key, kind) => {
 var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   FixedLayoutScopeChain: () => FixedLayoutScopeChain,
   FlowNodeScopeType: () => FlowNodeScopeTypeEnum,
   FlowNodeVariableData: () => FlowNodeVariableData,
   FreeLayoutScopeChain: () => FreeLayoutScopeChain,
-  VariableLayoutConfig: () => VariableLayoutConfig
+  GlobalScope: () => GlobalScope,
+  ScopeChainTransformService: () => ScopeChainTransformService,
+  VariableChainConfig: () => VariableChainConfig,
+  bindGlobalScope: () => bindGlobalScope,
+  getNodePrivateScope: () => getNodePrivateScope,
+  getNodeScope: () => getNodeScope
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
 // src/flow-node-variable-data.ts
 var import_core = require("@flowgram.ai/core");
@@ -60,9 +65,15 @@ var FlowNodeVariableData = class extends import_core.EntityData {
     });
     this.toDispose.push(this._public);
   }
+  /**
+   * The private scope of the node.
+   */
   get private() {
     return this._private;
   }
+  /**
+   * The public scope of the node.
+   */
   get public() {
     return this._public;
   }
@@ -120,6 +131,9 @@ var FlowNodeVariableData = class extends import_core.EntityData {
   clearPrivateVar(key = "outputs") {
     return this.private?.ast.remove(key);
   }
+  /**
+   * An array containing all scopes (public and private) of the node.
+   */
   get allScopes() {
     const res = [];
     if (this._public) {
@@ -133,106 +147,293 @@ var FlowNodeVariableData = class extends import_core.EntityData {
   getDefaultData() {
     return {};
   }
+  /**
+   * Initializes and returns the private scope for the node.
+   * If the private scope already exists, it returns the existing one.
+   * @returns The private scope of the node.
+   */
   initPrivate() {
     if (!this._private) {
       this._private = this.variableEngine.createScope(`${this.entity.id}_private`, {
         node: this.entity,
         type: "private" /* private */
       });
-      this._private.coverScopes.forEach((_scope) => {
-        _scope.refreshDeps();
-      });
-      this._private.depScopes.forEach((_scope) => {
-        _scope.refreshCovers();
-      });
-      this._private.available.refresh();
+      this.variableEngine.chain.refreshAllChange();
       this.toDispose.push(this._private);
     }
     return this._private;
   }
+  /**
+   * Find a variable field by key path in the public scope by scope chain.
+   * @param keyPath - The key path of the variable field.
+   * @returns The variable field, or undefined if not found.
+   */
+  getByKeyPath(keyPath) {
+    return this.public.available.getByKeyPath(keyPath);
+  }
+  /**
+   * Find a variable field by key path in the private scope by scope chain.
+   * @param keyPath - The key path of the variable field.
+   * @returns The variable field, or undefined if not found.
+   */
+  getByKeyPathInPrivate(keyPath) {
+    return this.private?.available.getByKeyPath(keyPath);
+  }
 };
 FlowNodeVariableData.type = "FlowNodeVariableData";
 
-// src/free-layout-scope-chain.ts
+// src/chains/free-layout-scope-chain.ts
+var import_inversify3 = require("inversify");
+var import_variable_core3 = require("@flowgram.ai/variable-core");
+var import_free_layout_core = require("@flowgram.ai/free-layout-core");
+var import_document2 = require("@flowgram.ai/document");
+var import_core3 = require("@flowgram.ai/core");
+
+// src/variable-chain-config.ts
+var VariableChainConfig = Symbol("VariableChainConfig");
+
+// src/services/scope-chain-transform-service.ts
 var import_inversify = require("inversify");
 var import_variable_core = require("@flowgram.ai/variable-core");
 var import_document = require("@flowgram.ai/document");
 var import_core2 = require("@flowgram.ai/core");
-var import_free_layout_core = require("@flowgram.ai/free-layout-core");
+var passthrough = (scopes, ctx) => scopes;
+var ScopeChainTransformService = class {
+  constructor(configs) {
+    this.configs = configs;
+    this.transformerMap = /* @__PURE__ */ new Map();
+    if (this.configs?.transformDeps || this.configs?.transformCovers) {
+      this.transformerMap.set("VARIABLE_LAYOUT_CONFIG", {
+        transformDeps: this.configs.transformDeps || passthrough,
+        transformCovers: this.configs.transformCovers || passthrough
+      });
+    }
+  }
+  /**
+   * check if transformer registered
+   * @param transformerId used to identify transformer, prevent duplicated
+   * @returns
+   */
+  hasTransformer(transformerId) {
+    return this.transformerMap.has(transformerId);
+  }
+  /**
+   * register new transform function
+   * @param transformerId used to identify transformer, prevent duplicated transformer
+   * @param transformer The transformer to register.
+   */
+  registerTransformer(transformerId, transformer) {
+    this.transformerMap.set(transformerId, transformer);
+  }
+  /**
+   * Transforms the dependency scopes.
+   * @param scopes The array of scopes to transform.
+   * @param param1 The context for the transformation.
+   * @returns The transformed array of scopes.
+   */
+  transformDeps(scopes, { scope }) {
+    return Array.from(this.transformerMap.values()).reduce((scopes2, transformer) => {
+      if (!transformer.transformDeps) {
+        return scopes2;
+      }
+      scopes2 = transformer.transformDeps(scopes2, {
+        scope,
+        document: this.document,
+        variableEngine: this.variableEngine
+      });
+      return scopes2;
+    }, scopes);
+  }
+  /**
+   * Transforms the cover scopes.
+   * @param scopes The array of scopes to transform.
+   * @param param1 The context for the transformation.
+   * @returns The transformed array of scopes.
+   */
+  transformCovers(scopes, { scope }) {
+    return Array.from(this.transformerMap.values()).reduce((scopes2, transformer) => {
+      if (!transformer.transformCovers) {
+        return scopes2;
+      }
+      scopes2 = transformer.transformCovers(scopes2, {
+        scope,
+        document: this.document,
+        variableEngine: this.variableEngine
+      });
+      return scopes2;
+    }, scopes);
+  }
+};
+__decorateClass([
+  (0, import_core2.lazyInject)(import_document.FlowDocument)
+], ScopeChainTransformService.prototype, "document", 2);
+__decorateClass([
+  (0, import_core2.lazyInject)(import_variable_core.VariableEngine)
+], ScopeChainTransformService.prototype, "variableEngine", 2);
+ScopeChainTransformService = __decorateClass([
+  (0, import_inversify.injectable)(),
+  __decorateParam(0, (0, import_inversify.optional)()),
+  __decorateParam(0, (0, import_inversify.inject)(VariableChainConfig))
+], ScopeChainTransformService);
 
-// src/variable-layout-config.ts
-var VariableLayoutConfig = Symbol("VariableLayoutConfig");
+// src/scopes/global-scope.ts
+var import_inversify2 = require("inversify");
+var import_variable_core2 = require("@flowgram.ai/variable-core");
+var GlobalScope = class extends import_variable_core2.Scope {
+  /**
+   * Check if the scope is Global Scope.
+   * @param scope
+   * @returns
+   */
+  static is(scope) {
+    return scope.id === GlobalScope.ID;
+  }
+};
+GlobalScope.ID = Symbol("GlobalScope");
+GlobalScope = __decorateClass([
+  (0, import_inversify2.injectable)()
+], GlobalScope);
+var bindGlobalScope = (bind) => {
+  bind(GlobalScope).toDynamicValue((ctx) => {
+    const variableEngine = ctx.container.get(import_variable_core2.VariableEngine);
+    let scope = variableEngine.getScopeById(GlobalScope.ID);
+    if (!scope) {
+      scope = variableEngine.createScope(
+        GlobalScope.ID,
+        {},
+        { ScopeConstructor: GlobalScope }
+      );
+      variableEngine.chain.refreshAllChange();
+    }
+    return scope;
+  });
+};
 
-// src/free-layout-scope-chain.ts
-var FreeLayoutScopeChain = class extends import_variable_core.ScopeChain {
+// src/chains/free-layout-scope-chain.ts
+var FreeLayoutScopeChain = class extends import_variable_core3.ScopeChain {
+  /**
+   * The virtual tree of the flow document.
+   */
   get tree() {
     return this.flowDocument.originTree;
   }
   onInit() {
     this.toDispose.pushAll([
-      // 线条发生变化时，会触发作用域链的更新
+      // When the line changes, the scope chain will be updated
       this.entityManager.onEntityDataChange(({ entityDataType }) => {
         if (entityDataType === import_free_layout_core.WorkflowNodeLinesData.type) {
           this.refreshAllChange();
         }
       }),
-      // 树变化时候刷新作用域
+      // Refresh the scope when the tree changes
       this.tree.onTreeChange(() => {
         this.refreshAllChange();
       })
     ]);
   }
-  // 获取同一层级所有输入节点
-  getAllInputLayerNodes(curr) {
-    return (curr.getData(import_free_layout_core.WorkflowNodeLinesData)?.allInputNodes || []).filter(
-      (_node) => _node.parent === curr.parent
-    );
+  /**
+   * Gets all input layer nodes for a given node in the same layer, sorted by distance.
+   * @param node The node to get input layer nodes for.
+   * @returns An array of input layer nodes.
+   */
+  getAllInputLayerNodes(node) {
+    const currParent = this.getNodeParent(node);
+    const result = /* @__PURE__ */ new Set();
+    const queue = [node];
+    while (queue.length) {
+      const curr = queue.shift();
+      (curr.lines?.inputNodes || []).forEach((inputNode) => {
+        if (this.getNodeParent(inputNode) === currParent) {
+          if (result.has(inputNode)) {
+            return;
+          }
+          queue.push(inputNode);
+          result.add(inputNode);
+        }
+      });
+    }
+    return Array.from(result).reverse();
   }
-  // 获取同一层级所有输出节点
+  /**
+   * Gets all output layer nodes for a given node in the same layer.
+   * @param curr The node to get output layer nodes for.
+   * @returns An array of output layer nodes.
+   */
   getAllOutputLayerNodes(curr) {
-    return (curr.getData(import_free_layout_core.WorkflowNodeLinesData)?.allOutputNodes || []).filter(
-      (_node) => _node.parent === curr.parent
+    const currParent = this.getNodeParent(curr);
+    return (curr.lines?.allOutputNodes || []).filter(
+      (_node) => this.getNodeParent(_node) === currParent
     );
   }
+  /**
+   * Gets the dependency scopes for a given scope.
+   * @param scope The scope to get dependencies for.
+   * @returns An array of dependency scopes.
+   */
   getDeps(scope) {
     const { node } = scope.meta || {};
     if (!node) {
-      return this.transformDeps([], { scope });
+      return this.transformService.transformDeps([], { scope });
     }
-    const scopes = [];
+    const deps = [];
     let curr = node;
     while (curr) {
-      const allInputNodes = this.getAllInputLayerNodes(curr);
-      scopes.push(
-        ...allInputNodes.map((_node) => _node.getData(FlowNodeVariableData).public).filter(Boolean)
-      );
       const currVarData = curr.getData(FlowNodeVariableData);
       if (currVarData?.private && scope !== currVarData.private) {
-        scopes.push(currVarData.private);
+        deps.unshift(currVarData.private);
       }
-      curr = this.getParent(curr);
+      const allInputNodes = this.getAllInputLayerNodes(curr);
+      deps.unshift(
+        ...allInputNodes.map((_node) => [
+          _node.getData(FlowNodeVariableData).public,
+          // 4. all public children of inputNodes
+          ...this.getAllPublicChildScopes(_node)
+        ]).flat().filter(Boolean)
+      );
+      curr = this.getNodeParent(curr);
     }
-    const uniqScopes = Array.from(new Set(scopes));
-    return this.transformDeps(uniqScopes, { scope });
+    const globalScope = this.variableEngine.getScopeById(GlobalScope.ID);
+    if (globalScope) {
+      deps.unshift(globalScope);
+    }
+    const uniqDeps = Array.from(new Set(deps));
+    return this.transformService.transformDeps(uniqDeps, { scope });
   }
+  /**
+   * Gets the covering scopes for a given scope.
+   * @param scope The scope to get covering scopes for.
+   * @returns An array of covering scopes.
+   */
   getCovers(scope) {
+    if (GlobalScope.is(scope)) {
+      const scopes2 = this.variableEngine.getAllScopes({ sort: true }).filter((_scope) => !GlobalScope.is(_scope));
+      return this.transformService.transformCovers(scopes2, { scope });
+    }
     const { node } = scope.meta || {};
     if (!node) {
-      return this.transformCovers([], { scope });
+      return this.transformService.transformCovers([], { scope });
     }
     const isPrivate = scope.meta.type === "private" /* private */;
     const queue = [];
     if (isPrivate) {
-      queue.push(...this.getChildren(node));
+      queue.push(...this.getNodeChildren(node));
     } else {
       queue.push(...this.getAllOutputLayerNodes(node) || []);
+      let parent = this.getNodeParent(node);
+      while (parent) {
+        if (this.isNodeChildrenPrivate(parent)) {
+          break;
+        }
+        queue.push(...this.getAllOutputLayerNodes(parent));
+        parent = this.getNodeParent(parent);
+      }
     }
     const scopes = [];
     while (queue.length) {
       const _node = queue.shift();
       const variableData = _node.getData(FlowNodeVariableData);
       scopes.push(...variableData.allScopes);
-      const children = _node && this.getChildren(_node);
+      const children = _node && this.getNodeChildren(_node);
       if (children?.length) {
         queue.push(...children);
       }
@@ -242,25 +443,16 @@ var FreeLayoutScopeChain = class extends import_variable_core.ScopeChain {
       scopes.push(currentVariableData.public);
     }
     const uniqScopes = Array.from(new Set(scopes));
-    return this.transformCovers(uniqScopes, { scope });
-  }
-  transformCovers(covers, { scope }) {
-    return this.configs?.transformCovers ? this.configs.transformCovers(covers, {
-      scope,
-      document: this.flowDocument,
-      variableEngine: this.variableEngine
-    }) : covers;
-  }
-  transformDeps(deps, { scope }) {
-    return this.configs?.transformDeps ? this.configs.transformDeps(deps, {
-      scope,
-      document: this.flowDocument,
-      variableEngine: this.variableEngine
-    }) : deps;
-  }
-  getChildren(node) {
-    if (this.configs?.getFreeChildren) {
-      return this.configs.getFreeChildren?.(node);
+    return this.transformService.transformCovers(uniqScopes, { scope });
+  }
+  /**
+   * Gets the children of a node.
+   * @param node The node to get children for.
+   * @returns An array of child nodes.
+   */
+  getNodeChildren(node) {
+    if (this.configs?.getNodeChildren) {
+      return this.configs.getNodeChildren?.(node);
     }
     const nodeMeta = node.getNodeMeta();
     const subCanvas = nodeMeta.subCanvas?.(node);
@@ -273,69 +465,117 @@ var FreeLayoutScopeChain = class extends import_variable_core.ScopeChain {
     }
     return this.tree.getChildren(node);
   }
-  getParent(node) {
-    if (this.configs?.getFreeParent) {
-      return this.configs.getFreeParent(node);
+  /**
+   * Get All children of nodes
+   * @param node
+   * @returns
+   */
+  getAllPublicChildScopes(node) {
+    if (this.isNodeChildrenPrivate(node)) {
+      return [];
+    }
+    return this.getNodeChildren(node).map((_node) => [
+      _node.getData(FlowNodeVariableData).public,
+      ...this.getAllPublicChildScopes(_node)
+    ]).flat();
+  }
+  /**
+   * Gets the parent of a node.
+   * @param node The node to get the parent for.
+   * @returns The parent node or `undefined` if not found.
+   */
+  getNodeParent(node) {
+    if (this.configs?.getNodeParent) {
+      return this.configs.getNodeParent(node);
     }
-    const initParent = node.document.originTree.getParent(node);
-    if (!initParent) {
-      return initParent;
+    let parent = node.document.originTree.getParent(node);
+    while (parent?.flowNodeType === import_document2.FlowNodeBaseType.GROUP) {
+      parent = parent.parent;
     }
-    const nodeMeta = initParent.getNodeMeta();
-    const subCanvas = nodeMeta.subCanvas?.(initParent);
+    if (!parent) {
+      return parent;
+    }
+    const nodeMeta = parent.getNodeMeta();
+    const subCanvas = nodeMeta.subCanvas?.(parent);
     if (subCanvas?.isCanvas) {
       return subCanvas.parentNode;
     }
-    return initParent;
+    return parent;
+  }
+  /**
+   * Checks if the children of a node are private and cannot be accessed by subsequent nodes.
+   * @param node The node to check.
+   * @returns `true` if the children are private, `false` otherwise.
+   */
+  isNodeChildrenPrivate(node) {
+    if (this.configs?.isNodeChildrenPrivate) {
+      return node ? this.configs?.isNodeChildrenPrivate(node) : false;
+    }
+    const isSystemNode = node?.id.startsWith("$");
+    return !isSystemNode && node?.flowNodeType !== import_document2.FlowNodeBaseType.GROUP;
   }
+  /**
+   * Sorts all scopes in the scope chain.
+   * @returns An empty array, as this method is not implemented.
+   */
   sortAll() {
     console.warn("FreeLayoutScopeChain.sortAll is not implemented");
     return [];
   }
 };
 __decorateClass([
-  (0, import_inversify.inject)(import_core2.EntityManager)
+  (0, import_inversify3.inject)(import_core3.EntityManager)
 ], FreeLayoutScopeChain.prototype, "entityManager", 2);
 __decorateClass([
-  (0, import_inversify.inject)(import_document.FlowDocument)
+  (0, import_inversify3.inject)(import_document2.FlowDocument)
 ], FreeLayoutScopeChain.prototype, "flowDocument", 2);
 __decorateClass([
-  (0, import_inversify.optional)(),
-  (0, import_inversify.inject)(VariableLayoutConfig)
+  (0, import_inversify3.optional)(),
+  (0, import_inversify3.inject)(VariableChainConfig)
 ], FreeLayoutScopeChain.prototype, "configs", 2);
 __decorateClass([
-  (0, import_inversify.postConstruct)()
+  (0, import_inversify3.inject)(ScopeChainTransformService)
+], FreeLayoutScopeChain.prototype, "transformService", 2);
+__decorateClass([
+  (0, import_inversify3.postConstruct)()
 ], FreeLayoutScopeChain.prototype, "onInit", 1);
 
-// src/fixed-layout-scope-chain.ts
-var import_inversify2 = require("inversify");
-var import_variable_core2 = require("@flowgram.ai/variable-core");
-var import_document2 = require("@flowgram.ai/document");
-var FixedLayoutScopeChain = class extends import_variable_core2.ScopeChain {
+// src/chains/fixed-layout-scope-chain.ts
+var import_inversify4 = require("inversify");
+var import_variable_core4 = require("@flowgram.ai/variable-core");
+var import_document3 = require("@flowgram.ai/document");
+var FixedLayoutScopeChain = class extends import_variable_core4.ScopeChain {
   constructor(flowDocument, configs) {
     super();
     this.flowDocument = flowDocument;
     this.configs = configs;
     this.bindTree(flowDocument.originTree);
     this.toDispose.push(
-      // REFRACTOR: onTreeChange 触发时机精细化
+      // REFRACTOR: onTreeChange trigger timing needs to be refined
       flowDocument.originTree.onTreeChange(() => {
         this.refreshAllChange();
       })
     );
   }
-  // 绑定树
+  /**
+   * Binds the scope chain to a `FlowVirtualTree`.
+   * @param tree The `FlowVirtualTree` to bind to.
+   */
   bindTree(tree) {
     this.tree = tree;
   }
-  // 获取依赖作用域
+  /**
+   * Gets the dependency scopes for a given scope.
+   * @param scope The scope to get dependencies for.
+   * @returns An array of dependency scopes.
+   */
   getDeps(scope) {
     if (!this.tree) {
-      return this.transformDeps([], { scope });
+      return this.transformService.transformDeps([], { scope });
     }
     const node = scope.meta.node;
     if (!node) {
-      return this.transformDeps([], { scope });
+      return this.transformService.transformDeps([], { scope });
     }
     const deps = [];
     let curr = node;
@@ -379,25 +619,37 @@ var FixedLayoutScopeChain = class extends import_variable_core2.ScopeChain {
       }
       curr = void 0;
     }
-    return this.transformDeps(deps, { scope });
+    const globalScope = this.variableEngine.getScopeById(GlobalScope.ID);
+    if (globalScope) {
+      deps.unshift(globalScope);
+    }
+    return this.transformService.transformDeps(deps, { scope });
   }
-  // 获取覆盖作用域
+  /**
+   * Gets the covering scopes for a given scope.
+   * @param scope The scope to get covering scopes for.
+   * @returns An array of covering scopes.
+   */
   getCovers(scope) {
     if (!this.tree) {
-      return this.transformCovers([], { scope });
+      return this.transformService.transformCovers([], { scope });
+    }
+    if (GlobalScope.is(scope)) {
+      const scopes = this.variableEngine.getAllScopes({ sort: true }).filter((_scope) => !GlobalScope.is(_scope));
+      return this.transformService.transformCovers(scopes, { scope });
     }
     const node = scope.meta.node;
     if (!node) {
-      return this.transformCovers([], { scope });
+      return this.transformService.transformCovers([], { scope });
     }
     const covers = [];
     if (scope.meta.type === "private" /* private */) {
       covers.push(
         ...this.getAllSortedChildScope(node, {
           addNodePrivateScope: true
-        })
+        }).filter((_scope) => _scope !== scope)
       );
-      return this.transformCovers(covers, { scope });
+      return this.transformService.transformCovers(covers, { scope });
     }
     let curr = node;
     while (curr) {
@@ -423,7 +675,7 @@ var FixedLayoutScopeChain = class extends import_variable_core2.ScopeChain {
         let currParentNext = this.tree.getNext(currParent);
         while (currParent) {
           if (this.isNodeChildrenPrivate(currParent)) {
-            return this.transformCovers(covers, { scope });
+            return this.transformService.transformCovers(covers, { scope });
           }
           if (currParentNext) {
             break;
@@ -439,33 +691,30 @@ var FixedLayoutScopeChain = class extends import_variable_core2.ScopeChain {
       }
       curr = void 0;
     }
-    return this.transformCovers(covers, { scope });
-  }
-  transformCovers(covers, { scope }) {
-    return this.configs?.transformCovers ? this.configs.transformCovers(covers, {
-      scope,
-      document: this.flowDocument,
-      variableEngine: this.variableEngine
-    }) : covers;
+    return this.transformService.transformCovers(covers, { scope });
   }
-  transformDeps(deps, { scope }) {
-    return this.configs?.transformDeps ? this.configs.transformDeps(deps, {
-      scope,
-      document: this.flowDocument,
-      variableEngine: this.variableEngine
-    }) : deps;
-  }
-  // 排序所有作用域
+  /**
+   * Sorts all scopes in the scope chain.
+   * @returns A sorted array of all scopes.
+   */
   sortAll() {
-    const { startNodeId } = this.configs || {};
-    const startNode = startNodeId ? this.flowDocument?.getNode(startNodeId) : void 0;
+    const startNode = this.flowDocument.getAllNodes().find((_node) => _node.isStart);
     if (!startNode) {
       return [];
     }
     const startVariableData = startNode.getData(FlowNodeVariableData);
-    return [startVariableData.public, ...this.getCovers(startVariableData.public)];
+    const startPublicScope = startVariableData.public;
+    const deps = this.getDeps(startPublicScope);
+    const covers = this.getCovers(startPublicScope).filter(
+      (_scope) => !deps.includes(_scope) && _scope !== startPublicScope
+    );
+    return [...deps, startPublicScope, ...covers];
   }
-  // 获取变量 Data 数据
+  /**
+   * Gets the `FlowNodeVariableData` for a given `ScopeChainNode`.
+   * @param node The `ScopeChainNode` to get data for.
+   * @returns The `FlowNodeVariableData` or `undefined` if not found.
+   */
   getVariableData(node) {
     if (node.flowNodeType === "virtualNode") {
       return;
@@ -475,7 +724,11 @@ var FixedLayoutScopeChain = class extends import_variable_core2.ScopeChain {
     }
     return node.getData(FlowNodeVariableData);
   }
-  // privateScope：子节点不可以被后续节点访问
+  /**
+   * Checks if the children of a node are private.
+   * @param node The node to check.
+   * @returns `true` if the children are private, `false` otherwise.
+   */
   isNodeChildrenPrivate(node) {
     if (this.configs?.isNodeChildrenPrivate) {
       return node ? this.configs?.isNodeChildrenPrivate(node) : false;
@@ -483,10 +736,20 @@ var FixedLayoutScopeChain = class extends import_variable_core2.ScopeChain {
     const isSystemNode = node?.id.startsWith("$");
     return !isSystemNode && this.hasChildren(node);
   }
+  /**
+   * Checks if a node has children.
+   * @param node The node to check.
+   * @returns `true` if the node has children, `false` otherwise.
+   */
   hasChildren(node) {
     return Boolean(this.tree && node && this.tree.getChildren(node).length > 0);
   }
-  // 子节点按照顺序进行排序（含自身）
+  /**
+   * Gets all sorted child scopes of a node.
+   * @param node The node to get child scopes for.
+   * @param options Options for getting child scopes.
+   * @returns An array of sorted child scopes.
+   */
   getAllSortedChildScope(node, {
     ignoreNodeChildrenPrivate,
     addNodePrivateScope
@@ -511,17 +774,33 @@ var FixedLayoutScopeChain = class extends import_variable_core2.ScopeChain {
     return scopes;
   }
 };
+__decorateClass([
+  (0, import_inversify4.inject)(ScopeChainTransformService)
+], FixedLayoutScopeChain.prototype, "transformService", 2);
 FixedLayoutScopeChain = __decorateClass([
-  __decorateParam(0, (0, import_inversify2.inject)(import_document2.FlowDocument)),
-  __decorateParam(1, (0, import_inversify2.optional)()),
-  __decorateParam(1, (0, import_inversify2.inject)(VariableLayoutConfig))
+  __decorateParam(0, (0, import_inversify4.inject)(import_document3.FlowDocument)),
+  __decorateParam(1, (0, import_inversify4.optional)()),
+  __decorateParam(1, (0, import_inversify4.inject)(VariableChainConfig))
 ], FixedLayoutScopeChain);
+
+// src/utils.ts
+function getNodeScope(node) {
+  return node.getData(FlowNodeVariableData).public;
+}
+function getNodePrivateScope(node) {
+  return node.getData(FlowNodeVariableData).initPrivate();
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   FixedLayoutScopeChain,
   FlowNodeScopeType,
   FlowNodeVariableData,
   FreeLayoutScopeChain,
-  VariableLayoutConfig
+  GlobalScope,
+  ScopeChainTransformService,
+  VariableChainConfig,
+  bindGlobalScope,
+  getNodePrivateScope,
+  getNodeScope
 });
 //# sourceMappingURL=index.js.map