react-three-game 0.0.69 → 0.0.71

package/dist/tools/prefabeditor/prefab.js

@@ -0,0 +1,229 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { getComponentAssetRefs, getComponentDef } from './components/ComponentRegistry';
+function clonePrefabValue(value) {
+    if (Array.isArray(value)) {
+        return value.map(item => clonePrefabValue(item));
+    }
+    if (value && typeof value === 'object') {
+        const clone = {};
+        Object.entries(value).forEach(([key, entry]) => {
+            clone[key] = clonePrefabValue(entry);
+        });
+        return clone;
+    }
+    return value;
+}
+function createComponentMap(components) {
+    const componentMap = {
+        transform: createComponentData('Transform'),
+    };
+    Object.entries(components).forEach(([key, component]) => {
+        componentMap[key] = createComponentData(component.type, component.properties);
+    });
+    return componentMap;
+}
+function getNodeNameFromPath(path, name) {
+    return name !== null && name !== void 0 ? name : path.replace(/^.*[\/]/, '').replace(/\.[^.]+$/, '');
+}
+function getAssetManifestKey(assetRefCounts) {
+    return Object.keys(assetRefCounts).sort().join('|');
+}
+function sameStringArrays(left, right) {
+    if (left.length !== right.length)
+        return false;
+    return left.every((value, index) => value === right[index]);
+}
+function getAssetRefs(node) {
+    var _a;
+    const refs = [];
+    Object.values((_a = node === null || node === void 0 ? void 0 : node.components) !== null && _a !== void 0 ? _a : {}).forEach(component => {
+        var _a;
+        if (!(component === null || component === void 0 ? void 0 : component.type))
+            return;
+        for (const ref of getComponentAssetRefs(component.type, (_a = component.properties) !== null && _a !== void 0 ? _a : {})) {
+            refs.push(`${ref.type}:${ref.path}`);
+        }
+    });
+    return refs.sort();
+}
+function addAssetRefs(assetRefCounts, refs) {
+    refs.forEach(ref => {
+        var _a;
+        assetRefCounts[ref] = ((_a = assetRefCounts[ref]) !== null && _a !== void 0 ? _a : 0) + 1;
+    });
+}
+function removeAssetRefs(assetRefCounts, refs) {
+    refs.forEach(ref => {
+        var _a;
+        const nextCount = ((_a = assetRefCounts[ref]) !== null && _a !== void 0 ? _a : 0) - 1;
+        if (nextCount > 0) {
+            assetRefCounts[ref] = nextCount;
+            return;
+        }
+        delete assetRefCounts[ref];
+    });
+}
+function createAssetRefCounts(nodesById) {
+    const assetRefCounts = {};
+    Object.values(nodesById).forEach(node => addAssetRefs(assetRefCounts, getAssetRefs(node)));
+    return assetRefCounts;
+}
+function denormalizeNode(id, nodesById, childIdsById) {
+    var _a;
+    const node = nodesById[id];
+    return Object.assign(Object.assign({}, node), { children: ((_a = childIdsById[id]) !== null && _a !== void 0 ? _a : []).map(childId => denormalizeNode(childId, nodesById, childIdsById)) });
+}
+export function createDefaultComponentProperties(type) {
+    var _a, _b;
+    return clonePrefabValue((_b = (_a = getComponentDef(type)) === null || _a === void 0 ? void 0 : _a.defaultProperties) !== null && _b !== void 0 ? _b : {});
+}
+export function createComponentData(type, properties) {
+    return {
+        type,
+        properties: properties ? clonePrefabValue(properties) : createDefaultComponentProperties(type),
+    };
+}
+export function createNode(name, components = {}, options) {
+    var _a;
+    return Object.assign({ id: (_a = options === null || options === void 0 ? void 0 : options.id) !== null && _a !== void 0 ? _a : crypto.randomUUID(), name, components: createComponentMap(components) }, ((options === null || options === void 0 ? void 0 : options.children) ? { children: options.children } : null));
+}
+export function createEmptyNode(name = 'New Node') {
+    return createNode(name);
+}
+export function createEmptyPrefab() {
+    return {
+        id: crypto.randomUUID(),
+        name: 'New Prefab',
+        root: createNode('Root', {}, { id: crypto.randomUUID(), children: [] }),
+    };
+}
+export function createModelNode(filename, name) {
+    return createNode(getNodeNameFromPath(filename, name), {
+        model: {
+            type: 'Model',
+            properties: {
+                filename,
+                instanced: false,
+                repeat: false,
+                repeatAxes: [{ axis: 'x', count: 1, offset: 1 }],
+            },
+        },
+    });
+}
+export function createImageNode(texturePath, name) {
+    return createNode(getNodeNameFromPath(texturePath, name), {
+        geometry: {
+            type: 'Geometry',
+            properties: { geometryType: 'plane', args: [1, 1] },
+        },
+        material: {
+            type: 'Material',
+            properties: { color: '#ffffff', texture: texturePath },
+        },
+    });
+}
+export function normalizePrefab(prefab, revision = 0) {
+    const nodesById = {};
+    const childIdsById = {};
+    const parentIdById = {};
+    insertSubtree(prefab.root, null, nodesById, childIdsById, parentIdById);
+    const assetRefCounts = createAssetRefCounts(nodesById);
+    return {
+        prefabId: prefab.id,
+        prefabName: prefab.name,
+        rootId: prefab.root.id,
+        nodesById,
+        childIdsById,
+        parentIdById,
+        revision,
+        assetManifestKey: getAssetManifestKey(assetRefCounts),
+        assetRefCounts,
+    };
+}
+export function createPrefabPatch(state, patch, nextAssetRefCounts = state.assetRefCounts) {
+    const assetRefsChanged = nextAssetRefCounts !== state.assetRefCounts;
+    return Object.assign(Object.assign(Object.assign({}, patch), { revision: state.revision + 1 }), (assetRefsChanged ? {
+        assetRefCounts: nextAssetRefCounts,
+        assetManifestKey: getAssetManifestKey(nextAssetRefCounts),
+    } : null));
+}
+export function denormalizePrefab(state) {
+    return {
+        id: state.prefabId,
+        name: state.prefabName,
+        root: denormalizeNode(state.rootId, state.nodesById, state.childIdsById),
+    };
+}
+export function collectSubtreeIds(id, childIdsById) {
+    var _a;
+    const ids = [id];
+    for (const childId of (_a = childIdsById[id]) !== null && _a !== void 0 ? _a : []) {
+        ids.push(...collectSubtreeIds(childId, childIdsById));
+    }
+    return ids;
+}
+export function insertSubtree(node, parentId, nodesById, childIdsById, parentIdById) {
+    var _a;
+    const { children } = node, nodeRecord = __rest(node, ["children"]);
+    nodesById[node.id] = nodeRecord;
+    childIdsById[node.id] = (_a = children === null || children === void 0 ? void 0 : children.map(child => child.id)) !== null && _a !== void 0 ? _a : [];
+    parentIdById[node.id] = parentId;
+    children === null || children === void 0 ? void 0 : children.forEach(child => insertSubtree(child, node.id, nodesById, childIdsById, parentIdById));
+}
+export function cloneSubtree(id, parentId, source, nodesById, childIdsById, parentIdById) {
+    var _a, _b;
+    const originalNode = source.nodesById[id];
+    if (!originalNode)
+        return null;
+    const clonedId = crypto.randomUUID();
+    const clonedNode = Object.assign(Object.assign({}, originalNode), { id: clonedId, name: `${(_a = originalNode.name) !== null && _a !== void 0 ? _a : originalNode.id} Copy` });
+    nodesById[clonedId] = clonedNode;
+    parentIdById[clonedId] = parentId;
+    const clonedChildIds = ((_b = source.childIdsById[id]) !== null && _b !== void 0 ? _b : [])
+        .map(childId => cloneSubtree(childId, clonedId, source, nodesById, childIdsById, parentIdById))
+        .filter((childId) => Boolean(childId));
+    childIdsById[clonedId] = clonedChildIds;
+    return clonedId;
+}
+export function isDescendant(id, potentialAncestorId, parentIdById) {
+    let currentId = id;
+    while (currentId) {
+        if (currentId === potentialAncestorId)
+            return true;
+        currentId = parentIdById[currentId];
+    }
+    return false;
+}
+export function updateAssetRefsForNodeChange(assetRefCounts, currentNode, nextNode) {
+    const currentRefs = getAssetRefs(currentNode);
+    const nextRefs = getAssetRefs(nextNode);
+    if (sameStringArrays(currentRefs, nextRefs)) {
+        return assetRefCounts;
+    }
+    const nextAssetRefCounts = Object.assign({}, assetRefCounts);
+    removeAssetRefs(nextAssetRefCounts, currentRefs);
+    addAssetRefs(nextAssetRefCounts, nextRefs);
+    return nextAssetRefCounts;
+}
+export function collectSubtreeAssetRefs(node) {
+    var _a;
+    const refs = getAssetRefs(node);
+    (_a = node.children) === null || _a === void 0 ? void 0 : _a.forEach(child => refs.push(...collectSubtreeAssetRefs(child)));
+    return refs;
+}
+export function collectAssetRefsForIds(ids, nodesById) {
+    return ids.reduce((refs, id) => {
+        refs.push(...getAssetRefs(nodesById[id]));
+        return refs;
+    }, []);
+}

package/dist/tools/prefabeditor/prefabStore.d.ts

@@ -1,20 +1,8 @@
 import { type ReactNode } from "react";
 import { type StoreApi } from "zustand/vanilla";
 import { GameObject, Prefab } from "./types";
-export type PrefabNodeRecord = Omit<GameObject, "children">;
-type PrefabAssetRefCounts = Record<string, number>;
-type PrefabDocumentSnapshot = {
-    prefabId?: string;
-    prefabName?: string;
-    rootId: string;
-    nodesById: Record<string, PrefabNodeRecord>;
-    childIdsById: Record<string, string[]>;
-    parentIdById: Record<string, string | null>;
-    revision: number;
-    assetManifestKey: string;
-    assetRefCounts: PrefabAssetRefCounts;
-};
-export interface PrefabStoreState extends PrefabDocumentSnapshot {
+import { denormalizePrefab, PrefabState, PrefabNodeRecord } from "./prefab";
+export interface PrefabStoreState extends PrefabState {
     replacePrefab: (prefab: Prefab) => void;
     updateNode: (id: string, update: (node: PrefabNodeRecord) => PrefabNodeRecord) => void;
     updateNodes: (updates: Array<{
@@ -33,10 +21,10 @@ export declare function PrefabStoreProvider({ store, children, }: {
     children: ReactNode;
 }): import("react").FunctionComponentElement<import("react").ProviderProps<PrefabStoreApi | null>>;
 export declare function usePrefabStoreApi(): PrefabStoreApi;
+export declare function useOptionalPrefabStoreApi(): PrefabStoreApi | null;
 export declare function usePrefabStore<T>(selector: (state: PrefabStoreState) => T): T;
 export declare function usePrefabRootId(): string;
 export declare function usePrefabNode(nodeId: string | null | undefined): PrefabNodeRecord | null;
 export declare function usePrefabChildIds(nodeId: string | null | undefined): string[];
 export declare function createPrefabStore(prefab: Prefab): PrefabStoreApi;
-export declare function prefabStoreToPrefab(state: Pick<PrefabDocumentSnapshot, "prefabId" | "prefabName" | "rootId" | "nodesById" | "childIdsById">): Prefab;
-export {};
+export declare const prefabStoreToPrefab: typeof denormalizePrefab;

package/dist/tools/prefabeditor/prefabStore.js

@@ -1,18 +1,8 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 import { createContext, createElement, useContext } from "react";
 import { subscribeWithSelector } from "zustand/middleware";
 import { useStore } from "zustand";
 import { createStore } from "zustand/vanilla";
+import { collectAssetRefsForIds, collectSubtreeAssetRefs, collectSubtreeIds, cloneSubtree, createPrefabPatch, denormalizePrefab, insertSubtree, isDescendant, normalizePrefab, updateAssetRefsForNodeChange, } from "./prefab";
 const PrefabStoreContext = createContext(null);
 const EMPTY_CHILD_IDS = [];
 export function PrefabStoreProvider({ store, children, }) {
@@ -25,6 +15,9 @@ export function usePrefabStoreApi() {
     }
     return store;
 }
+export function useOptionalPrefabStoreApi() {
+    return useContext(PrefabStoreContext);
+}
 export function usePrefabStore(selector) {
     return useStore(usePrefabStoreApi(), selector);
 }
@@ -38,8 +31,8 @@ export function usePrefabChildIds(nodeId) {
     return usePrefabStore(state => { var _a; return nodeId ? (_a = state.childIdsById[nodeId]) !== null && _a !== void 0 ? _a : EMPTY_CHILD_IDS : EMPTY_CHILD_IDS; });
 }
 export function createPrefabStore(prefab) {
-    return createStore()(subscribeWithSelector((set, get) => (Object.assign(Object.assign({}, createDocumentState(prefab)), { replacePrefab: (nextPrefab) => {
-            set(createDocumentState(nextPrefab, get().revision + 1));
+    return createStore()(subscribeWithSelector((set, get) => (Object.assign(Object.assign({}, normalizePrefab(prefab)), { replacePrefab: (nextPrefab) => {
+            set(normalizePrefab(nextPrefab, get().revision + 1));
         }, updateNode: (id, update) => {
             const state = get();
             const node = state.nodesById[id];
@@ -49,7 +42,7 @@ export function createPrefabStore(prefab) {
             if (nextNode === node)
                 return;
             const nextAssetRefCounts = updateAssetRefsForNodeChange(state.assetRefCounts, node, nextNode);
-            set(createMutationPatch(state, {
+            set(createPrefabPatch(state, {
                 nodesById: Object.assign(Object.assign({}, state.nodesById), { [id]: nextNode }),
             }, nextAssetRefCounts));
         }, updateNodes: (updates) => {
@@ -71,7 +64,7 @@ export function createPrefabStore(prefab) {
             }
             if (!nextNodesById)
                 return;
-            set(createMutationPatch(state, { nodesById: nextNodesById }, nextAssetRefCounts));
+            set(createPrefabPatch(state, { nodesById: nextNodesById }, nextAssetRefCounts));
         }, addChild: (parentId, node) => {
             var _a;
             const state = get();
@@ -83,8 +76,11 @@ export function createPrefabStore(prefab) {
             const nextAssetRefCounts = Object.assign({}, state.assetRefCounts);
             insertSubtree(node, parentId, nextNodesById, nextChildIdsById, nextParentIdById);
             nextChildIdsById[parentId] = [...((_a = nextChildIdsById[parentId]) !== null && _a !== void 0 ? _a : []), node.id];
-            addAssetRefs(nextAssetRefCounts, collectSubtreeAssetRefs(node));
-            set(createMutationPatch(state, {
+            collectSubtreeAssetRefs(node).forEach(ref => {
+                var _a;
+                nextAssetRefCounts[ref] = ((_a = nextAssetRefCounts[ref]) !== null && _a !== void 0 ? _a : 0) + 1;
+            });
+            set(createPrefabPatch(state, {
                 nodesById: nextNodesById,
                 childIdsById: nextChildIdsById,
                 parentIdById: nextParentIdById,
@@ -102,14 +98,22 @@ export function createPrefabStore(prefab) {
             const nextChildIdsById = Object.assign({}, state.childIdsById);
             const nextParentIdById = Object.assign({}, state.parentIdById);
             const nextAssetRefCounts = Object.assign({}, state.assetRefCounts);
-            removeAssetRefs(nextAssetRefCounts, collectAssetRefsForIds(idsToDelete, state.nodesById));
+            collectAssetRefsForIds(idsToDelete, state.nodesById).forEach(ref => {
+                var _a;
+                const nextCount = ((_a = nextAssetRefCounts[ref]) !== null && _a !== void 0 ? _a : 0) - 1;
+                if (nextCount > 0) {
+                    nextAssetRefCounts[ref] = nextCount;
+                    return;
+                }
+                delete nextAssetRefCounts[ref];
+            });
             idsToDelete.forEach(nodeId => {
                 delete nextNodesById[nodeId];
                 delete nextChildIdsById[nodeId];
                 delete nextParentIdById[nodeId];
             });
             nextChildIdsById[parentId] = ((_a = nextChildIdsById[parentId]) !== null && _a !== void 0 ? _a : []).filter(childId => childId !== id);
-            set(createMutationPatch(state, {
+            set(createPrefabPatch(state, {
                 nodesById: nextNodesById,
                 childIdsById: nextChildIdsById,
                 parentIdById: nextParentIdById,
@@ -125,7 +129,7 @@ export function createPrefabStore(prefab) {
             const nextNodesById = Object.assign({}, state.nodesById);
             const nextChildIdsById = Object.assign({}, state.childIdsById);
             const nextParentIdById = Object.assign({}, state.parentIdById);
-            const duplicatedRootId = cloneSubtreeIntoMaps(id, parentId, state, nextNodesById, nextChildIdsById, nextParentIdById);
+            const duplicatedRootId = cloneSubtree(id, parentId, state, nextNodesById, nextChildIdsById, nextParentIdById);
             if (!duplicatedRootId)
                 return null;
             const siblings = [...((_a = nextChildIdsById[parentId]) !== null && _a !== void 0 ? _a : [])];
@@ -138,8 +142,11 @@ export function createPrefabStore(prefab) {
             }
             nextChildIdsById[parentId] = siblings;
             const nextAssetRefCounts = Object.assign({}, state.assetRefCounts);
-            addAssetRefs(nextAssetRefCounts, collectAssetRefsForIds(collectSubtreeIds(id, state.childIdsById), state.nodesById));
-            set(createMutationPatch(state, {
+            collectAssetRefsForIds(collectSubtreeIds(id, state.childIdsById), state.nodesById).forEach(ref => {
+                var _a;
+                nextAssetRefCounts[ref] = ((_a = nextAssetRefCounts[ref]) !== null && _a !== void 0 ? _a : 0) + 1;
+            });
+            set(createPrefabPatch(state, {
                 nodesById: nextNodesById,
                 childIdsById: nextChildIdsById,
                 parentIdById: nextParentIdById,
@@ -151,7 +158,7 @@ export function createPrefabStore(prefab) {
             if (!node)
                 return;
             const nextNode = Object.assign(Object.assign({}, node), { [key]: !node[key] });
-            set(createMutationPatch(state, {
+            set(createPrefabPatch(state, {
                 nodesById: Object.assign(Object.assign({}, state.nodesById), { [id]: nextNode }),
             }));
         }, moveNode: (draggedId, targetId, position) => {
@@ -190,158 +197,10 @@ export function createPrefabStore(prefab) {
                 destinationChildren.splice(targetIndex, 0, draggedId);
                 nextChildIdsById[destinationParentId] = destinationChildren;
             }
-            set(createMutationPatch(state, {
+            set(createPrefabPatch(state, {
                 childIdsById: nextChildIdsById,
                 parentIdById: nextParentIdById,
             }));
         } }))));
 }
-export function prefabStoreToPrefab(state) {
-    return {
-        id: state.prefabId,
-        name: state.prefabName,
-        root: denormalizeNode(state.rootId, state.nodesById, state.childIdsById),
-    };
-}
-function createDocumentState(prefab, revision = 0) {
-    const nodesById = {};
-    const childIdsById = {};
-    const parentIdById = {};
-    insertSubtree(prefab.root, null, nodesById, childIdsById, parentIdById);
-    const assetRefCounts = createAssetRefCounts(nodesById);
-    return {
-        prefabId: prefab.id,
-        prefabName: prefab.name,
-        rootId: prefab.root.id,
-        nodesById,
-        childIdsById,
-        parentIdById,
-        revision,
-        assetManifestKey: getAssetManifestKey(assetRefCounts),
-        assetRefCounts,
-    };
-}
-function createMutationPatch(state, patch, nextAssetRefCounts = state.assetRefCounts) {
-    const assetRefsChanged = nextAssetRefCounts !== state.assetRefCounts;
-    return Object.assign(Object.assign(Object.assign({}, patch), { revision: state.revision + 1 }), (assetRefsChanged ? {
-        assetRefCounts: nextAssetRefCounts,
-        assetManifestKey: getAssetManifestKey(nextAssetRefCounts),
-    } : null));
-}
-function denormalizeNode(id, nodesById, childIdsById) {
-    var _a;
-    const node = nodesById[id];
-    return Object.assign(Object.assign({}, node), { children: ((_a = childIdsById[id]) !== null && _a !== void 0 ? _a : []).map(childId => denormalizeNode(childId, nodesById, childIdsById)) });
-}
-function collectSubtreeIds(id, childIdsById) {
-    var _a;
-    const ids = [id];
-    for (const childId of (_a = childIdsById[id]) !== null && _a !== void 0 ? _a : []) {
-        ids.push(...collectSubtreeIds(childId, childIdsById));
-    }
-    return ids;
-}
-function insertSubtree(node, parentId, nodesById, childIdsById, parentIdById) {
-    var _a;
-    const { children } = node, nodeRecord = __rest(node, ["children"]);
-    nodesById[node.id] = nodeRecord;
-    childIdsById[node.id] = (_a = children === null || children === void 0 ? void 0 : children.map(child => child.id)) !== null && _a !== void 0 ? _a : [];
-    parentIdById[node.id] = parentId;
-    children === null || children === void 0 ? void 0 : children.forEach(child => insertSubtree(child, node.id, nodesById, childIdsById, parentIdById));
-}
-function cloneSubtreeIntoMaps(id, parentId, source, nodesById, childIdsById, parentIdById) {
-    var _a, _b;
-    const originalNode = source.nodesById[id];
-    if (!originalNode)
-        return null;
-    const clonedId = crypto.randomUUID();
-    const clonedNode = Object.assign(Object.assign({}, originalNode), { id: clonedId, name: `${(_a = originalNode.name) !== null && _a !== void 0 ? _a : originalNode.id} Copy` });
-    nodesById[clonedId] = clonedNode;
-    parentIdById[clonedId] = parentId;
-    const clonedChildIds = ((_b = source.childIdsById[id]) !== null && _b !== void 0 ? _b : [])
-        .map(childId => cloneSubtreeIntoMaps(childId, clonedId, source, nodesById, childIdsById, parentIdById))
-        .filter((childId) => Boolean(childId));
-    childIdsById[clonedId] = clonedChildIds;
-    return clonedId;
-}
-function isDescendant(id, potentialAncestorId, parentIdById) {
-    let currentId = id;
-    while (currentId) {
-        if (currentId === potentialAncestorId)
-            return true;
-        currentId = parentIdById[currentId];
-    }
-    return false;
-}
-function createAssetRefCounts(nodesById) {
-    const assetRefCounts = {};
-    Object.values(nodesById).forEach(node => addAssetRefs(assetRefCounts, getAssetRefs(node)));
-    return assetRefCounts;
-}
-function updateAssetRefsForNodeChange(assetRefCounts, currentNode, nextNode) {
-    const currentRefs = getAssetRefs(currentNode);
-    const nextRefs = getAssetRefs(nextNode);
-    if (sameStringArrays(currentRefs, nextRefs)) {
-        return assetRefCounts;
-    }
-    const nextAssetRefCounts = Object.assign({}, assetRefCounts);
-    removeAssetRefs(nextAssetRefCounts, currentRefs);
-    addAssetRefs(nextAssetRefCounts, nextRefs);
-    return nextAssetRefCounts;
-}
-function collectSubtreeAssetRefs(node) {
-    var _a;
-    const refs = getAssetRefs(node);
-    (_a = node.children) === null || _a === void 0 ? void 0 : _a.forEach(child => refs.push(...collectSubtreeAssetRefs(child)));
-    return refs;
-}
-function collectAssetRefsForIds(ids, nodesById) {
-    return ids.flatMap(id => getAssetRefs(nodesById[id]));
-}
-function getAssetRefs(node) {
-    var _a;
-    const refs = [];
-    Object.values((_a = node === null || node === void 0 ? void 0 : node.components) !== null && _a !== void 0 ? _a : {}).forEach(component => {
-        var _a, _b, _c, _d;
-        if (!(component === null || component === void 0 ? void 0 : component.type))
-            return;
-        if (component.type === "Model" && ((_a = component.properties) === null || _a === void 0 ? void 0 : _a.filename)) {
-            refs.push(`model:${component.properties.filename}`);
-        }
-        if (component.type === "Material") {
-            if ((_b = component.properties) === null || _b === void 0 ? void 0 : _b.texture)
-                refs.push(`texture:${component.properties.texture}`);
-            if ((_c = component.properties) === null || _c === void 0 ? void 0 : _c.normalMapTexture)
-                refs.push(`texture:${component.properties.normalMapTexture}`);
-        }
-        if (component.type === "SpotLight" && ((_d = component.properties) === null || _d === void 0 ? void 0 : _d.map)) {
-            refs.push(`texture:${component.properties.map}`);
-        }
-    });
-    return refs.sort();
-}
-function addAssetRefs(assetRefCounts, refs) {
-    refs.forEach(ref => {
-        var _a;
-        assetRefCounts[ref] = ((_a = assetRefCounts[ref]) !== null && _a !== void 0 ? _a : 0) + 1;
-    });
-}
-function removeAssetRefs(assetRefCounts, refs) {
-    refs.forEach(ref => {
-        var _a;
-        const nextCount = ((_a = assetRefCounts[ref]) !== null && _a !== void 0 ? _a : 0) - 1;
-        if (nextCount > 0) {
-            assetRefCounts[ref] = nextCount;
-            return;
-        }
-        delete assetRefCounts[ref];
-    });
-}
-function getAssetManifestKey(assetRefCounts) {
-    return Object.keys(assetRefCounts).sort().join("|");
-}
-function sameStringArrays(left, right) {
-    if (left.length !== right.length)
-        return false;
-    return left.every((value, index) => value === right[index]);
-}
+export const prefabStoreToPrefab = denormalizePrefab;

package/dist/tools/prefabeditor/{sceneApi.d.ts → scene.d.ts}

@@ -15,16 +15,27 @@ export interface EntityComponent<TProperties = Record<string, any>> {
 }
 export interface Entity {
     readonly id: string;
+    readonly name: string | undefined;
+    readonly enabled: boolean;
+    readonly parent: Entity | null;
+    readonly children: Entity[];
     set: (data: EntityData) => void;
     update: (update: (node: EntityData) => EntityData) => void;
     getComponent: <TProperties = Record<string, any>>(name: string) => EntityComponent<TProperties> | null;
+    addComponent: (type: string, properties?: Record<string, any>) => EntityComponent | null;
+    removeComponent: (name: string) => void;
+    destroy: () => void;
 }
 export type EntityUpdate = (node: EntityData) => EntityData;
 export type SceneUpdates = Record<string, EntityUpdate>;
 export interface Scene {
     readonly rootId: string;
-    find: (id: string) => Entity | null;
+    find: (nameOrId: string) => Entity | null;
     get: (id: string) => Entity;
+    create: (name: string, components?: Record<string, {
+        type: string;
+        properties?: Record<string, any>;
+    }>, options?: SpawnOptions) => Entity;
     update: {
         (id: string, update: EntityUpdate): void;
         (updates: SceneUpdates): void;
@@ -35,6 +46,9 @@ export interface Scene {
 interface SceneAdapter {
     getRootId: () => string;
     getNode: (id: string) => EntityData | null;
+    getChildIds: (id: string) => string[];
+    getParentId: (id: string) => string | null;
+    findByName: (name: string) => string | null;
     updateNode: (id: string, update: (node: EntityData) => EntityData) => void;
     updateNodes: (updates: Record<string, (node: EntityData) => EntityData>) => void;
     addNode: (node: GameObject, options?: SpawnOptions) => string;