react-three-game 0.0.67 → 0.0.69

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

@@ -0,0 +1,42 @@
+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 {
+    replacePrefab: (prefab: Prefab) => void;
+    updateNode: (id: string, update: (node: PrefabNodeRecord) => PrefabNodeRecord) => void;
+    updateNodes: (updates: Array<{
+        id: string;
+        update: (node: PrefabNodeRecord) => PrefabNodeRecord;
+    }>) => void;
+    addChild: (parentId: string, node: GameObject) => void;
+    deleteNode: (id: string) => void;
+    duplicateNode: (id: string) => string | null;
+    toggleNodeFlag: (id: string, key: "disabled" | "locked") => void;
+    moveNode: (draggedId: string, targetId: string, position: "before" | "inside") => void;
+}
+export type PrefabStoreApi = StoreApi<PrefabStoreState>;
+export declare function PrefabStoreProvider({ store, children, }: {
+    store: PrefabStoreApi;
+    children: ReactNode;
+}): import("react").FunctionComponentElement<import("react").ProviderProps<PrefabStoreApi | null>>;
+export declare function usePrefabStoreApi(): PrefabStoreApi;
+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 {};

package/dist/tools/prefabeditor/prefabStore.js

@@ -0,0 +1,347 @@
+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";
+const PrefabStoreContext = createContext(null);
+const EMPTY_CHILD_IDS = [];
+export function PrefabStoreProvider({ store, children, }) {
+    return createElement(PrefabStoreContext.Provider, { value: store }, children);
+}
+export function usePrefabStoreApi() {
+    const store = useContext(PrefabStoreContext);
+    if (!store) {
+        throw new Error("usePrefabStoreApi must be used within PrefabStoreProvider");
+    }
+    return store;
+}
+export function usePrefabStore(selector) {
+    return useStore(usePrefabStoreApi(), selector);
+}
+export function usePrefabRootId() {
+    return usePrefabStore(state => state.rootId);
+}
+export function usePrefabNode(nodeId) {
+    return usePrefabStore(state => { var _a; return nodeId ? (_a = state.nodesById[nodeId]) !== null && _a !== void 0 ? _a : null : null; });
+}
+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));
+        }, updateNode: (id, update) => {
+            const state = get();
+            const node = state.nodesById[id];
+            if (!node)
+                return;
+            const nextNode = update(node);
+            if (nextNode === node)
+                return;
+            const nextAssetRefCounts = updateAssetRefsForNodeChange(state.assetRefCounts, node, nextNode);
+            set(createMutationPatch(state, {
+                nodesById: Object.assign(Object.assign({}, state.nodesById), { [id]: nextNode }),
+            }, nextAssetRefCounts));
+        }, updateNodes: (updates) => {
+            if (updates.length === 0)
+                return;
+            const state = get();
+            let nextNodesById = null;
+            let nextAssetRefCounts = state.assetRefCounts;
+            for (const { id, update } of updates) {
+                const currentNode = (nextNodesById !== null && nextNodesById !== void 0 ? nextNodesById : state.nodesById)[id];
+                if (!currentNode)
+                    continue;
+                const nextNode = update(currentNode);
+                if (nextNode === currentNode)
+                    continue;
+                nextNodesById !== null && nextNodesById !== void 0 ? nextNodesById : (nextNodesById = Object.assign({}, state.nodesById));
+                nextNodesById[id] = nextNode;
+                nextAssetRefCounts = updateAssetRefsForNodeChange(nextAssetRefCounts, currentNode, nextNode);
+            }
+            if (!nextNodesById)
+                return;
+            set(createMutationPatch(state, { nodesById: nextNodesById }, nextAssetRefCounts));
+        }, addChild: (parentId, node) => {
+            var _a;
+            const state = get();
+            if (!state.nodesById[parentId])
+                return;
+            const nextNodesById = Object.assign({}, state.nodesById);
+            const nextChildIdsById = Object.assign({}, state.childIdsById);
+            const nextParentIdById = Object.assign({}, state.parentIdById);
+            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, {
+                nodesById: nextNodesById,
+                childIdsById: nextChildIdsById,
+                parentIdById: nextParentIdById,
+            }, nextAssetRefCounts));
+        }, deleteNode: (id) => {
+            var _a;
+            const state = get();
+            if (id === state.rootId || !state.nodesById[id])
+                return;
+            const parentId = state.parentIdById[id];
+            if (!parentId)
+                return;
+            const idsToDelete = collectSubtreeIds(id, state.childIdsById);
+            const nextNodesById = Object.assign({}, state.nodesById);
+            const nextChildIdsById = Object.assign({}, state.childIdsById);
+            const nextParentIdById = Object.assign({}, state.parentIdById);
+            const nextAssetRefCounts = Object.assign({}, state.assetRefCounts);
+            removeAssetRefs(nextAssetRefCounts, collectAssetRefsForIds(idsToDelete, state.nodesById));
+            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, {
+                nodesById: nextNodesById,
+                childIdsById: nextChildIdsById,
+                parentIdById: nextParentIdById,
+            }, nextAssetRefCounts));
+        }, duplicateNode: (id) => {
+            var _a;
+            const state = get();
+            if (id === state.rootId || !state.nodesById[id])
+                return null;
+            const parentId = state.parentIdById[id];
+            if (!parentId)
+                return null;
+            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);
+            if (!duplicatedRootId)
+                return null;
+            const siblings = [...((_a = nextChildIdsById[parentId]) !== null && _a !== void 0 ? _a : [])];
+            const currentIndex = siblings.findIndex(childId => childId === id);
+            if (currentIndex === -1) {
+                siblings.push(duplicatedRootId);
+            }
+            else {
+                siblings.splice(currentIndex + 1, 0, duplicatedRootId);
+            }
+            nextChildIdsById[parentId] = siblings;
+            const nextAssetRefCounts = Object.assign({}, state.assetRefCounts);
+            addAssetRefs(nextAssetRefCounts, collectAssetRefsForIds(collectSubtreeIds(id, state.childIdsById), state.nodesById));
+            set(createMutationPatch(state, {
+                nodesById: nextNodesById,
+                childIdsById: nextChildIdsById,
+                parentIdById: nextParentIdById,
+            }, nextAssetRefCounts));
+            return duplicatedRootId;
+        }, toggleNodeFlag: (id, key) => {
+            const state = get();
+            const node = state.nodesById[id];
+            if (!node)
+                return;
+            const nextNode = Object.assign(Object.assign({}, node), { [key]: !node[key] });
+            set(createMutationPatch(state, {
+                nodesById: Object.assign(Object.assign({}, state.nodesById), { [id]: nextNode }),
+            }));
+        }, moveNode: (draggedId, targetId, position) => {
+            var _a, _b, _c;
+            const state = get();
+            if (draggedId === state.rootId || draggedId === targetId)
+                return;
+            if (!state.nodesById[draggedId] || !state.nodesById[targetId])
+                return;
+            if (isDescendant(targetId, draggedId, state.parentIdById))
+                return;
+            const currentParentId = state.parentIdById[draggedId];
+            if (!currentParentId)
+                return;
+            const destinationParentId = position === "inside"
+                ? targetId
+                : state.parentIdById[targetId];
+            if (!destinationParentId)
+                return;
+            if (destinationParentId === draggedId || isDescendant(destinationParentId, draggedId, state.parentIdById))
+                return;
+            const nextChildIdsById = Object.assign({}, state.childIdsById);
+            const nextParentIdById = Object.assign(Object.assign({}, state.parentIdById), { [draggedId]: destinationParentId });
+            const sourceChildren = [...((_a = nextChildIdsById[currentParentId]) !== null && _a !== void 0 ? _a : [])].filter(childId => childId !== draggedId);
+            nextChildIdsById[currentParentId] = sourceChildren;
+            if (position === "inside") {
+                nextChildIdsById[destinationParentId] = [...((_b = nextChildIdsById[destinationParentId]) !== null && _b !== void 0 ? _b : []), draggedId];
+            }
+            else {
+                const destinationChildren = destinationParentId === currentParentId
+                    ? [...sourceChildren]
+                    : [...((_c = nextChildIdsById[destinationParentId]) !== null && _c !== void 0 ? _c : [])];
+                const targetIndex = destinationChildren.findIndex(childId => childId === targetId);
+                if (targetIndex === -1)
+                    return;
+                destinationChildren.splice(targetIndex, 0, draggedId);
+                nextChildIdsById[destinationParentId] = destinationChildren;
+            }
+            set(createMutationPatch(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]);
+}

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

@@ -0,0 +1,44 @@
+import type { GameObject } from "./types";
+export interface SpawnOptions {
+    name?: string;
+    parentId?: string;
+    select?: boolean;
+}
+export type EntityData = Omit<GameObject, "children">;
+export type PropertyPath = string | Array<string | number>;
+export interface EntityComponent<TProperties = Record<string, any>> {
+    readonly key: string;
+    readonly type: string;
+    get: <TValue = unknown>(path?: PropertyPath) => TValue | undefined;
+    set: (path: PropertyPath, value: unknown) => void;
+    update: (update: (properties: TProperties) => TProperties) => void;
+}
+export interface Entity {
+    readonly id: string;
+    set: (data: EntityData) => void;
+    update: (update: (node: EntityData) => EntityData) => void;
+    getComponent: <TProperties = Record<string, any>>(name: string) => EntityComponent<TProperties> | null;
+}
+export type EntityUpdate = (node: EntityData) => EntityData;
+export type SceneUpdates = Record<string, EntityUpdate>;
+export interface Scene {
+    readonly rootId: string;
+    find: (id: string) => Entity | null;
+    get: (id: string) => Entity;
+    update: {
+        (id: string, update: EntityUpdate): void;
+        (updates: SceneUpdates): void;
+    };
+    add: (node: GameObject, options?: SpawnOptions) => Entity;
+    remove: (id: string) => void;
+}
+interface SceneAdapter {
+    getRootId: () => string;
+    getNode: (id: string) => EntityData | null;
+    updateNode: (id: string, update: (node: EntityData) => EntityData) => void;
+    updateNodes: (updates: Record<string, (node: EntityData) => EntityData>) => void;
+    addNode: (node: GameObject, options?: SpawnOptions) => string;
+    removeNode: (id: string) => void;
+}
+export declare function createScene(adapter: SceneAdapter): Scene;
+export {};

package/dist/tools/prefabeditor/sceneApi.js

@@ -0,0 +1,161 @@
+function missingNode(id) {
+    throw new Error(`Scene node not found: ${id}`);
+}
+function normalizePath(path) {
+    if (path === undefined) {
+        return [];
+    }
+    if (Array.isArray(path)) {
+        return path;
+    }
+    return path.split(".").filter(Boolean);
+}
+function getValueAtPath(value, path) {
+    const segments = normalizePath(path);
+    let current = value;
+    for (const segment of segments) {
+        if (current == null || typeof current !== "object") {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+function setValueAtPath(value, path, nextValue) {
+    const segments = normalizePath(path);
+    if (segments.length === 0) {
+        return nextValue;
+    }
+    const cloneBranch = (current, index) => {
+        const segment = segments[index];
+        const source = current == null ? undefined : current;
+        const container = Array.isArray(source)
+            ? [...source]
+            : source && typeof source === "object"
+                ? Object.assign({}, source) : typeof segment === "number"
+                ? []
+                : {};
+        if (index === segments.length - 1) {
+            container[segment] = nextValue;
+            return container;
+        }
+        const child = source && typeof source === "object"
+            ? source[segment]
+            : undefined;
+        container[segment] = cloneBranch(child, index + 1);
+        return container;
+    };
+    return cloneBranch(value, 0);
+}
+function findComponentEntry(node, name) {
+    if (!node.components) {
+        return null;
+    }
+    const direct = node.components[name];
+    if (direct) {
+        return [name, direct];
+    }
+    const normalizedName = name.toLowerCase();
+    for (const [key, component] of Object.entries(node.components)) {
+        if (!component) {
+            continue;
+        }
+        if (key.toLowerCase() === normalizedName || component.type.toLowerCase() === normalizedName) {
+            return [key, component];
+        }
+    }
+    return null;
+}
+export function createScene(adapter) {
+    const findNode = (id) => adapter.getNode(id) ? createNode(id) : null;
+    const getNode = (id) => { var _a; return (_a = findNode(id)) !== null && _a !== void 0 ? _a : missingNode(id); };
+    function createComponent(entityId, componentKey, componentType) {
+        return {
+            key: componentKey,
+            type: componentType,
+            get(path) {
+                var _a;
+                const node = adapter.getNode(entityId);
+                const component = (_a = node === null || node === void 0 ? void 0 : node.components) === null || _a === void 0 ? void 0 : _a[componentKey];
+                if (!component) {
+                    return undefined;
+                }
+                return getValueAtPath(component.properties, path);
+            },
+            set(path, value) {
+                adapter.updateNode(entityId, node => {
+                    var _a;
+                    const component = (_a = node.components) === null || _a === void 0 ? void 0 : _a[componentKey];
+                    if (!component) {
+                        return node;
+                    }
+                    return Object.assign(Object.assign({}, node), { components: Object.assign(Object.assign({}, node.components), { [componentKey]: Object.assign(Object.assign({}, component), { properties: setValueAtPath(component.properties, path, value) }) }) });
+                });
+            },
+            update(update) {
+                adapter.updateNode(entityId, node => {
+                    var _a;
+                    const component = (_a = node.components) === null || _a === void 0 ? void 0 : _a[componentKey];
+                    if (!component) {
+                        return node;
+                    }
+                    const nextProperties = update(component.properties);
+                    if (nextProperties === component.properties) {
+                        return node;
+                    }
+                    return Object.assign(Object.assign({}, node), { components: Object.assign(Object.assign({}, node.components), { [componentKey]: Object.assign(Object.assign({}, component), { properties: nextProperties }) }) });
+                });
+            },
+        };
+    }
+    function createNode(id) {
+        return {
+            id,
+            set(data) {
+                adapter.updateNode(id, () => data);
+            },
+            update(update) {
+                adapter.updateNode(id, update);
+            },
+            getComponent(name) {
+                const node = adapter.getNode(id);
+                if (!node) {
+                    return null;
+                }
+                const entry = findComponentEntry(node, name);
+                if (!entry) {
+                    return null;
+                }
+                const [componentKey, component] = entry;
+                return createComponent(id, componentKey, component.type);
+            },
+        };
+    }
+    function update(idOrUpdates, mutate) {
+        if (typeof idOrUpdates === "string") {
+            if (!mutate) {
+                return;
+            }
+            adapter.updateNode(idOrUpdates, mutate);
+            return;
+        }
+        if (Object.keys(idOrUpdates).length === 0) {
+            return;
+        }
+        adapter.updateNodes(idOrUpdates);
+    }
+    return {
+        get rootId() {
+            return adapter.getRootId();
+        },
+        find: findNode,
+        get: getNode,
+        update,
+        add(node, options) {
+            return createNode(adapter.addNode(node, options));
+        },
+        remove(id) {
+            adapter.removeNode(id);
+        },
+    };
+}

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

@@ -897,6 +897,8 @@ export declare const inspector: {
         maxHeight: string;
         overflowY: "auto";
         overflowX: "hidden";
+        scrollbarWidth: "thin";
+        scrollbarColor: string;
         boxSizing: "border-box";
         display: string;
         flexDirection: "column";
@@ -1813,7 +1815,6 @@ export declare const toolbar: {
         cursor: string;
     };
 };
-export declare const scrollbarCSS: string;
 export declare const componentCard: {
     container: React.CSSProperties;
 };

package/dist/tools/prefabeditor/styles.js

@@ -98,6 +98,8 @@ export const inspector = {
         maxHeight: '80vh',
         overflowY: 'auto',
         overflowX: 'hidden',
+        scrollbarWidth: 'thin',
+        scrollbarColor: `${colors.bgLight} transparent`,
         boxSizing: 'border-box',
         display: 'flex',
         flexDirection: 'column',
@@ -182,18 +184,6 @@ export const toolbar = {
         cursor: 'not-allowed',
     },
 };
-// Shared scrollbar CSS (inject via <style> tag since CSS can't be bundled)
-export const scrollbarCSS = `
-.prefab-scroll::-webkit-scrollbar,
-.tree-scroll::-webkit-scrollbar { width: 6px; height: 6px; }
-.prefab-scroll::-webkit-scrollbar-track,
-.tree-scroll::-webkit-scrollbar-track { background: transparent; }
-.prefab-scroll::-webkit-scrollbar-thumb,
-.tree-scroll::-webkit-scrollbar-thumb { background: ${colors.border}; border-radius: 3px; }
-.prefab-scroll::-webkit-scrollbar-thumb:hover,
-.tree-scroll::-webkit-scrollbar-thumb:hover { background: #555; }
-.prefab-scroll { scrollbar-width: thin; scrollbar-color: ${colors.border} transparent; }
-`;
 // Reusable component card style for inspector sections
 export const componentCard = {
     container: {