@pascal-app/core 0.3.2 → 0.4.0

package/dist/utils/clone-scene-graph.js

@@ -11,8 +11,8 @@ function extractIdPrefix(id) {
  * parent-child relationships and other internal references.
  *
  * This is useful for:
+ * - Duplicating a project (host app creates a new project record, then loads the cloned scene)
  * - Copying nodes between different projects
- * - Duplicating a subset of a scene within the same project
  * - Multi-scene in-memory scenarios
  */
 export function cloneSceneGraph(sceneGraph) {
@@ -28,17 +28,28 @@ export function cloneSceneGraph(sceneGraph) {
     const clonedNodes = {};
     for (const [oldId, node] of Object.entries(nodes)) {
         const newId = idMap.get(oldId);
-        // structuredClone to avoid shared references between original and clone
         const clonedNode = structuredClone({ ...node, id: newId });
         // Remap parentId
         if (clonedNode.parentId && typeof clonedNode.parentId === 'string') {
             clonedNode.parentId = (idMap.get(clonedNode.parentId) ?? null);
         }
-        // Remap children array (walls, levels, buildings, sites, items can have children)
+        // Remap children array (buildings, levels, walls, items, etc.)
+        // Children can be either string IDs or embedded node objects (with an `id` property).
+        // Normalize both forms to remapped string IDs.
         if ('children' in clonedNode && Array.isArray(clonedNode.children)) {
             ;
             clonedNode.children = clonedNode.children
-                .map((childId) => idMap.get(childId))
+                .map((child) => {
+                if (typeof child === 'string')
+                    return idMap.get(child);
+                if (child &&
+                    typeof child === 'object' &&
+                    'id' in child &&
+                    typeof child.id === 'string') {
+                    return idMap.get(child.id);
+                }
+                return undefined;
+            })
                 .filter((id) => id !== undefined);
         }
         // Remap wallId (items/doors/windows attached to walls)
@@ -57,7 +68,6 @@ export function cloneSceneGraph(sceneGraph) {
     if (collections) {
         clonedCollections = {};
         const collectionIdMap = new Map();
-        // Generate new collection IDs
         for (const collectionId of Object.keys(collections)) {
             collectionIdMap.set(collectionId, generateId('collection'));
         }
@@ -94,3 +104,148 @@ export function cloneSceneGraph(sceneGraph) {
         ...(clonedCollections && { collections: clonedCollections }),
     };
 }
+/**
+ * Deep clones a level node and all its descendants with fresh IDs.
+ * All internal references (parentId, children, wallId) are remapped to the new IDs.
+ * The cloned level node's parentId is preserved (building ID) — not remapped.
+ *
+ * Unlike `cloneSceneGraph` (which operates on serialized data), this function works
+ * on live runtime nodes that may have non-serializable properties (Three.js objects,
+ * etc.). It uses JSON roundtrip to safely strip them.
+ *
+ * @returns clonedNodes - flat array of all cloned nodes (level + descendants)
+ * @returns newLevelId - the ID of the cloned level node
+ * @returns idMap - old ID → new ID mapping
+ */
+export function cloneLevelSubtree(nodes, levelId) {
+    const levelNode = nodes[levelId];
+    if (!levelNode || levelNode.type !== 'level') {
+        throw new Error(`Node "${levelId}" is not a level`);
+    }
+    // Recursively collect the level node + all descendants via children arrays
+    const subtreeIds = new Set();
+    const collect = (id) => {
+        if (subtreeIds.has(id))
+            return;
+        const node = nodes[id];
+        if (!node)
+            return;
+        subtreeIds.add(id);
+        if ('children' in node && Array.isArray(node.children)) {
+            for (const childId of node.children) {
+                collect(childId);
+            }
+        }
+    };
+    collect(levelId);
+    // Build ID mapping: old → new
+    const idMap = new Map();
+    for (const oldId of subtreeIds) {
+        const prefix = extractIdPrefix(oldId);
+        idMap.set(oldId, generateId(prefix));
+    }
+    const newLevelId = idMap.get(levelId);
+    // Clone each node with remapped references.
+    // Use JSON roundtrip instead of structuredClone because live runtime nodes may
+    // carry non-serializable properties (Three.js Object3D refs, functions, etc.)
+    // that structuredClone would throw on.
+    const clonedNodes = [];
+    for (const oldId of subtreeIds) {
+        const node = nodes[oldId];
+        if (!node)
+            continue;
+        const newId = idMap.get(oldId);
+        // JSON roundtrip: safely strips functions, Object3D, circular refs, etc.
+        const cloned = JSON.parse(JSON.stringify(node));
+        cloned.id = newId;
+        // Remap parentId — but only for descendants, not the level node itself
+        // (the level's parentId points to the building, which is outside the subtree)
+        if (oldId !== levelId && cloned.parentId && typeof cloned.parentId === 'string') {
+            cloned.parentId = (idMap.get(cloned.parentId) ?? cloned.parentId);
+        }
+        // Remap children array
+        if ('children' in cloned && Array.isArray(cloned.children)) {
+            ;
+            cloned.children = cloned.children
+                .map((child) => {
+                if (typeof child === 'string')
+                    return idMap.get(child) ?? child;
+                if (child &&
+                    typeof child === 'object' &&
+                    'id' in child &&
+                    typeof child.id === 'string') {
+                    return idMap.get(child.id) ?? child.id;
+                }
+                return child;
+            })
+                .filter((id) => typeof id === 'string');
+        }
+        // Remap wallId (doors/windows attached to walls)
+        if ('wallId' in cloned && typeof cloned.wallId === 'string') {
+            ;
+            cloned.wallId = idMap.get(cloned.wallId) ?? cloned.wallId;
+        }
+        clonedNodes.push(cloned);
+    }
+    return { clonedNodes, newLevelId, idMap };
+}
+/**
+ * Forks a scene graph for use as a new project: clones with new IDs and strips
+ * scan and guide nodes (and their references) since those contain user-uploaded
+ * imagery that shouldn't carry over to a forked project.
+ */
+export function forkSceneGraph(sceneGraph) {
+    const { nodes, rootNodeIds, collections } = sceneGraph;
+    // First, identify scan and guide node IDs to exclude (user-uploaded imagery)
+    const excludedNodeIds = new Set();
+    for (const [nodeId, node] of Object.entries(nodes)) {
+        if (node.type === 'scan' || node.type === 'guide') {
+            excludedNodeIds.add(nodeId);
+        }
+    }
+    // Build a filtered scene graph without scan nodes
+    const filteredNodes = {};
+    for (const [nodeId, node] of Object.entries(nodes)) {
+        if (excludedNodeIds.has(nodeId))
+            continue;
+        const clonedNode = structuredClone(node);
+        // Remove scan children from any parent that references them.
+        // Children can be string IDs or embedded node objects.
+        if ('children' in clonedNode && Array.isArray(clonedNode.children)) {
+            ;
+            clonedNode.children = clonedNode.children.filter((child) => {
+                const childId = typeof child === 'string'
+                    ? child
+                    : child && typeof child === 'object' && 'id' in child
+                        ? child.id
+                        : null;
+                return childId ? !excludedNodeIds.has(childId) : true;
+            });
+        }
+        filteredNodes[nodeId] = clonedNode;
+    }
+    const filteredRootNodeIds = rootNodeIds.filter((id) => !excludedNodeIds.has(id));
+    // Filter collections to remove references to scan nodes
+    let filteredCollections;
+    if (collections) {
+        filteredCollections = {};
+        for (const [collectionId, collection] of Object.entries(collections)) {
+            const filteredNodeIds = collection.nodeIds.filter((id) => !excludedNodeIds.has(id));
+            if (filteredNodeIds.length > 0) {
+                filteredCollections[collectionId] = {
+                    ...collection,
+                    nodeIds: filteredNodeIds,
+                    controlNodeId: collection.controlNodeId && excludedNodeIds.has(collection.controlNodeId)
+                        ? undefined
+                        : collection.controlNodeId,
+                };
+            }
+        }
+    }
+    // Now clone the filtered graph with new IDs
+    return cloneSceneGraph({
+        nodes: filteredNodes,
+        rootNodeIds: filteredRootNodeIds,
+        ...(filteredCollections && { collections: filteredCollections }),
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pascal-app/core",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Core library for Pascal 3D building editor",
   "type": "module",
   "main": "./dist/index.js",
@@ -10,6 +10,11 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./clone-scene-graph": {
+      "types": "./dist/utils/clone-scene-graph.d.ts",
+      "import": "./dist/utils/clone-scene-graph.js",
+      "default": "./dist/utils/clone-scene-graph.js"
     }
   },
   "files": [