@trojanbox-vcp-test/site-edit-engine 0.1.0

package/dist/internal-adapter.js

@@ -0,0 +1,350 @@
+const STRUCTURAL_KEY_MAP = new Map([
+    ["routeId", "routeId"],
+    ["documentVersion", "documentVersion"],
+    ["segmentIndex", "segmentIndex"],
+    ["preserveBindings", "preserveBindings"],
+    ["exportName", "exportName"],
+    ["anchorKey", "anchorKey"],
+    ["parentKey", "parentKey"],
+    ["slotName", "slotName"],
+    ["toIndex", "toIndex"],
+    ["fromIndex", "fromIndex"],
+    ["nextExpression", "nextExpression"],
+    ["nextToken", "nextToken"],
+]);
+const OPAQUE_VALUE_KEYS = new Set(["value", "block", "properties", "props"]);
+export function toInternalOperationRequest(request) {
+    return {
+        id: request.id,
+        routeId: request.routeId,
+        kind: request.kind,
+        target: toInternalTarget(request.target),
+        documentVersion: request.documentVersion,
+        params: renameStructuralKeys(request.params),
+    };
+}
+export function toSiteEditOperationResult(result) {
+    return {
+        requestId: result.requestId,
+        kind: result.kind,
+        target: toSiteEditTarget(result.target),
+        ok: result.ok,
+        resultVersion: result.resultVersion,
+        error: result.error,
+    };
+}
+export function toSiteEditRenderDocument(document, context) {
+    return {
+        siteId: context.siteId,
+        snapshotId: context.snapshotId,
+        routeId: document.routeId,
+        version: document.version,
+        rootKeys: document.rootKeys,
+        entries: document.entries.map((entry) => ({
+            key: entry.key,
+            tag: entry.tag,
+            label: entry.label,
+            parentKey: entry.parentKey,
+            childKeys: entry.childKeys,
+            operationSummary: {
+                canUpdateText: entry.operationSummary.canUpdateText,
+                canInsertChild: entry.operationSummary.canInsertChild,
+                canMove: entry.operationSummary.canMove,
+                canRemove: entry.operationSummary.canRemove,
+            },
+        })),
+    };
+}
+export function toSiteEditObjectSummary(detail) {
+    return {
+        key: detail.key,
+        tag: detail.tag,
+        label: detail.label,
+        capabilities: {
+            constraints: detail.capabilities.constraints,
+        },
+        isOpaque: detail.isOpaque,
+        provenanceChain: detail.provenanceChain
+            ? {
+                editMode: detail.provenanceChain.editMode,
+                diagnostics: detail.provenanceChain.diagnostics,
+            }
+            : undefined,
+        ancestors: detail.ancestors,
+    };
+}
+export function toSiteEditObjectEditContext(detail) {
+    return {
+        key: detail.key,
+        componentName: detail.componentName,
+        sourceFile: detail.sourceFile,
+        capabilities: toSiteEditCapability(detail.capabilities),
+        writeTarget: {
+            kind: detail.writeTarget.kind,
+            file: detail.writeTarget.file,
+            componentName: detail.writeTarget.componentName,
+            isProxy: detail.writeTarget.isProxy,
+        },
+        effectiveWriteTarget: detail.effectiveWriteTarget
+            ? {
+                kind: detail.effectiveWriteTarget.kind,
+                file: detail.effectiveWriteTarget.file,
+                isProxy: detail.effectiveWriteTarget.isProxy,
+                displayPath: detail.effectiveWriteTarget.displayPath,
+                sourceType: detail.effectiveWriteTarget.sourceType,
+                sourceId: detail.effectiveWriteTarget.sourceId,
+            }
+            : undefined,
+        provenanceChain: toSiteEditProvenanceChain(detail),
+        componentSemantic: asRecord(detail.componentSemantic),
+        textSegments: detail.textSegments.map((segment) => ({
+            index: segment.index,
+            value: segment.value,
+            editable: segment.editable,
+            source: segment.source
+                ? {
+                    kind: segment.source.kind,
+                    file: segment.source.file,
+                    expression: segment.source.expression,
+                    bindingName: segment.source.bindingName,
+                    path: segment.source.path,
+                }
+                : null,
+        })),
+        boundaryKind: detail.boundaryKind,
+        children: detail.children,
+        siblings: detail.siblings,
+    };
+}
+export function toSiteEditObjectStyleDetail(detail) {
+    return {
+        key: detail.key,
+        styleSource: detail.styleSource,
+        styleModel: detail.styleModel
+            ? {
+                kind: detail.styleModel.kind,
+                properties: detail.styleModel.properties.map((property) => ({
+                    property: property.property,
+                    value: property.value,
+                    resolvedValue: property.resolvedValue,
+                    ...(property.breakpoint ? { breakpoint: property.breakpoint } : {}),
+                    ...(property.state ? { state: property.state } : {}),
+                    ...(property.variants?.length
+                        ? { variants: property.variants }
+                        : {}),
+                    ...(property.options?.length ? { options: property.options } : {}),
+                    editable: property.editable,
+                    ...(property.diagnostics?.length
+                        ? { diagnostics: property.diagnostics }
+                        : {}),
+                    operationBoundary: property.operationBoundary,
+                })),
+            }
+            : undefined,
+    };
+}
+export function toSiteEditObjectContentDetail(detail) {
+    return {
+        key: detail.key,
+        contentModel: asRecord(detail.contentModel),
+    };
+}
+export function toSiteEditObjectMediaDetail(detail) {
+    return {
+        key: detail.key,
+        mediaModel: asRecord(detail.mediaModel),
+    };
+}
+export function toSiteEditObjectDetail(detail) {
+    const styleDetail = toSiteEditObjectStyleDetail(detail);
+    return {
+        key: detail.key,
+        tag: detail.tag,
+        componentName: detail.componentName,
+        sourceFile: detail.sourceFile,
+        label: detail.label,
+        capabilities: toSiteEditCapability(detail.capabilities),
+        writeTarget: {
+            kind: detail.writeTarget.kind,
+            file: detail.writeTarget.file,
+            componentName: detail.writeTarget.componentName,
+            isProxy: detail.writeTarget.isProxy,
+        },
+        effectiveWriteTarget: detail.effectiveWriteTarget
+            ? {
+                kind: detail.effectiveWriteTarget.kind,
+                file: detail.effectiveWriteTarget.file,
+                isProxy: detail.effectiveWriteTarget.isProxy,
+                displayPath: detail.effectiveWriteTarget.displayPath,
+                sourceType: detail.effectiveWriteTarget.sourceType,
+                sourceId: detail.effectiveWriteTarget.sourceId,
+            }
+            : undefined,
+        provenanceChain: toSiteEditProvenanceChain(detail),
+        componentSemantic: asRecord(detail.componentSemantic),
+        contentModel: asRecord(detail.contentModel),
+        mediaModel: asRecord(detail.mediaModel),
+        styleSource: styleDetail.styleSource,
+        styleModel: styleDetail.styleModel,
+        conditional: asRecord(detail.conditional),
+        textSegments: detail.textSegments.map((segment) => ({
+            index: segment.index,
+            value: segment.value,
+            editable: segment.editable,
+            source: segment.source
+                ? {
+                    kind: segment.source.kind,
+                    file: segment.source.file,
+                    expression: segment.source.expression,
+                    bindingName: segment.source.bindingName,
+                    path: segment.source.path,
+                }
+                : null,
+        })),
+        boundaryKind: detail.boundaryKind,
+        isOpaque: detail.isOpaque,
+        ancestors: detail.ancestors,
+        children: detail.children,
+        siblings: detail.siblings,
+    };
+}
+export function toSiteEditEvent(event, context) {
+    const at = new Date().toISOString();
+    if (event.type === "document-changed") {
+        return {
+            type: "site-edit.document.changed",
+            siteId: context.siteId,
+            snapshotId: context.snapshotId,
+            routeId: event.routeId,
+            version: event.version,
+            at,
+        };
+    }
+    if (event.type === "operation-completed") {
+        return {
+            type: "site-edit.operation.completed",
+            siteId: context.siteId,
+            result: toSiteEditOperationResult(event.result),
+            at,
+        };
+    }
+    if (event.type === "operation-failed") {
+        return {
+            type: "site-edit.operation.failed",
+            siteId: context.siteId,
+            requestId: event.requestId,
+            error: event.error,
+            at,
+        };
+    }
+    if (event.type === "capability-changed") {
+        return {
+            type: "site-edit.capability.changed",
+            siteId: context.siteId,
+            routeId: "",
+            keys: event.keys,
+            at,
+        };
+    }
+    return null;
+}
+function toInternalTarget(target) {
+    if (target.kind === "route") {
+        return { kind: "route", routeId: target.routeId };
+    }
+    return target;
+}
+function toSiteEditTarget(target) {
+    if (target.kind === "route") {
+        return { kind: "route", routeId: target.routeId };
+    }
+    return target;
+}
+function toSiteEditCapability(capability) {
+    return {
+        key: capability.key,
+        canUpdateText: capability.canUpdateText,
+        canInsertChild: capability.canInsertChild,
+        canMove: capability.canMove,
+        canRemove: capability.canRemove,
+        editModes: capability.editModes
+            ? {
+                updateText: capability.editModes.updateText
+                    ? {
+                        mode: capability.editModes.updateText.mode,
+                        reasonCode: capability.editModes.updateText.reasonCode,
+                    }
+                    : undefined,
+                insertChild: capability.editModes.insertChild
+                    ? {
+                        mode: capability.editModes.insertChild.mode,
+                        reasonCode: capability.editModes.insertChild.reasonCode,
+                    }
+                    : undefined,
+                move: capability.editModes.move
+                    ? {
+                        mode: capability.editModes.move.mode,
+                        reasonCode: capability.editModes.move.reasonCode,
+                    }
+                    : undefined,
+                remove: capability.editModes.remove
+                    ? {
+                        mode: capability.editModes.remove.mode,
+                        reasonCode: capability.editModes.remove.reasonCode,
+                    }
+                    : undefined,
+            }
+            : undefined,
+        constraints: capability.constraints,
+    };
+}
+function toSiteEditProvenanceChain(detail) {
+    return detail.provenanceChain
+        ? {
+            finalSource: detail.provenanceChain.finalSource
+                ? {
+                    kind: detail.provenanceChain.finalSource.kind,
+                    file: detail.provenanceChain.finalSource.file,
+                    displayPath: detail.provenanceChain.finalSource.displayPath,
+                    externalSource: detail.provenanceChain.finalSource.externalSource
+                        ? {
+                            sourceType: detail.provenanceChain.finalSource.externalSource
+                                .sourceType,
+                            sourceId: detail.provenanceChain.finalSource.externalSource
+                                .sourceId,
+                            adapterId: detail.provenanceChain.finalSource.externalSource
+                                .adapterId,
+                        }
+                        : undefined,
+                }
+                : null,
+            chain: detail.provenanceChain.chain.map((hop) => ({
+                kind: hop.kind,
+                file: hop.file,
+                displayName: hop.displayName,
+                canEditHere: hop.canEditHere,
+            })),
+            confidence: detail.provenanceChain.confidence,
+            editMode: detail.provenanceChain.editMode,
+            diagnostics: detail.provenanceChain.diagnostics,
+        }
+        : undefined;
+}
+function renameStructuralKeys(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => renameStructuralKeys(item));
+    }
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, nestedValue]) => {
+        const nextKey = STRUCTURAL_KEY_MAP.get(key) ?? key;
+        const nextValue = OPAQUE_VALUE_KEYS.has(key)
+            ? nestedValue
+            : renameStructuralKeys(nestedValue);
+        return [nextKey, nextValue];
+    }));
+}
+function asRecord(value) {
+    return value ? value : undefined;
+}

package/dist/next-app-router-fs.d.ts

@@ -0,0 +1,2 @@
+import type { SiteEditNextRouteConfig } from "./next-app-router.js";
+export declare function scanNextAppRouterRoutes(projectRoot: string): SiteEditNextRouteConfig[];

package/dist/next-app-router-fs.js

@@ -0,0 +1,64 @@
+import fs from "node:fs";
+import path from "node:path";
+const pageFilePattern = /^page\.(?:tsx|ts|jsx|js|mjs|cjs)$/;
+export function scanNextAppRouterRoutes(projectRoot) {
+    const appRoot = resolveAppRoot(projectRoot);
+    if (!appRoot) {
+        return [];
+    }
+    return collectPageFiles(appRoot)
+        .map((file) => ({
+        routeId: toRouteId(appRoot, file),
+        entryFile: toPosixPath(path.relative(projectRoot, file)),
+    }))
+        .sort((left, right) => left.routeId.localeCompare(right.routeId));
+}
+function resolveAppRoot(projectRoot) {
+    for (const candidate of ["app", "src/app"]) {
+        const absolutePath = path.join(projectRoot, candidate);
+        if (fs.existsSync(absolutePath) &&
+            fs.statSync(absolutePath).isDirectory()) {
+            return absolutePath;
+        }
+    }
+    return null;
+}
+function collectPageFiles(directory) {
+    const files = [];
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+        const absolutePath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === "node_modules" ||
+                entry.name.startsWith(".") ||
+                entry.name.startsWith("_") ||
+                entry.name.startsWith("@")) {
+                continue;
+            }
+            files.push(...collectPageFiles(absolutePath));
+            continue;
+        }
+        if (entry.isFile() && pageFilePattern.test(entry.name)) {
+            files.push(absolutePath);
+        }
+    }
+    return files;
+}
+function toRouteId(appRoot, pageFile) {
+    const relativeDirectory = toPosixPath(path.relative(appRoot, path.dirname(pageFile)));
+    const segments = relativeDirectory
+        ? relativeDirectory.split("/").filter((segment) => isRouteSegment(segment))
+        : [];
+    return segments.length === 0 ? "/" : `/${segments.join("/")}`;
+}
+function isRouteSegment(segment) {
+    return (Boolean(segment) &&
+        !segment.startsWith("@") &&
+        !segment.startsWith("_") &&
+        !isRouteGroup(segment));
+}
+function isRouteGroup(segment) {
+    return segment.startsWith("(") && segment.endsWith(")");
+}
+function toPosixPath(value) {
+    return value.replace(/\\/g, "/");
+}

package/dist/next-app-router.d.ts

@@ -0,0 +1,11 @@
+export type SiteEditNextRouteConfig = {
+    routeId: string;
+    entryFile: string;
+};
+export { scanNextAppRouterRoutes } from "./next-app-router-fs.js";
+export type SiteEditRouteSourceFile = {
+    path: string;
+};
+export declare function scanNextAppRouterRoutesFromFiles(files: SiteEditRouteSourceFile[]): SiteEditNextRouteConfig[];
+export declare function resolveNextAppRouteId(pathname: string | null | undefined, routes: SiteEditNextRouteConfig[], basePath?: string): string;
+export declare function normalizeNextRoutePath(pathname: string | null | undefined, basePath?: string): string;

package/dist/next-app-router.js

@@ -0,0 +1,140 @@
+export { scanNextAppRouterRoutes } from "./next-app-router-fs.js";
+const pageFilePattern = /^page\.(?:tsx|ts|jsx|js|mjs|cjs)$/;
+const dynamicSegmentPattern = /^\[[^\]]+\]$/;
+const catchAllSegmentPattern = /^\[\.\.\.[^\]]+\]$/;
+const optionalCatchAllSegmentPattern = /^\[\[\.\.\.[^\]]+\]\]$/;
+export function scanNextAppRouterRoutesFromFiles(files) {
+    const normalizedPaths = files.map((file) => toPosixPath(file.path));
+    const appRoot = resolveAppRoot(normalizedPaths);
+    if (!appRoot) {
+        return [];
+    }
+    return normalizedPaths
+        .filter((file) => isAppPageFile(appRoot, file))
+        .map((file) => ({
+        routeId: toRouteId(appRoot, file),
+        entryFile: file,
+    }))
+        .sort((left, right) => left.routeId.localeCompare(right.routeId));
+}
+export function resolveNextAppRouteId(pathname, routes, basePath = "") {
+    const normalized = normalizeNextRoutePath(pathname, basePath);
+    if (routes.some((route) => route.routeId === normalized)) {
+        return normalized;
+    }
+    const matchingRoute = [...routes]
+        .sort((left, right) => getRouteScore(right.routeId) - getRouteScore(left.routeId))
+        .find((route) => createRouteMatcher(route.routeId).test(normalized));
+    return matchingRoute?.routeId ?? "/";
+}
+export function normalizeNextRoutePath(pathname, basePath = "") {
+    const value = (pathname ?? "/").trim() || "/";
+    const withoutQuery = value.split(/[?#]/, 1)[0] || "/";
+    const normalizedPathname = withoutQuery.startsWith("/")
+        ? withoutQuery
+        : `/${withoutQuery}`;
+    const normalizedBasePath = normalizeBasePath(basePath);
+    const withoutBasePath = normalizedBasePath &&
+        (normalizedPathname === normalizedBasePath ||
+            normalizedPathname.startsWith(`${normalizedBasePath}/`))
+        ? normalizedPathname.slice(normalizedBasePath.length) || "/"
+        : normalizedPathname;
+    const withLeadingSlash = withoutBasePath.startsWith("/")
+        ? withoutBasePath
+        : `/${withoutBasePath}`;
+    return withLeadingSlash === "/" ? "/" : withLeadingSlash.replace(/\/+$/, "");
+}
+function resolveAppRoot(files) {
+    const hasRootApp = files.some((file) => file.startsWith("app/"));
+    if (hasRootApp) {
+        return "app";
+    }
+    const hasSrcApp = files.some((file) => file.startsWith("src/app/"));
+    return hasSrcApp ? "src/app" : null;
+}
+function isAppPageFile(appRoot, file) {
+    if (!file.startsWith(`${appRoot}/`)) {
+        return false;
+    }
+    const basename = file.slice(file.lastIndexOf("/") + 1);
+    if (!pageFilePattern.test(basename)) {
+        return false;
+    }
+    return file
+        .slice(appRoot.length + 1, -basename.length - 1)
+        .split("/")
+        .filter(Boolean)
+        .every((segment) => !segment.startsWith("@") && !segment.startsWith("_"));
+}
+function toRouteId(appRoot, pageFile) {
+    const relativeDirectory = pageFile
+        .slice(appRoot.length + 1)
+        .split("/")
+        .slice(0, -1)
+        .filter((segment) => isRouteSegment(segment));
+    return relativeDirectory.length === 0
+        ? "/"
+        : `/${relativeDirectory.join("/")}`;
+}
+function isRouteSegment(segment) {
+    return (Boolean(segment) &&
+        !segment.startsWith("@") &&
+        !segment.startsWith("_") &&
+        !isRouteGroup(segment));
+}
+function isRouteGroup(segment) {
+    return segment.startsWith("(") && segment.endsWith(")");
+}
+function createRouteMatcher(routeId) {
+    if (routeId === "/") {
+        return /^\/$/;
+    }
+    const pattern = routeId
+        .split("/")
+        .filter(Boolean)
+        .map((segment) => {
+        if (optionalCatchAllSegmentPattern.test(segment)) {
+            return "(?:/.*)?";
+        }
+        if (catchAllSegmentPattern.test(segment)) {
+            return "/.+";
+        }
+        if (dynamicSegmentPattern.test(segment)) {
+            return "/[^/]+";
+        }
+        return `/${escapeRegExp(segment)}`;
+    })
+        .join("");
+    return new RegExp(`^${pattern}$`);
+}
+function getRouteScore(routeId) {
+    return routeId
+        .split("/")
+        .filter(Boolean)
+        .reduce((score, segment) => {
+        if (optionalCatchAllSegmentPattern.test(segment)) {
+            return score + 1;
+        }
+        if (catchAllSegmentPattern.test(segment)) {
+            return score + 2;
+        }
+        if (dynamicSegmentPattern.test(segment)) {
+            return score + 3;
+        }
+        return score + 4;
+    }, 0);
+}
+function normalizeBasePath(basePath) {
+    const trimmed = basePath.trim();
+    if (!trimmed || trimmed === "/") {
+        return "";
+    }
+    const withLeadingSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+    return withLeadingSlash.replace(/\/+$/, "");
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function toPosixPath(value) {
+    return value.replace(/\\/g, "/").replace(/^\.\//, "");
+}