@fps-games/editor 0.1.4-beta.3 → 0.1.4-beta.5

package/dist/local-editor-harness.js

@@ -7,6 +7,8 @@ import { createPlayableBabylonOutlineInspectorSection, createPlayableBabylonOutl
 import { createLocalEditorViewportRenderCoordinator, } from './local-editor-viewport-render-coordinator.js';
 import { createLocalEditorSceneViewInteractionRuntime, } from './local-editor-scene-view-interaction-runtime.js';
 const BATCH_EDIT_REQUIRES_MULTI_PATCH_REASON = 'Batch edit requires multi-property patch support.';
+const EDITOR_PROJECTION_IDLE_BEFORE_RUN_GAME_TIMEOUT_MS = 1500;
+const EDITOR_WORLD_DISPOSE_BOUNDARY_DELAY_MS = 500;
 export function createLocalEditorHarness(options) {
     const root = options.root ?? document.body;
     const state = {
@@ -87,12 +89,10 @@ export function createLocalEditorHarness(options) {
                 void runExclusive(state, harness.render, () => harness.discardAndRunGame());
             },
             onUndo: () => {
-                if (undoSessionChange(state, options))
-                    harness.render();
+                void harness.undo({ origin: 'user', waitForProjection: 'none' });
             },
             onRedo: () => {
-                if (redoSessionChange(state, options))
-                    harness.render();
+                void harness.redo({ origin: 'user', waitForProjection: 'none' });
             },
             onCreateFromAsset: (assetId) => {
                 if (createAssetFromBrowserIntent(state, options, assetId))
@@ -300,7 +300,9 @@ export function createLocalEditorHarness(options) {
     });
     const runGameFromEditor = async (reason) => {
         cancelActiveOperation(state);
+        await waitForEditorProjectionIdleBeforeRunGame(state);
         disposeEditorWorld(state);
+        await waitForEditorWorldDisposeBoundary();
         state.mode = 'game';
         state.session = null;
         state.source = null;
@@ -370,6 +372,18 @@ export function createLocalEditorHarness(options) {
             harness.render();
             return result;
         },
+        async undo(historyOptions) {
+            const result = applyHistoryOperation(state, options, 'undo', historyOptions);
+            if (result.ok)
+                harness.render();
+            return waitForHistoryOperationProjection(state, result);
+        },
+        async redo(historyOptions) {
+            const result = applyHistoryOperation(state, options, 'redo', historyOptions);
+            if (result.ok)
+                harness.render();
+            return waitForHistoryOperationProjection(state, result);
+        },
         async enterEditor() {
             const loadedSource = options.persistenceAdapter.loadAuthoringSource
                 ? await options.persistenceAdapter.loadAuthoringSource()
@@ -835,6 +849,7 @@ async function createEditorWorld(state, options, renderUi, renderPreviewUi, upda
         scene: world.scene,
         importModel: options.worldAdapter.importProjectionModel,
         resolveTextureUrl: options.worldAdapter.resolveMaterialTextureUrl,
+        selectionEdgesPrewarm: options.world?.selectionEdgesPrewarm,
         logger: console,
         onProjectionReady(event) {
             syncCurrentSelectionToSceneArtifacts(state, `projection-${event.nodeId}-ready-selection`);
@@ -1156,6 +1171,63 @@ function disposeEditorWorld(state) {
     state.world = null;
     state.engine = null;
 }
+async function waitForEditorProjectionIdleBeforeRunGame(state) {
+    const projection = state.projection;
+    if (!projection)
+        return;
+    const timeout = createTimeoutPromise(EDITOR_PROJECTION_IDLE_BEFORE_RUN_GAME_TIMEOUT_MS);
+    try {
+        await Promise.race([
+            projection.waitForIdle().catch(() => null),
+            timeout.promise,
+        ]);
+    }
+    finally {
+        timeout.cancel();
+    }
+}
+async function waitForEditorWorldDisposeBoundary() {
+    await waitForEditorAnimationFrame();
+    await waitForEditorAnimationFrame();
+    await waitForEditorTimeout(EDITOR_WORLD_DISPOSE_BOUNDARY_DELAY_MS);
+}
+function waitForEditorAnimationFrame() {
+    if (typeof window === 'undefined' || typeof window.requestAnimationFrame !== 'function') {
+        return Promise.resolve();
+    }
+    return new Promise(resolve => {
+        window.requestAnimationFrame(() => resolve());
+    });
+}
+function waitForEditorTimeout(milliseconds) {
+    if (typeof window === 'undefined' || typeof window.setTimeout !== 'function') {
+        return Promise.resolve();
+    }
+    return new Promise(resolve => {
+        window.setTimeout(() => resolve(), milliseconds);
+    });
+}
+function createTimeoutPromise(milliseconds) {
+    if (typeof window === 'undefined' || typeof window.setTimeout !== 'function') {
+        return { promise: new Promise(() => undefined), cancel: () => undefined };
+    }
+    let timeoutId = null;
+    const promise = new Promise(resolve => {
+        timeoutId = window.setTimeout(() => {
+            timeoutId = null;
+            resolve();
+        }, milliseconds);
+    });
+    return {
+        promise,
+        cancel() {
+            if (timeoutId === null)
+                return;
+            window.clearTimeout(timeoutId);
+            timeoutId = null;
+        },
+    };
+}
 function requestEditorSceneFrame(state, reason) {
     state.viewportRenderCoordinator?.requestFrame(reason);
 }
@@ -1409,6 +1481,7 @@ function renameSceneGraphNode(state, options, intent) {
         label: patch.label ?? `Rename ${intent.id}`,
         patch: patch.patch,
         targetId: intent.id,
+        ...withProjectionImpact(patch.projectionImpact),
     });
     if (!result.documentChanged) {
         state.status = `Rename unchanged: ${intent.id}`;
@@ -1434,6 +1507,7 @@ function createSceneGraphGroup(state, options, intent) {
         label: patch.label ?? 'Create Empty',
         patch: patch.patch,
         targetId: patch.createdId ?? undefined,
+        ...withProjectionImpact(resolveProjectionImpact(patch, createCreatedNodeProjectionImpact([patch.createdId]))),
     });
     if (!result.documentChanged) {
         state.status = 'Create empty unchanged';
@@ -1469,6 +1543,10 @@ function createSceneGraphPrimitive(state, options, intent) {
         label: patch.label ?? `Create ${intent.shape}`,
         patch: patch.patch,
         targetId: patch.createdId ?? undefined,
+        ...withProjectionImpact(resolveProjectionImpact(patch, createKnownCreatedReprojectProjectionImpact({
+            createdNodeIds: [patch.createdId],
+            reprojectIds: patch.reprojectIds,
+        }))),
     });
     if (!result.documentChanged) {
         state.status = `Create ${intent.shape} unchanged`;
@@ -1509,6 +1587,9 @@ function deleteSceneGraphNodes(state, options, intent) {
         label: patch.label ?? `Delete ${intent.ids.length} node(s)`,
         patch: patch.patch,
         targetId: intent.activeId ?? undefined,
+        ...withProjectionImpact(resolveProjectionImpact(patch, patch.deletedIds
+            ? createDeletedNodeProjectionImpact(patch.deletedIds)
+            : undefined)),
     });
     if (!result.documentChanged) {
         state.status = 'Delete unchanged';
@@ -1557,6 +1638,10 @@ function duplicateSceneGraphNodes(state, options, intent) {
         label: patch.label ?? `Duplicate ${targetIds.length} object(s)`,
         patch: patch.patch,
         targetId: patch.activeId ?? patch.createdIds[patch.createdIds.length - 1] ?? undefined,
+        ...withProjectionImpact(resolveProjectionImpact(patch, createCreatedReprojectProjectionImpact({
+            createdNodeIds: patch.createdIds,
+            reprojectIds: patch.reprojectIds,
+        }))),
     });
     if (!result.documentChanged) {
         state.status = 'Duplicate unchanged';
@@ -1613,6 +1698,7 @@ function dropSceneGraphNode(state, options, intent) {
         label: patch.label ?? `Reparent ${intent.draggedId}`,
         patch: patch.patch,
         targetId: intent.draggedId,
+        ...withProjectionImpact(patch.projectionImpact),
     });
     if (!result.documentChanged) {
         state.status = `Reparent unchanged: ${intent.draggedId}`;
@@ -1657,6 +1743,7 @@ function moveSceneGraphNodes(state, options, intent) {
         label: patch.label ?? `Move ${intent.ids.length} node(s)`,
         patch: patch.patch,
         targetId: intent.ids[0] ?? undefined,
+        ...withProjectionImpact(patch.projectionImpact),
     });
     if (!result.documentChanged) {
         state.status = 'Move unchanged';
@@ -1694,6 +1781,7 @@ function groupSceneGraphSelection(state, options, intent) {
         label: patch.label ?? 'Create Parent',
         patch: patch.patch,
         targetId: patch.createdId,
+        ...withProjectionImpact(patch.projectionImpact),
     });
     if (!result.documentChanged) {
         state.status = 'Create Parent unchanged';
@@ -1914,6 +2002,9 @@ function executeTransformAction(state, options, action) {
         label: patch.label ?? formatTransformActionStatus(action, changedTargets.length),
         patch: patch.patch,
         targetId: selection.activeId ?? changedTargets[0]?.id,
+        ...withProjectionImpact(resolveProjectionImpact(patch, patch.reprojectIds?.length
+            ? createReprojectProjectionImpact(patch.reprojectIds)
+            : createTransformProjectionImpact(changedTargets.map(target => target.id)))),
     });
     if (!result.documentChanged) {
         state.status = `Transform action unchanged: ${action}`;
@@ -2010,6 +2101,11 @@ function patchBrowserAssetAction(state, options, input) {
         type: 'document.patch',
         label: patch.label ?? `Asset action ${input.actionId}`,
         patch: patch.patch,
+        ...withProjectionImpact(resolveProjectionImpact(patch, patch.reprojectIds?.length
+            ? createReprojectProjectionImpact(patch.reprojectIds)
+            : patch.changedIds?.length
+                ? createReprojectProjectionImpact(patch.changedIds)
+                : undefined)),
     });
     state.summary = summarizeDocument(options, result.workingDocument, session.getSource());
     state.status = patch.label ?? `Asset action ${input.actionId}`;
@@ -2091,6 +2187,10 @@ function commitArmedPlacement(state, options, event) {
         label: patch.label ?? `Place ${armed.assetId}`,
         patch: patch.patch,
         targetId: patch.createdId ?? undefined,
+        ...withProjectionImpact(resolveProjectionImpact(patch, createKnownCreatedReprojectProjectionImpact({
+            createdNodeIds: [patch.createdId],
+            reprojectIds: patch.reprojectIds,
+        }))),
     });
     if (!result.documentChanged) {
         state.status = 'Placement unchanged';
@@ -2154,8 +2254,14 @@ function addAssetToDocument(state, options, assetId, createOptions = {}) {
         type: 'document.patch',
         label: patch.label ?? 'Create Object From Asset',
         patch: patch.patch,
+        ...withProjectionImpact(resolveProjectionImpact(patch, createKnownCreatedReprojectProjectionImpact({
+            createdNodeIds: [patch.createdId],
+            reprojectIds: patch.reprojectIds,
+        }))),
     });
-    const createdId = options.documentAdapter.findCreatedId?.(beforeDocument, result.workingDocument);
+    const createdId = patch.createdId
+        ?? options.documentAdapter.findCreatedId?.(beforeDocument, result.workingDocument)
+        ?? null;
     let selectionResult = null;
     if (createdId) {
         selectionResult = session.dispatch({
@@ -2217,15 +2323,22 @@ function patchSerializedProperty(state, options, input) {
         });
         if (!patch)
             return false;
+        const changedIds = patch.changedIds ?? targetIds;
         const result = state.session.dispatch({
             type: 'document.patch',
             label: patch.label ?? `Patch ${payload.path} on ${targetIds.length} objects`,
             patch: patch.patch,
             targetId: state.session.getState().selection.activeId ?? undefined,
+            ...withProjectionImpact(resolveProjectionImpact(patch, patch.reprojectIds?.length
+                ? createReprojectProjectionImpact(patch.reprojectIds)
+                : shouldReprojectInspectorEdit
+                    ? createReprojectProjectionImpact(changedIds)
+                    : isSerializedTransformPath(payload.path)
+                        ? createTransformProjectionImpact(targetIds)
+                        : undefined)),
         });
         if (!result.documentChanged)
             return false;
-        const changedIds = patch.changedIds ?? targetIds;
         const projectionSyncIds = isSerializedTransformPath(payload.path) ? targetIds : changedIds;
         const workingDocument = result.workingDocument;
         if (patch.reprojectIds?.length)
@@ -2256,6 +2369,13 @@ function patchSerializedProperty(state, options, input) {
         type: 'document.patch',
         label: patch.label ?? `Patch ${payload.path}`,
         patch: patch.patch,
+        ...withProjectionImpact(resolveProjectionImpact(patch, patch.reprojectIds?.length
+            ? createReprojectProjectionImpact(patch.reprojectIds)
+            : shouldReprojectInspectorEdit
+                ? createReprojectProjectionImpact(patch.changedIds ?? [patch.changedId ?? payload.targetId])
+                : isSerializedTransformPath(payload.path)
+                    ? createTransformProjectionImpact([patch.changedId ?? payload.targetId])
+                    : undefined)),
     });
     if (patch.reprojectIds?.length)
         reprojectProjectionForChangedIds(state, options, result.workingDocument, patch.reprojectIds);
@@ -2480,6 +2600,10 @@ function beginDuplicateDrag(state, options, input) {
         label: patch.label ?? `Duplicate ${input.targetIds.length} object(s)`,
         patch: patch.patch,
         targetId: patch.activeId ?? patch.createdIds[patch.createdIds.length - 1] ?? undefined,
+        ...withProjectionImpact(resolveProjectionImpact(patch, createCreatedReprojectProjectionImpact({
+            createdNodeIds: patch.createdIds,
+            reprojectIds: patch.reprojectIds,
+        }))),
     });
     if (!result.documentChanged) {
         state.status = 'Duplicate drag unchanged';
@@ -2559,6 +2683,9 @@ function commitGizmoTransform(state, options, event) {
             label: patch.label ?? `${event.tool} ${event.targetIds.length} objects`,
             patch: patch.patch,
             targetId: event.activeId ?? undefined,
+            ...withProjectionImpact(resolveProjectionImpact(patch, patch.reprojectIds?.length
+                ? createReprojectProjectionImpact(patch.reprojectIds)
+                : createTransformProjectionImpact(event.targetIds))),
         }, {
             mergeWithPrevious: event.targetIds.some(id => state.duplicateDrag?.createdIds.includes(id)) === true,
         });
@@ -2594,6 +2721,9 @@ function commitGizmoTransform(state, options, event) {
         label: patch.label ?? `${event.tool} ${targetId}`,
         patch: patch.patch,
         targetId,
+        ...withProjectionImpact(resolveProjectionImpact(patch, patch.reprojectIds?.length
+            ? createReprojectProjectionImpact(patch.reprojectIds)
+            : createTransformProjectionImpact([patch.changedId ?? targetId]))),
     }, {
         mergeWithPrevious: state.duplicateDrag?.createdIds.includes(targetId) === true,
     });
@@ -2699,29 +2829,193 @@ function formatAssetLabel(asset, fallback) {
     const label = record?.label ?? record?.displayName ?? record?.name;
     return typeof label === 'string' && label.trim() ? label : fallback;
 }
-function undoSessionChange(state, options) {
-    cancelActiveOperation(state);
-    const result = state.session?.undo();
-    if (!result)
-        return false;
-    rebuildProjection(state, options, result);
-    state.summary = summarizeDocument(options, result.workingDocument, state.session?.getSource());
-    state.status = `Undo ${result.transaction.label}`;
-    return true;
+function withProjectionImpact(impact) {
+    return impact ? { projectionImpact: impact } : {};
+}
+function resolveProjectionImpact(source, fallback) {
+    return source.projectionImpact ?? fallback;
+}
+function createTransformProjectionImpact(ids) {
+    return createIncrementalProjectionImpact({ syncTransformIds: ids });
+}
+function createReprojectProjectionImpact(ids) {
+    return createIncrementalProjectionImpact({ reprojectIds: ids });
+}
+function createCreatedNodeProjectionImpact(ids) {
+    return createIncrementalProjectionImpact({ createdNodeIds: ids });
+}
+function createDeletedNodeProjectionImpact(ids) {
+    return createIncrementalProjectionImpact({ deletedNodeIds: ids });
+}
+function createCreatedReprojectProjectionImpact(input) {
+    return createIncrementalProjectionImpact({
+        createdNodeIds: input.createdNodeIds,
+        reprojectIds: input.reprojectIds,
+    });
 }
-function redoSessionChange(state, options) {
+function createKnownCreatedReprojectProjectionImpact(input) {
+    const createdNodeIds = uniqueProjectionIds(input.createdNodeIds);
+    if (createdNodeIds.length === 0)
+        return undefined;
+    return createCreatedReprojectProjectionImpact({
+        createdNodeIds,
+        reprojectIds: input.reprojectIds,
+    });
+}
+function createIncrementalProjectionImpact(input) {
+    const syncTransformIds = uniqueProjectionIds(input.syncTransformIds);
+    const reprojectIds = uniqueProjectionIds(input.reprojectIds);
+    const createdNodeIds = uniqueProjectionIds(input.createdNodeIds);
+    const deletedNodeIds = uniqueProjectionIds(input.deletedNodeIds);
+    if (syncTransformIds.length === 0
+        && reprojectIds.length === 0
+        && createdNodeIds.length === 0
+        && deletedNodeIds.length === 0) {
+        return undefined;
+    }
+    return {
+        type: 'incremental',
+        ...(syncTransformIds.length ? { syncTransformIds } : {}),
+        ...(reprojectIds.length ? { reprojectIds } : {}),
+        ...(createdNodeIds.length ? { createdNodeIds } : {}),
+        ...(deletedNodeIds.length ? { deletedNodeIds } : {}),
+    };
+}
+function uniqueProjectionIds(ids) {
+    const result = [];
+    const seen = new Set();
+    for (const id of ids ?? []) {
+        if (!id || seen.has(id))
+            continue;
+        seen.add(id);
+        result.push(id);
+    }
+    return result;
+}
+function applyHistoryOperation(state, options, operation, input = {}) {
+    const origin = input.origin ?? 'user';
+    const waitForProjection = input.waitForProjection ?? 'none';
     cancelActiveOperation(state);
-    const result = state.session?.redo();
+    const result = operation === 'undo'
+        ? state.session?.undo()
+        : state.session?.redo();
     if (!result)
-        return false;
-    rebuildProjection(state, options, result);
+        return createHistoryOperationResult(state, {
+            operation,
+            origin,
+            waitForProjection,
+            result: null,
+            status: operation === 'undo' ? 'Undo unavailable' : 'Redo unavailable',
+        });
+    applyHistoryProjectionImpact(state, options, result, operation);
     state.summary = summarizeDocument(options, result.workingDocument, state.session?.getSource());
-    state.status = `Redo ${result.transaction.label}`;
-    return true;
+    state.status = `${operation === 'undo' ? 'Undo' : 'Redo'} ${result.transaction.label}`;
+    return createHistoryOperationResult(state, {
+        operation,
+        origin,
+        waitForProjection,
+        result,
+        status: state.status,
+    });
+}
+async function waitForHistoryOperationProjection(state, result) {
+    if (!result.ok || result.waitForProjection !== 'settled')
+        return result;
+    const idleState = await state.projection?.waitForIdle() ?? null;
+    return {
+        ...result,
+        projection: createHistoryProjectionResult(result.waitForProjection, idleState, state),
+    };
+}
+function createHistoryOperationResult(state, input) {
+    const sessionState = state.session?.getState() ?? null;
+    return {
+        ok: !!input.result,
+        operation: input.operation,
+        origin: input.origin,
+        waitForProjection: input.waitForProjection,
+        documentChanged: input.result?.documentChanged ?? false,
+        transactionLabel: input.result?.transaction.label ?? null,
+        workingDocument: input.result?.workingDocument ?? sessionState?.workingDocument ?? null,
+        dirty: input.result?.dirty ?? sessionState?.dirty ?? false,
+        history: {
+            canUndo: sessionState?.canUndo ?? false,
+            canRedo: sessionState?.canRedo ?? false,
+        },
+        status: input.status,
+        projection: createHistoryProjectionResult(input.waitForProjection, null, state),
+    };
+}
+function createHistoryProjectionResult(waitPolicy, idleState, state) {
+    const resolved = idleState ?? state.projection?.getIdleState() ?? null;
+    return {
+        waitPolicy,
+        idle: resolved?.idle ?? true,
+        activeBatchIds: resolved?.activeBatchIds ?? [],
+        lastBatch: resolved?.lastBatch ?? null,
+    };
+}
+function applyHistoryProjectionImpact(state, options, result, operation) {
+    const impact = result.transaction.projectionImpact;
+    if (!impact || impact.type === 'rebuild') {
+        rebuildProjection(state, options, result);
+        return;
+    }
+    const applied = applyIncrementalHistoryProjectionImpact(state, options, result, operation, impact);
+    if (!applied)
+        rebuildProjection(state, options, result);
 }
 function rebuildProjection(state, options, result) {
     rebuildProjectionFromDocument(state, options, result.workingDocument, result.selection);
 }
+function applyIncrementalHistoryProjectionImpact(state, options, result, operation, impact) {
+    if (!state.projection)
+        return false;
+    const syncTransformIds = uniqueProjectionIds(impact.syncTransformIds);
+    const reprojectIds = uniqueProjectionIds(impact.reprojectIds);
+    const projectNodeIds = operation === 'redo'
+        ? uniqueProjectionIds(impact.createdNodeIds)
+        : uniqueProjectionIds(impact.deletedNodeIds);
+    const removeNodeIds = operation === 'redo'
+        ? uniqueProjectionIds(impact.deletedNodeIds)
+        : uniqueProjectionIds(impact.createdNodeIds);
+    const touched = syncTransformIds.length > 0
+        || reprojectIds.length > 0
+        || projectNodeIds.length > 0
+        || removeNodeIds.length > 0;
+    if (!touched)
+        return false;
+    for (const nodeId of removeNodeIds) {
+        state.projection.removeNode(nodeId);
+    }
+    for (const nodeId of projectNodeIds) {
+        const projectedNode = options.documentAdapter.getProjectionNode(result.workingDocument, nodeId);
+        if (!projectedNode)
+            return false;
+        state.projection.projectNode(projectedNode);
+    }
+    for (const nodeId of reprojectIds) {
+        const projectedNode = options.documentAdapter.getProjectionNode(result.workingDocument, nodeId);
+        if (!projectedNode)
+            return false;
+        state.projection.projectNode(projectedNode);
+    }
+    for (const nodeId of syncTransformIds) {
+        const projectedNode = options.documentAdapter.getProjectionNode(result.workingDocument, nodeId);
+        if (!projectedNode)
+            return false;
+        state.projection.syncNodeTransform(projectedNode);
+    }
+    syncProjectionAfterHistoryIncrementalImpact(state, options, result.workingDocument, result.selection);
+    return true;
+}
+function syncProjectionAfterHistoryIncrementalImpact(state, options, document, selection) {
+    const sanitized = sanitizeSelection(state, options, document, selection);
+    syncSelectionToProjection(state, sanitized ?? selection);
+    syncEditorWorldAppearanceFromDocument(state, options, document, 'world-appearance-history-impact');
+    syncEditorWorldRenderingFromDocument(state, options, document, 'world-rendering-history-impact', true);
+    invalidateEditorScene(state, 'projection-history-impact', options);
+}
 function rebuildProjectionFromDocument(state, options, document, selection) {
     state.projection?.rebuild(options.documentAdapter.getProjectionNodes(document));
     const sanitized = sanitizeSelection(state, options, document, selection);