@fps-games/editor 0.2.1-beta.2 → 0.2.1-beta.4

package/node_modules/@fps-games/plugin-hierarchy/dist/kernel.js

@@ -133,6 +133,7 @@ export function createHierarchyKernel() {
     const projections = new Map();
     const viewStateSnapshots = new WeakMap();
     const operationCache = new WeakMap();
+    const labelPresentations = new Map();
     const adapters = new Set();
     let providers = [];
     let activeProvider = null;
@@ -157,10 +158,10 @@ export function createHierarchyKernel() {
     const synchronize = () => {
         const resolved = resolveProvider();
         const nextProvider = resolved?.provider ?? null;
-        const snapshot = resolved?.snapshot ?? null;
-        if (snapshot && nextProvider)
-            assertMonotonicSnapshotRevision(revisionRecords, nextProvider, snapshot);
-        const nextScopeKey = snapshot?.scopeKey ?? null;
+        const sourceSnapshot = resolved?.snapshot ?? null;
+        if (sourceSnapshot && nextProvider)
+            assertMonotonicSnapshotRevision(revisionRecords, nextProvider, sourceSnapshot);
+        const nextScopeKey = sourceSnapshot?.scopeKey ?? null;
         if (activeProvider !== nextProvider || activeScopeKey !== nextScopeKey) {
             if (activeScopeKey)
                 cancelTransientState(viewStates.get(activeScopeKey));
@@ -170,6 +171,9 @@ export function createHierarchyKernel() {
             activeScopeKey = nextScopeKey;
             authorityToken += 1;
         }
+        const snapshot = sourceSnapshot && nextProvider
+            ? applyHierarchyLabelPresentation(labelPresentations, nextProvider, sourceSnapshot)
+            : null;
         if (snapshot)
             sanitizeViewState(getState(snapshot.scopeKey), snapshot);
         return snapshot;
@@ -320,6 +324,7 @@ export function createHierarchyKernel() {
             const previousRevisionRecords = cloneRevisionRecords(revisionRecords);
             const previousViewStates = cloneMutableViewStates(viewStates);
             const previousProjections = new Map(projections);
+            const previousLabelPresentations = cloneHierarchyLabelPresentations(labelPresentations);
             let model;
             try {
                 providers = next;
@@ -333,12 +338,17 @@ export function createHierarchyKernel() {
                 replaceMapContents(revisionRecords, previousRevisionRecords);
                 replaceMapContents(viewStates, previousViewStates);
                 replaceMapContents(projections, previousProjections);
+                replaceMapContents(labelPresentations, previousLabelPresentations);
                 throw error;
             }
             for (const provider of revisionRecords.keys()) {
                 if (!next.includes(provider))
                     revisionRecords.delete(provider);
             }
+            for (const [scopeKey, presentation] of labelPresentations) {
+                if (!next.includes(presentation.provider))
+                    labelPresentations.delete(scopeKey);
+            }
             // Provider authority is committed before notifying UI edges. A failing
             // adapter cannot roll the authoritative provider set back underneath an
             // adapter that has already observed the new model.
@@ -346,6 +356,33 @@ export function createHierarchyKernel() {
         },
         getProvider() { synchronize(); return activeProvider; },
         getViewModel,
+        patchNodeLabels(labels) {
+            const snapshot = synchronize();
+            const provider = activeProvider;
+            if (!snapshot || !provider)
+                return null;
+            let presentation = labelPresentations.get(snapshot.scopeKey);
+            if (presentation?.provider !== provider
+                || presentation.structureRevision !== snapshot.structureRevision) {
+                presentation = {
+                    provider,
+                    structureRevision: snapshot.structureRevision,
+                    labels: new Map(),
+                    sourceSnapshot: null,
+                    snapshot: null,
+                };
+                labelPresentations.set(snapshot.scopeKey, presentation);
+            }
+            for (const [id, label] of Object.entries(labels)) {
+                if (!label.trim() || !snapshot.nodeById.has(id))
+                    return null;
+            }
+            for (const [id, label] of Object.entries(labels))
+                presentation.labels.set(id, label);
+            presentation.sourceSnapshot = null;
+            presentation.snapshot = null;
+            return applyHierarchyLabelPresentation(labelPresentations, provider, snapshot);
+        },
         listOperations(context, expectedAuthorityToken) {
             const previousProvider = activeProvider;
             const previousScopeKey = activeScopeKey;
@@ -735,6 +772,43 @@ function replaceMapContents(target, source) {
     for (const [key, value] of source)
         target.set(key, value);
 }
+function applyHierarchyLabelPresentation(presentations, provider, sourceSnapshot) {
+    const presentation = presentations.get(sourceSnapshot.scopeKey);
+    if (!presentation)
+        return sourceSnapshot;
+    if (presentation.provider !== provider
+        || presentation.structureRevision !== sourceSnapshot.structureRevision) {
+        presentations.delete(sourceSnapshot.scopeKey);
+        return sourceSnapshot;
+    }
+    if (presentation.sourceSnapshot === sourceSnapshot && presentation.snapshot) {
+        return presentation.snapshot;
+    }
+    const nodeById = new Map(sourceSnapshot.nodeById);
+    let changed = false;
+    for (const [id, label] of presentation.labels) {
+        const node = nodeById.get(id);
+        if (!node || node.label === label)
+            continue;
+        nodeById.set(id, Object.freeze({ ...node, label }));
+        changed = true;
+    }
+    const snapshot = changed
+        ? Object.freeze({
+            ...sourceSnapshot,
+            nodeById: createReadonlyMapView(nodeById),
+        })
+        : sourceSnapshot;
+    presentation.sourceSnapshot = sourceSnapshot;
+    presentation.snapshot = snapshot;
+    return snapshot;
+}
+function cloneHierarchyLabelPresentations(source) {
+    return new Map([...source].map(([scopeKey, presentation]) => [scopeKey, {
+            ...presentation,
+            labels: new Map(presentation.labels),
+        }]));
+}
 function cloneRevisionRecords(source) {
     return new Map([...source].map(([provider, records]) => [provider, new Map(records)]));
 }