@ifc-lite/mutations 1.27.0 → 2.1.0

package/dist/mutable-property-view.js

@@ -1,9 +1,13 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+import { findQuantityInBaseSets } from './base-qset-lookup.js';
+import { computeSetClaims, mutatedMembersForInstance } from './same-name-set-claims.js';
+import { encodeNonFiniteNumbers, decodeNonFiniteNumbers } from './nonfinite-json.js';
 import { PropertyValueType, QuantityType } from '@ifc-lite/data';
 import { propertyKey, quantityKey, attributeKey, generateMutationId } from './types.js';
 import { collectEffectiveChanges } from './effective-changes.js';
+import { applyMutationsBatch } from './apply-mutations.js';
 export class MutablePropertyView {
     baseTable;
     onDemandExtractor = null;
@@ -245,58 +249,31 @@ export class MutablePropertyView {
         const seenPsets = new Set();
         // First, add properties from base (on-demand or table) with mutations applied
         const basePsets = this.getBasePropertiesForEntity(entityId);
+        // Two base psets can share a name (type pset + occurrence pset); a
+        // mutation key has no per-instance identity, so figure out up front
+        // which instance an edit -- or a brand-new property -- is claimed by:
+        // decides both an EXISTING property's SET/DELETE and where a brand-new
+        // property lands. Same mechanism `getQuantitiesForEntity` below uses,
+        // via `same-name-set-claims.ts`.
+        const claims = computeSetClaims(basePsets, pset => pset.properties);
         for (const pset of basePsets) {
             // Skip deleted property sets
             if (this.deletedPsets.has(`${entityId}:${pset.name}`)) {
                 continue;
             }
             seenPsets.add(pset.name);
-            // Apply property mutations
-            const mutatedProperties = [];
-            for (const prop of pset.properties) {
-                const key = propertyKey(entityId, pset.name, prop.name);
-                const mutation = this.propertyMutations.get(key);
-                if (mutation) {
-                    if (mutation.operation === 'DELETE') {
-                        continue; // Skip deleted properties
-                    }
-                    // Apply SET mutation
-                    mutatedProperties.push({
-                        name: prop.name,
-                        type: mutation.valueType ?? prop.type,
-                        value: mutation.value ?? null,
-                        unit: mutation.unit ?? prop.unit,
-                        dataType: prop.dataType,
-                    });
-                }
-                else {
-                    mutatedProperties.push(prop);
-                }
-            }
-            // Check for new properties added to this pset. Iterate the per-entity
-            // key set so this stays O(M_entity) instead of scanning every mutation
-            // in the model.
-            const entityPropKeys = this.propertyKeysByEntity.get(entityId);
-            if (entityPropKeys) {
-                const psetPrefix = `${entityId}:${pset.name}:`;
-                for (const key of entityPropKeys) {
-                    if (!key.startsWith(psetPrefix))
-                        continue;
-                    const mutation = this.propertyMutations.get(key);
-                    if (!mutation || mutation.operation !== 'SET')
-                        continue;
-                    const propName = key.slice(psetPrefix.length);
-                    // Only add if not already in the list
-                    if (!mutatedProperties.some(p => p.name === propName)) {
-                        mutatedProperties.push({
-                            name: propName,
-                            type: mutation.valueType ?? PropertyValueType.String,
-                            value: mutation.value ?? null,
-                            unit: mutation.unit,
-                        });
-                    }
-                }
-            }
+            const mutatedProperties = mutatedMembersForInstance(entityId, pset, pset.properties, claims, this.propertyMutations, this.propertyKeysByEntity.get(entityId), propertyKey, (prop, mutation) => ({
+                name: prop.name,
+                type: mutation.valueType ?? prop.type,
+                value: mutation.value ?? null,
+                unit: mutation.unit ?? prop.unit,
+                dataType: prop.dataType,
+            }), prop => prop, (name, mutation) => ({
+                name,
+                type: mutation.valueType ?? PropertyValueType.String,
+                value: mutation.value ?? null,
+                unit: mutation.unit,
+            }));
             if (mutatedProperties.length > 0) {
                 result.push({
                     name: pset.name,
@@ -336,14 +313,17 @@ export class MutablePropertyView {
                 return prop.value;
             }
         }
-        // Fall back to on-demand extraction or base table
+        // Fall back to on-demand extraction or base table. Scan every same-named
+        // pset (an entity can carry two, e.g. type + occurrence), not just the
+        // first -- see findQuantityInBaseSets's doc for why this doesn't import
+        // @ifc-lite/query's version.
         const basePsets = this.getBasePropertiesForEntity(entityId);
-        const pset = basePsets.find(p => p.name === psetName);
-        if (pset) {
+        for (const pset of basePsets) {
+            if (pset.name !== psetName)
+                continue;
             const prop = pset.properties.find(p => p.name === propName);
-            if (prop) {
+            if (prop)
                 return prop.value;
-            }
         }
         return null;
     }
@@ -351,8 +331,13 @@ export class MutablePropertyView {
      * Set a property value
      * If the property set doesn't exist, creates it automatically
      * @param skipHistory - If true, don't add to mutation history (used for undo/redo)
+     * @param dataType - IFC measure dataType this value was scaled against at
+     *   write time (e.g. an IDS correction, #3929/#3943), stored on the
+     *   `PropertyMutation` for a read-side overlay that needs to convert it
+     *   between unit frames. New, additive, optional — every existing caller
+     *   is unaffected.
      */
-    setProperty(entityId, psetName, propName, value, valueType = PropertyValueType.String, unit, skipHistory = false) {
+    setProperty(entityId, psetName, propName, value, valueType = PropertyValueType.String, unit, skipHistory = false, dataType) {
         const key = propertyKey(entityId, psetName, propName);
         // Get old value for undo
         const oldValue = this.getPropertyValue(entityId, psetName, propName);
@@ -437,6 +422,7 @@ export class MutablePropertyView {
             value,
             valueType,
             unit,
+            dataType,
         });
         const mutation = {
             id: generateMutationId(),
@@ -591,17 +577,20 @@ export class MutablePropertyView {
                 this.deletePropertyMutation(entityId, key);
             }
         }
-        // A DELETE marker in `deletedPsets` only earns its keep when it is
-        // masking a pset that genuinely exists in the base data — same argument
-        // as `deleteProperty` one level down (see the comment above its own
-        // base-existence check): a purely in-session pset (added via
+        // A DELETE marker in `deletedPsets` only earns its keep when it is masking
+        // a pset that genuinely exists in the base data — same argument as
+        // `deleteProperty` one level down. A purely in-session pset (added via
         // `createPropertySet`, never in the base file) has nothing to mask, so
-        // dropping the pset above already nets to nothing and there is no
-        // deletion to report. Recording it as deleted here told the export
-        // review a pset would be removed when the net change was zero.
+        // dropping it above already nets to nothing: recording a deletion here
+        // told the export review a pset would go when the net change was zero.
+        // EVERY same-named pset: `deletedPsets` masks by name so the panel hides
+        // both, but the DELETE markers the exporter reads are per PROPERTY —
+        // covering only the first left `getForEntity` and `getPropertyValue`
+        // disagreeing on whether the second still exists.
         const existingPsets = this.getBasePropertiesForEntity(entityId);
-        const pset = existingPsets.find(p => p.name === psetName);
-        if (pset) {
+        for (const pset of existingPsets) {
+            if (pset.name !== psetName)
+                continue;
             this.deletedPsets.add(`${entityId}:${psetName}`);
             for (const prop of pset.properties) {
                 const key = propertyKey(entityId, psetName, prop.name);
@@ -642,50 +631,25 @@ export class MutablePropertyView {
         const result = [];
         const seenQsets = new Set();
         const baseQsets = this.getBaseQuantitiesForEntity(entityId);
+        // Same name-only key, and the same claiming rule, as the property path
+        // above (`same-name-set-claims.ts`): an edit or a brand-new quantity
+        // lands on exactly one same-named qset instance.
+        const claims = computeSetClaims(baseQsets, qset => qset.quantities);
         for (const qset of baseQsets) {
             if (this.deletedQsets.has(`${entityId}:${qset.name}`))
                 continue;
             seenQsets.add(qset.name);
-            const mutatedQuantities = [];
-            for (const q of qset.quantities) {
-                const key = quantityKey(entityId, qset.name, q.name);
-                const mutation = this.quantityMutations.get(key);
-                if (mutation) {
-                    if (mutation.operation === 'DELETE')
-                        continue;
-                    mutatedQuantities.push({
-                        name: q.name,
-                        type: mutation.quantityType ?? q.type,
-                        value: mutation.value ?? q.value,
-                        unit: mutation.unit ?? q.unit,
-                    });
-                }
-                else {
-                    mutatedQuantities.push(q);
-                }
-            }
-            // Check for new quantities added to this qset (per-entity index — see
-            // the property-mutations site above for rationale).
-            const entityQtyKeys = this.quantityKeysByEntity.get(entityId);
-            if (entityQtyKeys) {
-                const qsetPrefix = `${entityId}:${qset.name}:`;
-                for (const key of entityQtyKeys) {
-                    if (!key.startsWith(qsetPrefix))
-                        continue;
-                    const mutation = this.quantityMutations.get(key);
-                    if (!mutation || mutation.operation !== 'SET')
-                        continue;
-                    const quantName = key.slice(qsetPrefix.length);
-                    if (!mutatedQuantities.some(q => q.name === quantName)) {
-                        mutatedQuantities.push({
-                            name: quantName,
-                            type: mutation.quantityType ?? QuantityType.Count,
-                            value: mutation.value ?? 0,
-                            unit: mutation.unit,
-                        });
-                    }
-                }
-            }
+            const mutatedQuantities = mutatedMembersForInstance(entityId, qset, qset.quantities, claims, this.quantityMutations, this.quantityKeysByEntity.get(entityId), quantityKey, (q, mutation) => ({
+                name: q.name,
+                type: mutation.quantityType ?? q.type,
+                value: mutation.value ?? q.value,
+                unit: mutation.unit ?? q.unit,
+            }), q => q, (name, mutation) => ({
+                name,
+                type: mutation.quantityType ?? QuantityType.Count,
+                value: mutation.value ?? 0,
+                unit: mutation.unit,
+            }));
             if (mutatedQuantities.length > 0) {
                 result.push({ name: qset.name, quantities: mutatedQuantities });
             }
@@ -789,9 +753,7 @@ export class MutablePropertyView {
             isUpdate = true;
         }
         else {
-            const baseQuantity = baseQsets
-                .find(q => q.name === qsetName)
-                ?.quantities.find(q => q.name === quantName);
+            const baseQuantity = findQuantityInBaseSets(baseQsets, qsetName, quantName);
             oldValue = baseQuantity ? baseQuantity.value : null;
             isUpdate = baseQuantity !== undefined;
         }
@@ -847,12 +809,11 @@ export class MutablePropertyView {
                 this.deleteQuantityMutation(entityId, quantityKey(entityId, qsetName, quantity.name));
             }
         }
-        // A DELETE marker only earns its keep against a qset that genuinely exists
-        // in the base file - same argument as `deletePropertySet`'s. A purely
-        // in-session qset has nothing to mask, and recording one would tell the
-        // export review a set is being removed when the net change is zero.
-        const baseQset = this.getBaseQuantitiesForEntity(entityId).find(q => q.name === qsetName);
-        if (baseQset) {
+        // Only masks a qset that genuinely exists in the base file, and covers
+        // EVERY same-named one - both arguments as in `deletePropertySet` above.
+        for (const baseQset of this.getBaseQuantitiesForEntity(entityId)) {
+            if (baseQset.name !== qsetName)
+                continue;
             this.deletedQsets.add(`${entityId}:${qsetName}`);
             for (const quantity of baseQset.quantities) {
                 this.setQuantityMutation(entityId, quantityKey(entityId, qsetName, quantity.name), { operation: 'DELETE' });
@@ -1476,6 +1437,38 @@ export class MutablePropertyView {
     getMutationsForEntity(entityId) {
         return this.mutationHistory.filter(m => m.entityId === entityId);
     }
+    /**
+     * The live overlay's CURRENT property mutation for one entity's specific
+     * pset+prop, or `undefined` when that exact key carries no override right
+     * now.
+     *
+     * Reads `propertyMutations` directly (the same map `getPropertyValue` and
+     * `hasChanges` consult) — never `mutationHistory` (see `getMutationsForEntity`
+     * above), which is append-only and does not shrink on undo. Undo re-applies
+     * the inverse mutation with `skipHistory=true` (`mutationSlice.ts`, "to
+     * avoid polluting mutation history"): that inverse call still writes
+     * through `setProperty`/`deleteProperty`, so `propertyMutations` — and thus
+     * this method — reflects the reverted (or, after redo, re-applied) value
+     * immediately, while `getMutationsForEntity` keeps returning the stale
+     * pre-undo entry.
+     *
+     * Unlike `getPropertyValue` (which collapses "no override", "override
+     * value is null", and "override is a DELETE marker" all down to a bare
+     * `null`), this returns the raw `PropertyMutation` so a caller projecting
+     * the overlay onto an EXTERNAL base it doesn't otherwise share with this
+     * view (e.g. the IDS bridge's `PropertyOverlayResolver`, #3929) can tell
+     * "nothing to apply here" apart from "apply a DELETE" apart from "apply a
+     * SET to null". Unlike `getEffectiveChanges()`, this does not require the
+     * view's own `getBasePropertiesForEntity` to already know the pset —
+     * `setProperty` always writes `propertyMutations` regardless of whether the
+     * pset is new-in-session or pre-existing (see its "Always store in
+     * propertyMutations for tracking" comment), so this stays correct for a
+     * view with no base wired at all (a `MutablePropertyView` overlay used
+     * purely as a delta against someone else's separate base).
+     */
+    getPropertyMutation(entityId, psetName, propName) {
+        return this.propertyMutations.get(propertyKey(entityId, psetName, propName));
+    }
     /**
      * Check if an entity currently carries an overlay change.
      *
@@ -1663,170 +1656,13 @@ export class MutablePropertyView {
         this.mutationHistory = [];
     }
     /**
-     * Apply a batch of mutations (e.g., from imported change set)
+     * Apply a batch of mutations (e.g., from imported change set). The
+     * dispatcher itself lives in `applyMutationsBatch` (./apply-mutations.js)
+     * — this method just supplies the two bits of private state it needs
+     * without exposing them publicly.
      */
     applyMutations(mutations) {
-        // CREATE_ENTITY records are skipped (callers must restore the
-        // payload via restoreNewEntity). Track the ids we've skipped so a
-        // matching DELETE_ENTITY in the same batch doesn't tombstone an
-        // entity that never made it into this view — that stale tombstone
-        // would later suppress a freshly-allocated overlay entity reusing
-        // the same expressId.
-        // Pass 1: collect every CREATE_ENTITY id up front, over the whole
-        // array, before applying anything. CREATE_ENTITY is unconditionally
-        // skipped below (every id it's called for lands here) — but a caller
-        // supplying an arbitrary (e.g. imported/merged) Mutation[] may not have
-        // its CREATE_ENTITY appear before the mutations that depend on it. A
-        // single incremental forward pass would only "see" a create once the
-        // loop reaches it, so a dependent mutation earlier in the array would
-        // replay before its own entity's creation was known to be skipped —
-        // reproducing the orphaned-pset bug via ordering instead of via the
-        // original bug shape. Doing the full collection first makes the result
-        // order-independent.
-        const skippedCreateIds = new Set();
-        for (const mutation of mutations) {
-            if (mutation.type === 'CREATE_ENTITY') {
-                skippedCreateIds.add(mutation.entityId);
-            }
-        }
-        // Pass 2: apply mutations against the now-complete skip set.
-        for (const mutation of mutations) {
-            // Any mutation recorded against an entity whose own CREATE_ENTITY was
-            // skipped above would otherwise replay into an orphan — a pset (or
-            // attribute/quantity/type edit) keyed to an expressId that exists in
-            // neither the source buffer nor `newEntities`. Refuse those too, so
-            // the round trip is lossy (entity + its edits both dropped) rather
-            // than corrupting (edits surviving without their entity). This keys
-            // off `skippedCreateIds`, not "id absent from newEntities", so a
-            // mutation against a normal, pre-existing source-buffer entity is
-            // never affected — only ids that had their own CREATE_ENTITY skipped
-            // in this same batch land here.
-            // The `newEntities` check makes the condition "the create was skipped
-            // AND nothing else supplied the entity". A caller following the
-            // documented recovery flow calls `restoreNewEntity()` first and
-            // *then* replays the history; the id is live by the time we get here,
-            // so there is no orphan to guard against and dropping its edits would
-            // silently lose data on the exact path the console.warn recommends.
-            if (mutation.type !== 'CREATE_ENTITY' &&
-                skippedCreateIds.has(mutation.entityId) &&
-                !this.newEntities.has(mutation.entityId)) {
-                continue;
-            }
-            switch (mutation.type) {
-                case 'CREATE_PROPERTY':
-                case 'UPDATE_PROPERTY':
-                    if (mutation.psetName && mutation.propName && mutation.newValue !== undefined) {
-                        this.setProperty(mutation.entityId, mutation.psetName, mutation.propName, mutation.newValue, mutation.valueType);
-                    }
-                    break;
-                case 'DELETE_PROPERTY':
-                    if (mutation.psetName && mutation.propName) {
-                        this.deleteProperty(mutation.entityId, mutation.psetName, mutation.propName);
-                    }
-                    break;
-                case 'DELETE_PROPERTY_SET':
-                    if (mutation.psetName) {
-                        this.deletePropertySet(mutation.entityId, mutation.psetName);
-                    }
-                    break;
-                case 'DELETE_QUANTITY_SET':
-                    if (mutation.psetName) {
-                        this.deleteQuantitySet(mutation.entityId, mutation.psetName);
-                        // The marker is recorded even when this view cannot SEE the base
-                        // set, unlike the live path. `deleteQuantitySet` only masks a set
-                        // the quantity extractor reports, and that extractor is opt-in
-                        // (null by default, and several in-tree callers wire the property
-                        // one beside it and not it). A replayed deletion is a decision the
-                        // origin session already made, so dropping it here would let a
-                        // later export regenerate a set the user removed. An inert marker
-                        // on a set that does not exist costs a row in the change list;
-                        // losing the deletion costs the user's edit.
-                        this.deletedQsets.add(`${mutation.entityId}:${mutation.psetName}`);
-                    }
-                    break;
-                case 'CREATE_QUANTITY':
-                case 'UPDATE_QUANTITY':
-                    if (mutation.psetName && mutation.propName && mutation.newValue !== undefined) {
-                        this.setQuantity(mutation.entityId, mutation.psetName, mutation.propName, Number(mutation.newValue), mutation.quantityType ?? QuantityType.Count, mutation.unit);
-                    }
-                    else if (mutation.type === 'CREATE_QUANTITY' &&
-                        mutation.psetName &&
-                        Array.isArray(mutation.newValue)) {
-                        // `createQuantitySet()` (whole-qset creation, e.g.
-                        // `StoreEditor.addQuantitySet`) records ONE CREATE_QUANTITY mutation
-                        // for the whole set — no `propName`, `newValue` is the full
-                        // quantities array — unlike `setQuantity()`'s per-quantity
-                        // CREATE_QUANTITY, which always carries both. Mirrors the
-                        // CREATE_PROPERTY_SET handling below. Without this branch the
-                        // `psetName && propName` check above is false and the record
-                        // matched this `case` with nothing done — never falling through to
-                        // the "unhandled mutation type" warning either — so a freshly
-                        // created quantity set silently vanished on
-                        // exportMutations()/importMutations() round trip.
-                        this.createQuantitySet(mutation.entityId, mutation.psetName, mutation.newValue);
-                    }
-                    break;
-                case 'UPDATE_POSITIONAL_ATTRIBUTE': {
-                    // attributeName is `@<index>` for positional mutations.
-                    const attr = mutation.attributeName ?? '';
-                    if (!attr.startsWith('@'))
-                        break;
-                    const index = Number(attr.slice(1));
-                    if (!Number.isInteger(index) || index < 0)
-                        break;
-                    if (mutation.newValue === undefined)
-                        break;
-                    this.setPositionalAttribute(mutation.entityId, index, mutation.newValue);
-                    break;
-                }
-                case 'UPDATE_ENTITY_TYPE': {
-                    const newType = mutation.entityType ?? (typeof mutation.newValue === 'string' ? mutation.newValue : undefined);
-                    if (!newType)
-                        break;
-                    this.setEntityType(mutation.entityId, newType, mutation.predefinedType ?? null, mutation.oldValue == null ? undefined : String(mutation.oldValue));
-                    break;
-                }
-                case 'UPDATE_ATTRIBUTE':
-                    if (mutation.attributeName && mutation.newValue !== undefined && mutation.newValue !== null) {
-                        this.setAttribute(mutation.entityId, mutation.attributeName, String(mutation.newValue), mutation.oldValue == null ? undefined : String(mutation.oldValue));
-                    }
-                    break;
-                case 'CREATE_PROPERTY_SET':
-                    if (mutation.psetName && Array.isArray(mutation.newValue)) {
-                        // newValue is the original properties array (see createPropertySet,
-                        // where newValue = properties: Array<{ name; value; type?; unit? }>).
-                        this.createPropertySet(mutation.entityId, mutation.psetName, mutation.newValue);
-                    }
-                    break;
-                case 'CREATE_ENTITY': {
-                    // Replay creates rely on the importer providing the entity body
-                    // via `restoreNewEntity` separately. The history record alone
-                    // doesn't carry the type+attributes payload — applying a bare
-                    // CREATE_ENTITY would lose the entity. We log and skip rather
-                    // than silently dropping it, so callers see they need to
-                    // restore the payload through the dedicated path. Unless the
-                    // caller already restored it, every other mutation recorded
-                    // against this id in this batch is dropped too (see the guard
-                    // above this switch) — otherwise the entity is gone but its edits
-                    // survive as an orphan. (skippedCreateIds was already fully
-                    // populated in pass 1, above.)
-                    // eslint-disable-next-line no-console
-                    console.warn(`applyMutations: CREATE_ENTITY for #${mutation.entityId} requires a NewEntity payload — ` +
-                        `restore via restoreNewEntity(). Skipping the record; dependent mutations recorded against ` +
-                        `#${mutation.entityId} are dropped too unless the entity was restored before this call.`);
-                    break;
-                }
-                case 'DELETE_ENTITY':
-                    this.deleteEntity(mutation.entityId);
-                    break;
-                default:
-                    // Surface unhandled mutation types instead of silently dropping
-                    // them, so future gaps in this switch are visible.
-                    // eslint-disable-next-line no-console
-                    console.warn(`applyMutations: unhandled mutation type '${mutation.type}' for #${mutation.entityId} — skipped`);
-                    break;
-            }
-        }
+        applyMutationsBatch(this, mutations, (entityId) => this.newEntities.has(entityId), (entityId, qsetName) => this.deletedQsets.add(`${entityId}:${qsetName}`));
     }
     /**
      * Export mutations as JSON. Includes every record in `mutationHistory`,
@@ -1838,7 +1674,7 @@ export class MutablePropertyView {
             modelId: this.modelId,
             mutations: this.mutationHistory,
             exportedAt: Date.now(),
-        }, null, 2);
+        }, encodeNonFiniteNumbers, 2);
     }
     /**
      * Import mutations from JSON produced by `exportMutations`.
@@ -1860,7 +1696,7 @@ export class MutablePropertyView {
      * fires.
      */
     importMutations(json) {
-        const data = JSON.parse(json);
+        const data = JSON.parse(json, decodeNonFiniteNumbers);
         if (data.mutations && Array.isArray(data.mutations)) {
             this.applyMutations(data.mutations);
         }