@superblocksteam/vite-plugin-file-sync 1.99.99-next.2 → 2.0.0-SNAPSHOT.2143e2e95d0107ab

package/dist/parsing/scope.js

@@ -1,669 +0,0 @@
-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