react-three-game 0.0.70 → 0.0.71

package/dist/tools/prefabeditor/components/SpotLightComponent.js

@@ -1,57 +1,81 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useRef, useEffect, useMemo, useState } from "react";
-import { BooleanField, ColorField, FieldGroup, Label, NumberField } from "./Input";
+import { useHelper } from "@react-three/drei";
+import { useRef, useEffect } from "react";
+import { BooleanField, ColorField, Label, NumberField, Vector3Input } from "./Input";
 import { SpotLightHelper } from "three";
+import { useSceneRuntime } from "../PrefabRoot";
 import { useFrame } from "@react-three/fiber";
 import { TexturePicker } from "../../assetviewer/page";
+import { LightSection, ShadowBiasField, mergeWithDefaults } from "./lightUtils";
 const spotLightDefaults = {
     color: '#ffffff',
-    intensity: 200,
-    angle: 0.5,
-    penumbra: 0.5,
-    distance: 100,
-    castShadow: true,
+    intensity: 1,
+    angle: Math.PI / 3,
+    penumbra: 0,
+    distance: 0,
+    decay: 2,
+    castShadow: false,
+    shadowMapSize: 512,
+    shadowBias: 0,
+    shadowNormalBias: 0,
+    shadowAutoUpdate: true,
+    shadowCameraNear: 0.5,
+    shadowCameraFar: 500,
+    targetOffset: [0, -5, 0],
+    map: undefined,
 };
 function SpotLightComponentEditor({ component, onUpdate, basePath = "" }) {
-    const values = Object.assign(Object.assign({}, spotLightDefaults), component.properties);
-    return (_jsxs(FieldGroup, { children: [_jsx(ColorField, { name: "color", label: "Color", values: values, onChange: onUpdate }), _jsx(NumberField, { name: "intensity", label: "Intensity", values: values, onChange: onUpdate, min: 0, step: 1, fallback: 200 }), _jsx(NumberField, { name: "angle", label: "Angle", values: values, onChange: onUpdate, min: 0, max: Math.PI, step: 0.05, fallback: 0.5 }), _jsx(NumberField, { name: "penumbra", label: "Penumbra", values: values, onChange: onUpdate, min: 0, max: 1, step: 0.05, fallback: 0.5 }), _jsx(NumberField, { name: "distance", label: "Distance", values: values, onChange: onUpdate, min: 0, step: 1, fallback: 100 }), _jsx(BooleanField, { name: "castShadow", label: "Cast Shadow", values: values, onChange: onUpdate, fallback: true }), _jsxs("div", { children: [_jsx(Label, { children: "Texture Map" }), _jsx(TexturePicker, { value: values.map, onChange: (map) => onUpdate({ map }), basePath: basePath })] })] }));
+    const values = mergeWithDefaults(spotLightDefaults, component.properties);
+    return (_jsxs("div", { style: { display: 'flex', flexDirection: 'column', gap: 8 }, children: [_jsxs(LightSection, { title: "Light", children: [_jsx(ColorField, { name: "color", label: "Color", values: values, onChange: onUpdate }), _jsx(NumberField, { name: "intensity", label: "Intensity", values: values, onChange: onUpdate, min: 0, step: 0.1, fallback: 1 }), _jsx(NumberField, { name: "angle", label: "Angle", values: values, onChange: onUpdate, min: 0, max: Math.PI / 2, step: 0.05, fallback: Math.PI / 3 }), _jsx(NumberField, { name: "penumbra", label: "Penumbra", values: values, onChange: onUpdate, min: 0, max: 1, step: 0.05, fallback: 0 }), _jsx(NumberField, { name: "distance", label: "Distance", values: values, onChange: onUpdate, min: 0, step: 1, fallback: 0 }), _jsx(NumberField, { name: "decay", label: "Decay", values: values, onChange: onUpdate, min: 0, step: 0.1, fallback: 2 }), _jsx(Vector3Input, { label: "Target Offset", value: values.targetOffset, onChange: targetOffset => onUpdate({ targetOffset }), snap: 0.5 }), _jsxs("div", { children: [_jsx(Label, { children: "Texture Map" }), _jsx(TexturePicker, { value: values.map, onChange: (map) => onUpdate({ map }), basePath: basePath })] })] }), _jsxs(LightSection, { title: "Shadow", children: [_jsx(BooleanField, { name: "castShadow", label: "Cast Shadow", values: values, onChange: onUpdate, fallback: false }), values.castShadow ? (_jsxs(_Fragment, { children: [_jsx(BooleanField, { name: "shadowAutoUpdate", label: "Auto Update", values: values, onChange: onUpdate, fallback: true }), _jsx(NumberField, { name: "shadowMapSize", label: "Map Size", values: values, onChange: onUpdate, min: 128, step: 128, fallback: 512 }), _jsx(ShadowBiasField, { name: "shadowBias", label: "Bias", values: values, onChange: onUpdate, fallback: 0 }), _jsx(ShadowBiasField, { name: "shadowNormalBias", label: "Normal Bias", values: values, onChange: onUpdate, fallback: 0 }), _jsx(NumberField, { name: "shadowCameraNear", label: "Near", values: values, onChange: onUpdate, min: 0.001, step: 0.1, fallback: 0.5 }), _jsx(NumberField, { name: "shadowCameraFar", label: "Far", values: values, onChange: onUpdate, min: 0.1, step: 1, fallback: 500 })] })) : null] })] }));
 }
-function SpotLightView({ properties, children, editMode, isSelected, loadedTextures }) {
-    const merged = Object.assign(Object.assign({}, spotLightDefaults), properties);
+function SpotLightView({ properties, children, editMode, isSelected }) {
+    var _a;
+    const { getTexture } = useSceneRuntime();
+    const merged = mergeWithDefaults(spotLightDefaults, properties);
     const color = merged.color;
     const intensity = merged.intensity;
     const angle = merged.angle;
     const penumbra = merged.penumbra;
     const distance = merged.distance;
+    const decay = merged.decay;
     const castShadow = merged.castShadow;
-    const textureMap = merged.map && loadedTextures ? loadedTextures[merged.map] : undefined;
+    const shadowMapSize = merged.shadowMapSize;
+    const shadowBias = merged.shadowBias;
+    const shadowNormalBias = merged.shadowNormalBias;
+    const shadowAutoUpdate = merged.shadowAutoUpdate;
+    const shadowCameraNear = merged.shadowCameraNear;
+    const shadowCameraFar = merged.shadowCameraFar;
+    const targetOffset = merged.targetOffset;
+    const textureMap = merged.map ? (_a = getTexture(merged.map)) !== null && _a !== void 0 ? _a : undefined : undefined;
     const spotLightRef = useRef(null);
     const targetRef = useRef(null);
-    const [spotLight, setSpotLight] = useState(null);
-    const spotLightHelper = useMemo(() => spotLight ? new SpotLightHelper(spotLight, color) : null, [spotLight, color]);
-    useEffect(() => {
-        return () => {
-            spotLightHelper === null || spotLightHelper === void 0 ? void 0 : spotLightHelper.dispose();
-        };
-    }, [spotLightHelper]);
+    useHelper(editMode && isSelected ? spotLightRef : null, SpotLightHelper, color);
     useEffect(() => {
         if (spotLightRef.current && targetRef.current) {
             spotLightRef.current.target = targetRef.current;
-            setSpotLight(spotLightRef.current);
         }
     }, []);
+    useEffect(() => {
+        var _a;
+        const shadow = (_a = spotLightRef.current) === null || _a === void 0 ? void 0 : _a.shadow;
+        if (!shadow)
+            return;
+        shadow.needsUpdate = true;
+        shadow.camera.updateProjectionMatrix();
+    }, [castShadow, shadowMapSize, shadowBias, shadowNormalBias, shadowAutoUpdate, shadowCameraNear, shadowCameraFar]);
     useFrame(() => {
-        if (spotLightHelper && editMode && isSelected) {
-            spotLightHelper.update();
+        var _a;
+        if ((_a = spotLightRef.current) === null || _a === void 0 ? void 0 : _a.target) {
+            spotLightRef.current.target.updateMatrixWorld();
         }
     });
-    return (_jsxs(_Fragment, { children: [_jsx("spotLight", { ref: spotLightRef, color: color, intensity: intensity, angle: angle, penumbra: penumbra, distance: distance, map: textureMap, castShadow: castShadow, "shadow-mapSize-width": 1024, "shadow-mapSize-height": 1024, "shadow-bias": -0.0001, "shadow-normalBias": 0.02 }), editMode && isSelected && spotLightHelper && (_jsx("primitive", { object: spotLightHelper })), _jsx("object3D", { ref: targetRef, position: [0, -5, 0] }), editMode && (_jsxs(_Fragment, { children: [_jsxs("mesh", { children: [_jsx("sphereGeometry", { args: [0.2, 8, 6] }), _jsx("meshBasicMaterial", { color: color, wireframe: true })] }), _jsxs("mesh", { position: [0, -5, 0], children: [_jsx("sphereGeometry", { args: [0.15, 8, 6] }), _jsx("meshBasicMaterial", { color: color, wireframe: true, opacity: 0.5, transparent: true })] })] })), children] }));
+    return (_jsxs(_Fragment, { children: [_jsx("spotLight", { ref: spotLightRef, color: color, intensity: intensity, angle: angle, penumbra: penumbra, distance: distance, decay: decay, map: textureMap, castShadow: castShadow, "shadow-mapSize-width": shadowMapSize, "shadow-mapSize-height": shadowMapSize, "shadow-bias": shadowBias, "shadow-normalBias": shadowNormalBias, "shadow-autoUpdate": shadowAutoUpdate, "shadow-camera-near": shadowCameraNear, "shadow-camera-far": shadowCameraFar }), _jsx("object3D", { ref: targetRef, position: targetOffset }), editMode && isSelected && (_jsxs(_Fragment, { children: [_jsxs("mesh", { children: [_jsx("sphereGeometry", { args: [0.2, 8, 6] }), _jsx("meshBasicMaterial", { color: color, wireframe: true })] }), _jsxs("mesh", { position: targetOffset, children: [_jsx("sphereGeometry", { args: [0.15, 8, 6] }), _jsx("meshBasicMaterial", { color: color, wireframe: true, opacity: 0.5, transparent: true })] })] })), children] }));
 }
 const SpotLightComponent = {
     name: 'SpotLight',
     Editor: SpotLightComponentEditor,
     View: SpotLightView,
-    defaultProperties: spotLightDefaults,
+    defaultProperties: {},
     getAssetRefs: (properties) => {
         if (properties.map)
             return [{ type: 'texture', path: properties.map }];

package/dist/tools/prefabeditor/components/index.js

@@ -3,6 +3,7 @@ import TransformComponent from './TransformComponent';
 import MaterialComponent from './MaterialComponent';
 import PhysicsComponent from './PhysicsComponent';
 import SpotLightComponent from './SpotLightComponent';
+import PointLightComponent from './PointLightComponent';
 import DirectionalLightComponent from './DirectionalLightComponent';
 import AmbientLightComponent from './AmbientLightComponent';
 import ModelComponent from './ModelComponent';
@@ -17,6 +18,7 @@ export default [
     MaterialComponent,
     PhysicsComponent,
     SpotLightComponent,
+    PointLightComponent,
     DirectionalLightComponent,
     AmbientLightComponent,
     ModelComponent,

package/dist/tools/prefabeditor/components/lightUtils.d.ts

@@ -0,0 +1,13 @@
+import { type ReactNode } from 'react';
+export declare function mergeWithDefaults<T extends Record<string, any>>(defaults: T, properties?: Record<string, any> | null): T;
+export declare function LightSection({ title, children }: {
+    title: string;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ShadowBiasField({ name, label, values, onChange, fallback, }: {
+    name: string;
+    label: string;
+    values: Record<string, any>;
+    onChange: (values: Record<string, any>) => void;
+    fallback?: number;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/tools/prefabeditor/components/lightUtils.js

@@ -0,0 +1,64 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { colors } from '../styles';
+import { FieldGroup, FieldRow, NumberInput } from './Input';
+export function mergeWithDefaults(defaults, properties) {
+    const merged = Object.assign({}, defaults);
+    if (!properties) {
+        return merged;
+    }
+    for (const [key, value] of Object.entries(properties)) {
+        if (value !== undefined) {
+            merged[key] = value;
+        }
+    }
+    return merged;
+}
+export function LightSection({ title, children }) {
+    return (_jsxs("div", { style: {
+            display: 'flex',
+            flexDirection: 'column',
+            gap: 8,
+            padding: '8px 10px',
+            border: `1px solid ${colors.border}`,
+            borderRadius: 6,
+            background: colors.bgSurface,
+        }, children: [_jsx("div", { style: {
+                    fontSize: 10,
+                    textTransform: 'uppercase',
+                    letterSpacing: '0.08em',
+                    color: colors.textMuted,
+                    fontWeight: 600,
+                }, children: title }), _jsx(FieldGroup, { children: children })] }));
+}
+const shadowBiasSteps = [0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001];
+function getBiasStep(value) {
+    var _a;
+    const absValue = Math.abs(value);
+    if (absValue === 0) {
+        return 0.001;
+    }
+    return (_a = shadowBiasSteps.find(step => absValue >= step)) !== null && _a !== void 0 ? _a : shadowBiasSteps[shadowBiasSteps.length - 1];
+}
+function formatBiasStep(step) {
+    return step.toLocaleString('en-US', {
+        minimumFractionDigits: 0,
+        maximumFractionDigits: 6,
+        useGrouping: false,
+    });
+}
+export function ShadowBiasField({ name, label, values, onChange, fallback = 0, }) {
+    var _a;
+    const value = (_a = values[name]) !== null && _a !== void 0 ? _a : fallback;
+    const [step, setStep] = useState(() => getBiasStep(value));
+    return (_jsx(FieldRow, { label: label, children: _jsxs("div", { style: { display: 'flex', alignItems: 'center', gap: 6 }, children: [_jsx(NumberInput, { value: value, onChange: nextValue => onChange({ [name]: nextValue }), step: step, min: -0.1, max: 0.1, style: { width: 92 } }), _jsx("select", { value: step.toString(), onChange: event => setStep(Number(event.target.value)), style: {
+                        width: 78,
+                        backgroundColor: colors.bgInput,
+                        border: `1px solid ${colors.border}`,
+                        color: colors.text,
+                        borderRadius: 3,
+                        fontSize: 11,
+                        padding: '3px 6px',
+                        fontFamily: 'monospace',
+                    }, title: "Bias scrub step", children: shadowBiasSteps.map(option => (_jsx("option", { value: option, children: formatBiasStep(option) }, option))) })] }) }));
+}

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

@@ -0,0 +1,37 @@
+import type { ComponentData, GameObject, Prefab } from './types';
+export type PrefabNodeRecord = Omit<GameObject, 'children'>;
+export type PrefabAssetRefCounts = Record<string, number>;
+export interface PrefabState {
+    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 declare function createDefaultComponentProperties(type: string): Record<string, any>;
+export declare function createComponentData(type: string, properties?: Record<string, any>): ComponentData;
+export declare function createNode(name: string, components?: Record<string, {
+    type: string;
+    properties?: Record<string, any>;
+}>, options?: {
+    id?: string;
+    children?: GameObject[];
+}): GameObject;
+export declare function createEmptyNode(name?: string): GameObject;
+export declare function createEmptyPrefab(): Prefab;
+export declare function createModelNode(filename: string, name?: string): GameObject;
+export declare function createImageNode(texturePath: string, name?: string): GameObject;
+export declare function normalizePrefab(prefab: Prefab, revision?: number): PrefabState;
+export declare function createPrefabPatch(state: PrefabState, patch: Partial<PrefabState>, nextAssetRefCounts?: PrefabAssetRefCounts): Partial<PrefabState>;
+export declare function denormalizePrefab(state: Pick<PrefabState, 'prefabId' | 'prefabName' | 'rootId' | 'nodesById' | 'childIdsById'>): Prefab;
+export declare function collectSubtreeIds(id: string, childIdsById: Record<string, string[]>): string[];
+export declare function insertSubtree(node: GameObject, parentId: string | null, nodesById: Record<string, PrefabNodeRecord>, childIdsById: Record<string, string[]>, parentIdById: Record<string, string | null>): void;
+export declare function cloneSubtree(id: string, parentId: string | null, source: Pick<PrefabState, 'nodesById' | 'childIdsById'>, nodesById: Record<string, PrefabNodeRecord>, childIdsById: Record<string, string[]>, parentIdById: Record<string, string | null>): string | null;
+export declare function isDescendant(id: string, potentialAncestorId: string, parentIdById: Record<string, string | null>): boolean;
+export declare function updateAssetRefsForNodeChange(assetRefCounts: PrefabAssetRefCounts, currentNode: PrefabNodeRecord, nextNode: PrefabNodeRecord): PrefabAssetRefCounts;
+export declare function collectSubtreeAssetRefs(node: GameObject): string[];
+export declare function collectAssetRefsForIds(ids: string[], nodesById: Record<string, PrefabNodeRecord>): string[];

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<{
@@ -39,5 +27,4 @@ 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;