@superblocksteam/vite-plugin-file-sync 2.0.55 → 2.0.56-next.0

package/dist/sb-scope-manager.js

@@ -1,678 +0,0 @@
-import path from "node:path";
-import * as t from "@babel/types";
-import { getStableEntityId, getStableScopeId, } from "@superblocksteam/library-shared";
-import { sbEntitySymbol } from "@superblocksteam/library-shared/types";
-import { TracedEventEmitter } from "@superblocksteam/shared";
-import { SCOPE_FILE } from "./file-system-helpers.js";
-import { supplementElementIds } from "./parsing/ids.js";
-import { EXTERNAL_LIBRARY_OPTIONS } from "./parsing/imports.js";
-import { getVariableReferences } from "./parsing/jsx.js";
-import { buildScopeDestructuredUsageMap, fromEntityToNode, fromNodeToEntity, updateScopeUsages, addScopeToComponent, isComponentAlreadyUsingScope, parseSbScopeDefinition, updateEntityNode, findBindComponentsInScopeUsage, addTypeParametersToScope, updateDestructuredEntitiesParam, updateScopeNameInOptions, renameScopeVariableDeclaration, updateScopeImports, } from "./parsing/scope.js";
-import { addImport, getImportPath } from "./parsing/util.js";
-import { deleteEntityInAst } from "./refactor/entities.js";
-import { renameEntityInJavascript } from "./refactor/javascript.js";
-export class SbScopeManager extends TracedEventEmitter {
-    // maps file name to scope definition
-    pageAndAppScopes = new Map();
-    scopeIdToFilePath = {};
-    sourceTracker;
-    filePathsWithDuplicateComponentNames = new Set();
-    // this maps scope name to file name to the node where the scope is being spread
-    scopeNameToScopeUsage = {};
-    constructor(sourceTracker, tracer) {
-        super(tracer, { captureRejections: true });
-        this.sourceTracker = sourceTracker;
-    }
-    parseScopes(fileMeta) {
-        const scopeFiles = Object.keys(fileMeta).filter((filePath) => filePath.endsWith(SCOPE_FILE));
-        const nonScopeFiles = Object.keys(fileMeta).filter((filePath) => !scopeFiles.includes(filePath));
-        // get scope defs first
-        for (const scopeFile of scopeFiles) {
-            if (!fileMeta[scopeFile]) {
-                console.error("Scope file not found", scopeFile);
-                return;
-            }
-            const { ast } = fileMeta[scopeFile];
-            if (!ast) {
-                console.error("AST not found for scope file", scopeFile);
-                return;
-            }
-            try {
-                const scopeDefinition = parseSbScopeDefinition(ast);
-                this.pageAndAppScopes.set(scopeFile, scopeDefinition);
-                this.scopeIdToFilePath[scopeDefinition.id] = scopeFile;
-                const { idMap } = supplementElementIds({
-                    fileName: scopeFile,
-                    ast,
-                    shouldModifyAst: false,
-                    scopeId: scopeDefinition.id,
-                });
-                idMap.forEach((path, id) => {
-                    this.sourceTracker.setElementToLocation(id, path);
-                    this.sourceTracker.setElementToFilePath(id, scopeFile);
-                });
-            }
-            catch (e) {
-                console.error("Error parsing scope definition", e);
-            }
-        }
-        // look for scope usages in non-scope files
-        for (const nonScopeFile of nonScopeFiles) {
-            if (!fileMeta[nonScopeFile])
-                return;
-            const { ast } = fileMeta[nonScopeFile];
-            if (!ast)
-                return;
-            this.getScopeUsage(ast, nonScopeFile);
-        }
-        this.reconcileBindPropertiesAndScopeDefinitions();
-    }
-    /**
-     * Resets the scope tracking for a given file path. This function handles two cases:
-     * 1. For scope files (ending with SCOPE_FILE):
-     *    - Removes the existing scope definition
-     *    - Re-parses the scope definition from the AST
-     *    - Updates the scope tracking maps with the new definition
-     * 2. For non-scope files:
-     *    - Removes all existing scope usages for the file
-     *    - Re-parses and adds new scope usages from the AST
-     *
-     * @param filePath - The path of the file to reset scope tracking for
-     */
-    resetScope(filePath) {
-        if (filePath.endsWith(SCOPE_FILE)) {
-            const scopeDef = this.pageAndAppScopes.get(filePath);
-            if (!scopeDef) {
-                return [];
-            }
-            this.pageAndAppScopes.delete(filePath);
-            const currentFiles = this.sourceTracker.getCurrentFiles();
-            const ast = currentFiles[filePath]?.ast;
-            if (!ast) {
-                console.error("AST not found for scope file", filePath);
-                return [];
-            }
-            const scopeDefinition = parseSbScopeDefinition(ast);
-            this.pageAndAppScopes.set(filePath, scopeDefinition);
-            this.scopeIdToFilePath[scopeDefinition.id] = filePath;
-            const { idMap } = supplementElementIds({
-                fileName: filePath,
-                ast,
-                shouldModifyAst: false,
-                scopeId: scopeDefinition.id,
-            });
-            idMap.forEach((path, id) => {
-                this.sourceTracker.setElementToLocation(id, path);
-                this.sourceTracker.setElementToFilePath(id, filePath);
-            });
-        }
-        else {
-            // remove old scope usages for this file
-            for (const scopeName of Object.keys(this.scopeNameToScopeUsage)) {
-                if (this.scopeNameToScopeUsage[scopeName]?.[filePath]) {
-                    delete this.scopeNameToScopeUsage[scopeName][filePath];
-                }
-            }
-            // re-add scope usages for this file
-            const currentFiles = this.sourceTracker.getCurrentFiles();
-            const ast = currentFiles[filePath]?.ast;
-            if (!ast) {
-                console.error("AST not found for scope file", filePath);
-                return [];
-            }
-            this.getScopeUsage(ast, filePath);
-        }
-        return this.reconcileBindPropertiesAndScopeDefinitions();
-    }
-    getScopeDefinitionAndFilePathByNameOrId({ identifier, type, }) {
-        for (const [filePath, scopeDef] of this.pageAndAppScopes.entries()) {
-            if (type === "id" && scopeDef.id === identifier) {
-                return { scopeDefinition: scopeDef, filePath };
-            }
-            if (type === "name" && scopeDef.name === identifier) {
-                return { scopeDefinition: scopeDef, filePath };
-            }
-        }
-        return { scopeDefinition: undefined, filePath: undefined };
-    }
-    addScopeDestructuringForComponent({ elementLocation, scopeName, componentFilePath, }) {
-        if (isComponentAlreadyUsingScope(elementLocation, this.scopeNameToScopeUsage?.[scopeName]?.[componentFilePath])) {
-            return;
-        }
-        // Find the scope definition
-        const { scopeDefinition: scopeDef } = this.getScopeDefinitionAndFilePathByNameOrId({
-            identifier: scopeName,
-            type: "name",
-        });
-        if (!scopeDef) {
-            this.emit("scopeNotFound", scopeName);
-            return;
-        }
-        // Add scope to the component
-        const addedNodePath = addScopeToComponent({
-            elementLocation,
-            scopeDefinition: scopeDef,
-        });
-        // Update the scope usage map
-        if (addedNodePath) {
-            if (!this.scopeNameToScopeUsage[scopeName]) {
-                this.scopeNameToScopeUsage[scopeName] = {};
-            }
-            if (!this.scopeNameToScopeUsage[scopeName][componentFilePath]) {
-                this.scopeNameToScopeUsage[scopeName][componentFilePath] = [];
-            }
-            this.scopeNameToScopeUsage[scopeName][componentFilePath].push(addedNodePath);
-        }
-    }
-    getDefaultScopeDefForFile(filePath) {
-        const scopeFilePath = path.join(path.dirname(filePath), SCOPE_FILE);
-        return this.pageAndAppScopes.get(scopeFilePath);
-    }
-    getAndUpdateScopeImportsForCodeSnippet({ jsxAttribute, codeFilePath, existingImports, elementLocation, }) {
-        const defaultScopeDef = this.getDefaultScopeDefForFile(codeFilePath);
-        // We are searching for all references of different global scope or entities inside the default scope
-        // For example for an element in Page1, we want to search for "App", "PageEntity1", "PageEntity2", ..etc
-        const unimportedScopes = this.findUnimportedScopes(existingImports);
-        const referencesToSearch = new Set([
-            ...unimportedScopes,
-            ...(defaultScopeDef?.entityNames ?? []),
-        ]);
-        const usedReferences = getVariableReferences(jsxAttribute, referencesToSearch);
-        const usedScopes = usedReferences.filter((reference) => unimportedScopes.has(reference));
-        // if there are any references of default scope variables, make sure
-        // to import the default scope and update all
-        if (usedScopes.length !== referencesToSearch.size && defaultScopeDef) {
-            usedScopes.push(defaultScopeDef.name);
-            this.addScopeDestructuringForComponent({
-                elementLocation,
-                scopeName: defaultScopeDef.name,
-                componentFilePath: codeFilePath,
-            });
-            this.updateScopeUsages(defaultScopeDef.name, defaultScopeDef.entityNames);
-        }
-        const result = usedScopes
-            .map((scopeName) => {
-            const { scopeDefinition: scopeDef, filePath } = this.getScopeDefinitionAndFilePathByNameOrId({
-                identifier: scopeName,
-                type: "name",
-            });
-            if (!scopeDef || !filePath) {
-                return null;
-            }
-            const importPath = getImportPath(codeFilePath, filePath);
-            return {
-                importPath,
-                importName: scopeDef.name,
-            };
-        })
-            .filter((item) => item !== null);
-        return result;
-    }
-    findUnimportedScopes(existingImports) {
-        const unimportedScopes = new Set();
-        const allScopeNames = Array.from(this.pageAndAppScopes.values()).map((scope) => scope.name);
-        for (const scopeName of allScopeNames) {
-            if (existingImports?.[scopeName]) {
-                // already imported in this file, dont need to import
-                continue;
-            }
-            unimportedScopes.add(scopeName);
-        }
-        return unimportedScopes;
-    }
-    /**
-     * Manage page scope
-     */
-    /**
-     * Rename a page and update the scope definition, ensure that the new scope file
-     * has been written to the file system and parsed before calling this function.
-     */
-    renamePageScope({ oldName, newName, newFilePath, indexAst, scopeAst, }) {
-        const scopeDef = this.pageAndAppScopes.get(newFilePath);
-        if (!scopeDef) {
-            throw new Error(`Scope definition not found for file ${newFilePath}`);
-        }
-        updateScopeNameInOptions(scopeDef, newName);
-        scopeDef.id = getStableScopeId(newName);
-        scopeDef.name = newName;
-        renameScopeVariableDeclaration(oldName, newName, scopeAst);
-        updateScopeImports(oldName, newName, indexAst);
-        const oldScopeDef = this.getScopeDefinitionAndFilePathByNameOrId({
-            identifier: oldName,
-            type: "name",
-        });
-        if (oldScopeDef.filePath) {
-            this.deleteScope(oldScopeDef.filePath);
-        }
-    }
-    /**
-     Manage scope entities
-     */
-    addScopeEntity(scopeId, payload) {
-        // Find the scope definition
-        const { scopeDefinition: scopeDef, filePath } = this.getScopeDefinitionAndFilePathByNameOrId({
-            identifier: scopeId,
-            type: "id",
-        });
-        if (!scopeDef) {
-            console.warn("Scope definition not found for scopeId", scopeId);
-            this.emit("scopeNotFound", scopeId);
-            return [];
-        }
-        const { entity: entityAst, imports } = fromEntityToNode({
-            [sbEntitySymbol]: true,
-            type: payload.type,
-            name: payload.name,
-            ...payload.attributes,
-        });
-        // Use the existing scopeObject path
-        const objPath = scopeDef.scopeEntities;
-        if (!objPath || !objPath.isObjectExpression()) {
-            console.warn("Scope object path not found for scopeId", scopeId);
-            this.emit("scopeNotFound", scopeId);
-            return [];
-        }
-        // Add the entity to the object expression
-        const [newEntityNode] = objPath.pushContainer("properties", entityAst);
-        // Add all required imports
-        imports.forEach(({ importName, importPath }) => {
-            addImport({
-                path: objPath,
-                importName,
-                importPath,
-                onAdd: () => {
-                    // todo: we could track this in the fileToMeta map
-                },
-            });
-        });
-        const id = getStableEntityId(scopeId, payload.name);
-        this.sourceTracker.setElementToLocation(id, newEntityNode);
-        this.sourceTracker.setElementToFilePath(id, filePath);
-        scopeDef.entityNames.push(payload.name);
-        scopeDef.scopeNameToEntityId[payload.name] = id;
-        const updatedFiles = this.updateScopeUsages(scopeDef.name, scopeDef.entityNames);
-        updateDestructuredEntitiesParam(scopeDef);
-        return [...updatedFiles, filePath];
-    }
-    updateScopeEntity({ entityId, updates }) {
-        const entityNode = this.sourceTracker.getElementToLocation(entityId);
-        const codeFilePath = this.sourceTracker.getElementToFilePath(entityId);
-        if (!entityNode || !t.isObjectProperty(entityNode.node)) {
-            throw new Error("Entity to update not found " + entityId);
-        }
-        if (!codeFilePath) {
-            throw new Error("File path not found for entity: " + entityId);
-        }
-        const scopeDef = this.pageAndAppScopes.get(codeFilePath);
-        if (!scopeDef) {
-            throw new Error("Scope definition not found for file: " + codeFilePath);
-        }
-        const newEntity = fromNodeToEntity(entityNode, entityId);
-        if (!newEntity) {
-            throw new Error("Entity could not be created from node: " + entityId);
-        }
-        const { imports } = updateEntityNode(entityNode, updates ?? {}, entityId);
-        // looke for scope & external imports
-        const existingImports = this.sourceTracker.getCurrentFiles()[codeFilePath].imports;
-        const unimportedScopes = this.findUnimportedScopes(existingImports);
-        const scopeReferences = getVariableReferences(entityNode.node, unimportedScopes);
-        const scopeImports = scopeReferences
-            .map((scopeName) => {
-            const { scopeDefinition: scopeDef, filePath } = this.getScopeDefinitionAndFilePathByNameOrId({
-                identifier: scopeName,
-                type: "name",
-            });
-            if (!scopeDef || !filePath) {
-                return null;
-            }
-            const importPath = getImportPath(codeFilePath, filePath);
-            return {
-                importPath,
-                importName: scopeDef.name,
-            };
-        })
-            .filter((item) => item !== null);
-        let allImports = [...imports, ...scopeImports];
-        for (const externalLibrary of EXTERNAL_LIBRARY_OPTIONS) {
-            const referencedGlobalFunctions = getVariableReferences(entityNode.node, externalLibrary.imports).map((funcName) => {
-                return {
-                    importPath: externalLibrary.library,
-                    importName: funcName,
-                };
-            });
-            allImports = [...allImports, ...referencedGlobalFunctions];
-        }
-        allImports.forEach(({ importName, importPath }) => {
-            addImport({
-                importPath,
-                importName,
-                path: entityNode.parentPath,
-                onAdd: () => { },
-            });
-        });
-        return codeFilePath;
-    }
-    deleteScopeEntity(entityId) {
-        const entityNode = this.sourceTracker.getElementToLocation(entityId);
-        if (!entityNode) {
-            console.warn("Entity to delete not found", entityId);
-            this.emit("entityNotFound", entityId, "deleteScopeEntity");
-            return {
-                changedFiles: [],
-                deletedEntitiesNames: [],
-            };
-        }
-        const entityName = (entityNode?.node?.key).name;
-        const filePath = this.sourceTracker.getElementToFilePath(entityId);
-        if (!entityNode || !t.isObjectProperty(entityNode.node)) {
-            throw new Error("Entity to delete not found" + entityId);
-        }
-        if (!filePath) {
-            throw new Error("File path not found for entity: " + entityId);
-        }
-        const scopeDef = this.pageAndAppScopes.get(filePath);
-        if (!scopeDef) {
-            throw new Error("Scope definition not found for file: " + filePath);
-        }
-        entityNode.remove();
-        this.sourceTracker.deleteElementToLocation(entityId);
-        this.sourceTracker.deleteElementToFilePath(entityId);
-        scopeDef.entityNames = scopeDef.entityNames.filter((name) => name !== entityName);
-        delete scopeDef.scopeNameToEntityId[entityName];
-        const updatedFiles = this.updateScopeUsages(scopeDef.name, scopeDef.entityNames);
-        updatedFiles.forEach((file) => {
-            const fileMeta = this.sourceTracker.getCurrentFiles()[file];
-            if (fileMeta && fileMeta.ast) {
-                deleteEntityInAst({
-                    entityName,
-                    ast: fileMeta.ast,
-                });
-            }
-        });
-        updateDestructuredEntitiesParam(scopeDef);
-        return {
-            changedFiles: [...updatedFiles, filePath],
-            deletedEntitiesNames: [entityName],
-        };
-    }
-    getReferencingFilesByScopeName(scopeName) {
-        const referencingFiles = new Set();
-        if (scopeName && this.scopeNameToScopeUsage[scopeName]) {
-            Object.keys(this.scopeNameToScopeUsage[scopeName]).forEach((filePath) => {
-                referencingFiles.add(filePath);
-            });
-        }
-        return referencingFiles;
-    }
-    getReferencingFilesByEntityId(entityId) {
-        let referencingFiles = new Set();
-        const filePath = this.sourceTracker.getElementToFilePath(entityId);
-        if (filePath) {
-            referencingFiles.add(filePath);
-            const scopeDef = this.pageAndAppScopes.get(filePath);
-            if (scopeDef) {
-                const scopeName = scopeDef.name;
-                referencingFiles = new Set([
-                    ...referencingFiles,
-                    ...this.getReferencingFilesByScopeName(scopeName),
-                ]);
-            }
-        }
-        return referencingFiles;
-    }
-    getReferencingFilesByEntityIdAndScopeName(entityId, scopeName) {
-        return new Set([
-            ...this.getReferencingFilesByEntityId(entityId),
-            ...this.getReferencingFilesByScopeName(scopeName),
-        ]);
-    }
-    renameScopeEntity({ entityId, newName, oldName, }) {
-        const filePath = this.sourceTracker.getElementToFilePath(entityId);
-        if (!filePath) {
-            return {
-                changedFiles: [],
-                scopeFile: filePath,
-            };
-        }
-        const scopeDef = this.pageAndAppScopes.get(filePath);
-        if (!scopeDef) {
-            return {
-                changedFiles: [],
-                scopeFile: filePath,
-            };
-        }
-        const entityNode = this.sourceTracker.getElementToLocation(entityId);
-        if (!entityNode || !t.isObjectProperty(entityNode.node)) {
-            return {
-                changedFiles: [],
-            };
-        }
-        const key = entityNode.get("key");
-        if (key) {
-            key.replaceWith(t.identifier(newName));
-        }
-        // Update references in all values in the scope file
-        const scopeEntities = scopeDef.scopeEntities;
-        if (scopeEntities) {
-            renameEntityInJavascript({
-                oldName,
-                newName,
-                nodePath: scopeEntities,
-            });
-        }
-        scopeDef.entityNames = scopeDef.entityNames.map((name) => name === oldName ? newName : name);
-        // clear references to old name and set references to new name
-        const newEntityId = getStableEntityId(scopeDef.id, newName);
-        this.sourceTracker.deleteElementToLocation(entityId);
-        this.sourceTracker.deleteElementToFilePath(entityId);
-        scopeDef.scopeNameToEntityId[newName] = newEntityId;
-        this.sourceTracker.setElementToLocation(newEntityId, entityNode);
-        this.sourceTracker.setElementToFilePath(newEntityId, filePath);
-        delete scopeDef.scopeNameToEntityId[oldName];
-        const updatedFiles = this.updateScopeUsages(scopeDef.name, scopeDef.entityNames);
-        updateDestructuredEntitiesParam(scopeDef);
-        return {
-            changedFiles: [...updatedFiles, filePath],
-            scopeFile: filePath,
-        };
-    }
-    /*
-     Manage scope component types
-    */
-    addScopeComponent(scopeName, componentName) {
-        const { scopeDefinition: currentScope, filePath } = this.getScopeDefinitionAndFilePathByNameOrId({
-            identifier: scopeName,
-            type: "name",
-        });
-        if (!currentScope) {
-            this.emit("scopeNotFound", scopeName);
-            return [];
-        }
-        const scopeDef = currentScope.scopeComponents
-            ? currentScope
-            : addTypeParametersToScope(currentScope);
-        if (!scopeDef.scopeComponents) {
-            throw new Error("Scope components not found, even though we added type parameters");
-        }
-        const newProperty = t.tsPropertySignature(t.identifier(componentName), t.tsTypeAnnotation(t.tsAnyKeyword()));
-        const newComponents = scopeDef.scopeComponents.pushContainer("members", newProperty);
-        // Update the entity names list
-        scopeDef.entityNames.push(componentName);
-        // Update all scope usages to include the new component
-        const updatedFiles = this.updateScopeUsages(scopeDef.name, scopeDef.entityNames);
-        const entityId = getStableEntityId(scopeDef.id, componentName);
-        this.sourceTracker.setElementToLocation(entityId, newComponents[0]);
-        this.sourceTracker.setElementToFilePath(entityId, filePath);
-        updateDestructuredEntitiesParam(scopeDef);
-        return [...updatedFiles, filePath];
-    }
-    deleteScopeComponent(scopeName, componentName) {
-        const { scopeDefinition: scopeDef } = this.getScopeDefinitionAndFilePathByNameOrId({
-            identifier: scopeName,
-            type: "name",
-        });
-        if (!scopeDef) {
-            return [];
-        }
-        const componentTypeId = getStableEntityId(scopeDef.id, componentName);
-        const componentNode = this.sourceTracker.getElementToLocation(componentTypeId);
-        const filePath = this.sourceTracker.getElementToFilePath(componentTypeId);
-        if (!componentNode ||
-            !t.isTSPropertySignature(componentNode.node) ||
-            !filePath) {
-            return [];
-        }
-        // Remove the component node from the AST
-        componentNode.remove();
-        // Clean up references
-        this.sourceTracker.deleteElementToLocation(componentTypeId);
-        this.sourceTracker.deleteElementToFilePath(componentTypeId);
-        // Update the entity names list
-        scopeDef.entityNames = scopeDef.entityNames.filter((name) => name !== componentName);
-        delete scopeDef.scopeNameToEntityId[componentName];
-        const updatedFiles = this.updateScopeUsages(scopeDef.name, scopeDef.entityNames);
-        updatedFiles.forEach((file) => {
-            const fileMeta = this.sourceTracker.getCurrentFiles()[file];
-            if (fileMeta && fileMeta.ast) {
-                deleteEntityInAst({
-                    entityName: componentName,
-                    ast: fileMeta.ast,
-                });
-            }
-        });
-        updateDestructuredEntitiesParam(scopeDef);
-        return [...updatedFiles, filePath];
-    }
-    getReferencingFiles(scopeName) {
-        const referencingFiles = new Set();
-        if (scopeName && this.scopeNameToScopeUsage[scopeName]) {
-            Object.keys(this.scopeNameToScopeUsage[scopeName]).forEach((filePath) => {
-                referencingFiles.add(filePath);
-            });
-        }
-        return referencingFiles;
-    }
-    getScopeFileByScopeName(scopeName) {
-        const { filePath: scopeFile } = this.getScopeDefinitionAndFilePathByNameOrId({
-            identifier: scopeName,
-            type: "name",
-        });
-        return scopeFile;
-    }
-    renameScopeComponent({ newName, oldName, scopeName, componentFilePath, }) {
-        if (!oldName) {
-            return this.addScopeComponent(scopeName, newName);
-        }
-        const { scopeDefinition: scopeDef, filePath: scopeFile } = this.getScopeDefinitionAndFilePathByNameOrId({
-            identifier: scopeName,
-            type: "name",
-        });
-        if (!scopeDef) {
-            return [];
-        }
-        const componentTypeId = getStableEntityId(scopeDef.id, oldName);
-        const filePath = this.sourceTracker.getElementToFilePath(componentTypeId);
-        if (!filePath) {
-            // this could happen if we're renaming a component that had a duplicate name with somthing else
-            return this.resetScope(scopeFile);
-        }
-        const componentNode = this.sourceTracker.getElementToLocation(componentTypeId);
-        if (!componentNode) {
-            // this could happen if we're renaming a component that had a duplicate name with somthing else
-            return this.resetScope(scopeFile);
-        }
-        // Update the key name in the AST
-        const key = componentNode.get("key");
-        if (key) {
-            key.replaceWith(t.identifier(newName));
-        }
-        // Update references in all values in the scope file
-        const scopeEntities = scopeDef.scopeEntities;
-        if (scopeEntities) {
-            renameEntityInJavascript({
-                oldName,
-                newName,
-                nodePath: scopeEntities,
-            });
-        }
-        // Update the entity names list
-        scopeDef.entityNames = scopeDef.entityNames.map((name) => name === oldName ? newName : name);
-        delete scopeDef.scopeNameToEntityId[oldName];
-        const updatedFiles = this.updateScopeUsages(scopeDef.name, scopeDef.entityNames);
-        // clear references to old name and set references to new name
-        this.sourceTracker.deleteElementToLocation(componentTypeId);
-        this.sourceTracker.deleteElementToFilePath(componentTypeId);
-        const newComponentTypeId = getStableEntityId(scopeDef.id, newName);
-        scopeDef.scopeNameToEntityId[newName] = newComponentTypeId;
-        this.sourceTracker.setElementToLocation(newComponentTypeId, componentNode);
-        this.sourceTracker.setElementToFilePath(newComponentTypeId, filePath);
-        updateDestructuredEntitiesParam(scopeDef);
-        // handle edge case with a user fixing duplicate names
-        if (this.filePathsWithDuplicateComponentNames.has(componentFilePath)) {
-            const reconciledFiles = this.reconcileBindPropertiesAndScopeDefinitions();
-            return [...updatedFiles, ...reconciledFiles, filePath];
-        }
-        return [...updatedFiles, filePath];
-    }
-    getScopeUsage(ast, filePath) {
-        const allScopeNames = new Set();
-        for (const [_, scopeDef] of this.pageAndAppScopes.entries()) {
-            allScopeNames.add(scopeDef.name);
-        }
-        buildScopeDestructuredUsageMap(ast, filePath, allScopeNames, this.scopeNameToScopeUsage);
-    }
-    reconcileBindPropertiesAndScopeDefinitions() {
-        this.filePathsWithDuplicateComponentNames.clear();
-        for (const [scopeName, scopeUsages] of Object.entries(this.scopeNameToScopeUsage)) {
-            const { scopeDefinition: scopeDef } = this.getScopeDefinitionAndFilePathByNameOrId({
-                identifier: scopeName,
-                type: "name",
-            });
-            if (!scopeDef) {
-                continue;
-            }
-            const missingComponents = new Set();
-            const seenNames = new Set();
-            for (const [filePath, usages] of Object.entries(scopeUsages)) {
-                for (const usage of usages) {
-                    const bindNames = findBindComponentsInScopeUsage(usage);
-                    for (const bindName of bindNames) {
-                        if (seenNames.has(bindName)) {
-                            this.filePathsWithDuplicateComponentNames.add(filePath);
-                        }
-                        seenNames.add(bindName);
-                        if (!scopeDef.entityNames.includes(bindName)) {
-                            missingComponents.add(bindName);
-                        }
-                    }
-                }
-            }
-            const updatedFiles = [];
-            // Add missing components to the scope definition
-            for (const missingComponent of missingComponents) {
-                updatedFiles.push(...this.addScopeComponent(scopeName, missingComponent));
-            }
-            return updatedFiles;
-        }
-        return [];
-    }
-    updateScopeUsages(scopeName, entityNames) {
-        const uniqueEntityNames = [...new Set(entityNames)];
-        const scopeUsages = this.scopeNameToScopeUsage[scopeName];
-        if (scopeUsages) {
-            updateScopeUsages(scopeUsages, uniqueEntityNames);
-            return Object.keys(scopeUsages);
-        }
-        return [];
-    }
-    deleteScope(scopeName) {
-        const scopeDef = this.pageAndAppScopes.get(scopeName);
-        if (!scopeDef) {
-            return [];
-        }
-        this.pageAndAppScopes.delete(scopeName);
-        delete this.scopeIdToFilePath[scopeDef.id];
-        delete this.scopeNameToScopeUsage[scopeName];
-    }
-}
-//# sourceMappingURL=sb-scope-manager.js.map