nudge-ui 0.2.2 → 0.2.3

package/dist/inspector/changes/draftChanges.js

@@ -0,0 +1,300 @@
+import { canWriteWorkspace } from "../canvas/workspaceLease.js";
+import { applicationTarget, targetKey } from "../drafts/model.js";
+import { changeKey, mergeChange, sameEffectiveChanges, selectorForChange } from "./model.js";
+import { isElementChange } from "./types.js";
+import { recordEdit, replayTimeline, pruneDraftHistory, timelineStatus, subscribeTimeline, clearSessionUndoHistory, discardDraftHistory, } from "../workspace/timeline.js";
+export { recordCanvasChange, discardCanvasHistory, discardDraftHistory, clearSessionUndoHistory, createChangeHistoryGroup, } from "../workspace/timeline.js";
+const drafts = new Map();
+const lockedDrafts = new Set();
+const listeners = new Set();
+const draftListeners = new Set();
+/** Until a frame is activated, edits belong to the current page's draft. */
+let activeDraftId = null;
+function activeId() {
+    return activeDraftId ??= targetKey(applicationTarget());
+}
+function draftState(id = activeId()) {
+    let draft = drafts.get(id);
+    if (!draft) {
+        draft = { id, revision: 0, contents: { changes: [], structuralChanges: [] } };
+        drafts.set(id, draft);
+    }
+    return draft;
+}
+export function lockDraft(id) {
+    if (lockedDrafts.has(id))
+        throw new Error("This iteration is already saving.");
+    lockedDrafts.add(id);
+    return () => { lockedDrafts.delete(id); };
+}
+export function isDraftLocked(id) {
+    return id === undefined ? lockedDrafts.size > 0 : lockedDrafts.has(id);
+}
+export function canEditDraft(id = activeId()) {
+    return canWriteWorkspace() && !lockedDrafts.has(id);
+}
+export function setActiveDraft(id, activate) {
+    draftState(id).activate = activate;
+    if (activeId() === id)
+        return;
+    activeDraftId = id;
+    publishSelection();
+}
+let snapshot = null;
+function cloneContents(value) {
+    return {
+        changes: value.changes.map((change) => cloneValue(change)),
+        structuralChanges: value.structuralChanges.map((change) => cloneValue(change)),
+    };
+}
+function cloneValue(value, key) {
+    if (key === "oldToken" || key === "newToken")
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => cloneValue(item));
+    if (value !== null && typeof value === "object") {
+        const clone = {};
+        for (const [key, child] of Object.entries(value)) {
+            clone[key] = cloneValue(child, key);
+        }
+        return clone;
+    }
+    return value;
+}
+function freezeValue(value, key) {
+    if (key === "oldToken" || key === "newToken")
+        return value;
+    if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+        for (const [childKey, child] of Object.entries(value))
+            freezeValue(child, childKey);
+        Object.freeze(value);
+    }
+    return value;
+}
+function createSnapshot() {
+    const draft = draftState();
+    return Object.freeze({ draftId: draft.id, revision: draft.revision, ...draft.contents, ...timelineStatus() });
+}
+let notificationDepth = 0;
+let notificationPending = false;
+function mutate(operation) {
+    notificationDepth += 1;
+    try {
+        return operation();
+    }
+    finally {
+        notificationDepth -= 1;
+        if (notificationDepth === 0 && notificationPending) {
+            notificationPending = false;
+            publishSelection();
+        }
+    }
+}
+function publishSelection() {
+    if (notificationDepth > 0) {
+        notificationPending = true;
+        return;
+    }
+    snapshot = null;
+    for (const listener of listeners)
+        listener();
+}
+subscribeTimeline(publishSelection);
+function replaceContents(draft, next) {
+    draft.contents = freezeValue(cloneContents(next));
+    draft.revision += 1;
+    for (const listener of draftListeners)
+        listener(draft.id);
+    publishSelection();
+}
+export function subscribeDraftChanges(listener) {
+    draftListeners.add(listener);
+    return () => draftListeners.delete(listener);
+}
+export function getDraftChanges(id) {
+    const draft = drafts.get(id);
+    return {
+        draftId: id,
+        revision: draft?.revision ?? 0,
+        changes: draft?.contents.changes ?? [],
+        structuralChanges: draft?.contents.structuralChanges ?? [],
+        ...timelineStatus(),
+    };
+}
+export function restoreDraftChanges(id, next, revision = 1) {
+    const draft = draftState(id);
+    draft.contents = freezeValue(cloneContents(next));
+    draft.revision = revision;
+    publishSelection();
+}
+function commit(next) {
+    if (!canEditDraft())
+        return false;
+    const draft = draftState();
+    const before = draft.contents;
+    mutate(() => {
+        replaceContents(draft, next);
+        recordEdit({ draftId: draft.id, activate: draft.activate, before, after: draft.contents }, sameDraftContents);
+    });
+    return true;
+}
+function getSnapshot() { return snapshot ??= createSnapshot(); }
+function subscribe(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+function commitChangeRecordsImpl(incoming) {
+    if (incoming.length === 0)
+        return "unchanged";
+    const contents = draftState().contents;
+    const changes = incoming.reduce((current, change) => mergeChange(current, change), [...contents.changes]);
+    if (sameEffectiveChanges([...contents.changes], changes))
+        return "unchanged";
+    return commit({ ...contents, changes }) ? "applied" : "blocked";
+}
+function revertChangeRecordImpl(change) {
+    const contents = draftState().contents;
+    const changes = contents.changes.filter((candidate) => changeKey(candidate) !== changeKey(change));
+    return changes.length !== contents.changes.length && commit({ ...contents, changes });
+}
+function discardChangeRecordsImpl(target) {
+    const contents = draftState().contents;
+    const changes = contents.changes.filter((change) => target.kind === "selector"
+        ? selectorForChange(change) !== target.selector
+        : !isElementChange(change) || change.instanceOverride?.id !== target.id);
+    return changes.length !== contents.changes.length && commit({ ...contents, changes });
+}
+function commitStructuralChangeImpl(change) {
+    const contents = draftState().contents;
+    if (contents.structuralChanges.some((candidate) => candidate.id === change.id))
+        return false;
+    return commit({ ...contents, structuralChanges: [...contents.structuralChanges, change] });
+}
+function revertStructuralChangeRecordImpl(changeId) {
+    const contents = draftState().contents;
+    const structuralChanges = contents.structuralChanges.filter((change) => change.id !== changeId);
+    return structuralChanges.length !== contents.structuralChanges.length && commit({ ...contents, structuralChanges });
+}
+export function reconcileDraftChanges(id, verifiedKeys, verifiedStructuralIds) {
+    if (!canEditDraft(id))
+        return 0;
+    const draft = draftState(id);
+    const retain = (value) => ({
+        changes: value.changes.filter((change) => !verifiedKeys.has(changeKey(change))),
+        structuralChanges: value.structuralChanges.filter((change) => !verifiedStructuralIds.has(change.id)),
+    });
+    const next = retain(draft.contents);
+    const removed = draft.contents.changes.length - next.changes.length + draft.contents.structuralChanges.length - next.structuralChanges.length;
+    if (removed === 0)
+        return 0;
+    mutate(() => {
+        replaceContents(draft, next);
+        pruneDraftHistory(id, retain, sameDraftContents);
+    });
+    return removed;
+}
+function reconcileActiveDraftChangesImpl(keys, ids) {
+    return reconcileDraftChanges(activeId(), keys, ids);
+}
+function sameDraftContents(left, right) {
+    return sameEffectiveChanges([...left.changes], [...right.changes])
+        && JSON.stringify(left.structuralChanges) === JSON.stringify(right.structuralChanges);
+}
+function replay(direction) {
+    if (isDraftLocked() || !canWriteWorkspace())
+        return false;
+    return mutate(() => replayTimeline(direction, (entry, next) => {
+        replaceContents(draftState(entry.draftId), next);
+        entry.activate?.();
+        if (!entry.activate)
+            setActiveDraft(entry.draftId);
+    }));
+}
+function restoreActiveDraftChangesImpl(next, preserveHistory = false) {
+    mutate(() => {
+        replaceContents(draftState(), next);
+        if (!preserveHistory)
+            clearSessionUndoHistory();
+    });
+}
+export function clearDraftChanges(id, expectedRevision) {
+    const draft = draftState(id);
+    if (!canEditDraft(id) || (expectedRevision !== undefined && draft.revision !== expectedRevision))
+        return false;
+    mutate(() => {
+        replaceContents(draft, { changes: [], structuralChanges: [] });
+        discardDraftHistory(id);
+    });
+    return true;
+}
+export function listDraftIds() {
+    return [...drafts.keys()];
+}
+/** Drops a draft whose content no longer exists, such as a deleted iteration. */
+export function forgetDraft(id) {
+    if (!drafts.has(id) || lockedDrafts.has(id))
+        return;
+    discardDraftHistory(id);
+    drafts.delete(id);
+    for (const listener of draftListeners)
+        listener(id);
+    publishSelection();
+}
+function clearActiveDraftChangesImpl() { clearDraftChanges(activeId()); }
+function resetDraftChangesImpl() {
+    drafts.clear();
+    lockedDrafts.clear();
+    activeDraftId = null;
+    clearSessionUndoHistory();
+    publishSelection();
+}
+export const draftChangeStore = {
+    getSnapshot, subscribe,
+    commitChangeRecords: commitChangeRecordsImpl,
+    revertChangeRecord: revertChangeRecordImpl,
+    discardChangeRecords: discardChangeRecordsImpl,
+    commitStructuralChange: commitStructuralChangeImpl,
+    revertStructuralChangeRecord: revertStructuralChangeRecordImpl,
+    reconcileActiveDraftChanges: reconcileActiveDraftChangesImpl,
+    undoChange: () => replay("undo"),
+    redoChange: () => replay("redo"),
+    restoreActiveDraftChanges: restoreActiveDraftChangesImpl,
+    clearActiveDraftChanges: clearActiveDraftChangesImpl,
+};
+export function getActiveDraftChanges() {
+    return draftChangeStore.getSnapshot();
+}
+export function subscribeActiveDraftChanges(listener) {
+    return draftChangeStore.subscribe(listener);
+}
+export function commitChangeRecords(incoming, project) {
+    const result = draftChangeStore.commitChangeRecords(incoming);
+    if (result === "applied")
+        project(draftChangeStore.getSnapshot());
+    return result;
+}
+export function commitStructuralChange(change, project) {
+    const changed = draftChangeStore.commitStructuralChange(change);
+    if (changed)
+        project(draftChangeStore.getSnapshot());
+    return changed;
+}
+export function undoChange(project) {
+    const changed = draftChangeStore.undoChange();
+    if (changed)
+        project(draftChangeStore.getSnapshot());
+    return changed;
+}
+export function redoChange(project) {
+    const changed = draftChangeStore.redoChange();
+    if (changed)
+        project(draftChangeStore.getSnapshot());
+    return changed;
+}
+export function restoreActiveDraftChanges(next, project) {
+    draftChangeStore.restoreActiveDraftChanges(next);
+    project(draftChangeStore.getSnapshot());
+}
+export function resetDraftChanges() {
+    resetDraftChangesImpl();
+}

package/dist/inspector/changes/previewDiagnostics.d.ts

@@ -3,9 +3,11 @@ import type { PreviewResult } from "../projection/managedStylesheet.js";
 export interface PreviewDocument {
     readonly logicalDocument: string;
     readonly sessionId: string;
+    readonly draftId?: string;
 }
 export interface PreviewAttempt extends PreviewDocument {
-    readonly workspaceRevision: number;
+    readonly draftId: string;
+    readonly draftRevision: number;
     readonly attempt: number;
 }
 export interface PreviewDiagnostic extends PreviewAttempt {
@@ -26,7 +28,7 @@ export declare function publishPreviewDiagnostic(attempt: PreviewAttempt, change
 export declare function clearPreviewDiagnostics(changeKeys?: Iterable<string>): void;
 /** Notifies consumers when verification state changes without a result. */
 export declare function notifyPreviewDiagnostics(): void;
-export declare function getPreviewDiagnostic(changeKey: string, logicalDocument?: string): PreviewDiagnostic | undefined;
+export declare function getPreviewDiagnostic(changeKey: string, logicalDocument?: string, draftId?: string): PreviewDiagnostic | undefined;
 /**
  * Host-first read across live documents. The per-document store is observable
  * here so a Canvas-only conflict is not write-only; host remains the default

package/dist/inspector/changes/previewDiagnostics.js

@@ -1,16 +1,15 @@
-import { getWorkspaceChanges, subscribeWorkspaceChanges } from "./workspaceChanges.js";
+import { getActiveDraftChanges, getDraftChanges } from "./draftChanges.js";
 const HOST_DOCUMENT = {
     logicalDocument: "host",
     sessionId: "host-document",
 };
-let workspaceRevision = getWorkspaceChanges().revision;
 let activeSessions = new Map([[HOST_DOCUMENT.logicalDocument, HOST_DOCUMENT.sessionId]]);
 let attemptsBySession = new Map();
 let diagnostics = new Map();
 let diagnosticRevision = 0;
 const listeners = new Set();
 function storageKey(document, changeKey) {
-    return `${document.logicalDocument}\u0000${document.sessionId}\u0000${changeKey}`;
+    return `${document.draftId ?? getActiveDraftChanges().draftId}\u0000${document.logicalDocument}\u0000${document.sessionId}\u0000${changeKey}`;
 }
 function sessionKey(document) {
     return `${document.logicalDocument}\u0000${document.sessionId}`;
@@ -26,23 +25,12 @@ function notify() {
     for (const listener of listeners)
         listener();
 }
-function syncWorkspaceRevision() {
-    const nextRevision = getWorkspaceChanges().revision;
-    if (nextRevision === workspaceRevision)
-        return;
-    // Track the revision so late publishes are rejected per key. Do not clear
-    // here: a new commit must preserve earlier diagnostics until they are
-    // re-verified, otherwise every edit deletes every other change's status.
-    workspaceRevision = nextRevision;
-}
-subscribeWorkspaceChanges(syncWorkspaceRevision);
 /** Returns the stable host-document identity for this inspector lifetime. */
 export function getHostPreviewDocument() {
-    return HOST_DOCUMENT;
+    return { ...HOST_DOCUMENT, draftId: getActiveDraftChanges().draftId };
 }
 /** Starts or replaces the live session for one logical document. */
 export function startPreviewDocumentSession(document) {
-    syncWorkspaceRevision();
     const previousSession = activeSessions.get(document.logicalDocument);
     if (previousSession === document.sessionId)
         return;
@@ -76,9 +64,9 @@ export function invalidatePreviewDocumentSession(logicalDocument, sessionId) {
         notify();
 }
 /** Opens a verification attempt for the currently active document session. */
-export function beginPreviewAttempt(document, revision = getWorkspaceChanges().revision) {
-    syncWorkspaceRevision();
-    if (revision !== workspaceRevision || activeSessions.get(document.logicalDocument) !== document.sessionId) {
+export function beginPreviewAttempt(document, revision = getDraftChanges(document.draftId ?? getActiveDraftChanges().draftId).revision) {
+    const draftId = document.draftId ?? getActiveDraftChanges().draftId;
+    if (revision !== getDraftChanges(draftId).revision || activeSessions.get(document.logicalDocument) !== document.sessionId) {
         return null;
     }
     const attempt = (attemptsBySession.get(sessionKey(document)) ?? 0) + 1;
@@ -87,12 +75,11 @@ export function beginPreviewAttempt(document, revision = getWorkspaceChanges().r
     // rejects late publishes per key; wiping would drop every other change's
     // status before it is re-verified (and drop all host status when Canvas
     // verification returns null).
-    return { ...document, workspaceRevision: revision, attempt };
+    return { ...document, draftId, draftRevision: revision, attempt };
 }
 /** Publishes only a result from the active revision, session, and attempt. */
 export function publishPreviewDiagnostic(attempt, changeKey, result) {
-    syncWorkspaceRevision();
-    if (attempt.workspaceRevision !== workspaceRevision
+    if (attempt.draftRevision !== getDraftChanges(attempt.draftId).revision
         || activeSessions.get(attempt.logicalDocument) !== attempt.sessionId
         || attemptsBySession.get(sessionKey(attempt)) !== attempt.attempt) {
         return false;
@@ -101,7 +88,7 @@ export function publishPreviewDiagnostic(attempt, changeKey, result) {
     const previous = diagnostics.get(key);
     if (previous
         && previous.changeKey === changeKey
-        && previous.workspaceRevision === attempt.workspaceRevision
+        && previous.draftRevision === attempt.draftRevision
         && previous.attempt === attempt.attempt
         && sameResult(previous.result, result)) {
         return true;
@@ -127,7 +114,7 @@ export function clearPreviewDiagnostics(changeKeys) {
 export function notifyPreviewDiagnostics() {
     notify();
 }
-export function getPreviewDiagnostic(changeKey, logicalDocument = HOST_DOCUMENT.logicalDocument) {
+export function getPreviewDiagnostic(changeKey, logicalDocument = HOST_DOCUMENT.logicalDocument, draftId = getActiveDraftChanges().draftId) {
     // Pure getter: never sync or notify. It runs on the React render path via
     // StaleChangeIndicator, so side effects here would clear state mid-render.
     // Diagnostics survive workspace revisions until overwritten or explicitly
@@ -135,7 +122,7 @@ export function getPreviewDiagnostic(changeKey, logicalDocument = HOST_DOCUMENT.
     const sessionId = activeSessions.get(logicalDocument);
     if (!sessionId)
         return undefined;
-    return diagnostics.get(storageKey({ logicalDocument, sessionId }, changeKey));
+    return diagnostics.get(storageKey({ logicalDocument, sessionId, draftId }, changeKey));
 }
 /**
  * Host-first read across live documents. The per-document store is observable
@@ -164,7 +151,6 @@ export function getPreviewDiagnosticRevision() {
 }
 /** Test and teardown reset; it does not alter canonical workspace state. */
 export function resetPreviewDiagnostics() {
-    workspaceRevision = getWorkspaceChanges().revision;
     activeSessions = new Map([[HOST_DOCUMENT.logicalDocument, HOST_DOCUMENT.sessionId]]);
     attemptsBySession = new Map();
     diagnostics = new Map();

package/dist/inspector/clientManifest.d.ts

@@ -1,5 +1,5 @@
 import { type NudgeUiRuntimeConfig } from "./runtime/runtimeConfig.js";
-export type { NudgeUiRuntimeConfig } from "./runtime/runtimeConfig.js";
+export type { NudgeUiRuntimeConfig, NudgeUiRuntimeFeatures } from "./runtime/runtimeConfig.js";
 export { detectStylingSystem } from "./runtime/runtimeConfig.js";
 /** Version of the host-to-inspector runtime manifest Interface. */
 export declare const NUDGE_UI_CLIENT_MANIFEST_VERSION = 1;

package/dist/inspector/comments/CommentsOverlay.d.ts

@@ -0,0 +1,2 @@
+import { type ReactElement } from "react";
+export declare function CommentsOverlay(): ReactElement | null;