rea-agents 6.1.0 → 6.3.0

package/dist/domain/javascript/javascriptSemanticIterationSources.js

@@ -0,0 +1,106 @@
+import * as t from "@babel/types";
+import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
+import { semanticArrayIndex } from "./javascriptSemanticPropertyPaths.js";
+const add = (sources, source, mutation, guards) => {
+    sources.push({
+        node: source.node,
+        projection: source.projection,
+        mutation,
+        ...guards,
+    });
+};
+const project = (source, key) => {
+    if (source === undefined)
+        return undefined;
+    const index = key === null ? null : semanticArrayIndex(key);
+    return {
+        node: source.node,
+        projection: [
+            ...source.projection,
+            source.restStartIndex !== undefined && index !== null
+                ? source.restStartIndex + index
+                : key,
+        ],
+    };
+};
+const visit = (context, pattern, source, guards = {}) => {
+    const { sources, mutation } = context;
+    if (t.isTSParameterProperty(pattern)) {
+        visit(context, pattern.parameter, source, guards);
+        return;
+    }
+    if (t.isAssignmentPattern(pattern)) {
+        visit(context, pattern.left, source, {
+            ...guards,
+            requiredSources: [
+                ...(guards.requiredSources ?? []),
+                ...(source === undefined ? [] : [source]),
+            ],
+        });
+        visit(context, pattern.left, { node: pattern.right, projection: [] }, {
+            ...guards,
+            fallbackSources: [
+                ...(guards.fallbackSources ?? []),
+                ...(source === undefined ? [] : [source]),
+            ],
+        });
+        return;
+    }
+    if (t.isObjectPattern(pattern)) {
+        for (const property of pattern.properties) {
+            // Object rest creates a fresh object and has no iterable binding pattern.
+            if (t.isRestElement(property))
+                continue;
+            visit(context, property.value, project(source, semanticStaticPropertyKey(property.key, property.computed)), guards);
+        }
+        return;
+    }
+    if (t.isArrayPattern(pattern)) {
+        if (source !== undefined && source.restStartIndex === undefined)
+            add(sources, source, mutation, guards);
+        pattern.elements.forEach((element, index) => {
+            if (element === null)
+                return;
+            if (t.isRestElement(element))
+                visit(context, element.argument, source === undefined
+                    ? undefined
+                    : {
+                        node: source.node,
+                        projection: source.projection,
+                        restStartIndex: (source.restStartIndex ?? 0) + index,
+                    }, guards);
+            else
+                visit(context, element, project(source, index), guards);
+        });
+        return;
+    }
+    if (t.isRestElement(pattern))
+        visit(context, pattern.argument, undefined, guards);
+};
+/** Describe implicit iteration sources without deciding their runtime values. */
+export const semanticIterationSources = (node, parent) => {
+    const sources = [];
+    const context = { sources, mutation: node };
+    if (t.isVariableDeclarator(node) && node.init != null)
+        visit(context, node.id, { node: node.init, projection: [] });
+    else if (t.isAssignmentExpression(node) && node.operator === "=")
+        visit(context, node.left, { node: node.right, projection: [] });
+    else if (t.isForOfStatement(node)) {
+        add(sources, { node: node.right, projection: [] }, node, {});
+        const source = { node: node.right, projection: [null] };
+        if (t.isVariableDeclaration(node.left)) {
+            for (const declaration of node.left.declarations)
+                visit(context, declaration.id, source);
+        }
+        else
+            visit(context, node.left, source);
+    }
+    else if (t.isSpreadElement(node) && t.isArrayExpression(parent))
+        add(sources, { node: node.argument, projection: [] }, node, {});
+    else if (t.isYieldExpression(node) && node.delegate && node.argument != null)
+        add(sources, { node: node.argument, projection: [] }, node, {});
+    else if (t.isFunction(node))
+        for (const parameter of node.params)
+            visit(context, parameter, undefined);
+    return sources;
+};