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

package/dist/source-tracker.js

@@ -1,22 +1,19 @@
 import path from "node:path";
 import { parse } from "@babel/parser";
 import * as t from "@babel/types";
-import { isPropertyInfo, Property, splitJSPath, splitJSPathAdvanced, } from "@superblocksteam/library-shared";
-import { SbEntityType, } from "@superblocksteam/library-shared/types";
+import { isPropertyInfo, splitJSPath, splitJSPathAdvanced, } from "@superblocksteam/library-shared";
 import { format } from "prettier";
 import { generateJSXAttribute, generateJSXElement, writeNestedProperty, } from "./codegen.js";
 import { ComponentsManager } from "./components-manager.js";
-import { SCOPE_FILE } from "./file-system-helpers.js";
 import { generate } from "./generate.js";
 import { generatePredictableId } from "./ids.js";
 import { getSbElementId, setSbElementId, supplementElementIds, } from "./parsing/ids.js";
 import { getRequiredImportsForProperty, EXTERNAL_LIBRARY_OPTIONS, } from "./parsing/imports.js";
-import { getDescriptiveName, getJSXAttributeName, getVariableReferences, isNamedComponent, } from "./parsing/jsx.js";
-import { getTagName, addImport, extractImportsFromAst, getImportPath, } from "./parsing/util.js";
-import { deleteEntityInAst } from "./refactor/entities.js";
+import { getDescriptiveName, getJSXAttributeName, getVariableReferences, } from "./parsing/jsx.js";
+import { getTagName, addImport, extractImportsFromAst, } from "./parsing/util.js";
 import { RenameManager } from "./rename-manager.js";
-import { SbScopeManager } from "./sb-scope-manager.js";
 import { getErrorMeta, getLogger } from "./util/logger.js";
+import { getScopeIdFromName } from "./util.js";
 const ATTRIBUTE_TYPES_WITH_STATE_ACCESS = ["COMPUTED", "TEMPLATE", "EVENT"];
 // File Explanation:
 // This file is responsible for tracking the source code of the application.
@@ -25,17 +22,12 @@ const ATTRIBUTE_TYPES_WITH_STATE_ACCESS = ["COMPUTED", "TEMPLATE", "EVENT"];
 // This information is used by the source code editor to provide features like drag and drop and property editing.
 export class SourceTracker {
     renameManager = new RenameManager();
-    sbScopeManager;
     elementToLocation = {};
     elementToFilePath = {};
-    scopeIdToFilePath = {};
-    sbScopeNamesToFilePath = {};
     newlyAddedCount = 0;
     fileToMeta = {};
     changedFiles = new Set();
-    constructor(tracer) {
-        this.sbScopeManager = new SbScopeManager(this, tracer);
-    }
+    constructor(_tracer) { }
     getCurrentFiles() {
         return this.fileToMeta;
     }
@@ -90,18 +82,8 @@ export class SourceTracker {
     deleteElementToFilePath(el) {
         delete this.elementToFilePath[el];
     }
-    getScopeDefinitionForPage(pageName) {
-        const { scopeDefinition } = this.sbScopeManager.getScopeDefinitionAndFilePathByNameOrId({
-            identifier: pageName,
-            type: "name",
-        });
-        return scopeDefinition;
-    }
-    getScopeDefinitionAndFilePathByNameOrId({ identifier, type, }) {
-        return this.sbScopeManager.getScopeDefinitionAndFilePathByNameOrId({
-            identifier,
-            type,
-        });
+    getScopeIdForPage(pageName) {
+        return getScopeIdFromName(pageName);
     }
     parseJsxFromEntrypoint({ files, }) {
         const parsedAsts = {};
@@ -129,7 +111,6 @@ export class SourceTracker {
             code,
         }));
         const parsedAsts = this.parseJsxFromEntrypoint({
-            // entryPointFilePath: rootDir + "/pages/page1/_index.tsx",
             files: fileContents,
         });
         Object.entries(parsedAsts).forEach(([file, ast]) => {
@@ -144,29 +125,23 @@ export class SourceTracker {
                 imports: extractImportsFromAst(ast),
             };
         });
-        // We always re-parse scopes because we either have new scopes we need to parse, or
-        // we've done a move/refactor of a named scope (pages)
-        this.sbScopeManager.parseScopes(this.fileToMeta);
+        // Parse JSX elements and track their locations
         Object.entries(parsedAsts).forEach(([file, ast]) => {
-            // scope files are handled by the sbScopeManager
-            if (!file.endsWith(SCOPE_FILE)) {
-                const { idMap } = supplementElementIds({
-                    fileName: file,
-                    ast,
-                    shouldModifyAst: false,
-                });
-                idMap.forEach((path, id) => {
-                    this.elementToLocation[id] = path;
-                    this.elementToFilePath[id] = file;
-                });
-            }
+            const { idMap } = supplementElementIds({
+                fileName: file,
+                ast,
+                shouldModifyAst: false,
+            });
+            idMap.forEach((path, id) => {
+                this.elementToLocation[id] = path;
+                this.elementToFilePath[id] = file;
+            });
         });
     };
     handleNonVisualChangeByDeletingIds = async (fileName, fileContents) => {
         const extension = path.extname(fileName);
         if (extension !== ".ts" && extension !== ".tsx")
             return;
-        const existingFile = fileName in this.fileToMeta;
         try {
             const astMap = this.parseJsxFromEntrypoint({
                 files: [{ fileName, code: fileContents }],
@@ -192,36 +167,15 @@ export class SourceTracker {
                 delete this.elementToLocation[key];
                 delete this.elementToFilePath[key];
             });
-            let changedFiles = [];
-            if (existingFile) {
-                changedFiles = this.sbScopeManager.resetScope(fileName);
-            }
-            else {
-                this.sbScopeManager.parseScopes({
-                    [fileName]: {
-                        code: fileContents,
-                        ast,
-                        imports: extractImportsFromAst(ast),
-                    },
-                });
-                changedFiles.push(fileName);
-            }
-            // scope file is handled by the sbScopeManager
-            if (!fileName.endsWith(SCOPE_FILE)) {
-                const { idMap } = supplementElementIds({
-                    fileName,
-                    ast,
-                    shouldModifyAst: false,
-                });
-                idMap.forEach((path, id) => {
-                    this.elementToLocation[id] = path;
-                    this.elementToFilePath[id] = fileName;
-                });
-            }
-            changedFiles.forEach((file) => {
-                if (file !== fileName) {
-                    this.changedFiles.add(file);
-                }
+            // Parse JSX elements and track their locations
+            const { idMap } = supplementElementIds({
+                fileName,
+                ast,
+                shouldModifyAst: false,
+            });
+            idMap.forEach((path, id) => {
+                this.elementToLocation[id] = path;
+                this.elementToFilePath[id] = fileName;
             });
             // Mark the file as changed
             this.changedFiles.add(fileName);
@@ -240,18 +194,6 @@ export class SourceTracker {
                 delete this.elementToFilePath[id];
             }
         });
-        // Clean up sb scope mappings
-        Object.entries(this.sbScopeNamesToFilePath).forEach(([scopeName, info]) => {
-            if (info.filePath === fileName) {
-                delete this.sbScopeNamesToFilePath[scopeName];
-            }
-        });
-        // Clean up scope ID mappings
-        Object.entries(this.scopeIdToFilePath).forEach(([scopeId, path]) => {
-            if (path === fileName) {
-                delete this.scopeIdToFilePath[scopeId];
-            }
-        });
     };
     updateFileContents(filePath, code) {
         const existingFile = this.fileToMeta[filePath];
@@ -343,132 +285,15 @@ export class SourceTracker {
             throw new Error("Error updating source tracker during move" + e.message);
         }
     };
-    addApi = async ({ pageName, apiName, }) => {
-        const { scopeDefinition, filePath: scopeFilePath } = this.sbScopeManager.getScopeDefinitionAndFilePathByNameOrId({
-            identifier: pageName,
-            type: "name",
-        });
-        if (!scopeDefinition || !scopeFilePath) {
-            throw new Error("Scope not found for page " + pageName);
-        }
-        if (scopeDefinition.entityNames.includes(apiName)) {
-            getLogger().warn(`API name ${apiName} already exists in scope for page ${pageName}. Ignoring scope update.`);
-            return scopeDefinition.id;
-        }
-        const changedFiles = this.sbScopeManager.addScopeEntity(scopeDefinition.id, {
-            type: SbEntityType.API,
-            name: apiName,
-            attributes: {},
-        });
-        changedFiles.forEach((file) => {
-            this.changedFiles.add(file);
-        });
-        return scopeDefinition.id;
-    };
-    deleteApi = ({ pageName, apiName, }) => {
-        const { scopeDefinition, filePath: scopeFilePath } = this.sbScopeManager.getScopeDefinitionAndFilePathByNameOrId({
-            identifier: pageName,
-            type: "name",
-        });
-        if (!scopeDefinition || !scopeFilePath) {
-            throw new Error("Scope not found for page " + pageName);
-        }
-        const entityId = scopeDefinition.scopeNameToEntityId[apiName];
-        if (!entityId) {
-            getLogger().warn("Entity ID not found for API " + apiName);
-            return;
-        }
-        const { changedFiles } = this.sbScopeManager.deleteScopeEntity(entityId);
-        const scopeFolder = path.dirname(scopeFilePath);
-        for (const filePath of Object.keys(this.fileToMeta)) {
-            if (filePath.startsWith(scopeFolder) && filePath.endsWith(".tsx")) {
-                const currentFile = this.fileToMeta[filePath];
-                if (!currentFile || !currentFile.ast) {
-                    throw new Error(`File not found for element ${filePath}`);
-                }
-                deleteEntityInAst({ entityName: apiName, ast: currentFile.ast });
-            }
-        }
-        changedFiles.forEach((file) => {
-            this.changedFiles.add(file);
-        });
-        return scopeDefinition.id;
-    };
-    addEntity = ({ scopeId, entity, }) => {
-        const changedFiles = this.sbScopeManager.addScopeEntity(scopeId, entity);
-        changedFiles.forEach((file) => {
-            this.changedFiles.add(file);
-        });
-    };
-    updateEntity = (payload) => {
-        const changedFile = this.sbScopeManager.updateScopeEntity(payload);
-        this.changedFiles.add(changedFile);
-    };
-    deleteEntity = ({ entityId, }) => {
-        const { changedFiles, deletedEntitiesNames } = this.sbScopeManager.deleteScopeEntity(entityId);
-        changedFiles.forEach((file) => {
-            this.changedFiles.add(file);
-        });
-        return deletedEntitiesNames[0];
-    };
-    checkImportInFilesForNewName = ({ entityId, newName, oldName, scopeName, }) => {
-        const referencingFiles = this.sbScopeManager.getReferencingFilesByEntityIdAndScopeName(entityId, scopeName);
-        for (const filePath of referencingFiles) {
-            const file = this.fileToMeta[filePath];
-            if (!file || !file.ast) {
-                throw new Error(`File not found for element ${filePath}`);
-            }
-            const imports = extractImportsFromAst(file.ast);
-            if (newName in imports) {
-                throw new Error(`Cannot rename entity ${oldName} to ${newName} because it has a naming collision with an existing import in file ${filePath}`);
-            }
-        }
-    };
-    renameEntity = ({ entityId, oldName, newName, scopeName, }) => {
-        this.checkImportInFilesForNewName({
-            entityId,
-            newName,
-            oldName,
-            scopeName,
-        });
-        const { changedFiles, scopeFile } = this.sbScopeManager.renameScopeEntity({
-            entityId,
-            newName,
-            oldName,
-        });
-        if (changedFiles.length === 0) {
-            console.warn("No changed files found for entity", entityId);
-            return;
-        }
-        changedFiles.forEach((file) => {
-            this.changedFiles.add(file);
-        });
-        if (!scopeFile) {
-            console.error("Could not find scope file for entity", entityId);
-            return;
-        }
-        this.changedFiles.add(scopeFile);
-        // For now, just look in the same folder as the scope file for renames
-        // in the future, we may need to look in other folders
-        const scopeFolder = path.dirname(scopeFile);
-        for (const filePath of Object.keys(this.fileToMeta)) {
-            if (filePath.startsWith(scopeFolder) && filePath.endsWith(".tsx")) {
-                this.renameIdentifier({
-                    oldName,
-                    newName,
-                    filePath,
-                    parentBinding: scopeName,
-                });
-            }
-        }
+    addApi = async ({ apiName: _apiName }) => {
+        // Return the app-level scope ID
+        return getScopeIdFromName("App");
     };
-    addScopeComponent = ({ scopeName, componentName, }) => {
-        const changedFiles = this.sbScopeManager.addScopeComponent(scopeName, componentName);
-        changedFiles.forEach((file) => {
-            this.changedFiles.add(file);
-        });
+    deleteApi = ({ apiName: _apiName, }) => {
+        // Return the app-level scope ID
+        return getScopeIdFromName("App");
     };
-    addElement = ({ parentElement, tagName, properties, children, id, scopeName, }) => {
+    addElement = ({ parentElement, tagName, properties, children, id, scopeName: _scopeName, }) => {
         const logger = getLogger();
         const parentOpeningElementPath = this.getElementToLocation(parentElement.source.id);
         const parentFilepath = this.getElementToFilePath(parentElement.source.id);
@@ -486,54 +311,6 @@ export class SourceTracker {
             throw new Error("Parent element is not a JSX element");
         }
         try {
-            const childName = properties.name;
-            if (childName && scopeName) {
-                const { scopeDefinition, filePath: scopeFilePath } = this.sbScopeManager.getScopeDefinitionAndFilePathByNameOrId({
-                    identifier: scopeName,
-                    type: "name",
-                });
-                if (!scopeDefinition || !scopeFilePath) {
-                    console.log("No scope creation found for " + scopeName + " will not add a bind");
-                }
-                else {
-                    const { name: scopeExportName } = scopeDefinition;
-                    if (scopeFilePath !== parentFilepath) {
-                        // check if exportName is already imported into parentFilePath
-                        const parentFileImports = this.fileToMeta[parentFilepath]?.imports;
-                        if (!parentFileImports || !parentFileImports[scopeExportName]) {
-                            const importPath = getImportPath(parentFilepath, scopeFilePath);
-                            // add the import
-                            addImport({
-                                importPath,
-                                importName: scopeExportName,
-                                path: parentOpeningElementPath,
-                                onAdd: () => {
-                                    this.fileToMeta[parentFilepath].imports[scopeExportName] =
-                                        importPath;
-                                },
-                            });
-                        }
-                    }
-                    const childNameValue = childName.value;
-                    const changedFiles = this.sbScopeManager.addScopeComponent(scopeName, childNameValue);
-                    changedFiles.forEach((file) => {
-                        this.changedFiles.add(file);
-                    });
-                    // if the scope file path is in the same page directory as this file, then we should destructure it
-                    if (path.dirname(scopeFilePath) === path.dirname(parentFilepath)) {
-                        this.sbScopeManager.addScopeDestructuringForComponent({
-                            elementLocation: parentJSXElementPath,
-                            scopeName,
-                            componentFilePath: parentFilepath,
-                        });
-                        properties.bind = Property.Expression(`${childNameValue}`);
-                    }
-                    else {
-                        properties.bind = Property.Expression(`${scopeExportName}.${childNameValue}`);
-                    }
-                    delete properties.name;
-                }
-            }
             const newElement = generateJSXElement({
                 id,
                 tagName,
@@ -629,7 +406,7 @@ export class SourceTracker {
             throw new Error("Error updating source tracker during add" + e.message);
         }
     };
-    deleteElement = ({ source, scopeName, }) => {
+    deleteElement = ({ source, scopeName: _scopeName, }) => {
         const logger = getLogger();
         let openingTag = this.getElementToLocation(source.id);
         if (!openingTag) {
@@ -650,7 +427,7 @@ export class SourceTracker {
             logger.error(`Cannot delete a non-JSX element ${source.id}`);
             return;
         }
-        const componentName = getDescriptiveName(openingTag.node);
+        const _componentName = getDescriptiveName(openingTag.node);
         const children = [];
         openingTag.traverse({
             JSXElement: (path) => {
@@ -669,20 +446,8 @@ export class SourceTracker {
         }
         delete this.elementToLocation[source.id];
         delete this.elementToFilePath[source.id];
-        if (scopeName && componentName) {
-            const changedFiles = this.sbScopeManager.deleteScopeComponent(scopeName, componentName);
-            changedFiles.forEach((file) => {
-                this.changedFiles.add(file);
-            });
-        }
-        // Then remove all traces of the children
-        children.forEach(({ id, name: childComponentName }) => {
-            if (childComponentName && scopeName) {
-                const changedFiles = this.sbScopeManager.deleteScopeComponent(scopeName, childComponentName);
-                changedFiles.forEach((file) => {
-                    this.changedFiles.add(file);
-                });
-            }
+        // Clean up child element tracking
+        children.forEach(({ id }) => {
             delete this.elementToLocation[id];
             delete this.elementToFilePath[id];
         });
@@ -778,42 +543,6 @@ export class SourceTracker {
         }
         return found;
     };
-    removeVariableReferencesFromRoot = (functionRoot, variableName) => {
-        const referencesToRemove = new Set();
-        functionRoot.traverse({
-            JSXExpressionContainer(path) {
-                const expression = path.get("expression");
-                if (expression.isIdentifier() &&
-                    expression.node.name === variableName) {
-                    referencesToRemove.add(path);
-                }
-                else if (expression.isCallExpression()) {
-                    const callee = expression.get("callee");
-                    if (callee.isIdentifier() && callee.node.name === variableName) {
-                        referencesToRemove.add(path);
-                    }
-                }
-            },
-            Identifier(path) {
-                if (path.node.name === variableName && path.isReferencedIdentifier()) {
-                    const parent = path.parentPath;
-                    if (parent?.isJSXExpressionContainer()) {
-                        referencesToRemove.add(parent);
-                    }
-                }
-            },
-        });
-        for (const path of referencesToRemove) {
-            try {
-                if (!path.removed) {
-                    path.remove();
-                }
-            }
-            catch (_e) {
-                // Path might already be removed, ignore the error
-            }
-        }
-    };
     // If we're deleting the only Column in an Section, remove the Section
     deleteSectionIfOnlyChild = (openingTag) => {
         const parentElement = openingTag.parentPath;
@@ -935,7 +664,29 @@ export class SourceTracker {
         const openingElement = element.get("openingElement");
         if (openingElement.node.selfClosing) {
             openingElement.node.selfClosing = false;
-            element.node.closingElement = t.jsxClosingElement(t.jsxIdentifier(getTagName(openingElement.node.name) ?? ""));
+            element.node.closingElement = t.jsxClosingElement(openingElement.node.name);
+        }
+    };
+    setJSXChildren = (jsxElement, info) => {
+        const logger = getLogger();
+        try {
+            // Ensure the element is not self-closing
+            this.transformSelfClosingTagToRegularTag(jsxElement);
+            // Clear existing children
+            jsxElement.node.children = [];
+            // Handle different types of children content
+            if (info.type === "STATIC" && typeof info.value === "string") {
+                // For string children, create a text node
+                if (info.value.trim() !== "") {
+                    jsxElement.node.children = [t.jsxText(info.value)];
+                }
+            }
+            else {
+                console.warn("setting non-static string children is not supported");
+            }
+        }
+        catch (e) {
+            logger.error("Error setting JSX children", getErrorMeta(e));
         }
     };
     setProperty = ({ source, property, info, }) => {
@@ -965,8 +716,28 @@ export class SourceTracker {
             if (!openingTag.isJSXOpeningElement()) {
                 throw new Error(`Element ${source.id} is not a JSXOpeningElement`);
             }
+            // Get the JSX element to handle children
+            let jsxElement = this.getElementToLocation(source.id);
+            if (jsxElement?.isJSXOpeningElement()) {
+                jsxElement = jsxElement.parentPath;
+            }
             // Iterate over the changes and set each attribute using the helper
             for (const [key, info] of Object.entries(changes)) {
+                // Special handling for children property
+                if (key === "children") {
+                    const childrenAttribute = openingTag
+                        .get("attributes")
+                        .find((attr) => attr.isJSXAttribute() && attr.node.name.name === "children");
+                    const jsxChildrenExists = jsxElement.isJSXElement() && jsxElement.node.children.length > 0;
+                    // We always set the jsx children UNLESS children exists as an attribute and there are no current jsx children
+                    if (jsxChildrenExists || !childrenAttribute) {
+                        this.setJSXChildren(jsxElement, info);
+                        if (childrenAttribute) {
+                            childrenAttribute.remove();
+                        }
+                        continue;
+                    }
+                }
                 const jsxAttribute = this.setAttribute(openingTag, key, info);
                 const imports = getRequiredImportsForProperty(info);
                 if (imports.length > 0) {
@@ -985,13 +756,7 @@ export class SourceTracker {
                 }
                 if (ATTRIBUTE_TYPES_WITH_STATE_ACCESS.includes(info.type) &&
                     jsxAttribute) {
-                    const elementLocation = this.getElementToLocation(source.id);
-                    const scopeImports = this.sbScopeManager.getAndUpdateScopeImportsForCodeSnippet({
-                        jsxAttribute,
-                        codeFilePath: fileName,
-                        elementLocation,
-                        existingImports: this.fileToMeta[fileName].imports,
-                    });
+                    // Add external library imports (but not scope imports)
                     for (const externalLibrary of EXTERNAL_LIBRARY_OPTIONS) {
                         const referencedGlobalFunctions = getVariableReferences(jsxAttribute, externalLibrary.imports).map((funcName) => {
                             return {
@@ -999,7 +764,7 @@ export class SourceTracker {
                                 importName: funcName,
                             };
                         });
-                        [...referencedGlobalFunctions, ...scopeImports].forEach(({ importPath, importName }) => {
+                        referencedGlobalFunctions.forEach(({ importPath, importName }) => {
                             addImport({
                                 importPath,
                                 importName,
@@ -1046,18 +811,12 @@ export class SourceTracker {
             logger.error("Error deleting properties", getErrorMeta(e));
         }
     };
-    renameComponent = async ({ widgetSourceId, newName, oldName, scopeName, renameInAst = true, }) => {
+    renameComponent = async ({ widgetSourceId, newName, oldName: _oldName, renameInAst = true, }) => {
         const filePath = this.getElementToFilePath(widgetSourceId);
         const currentFile = this.fileToMeta[filePath];
         if (!currentFile || !currentFile.ast) {
             throw new Error(`File not found for element ${filePath}`);
         }
-        this.checkImportInFilesForNewName({
-            entityId: widgetSourceId,
-            newName,
-            oldName,
-            scopeName,
-        });
         let widgetNode = this.getElementToLocation(widgetSourceId);
         if (!widgetNode) {
             throw new Error(`Widget ${widgetSourceId} not found`);
@@ -1065,26 +824,6 @@ export class SourceTracker {
         if (widgetNode?.isJSXElement()) {
             widgetNode = widgetNode.get("openingElement");
         }
-        const hasNameAttribute = isNamedComponent(widgetNode.node);
-        if (scopeName) {
-            if (!hasNameAttribute) {
-                // if this is the first component getting named, we might need to add a scope destructuring for it
-                this.sbScopeManager.addScopeDestructuringForComponent({
-                    elementLocation: widgetNode,
-                    scopeName,
-                    componentFilePath: filePath,
-                });
-            }
-            const changedFiles = this.sbScopeManager.renameScopeComponent({
-                oldName: hasNameAttribute ? oldName : undefined,
-                newName,
-                scopeName,
-                componentFilePath: filePath,
-            });
-            changedFiles.forEach((file) => {
-                this.changedFiles.add(file);
-            });
-        }
         await this.renameManager.renameComponent({
             widgetNode: widgetNode,
             newName,
@@ -1110,41 +849,11 @@ export class SourceTracker {
         });
         this.changedFiles.add(filePath);
     };
-    /**
-     * Change the name of a scope definition in a specific file path. Note: if this is part of a page rename,
-     * you have to perform all of the file system operations separately.
-  
-     */
-    renamePage = ({ oldName, newName, scopeFilePath, pageFilePath, }) => {
-        const scopeAst = this.fileToMeta[scopeFilePath]?.ast;
-        if (!scopeAst) {
-            throw new Error(`File not found for element ${scopeFilePath}`);
-        }
-        const pageAst = this.fileToMeta[pageFilePath]?.ast;
-        if (!pageAst) {
-            throw new Error(`File not found for element ${pageFilePath}`);
-        }
-        this.sbScopeManager.renamePageScope({
-            oldName,
-            newName,
-            newFilePath: scopeFilePath,
-            indexAst: pageAst,
-            scopeAst,
-        });
-        this.changedFiles.add(scopeFilePath);
-        this.changedFiles.add(pageFilePath);
-    };
     getAddElementImports = ({ properties, children, }) => {
         const componentsManager = ComponentsManager.getInstance();
         const getPropertyImports = (properties) => {
             return Object.values(properties)
                 .flatMap((property) => {
-                if (property.type === "EVENT") {
-                    return {
-                        importPath: "@superblocksteam/library",
-                        importName: "EventFlow",
-                    };
-                }
                 if (property.type === "DIMENSION") {
                     return {
                         importPath: "@superblocksteam/library",