@pascal-app/core 0.8.0 → 0.9.1

package/dist/store/actions/node-actions.js

@@ -1,4 +1,346 @@
-import { getEffectiveWallSurfaceMaterial, getWallSurfaceMaterialSignature, } from '../../schema';
+import { AnyNode as AnyNodeSchema, getEffectiveWallSurfaceMaterial, getWallSurfaceMaterialSignature, } from '../../schema';
+const NUMBER_FORMAT_BOUNDS = {
+    safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+    int32: [-2147483648, 2147483647],
+    uint32: [0, 4294967295],
+    float32: [-3.4028234663852886e38, 3.4028234663852886e38],
+};
+const INTEGER_NUMBER_FORMATS = new Set(['safeint', 'int32', 'uint32']);
+function getSchemaDef(schema) {
+    return schema?._zod?.def ?? schema?.def;
+}
+function getSchemaDefault(schema) {
+    const def = getSchemaDef(schema);
+    if (!(def?.type === 'default' || def?.type === 'prefault'))
+        return undefined;
+    return def.defaultValue;
+}
+function unwrapSchema(schema) {
+    let current = schema ?? null;
+    while (current) {
+        const def = getSchemaDef(current);
+        if (!(def?.type === 'default' ||
+            def?.type === 'prefault' ||
+            def?.type === 'optional' ||
+            def?.type === 'nullable' ||
+            def?.type === 'catch' ||
+            def?.type === 'readonly' ||
+            def?.type === 'nonoptional')) {
+            return current;
+        }
+        current = def.innerType ?? null;
+    }
+    return null;
+}
+function getObjectShape(schema) {
+    const unwrapped = unwrapSchema(schema);
+    const def = getSchemaDef(unwrapped);
+    if (def?.type !== 'object')
+        return null;
+    return unwrapped?.shape ?? def.shape ?? null;
+}
+function schemaAllowsValue(schema, value) {
+    const unwrapped = unwrapSchema(schema);
+    if (!unwrapped)
+        return false;
+    const def = getSchemaDef(unwrapped);
+    if (unwrapped._zod?.values?.has(value))
+        return true;
+    if (Array.isArray(def?.values) && def.values.includes(value))
+        return true;
+    if (def?.entries && Object.values(def.entries).includes(value))
+        return true;
+    return false;
+}
+function getNodeSchemaForType(type) {
+    const schema = AnyNodeSchema;
+    const options = getSchemaDef(schema)?.options;
+    if (!options)
+        return null;
+    for (const option of options) {
+        const shape = getObjectShape(option);
+        if (shape?.type && schemaAllowsValue(shape.type, type)) {
+            return option;
+        }
+    }
+    return null;
+}
+function applyLowerLimit(current, candidate) {
+    if (!current)
+        return candidate;
+    if (candidate.value > current.value)
+        return candidate;
+    if (candidate.value === current.value && !candidate.inclusive)
+        return candidate;
+    return current;
+}
+function applyUpperLimit(current, candidate) {
+    if (!current)
+        return candidate;
+    if (candidate.value < current.value)
+        return candidate;
+    if (candidate.value === current.value && !candidate.inclusive)
+        return candidate;
+    return current;
+}
+function getNumberConstraints(schema) {
+    const unwrapped = unwrapSchema(schema) ?? schema;
+    const def = getSchemaDef(unwrapped);
+    const constraints = { integer: false };
+    const minValue = unwrapped.minValue;
+    if (typeof minValue === 'number') {
+        constraints.min = applyLowerLimit(constraints.min, { value: minValue, inclusive: true });
+    }
+    const maxValue = unwrapped.maxValue;
+    if (typeof maxValue === 'number') {
+        constraints.max = applyUpperLimit(constraints.max, { value: maxValue, inclusive: true });
+    }
+    for (const check of def?.checks ?? []) {
+        const checkDef = check._zod?.def;
+        if (!checkDef)
+            continue;
+        if (checkDef.check === 'greater_than' && typeof checkDef.value === 'number') {
+            constraints.min = applyLowerLimit(constraints.min, {
+                value: checkDef.value,
+                inclusive: checkDef.inclusive !== false,
+            });
+        }
+        else if (checkDef.check === 'less_than' && typeof checkDef.value === 'number') {
+            constraints.max = applyUpperLimit(constraints.max, {
+                value: checkDef.value,
+                inclusive: checkDef.inclusive !== false,
+            });
+        }
+        else if (checkDef.check === 'number_format' && checkDef.format) {
+            constraints.integer ||= INTEGER_NUMBER_FORMATS.has(checkDef.format);
+            const bounds = NUMBER_FORMAT_BOUNDS[checkDef.format];
+            if (bounds) {
+                constraints.min = applyLowerLimit(constraints.min, {
+                    value: bounds[0],
+                    inclusive: true,
+                });
+                constraints.max = applyUpperLimit(constraints.max, {
+                    value: bounds[1],
+                    inclusive: true,
+                });
+            }
+        }
+    }
+    const bag = unwrapped._zod?.bag;
+    if (typeof bag?.minimum === 'number') {
+        constraints.min = applyLowerLimit(constraints.min, { value: bag.minimum, inclusive: true });
+    }
+    if (typeof bag?.exclusiveMinimum === 'number') {
+        constraints.min = applyLowerLimit(constraints.min, {
+            value: bag.exclusiveMinimum,
+            inclusive: false,
+        });
+    }
+    if (typeof bag?.maximum === 'number') {
+        constraints.max = applyUpperLimit(constraints.max, { value: bag.maximum, inclusive: true });
+    }
+    if (typeof bag?.exclusiveMaximum === 'number') {
+        constraints.max = applyUpperLimit(constraints.max, {
+            value: bag.exclusiveMaximum,
+            inclusive: false,
+        });
+    }
+    return constraints;
+}
+function nextAbove(value) {
+    return value === 0 ? Number.EPSILON : value + Math.abs(value) * Number.EPSILON;
+}
+function nextBelow(value) {
+    return value === 0 ? -Number.EPSILON : value - Math.abs(value) * Number.EPSILON;
+}
+function clampNumber(value, constraints) {
+    let next = value;
+    let rounded = false;
+    let clamped = false;
+    if (constraints.integer && !Number.isInteger(next)) {
+        next = Math.round(next);
+        rounded = true;
+    }
+    if (constraints.min) {
+        const min = constraints.min.inclusive ? constraints.min.value : nextAbove(constraints.min.value);
+        if (next < min) {
+            next = min;
+            clamped = true;
+        }
+    }
+    if (constraints.max) {
+        const max = constraints.max.inclusive ? constraints.max.value : nextBelow(constraints.max.value);
+        if (next > max) {
+            next = max;
+            clamped = true;
+        }
+    }
+    return {
+        value: next,
+        action: clamped ? 'clamped' : rounded ? 'rounded' : undefined,
+    };
+}
+function getFiniteFallbackNumber(fallback, constraints) {
+    if (typeof fallback !== 'number' || !Number.isFinite(fallback))
+        return undefined;
+    return clampNumber(fallback, constraints).value;
+}
+function sanitizeNumber(schema, value, fallback, path) {
+    const constraints = schema ? getNumberConstraints(schema) : { integer: false };
+    if (!Number.isFinite(value)) {
+        const replacement = getFiniteFallbackNumber(fallback, constraints);
+        if (replacement === undefined) {
+            return {
+                value,
+                omit: true,
+                issues: [{ path, from: value, action: 'dropped' }],
+            };
+        }
+        return {
+            value: replacement,
+            issues: [{ path, from: value, to: replacement, action: 'dropped' }],
+        };
+    }
+    const clamped = clampNumber(value, constraints);
+    if (!Object.is(clamped.value, value)) {
+        return {
+            value: clamped.value,
+            issues: [
+                {
+                    path,
+                    from: value,
+                    to: clamped.value,
+                    action: clamped.action ?? 'clamped',
+                },
+            ],
+        };
+    }
+    return { value, issues: [] };
+}
+function sanitizeNumericValue(schema, value, fallback, path) {
+    const defaultFallback = schema ? getSchemaDefault(schema) : undefined;
+    const effectiveFallback = fallback === undefined ? defaultFallback : fallback;
+    const unwrapped = unwrapSchema(schema);
+    const def = getSchemaDef(unwrapped);
+    if (def?.type === 'number') {
+        if (typeof value !== 'number')
+            return { value, issues: [] };
+        return sanitizeNumber(unwrapped, value, effectiveFallback, path);
+    }
+    if (typeof value === 'number') {
+        return sanitizeNumber(null, value, effectiveFallback, path);
+    }
+    if (def?.type === 'tuple' && Array.isArray(value)) {
+        const fallbackItems = Array.isArray(effectiveFallback) ? effectiveFallback : [];
+        const next = [...value];
+        const issues = [];
+        for (let index = 0; index < next.length; index += 1) {
+            const itemSchema = def.items?.[index] ?? def.rest ?? null;
+            const child = sanitizeNumericValue(itemSchema, next[index], fallbackItems[index], [
+                ...path,
+                index,
+            ]);
+            issues.push(...child.issues);
+            if (child.omit) {
+                return { value, omit: true, issues };
+            }
+            next[index] = child.value;
+        }
+        return { value: issues.length > 0 ? next : value, issues };
+    }
+    if (def?.type === 'array' && Array.isArray(value)) {
+        const fallbackItems = Array.isArray(effectiveFallback) ? effectiveFallback : [];
+        const next = [];
+        const issues = [];
+        let omitted = false;
+        for (let index = 0; index < value.length; index += 1) {
+            const child = sanitizeNumericValue(def.element ?? null, value[index], fallbackItems[index], [
+                ...path,
+                index,
+            ]);
+            issues.push(...child.issues);
+            if (child.omit) {
+                omitted = true;
+                continue;
+            }
+            next.push(child.value);
+        }
+        return { value: issues.length > 0 || omitted ? next : value, issues };
+    }
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        const shape = def?.type === 'object' ? (unwrapped?.shape ?? def.shape ?? {}) : {};
+        const fallbackObject = effectiveFallback &&
+            typeof effectiveFallback === 'object' &&
+            !Array.isArray(effectiveFallback)
+            ? effectiveFallback
+            : {};
+        const input = value;
+        const next = { ...input };
+        const issues = [];
+        for (const key of Object.keys(input)) {
+            const child = sanitizeNumericValue(shape[key] ?? null, input[key], fallbackObject[key], [
+                ...path,
+                key,
+            ]);
+            issues.push(...child.issues);
+            if (child.omit) {
+                delete next[key];
+            }
+            else {
+                next[key] = child.value;
+            }
+        }
+        return { value: issues.length > 0 ? next : value, issues };
+    }
+    return { value, issues: [] };
+}
+function formatNumericValue(value) {
+    if (Number.isNaN(value))
+        return 'NaN';
+    if (value === Infinity)
+        return 'Infinity';
+    if (value === -Infinity)
+        return '-Infinity';
+    return String(value);
+}
+function numericSanitizeIssuesToMessage(issues) {
+    return issues
+        .map((issue) => {
+        const path = issue.path.map(String).join('.') || '<root>';
+        const to = issue.to === undefined ? '' : ` -> ${formatNumericValue(issue.to)}`;
+        return `${path}: ${formatNumericValue(issue.from)} ${issue.action}${to}`;
+    })
+        .join('; ');
+}
+function warnSanitizedNodeMutation(mutation, nodeId, issues) {
+    console.warn(`[Scene] Sanitized invalid numeric node ${mutation}`, nodeId, numericSanitizeIssuesToMessage(issues));
+}
+function parseCreatedNode(node, parentId) {
+    const candidate = { ...node, parentId };
+    const parsed = AnyNodeSchema.safeParse(candidate);
+    if (parsed.success)
+        return parsed.data;
+    const schema = getNodeSchemaForType(candidate.type);
+    const sanitized = sanitizeNumericValue(schema, candidate, undefined, []);
+    if (sanitized.issues.length === 0) {
+        return candidate;
+    }
+    warnSanitizedNodeMutation('create', node.id, sanitized.issues);
+    return sanitized.value;
+}
+function parseUpdatedNode(currentNode, data) {
+    const candidate = { ...currentNode, ...data };
+    const parsed = AnyNodeSchema.safeParse(candidate);
+    if (parsed.success)
+        return parsed.data;
+    const schema = getNodeSchemaForType(candidate.type);
+    const sanitized = sanitizeNumericValue(schema, data, currentNode, []);
+    if (sanitized.issues.length === 0) {
+        return candidate;
+    }
+    warnSanitizedNodeMutation('update', currentNode.id, sanitized.issues);
+    return { ...currentNode, ...sanitized.value };
+}
 // Track pending RAF for updateNodesAction to prevent multiple queued callbacks
 let pendingRafId = null;
 let pendingUpdates = new Set();
@@ -154,21 +496,25 @@ export const createNodesAction = (set, get, ops) => {
         const nextRootIds = [...state.rootNodeIds];
         for (const { node, parentId } of ops) {
             const effectiveParentId = parentId ?? node.parentId ?? null;
-            // 1. Assign parentId to the child (Safe because BaseNode has parentId)
-            const newNode = {
-                ...node,
-                parentId: effectiveParentId,
-            };
+            const newNode = parseCreatedNode(node, effectiveParentId);
             nextNodes[newNode.id] = newNode;
-            // 2. Update the Parent's children list
+            // 2. Update the Parent's children list. We append to ANY container
+            // parent (kind has `children` in its schema) — if the field is
+            // present but undefined (e.g. an old saved scene from before the
+            // kind gained children), we initialise to `[]` first so the
+            // reparenting goes through. Without this, hosting items on an
+            // old shelf (v1, before `children` was added) silently no-ops:
+            // the item is reparented to the shelf but the shelf's children
+            // array is never updated, so `ParametricNodeRenderer` doesn't
+            // mount it and the item "disappears".
             if (effectiveParentId && nextNodes[effectiveParentId]) {
                 const parent = nextNodes[effectiveParentId];
-                // Type Guard: Check if the parent node is a container that supports children
-                if ('children' in parent && Array.isArray(parent.children)) {
+                if ('children' in parent) {
+                    const existing = parent.children;
+                    const children = Array.isArray(existing) ? existing : [];
                     nextNodes[effectiveParentId] = {
                         ...parent,
-                        // Use Set to prevent duplicate IDs if createNode is called twice
-                        children: Array.from(new Set([...parent.children, newNode.id])), // We don't verify child types here
+                        children: Array.from(new Set([...children, newNode.id])),
                     };
                 }
             }
@@ -190,6 +536,125 @@ export const createNodesAction = (set, get, ops) => {
             get().markDirty(node.parentId);
     });
 };
+export const applyNodeChangesAction = (set, get, changes) => {
+    if (get().readOnly)
+        return;
+    const createOps = changes.create ?? [];
+    const updateOps = changes.update ?? [];
+    const deleteOps = changes.delete ?? [];
+    const nodesToMarkDirty = new Set();
+    const parentsToMarkDirty = new Set();
+    set((state) => {
+        const nextNodes = { ...state.nodes };
+        const nextCollections = { ...state.collections };
+        const nextRootIds = [...state.rootNodeIds];
+        let resolvedRootIds = nextRootIds;
+        for (const { id, data } of updateOps) {
+            const currentNode = nextNodes[id];
+            if (!currentNode)
+                continue;
+            const updatedNode = parseUpdatedNode(currentNode, data);
+            if (data.parentId !== undefined && data.parentId !== currentNode.parentId) {
+                const oldParentId = currentNode.parentId;
+                if (oldParentId && nextNodes[oldParentId]) {
+                    const oldParent = nextNodes[oldParentId];
+                    nextNodes[oldParent.id] = {
+                        ...oldParent,
+                        children: oldParent.children.filter((childId) => childId !== id),
+                    };
+                    parentsToMarkDirty.add(oldParent.id);
+                }
+                const newParentId = data.parentId;
+                if (newParentId && nextNodes[newParentId]) {
+                    const newParent = nextNodes[newParentId];
+                    nextNodes[newParent.id] = {
+                        ...newParent,
+                        children: Array.from(new Set([...newParent.children, id])),
+                    };
+                    parentsToMarkDirty.add(newParent.id);
+                }
+            }
+            nextNodes[id] = updatedNode;
+            nodesToMarkDirty.add(id);
+        }
+        for (const { node, parentId } of createOps) {
+            const effectiveParentId = parentId ?? node.parentId ?? null;
+            const newNode = parseCreatedNode(node, effectiveParentId);
+            nextNodes[newNode.id] = newNode;
+            nodesToMarkDirty.add(newNode.id);
+            if (effectiveParentId && nextNodes[effectiveParentId]) {
+                const parent = nextNodes[effectiveParentId];
+                if ('children' in parent && Array.isArray(parent.children)) {
+                    nextNodes[effectiveParentId] = {
+                        ...parent,
+                        children: Array.from(new Set([...parent.children, newNode.id])),
+                    };
+                    parentsToMarkDirty.add(effectiveParentId);
+                }
+            }
+            else if (!effectiveParentId && !nextRootIds.includes(newNode.id)) {
+                nextRootIds.push(newNode.id);
+            }
+        }
+        const allIdsToDelete = new Set();
+        const collectDelete = (id) => {
+            if (allIdsToDelete.has(id))
+                return;
+            allIdsToDelete.add(id);
+            const node = nextNodes[id];
+            if (node && 'children' in node && Array.isArray(node.children)) {
+                for (const childId of node.children) {
+                    collectDelete(childId);
+                }
+            }
+        };
+        for (const id of deleteOps) {
+            collectDelete(id);
+        }
+        for (const id of allIdsToDelete) {
+            const node = nextNodes[id];
+            if (!node)
+                continue;
+            const parentId = node.parentId;
+            if (parentId && nextNodes[parentId] && !allIdsToDelete.has(parentId)) {
+                const parent = nextNodes[parentId];
+                if (parent.children) {
+                    nextNodes[parent.id] = {
+                        ...parent,
+                        children: parent.children.filter((childId) => childId !== id),
+                    };
+                    parentsToMarkDirty.add(parent.id);
+                }
+            }
+            resolvedRootIds = resolvedRootIds.filter((rootId) => rootId !== id);
+            if ('collectionIds' in node && node.collectionIds) {
+                for (const collectionId of node.collectionIds) {
+                    const collection = nextCollections[collectionId];
+                    if (collection) {
+                        nextCollections[collectionId] = {
+                            ...collection,
+                            nodeIds: collection.nodeIds.filter((nodeId) => nodeId !== id),
+                        };
+                    }
+                }
+            }
+            delete nextNodes[id];
+        }
+        return { nodes: nextNodes, rootNodeIds: resolvedRootIds, collections: nextCollections };
+    });
+    for (const id of nodesToMarkDirty) {
+        get().markDirty(id);
+    }
+    for (const id of parentsToMarkDirty) {
+        get().markDirty(id);
+        const parent = get().nodes[id];
+        if (parent && 'children' in parent && Array.isArray(parent.children)) {
+            for (const childId of parent.children) {
+                get().markDirty(childId);
+            }
+        }
+    }
+};
 export const updateNodesAction = (set, get, updates) => {
     if (get().readOnly)
         return;
@@ -200,31 +665,43 @@ export const updateNodesAction = (set, get, updates) => {
             const currentNode = nextNodes[id];
             if (!currentNode)
                 continue;
+            const updatedNode = parseUpdatedNode(currentNode, data);
             // Handle Reparenting Logic
             if (data.parentId !== undefined && data.parentId !== currentNode.parentId) {
                 // 1. Remove from old parent
                 const oldParentId = currentNode.parentId;
                 if (oldParentId && nextNodes[oldParentId]) {
                     const oldParent = nextNodes[oldParentId];
+                    const oldChildren = Array.isArray(oldParent.children)
+                        ? oldParent.children
+                        : [];
                     nextNodes[oldParent.id] = {
                         ...oldParent,
-                        children: oldParent.children.filter((childId) => childId !== id),
+                        children: oldChildren.filter((childId) => childId !== id),
                     };
                     parentsToUpdate.add(oldParent.id);
                 }
-                // 2. Add to new parent
+                // 2. Add to new parent. Defensive against parents that don't yet
+                // carry a `children` array — older saved scenes can predate the
+                // schema field on a particular kind (shelf v1 → v2 added one),
+                // and a spread of `undefined` here throws and aborts the entire
+                // `set` callback. Initialising to `[]` matches what the schema's
+                // default would have produced.
                 const newParentId = data.parentId;
                 if (newParentId && nextNodes[newParentId]) {
                     const newParent = nextNodes[newParentId];
+                    const newChildren = Array.isArray(newParent.children)
+                        ? newParent.children
+                        : [];
                     nextNodes[newParent.id] = {
                         ...newParent,
-                        children: Array.from(new Set([...newParent.children, id])),
+                        children: Array.from(new Set([...newChildren, id])),
                     };
                     parentsToUpdate.add(newParent.id);
                 }
             }
             // Apply the update
-            nextNodes[id] = { ...nextNodes[id], ...data };
+            nextNodes[id] = updatedNode;
         }
         return { nodes: nextNodes };
     });

package/dist/store/actions/node-mutation-sanitize.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=node-mutation-sanitize.test.d.ts.map

package/dist/store/actions/node-mutation-sanitize.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-mutation-sanitize.test.d.ts","sourceRoot":"","sources":["../../../src/store/actions/node-mutation-sanitize.test.ts"],"names":[],"mappings":""}