@storystick/preview 0.0.0-stage → 0.2.0-rc.0

package/dist/provenance/source-registry.js

@@ -0,0 +1,562 @@
+import { previewPaintRenderIdentityFromAnchorMap, } from "./multi-frame-anchor-map.js";
+import { previewPaintRenderIdentityEquals, } from "./anchor-map.js";
+import { findPreviewOverlayClickTarget, } from "./overlay-projection.js";
+import { normalizePreviewVariantId } from "../identity/preview-identity.js";
+export function createPreviewV2SourceIdentitySnapshot(input) {
+    if (input.ownerMap?.valid !== true)
+        return null;
+    const routeFrame = activeRouteFrame(input);
+    if (routeFrame === null || input.anchorMap === null)
+        return null;
+    const renderIdentity = previewPaintRenderIdentityFromAnchorMap(input.anchorMap);
+    if (renderIdentity === null)
+        return null;
+    const entries = new Map();
+    const markerIdsBySourceKey = new Map();
+    for (const owner of input.ownerMap.owners) {
+        const ownerFrame = activeFrameForOwner(input, owner);
+        if (ownerFrame === null)
+            continue;
+        const entry = {
+            sourceKey: owner.sourceSetId,
+            sourceKind: owner.sourceKind,
+            frameId: ownerFrame.frameId,
+            routeHash: ownerFrame.routeHash,
+            variantId: ownerFrame.variantId,
+            codeVersion: ownerFrame.codeVersion,
+            renderId: ownerFrame.renderId,
+            sourceMapBytes: input.sourceMapBytes,
+        };
+        entries.set(previewV2SourceIdentityRegistryKey({
+            documentId: owner.documentId,
+            anchoredPath: owner.canonicalPath,
+        }), entry);
+        for (const anchor of owner.pathAnchors) {
+            entries.set(previewV2SourceIdentityRegistryKey({
+                documentId: owner.documentId,
+                anchoredPath: owner.canonicalPath,
+                sliceKey: anchor.key,
+            }), entry);
+        }
+        if (owner.navigationPath !== undefined) {
+            entries.set(previewV2SourceIdentityRegistryKey({
+                documentId: owner.documentId,
+                anchoredPath: owner.navigationPath,
+            }), entry);
+            for (const anchor of owner.navigationAnchors ?? []) {
+                entries.set(previewV2SourceIdentityRegistryKey({
+                    documentId: owner.documentId,
+                    anchoredPath: owner.navigationPath,
+                    sliceKey: anchor.key,
+                }), entry);
+            }
+        }
+        const markerIds = markerIdsBySourceKey.get(owner.sourceSetId) ?? [];
+        markerIds.push(owner.markerId);
+        markerIdsBySourceKey.set(owner.sourceSetId, markerIds);
+    }
+    return {
+        renderIdentity,
+        entries,
+        markerIdsBySourceKey,
+    };
+}
+export function createPreviewV2SourceRegistry(input) {
+    const sourceMapBytes = input.sourceMapBytes;
+    const resolveSourceIdentity = (request) => {
+        const owner = findOwnerForStudioTarget(input, request);
+        if (owner === null) {
+            return cachedSourceIdentityForStudioTarget(input, request);
+        }
+        const ownerFrame = activeFrameForOwner(input, owner);
+        if (ownerFrame === null) {
+            return cachedSourceIdentityForStudioTarget(input, request, {
+                allowWithValidOwnerMap: true,
+            });
+        }
+        return {
+            sourceKey: owner.sourceSetId,
+            sourceKind: owner.sourceKind,
+            frameId: ownerFrame.frameId,
+            routeHash: ownerFrame.routeHash,
+            variantId: ownerFrame.variantId,
+            codeVersion: ownerFrame.codeVersion,
+            renderId: ownerFrame.renderId,
+            markerIds: [...markerIdsForSourceKey(input, owner.sourceSetId)],
+            sourceMapBytes,
+        };
+    };
+    const resolveActiveRenderTargetCandidates = (sourceKey) => {
+        const sourceFrames = activeSourceFramesForSourceKey(input, sourceKey);
+        if (sourceFrames.length === 0)
+            return [];
+        const targets = [];
+        for (const { frame, markerIds } of sourceFrames) {
+            for (const anchor of frame.anchors) {
+                if (!markerIds.has(anchor.markerId))
+                    continue;
+                if (anchor.paintId === undefined || anchor.paintId.length === 0)
+                    continue;
+                targets.push({
+                    target: {
+                        renderTargetId: anchor.paintId,
+                        markerId: anchor.markerId,
+                    },
+                    ...(anchor.documentRect !== undefined
+                        ? { documentRect: anchor.documentRect }
+                        : {}),
+                });
+            }
+        }
+        return targets;
+    };
+    const resolveActiveRenderTargets = (sourceKey) => resolveActiveRenderTargetCandidates(sourceKey).map((candidate) => candidate.target);
+    const resolveActivePaintTarget = (args) => {
+        if (input.anchorMap === null || input.ownerMap?.valid !== true)
+            return null;
+        let resolved = null;
+        for (const frame of input.anchorMap.maps) {
+            for (const anchor of frame.anchors) {
+                if (anchor.paintId !== args.activePaint.paintId ||
+                    anchor.markerId !== args.activePaint.markerId)
+                    continue;
+                const owner = input.ownerMap.ownerByMarkerId.get(anchor.markerId);
+                if (owner === undefined ||
+                    owner.frameId !== frame.frameId ||
+                    owner.documentId !== args.owner.documentId ||
+                    owner.sourceSetId !== args.owner.sourceSetId ||
+                    owner.markerId !== args.owner.markerId ||
+                    args.activePaint.sourceSetId !== args.owner.sourceSetId) {
+                    continue;
+                }
+                if (resolved !== null)
+                    return null;
+                resolved = {
+                    target: {
+                        renderTargetId: anchor.paintId,
+                        markerId: anchor.markerId,
+                    },
+                    sourceKey: owner.sourceSetId,
+                };
+            }
+        }
+        return resolved;
+    };
+    const resolveRevealPayloadForStudioTarget = (args) => {
+        const identity = resolveSourceIdentity(args.request);
+        if (identity === null) {
+            return { ok: false, sourceKey: null, status: "unknownSource" };
+        }
+        const routeFrame = activeRouteFrame(input);
+        if (routeFrame === null || input.anchorMap === null) {
+            return {
+                ok: false,
+                sourceKey: identity.sourceKey,
+                status: "routeMissing",
+            };
+        }
+        const owner = findOwnerForStudioTarget(input, args.request);
+        const activePaint = owner === null
+            ? null
+            : (input.activePaintFor?.(owner.documentId, owner.sourceSetId) ?? null);
+        if (owner !== null &&
+            activePaint !== null &&
+            activePaintMatchesRenderIdentity(activePaint, input.anchorMap)) {
+            const activeTarget = resolveActivePaintTarget({
+                activePaint,
+                owner,
+            });
+            if (activeTarget !== null) {
+                return {
+                    ok: true,
+                    expectedStatus: "found",
+                    selection: { kind: "active-paint", paintId: activePaint.paintId },
+                    payload: {
+                        generation: input.anchorMap.generation,
+                        routeHash: input.anchorMap.routeHash,
+                        variantId: input.anchorMap.variantId,
+                        codeVersion: input.anchorMap.codeVersion,
+                        renderId: routeFrame.renderId,
+                        requestId: args.requestId,
+                        sourceKey: activeTarget.sourceKey,
+                        targetSelection: "active-paint",
+                        targets: [activeTarget.target],
+                        behavior: args.behavior,
+                    },
+                };
+            }
+        }
+        const candidates = resolveActiveRenderTargetCandidates(identity.sourceKey);
+        if (candidates.length === 0) {
+            return {
+                ok: false,
+                sourceKey: identity.sourceKey,
+                status: "notMounted",
+            };
+        }
+        const fallback = fallbackRenderTarget(candidates, input.currentViewport?.() ?? input.anchorMap.viewport);
+        return {
+            ok: true,
+            expectedStatus: "found",
+            selection: {
+                kind: fallback.usedViewport
+                    ? "nearest-viewport-fallback"
+                    : "first-document-fallback",
+                paintId: fallback.candidate.target.renderTargetId,
+            },
+            payload: {
+                generation: input.anchorMap.generation,
+                routeHash: input.anchorMap.routeHash,
+                variantId: input.anchorMap.variantId,
+                codeVersion: input.anchorMap.codeVersion,
+                renderId: routeFrame.renderId,
+                requestId: args.requestId,
+                sourceKey: identity.sourceKey,
+                targetSelection: fallback.usedViewport
+                    ? "nearest-viewport-fallback"
+                    : "first-document-fallback",
+                targets: [fallback.candidate.target],
+                behavior: args.behavior,
+            },
+        };
+    };
+    const resolveRevealPayloadForStudioSlice = (args) => {
+        const ownerMap = input.ownerMap;
+        if (ownerMap?.valid !== true) {
+            return { ok: false, sourceKey: null, status: "unknownSource" };
+        }
+        const candidates = ownerMap.owners.filter((owner) => owner.documentId === args.request.documentId &&
+            ownerAnchors(owner).some((anchor) => anchor.key === args.request.sliceKey));
+        const revealTargetsForOwner = (candidate) => resolveActiveRenderTargets(candidate.sourceSetId).filter((target) => target.markerId === candidate.markerId);
+        const owner = candidates.find((candidate) => revealTargetsForOwner(candidate).length > 0) ??
+            candidates.find((candidate) => activeFrameForOwner(input, candidate)) ??
+            candidates[0] ??
+            null;
+        if (owner === null) {
+            return { ok: false, sourceKey: null, status: "unknownSource" };
+        }
+        const routeFrame = activeRouteFrame(input);
+        if (routeFrame === null || input.anchorMap === null) {
+            return {
+                ok: false,
+                sourceKey: owner.sourceSetId,
+                status: "routeMissing",
+            };
+        }
+        // Slice focus is structural and singular. Use the exact owner's first
+        // mounted marker to scroll the iframe, while the parent-rendered slice
+        // overlay owns the persistent visual. This avoids flashing a field or
+        // surfacing an irrelevant "multiple matches" notice.
+        const targets = revealTargetsForOwner(owner).slice(0, 1);
+        if (targets.length === 0) {
+            return {
+                ok: false,
+                sourceKey: owner.sourceSetId,
+                status: "notMounted",
+            };
+        }
+        return {
+            ok: true,
+            expectedStatus: "found",
+            selection: {
+                kind: "first-document-fallback",
+                paintId: targets[0].renderTargetId,
+            },
+            payload: {
+                generation: input.anchorMap.generation,
+                routeHash: input.anchorMap.routeHash,
+                variantId: input.anchorMap.variantId,
+                codeVersion: input.anchorMap.codeVersion,
+                renderId: routeFrame.renderId,
+                requestId: args.requestId,
+                sourceKey: owner.sourceSetId,
+                targetSelection: "first-document-fallback",
+                targets,
+                behavior: args.behavior,
+            },
+        };
+    };
+    const resolveEditableTargetFromOverlayClick = (payload, options = {}) => {
+        const active = input.activeOverlayTargets ?? null;
+        if (active === null)
+            return null;
+        if (options.expectedPresentationDocumentId !== undefined &&
+            options.expectedPresentationDocumentId !==
+                active.presentationFrameIdentity.documentId) {
+            return null;
+        }
+        if (active.generation !== payload.generation)
+            return null;
+        if (active.renderIdentity.routeHash !== payload.routeHash)
+            return null;
+        if (active.renderIdentity.codeVersion !== payload.codeVersion)
+            return null;
+        if (active.renderIdentity.renderId !== payload.renderId)
+            return null;
+        const target = findPreviewOverlayClickTarget(active.targets, payload);
+        if (target === null)
+            return null;
+        const activeVariantId = normalizePreviewVariantId(active.renderIdentity.variantId);
+        if (activeVariantId !== null &&
+            target.documentId === active.presentationFrameIdentity.documentId) {
+            return {
+                ...target,
+                variantId: activeVariantId,
+            };
+        }
+        return target;
+    };
+    return {
+        resolveSourceIdentity,
+        resolveActiveRenderTargets,
+        resolveRevealPayloadForStudioTarget,
+        resolveRevealPayloadForStudioSlice,
+        resolveEditableTargetFromOverlayClick,
+    };
+}
+function findOwnerForStudioTarget(input, request) {
+    const ownerMap = input.ownerMap;
+    if (ownerMap?.valid !== true)
+        return null;
+    const candidates = ownerMap.owners.filter((candidate) => {
+        if (candidate.documentId !== request.documentId)
+            return false;
+        if (request.expectedSourceKey !== undefined &&
+            candidate.sourceSetId !== request.expectedSourceKey)
+            return false;
+        if (!ownerPathMatchesRequest(candidate, request))
+            return false;
+        if (!matchesExpectedSourceKind(candidate, request))
+            return false;
+        if (!matchesRichTextTextNode(candidate, request))
+            return false;
+        if (!matchesRichTextSliceEmbed(candidate, request))
+            return false;
+        if (request.sliceKey === undefined)
+            return true;
+        return ownerAnchors(candidate).some((anchor) => anchor.key === request.sliceKey);
+    });
+    if (candidates.length === 0)
+        return null;
+    if (request.expectedSourceKind !== "richtext")
+        return candidates[0] ?? null;
+    return ([...candidates].sort((a, b) => richtextOwnerRenderRank(input, a) - richtextOwnerRenderRank(input, b))[0] ?? null);
+}
+function activePaintMatchesRenderIdentity(activePaint, anchorMap) {
+    const anchorIdentity = previewPaintRenderIdentityFromAnchorMap(anchorMap);
+    return (anchorIdentity !== null &&
+        previewPaintRenderIdentityEquals(activePaint.renderIdentity, anchorIdentity));
+}
+function fallbackRenderTarget(candidates, viewport) {
+    const first = candidates[0];
+    if (!isFiniteRect(viewport)) {
+        return { candidate: first, usedViewport: false };
+    }
+    let nearest = null;
+    let nearestDistance = Number.POSITIVE_INFINITY;
+    for (const candidate of candidates) {
+        if (!isFiniteRect(candidate.documentRect))
+            continue;
+        const distance = squaredDistanceBetweenRects(candidate.documentRect, viewport);
+        if (distance >= nearestDistance)
+            continue;
+        nearest = candidate;
+        nearestDistance = distance;
+    }
+    return nearest === null
+        ? { candidate: first, usedViewport: false }
+        : { candidate: nearest, usedViewport: true };
+}
+function squaredDistanceBetweenRects(left, right) {
+    const horizontalGap = Math.max(right.x - (left.x + left.width), left.x - (right.x + right.width), 0);
+    const verticalGap = Math.max(right.y - (left.y + left.height), left.y - (right.y + right.height), 0);
+    return horizontalGap * horizontalGap + verticalGap * verticalGap;
+}
+function isFiniteRect(rect) {
+    return (rect !== undefined &&
+        Number.isFinite(rect.x) &&
+        Number.isFinite(rect.y) &&
+        Number.isFinite(rect.width) &&
+        rect.width >= 0 &&
+        Number.isFinite(rect.height) &&
+        rect.height >= 0);
+}
+function richtextOwnerRenderRank(input, owner) {
+    const frame = activeFrameById(input, owner.frameId);
+    if (frame === null)
+        return 3;
+    const anchors = frame.anchors.filter((anchor) => anchor.markerId === owner.markerId);
+    if (anchors.some((anchor) => anchor.carrier !== "coded-text"))
+        return 0;
+    if (anchors.some((anchor) => anchor.carrier === "coded-text"))
+        return 1;
+    return 2;
+}
+function ownerPathMatchesRequest(owner, request) {
+    return (owner.canonicalPath === request.anchoredPath ||
+        owner.navigationPath === request.anchoredPath);
+}
+function ownerAnchors(owner) {
+    return [...owner.pathAnchors, ...(owner.navigationAnchors ?? [])];
+}
+function matchesRichTextTextNode(owner, request) {
+    return (request.richTextTextNodeIndex === undefined ||
+        owner.richTextTextNodeIndex === request.richTextTextNodeIndex);
+}
+function matchesRichTextSliceEmbed(owner, request) {
+    if (request.richTextSliceEmbedIndex !== undefined &&
+        owner.richTextSliceEmbedIndex !== request.richTextSliceEmbedIndex) {
+        return false;
+    }
+    return (request.richTextSliceEmbedKey === undefined ||
+        owner.richTextSliceEmbedKey === request.richTextSliceEmbedKey);
+}
+function cachedSourceIdentityForStudioTarget(input, request, options = {}) {
+    if (request.expectedSourceKind === "richtext")
+        return null;
+    const snapshot = activeSourceIdentitySnapshot(input);
+    if (snapshot === null)
+        return null;
+    const entry = snapshot.entries.get(previewV2SourceIdentityRegistryKey(request)) ?? null;
+    if (entry === null)
+        return null;
+    if (!cachedFrameIdentityStillCurrent(input, entry))
+        return null;
+    if (input.ownerMap?.valid === true &&
+        options.allowWithValidOwnerMap !== true &&
+        activeFrameById(input, entry.frameId) !== null) {
+        return null;
+    }
+    if (entry.sourceKind === "richtext")
+        return null;
+    if (!matchesExpectedSourceKind(entry, request))
+        return null;
+    return {
+        ...entry,
+        markerIds: [...(snapshot.markerIdsBySourceKey.get(entry.sourceKey) ?? [])],
+    };
+}
+function cachedFrameIdentityStillCurrent(input, frame) {
+    const activeFrame = activeFrameById(input, frame.frameId);
+    return (activeFrame === null ||
+        (activeFrame.routeHash === frame.routeHash &&
+            normalizePreviewVariantId(activeFrame.variantId) ===
+                normalizePreviewVariantId(frame.variantId) &&
+            activeFrame.codeVersion === frame.codeVersion &&
+            activeFrame.renderId === frame.renderId));
+}
+function matchesExpectedSourceKind(owner, request) {
+    return (request.expectedSourceKind === undefined ||
+        owner.sourceKind === request.expectedSourceKind);
+}
+function activeSourceIdentitySnapshot(input) {
+    const snapshot = input.sourceIdentitySnapshot ?? null;
+    if (snapshot === null)
+        return null;
+    const routeFrame = activeRouteFrameIdentity(input);
+    if (routeFrame === null || input.anchorMap === null)
+        return null;
+    const renderIdentity = previewPaintRenderIdentityFromAnchorMap(input.anchorMap);
+    if (renderIdentity === null)
+        return null;
+    if (!previewPaintRenderIdentityEquals(snapshot.renderIdentity, renderIdentity)) {
+        return null;
+    }
+    return snapshot;
+}
+function ownersForSourceKey(input, sourceKey) {
+    const ownerMap = input.ownerMap;
+    if (ownerMap?.valid !== true)
+        return [];
+    return ownerMap.owners.filter((owner) => owner.sourceSetId === sourceKey);
+}
+function markerIdsForSourceKey(input, sourceKey) {
+    if (input.ownerMap?.valid === true) {
+        return new Set(ownersForSourceKey(input, sourceKey).map((owner) => owner.markerId));
+    }
+    const snapshot = activeSourceIdentitySnapshot(input);
+    return new Set(snapshot?.markerIdsBySourceKey.get(sourceKey) ?? []);
+}
+function activeSourceFramesForSourceKey(input, sourceKey) {
+    if (input.ownerMap?.valid === true) {
+        const markerIdsByFrameId = new Map();
+        for (const owner of ownersForSourceKey(input, sourceKey)) {
+            const markerIds = markerIdsByFrameId.get(owner.frameId) ?? new Set();
+            markerIds.add(owner.markerId);
+            markerIdsByFrameId.set(owner.frameId, markerIds);
+        }
+        return [...markerIdsByFrameId.entries()].flatMap(([frameId, markerIds]) => {
+            const frame = activeFrameById(input, frameId);
+            return frame === null ? [] : [{ frame, markerIds }];
+        });
+    }
+    const snapshot = activeSourceIdentitySnapshot(input);
+    if (snapshot === null)
+        return [];
+    const markerIds = new Set(snapshot.markerIdsBySourceKey.get(sourceKey) ?? []);
+    if (markerIds.size === 0)
+        return [];
+    const frameIds = new Set([...snapshot.entries.values()]
+        .filter((entry) => entry.sourceKey === sourceKey)
+        .map((entry) => entry.frameId));
+    return [...frameIds].flatMap((frameId) => {
+        const frame = activeFrameById(input, frameId);
+        return frame === null ? [] : [{ frame, markerIds }];
+    });
+}
+function activeRouteFrame(input) {
+    const routeFrame = activeRouteFrameIdentity(input);
+    if (routeFrame === null || input.anchorMap === null)
+        return null;
+    if (!input.anchorMap.valid || !routeFrame.valid)
+        return null;
+    return routeFrame;
+}
+function activeFrameForOwner(input, owner) {
+    return activeFrameById(input, owner.frameId);
+}
+function activeFrameById(input, frameId) {
+    const { sessionId, anchorMap } = input;
+    if (sessionId === null || anchorMap === null)
+        return null;
+    if (anchorMap.pending || !anchorMap.valid)
+        return null;
+    if (anchorMap.sessionId !== sessionId)
+        return null;
+    const frame = anchorMap.maps.find((map) => map.frameId === frameId);
+    if (frame === undefined)
+        return null;
+    if (!frame.valid)
+        return null;
+    if (frame.codeVersion !== anchorMap.codeVersion)
+        return null;
+    if (frame.renderId.length === 0)
+        return null;
+    return frame;
+}
+function activeRouteFrameIdentity(input) {
+    const { sessionId, anchorMap } = input;
+    if (sessionId === null || anchorMap === null)
+        return null;
+    if (anchorMap.pending)
+        return null;
+    if (anchorMap.sessionId !== sessionId)
+        return null;
+    const routeFrame = anchorMap.maps.find((map) => map.frameId === "route");
+    if (routeFrame === undefined)
+        return null;
+    if (routeFrame.routeHash !== anchorMap.routeHash)
+        return null;
+    if (routeFrame.codeVersion !== anchorMap.codeVersion)
+        return null;
+    if (routeFrame.renderId.length === 0)
+        return null;
+    return routeFrame;
+}
+function previewV2SourceIdentityRegistryKey(request) {
+    return [
+        request.documentId,
+        request.anchoredPath,
+        request.sliceKey ?? "",
+    ].join("\u0000");
+}