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

package/dist/file-sync-vite-plugin.js

@@ -0,0 +1,691 @@
+import path from "node:path";
+import { ApiTriggerType } from "@superblocksteam/shared";
+import bodyParser from "body-parser";
+import { stripIndent } from "common-tags";
+import { normalizePath } from "vite";
+import { extractApiDependencies, extractIdentifierPathsFromApi, } from "./binding-extraction/extract-identifiers.js";
+import { ComponentsManager } from "./components-manager.js";
+import { makeServerError } from "./errors/make-server-error.js";
+import { getPageFilePath, SCOPE_FILE } from "./file-system-helpers.js";
+import { FileSyncManager } from "./file-system-manager.js";
+import { indexHtmlMiddleware } from "./injected-index.js";
+import { LockServiceStatus } from "./lock-service/index.js";
+import { getLegacyComponentsFolder, isCustomBuildEnabled, setOptions, } from "./plugin-options.js";
+import { generateRootSource } from "./routing.js";
+import { SocketManager } from "./socket-manager.js";
+import { GenerationNumberSequence } from "./util/generation-number-sequence.js";
+import { getErrorMeta, setLogger } from "./util/logger.js";
+import { getAllApiDefinitions, getAllPages } from "./util.js";
+let hasStarted = false;
+let isInitialized = false;
+let config;
+const virtualLegacyId = "virtual:legacy-wrapper";
+const resolvedVirtualLegacyId = `\0${virtualLegacyId}`;
+const virtualRegisteredComponentsId = "virtual:registered-components";
+const resolvedVirtualRegisteredComponentsId = `\0${virtualRegisteredComponentsId}`;
+export const fileSyncVitePlugin = (pluginParams, options) => {
+    const logger = setLogger(pluginParams.logger);
+    setOptions(options ?? {
+        legacyComponentsFolder: "legacy",
+    });
+    const generationNumberSequence = new GenerationNumberSequence();
+    const syncService = pluginParams.syncService;
+    const lockService = pluginParams.lockService;
+    const aiService = pluginParams.aiService;
+    const fsOperationQueue = pluginParams.fsOperationQueue;
+    const httpServer = pluginParams.httpServer;
+    const fileSyncManager = new FileSyncManager(fsOperationQueue, generationNumberSequence);
+    if (syncService) {
+        syncService.generationNumberSequence = generationNumberSequence;
+    }
+    // Set up sync callback in lock service
+    if (lockService && syncService) {
+        lockService.setSyncCallback(async () => {
+            await syncService.uploadDirectory();
+            await syncService.uploadDirectoryNowIfNeeded();
+        });
+    }
+    return {
+        name: "sb-file-sync",
+        apply: "serve",
+        enforce: "pre",
+        async configureServer(server) {
+            config = server.config;
+            const componentsManager = ComponentsManager.getInstance();
+            await Promise.all([
+                componentsManager.initialize(process.cwd(), server.watcher),
+                server.waitForRequestsIdle("sb-file-sync").then(async () => {
+                    if (hasStarted) {
+                        // We only want to initialize the file sync once, but vite seems to fire this multiple times
+                        return;
+                    }
+                    hasStarted = true;
+                    const root = server.config.root;
+                    try {
+                        await fileSyncManager.watch(server.watcher, root).then(() => {
+                            isInitialized = true;
+                        });
+                    }
+                    catch (e) {
+                        logger.error("Error watching files", getErrorMeta(e));
+                    }
+                }),
+            ]);
+            server.middlewares.use(indexHtmlMiddleware(server, fileSyncManager));
+            server.middlewares.use("/sb-init", bodyParser.json({ strict: true }));
+            server.middlewares.use("/sb-init", async (req, res, next) => {
+                if (!isInitialized) {
+                    return next();
+                }
+                if (req.method !== "GET" && req.method !== "OPTIONS") {
+                    res.statusCode = 405;
+                    res.end("Method not allowed");
+                    return res.end();
+                }
+                res.setHeader("Access-Control-Allow-Origin", "*");
+                res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+                res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+                if (req.method === "OPTIONS") {
+                    res.statusCode = 204;
+                    res.end();
+                    return;
+                }
+                const fullUrl = new URL(req.url ?? "/", "http://localhost:5173");
+                if (!fullUrl.searchParams.get("route")) {
+                    res.statusCode = 400;
+                    res.end("Missing route, use ?route=/route");
+                    return res.end();
+                }
+                const actualUrl = new URL(fullUrl.searchParams.get("route") ?? "/", fullUrl);
+                const files = await getAllApiDefinitions({
+                    rootDir: config.root,
+                    currentUrl: actualUrl.toString(),
+                });
+                res.setHeader("Content-Type", "application/json");
+                return res.end(JSON.stringify(files));
+            });
+            server.middlewares.use("/sb-scopes", bodyParser.json({ strict: true }));
+            server.middlewares.use("/sb-scopes", async (req, res, next) => {
+                if (!isInitialized) {
+                    return next();
+                }
+                if (req.method !== "GET" && req.method !== "OPTIONS") {
+                    res.statusCode = 405;
+                    res.end("Method not allowed");
+                    return res.end();
+                }
+                res.setHeader("Access-Control-Allow-Origin", "*");
+                res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+                res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+                if (req.method === "OPTIONS") {
+                    res.statusCode = 204;
+                    res.end();
+                    return;
+                }
+                const appScope = await getAppScope(fileSyncManager);
+                res.setHeader("Content-Type", "application/json");
+                return res.end(JSON.stringify(appScope));
+            });
+            // AI ping endpoint to keep connection alive during generation
+            server.middlewares.use("/sb-ping", async (req, res, _next) => {
+                if (req.method !== "GET" && req.method !== "OPTIONS") {
+                    res.statusCode = 405;
+                    res.end("Method not allowed");
+                    return res.end();
+                }
+                res.setHeader("Access-Control-Allow-Origin", "*");
+                res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+                res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+                if (req.method === "OPTIONS") {
+                    res.statusCode = 204;
+                    res.end();
+                    return;
+                }
+                res.setHeader("Content-Type", "application/json");
+                return res.end(JSON.stringify({ status: "ok", timestamp: Date.now() }));
+            });
+            const socketManager = new SocketManager();
+            socketManager.startSocketServer({
+                server: httpServer,
+                fileSyncManager,
+                lockService,
+                syncService,
+                aiService,
+                tracer: pluginParams.tracer,
+                path: "/sb-updates",
+            });
+            socketManager.removeAllListeners();
+            const sendError = (errorEvent) => {
+                socketManager.callEditorClients((socket) => socket.call.error(errorEvent));
+            };
+            // Add some process error handling to ensure to notify the user of
+            // any uncaught exceptions or rejections
+            process.on("uncaughtException", (error) => {
+                sendError(makeServerError(error));
+                process.exit(1);
+            });
+            process.on("unhandledRejection", (reason) => {
+                logger.error("Unhandled rejection", reason);
+                const error = reason instanceof Error
+                    ? reason
+                    : typeof reason === "object"
+                        ? new Error(JSON.stringify(reason))
+                        : new Error(String(reason));
+                sendError(makeServerError(error));
+                process.exit(1);
+            });
+            syncService?.removeListener?.("error", sendError);
+            syncService?.on?.("error", sendError);
+            lockService?.removeListener?.("error", sendError);
+            lockService?.on?.("error", sendError);
+            const extractApiParamsAndDependencies = (socket) => {
+                const allApis = fileSyncManager.getApiFiles();
+                const allApiNames = Object.values(allApis).map(({ api }) => api.apiPb.metadata.name);
+                const apiDependencyMap = {};
+                Promise.all([
+                    ...Object.values(allApis).map(async ({ api }) => {
+                        const bindings = await extractIdentifierPathsFromApi(api);
+                        const allIdentifiers = bindings.flatMap((binding) => binding.bindings);
+                        const apiDependencies = extractApiDependencies(allApiNames, bindings);
+                        apiDependencyMap[api.apiPb.metadata.name] = apiDependencies;
+                        return socket.call.updateApiParams({
+                            apiName: api.apiPb.metadata.name,
+                            params: allIdentifiers,
+                            apiDependencies,
+                        });
+                    }),
+                ]).then(() => {
+                    socketManager.callEditorClients((editorClientSocket) => {
+                        return editorClientSocket.call.setApiDependencies({
+                            apiDependencies: apiDependencyMap,
+                        });
+                    });
+                });
+            };
+            socketManager.on("connect:library", async (socket) => {
+                const allApis = fileSyncManager.getApiFiles();
+                socket.call
+                    .setApiDefinitions(allApis)
+                    .then(() => extractApiParamsAndDependencies(socket));
+                const tsFilePaths = fileSyncManager.getTsFilePaths();
+                return socket.call.updateLocalBindingEntities({
+                    entities: Array.from(new Set(tsFilePaths.flatMap((file) => fileSyncManager.getLocalBindingEntities(file)))),
+                });
+            });
+            const sendRootUpdate = async (path, sync = false) => {
+                const roots = fileSyncManager.getPageRoots(path);
+                const scope = fileSyncManager.getScope(path);
+                if (!roots || !scope) {
+                    logger?.error(`sendRootUpdate: no roots or scope ${path}`);
+                    return;
+                }
+                const { scopeId } = scope;
+                socketManager.callEditorClients((socket) => {
+                    return socket.call.updateScope({
+                        scopeId,
+                        updates: { roots },
+                    });
+                });
+                if (sync && syncService) {
+                    await syncService.uploadDirectory();
+                }
+            };
+            const sendMultiRootUpdate = async (paths, sync = false) => {
+                paths.forEach((path) => {
+                    sendRootUpdate(path);
+                });
+                if (sync && syncService) {
+                    await syncService.uploadDirectory();
+                }
+            };
+            const sendRootReset = async (sync = false) => {
+                const appScope = await getAppScope(fileSyncManager);
+                socketManager.callEditorClients((socket) => {
+                    return socket.call.resetScope({
+                        appScope,
+                    });
+                });
+                if (sync && syncService) {
+                    await syncService.uploadDirectory();
+                }
+            };
+            // TODO: @damian - Check if we need both sendFileUpdate and sendEntityUpdate
+            const sendFileUpdate = (path) => {
+                const scope = fileSyncManager.getScope(path);
+                const entities = scope?.entities ?? {};
+                const scopeId = scope?.scopeId ?? "";
+                const roots = fileSyncManager.getPageRoots(path);
+                socketManager.callEditorClients((socket) => socket.call.updateScope({
+                    scopeId,
+                    updates: { entities, roots: roots ?? undefined },
+                }));
+            };
+            const sendDeleteComponentsUpdate = async (path, sourceIds) => {
+                const scope = fileSyncManager.getScope(path);
+                if (!scope) {
+                    console.error("No scope found for", path);
+                    return;
+                }
+                await sendRootUpdate(path);
+                socketManager.callLibraryClients((socket) => {
+                    return socket.call.deleteEntities(sourceIds.map((sourceId) => ({
+                        scopeId: scope.scopeId,
+                        sourceId,
+                    })));
+                });
+            };
+            const sendDeleteEntityUpdate = async (path, entityName) => {
+                const scope = fileSyncManager.getScope(path);
+                if (!scope) {
+                    console.error("No scope found for", path);
+                    return;
+                }
+                const { scopeId } = scope;
+                await sendEntityUpdate(path);
+                socketManager.callLibraryClients((socket) => {
+                    return socket.call.deleteEntities([
+                        {
+                            scopeId,
+                            entityName,
+                        },
+                    ]);
+                });
+            };
+            const sendEntityUpdate = (path) => {
+                const scope = fileSyncManager.getScope(path);
+                if (!scope) {
+                    console.error("No scope found for", path);
+                    return;
+                }
+                const { entities, scopeId } = scope;
+                socketManager.callEditorClients((socket) => socket.call.updateScope({
+                    scopeId,
+                    updates: {
+                        entities,
+                    },
+                }));
+            };
+            // configured twice otherwise, always remove all listeners
+            fileSyncManager.removeAllListeners();
+            fileSyncManager.on("error", sendError);
+            fileSyncManager.on("reparent", sendRootUpdate);
+            fileSyncManager.on("batchUpdate", sendMultiRootUpdate);
+            fileSyncManager.on("createComponent", sendRootUpdate);
+            fileSyncManager.on("deleteComponents", sendDeleteComponentsUpdate);
+            fileSyncManager.on("addEntity", sendEntityUpdate);
+            fileSyncManager.on("updateEntity", sendEntityUpdate);
+            fileSyncManager.on("deleteEntity", sendDeleteEntityUpdate);
+            fileSyncManager.on("renameComponent", sendFileUpdate);
+            fileSyncManager.on("renameEntity", sendFileUpdate);
+            fileSyncManager.on("addPage", sendRootUpdate);
+            fileSyncManager.on("renamePage", () => sendRootReset(true));
+            fileSyncManager.on("fileChanged", async (path, _content, isNonVisualEdit) => {
+                socketManager.callLibraryClients((socket) => {
+                    return socket.call.updateLocalBindingEntities({
+                        entities: fileSyncManager.getLocalBindingEntities(path),
+                    });
+                });
+                if (isNonVisualEdit) {
+                    sendFileUpdate(path);
+                    socketManager.callLibraryClients((socket) => {
+                        return socket.call.nonVisualEdit();
+                    });
+                }
+                if (syncService) {
+                    await syncService.uploadDirectory();
+                }
+            });
+            fileSyncManager.on("apiUpdate", async (payload) => {
+                socketManager.callLibraryClients(async (socket) => {
+                    Promise.all([
+                        socket.call.updateApi(payload),
+                        extractApiParamsAndDependencies(socket),
+                    ]);
+                });
+                if (payload.api.pageName) {
+                    const pagePath = getPageFilePath(config.root, payload.api.pageName);
+                    sendEntityUpdate(pagePath);
+                }
+                if (syncService) {
+                    await syncService.uploadDirectory();
+                }
+            });
+            fileSyncManager.on("apiManualUpdate", async (payload, sendScopeUpdates = false) => {
+                socketManager.callLibraryClients(async (socket) => {
+                    Promise.all([
+                        socket.call.updateApi(payload),
+                        extractApiParamsAndDependencies(socket),
+                    ]);
+                });
+                if (sendScopeUpdates) {
+                    sendFileUpdate(getPageFilePath(config.root, payload.api.pageName));
+                }
+                if (syncService) {
+                    await syncService.uploadDirectory();
+                }
+                socketManager.callEditorClients((socket) => {
+                    return socket.call.manualUpdateApi({
+                        api: payload.api,
+                    });
+                });
+            });
+            if (syncService) {
+                syncService.on("synchronizationStatusChange", async (status, generationNumber) => {
+                    socketManager.callEditorClients(async (socket) => {
+                        try {
+                            await socket.call.syncStatus({ status, generationNumber });
+                        }
+                        catch (err) {
+                            logger.error("Failed to send syncStatus", getErrorMeta(err));
+                        }
+                    });
+                });
+            }
+            if (lockService) {
+                lockService.on("statusChange", (status) => {
+                    if (status === LockServiceStatus.FAILED_TO_ACQUIRE_LOCK ||
+                        status === LockServiceStatus.RELEASING) {
+                        socketManager.callEditorClients(async (socket) => {
+                            try {
+                                await socket.call.releasingLock();
+                            }
+                            catch (err) {
+                                logger.error("Failed to send releasingLock", getErrorMeta(err));
+                            }
+                        });
+                    }
+                    else if (status === LockServiceStatus.LOCK_INVALID) {
+                        sendError(makeServerError(new Error("Error renewing connection to editing session. Please refresh the page.")));
+                    }
+                    else if (status === LockServiceStatus.LOCK_RELEASED) {
+                        sendError(makeServerError(new Error("Editing session is no longer active. Please refresh the page or move to local mode.")));
+                    }
+                });
+            }
+            fileSyncManager.on("routesChanged", () => {
+                const rootId = normalizePath(path.join(config.root, "root.tsx"));
+                const module = server.moduleGraph.getModuleById(rootId);
+                if (module) {
+                    server.reloadModule(module);
+                }
+            });
+            fileSyncManager.on("apiDelete", async (payload) => {
+                socketManager.callLibraryClients(async (socket) => {
+                    Promise.all([
+                        socket.call.deleteApis(payload.apis.map((api) => ({
+                            apiName: api.apiName,
+                            scopeId: api.scopeId,
+                        }))),
+                        extractApiParamsAndDependencies(socket),
+                    ]);
+                    // All APIs should belong to the same page but to be consistant we iterate over all APIs
+                    const pageNames = new Set(payload.apis.map((api) => api.pageName));
+                    if (pageNames.size > 0) {
+                        pageNames.forEach((pageName) => {
+                            const pagePath = getPageFilePath(config.root, pageName);
+                            sendEntityUpdate(pagePath);
+                        });
+                    }
+                    if (syncService) {
+                        await syncService.uploadDirectory();
+                    }
+                });
+            });
+            fileSyncManager.on("apiManualDelete", async (payload) => {
+                socketManager.callLibraryClients(async (socket) => {
+                    Promise.all([
+                        socket.call.deleteApis([
+                            {
+                                apiName: payload.api.apiName,
+                                scopeId: payload.api.scopeId,
+                            },
+                        ]),
+                        extractApiParamsAndDependencies(socket),
+                    ]);
+                    const pagePath = getPageFilePath(config.root, payload.api.pageName);
+                    sendEntityUpdate(pagePath);
+                });
+                socketManager.callEditorClients((socket) => {
+                    return socket.call.manualDeleteApi({
+                        id: payload.api.id,
+                    });
+                });
+                if (syncService) {
+                    await syncService.uploadDirectory();
+                }
+            });
+            if (syncService && aiService) {
+                socketManager.on("connect:editor", async (socket) => {
+                    const hasDraft = await syncService.hasLocalDraftChanges();
+                    return socket.call.aiSetDraftState({ hasDraft });
+                });
+                syncService.on("draftStateChanged", (hasDraft) => {
+                    socketManager.callEditorClients((socket) => {
+                        return socket.call.aiSetDraftState({ hasDraft });
+                    });
+                });
+                aiService.on("generationCompleted", (hasDraft) => {
+                    if (hasDraft) {
+                        // we have been deferring hot updates; trigger a reload to render the ai draft
+                        logger.info("Requesting full reload to render AI draft");
+                        server.ws.send({
+                            type: "full-reload",
+                        });
+                    }
+                });
+                // capture vite error logging
+                const originalErrorLogger = config.logger.error;
+                config.logger.error = (...args) => {
+                    if (aiService.isBusy()) {
+                        const [message, options] = args;
+                        let error;
+                        if (options?.error instanceof Error) {
+                            error = options.error;
+                        }
+                        else if (typeof options?.error?.stack === "string") {
+                            // it's a RollupError
+                            error = new Error(options.error.stack);
+                        }
+                        else {
+                            error = new Error(message);
+                        }
+                        aiService.handleBuildSystemError(error);
+                    }
+                    return originalErrorLogger.apply(config.logger, args);
+                };
+            }
+            const triggerRegisteredComponentUpdate = () => {
+                const module = server.moduleGraph.getModuleById(resolvedVirtualRegisteredComponentsId);
+                if (module) {
+                    server.reloadModule(module);
+                }
+            };
+            componentsManager.on("error", sendError);
+            componentsManager.on("registeredComponentAdded", triggerRegisteredComponentUpdate);
+            componentsManager.on("registeredComponentRemoved", (name) => {
+                triggerRegisteredComponentUpdate();
+                socketManager.callLibraryClients((socket) => {
+                    return socket.call.removeRegisteredComponent({
+                        name,
+                    });
+                });
+            });
+            componentsManager.on("registeredComponentChanged", (name, oldName) => {
+                triggerRegisteredComponentUpdate();
+                if (oldName) {
+                    socketManager.callLibraryClients(async (socket) => {
+                        await socket.call.renameRegisteredComponent({
+                            name,
+                            oldName,
+                        });
+                    });
+                }
+            });
+        },
+        async transform(code, id) {
+            const relativePath = path.relative(config.root, id);
+            if (!this.meta.watchMode)
+                return;
+            if (relativePath === "root.tsx") {
+                const source = generateRootSource(code, fileSyncManager);
+                return {
+                    code: /*js*/ stripIndent `
+            import "${virtualRegisteredComponentsId}";
+
+            ${source}
+          `,
+                    map: null,
+                };
+            }
+            else if (id.endsWith(".tsx") &&
+                !id.includes(`${getLegacyComponentsFolder()}/`)) {
+                try {
+                    if (!fileSyncManager.readFile(id)) {
+                        return { code, map: null };
+                    }
+                    const fileContents = await fileSyncManager.getFileWithIds(id);
+                    if (!fileContents) {
+                        throw new Error("File not found in file sync manager " + id);
+                    }
+                    return {
+                        code: fileContents,
+                        map: null,
+                    };
+                }
+                catch (e) {
+                    logger.error("Error transforming file", getErrorMeta(e));
+                }
+            }
+            else if (id.endsWith(SCOPE_FILE)) {
+                const fileContents = await fileSyncManager.getFileWithIds(id);
+                if (!fileContents) {
+                    throw new Error("File not found in file sync manager " + id);
+                }
+                return {
+                    code: fileContents,
+                    map: null,
+                };
+            }
+            return {
+                code,
+                map: null,
+            };
+        },
+        resolveId(id) {
+            if (id === virtualLegacyId && isCustomBuildEnabled()) {
+                return resolvedVirtualLegacyId;
+            }
+            if (id === virtualRegisteredComponentsId) {
+                return resolvedVirtualRegisteredComponentsId;
+            }
+        },
+        async load(id) {
+            // This is a virtual file that we use to wrap any components that are using a
+            // version of React that is not our current library version. Those components need to be
+            // mounted with the version of React that is being used inside the "legacy" folder.
+            if (id === resolvedVirtualLegacyId) {
+                const customFolder = getLegacyComponentsFolder();
+                return /*js*/ `
+        import React from "react";
+        import ReactDOMLegacy from "/${customFolder}/dist/react-dom";
+        import ReactLegacy from "/${customFolder}/dist/react";
+
+        export function wrapCustomComponent(CustomComponent) {
+          return React.forwardRef((props, ref) => {
+            const containerRef = React.useRef(null);
+
+            React.useEffect(() => {
+              if (!containerRef.current) return;
+
+              const container = containerRef.current;
+
+              ReactDOMLegacy.render(
+                ReactLegacy.createElement(CustomComponent, props),
+                container,
+              );
+
+              return () => {
+                if (container) {
+                  ReactDOMLegacy.unmountComponentAtNode(container);
+                }
+              };
+            }, [props]);
+
+            return React.createElement("div", { ref: mergeRefs(containerRef, ref) });
+          });
+        }
+
+        function mergeRefs(...refs) {
+          return (value) => {
+            refs.forEach((ref) => {
+              if (typeof ref === "function") {
+                ref(value);
+              } else if (ref != null) {
+                ref.current = value;
+              }
+            });
+          };
+        }
+      `;
+            }
+            if (id === resolvedVirtualRegisteredComponentsId) {
+                const componentsManager = ComponentsManager.getInstance();
+                const paths = componentsManager.componentFilePaths;
+                return /*js*/ `
+        ${Array.from(paths)
+                    .map((filePath) => `
+              import "/${path.relative(config.root, filePath)}";
+            `)
+                    .join("\n")}
+        `;
+            }
+        },
+        handleHotUpdate() {
+            // prevent hot updates if the AI service is busy generating a draft
+            if (aiService?.isBusy()) {
+                return [];
+            }
+        },
+    };
+};
+async function getAppScope(fileSyncManager) {
+    const pageContents = await getAllPages({
+        rootDir: config.root,
+    });
+    const pages = pageContents.reduce((acc, { name, route, fileName }) => {
+        const roots = fileSyncManager.getPageRoots(fileName);
+        const pageScopeDef = fileSyncManager.getScope(fileName);
+        if (roots && pageScopeDef) {
+            acc[name] = {
+                name,
+                ...pageScopeDef,
+                route,
+                roots,
+            };
+        }
+        return acc;
+    }, {});
+    const appScopeDef = fileSyncManager.getScope(fileSyncManager.appFilePath);
+    const apiFiles = fileSyncManager.getApiFiles();
+    const apis = Object.values(apiFiles)
+        .filter(({ api: { apiPb } }) => !!apiPb.metadata && !!apiPb.trigger?.application)
+        .map(({ api: { apiPb } }) => ({
+        id: apiPb.metadata.id,
+        name: apiPb.metadata.name,
+        applicationId: apiPb.trigger.application?.id,
+        pageId: apiPb.trigger.application?.pageId,
+        organizationId: apiPb.metadata.organization,
+        updated: apiPb.metadata?.timestamps?.updated
+            ? new Date(apiPb.metadata?.timestamps?.updated)
+            : undefined,
+        triggerType: ApiTriggerType.UI,
+        apiPb: apiPb,
+    }));
+    const appScope = {
+        ...appScopeDef,
+        pages,
+        apis,
+    };
+    return appScope;
+}
+//# sourceMappingURL=file-sync-vite-plugin.js.map