@layerzerolabs/dfs 0.0.30 → 0.0.31

package/.turbo/turbo-build.log

@@ -10,9 +10,9 @@
 CLI Cleaning output folder
 CJS Build start
 ESM Build start
-CJS dist/index.cjs     3.27 KB
-CJS dist/index.cjs.map 11.45 KB
-CJS ⚡️ Build success in 152ms
-ESM dist/index.js     3.25 KB
-ESM dist/index.js.map 11.45 KB
-ESM ⚡️ Build success in 153ms
+ESM dist/index.js     3.42 KB
+ESM dist/index.js.map 11.75 KB
+ESM ⚡️ Build success in 101ms
+CJS dist/index.cjs     3.43 KB
+CJS dist/index.cjs.map 11.76 KB
+CJS ⚡️ Build success in 101ms

package/.turbo/turbo-test.log

@@ -5,11 +5,11 @@
 
  RUN  v3.2.3 /home/runner/work/monorepo-internal/monorepo-internal/packages/framework/dfs
 
- ✓ test/dfs.test.ts (7 tests) 605ms
-   ✓ DI Depth-first-search > The handlers for each of a node's dependencies should be completed before that node  302ms
+ ✓ test/dfs.test.ts (7 tests) 573ms
+   ✓ DI Depth-first-search > The handlers for each of a node's dependencies should be completed before that node  303ms
 
  Test Files  1 passed (1)
       Tests  7 passed (7)
-   Start at  00:32:10
-   Duration  1.36s (transform 225ms, setup 0ms, collect 211ms, tests 605ms, environment 0ms, prepare 331ms)
+   Start at  22:01:43
+   Duration  962ms (transform 69ms, setup 0ms, collect 68ms, tests 573ms, environment 0ms, prepare 90ms)
 

package/dist/index.cjs

@@ -17,14 +17,16 @@ var buildAncestryDistanceIndex = /* @__PURE__ */ __name((node, prehandler) => {
   const initializeMaps = /* @__PURE__ */ __name((cur) => {
     ancestryDistanceIndex.set(cur.name, /* @__PURE__ */ new Map());
     for (const dep of Object.values(cur.dependencies)) {
-      const inDegree = inDegreeByNodeName.get(dep.name) || 0;
-      inDegreeByNodeName.set(dep.name, inDegree + 1);
-      if (!ancestryDistanceIndex.has(dep.name)) initializeMaps(dep);
+      const handledDep = prehandler(dep);
+      const inDegree = inDegreeByNodeName.get(handledDep.name) || 0;
+      inDegreeByNodeName.set(handledDep.name, inDegree + 1);
+      if (!ancestryDistanceIndex.has(handledDep.name)) initializeMaps(handledDep);
     }
   }, "initializeMaps");
-  initializeMaps(node);
+  const handled = prehandler(node);
+  initializeMaps(handled);
   let queue = [
-    prehandler(node)
+    handled
   ];
   while (queue.length > 0) {
     const curNode = queue.shift();
@@ -36,12 +38,13 @@ var buildAncestryDistanceIndex = /* @__PURE__ */ __name((node, prehandler) => {
       ...ancestryDistanceIndex.get(curNode.name)
     ]);
     for (const dep of Object.values(curNode.dependencies)) {
-      const inDegree = inDegreeByNodeName.get(dep.name);
+      const handledDep = prehandler(dep);
+      const inDegree = inDegreeByNodeName.get(handledDep.name);
       if (inDegree === 1) {
-        queue.push(prehandler(dep));
+        queue.push(handledDep);
       }
-      inDegreeByNodeName.set(dep.name, inDegree - 1);
-      const childDistances = ancestryDistanceIndex.get(dep.name);
+      inDegreeByNodeName.set(handledDep.name, inDegree - 1);
+      const childDistances = ancestryDistanceIndex.get(handledDep.name);
       mergeAncestorDistances(currentMinimalDistances, childDistances);
     }
   }
@@ -67,7 +70,7 @@ var dfs = /* @__PURE__ */ __name((node, handler, prehandler = (node2) => node2,
     await Promise.all(childrenPromises);
     const minimalDistances = ancestryDistanceIndex.get(prehandledNode.name);
     const sortedAncestors = Array.from(minimalDistances.entries()).sort((a, b) => a[1] - b[1]);
-    const regRes = await handler(node2, sortedAncestors.map(([node3, _]) => node3));
+    const regRes = await handler(prehandledNode, sortedAncestors.map(([node3, _]) => node3));
     if (regRes) {
       (_returns[regRes.key] ??= {})[prehandledNode.name] = regRes.value;
     }

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"names":["mergeAncestorDistances","parentDistances","childDistances","ancestor","parentDist","candidate","current","get","Infinity","set","Math","min","buildAncestryDistanceIndex","node","prehandler","ancestryDistanceIndex","Map","inDegreeByNodeName","initializeMaps","cur","name","dep","Object","values","dependencies","inDegree","has","queue","length","curNode","shift","currentMinimalDistances","push","nodeName","Error","dfs","handler","_returns","nodeResolverPromises","resolveNode","prehandledNode","childrenPromises","dependencyValue","Promise","all","minimalDistances","sortedAncestors","Array","from","entries","sort","a","b","regRes","map","_","key","value"],"mappings":"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","file":"index.cjs","sourcesContent":["import type { DependencyNode } from '@layerzerolabs/dependency-graph';\n\n/**\n * A registrar is a simple interface for an object that provides the ability to traverse the dependency graph.\n * It is implicit in this definition that the registrar should also *register* values adhering to the schemata\n * of the graph.\n */\nexport interface Registrar<ReturnType> {\n    traverseDependencies: (rootNode: DependencyNode) => Promise<ReturnType>;\n}\nexport type NodeHandlerFunction = (\n    node: DependencyNode,\n    ancestry: DependencyNode[],\n) => Promise<{ key: string; value: any }>;\nexport type NodePreHandlerFunction = (node: DependencyNode) => DependencyNode;\n\n// Map of ancestor node -> minimal hop distance\ntype AncestorDistanceByNode = Map<DependencyNode, number>;\n// Index from node name -> its ancestor distance map\ntype AncestryDistanceIndex = Map<string, AncestorDistanceByNode>;\n\n/**\n * In-place merge of minimal ancestry distances.\n *\n * childDistances holds minimal distances from the child to each ancestor (keyed by DependencyNode).\n * For every entry in parentDistances, we update the child's map with (parentDist + 1),\n * keeping the minimal value if the ancestor already exists.\n */\nconst mergeAncestorDistances = (\n    parentDistances: AncestorDistanceByNode,\n    childDistances: AncestorDistanceByNode,\n) => {\n    for (const [ancestor, parentDist] of parentDistances) {\n        const candidate = parentDist + 1;\n        const current = childDistances.get(ancestor) || Infinity;\n        childDistances.set(ancestor, Math.min(current, candidate));\n    }\n};\n\n/**\n * Builds a minimal ancestry distance index for all nodes reachable from the root.\n *\n * Returns a Map: node.name -> Map<DependencyNode, distance> where distance is the minimal hop count\n * from the node to that ancestor. We perform a Kahn-style BFS over the DAG, and for each edge\n * curNode -> dep we merge curNode's minimal distances into the dependency with +1 hop and take the minimum.\n */\nconst buildAncestryDistanceIndex = (\n    node: DependencyNode,\n    prehandler: NodePreHandlerFunction,\n): AncestryDistanceIndex => {\n    const ancestryDistanceIndex: AncestryDistanceIndex = new Map();\n    const inDegreeByNodeName = new Map<string, number>();\n\n    // If A depends on B and C, B depends on C, we initialize with:\n    // ancestryDistanceIndex: { A: Map(), B: Map(), C: Map() }\n    // inDegreeByNodeName: { B: 1, C: 2 }\n    const initializeMaps = (cur: DependencyNode) => {\n        ancestryDistanceIndex.set(cur.name, new Map());\n        for (const dep of Object.values(cur.dependencies)) {\n            const inDegree = inDegreeByNodeName.get(dep.name) || 0;\n            inDegreeByNodeName.set(dep.name, inDegree + 1);\n            if (!ancestryDistanceIndex.has(dep.name)) initializeMaps(dep);\n        }\n    };\n    initializeMaps(node);\n\n    // Kahn-style topological BFS accumulating minimal distance ancestors\n    let queue = [prehandler(node)];\n    while (queue.length > 0) {\n        const curNode = queue.shift()!;\n        // Include self with distance 0, then extend with the already known minimal distances\n        const currentMinimalDistances: AncestorDistanceByNode = new Map([\n            [curNode, 0],\n            ...ancestryDistanceIndex.get(curNode.name)!,\n        ]);\n        // Add the new processable dependencies to the queue, update their state.\n        for (const dep of Object.values(curNode.dependencies)) {\n            const inDegree = inDegreeByNodeName.get(dep.name)!;\n            // We are the last edge missing in the graph for this dependency -> we can process it after us.\n            if (inDegree === 1) {\n                queue.push(prehandler(dep));\n            }\n            // Reduce the in-degree of the dependency -> it basically means that this edge got removed from the graph.\n            inDegreeByNodeName.set(dep.name, inDegree - 1);\n\n            // Merge curNode's minimal distances (+1 hop) into the dependency's minimal distances\n            const childDistances = ancestryDistanceIndex.get(dep.name)!;\n            mergeAncestorDistances(currentMinimalDistances, childDistances);\n        }\n    }\n\n    for (const [nodeName, inDegree] of inDegreeByNodeName) {\n        if (inDegree !== 0) {\n            throw new Error(\n                `node ${nodeName} has in-degree ${inDegree}, this indicates a cycle in the graph containing the node`,\n            );\n        }\n    }\n\n    return ancestryDistanceIndex;\n};\n\n/**\n * Performs a depth-first-search on a tree of dependency nodes, and returns a function\n * that will call the handler for each node in the tree, ordered s.t. the handler of N\n * will be called only after the handlers of dependencies(N) have been called.\n * The node's ancestors are sorted by non-decreasing minimal distance.\n * The resolver function will only call the handler once for each unique definition node.\n * The resolver function returns an object whose keys are the keys defined\n * by each of the handlers, and whose values are objects whose keys are the names\n * of the nodes resolved and whose values are the values defined by the handlers.\n * @param node the root node of the tree\n * @param handler a function that accepts a node and registers it\n * @param prehandler a function that accepts a node and returns a node. Will be used to pre-process the graph\n * @returns a resolver function\n */\nexport const dfs = <ReturnTypes>(\n    node: DependencyNode,\n    handler: NodeHandlerFunction,\n    prehandler: NodePreHandlerFunction = (node) => node,\n    _returns: ReturnTypes = {} as any,\n): (() => Promise<ReturnTypes>) => {\n    const ancestryDistanceIndex = buildAncestryDistanceIndex(node, prehandler);\n\n    // Maintains Map<node.name, Promise<void>> -> the promise to resolve the node, for all nodes.\n    const nodeResolverPromises = new Map<string, Promise<void>>();\n    const resolveNode = async (node: DependencyNode) => {\n        const prehandledNode = prehandler(node);\n        // first wait for all its children\n        const childrenPromises = [];\n        for (const dependencyValue of Object.values(prehandledNode.dependencies)) {\n            // Grab the cached promise or create it, we want to have only 1 handler promise for each node.\n            if (!nodeResolverPromises.has(dependencyValue.name)) {\n                nodeResolverPromises.set(dependencyValue.name, resolveNode(dependencyValue));\n            }\n            childrenPromises.push(nodeResolverPromises.get(dependencyValue.name)!);\n        }\n        await Promise.all(childrenPromises);\n\n        // Then, you can process yourself. Build ancestry sorted by non-decreasing minimal distance.\n        const minimalDistances = ancestryDistanceIndex.get(prehandledNode.name)!;\n        const sortedAncestors = Array.from(minimalDistances.entries()).sort((a, b) => a[1] - b[1]);\n        const regRes = await handler(\n            node,\n            sortedAncestors.map(([node, _]) => node),\n        );\n        if (regRes) {\n            ((_returns as any)[regRes.key] ??= {})[prehandledNode.name] = regRes.value;\n        }\n    };\n\n    return async () => {\n        await resolveNode(node);\n        return _returns;\n    };\n};\n"]}
+{"version":3,"sources":["../src/index.ts"],"names":["mergeAncestorDistances","parentDistances","childDistances","ancestor","parentDist","candidate","current","get","Infinity","set","Math","min","buildAncestryDistanceIndex","node","prehandler","ancestryDistanceIndex","Map","inDegreeByNodeName","initializeMaps","cur","name","dep","Object","values","dependencies","handledDep","inDegree","has","handled","queue","length","curNode","shift","currentMinimalDistances","push","nodeName","Error","dfs","handler","_returns","nodeResolverPromises","resolveNode","prehandledNode","childrenPromises","dependencyValue","Promise","all","minimalDistances","sortedAncestors","Array","from","entries","sort","a","b","regRes","map","_","key","value"],"mappings":"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","file":"index.cjs","sourcesContent":["import type { DependencyNode } from '@layerzerolabs/dependency-graph';\n\n/**\n * A registrar is a simple interface for an object that provides the ability to traverse the dependency graph.\n * It is implicit in this definition that the registrar should also *register* values adhering to the schemata\n * of the graph.\n */\nexport interface Registrar<ReturnType> {\n    traverseDependencies: (rootNode: DependencyNode) => Promise<ReturnType>;\n}\nexport type NodeHandlerFunction = (\n    node: DependencyNode,\n    ancestry: DependencyNode[],\n) => Promise<{ key: string; value: any }>;\nexport type NodePreHandlerFunction = (node: DependencyNode) => DependencyNode;\n\n// Map of ancestor node -> minimal hop distance\ntype AncestorDistanceByNode = Map<DependencyNode, number>;\n// Index from node name -> its ancestor distance map\ntype AncestryDistanceIndex = Map<string, AncestorDistanceByNode>;\n\n/**\n * In-place merge of minimal ancestry distances.\n *\n * childDistances holds minimal distances from the child to each ancestor (keyed by DependencyNode).\n * For every entry in parentDistances, we update the child's map with (parentDist + 1),\n * keeping the minimal value if the ancestor already exists.\n */\nconst mergeAncestorDistances = (\n    parentDistances: AncestorDistanceByNode,\n    childDistances: AncestorDistanceByNode,\n) => {\n    for (const [ancestor, parentDist] of parentDistances) {\n        const candidate = parentDist + 1;\n        const current = childDistances.get(ancestor) || Infinity;\n        childDistances.set(ancestor, Math.min(current, candidate));\n    }\n};\n\n/**\n * Builds a minimal ancestry distance index for all nodes reachable from the root.\n *\n * Returns a Map: node.name -> Map<DependencyNode, distance> where distance is the minimal hop count\n * from the node to that ancestor. We perform a Kahn-style BFS over the DAG, and for each edge\n * curNode -> dep we merge curNode's minimal distances into the dependency with +1 hop and take the minimum.\n */\nconst buildAncestryDistanceIndex = (\n    node: DependencyNode,\n    prehandler: NodePreHandlerFunction,\n): AncestryDistanceIndex => {\n    const ancestryDistanceIndex: AncestryDistanceIndex = new Map();\n    const inDegreeByNodeName = new Map<string, number>();\n\n    // If A depends on B and C, B depends on C, we initialize with:\n    // ancestryDistanceIndex: { A: Map(), B: Map(), C: Map() }\n    // inDegreeByNodeName: { B: 1, C: 2 }\n    const initializeMaps = (cur: DependencyNode) => {\n        ancestryDistanceIndex.set(cur.name, new Map());\n        for (const dep of Object.values(cur.dependencies)) {\n            const handledDep = prehandler(dep);\n            const inDegree = inDegreeByNodeName.get(handledDep.name) || 0;\n            inDegreeByNodeName.set(handledDep.name, inDegree + 1);\n            if (!ancestryDistanceIndex.has(handledDep.name)) initializeMaps(handledDep);\n        }\n    };\n\n    const handled = prehandler(node);\n\n    initializeMaps(handled);\n\n    // Kahn-style topological BFS accumulating minimal distance ancestors\n    let queue = [handled];\n    while (queue.length > 0) {\n        const curNode = queue.shift()!;\n        // Include self with distance 0, then extend with the already known minimal distances\n        const currentMinimalDistances: AncestorDistanceByNode = new Map([\n            [curNode, 0],\n            ...ancestryDistanceIndex.get(curNode.name)!,\n        ]);\n        // Add the new processable dependencies to the queue, update their state.\n        for (const dep of Object.values(curNode.dependencies)) {\n            const handledDep = prehandler(dep);\n            const inDegree = inDegreeByNodeName.get(handledDep.name)!;\n            // We are the last edge missing in the graph for this dependency -> we can process it after us.\n            if (inDegree === 1) {\n                queue.push(handledDep);\n            }\n            // Reduce the in-degree of the dependency -> it basically means that this edge got removed from the graph.\n            inDegreeByNodeName.set(handledDep.name, inDegree - 1);\n\n            // Merge curNode's minimal distances (+1 hop) into the dependency's minimal distances\n            const childDistances = ancestryDistanceIndex.get(handledDep.name)!;\n            mergeAncestorDistances(currentMinimalDistances, childDistances);\n        }\n    }\n\n    for (const [nodeName, inDegree] of inDegreeByNodeName) {\n        if (inDegree !== 0) {\n            throw new Error(\n                `node ${nodeName} has in-degree ${inDegree}, this indicates a cycle in the graph containing the node`,\n            );\n        }\n    }\n\n    return ancestryDistanceIndex;\n};\n\n/**\n * Performs a depth-first-search on a tree of dependency nodes, and returns a function\n * that will call the handler for each node in the tree, ordered s.t. the handler of N\n * will be called only after the handlers of dependencies(N) have been called.\n * The node's ancestors are sorted by non-decreasing minimal distance.\n * The resolver function will only call the handler once for each unique definition node.\n * The resolver function returns an object whose keys are the keys defined\n * by each of the handlers, and whose values are objects whose keys are the names\n * of the nodes resolved and whose values are the values defined by the handlers.\n * @param node the root node of the tree\n * @param handler a function that accepts a node and registers it\n * @param prehandler a function that accepts a node and returns a node. Will be used to pre-process the graph\n * @returns a resolver function\n */\nexport const dfs = <ReturnTypes>(\n    node: DependencyNode,\n    handler: NodeHandlerFunction,\n    prehandler: NodePreHandlerFunction = (node) => node,\n    _returns: ReturnTypes = {} as any,\n): (() => Promise<ReturnTypes>) => {\n    const ancestryDistanceIndex = buildAncestryDistanceIndex(node, prehandler);\n\n    // Maintains Map<node.name, Promise<void>> -> the promise to resolve the node, for all nodes.\n    const nodeResolverPromises = new Map<string, Promise<void>>();\n    const resolveNode = async (node: DependencyNode) => {\n        const prehandledNode = prehandler(node);\n        // first wait for all its children\n        const childrenPromises = [];\n        for (const dependencyValue of Object.values(prehandledNode.dependencies)) {\n            // Grab the cached promise or create it, we want to have only 1 handler promise for each node.\n            if (!nodeResolverPromises.has(dependencyValue.name)) {\n                nodeResolverPromises.set(dependencyValue.name, resolveNode(dependencyValue));\n            }\n            childrenPromises.push(nodeResolverPromises.get(dependencyValue.name)!);\n        }\n        await Promise.all(childrenPromises);\n\n        // Then, you can process yourself. Build ancestry sorted by non-decreasing minimal distance.\n        const minimalDistances = ancestryDistanceIndex.get(prehandledNode.name)!;\n        const sortedAncestors = Array.from(minimalDistances.entries()).sort((a, b) => a[1] - b[1]);\n        const regRes = await handler(\n            prehandledNode,\n            sortedAncestors.map(([node, _]) => node),\n        );\n        if (regRes) {\n            ((_returns as any)[regRes.key] ??= {})[prehandledNode.name] = regRes.value;\n        }\n    };\n\n    return async () => {\n        await resolveNode(node);\n        return _returns;\n    };\n};\n"]}

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEtE;;;;GAIG;AACH,MAAM,WAAW,SAAS,CAAC,UAAU;IACjC,oBAAoB,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;CAC3E;AACD,MAAM,MAAM,mBAAmB,GAAG,CAC9B,IAAI,EAAE,cAAc,EACpB,QAAQ,EAAE,cAAc,EAAE,KACzB,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,GAAG,CAAA;CAAE,CAAC,CAAC;AAC1C,MAAM,MAAM,sBAAsB,GAAG,CAAC,IAAI,EAAE,cAAc,KAAK,cAAc,CAAC;AAwF9E;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,GAAG,GAAI,WAAW,EAC3B,MAAM,cAAc,EACpB,SAAS,mBAAmB,EAC5B,aAAY,sBAAuC,EACnD,WAAU,WAAuB,KAClC,CAAC,MAAM,OAAO,CAAC,WAAW,CAAC,CAkC7B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEtE;;;;GAIG;AACH,MAAM,WAAW,SAAS,CAAC,UAAU;IACjC,oBAAoB,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;CAC3E;AACD,MAAM,MAAM,mBAAmB,GAAG,CAC9B,IAAI,EAAE,cAAc,EACpB,QAAQ,EAAE,cAAc,EAAE,KACzB,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,GAAG,CAAA;CAAE,CAAC,CAAC;AAC1C,MAAM,MAAM,sBAAsB,GAAG,CAAC,IAAI,EAAE,cAAc,KAAK,cAAc,CAAC;AA6F9E;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,GAAG,GAAI,WAAW,EAC3B,MAAM,cAAc,EACpB,SAAS,mBAAmB,EAC5B,aAAY,sBAAuC,EACnD,WAAU,WAAuB,KAClC,CAAC,MAAM,OAAO,CAAC,WAAW,CAAC,CAkC7B,CAAC"}

package/dist/index.js

@@ -15,14 +15,16 @@ var buildAncestryDistanceIndex = /* @__PURE__ */ __name((node, prehandler) => {
   const initializeMaps = /* @__PURE__ */ __name((cur) => {
     ancestryDistanceIndex.set(cur.name, /* @__PURE__ */ new Map());
     for (const dep of Object.values(cur.dependencies)) {
-      const inDegree = inDegreeByNodeName.get(dep.name) || 0;
-      inDegreeByNodeName.set(dep.name, inDegree + 1);
-      if (!ancestryDistanceIndex.has(dep.name)) initializeMaps(dep);
+      const handledDep = prehandler(dep);
+      const inDegree = inDegreeByNodeName.get(handledDep.name) || 0;
+      inDegreeByNodeName.set(handledDep.name, inDegree + 1);
+      if (!ancestryDistanceIndex.has(handledDep.name)) initializeMaps(handledDep);
     }
   }, "initializeMaps");
-  initializeMaps(node);
+  const handled = prehandler(node);
+  initializeMaps(handled);
   let queue = [
-    prehandler(node)
+    handled
   ];
   while (queue.length > 0) {
     const curNode = queue.shift();
@@ -34,12 +36,13 @@ var buildAncestryDistanceIndex = /* @__PURE__ */ __name((node, prehandler) => {
       ...ancestryDistanceIndex.get(curNode.name)
     ]);
     for (const dep of Object.values(curNode.dependencies)) {
-      const inDegree = inDegreeByNodeName.get(dep.name);
+      const handledDep = prehandler(dep);
+      const inDegree = inDegreeByNodeName.get(handledDep.name);
       if (inDegree === 1) {
-        queue.push(prehandler(dep));
+        queue.push(handledDep);
       }
-      inDegreeByNodeName.set(dep.name, inDegree - 1);
-      const childDistances = ancestryDistanceIndex.get(dep.name);
+      inDegreeByNodeName.set(handledDep.name, inDegree - 1);
+      const childDistances = ancestryDistanceIndex.get(handledDep.name);
       mergeAncestorDistances(currentMinimalDistances, childDistances);
     }
   }
@@ -65,7 +68,7 @@ var dfs = /* @__PURE__ */ __name((node, handler, prehandler = (node2) => node2,
     await Promise.all(childrenPromises);
     const minimalDistances = ancestryDistanceIndex.get(prehandledNode.name);
     const sortedAncestors = Array.from(minimalDistances.entries()).sort((a, b) => a[1] - b[1]);
-    const regRes = await handler(node2, sortedAncestors.map(([node3, _]) => node3));
+    const regRes = await handler(prehandledNode, sortedAncestors.map(([node3, _]) => node3));
     if (regRes) {
       (_returns[regRes.key] ??= {})[prehandledNode.name] = regRes.value;
     }

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"names":["mergeAncestorDistances","parentDistances","childDistances","ancestor","parentDist","candidate","current","get","Infinity","set","Math","min","buildAncestryDistanceIndex","node","prehandler","ancestryDistanceIndex","Map","inDegreeByNodeName","initializeMaps","cur","name","dep","Object","values","dependencies","inDegree","has","queue","length","curNode","shift","currentMinimalDistances","push","nodeName","Error","dfs","handler","_returns","nodeResolverPromises","resolveNode","prehandledNode","childrenPromises","dependencyValue","Promise","all","minimalDistances","sortedAncestors","Array","from","entries","sort","a","b","regRes","map","_","key","value"],"mappings":"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","file":"index.js","sourcesContent":["import type { DependencyNode } from '@layerzerolabs/dependency-graph';\n\n/**\n * A registrar is a simple interface for an object that provides the ability to traverse the dependency graph.\n * It is implicit in this definition that the registrar should also *register* values adhering to the schemata\n * of the graph.\n */\nexport interface Registrar<ReturnType> {\n    traverseDependencies: (rootNode: DependencyNode) => Promise<ReturnType>;\n}\nexport type NodeHandlerFunction = (\n    node: DependencyNode,\n    ancestry: DependencyNode[],\n) => Promise<{ key: string; value: any }>;\nexport type NodePreHandlerFunction = (node: DependencyNode) => DependencyNode;\n\n// Map of ancestor node -> minimal hop distance\ntype AncestorDistanceByNode = Map<DependencyNode, number>;\n// Index from node name -> its ancestor distance map\ntype AncestryDistanceIndex = Map<string, AncestorDistanceByNode>;\n\n/**\n * In-place merge of minimal ancestry distances.\n *\n * childDistances holds minimal distances from the child to each ancestor (keyed by DependencyNode).\n * For every entry in parentDistances, we update the child's map with (parentDist + 1),\n * keeping the minimal value if the ancestor already exists.\n */\nconst mergeAncestorDistances = (\n    parentDistances: AncestorDistanceByNode,\n    childDistances: AncestorDistanceByNode,\n) => {\n    for (const [ancestor, parentDist] of parentDistances) {\n        const candidate = parentDist + 1;\n        const current = childDistances.get(ancestor) || Infinity;\n        childDistances.set(ancestor, Math.min(current, candidate));\n    }\n};\n\n/**\n * Builds a minimal ancestry distance index for all nodes reachable from the root.\n *\n * Returns a Map: node.name -> Map<DependencyNode, distance> where distance is the minimal hop count\n * from the node to that ancestor. We perform a Kahn-style BFS over the DAG, and for each edge\n * curNode -> dep we merge curNode's minimal distances into the dependency with +1 hop and take the minimum.\n */\nconst buildAncestryDistanceIndex = (\n    node: DependencyNode,\n    prehandler: NodePreHandlerFunction,\n): AncestryDistanceIndex => {\n    const ancestryDistanceIndex: AncestryDistanceIndex = new Map();\n    const inDegreeByNodeName = new Map<string, number>();\n\n    // If A depends on B and C, B depends on C, we initialize with:\n    // ancestryDistanceIndex: { A: Map(), B: Map(), C: Map() }\n    // inDegreeByNodeName: { B: 1, C: 2 }\n    const initializeMaps = (cur: DependencyNode) => {\n        ancestryDistanceIndex.set(cur.name, new Map());\n        for (const dep of Object.values(cur.dependencies)) {\n            const inDegree = inDegreeByNodeName.get(dep.name) || 0;\n            inDegreeByNodeName.set(dep.name, inDegree + 1);\n            if (!ancestryDistanceIndex.has(dep.name)) initializeMaps(dep);\n        }\n    };\n    initializeMaps(node);\n\n    // Kahn-style topological BFS accumulating minimal distance ancestors\n    let queue = [prehandler(node)];\n    while (queue.length > 0) {\n        const curNode = queue.shift()!;\n        // Include self with distance 0, then extend with the already known minimal distances\n        const currentMinimalDistances: AncestorDistanceByNode = new Map([\n            [curNode, 0],\n            ...ancestryDistanceIndex.get(curNode.name)!,\n        ]);\n        // Add the new processable dependencies to the queue, update their state.\n        for (const dep of Object.values(curNode.dependencies)) {\n            const inDegree = inDegreeByNodeName.get(dep.name)!;\n            // We are the last edge missing in the graph for this dependency -> we can process it after us.\n            if (inDegree === 1) {\n                queue.push(prehandler(dep));\n            }\n            // Reduce the in-degree of the dependency -> it basically means that this edge got removed from the graph.\n            inDegreeByNodeName.set(dep.name, inDegree - 1);\n\n            // Merge curNode's minimal distances (+1 hop) into the dependency's minimal distances\n            const childDistances = ancestryDistanceIndex.get(dep.name)!;\n            mergeAncestorDistances(currentMinimalDistances, childDistances);\n        }\n    }\n\n    for (const [nodeName, inDegree] of inDegreeByNodeName) {\n        if (inDegree !== 0) {\n            throw new Error(\n                `node ${nodeName} has in-degree ${inDegree}, this indicates a cycle in the graph containing the node`,\n            );\n        }\n    }\n\n    return ancestryDistanceIndex;\n};\n\n/**\n * Performs a depth-first-search on a tree of dependency nodes, and returns a function\n * that will call the handler for each node in the tree, ordered s.t. the handler of N\n * will be called only after the handlers of dependencies(N) have been called.\n * The node's ancestors are sorted by non-decreasing minimal distance.\n * The resolver function will only call the handler once for each unique definition node.\n * The resolver function returns an object whose keys are the keys defined\n * by each of the handlers, and whose values are objects whose keys are the names\n * of the nodes resolved and whose values are the values defined by the handlers.\n * @param node the root node of the tree\n * @param handler a function that accepts a node and registers it\n * @param prehandler a function that accepts a node and returns a node. Will be used to pre-process the graph\n * @returns a resolver function\n */\nexport const dfs = <ReturnTypes>(\n    node: DependencyNode,\n    handler: NodeHandlerFunction,\n    prehandler: NodePreHandlerFunction = (node) => node,\n    _returns: ReturnTypes = {} as any,\n): (() => Promise<ReturnTypes>) => {\n    const ancestryDistanceIndex = buildAncestryDistanceIndex(node, prehandler);\n\n    // Maintains Map<node.name, Promise<void>> -> the promise to resolve the node, for all nodes.\n    const nodeResolverPromises = new Map<string, Promise<void>>();\n    const resolveNode = async (node: DependencyNode) => {\n        const prehandledNode = prehandler(node);\n        // first wait for all its children\n        const childrenPromises = [];\n        for (const dependencyValue of Object.values(prehandledNode.dependencies)) {\n            // Grab the cached promise or create it, we want to have only 1 handler promise for each node.\n            if (!nodeResolverPromises.has(dependencyValue.name)) {\n                nodeResolverPromises.set(dependencyValue.name, resolveNode(dependencyValue));\n            }\n            childrenPromises.push(nodeResolverPromises.get(dependencyValue.name)!);\n        }\n        await Promise.all(childrenPromises);\n\n        // Then, you can process yourself. Build ancestry sorted by non-decreasing minimal distance.\n        const minimalDistances = ancestryDistanceIndex.get(prehandledNode.name)!;\n        const sortedAncestors = Array.from(minimalDistances.entries()).sort((a, b) => a[1] - b[1]);\n        const regRes = await handler(\n            node,\n            sortedAncestors.map(([node, _]) => node),\n        );\n        if (regRes) {\n            ((_returns as any)[regRes.key] ??= {})[prehandledNode.name] = regRes.value;\n        }\n    };\n\n    return async () => {\n        await resolveNode(node);\n        return _returns;\n    };\n};\n"]}
+{"version":3,"sources":["../src/index.ts"],"names":["mergeAncestorDistances","parentDistances","childDistances","ancestor","parentDist","candidate","current","get","Infinity","set","Math","min","buildAncestryDistanceIndex","node","prehandler","ancestryDistanceIndex","Map","inDegreeByNodeName","initializeMaps","cur","name","dep","Object","values","dependencies","handledDep","inDegree","has","handled","queue","length","curNode","shift","currentMinimalDistances","push","nodeName","Error","dfs","handler","_returns","nodeResolverPromises","resolveNode","prehandledNode","childrenPromises","dependencyValue","Promise","all","minimalDistances","sortedAncestors","Array","from","entries","sort","a","b","regRes","map","_","key","value"],"mappings":"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","file":"index.js","sourcesContent":["import type { DependencyNode } from '@layerzerolabs/dependency-graph';\n\n/**\n * A registrar is a simple interface for an object that provides the ability to traverse the dependency graph.\n * It is implicit in this definition that the registrar should also *register* values adhering to the schemata\n * of the graph.\n */\nexport interface Registrar<ReturnType> {\n    traverseDependencies: (rootNode: DependencyNode) => Promise<ReturnType>;\n}\nexport type NodeHandlerFunction = (\n    node: DependencyNode,\n    ancestry: DependencyNode[],\n) => Promise<{ key: string; value: any }>;\nexport type NodePreHandlerFunction = (node: DependencyNode) => DependencyNode;\n\n// Map of ancestor node -> minimal hop distance\ntype AncestorDistanceByNode = Map<DependencyNode, number>;\n// Index from node name -> its ancestor distance map\ntype AncestryDistanceIndex = Map<string, AncestorDistanceByNode>;\n\n/**\n * In-place merge of minimal ancestry distances.\n *\n * childDistances holds minimal distances from the child to each ancestor (keyed by DependencyNode).\n * For every entry in parentDistances, we update the child's map with (parentDist + 1),\n * keeping the minimal value if the ancestor already exists.\n */\nconst mergeAncestorDistances = (\n    parentDistances: AncestorDistanceByNode,\n    childDistances: AncestorDistanceByNode,\n) => {\n    for (const [ancestor, parentDist] of parentDistances) {\n        const candidate = parentDist + 1;\n        const current = childDistances.get(ancestor) || Infinity;\n        childDistances.set(ancestor, Math.min(current, candidate));\n    }\n};\n\n/**\n * Builds a minimal ancestry distance index for all nodes reachable from the root.\n *\n * Returns a Map: node.name -> Map<DependencyNode, distance> where distance is the minimal hop count\n * from the node to that ancestor. We perform a Kahn-style BFS over the DAG, and for each edge\n * curNode -> dep we merge curNode's minimal distances into the dependency with +1 hop and take the minimum.\n */\nconst buildAncestryDistanceIndex = (\n    node: DependencyNode,\n    prehandler: NodePreHandlerFunction,\n): AncestryDistanceIndex => {\n    const ancestryDistanceIndex: AncestryDistanceIndex = new Map();\n    const inDegreeByNodeName = new Map<string, number>();\n\n    // If A depends on B and C, B depends on C, we initialize with:\n    // ancestryDistanceIndex: { A: Map(), B: Map(), C: Map() }\n    // inDegreeByNodeName: { B: 1, C: 2 }\n    const initializeMaps = (cur: DependencyNode) => {\n        ancestryDistanceIndex.set(cur.name, new Map());\n        for (const dep of Object.values(cur.dependencies)) {\n            const handledDep = prehandler(dep);\n            const inDegree = inDegreeByNodeName.get(handledDep.name) || 0;\n            inDegreeByNodeName.set(handledDep.name, inDegree + 1);\n            if (!ancestryDistanceIndex.has(handledDep.name)) initializeMaps(handledDep);\n        }\n    };\n\n    const handled = prehandler(node);\n\n    initializeMaps(handled);\n\n    // Kahn-style topological BFS accumulating minimal distance ancestors\n    let queue = [handled];\n    while (queue.length > 0) {\n        const curNode = queue.shift()!;\n        // Include self with distance 0, then extend with the already known minimal distances\n        const currentMinimalDistances: AncestorDistanceByNode = new Map([\n            [curNode, 0],\n            ...ancestryDistanceIndex.get(curNode.name)!,\n        ]);\n        // Add the new processable dependencies to the queue, update their state.\n        for (const dep of Object.values(curNode.dependencies)) {\n            const handledDep = prehandler(dep);\n            const inDegree = inDegreeByNodeName.get(handledDep.name)!;\n            // We are the last edge missing in the graph for this dependency -> we can process it after us.\n            if (inDegree === 1) {\n                queue.push(handledDep);\n            }\n            // Reduce the in-degree of the dependency -> it basically means that this edge got removed from the graph.\n            inDegreeByNodeName.set(handledDep.name, inDegree - 1);\n\n            // Merge curNode's minimal distances (+1 hop) into the dependency's minimal distances\n            const childDistances = ancestryDistanceIndex.get(handledDep.name)!;\n            mergeAncestorDistances(currentMinimalDistances, childDistances);\n        }\n    }\n\n    for (const [nodeName, inDegree] of inDegreeByNodeName) {\n        if (inDegree !== 0) {\n            throw new Error(\n                `node ${nodeName} has in-degree ${inDegree}, this indicates a cycle in the graph containing the node`,\n            );\n        }\n    }\n\n    return ancestryDistanceIndex;\n};\n\n/**\n * Performs a depth-first-search on a tree of dependency nodes, and returns a function\n * that will call the handler for each node in the tree, ordered s.t. the handler of N\n * will be called only after the handlers of dependencies(N) have been called.\n * The node's ancestors are sorted by non-decreasing minimal distance.\n * The resolver function will only call the handler once for each unique definition node.\n * The resolver function returns an object whose keys are the keys defined\n * by each of the handlers, and whose values are objects whose keys are the names\n * of the nodes resolved and whose values are the values defined by the handlers.\n * @param node the root node of the tree\n * @param handler a function that accepts a node and registers it\n * @param prehandler a function that accepts a node and returns a node. Will be used to pre-process the graph\n * @returns a resolver function\n */\nexport const dfs = <ReturnTypes>(\n    node: DependencyNode,\n    handler: NodeHandlerFunction,\n    prehandler: NodePreHandlerFunction = (node) => node,\n    _returns: ReturnTypes = {} as any,\n): (() => Promise<ReturnTypes>) => {\n    const ancestryDistanceIndex = buildAncestryDistanceIndex(node, prehandler);\n\n    // Maintains Map<node.name, Promise<void>> -> the promise to resolve the node, for all nodes.\n    const nodeResolverPromises = new Map<string, Promise<void>>();\n    const resolveNode = async (node: DependencyNode) => {\n        const prehandledNode = prehandler(node);\n        // first wait for all its children\n        const childrenPromises = [];\n        for (const dependencyValue of Object.values(prehandledNode.dependencies)) {\n            // Grab the cached promise or create it, we want to have only 1 handler promise for each node.\n            if (!nodeResolverPromises.has(dependencyValue.name)) {\n                nodeResolverPromises.set(dependencyValue.name, resolveNode(dependencyValue));\n            }\n            childrenPromises.push(nodeResolverPromises.get(dependencyValue.name)!);\n        }\n        await Promise.all(childrenPromises);\n\n        // Then, you can process yourself. Build ancestry sorted by non-decreasing minimal distance.\n        const minimalDistances = ancestryDistanceIndex.get(prehandledNode.name)!;\n        const sortedAncestors = Array.from(minimalDistances.entries()).sort((a, b) => a[1] - b[1]);\n        const regRes = await handler(\n            prehandledNode,\n            sortedAncestors.map(([node, _]) => node),\n        );\n        if (regRes) {\n            ((_returns as any)[regRes.key] ??= {})[prehandledNode.name] = regRes.value;\n        }\n    };\n\n    return async () => {\n        await resolveNode(node);\n        return _returns;\n    };\n};\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/dfs",
-  "version": "0.0.30",
+  "version": "0.0.31",
   "private": false,
   "license": "MIT",
   "type": "module",
@@ -14,13 +14,13 @@
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "dependencies": {
-    "@layerzerolabs/dependency-graph": "0.0.30"
+    "@layerzerolabs/dependency-graph": "0.0.31"
   },
   "devDependencies": {
     "tsup": "^8.4.0",
     "vitest": "^3.2.3",
-    "@layerzerolabs/tsup-configuration": "0.0.30",
-    "@layerzerolabs/typescript-configuration": "0.0.30"
+    "@layerzerolabs/tsup-configuration": "0.0.31",
+    "@layerzerolabs/typescript-configuration": "0.0.31"
   },
   "publishConfig": {
     "access": "restricted",

package/src/index.ts

@@ -57,15 +57,19 @@ const buildAncestryDistanceIndex = (
     const initializeMaps = (cur: DependencyNode) => {
         ancestryDistanceIndex.set(cur.name, new Map());
         for (const dep of Object.values(cur.dependencies)) {
-            const inDegree = inDegreeByNodeName.get(dep.name) || 0;
-            inDegreeByNodeName.set(dep.name, inDegree + 1);
-            if (!ancestryDistanceIndex.has(dep.name)) initializeMaps(dep);
+            const handledDep = prehandler(dep);
+            const inDegree = inDegreeByNodeName.get(handledDep.name) || 0;
+            inDegreeByNodeName.set(handledDep.name, inDegree + 1);
+            if (!ancestryDistanceIndex.has(handledDep.name)) initializeMaps(handledDep);
         }
     };
-    initializeMaps(node);
+
+    const handled = prehandler(node);
+
+    initializeMaps(handled);
 
     // Kahn-style topological BFS accumulating minimal distance ancestors
-    let queue = [prehandler(node)];
+    let queue = [handled];
     while (queue.length > 0) {
         const curNode = queue.shift()!;
         // Include self with distance 0, then extend with the already known minimal distances
@@ -75,16 +79,17 @@ const buildAncestryDistanceIndex = (
         ]);
         // Add the new processable dependencies to the queue, update their state.
         for (const dep of Object.values(curNode.dependencies)) {
-            const inDegree = inDegreeByNodeName.get(dep.name)!;
+            const handledDep = prehandler(dep);
+            const inDegree = inDegreeByNodeName.get(handledDep.name)!;
             // We are the last edge missing in the graph for this dependency -> we can process it after us.
             if (inDegree === 1) {
-                queue.push(prehandler(dep));
+                queue.push(handledDep);
             }
             // Reduce the in-degree of the dependency -> it basically means that this edge got removed from the graph.
-            inDegreeByNodeName.set(dep.name, inDegree - 1);
+            inDegreeByNodeName.set(handledDep.name, inDegree - 1);
 
             // Merge curNode's minimal distances (+1 hop) into the dependency's minimal distances
-            const childDistances = ancestryDistanceIndex.get(dep.name)!;
+            const childDistances = ancestryDistanceIndex.get(handledDep.name)!;
             mergeAncestorDistances(currentMinimalDistances, childDistances);
         }
     }
@@ -141,7 +146,7 @@ export const dfs = <ReturnTypes>(
         const minimalDistances = ancestryDistanceIndex.get(prehandledNode.name)!;
         const sortedAncestors = Array.from(minimalDistances.entries()).sort((a, b) => a[1] - b[1]);
         const regRes = await handler(
-            node,
+            prehandledNode,
             sortedAncestors.map(([node, _]) => node),
         );
         if (regRes) {