@superblocksteam/vite-plugin-file-sync 1.99.99-next.2

package/dist/parsing/scope.js

@@ -0,0 +1,669 @@
+import { transformFromAstSync } from "@babel/core";
+import { parse } from "@babel/parser";
+import { variableDeclarator, objectPattern, objectProperty, variableDeclaration, identifier, blockStatement, returnStatement, } from "@babel/types";
+import * as t from "@babel/types";
+import { getStableScopeId, } from "@superblocksteam/library-shared";
+import { SbEntityType } from "@superblocksteam/library-shared/types";
+import { generatePredictableId } from "@superblocksteam/shared/dist/utils/appDSL.js";
+import { getPropertyExpression } from "../codegen.js";
+import { traverse } from "../traverse.js";
+import { parser as entityParser } from "./entity/index.js";
+import { getSbElementId, setSbElementId, supplementElementIds } from "./ids.js";
+import { REQUIRED_IMPORTS_BY_PROPERTY_TYPE } from "./imports.js";
+import { getIdentiferName, isSbScopeFunction, nodeToValue, extractNameFromBindAttribute, } from "./util.js";
+export function getScopeElementId(scopeId, name) {
+    return `SB-${generatePredictableId(scopeId + name)}-type`;
+}
+const importsByEntityType = {
+    [SbEntityType.VARIABLE]: [
+        { importName: "SB", importPath: "@superblocksteam/library" },
+        { importName: "SbVariable", importPath: "@superblocksteam/library" },
+        {
+            importName: "SbVariablePersistence",
+            importPath: "@superblocksteam/library",
+        },
+    ],
+    [SbEntityType.TIMER]: [
+        { importName: "SB", importPath: "@superblocksteam/library" },
+        { importName: "SbTimer", importPath: "@superblocksteam/library" },
+        { importName: "SbEventFlow", importPath: "@superblocksteam/library" },
+    ],
+    [SbEntityType.EVENT]: [
+        { importName: "SbEvent", importPath: "@superblocksteam/library" },
+    ],
+    [SbEntityType.API]: [
+        { importName: "SB", importPath: "@superblocksteam/library" },
+        { importName: "SbApi", importPath: "@superblocksteam/library" },
+        { importName: "SbEventFlow", importPath: "@superblocksteam/library" },
+    ],
+};
+/**
+ * Given an object property from a scope entry, like:
+ * pageSize: SbVariable({
+ *   defaultValue: "test ${Math.random()}",
+ *   persistence: SbVariablePersistence.TEMPORARY
+ * })
+ *
+ * Returns a reference to the object expression node
+ */
+function getConfigObject(node) {
+    const config = node.get("value");
+    if (!config.isCallExpression()) {
+        return null;
+    }
+    const args = config.get("arguments");
+    if (args.length !== 1) {
+        return null;
+    }
+    const configObject = args[0];
+    if (!configObject?.isObjectExpression()) {
+        return null;
+    }
+    return configObject;
+}
+export function updateEntityNode(node, updates, entityId) {
+    const entity = fromNodeToEntity(node, entityId);
+    if (!entity) {
+        throw new Error("Entity could not be created from node: " +
+            getIdentiferName(node.node.key));
+    }
+    const configObject = getConfigObject(node);
+    if (!configObject) {
+        return {
+            imports: [],
+        };
+    }
+    let imports = importsByEntityType[entity.type] ?? [];
+    for (const [key, info] of Object.entries(updates ?? {})) {
+        const property = configObject.get("properties").find((property) => {
+            return (property.isObjectProperty() &&
+                property.get("key").isIdentifier() &&
+                getIdentiferName(property.node.key) === key);
+        });
+        if (!property) {
+            configObject.pushContainer("properties", objectProperty(identifier(key), getPropertyExpression(info)));
+        }
+        else {
+            property.replaceWith(objectProperty(identifier(key), getPropertyExpression(info)));
+        }
+        if (info.type in REQUIRED_IMPORTS_BY_PROPERTY_TYPE) {
+            const requiredImports = REQUIRED_IMPORTS_BY_PROPERTY_TYPE[info.type];
+            if (requiredImports) {
+                imports = [...imports, ...requiredImports];
+            }
+        }
+    }
+    return { imports };
+}
+export function fromEntityToNode(entity) {
+    const imports = importsByEntityType[entity.type] ?? [];
+    const code = entityParser.toCode(entity);
+    const parsedEntity = parse(code, {
+        sourceType: "module",
+        plugins: ["typescript", "jsx"],
+    });
+    if (parsedEntity.program.body[0]?.type !== "ExpressionStatement") {
+        throw new Error("Invalid entity ast definition");
+    }
+    return {
+        entity: objectProperty(identifier(entity.name), parsedEntity.program.body[0].expression),
+        imports,
+    };
+}
+export function fromNodeToEntity(property, entityId) {
+    const entityName = nodeToValue(property.get("key").node);
+    const expression = property.get("value");
+    const id = entityId ?? getSbElementId(property.node);
+    return entityParser.toValue(expression, {
+        key: entityName,
+        id,
+    });
+}
+export function getScope(fileName, file) {
+    if (!file || !file.ast) {
+        return null;
+    }
+    const clonedAst = transformFromAstSync(file.ast, undefined, { ast: true });
+    if (!clonedAst?.ast) {
+        throw new Error("Failed to clone AST for file " + fileName);
+    }
+    const ast = clonedAst.ast;
+    if (!ast) {
+        throw new Error("Failed to parse AST for file " + fileName);
+    }
+    try {
+        const scope = parseSbScopeDefinition(ast);
+        if (!scope) {
+            return null;
+        }
+        const scopeId = scope.id;
+        supplementElementIds({ fileName, ast, shouldModifyAst: true, scopeId });
+        const entities = scope.scopeEntities?.get("properties").reduce((acc, property) => {
+            if (property.isObjectProperty()) {
+                const entity = fromNodeToEntity(property);
+                if (entity) {
+                    acc[entity.name] = entity;
+                }
+            }
+            return acc;
+        }, {}) ?? {};
+        return {
+            entities: entities,
+            scopeName: scope.name,
+            scopeId: scope.id,
+        };
+    }
+    catch (_e) {
+        return null;
+    }
+}
+// sb scope utils
+/**
+ * Builds a map of scope usages within files
+ * @param ast The AST to analyze
+ * @param filePath The path of the file being analyzed
+ * @param scopeDefinitions List of scope definitions (name and entities)
+ * @param scopeNameToScopeUsage Existing map to update (optional)
+ * @returns Updated map of scope usages
+ */
+export function buildScopeDestructuredUsageMap(ast, filePath, scopeNames, scopeNameToScopeUsage = {}) {
+    traverse(ast, {
+        // Look for variable declarations like: const { Entity1 } = ScopeName;
+        VariableDeclaration(path) {
+            const declarations = path.get("declarations");
+            for (const declaration of declarations) {
+                if (!declaration.isVariableDeclarator())
+                    continue;
+                const id = declaration.get("id");
+                const init = declaration.get("init");
+                // Check if this is a destructuring assignment
+                if (id.isObjectPattern() && init.isIdentifier()) {
+                    const scopeName = init.node.name;
+                    // Check if the identifier is a known scope
+                    if (scopeNames.has(scopeName)) {
+                        // Initialize the nested structure if it doesn't exist
+                        if (!scopeNameToScopeUsage[scopeName]) {
+                            scopeNameToScopeUsage[scopeName] = {};
+                        }
+                        if (!scopeNameToScopeUsage[scopeName][filePath]) {
+                            scopeNameToScopeUsage[scopeName][filePath] = [];
+                        }
+                        // Add this usage to the map
+                        scopeNameToScopeUsage[scopeName][filePath].push(path);
+                    }
+                }
+            }
+        },
+    });
+    return scopeNameToScopeUsage;
+}
+/**
+ * Updates all scope usages to include the complete list of entity names
+ * @param scopeUsages Map of file paths to NodePaths where the scope is used
+ * @param entityNames Complete list of entity names to include in all usages
+ */
+export function updateScopeUsages(scopeUsages, entityNames) {
+    // Process each file's usages
+    Object.values(scopeUsages).forEach((usages) => {
+        usages.forEach((usage) => {
+            if (usage.isVariableDeclaration()) {
+                // Handle variable declarations: const { Entity1 } = Scope;
+                const declarations = usage.get("declarations");
+                for (const declaration of declarations) {
+                    if (!declaration.isVariableDeclarator())
+                        continue;
+                    const id = declaration.get("id");
+                    if (id.isObjectPattern()) {
+                        const newProperties = entityNames.map((name) => objectProperty(identifier(name), identifier(name), false, // computed
+                        true));
+                        id.node.properties = newProperties;
+                    }
+                }
+            }
+        });
+    });
+}
+/**
+ * Adds scope destructuring and imports to a component based on a JSX element locator
+ * @param elementPath Path to the JSX element that serves as the locator
+ * @param scopeDef Scope definition containing name, entities, and file path
+ * @param componentFilePath Path to the component file (for relative import calculation)
+ * @returns The newly created destructuring node path or null if failed
+ */
+export function addScopeToComponent({ elementLocation, scopeDefinition, }) {
+    // Find the function component or class that contains this JSX element
+    const componentPath = findEnclosingComponent(elementLocation);
+    if (!componentPath) {
+        throw new Error("Could not find enclosing component for the JSX element");
+    }
+    return addScopeDestructuring(componentPath, scopeDefinition);
+}
+function findEnclosingComponent(elementPath) {
+    let currentPath = elementPath;
+    while (currentPath) {
+        // Check for component types
+        if (currentPath.isFunctionDeclaration() ||
+            currentPath.isArrowFunctionExpression() ||
+            currentPath.isFunctionExpression() ||
+            currentPath.isClassDeclaration()) {
+            return currentPath;
+        }
+        // Move up the tree
+        currentPath = currentPath.parentPath;
+    }
+    return null;
+}
+/**
+ * Adds scope destructuring to the component body
+ * @param componentPath Path to the component declaration
+ * @param scopeDef Scope definition containing name and entities
+ * @returns The newly created destructuring node path or null if failed
+ */
+function addScopeDestructuring(componentPath, scopeDefinition) {
+    // Create the destructuring variable declaration
+    // const { Entity1, Entity2 } = ScopeName;
+    const uniqueEntityNames = [...new Set(scopeDefinition.entityNames)];
+    const destructuringDeclaration = variableDeclaration("const", [
+        variableDeclarator(objectPattern(uniqueEntityNames.map((name) => objectProperty(identifier(name), identifier(name), false, // computed
+        true))), identifier(scopeDefinition.name)),
+    ]);
+    let addedNodePath = null;
+    if (componentPath.isFunctionDeclaration() ||
+        componentPath.isFunctionExpression() ||
+        componentPath.isArrowFunctionExpression()) {
+        // For function components, add at the start of the function body
+        let body = componentPath.get("body");
+        if (Array.isArray(body)) {
+            body = body[0];
+            if (!body)
+                return null;
+        }
+        body = body;
+        if (body.isBlockStatement()) {
+            // Function with block body: function Component() { ... }
+            const [newPath] = body.unshiftContainer("body", destructuringDeclaration);
+            addedNodePath = newPath;
+        }
+        else {
+            // Arrow function with expression body: () => <div />
+            // Need to convert to block body first
+            const retStatement = returnStatement(body.node);
+            componentPath.node.body = blockStatement([
+                destructuringDeclaration,
+                retStatement,
+            ]);
+            // Get the path to the newly added node
+            const blockBody = componentPath.get("body");
+            addedNodePath = blockBody.get("body")[0];
+        }
+    }
+    else if (componentPath.isClassDeclaration()) {
+        // For class components, add to the render method
+        const renderMethod = findRenderMethod(componentPath);
+        if (renderMethod) {
+            const renderBody = renderMethod.get("body");
+            const [newPath] = renderBody.unshiftContainer("body", destructuringDeclaration);
+            addedNodePath = newPath;
+        }
+    }
+    return addedNodePath;
+}
+function findRenderMethod(classPath) {
+    const body = classPath.get("body");
+    const methods = body.get("body");
+    for (const method of methods) {
+        if (method.isClassMethod() &&
+            method.node.kind === "method" &&
+            method.get("key").isIdentifier() &&
+            method.get("key").node.name === "render") {
+            return method;
+        }
+    }
+    return null;
+}
+export function isComponentAlreadyUsingScope(elementLocation, usagesInFile) {
+    // Check if we have usage data for this scope and file
+    if (!usagesInFile?.length) {
+        return false;
+    }
+    // Find the component that contains this JSX element
+    const componentPath = findEnclosingComponent(elementLocation);
+    if (!componentPath) {
+        return false;
+    }
+    // Check if any of the usages are within the same component
+    for (const usage of usagesInFile) {
+        // Find the component containing this usage
+        let currentPath = usage;
+        let usageComponentPath = null;
+        // Traverse up the tree to find the containing component
+        while (currentPath) {
+            if (currentPath.isFunctionDeclaration() ||
+                currentPath.isArrowFunctionExpression() ||
+                currentPath.isFunctionExpression() ||
+                currentPath.isClassDeclaration()) {
+                usageComponentPath = currentPath;
+                break;
+            }
+            currentPath = currentPath.parentPath;
+        }
+        // If the usage is in the same component, return true
+        if (usageComponentPath && usageComponentPath === componentPath) {
+            return true;
+        }
+    }
+    return false;
+}
+/*
+    Example code:
+    export const Page1Scope = createSbScope<
+      {component: any}
+    >( ({ entities: { component, count } }: { entities: { component, count } }) => ({
+        count: SbVariable({ defaultValue: 0 }),
+       }),
+    );
+
+    export const Page1 = Page1Scope.entities;
+
+    SBDefintiion:
+      - name: Page1
+      - entityNames: ["count", "component"]
+      - scopeEntities: {count: SBVariable({defaultValue: 0})} (nodepath)
+      - scopeComponents: { component: any} (nodePath)
+      - destructuredEntitiesParam: { component, count } (nodePath)
+      - scopeFunction: ({ entities }: { component, count }) => {
+        count: SbVariable({ defaultValue: 0 }),
+      } (nodePath)
+  */
+export function parseSbScopeDefinition(ast) {
+    let scopeName = null;
+    let scopeScopeName = null; // e.g., "Page1Scope"
+    const entityNames = [];
+    let mainNode = null;
+    let scopeEntities = null;
+    let scopeComponents = null;
+    let destructuredEntitiesParam = null;
+    let scopeFunction = null;
+    const scopeNameToEntityId = {};
+    let scopeId = null;
+    // Helper function to extract entity names and IDs from object expression
+    function extractEntityNamesFromObject(objExpr) {
+        const properties = objExpr.get("properties");
+        properties.forEach((prop) => {
+            if (prop.isObjectProperty() && prop.node.key.type === "Identifier") {
+                const name = getIdentiferName(prop.node.key);
+                if (!name) {
+                    console.warn("Could not find name for entity");
+                    return;
+                }
+                // Add to entityNames if not already present
+                if (!entityNames.includes(name)) {
+                    entityNames.push(name);
+                }
+                let entityId = getSbElementId(prop.node);
+                if (!entityId) {
+                    entityId = getScopeElementId(scopeId, name);
+                    setSbElementId(prop.node, entityId);
+                }
+                if (entityId) {
+                    scopeNameToEntityId[name] = entityId;
+                }
+            }
+        });
+    }
+    // Helper function to find and process the returned object expression
+    function findReturnedObject(functionPath) {
+        const body = functionPath.get("body");
+        if (body.isObjectExpression()) {
+            // Arrow function with expression body: () => ({})
+            scopeEntities = body;
+            extractEntityNamesFromObject(body);
+        }
+        else if (body.isBlockStatement()) {
+            // Function with block body: () => { return {}; } or function() { return {}; }
+            body.traverse({
+                ReturnStatement(returnPath) {
+                    const argument = returnPath.get("argument");
+                    if (argument.isObjectExpression()) {
+                        scopeEntities = argument;
+                        extractEntityNamesFromObject(argument);
+                    }
+                },
+            });
+        }
+    }
+    // First pass: Find the export const Page1 = Page1Scope.entities statement to get the page name
+    traverse(ast, {
+        ExportNamedDeclaration(path) {
+            const declaration = path.get("declaration");
+            if (!declaration.isVariableDeclaration())
+                return;
+            const declarations = declaration.get("declarations");
+            for (const varDeclarator of declarations) {
+                if (!varDeclarator.isVariableDeclarator())
+                    continue;
+                const id = varDeclarator.get("id");
+                const init = varDeclarator.get("init");
+                // Check if this is the entities export (e.g., export const Page1 = Page1Scope.entities)
+                if (id.isIdentifier() &&
+                    init.isMemberExpression() &&
+                    init.get("property").isIdentifier()) {
+                    const property = init.get("property");
+                    if (property.isIdentifier() && property.node.name === "entities") {
+                        const object = init.get("object");
+                        if (object.isIdentifier()) {
+                            // Found the entities export, extract the page name from the left side of the assignment
+                            scopeName = id.node.name;
+                            scopeScopeName = object.node.name;
+                            scopeId = getStableScopeId(scopeName);
+                            break;
+                        }
+                    }
+                }
+            }
+        },
+    });
+    // Second pass: Find the scope definition and extract entity names
+    if (scopeName && scopeScopeName && scopeId) {
+        traverse(ast, {
+            VariableDeclaration(path) {
+                const declarations = path.get("declarations");
+                for (const varDeclarator of declarations) {
+                    if (!varDeclarator.isVariableDeclarator())
+                        continue;
+                    const id = varDeclarator.get("id");
+                    const init = varDeclarator.get("init");
+                    if (id.isIdentifier() && id.node.name === scopeScopeName) {
+                        if (init.isCallExpression() && init.get("callee").isIdentifier()) {
+                            const callee = init.get("callee");
+                            if (callee.isIdentifier() &&
+                                isSbScopeFunction(callee.node.name)) {
+                                // Extract entity names from the type parameters
+                                if (init.node.typeParameters) {
+                                    const typeParameters = init.get("typeParameters");
+                                    if (typeParameters.isTSTypeParameterInstantiation() &&
+                                        typeParameters.node.params.length > 0) {
+                                        const typeParams = typeParameters.get("params");
+                                        if (typeParams.length > 0) {
+                                            const typeParam = typeParams[0];
+                                            if (typeParam && typeParam.isTSTypeLiteral()) {
+                                                const members = typeParam.get("members");
+                                                members.forEach((member) => {
+                                                    if (member.isTSPropertySignature() &&
+                                                        member.get("key").isIdentifier()) {
+                                                        const key = member.get("key");
+                                                        if (key.isIdentifier()) {
+                                                            entityNames.push(key.node.name);
+                                                        }
+                                                    }
+                                                });
+                                                // Store reference to the type literal node for components
+                                                scopeComponents = typeParam;
+                                            }
+                                        }
+                                    }
+                                }
+                                // Extract entity names from the function argument
+                                if (init.node.arguments.length > 0) {
+                                    const args = init.get("arguments");
+                                    if (args.length > 0) {
+                                        const funcArg = args[0];
+                                        // Handle both arrow functions and regular functions
+                                        if (funcArg &&
+                                            (funcArg.isArrowFunctionExpression() ||
+                                                funcArg.isFunctionExpression())) {
+                                            scopeFunction = funcArg;
+                                            // Handle parameters
+                                            const params = funcArg.get("params");
+                                            if (params &&
+                                                Array.isArray(params) &&
+                                                params.length > 0) {
+                                                const param = params[0];
+                                                if (param && param.isObjectPattern()) {
+                                                    destructuredEntitiesParam = param;
+                                                }
+                                            }
+                                            // Find and process the returned object
+                                            findReturnedObject(funcArg);
+                                        }
+                                    }
+                                }
+                                // Set mainNode to the createSbScope call expression
+                                mainNode = init;
+                            }
+                        }
+                    }
+                }
+            },
+        });
+    }
+    if (!scopeName || !mainNode || !scopeId || !scopeFunction || !scopeEntities) {
+        throw new Error("Failed to parse scope definition: missing required elements for scope creation");
+    }
+    // Remove duplicates from entityNames if any
+    const uniqueEntityNames = [...new Set(entityNames)];
+    return {
+        name: scopeName,
+        entityNames: uniqueEntityNames,
+        mainNode,
+        scopeEntities,
+        scopeComponents,
+        id: scopeId,
+        scopeNameToEntityId,
+        destructuredEntitiesParam,
+        scopeFunction,
+    };
+}
+export function findBindComponentsInScopeUsage(usage) {
+    const componentPath = findEnclosingComponent(usage);
+    if (!componentPath) {
+        return [];
+    }
+    const allBindNames = findBindNamesInComponentPath(componentPath);
+    return Array.from(new Set(allBindNames));
+}
+function findBindNamesInComponentPath(componentPath) {
+    const bindNames = [];
+    componentPath.traverse({
+        JSXElement(path) {
+            const bindAttribute = path
+                .get("openingElement")
+                .get("attributes")
+                .find((n) => n.isJSXAttribute() && getIdentiferName(n.node.name) === "bind");
+            if (bindAttribute) {
+                const bindName = extractNameFromBindAttribute(bindAttribute.node, true);
+                if (bindName) {
+                    bindNames.push(bindName);
+                }
+            }
+        },
+    });
+    return bindNames;
+}
+/**
+ * Creates an empty scope definition with the given scope name.
+ * This generates a minimal scope with no entities or components and returns the parsed definition.
+ * Useful as a fallback when components are missing and need to be initialized.
+ *
+ * @param scopeName - The name of the scope (e.g., "Page1")
+ * @returns A parsed SbScopeDefinition with empty entities and components
+ */
+export function createEmptyScopeDefinition(scopeName) {
+    const code = `const ${scopeName}Scope = createSbScope<{}>(() => ({}));
+export const ${scopeName} = ${scopeName}Scope.entities;`;
+    const ast = parse(code, {
+        sourceType: "module",
+        plugins: ["typescript", "jsx"],
+    });
+    return parseSbScopeDefinition(ast);
+}
+/**
+ * Adds type parameters to an existing createSbScope call if they don't exist.
+ * This function modifies the AST directly by adding a TypeScript type parameter
+ * to the createSbScope call expression.
+ *
+ * @param scopeDefinition - The scope definition containing the AST nodes
+ * @returns The scope definition with type parameters added (modifies the scope definition in place)
+ */
+export function addTypeParametersToScope(scopeDefinition) {
+    // Get the createSbScope call expression
+    const mainPath = scopeDefinition.mainNode;
+    // Check if type parameters already exist
+    if (mainPath.node.typeParameters) {
+        const typeParams = mainPath.node.typeParameters.params;
+        if (typeParams.length > 0 && t.isTSTypeLiteral(typeParams[0])) {
+            return scopeDefinition;
+        }
+    }
+    const emptyScope = createEmptyScopeDefinition(scopeDefinition.name);
+    const typeParameterInstantiation = emptyScope.mainNode.node.typeParameters;
+    // Add type parameters to the AST
+    mainPath.node.typeParameters = typeParameterInstantiation;
+    // Add the type literal to the scope definition
+    scopeDefinition.scopeComponents = emptyScope.scopeComponents;
+    return scopeDefinition;
+}
+/**
+ * Utility to update the destructured entities parameter in function-based scopes
+ * Handles both cases:
+ * 1. ({ entities }) => ... (needs to add destructuring)
+ * 2. () => ... (needs to add entire parameter)
+ */
+export function updateDestructuredEntitiesParam(scopeDef) {
+    const uniqueEntityNames = [...new Set(scopeDef.entityNames)];
+    // If no entities, just ensure we have a basic parameter structure
+    if (uniqueEntityNames.length === 0) {
+        // For empty scopes, we can use either ({ entities }) or () format
+        // We'll standardize on () for empty scopes
+        if (scopeDef.scopeFunction.node.params.length > 0) {
+            scopeDef.scopeFunction.node.params = [];
+            scopeDef.destructuredEntitiesParam = null; // Clear the reference
+        }
+        return;
+    }
+    // Create the entities destructuring pattern
+    const entitiesDestructuring = objectPattern(uniqueEntityNames.map((name) => objectProperty(identifier(name), identifier(name), false, // computed
+    true)));
+    const entitiesProperty = objectProperty(identifier("entities"), entitiesDestructuring);
+    const mainDestructuringPattern = objectPattern([entitiesProperty]);
+    // Case 1: Function already has parameters
+    if (scopeDef.scopeFunction.node.params.length > 0) {
+        const firstParam = scopeDef.scopeFunction.get("params")[0];
+        if (firstParam && firstParam.isObjectPattern()) {
+            // Update existing object pattern
+            firstParam.node.properties = [entitiesProperty];
+            scopeDef.destructuredEntitiesParam = firstParam;
+        }
+        else if (firstParam) {
+            // Replace non-object parameter with object pattern
+            firstParam.replaceWith(mainDestructuringPattern);
+            scopeDef.destructuredEntitiesParam = scopeDef.scopeFunction.get("params")[0];
+        }
+    }
+    else {
+        // Case 2: Function has no parameters - add the destructuring parameter
+        scopeDef.scopeFunction.node.params = [mainDestructuringPattern];
+        scopeDef.destructuredEntitiesParam = scopeDef.scopeFunction.get("params")[0];
+    }
+}
+//# sourceMappingURL=scope.js.map