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

package/dist/runtime-sync.js

@@ -1,321 +0,0 @@
-export const DEFAULT_SITE_EDIT_RUNTIME_READY_TIMEOUT_MS = 1500;
-export const SITE_EDIT_RUNTIME_READY_POLL_INTERVAL_MS = 16;
-export const SITE_EDIT_RUNTIME_ATTRIBUTES = {
-    key: "data-vcp-edit-key",
-    parentKey: "data-vcp-edit-parent-key",
-    movable: "data-vcp-movable",
-    removable: "data-vcp-removable",
-    flags: "data-vcp-flags",
-};
-const CONTAINER_TAGS = new Set([
-    "article",
-    "aside",
-    "div",
-    "footer",
-    "form",
-    "header",
-    "li",
-    "main",
-    "nav",
-    "ol",
-    "section",
-    "ul",
-]);
-const TEXT_TAGS = new Set([
-    "a",
-    "button",
-    "em",
-    "h1",
-    "h2",
-    "h3",
-    "h4",
-    "h5",
-    "h6",
-    "label",
-    "p",
-    "small",
-    "span",
-    "strong",
-]);
-const STRONG_SYNC_OPERATION_KINDS = new Set([
-    "update-text",
-    "remove-node",
-    "insert-child",
-    "move-node",
-    "replace-rich-text-content",
-    "insert-rich-text-block",
-    "remove-rich-text-block",
-    "set-media-field",
-    "set-component-slot-content",
-    "set-object-field",
-    "insert-object-field",
-    "remove-object-field",
-    "update-array-item",
-    "insert-array-item",
-    "remove-array-item",
-    "move-array-item",
-    "replace-conditional-expression",
-    "set-conditional-branch-content",
-    "set-jsx-prop",
-    "remove-jsx-prop",
-    "set-class-name",
-    "add-class-token",
-    "remove-class-token",
-    "set-style-property",
-    "set-style-properties",
-    "set-css-module-class",
-]);
-export function diffSiteEditRenderDocuments(previous_document, next_document) {
-    const previousEntries = new Map(previous_document.entries.map((entry) => [entry.key, entry]));
-    const nextEntries = new Map(next_document.entries.map((entry) => [entry.key, entry]));
-    const added_keys = next_document.entries
-        .map((entry) => entry.key)
-        .filter((key) => !previousEntries.has(key));
-    const removed_keys = previous_document.entries
-        .map((entry) => entry.key)
-        .filter((key) => !nextEntries.has(key));
-    const retained_keys = next_document.entries
-        .map((entry) => entry.key)
-        .filter((key) => previousEntries.has(key));
-    const changed_parentKeys = retained_keys.filter((key) => previousEntries.get(key)?.parentKey !== nextEntries.get(key)?.parentKey);
-    const changed_child_order_keys = retained_keys.filter((key) => {
-        const previousChildren = previousEntries.get(key)?.childKeys ?? [];
-        const nextChildren = nextEntries.get(key)?.childKeys ?? [];
-        return previousChildren.join("\u0000") !== nextChildren.join("\u0000");
-    });
-    return {
-        added_keys,
-        removed_keys,
-        retained_keys,
-        changed_parentKeys,
-        changed_child_order_keys,
-    };
-}
-export function isSiteEditRuntimeSyncedOperation(kind) {
-    return STRONG_SYNC_OPERATION_KINDS.has(kind);
-}
-export class SiteEditRuntimeDomAdapter {
-    constructor(documentLike, attributes = SITE_EDIT_RUNTIME_ATTRIBUTES) {
-        this.documentLike = documentLike;
-        this.attributes = attributes;
-    }
-    getKeyFromElement(element) {
-        return element.getAttribute(this.attributes.key);
-    }
-    findEditableElement(element) {
-        return element?.closest(`[${this.attributes.key}]`) ?? null;
-    }
-    findElementByKey(key) {
-        return (this.documentLike?.querySelector(`[${this.attributes.key}="${escapeAttributeValue(key)}"]`) ?? null);
-    }
-    findElementByRef(ref) {
-        if (typeof ref.instance_index !== "number" ||
-            typeof ref.instance_count !== "number" ||
-            ref.instance_count <= 1 ||
-            !this.documentLike?.querySelectorAll) {
-            return this.findElementByKey(ref.key);
-        }
-        const matches = Array.from(this.documentLike.querySelectorAll(`[${this.attributes.key}]`)).filter((item) => item.getAttribute(this.attributes.key) === ref.key);
-        return matches[ref.instance_index] ?? null;
-    }
-    snapshot(element) {
-        const attributes = Object.fromEntries(element
-            .getAttributeNames()
-            .map((name) => [name, element.getAttribute(name) ?? ""]));
-        const key = element.getAttribute(this.attributes.key) ?? "";
-        const tagName = element.tagName.toLowerCase();
-        const textPreview = element.textContent?.trim().slice(0, 80);
-        const snapshot = {
-            key,
-            tag_name: tagName,
-            attributes,
-            runtime_flags: {
-                editable: true,
-                movable: element.getAttribute(this.attributes.movable) !== "false",
-                removable: element.getAttribute(this.attributes.removable) !== "false",
-                text_editable: TEXT_TAGS.has(tagName),
-                container: CONTAINER_TAGS.has(tagName),
-            },
-        };
-        const instancePosition = this.resolveInstancePosition(element, key);
-        if (instancePosition) {
-            snapshot.instance_index = instancePosition.index;
-            snapshot.instance_count = instancePosition.count;
-        }
-        if (textPreview !== undefined) {
-            snapshot.text_preview = textPreview;
-        }
-        return snapshot;
-    }
-    resolveInstancePosition(element, key) {
-        if (!key || !this.documentLike?.querySelectorAll) {
-            return null;
-        }
-        const matches = Array.from(this.documentLike.querySelectorAll(`[${this.attributes.key}]`)).filter((item) => item.getAttribute(this.attributes.key) === key);
-        if (matches.length <= 1) {
-            return null;
-        }
-        const index = matches.indexOf(element);
-        if (index < 0) {
-            return null;
-        }
-        return {
-            count: matches.length,
-            index,
-        };
-    }
-}
-export class SiteEditRuntimeReadyProbe {
-    constructor(documentLike, attributes = SITE_EDIT_RUNTIME_ATTRIBUTES) {
-        this.dom = new SiteEditRuntimeDomAdapter(documentLike, attributes);
-    }
-    probe(input, diff = diffSiteEditRenderDocuments(input.previous_document, input.next_document)) {
-        const rootKeys = input.next_document.rootKeys.length > 0
-            ? input.next_document.rootKeys
-            : input.next_document.entries.slice(0, 1).map((entry) => entry.key);
-        const missingRoot = rootKeys.find((key) => !this.dom.findElementByKey(key));
-        if (missingRoot) {
-            return failure(input, "missing-root", "document-root", `preview root is missing: ${missingRoot}`);
-        }
-        if (input.selected_key &&
-            hasDocumentKey(input.next_document, input.selected_key) &&
-            !this.dom.findElementByKey(input.selected_key)) {
-            return failure(input, "missing-selected-key", "selected-node", `selected node is missing from preview DOM: ${input.selected_key}`);
-        }
-        const kind = input.request?.kind ?? input.result.kind;
-        if (!isSiteEditRuntimeSyncedOperation(kind)) {
-            return failure(input, "unsupported-operation", "operation-specific", `runtime ready check is not implemented for ${kind}`);
-        }
-        return this.checkOperationProjection(input, diff);
-    }
-    checkOperationProjection(input, diff) {
-        const kind = input.request?.kind ?? input.result.kind;
-        const targetKey = getNodeTargetKey(input.request) ?? getNodeTargetKey(input.result);
-        if (kind === "update-text" &&
-            input.request?.params.kind === "update-text") {
-            return this.checkTextProjection(input, targetKey);
-        }
-        if (kind === "remove-node" &&
-            targetKey &&
-            !hasDocumentKey(input.next_document, targetKey)) {
-            if (this.dom.findElementByKey(targetKey)) {
-                return failure(input, "removed-target-still-present", "removed-node", `removed node is still present in preview DOM: ${targetKey}`);
-            }
-            return this.checkGenericDiffProjection(input, diff, "removed-node");
-        }
-        if (kind === "insert-child") {
-            const addedResult = this.checkAddedKeys(input, diff, "inserted-node");
-            return addedResult.ok
-                ? this.checkGenericDiffProjection(input, diff, "inserted-node")
-                : addedResult;
-        }
-        if (kind === "move-node") {
-            return this.checkMovedNodeProjection(input, diff, targetKey);
-        }
-        return this.checkGenericDiffProjection(input, diff, "document-diff");
-    }
-    checkTextProjection(input, targetKey) {
-        if (!targetKey) {
-            return failure(input, "missing-target", "text-content", "update-text target key is missing");
-        }
-        const target = this.dom.findElementByKey(targetKey);
-        if (!target) {
-            return failure(input, "missing-target", "text-content", `update-text target is missing: ${targetKey}`);
-        }
-        const actualText = normalizeText(target.textContent ?? "");
-        const params = input.request?.params;
-        const expectedText = normalizeText(params?.kind === "update-text" ? params.value : "");
-        if (actualText !== expectedText) {
-            return failure(input, "text-mismatch", "text-content", `preview text has not updated for ${targetKey}`);
-        }
-        return success(input, "text-content", [targetKey]);
-    }
-    checkMovedNodeProjection(input, diff, targetKey) {
-        if (targetKey && !this.dom.findElementByKey(targetKey)) {
-            return failure(input, "missing-target", "moved-node", `moved node is missing: ${targetKey}`);
-        }
-        for (const parentKey of diff.changed_child_order_keys) {
-            const parent = input.next_document.entries.find((entry) => entry.key === parentKey);
-            if (!parent || !this.isChildOrderReady(parent.childKeys)) {
-                return failure(input, "order-mismatch", "child-order", `child order is not ready for ${parentKey}`);
-            }
-        }
-        return this.checkGenericDiffProjection(input, diff, "moved-node");
-    }
-    checkGenericDiffProjection(input, diff, check) {
-        const addedResult = this.checkAddedKeys(input, diff, check);
-        if (!addedResult.ok) {
-            return addedResult;
-        }
-        const presentRemovedKey = diff.removed_keys.find((key) => this.dom.findElementByKey(key));
-        if (presentRemovedKey) {
-            return failure(input, "removed-target-still-present", check, `removed node is still present in preview DOM: ${presentRemovedKey}`);
-        }
-        return success(input, check, [
-            ...input.next_document.rootKeys,
-            ...diff.added_keys,
-            ...diff.changed_parentKeys,
-            ...diff.changed_child_order_keys,
-        ]);
-    }
-    checkAddedKeys(input, diff, check) {
-        const missingAddedKey = diff.added_keys.find((key) => !this.dom.findElementByKey(key));
-        if (missingAddedKey) {
-            return failure(input, "missing-added-key", check, `added node is missing from preview DOM: ${missingAddedKey}`);
-        }
-        return success(input, check, diff.added_keys);
-    }
-    isChildOrderReady(childKeys) {
-        const elements = childKeys
-            .map((key) => this.dom.findElementByKey(key))
-            .filter((element) => Boolean(element));
-        if (elements.length < 2) {
-            return elements.length === childKeys.length;
-        }
-        for (let index = 1; index < elements.length; index += 1) {
-            const previous = elements[index - 1];
-            const current = elements[index];
-            if (previous &&
-                current &&
-                (previous.compareDocumentPosition(current) & 4) === 0) {
-                return false;
-            }
-        }
-        return elements.length === childKeys.length;
-    }
-}
-export function getSiteEditNodeTargetKey(input) {
-    return getNodeTargetKey(input);
-}
-export function hasSiteEditDocumentKey(document, key) {
-    return hasDocumentKey(document, key);
-}
-function getNodeTargetKey(input) {
-    return input?.target.kind === "node" ? input.target.key : null;
-}
-function hasDocumentKey(document, key) {
-    return document.entries.some((entry) => entry.key === key);
-}
-function normalizeText(value) {
-    return value.replace(/\s+/g, " ").trim();
-}
-function success(input, check, observed_keys) {
-    return {
-        ok: true,
-        version: input.next_document.version,
-        observed_keys: [...new Set(observed_keys.filter(Boolean))],
-        check,
-    };
-}
-function failure(input, reason, check, message) {
-    return {
-        ok: false,
-        version: input.next_document.version,
-        reason,
-        check,
-        message,
-    };
-}
-function escapeAttributeValue(value) {
-    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-}

package/dist/runtime.js

@@ -1,134 +0,0 @@
-import { SiteEditPatchPlanSchema } from "@trojanbox-vcp-test/contracts";
-import { toInternalOperationRequest, toSiteEditEvent, toSiteEditObjectContentDetail, toSiteEditObjectDetail, toSiteEditObjectEditContext, toSiteEditObjectMediaDetail, toSiteEditObjectStyleDetail, toSiteEditObjectSummary, toSiteEditOperationResult, toSiteEditRenderDocument, } from "./internal-adapter.js";
-import { createInternalEditEngine } from "./internal/runtime/InternalEditEngine.js";
-import { sha256ContentHash, SnapshotFileSystem, } from "./snapshot-file-system.js";
-export class SnapshotSiteEditEngineRuntime {
-    constructor(options) {
-        this.options = options;
-        this.fileSystem = new SnapshotFileSystem(options.files);
-        this.engine = this.createEngine(this.fileSystem);
-    }
-    get status() {
-        return this.engine.status;
-    }
-    async setActiveRoute(routeId) {
-        await this.engine.setActiveRoute(routeId);
-    }
-    getDocument(routeId) {
-        return toSiteEditRenderDocument(this.engine.getDocument(routeId), {
-            siteId: this.options.siteId,
-            snapshotId: this.options.snapshotId,
-        });
-    }
-    getObjectCapabilities(key, routeId) {
-        const detail = toSiteEditObjectDetail(this.engine.getRenderDetail(key, routeId));
-        return {
-            key: detail.key,
-            canUpdateText: detail.capabilities.canUpdateText,
-            canInsertChild: detail.capabilities.canInsertChild,
-            canMove: detail.capabilities.canMove,
-            canRemove: detail.capabilities.canRemove,
-            boundaryKind: detail.boundaryKind,
-            isOpaque: detail.isOpaque,
-        };
-    }
-    getObjectSummary(key, routeId) {
-        return toSiteEditObjectSummary(this.engine.getRenderDetail(key, routeId));
-    }
-    getObjectEditContext(key, routeId) {
-        return toSiteEditObjectEditContext(this.engine.getRenderDetail(key, routeId));
-    }
-    getObjectStyleDetail(key, routeId) {
-        return toSiteEditObjectStyleDetail(this.engine.getRenderDetail(key, routeId));
-    }
-    getObjectContentDetail(key, routeId) {
-        return toSiteEditObjectContentDetail(this.engine.getRenderDetail(key, routeId));
-    }
-    getObjectMediaDetail(key, routeId) {
-        return toSiteEditObjectMediaDetail(this.engine.getRenderDetail(key, routeId));
-    }
-    getClassNameSource(key, routeId) {
-        return this.engine.getClassNameSource(key, routeId);
-    }
-    setClassNameSource(request) {
-        return this.engine.setClassNameSource(request);
-    }
-    async planOperation(request) {
-        const scratchFileSystem = new SnapshotFileSystem(this.options.files);
-        const scratchEngine = this.createEngine(scratchFileSystem);
-        for (const route of this.options.routes) {
-            await scratchEngine.setActiveRoute(route.routeId);
-        }
-        const result = toSiteEditOperationResult(await scratchEngine.execute(toInternalOperationRequest(request)));
-        if (!result.ok) {
-            return { result };
-        }
-        const changedFiles = scratchFileSystem.getChangedFiles();
-        if (changedFiles.length === 0) {
-            return { result };
-        }
-        const patchPlan = SiteEditPatchPlanSchema.parse({
-            siteId: request.siteId,
-            baseSnapshotId: request.baseSnapshotId,
-            operationId: request.id,
-            reason: `site-edit:${request.kind}`,
-            patches: changedFiles.map((file) => ({
-                path: file.path,
-                operation: file.before === undefined ? "create" : "update",
-                expectedHash: file.before === undefined
-                    ? undefined
-                    : sha256ContentHash(file.before),
-                fullContent: file.after,
-            })),
-            changedRouteIds: this.getChangedRouteIds(changedFiles.map((file) => file.path)),
-            diagnostics: [],
-        });
-        this.options.onEvent?.({
-            type: "site-edit.operation.planned",
-            siteId: request.siteId,
-            operationId: request.id,
-            baseSnapshotId: request.baseSnapshotId,
-            changedFiles: patchPlan.patches.map((patch) => patch.path),
-            at: new Date().toISOString(),
-        });
-        return { result, patchPlan };
-    }
-    dispose() {
-        this.engine.dispose();
-    }
-    createEngine(fileSystem) {
-        return createInternalEditEngine({
-            projectRoot: "/snapshot",
-            fileSystem,
-            routes: this.options.routes.map((route) => ({
-                routeId: route.routeId,
-                entryFile: route.entryFile,
-            })),
-            onEvent: this.options.onEvent
-                ? (event) => {
-                    const siteEditEvent = toSiteEditEvent(event, {
-                        siteId: this.options.siteId,
-                        snapshotId: this.options.snapshotId,
-                    });
-                    if (siteEditEvent) {
-                        this.options.onEvent?.(siteEditEvent);
-                    }
-                }
-                : undefined,
-            dev: this.options.dev,
-        });
-    }
-    getChangedRouteIds(changedPaths) {
-        const changedPathSet = new Set(changedPaths);
-        const directlyChangedRoutes = this.options.routes
-            .filter((route) => changedPathSet.has(route.entryFile))
-            .map((route) => route.routeId);
-        if (directlyChangedRoutes.length > 0) {
-            return directlyChangedRoutes;
-        }
-        return this.options.routes.map((route) => route.routeId);
-    }
-}
-export function createSiteEditEngineRuntime(options) {
-    return new SnapshotSiteEditEngineRuntime(options);
-}