@relu-interactives/spatial-ecs 0.2.20 → 0.2.22

package/dist/index.js

@@ -1,11 +1,11 @@
-import { MeshGeometrySystem, InstancedMeshSystem, EnvironmentSyncSystem, PostprocessingSyncSystem, LightSyncSystem, MaterialSyncSystem, PhysicsSyncSystem, AnimationSystem, AudioSystem, VideoSystem, CameraSyncSystem, TransformSyncSystem, ObjectVisibilitySystem, RenderSystem, spawnPrefab, despawnPrefab, collectEntitySubtree } from './chunk-67MFQDHX.js';
-export { AnimationSystem, AudioSystem, Behaviour, CameraSyncSystem, EnvironmentSyncSystem, HYDRATABLE_ENTITY_KINDS, InputSystem, InstancedMeshSystem, KeyboardKeys, LightSyncSystem, MaterialSyncSystem, MeshGeometrySystem, OVERRIDE_DIFF_EXCLUDED_COMPONENTS, OVERRIDE_ROOT_EXCLUDED_COMPONENTS, ObjectVisibilitySystem, PREFAB_FILE_VERSION, PhysicsSyncSystem, PostprocessingSyncSystem, RenderSystem, ScriptBehaviourSystem, TransformSyncSystem, VideoSystem, buildComponentValueMaps, buildNodeMapsFromSnapshot, canonicalizeComponentValue, clearPrefabCache, collectDiffPaths, collectEntitySubtree, computeInstanceOverrides, decanonicalizeComponentValue, despawnPrefab, encodeOverride, findSnapshotRootEntityIds, groupOverridePaths, hydrateWorldFromSnapshot, hydrateWorldFromSnapshotDetailed, indexSnapshotByEntity, instantiateSubtree, loadPrefab, mergeComponentValue, parseOverride, parsePrefabAsset, restoreComponentState, restorePostCreateComponents, setPrefabAssetUrlResolver, spawnPrefab } from './chunk-67MFQDHX.js';
-import { registerDefaultFactories } from './chunk-HUHN6IFD.js';
-export { createAnimationComponent, createAudioComponent, createCameraComponent, createEntityTypeComponent, createEnvironmentComponent, createImageComponent, createImageTargetAnchorComponent, createImageTargetComponent, createInstanceSlotComponent, createInstancedMeshComponent, createLightComponent, createMaterialComponent, createMeshComponent, createMeshGeometryComponent, createModelComponent, createNameComponent, createObject3DRefComponent, createParentIdComponent, createPhysicsComponent, createPostprocessingComponent, createScriptComponent, createSelectableComponent, createSelectionTransformStateComponent, createSpriteComponent, createTransformComponent, createVideoComponent, registerDefaultComponentFactories, registerDefaultFactories } from './chunk-HUHN6IFD.js';
-import { ObjectManagementSystem } from './chunk-DY4ETMP2.js';
-export { ObjectManagementSystem, SHARED_MODEL_RESOURCE_FLAG, clearModelCache, loadSharedGltf, resolveDracoDecoderPath, setDracoDecoderPath } from './chunk-DY4ETMP2.js';
-import { SelectionTransformState, Object3DRef, Name, EntityType, ParentId, Environment, Postprocessing, ScriptComponent } from './chunk-Z6OMYEXU.js';
-export { AnimationStateMachine, AnimationStateManager, components_exports as CoreComponents } from './chunk-Z6OMYEXU.js';
+import { MeshGeometrySystem, InstancedMeshSystem, EnvironmentSyncSystem, PostprocessingSyncSystem, LightSyncSystem, MaterialSyncSystem, PhysicsSyncSystem, AnimationSystem, AudioSystem, VideoSystem, CameraSyncSystem, TransformSyncSystem, ObjectVisibilitySystem, RenderSystem, spawnPrefab, despawnPrefab, buildNodeKeyMapsFromSnapshot, indexSnapshotByEntity, findTopLevelNestedRegions, collectSnapshotSubtreeIds, groupOverridePaths, OVERRIDE_DIFF_EXCLUDED_COMPONENTS, OVERRIDE_ROOT_EXCLUDED_COMPONENTS, canonicalizeComponentValue, mergeComponentValue, decanonicalizeComponentValue, computeInstanceOverrides, collectEntitySubtree, ADDED_NODE_MARKER_COMPONENT } from './chunk-GZ2NKSMV.js';
+export { ADDED_NODE_MARKER_COMPONENT, AnimationSystem, AudioSystem, Behaviour, CameraSyncSystem, EnvironmentSyncSystem, HYDRATABLE_ENTITY_KINDS, InputSystem, InstancedMeshSystem, KeyboardKeys, LightSyncSystem, MaterialSyncSystem, MeshGeometrySystem, NODE_KEY_SEPARATOR, OVERRIDE_DIFF_EXCLUDED_COMPONENTS, OVERRIDE_ROOT_EXCLUDED_COMPONENTS, ObjectVisibilitySystem, PREFAB_FILE_VERSION, PREFAB_FILE_VERSION_NESTED, PhysicsSyncSystem, PostprocessingSyncSystem, RenderSystem, SCRIPT_OBJECT_ROOT_FLAG, ScriptBehaviourSystem, ScriptObject, ScriptObjectSystem, TransformSyncSystem, VideoSystem, buildComponentValueMaps, buildNodeKeyMapsFromSnapshot, buildNodeMapsFromSnapshot, canonicalizeComponentValue, clearPrefabCache, collectDiffPaths, collectEntitySubtree, collectSnapshotSubtreeIds, computeInstanceOverrides, decanonicalizeComponentValue, despawnPrefab, encodeOverride, findSnapshotRootEntityIds, findTopLevelNestedRegions, groupOverridePaths, hydrateWorldFromSnapshot, hydrateWorldFromSnapshotDetailed, indexSnapshotByEntity, instantiateSubtree, loadPrefab, mergeComponentValue, parseOverride, parsePrefabAsset, prefabFileVersionFor, restoreComponentState, restorePostCreateComponents, setPrefabAssetUrlResolver, spawnPrefab } from './chunk-GZ2NKSMV.js';
+import { registerDefaultFactories } from './chunk-52CHDPRQ.js';
+export { createAnimationComponent, createAudioComponent, createCameraComponent, createEntityTypeComponent, createEnvironmentComponent, createImageComponent, createImageTargetAnchorComponent, createImageTargetComponent, createInstanceSlotComponent, createInstancedMeshComponent, createLightComponent, createMaterialComponent, createMeshComponent, createMeshGeometryComponent, createModelComponent, createNameComponent, createObject3DRefComponent, createParentIdComponent, createPhysicsComponent, createPostprocessingComponent, createScriptComponent, createScriptObjectComponent, createSelectableComponent, createSelectionTransformStateComponent, createSpriteComponent, createTransformComponent, createVideoComponent, registerDefaultComponentFactories, registerDefaultFactories } from './chunk-52CHDPRQ.js';
+import { ObjectManagementSystem } from './chunk-WKGCC7YL.js';
+export { ObjectManagementSystem, SHARED_MODEL_RESOURCE_FLAG, clearModelCache, loadSharedGltf, resolveDracoDecoderPath, setDracoDecoderPath } from './chunk-WKGCC7YL.js';
+import { SelectionTransformState, Object3DRef, Name, EntityType, ParentId, Environment, Postprocessing, ScriptComponent } from './chunk-JHCPRVBC.js';
+export { AnimationStateMachine, AnimationStateManager, components_exports as CoreComponents } from './chunk-JHCPRVBC.js';
 import './chunk-QHILSPT4.js';
 import { normalizeDebugValue, DEBUG_CHANGE_IGNORED_SYSTEMS, cloneHistoryValue } from './chunk-ZXGHKX7N.js';
 import { __name } from './chunk-OY7ZODZP.js';
@@ -1037,6 +1037,11 @@ function remapSnapshotEntityIds(snapshot, idMap, options) {
             };
           });
         }
+      } else if (block.component === "ScriptObjectComponent" && record) {
+        const data = asRecord(record.data);
+        if (data) {
+          record.data = remapScriptData(data, idMap, nullExternal, warn);
+        }
       } else if (block.component === "InstancedMeshComponent" && record) {
         if (Array.isArray(record.instanceEntityIds)) {
           const remapped = [];
@@ -1078,12 +1083,237 @@ function remapSnapshotEntityIds(snapshot, idMap, options) {
 }
 __name(remapSnapshotEntityIds, "remapSnapshotEntityIds");
 
+// core/prefab/applyPrefabToSnapshot.ts
+var asRecord2 = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null, "asRecord");
+var clone = /* @__PURE__ */ __name((value) => structuredClone(value), "clone");
+var stableStringify = /* @__PURE__ */ __name((value) => {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}, "stableStringify");
+function getBlock(snapshot, component) {
+  let block = snapshot.components.find((b) => b.component === component);
+  if (!block) {
+    block = { component, entries: [] };
+    snapshot.components.push(block);
+  }
+  return block;
+}
+__name(getBlock, "getBlock");
+function setEntry(snapshot, component, entityId, value) {
+  const block = getBlock(snapshot, component);
+  const entry = block.entries.find((e) => e.entityId === entityId);
+  if (entry) {
+    entry.value = value;
+  } else {
+    block.entries.push({ entityId, value });
+    block.entries.sort((a, b) => a.entityId - b.entityId);
+  }
+}
+__name(setEntry, "setEntry");
+function deleteEntities(snapshot, entityIds) {
+  snapshot.entities = snapshot.entities.filter((id) => !entityIds.has(id));
+  snapshot.components = snapshot.components.map((block) => ({
+    component: block.component,
+    entries: block.entries.filter((e) => !entityIds.has(e.entityId))
+  })).filter((block) => block.entries.length > 0);
+}
+__name(deleteEntities, "deleteEntities");
+function extractRegionDoc(hostSnapshot, regionIds) {
+  const idSet = new Set(regionIds);
+  return {
+    entities: regionIds.slice(),
+    components: hostSnapshot.components.map((block) => ({
+      component: block.component,
+      entries: block.entries.filter((e) => idSet.has(e.entityId))
+    })).filter((block) => block.entries.length > 0)
+  };
+}
+__name(extractRegionDoc, "extractRegionDoc");
+function applyPrefabToSnapshotInstances(hostSnapshot, nestedUrl, newNestedSnapshot) {
+  const host = clone(hostSnapshot);
+  const newMaps = buildNodeKeyMapsFromSnapshot(newNestedSnapshot);
+  const newByEntity = indexSnapshotByEntity(newNestedSnapshot);
+  if (!newMaps.rootKey) {
+    return { snapshot: host, changed: false };
+  }
+  let changed = false;
+  const regions = findTopLevelNestedRegions(host).filter(
+    (region) => region.url === nestedUrl
+  );
+  for (const region of regions) {
+    const before = stableStringify(
+      extractRegionDoc(host, collectSnapshotSubtreeIds(host, region.rootEntityId))
+    );
+    patchRegion(host, region.rootEntityId, region.overrides, {
+      newSnapshot: newNestedSnapshot,
+      newMaps,
+      newByEntity
+    });
+    const after = stableStringify(
+      extractRegionDoc(host, collectSnapshotSubtreeIds(host, region.rootEntityId))
+    );
+    if (before !== after) {
+      changed = true;
+    }
+  }
+  return { snapshot: host, changed };
+}
+__name(applyPrefabToSnapshotInstances, "applyPrefabToSnapshotInstances");
+function patchRegion(host, regionRootId, storedOverrides, file) {
+  const { newSnapshot, newMaps, newByEntity } = file;
+  const regionIds = collectSnapshotSubtreeIds(host, regionRootId);
+  const regionDoc = extractRegionDoc(host, regionIds);
+  const regionMaps = buildNodeKeyMapsFromSnapshot(regionDoc, {
+    scopeRootEntityId: regionRootId
+  });
+  const regionByEntity = indexSnapshotByEntity(regionDoc);
+  const grouped = groupOverridePaths(storedOverrides);
+  const overridePathsFor = /* @__PURE__ */ __name((key, component) => grouped.get(key)?.get(component), "overridePathsFor");
+  const isMarkedAddition = /* @__PURE__ */ __name((key) => Boolean(grouped.get(key)?.get(ADDED_NODE_MARKER_COMPONENT)), "isMarkedAddition");
+  const parentBlockNew = newSnapshot.components.find(
+    (b) => b.component === "ParentId"
+  );
+  const keyToHostId = /* @__PURE__ */ new Map();
+  for (const [hostId, key] of regionMaps.idToKey) {
+    keyToHostId.set(key, hostId);
+  }
+  const addedFileIds = [...newMaps.keyToId.entries()].filter(([key]) => !keyToHostId.has(key)).map(([, fileId]) => fileId);
+  if (addedFileIds.length > 0) {
+    let nextHostId = Math.max(0, ...host.entities) + 1;
+    const addedSet = new Set(addedFileIds);
+    const idMap = /* @__PURE__ */ new Map();
+    for (const [key, fileId] of newMaps.keyToId) {
+      const hostId = keyToHostId.get(key);
+      if (hostId !== void 0) {
+        idMap.set(fileId, hostId);
+      }
+    }
+    for (const fileId of addedFileIds) {
+      idMap.set(fileId, nextHostId);
+      nextHostId += 1;
+    }
+    const addedSub = {
+      entities: newSnapshot.entities.filter((id) => addedSet.has(id)),
+      components: newSnapshot.components.map((block) => ({
+        component: block.component,
+        entries: block.entries.filter((e) => addedSet.has(e.entityId))
+      })).filter((block) => block.entries.length > 0)
+    };
+    const { snapshot: remapped } = remapSnapshotEntityIds(addedSub, idMap, {
+      externalRefPolicy: "null"
+    });
+    host.entities = [...host.entities, ...remapped.entities];
+    for (const block of remapped.components) {
+      for (const entry of block.entries) {
+        setEntry(host, block.component, entry.entityId, entry.value);
+      }
+    }
+    for (const fileId of addedFileIds) {
+      const hostId = idMap.get(fileId);
+      const parentValue = asRecord2(
+        parentBlockNew?.entries.find((e) => e.entityId === fileId)?.value
+      )?.value;
+      if (typeof parentValue === "number" && !addedSet.has(parentValue)) {
+        const parentKey = newMaps.idToKey.get(parentValue);
+        const parentHost = parentKey ? keyToHostId.get(parentKey) : void 0;
+        setEntry(host, "ParentId", hostId, {
+          __type: "ParentId",
+          value: parentHost ?? regionRootId
+        });
+      }
+      const key = newMaps.idToKey.get(fileId);
+      if (key) {
+        keyToHostId.set(key, hostId);
+      }
+    }
+  }
+  for (const [key, fileId] of newMaps.keyToId) {
+    const hostId = keyToHostId.get(key);
+    if (hostId === void 0) continue;
+    const isRegionRoot = key === newMaps.rootKey;
+    const fileComponents = newByEntity.get(fileId);
+    if (!fileComponents) continue;
+    const regionEntityComponents = regionByEntity.get(hostId);
+    for (const [componentName, fileRaw] of fileComponents) {
+      if (OVERRIDE_DIFF_EXCLUDED_COMPONENTS.has(componentName)) continue;
+      if (isRegionRoot && OVERRIDE_ROOT_EXCLUDED_COMPONENTS.has(componentName))
+        continue;
+      const fileCanonical = canonicalizeComponentValue(
+        componentName,
+        fileRaw,
+        newMaps.idToKey
+      );
+      const regionRaw = regionEntityComponents?.get(componentName);
+      const regionCanonical = regionRaw === void 0 ? void 0 : canonicalizeComponentValue(
+        componentName,
+        regionRaw,
+        regionMaps.idToKey
+      );
+      const merged = regionCanonical === void 0 ? fileCanonical : mergeComponentValue(
+        fileCanonical,
+        regionCanonical,
+        overridePathsFor(key, componentName)
+      );
+      if (regionCanonical !== void 0 && stableStringify(merged) === stableStringify(regionCanonical)) {
+        continue;
+      }
+      const hostValue = decanonicalizeComponentValue(merged, keyToHostId);
+      setEntry(host, componentName, hostId, hostValue);
+    }
+  }
+  const removedHostIds = /* @__PURE__ */ new Set();
+  for (const [key, hostId] of keyToHostId) {
+    if (newMaps.keyToId.has(key)) continue;
+    if (isMarkedAddition(key)) continue;
+    removedHostIds.add(hostId);
+  }
+  if (removedHostIds.size > 0) {
+    const regionIdSet = new Set(regionIds);
+    const parentBlockHost = host.components.find(
+      (b) => b.component === "ParentId"
+    );
+    for (const entry of parentBlockHost?.entries ?? []) {
+      const record = asRecord2(entry.value);
+      if (!removedHostIds.has(entry.entityId) && regionIdSet.has(entry.entityId) && record && typeof record.value === "number" && removedHostIds.has(record.value)) {
+        record.value = regionRootId;
+      }
+    }
+    deleteEntities(host, removedHostIds);
+  }
+  const refreshedRegionIds = collectSnapshotSubtreeIds(host, regionRootId);
+  const refreshedDoc = extractRegionDoc(host, refreshedRegionIds);
+  const refreshedOverrides = computeInstanceOverrides(
+    newSnapshot,
+    refreshedDoc,
+    { emitAdditionMarkers: true }
+  );
+  const instanceEntry = asRecord2(
+    host.components.find((b) => b.component === "PrefabInstance")?.entries.find((e) => e.entityId === regionRootId)?.value
+  );
+  if (instanceEntry) {
+    instanceEntry.overrides = refreshedOverrides;
+  }
+}
+__name(patchRegion, "patchRegion");
+
+// core/prefab/dependencies.ts
+function collectDirectPrefabDependencies(snapshot) {
+  const urls = /* @__PURE__ */ new Set();
+  for (const region of findTopLevelNestedRegions(snapshot)) {
+    urls.add(region.url);
+  }
+  return [...urls];
+}
+__name(collectDirectPrefabDependencies, "collectDirectPrefabDependencies");
+
 // core/prefab/serializeEntitySubtree.ts
 var SUBTREE_EXCLUDED_COMPONENTS = /* @__PURE__ */ new Set([
   "Environment",
   "Postprocessing",
-  "SelectionTransformState",
-  "PrefabInstance"
+  "SelectionTransformState"
 ]);
 function serializeEntitySubtree(world, rootId, options) {
   const orderedIds = collectEntitySubtree(world, [rootId]);
@@ -1115,6 +1345,19 @@ function serializeEntitySubtree(world, rootId, options) {
   if (rootParentEntry && rootParentEntry.value !== null && typeof rootParentEntry.value === "object") {
     rootParentEntry.value.value = null;
   }
+  const prefabInstanceBlock = snapshot.components.find(
+    (block) => block.component === "PrefabInstance"
+  );
+  if (prefabInstanceBlock) {
+    prefabInstanceBlock.entries = prefabInstanceBlock.entries.filter(
+      (entry) => entry.entityId !== rootFileId
+    );
+    if (prefabInstanceBlock.entries.length === 0) {
+      snapshot.components = snapshot.components.filter(
+        (block) => block !== prefabInstanceBlock
+      );
+    }
+  }
   const filteredWarnings = warnings.filter(
     (warning) => !(warning.component === "ParentId" && warning.entityId === rootId)
   );
@@ -1122,6 +1365,6 @@ function serializeEntitySubtree(world, rootId, options) {
 }
 __name(serializeEntitySubtree, "serializeEntitySubtree");
 
-export { World, remapSnapshotEntityIds, serializeEntitySubtree };
+export { World, applyPrefabToSnapshotInstances, collectDirectPrefabDependencies, remapSnapshotEntityIds, serializeEntitySubtree };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map