react-three-game 0.0.85 → 0.0.87

package/README.md

@@ -2,7 +2,7 @@
 
 ![Scene Editor](assets/editor.gif)
 
-JSON-first 3D game engine for React Three Fiber.
+JSON-first scene mounting and authoring for React Three Fiber.
 
 Built on top of [three.js](https://github.com/mrdoob/three.js), [@react-three/fiber](https://github.com/pmndrs/react-three-fiber), and [@react-three/rapier](https://github.com/pmndrs/react-three-rapier).
 
@@ -10,7 +10,7 @@ Built on top of [three.js](https://github.com/mrdoob/three.js), [@react-three/fi
 * **🎬 Scene Editor** - Edit prefabs visually with hierarchy, inspector, transform gizmos, and play mode.
 * **⚛️ Physics** - Author rigid bodies directly in prefab data and run them through Rapier.
 * **🧩 Components** - Build scenes from reusable `GameObject` + component composition.
-* **🔧 Runtime Scene API** - Mutate the live world through `Scene`, `Entity`, and `EntityComponent` handles.
+* **🔧 Direct Runtime Access** - Get native `Object3D`, Rapier rigid body, and prefab store access without a parallel engine API.
 * **⚡ R3F Native** - Use normal React Three Fiber components whenever runtime behavior is clearer in code.
 
 ## Documentation
@@ -98,12 +98,10 @@ Open the hosted editor here:
 
 * https://prnth.com/react-three-game/editor
 
-## Prefabs And Scenes
+## Prefabs And Mounted Scenes
 
 `Prefab` is the serializable pure data format.
 
-`Scene` is the live runtime/editor world handle.
-
 That means a saved scene is just a prefab, and the same prefab can be:
 
 * edited directly in `PrefabEditor`
@@ -163,7 +161,7 @@ interface GameObject {
 
 ## Runtime Mutation
 
-Use the `Scene` API from `PrefabEditorRef` for authored state changes that should stay in prefab data.
+Use native object access for Three.js behavior and the prefab store for authored data changes.
 
 ```tsx
 import { useEffect, useRef } from "react";
@@ -173,48 +171,105 @@ function RaiseBall() {
   const editorRef = useRef<PrefabEditorRef>(null);
 
   useEffect(() => {
-    const transform = editorRef.current
-      ?.scene
-      .find("ball")
-      ?.getComponent<{ position: [number, number, number] }>("Transform");
-
-    transform?.set("position", [0, 8, 0]);
+    editorRef.current?.store.getState().updateNode("ball", (node) => ({
+      ...node,
+      components: {
+        ...node.components,
+        transform: {
+          type: "Transform",
+          properties: {
+            ...node.components?.transform?.properties,
+            position: [0, 8, 0],
+          },
+        },
+      },
+    }));
   }, []);
 
   return <PrefabEditor ref={editorRef} initialPrefab={prefab} />;
 }
 ```
 
-Batch related entity changes so they flush as one store revision:
+For live Three.js access, use mounted objects directly:
 
 ```tsx
-scene.batch(() => {
-  scene.find("orb1")?.getComponent("Transform")?.set("position", [1, 0, 0]);
-  scene.find("orb2")?.getComponent("Transform")?.set("position", [-1, 0, 0]);
-});
+const ball = editorRef.current?.getObject("ball");
+ball?.rotateY(0.5);
 ```
 
-Define a component runtime factory with `create(ctx)` for hot runtime behavior that mutates the live Three.js object directly:
+Mounted node metadata is mirrored onto the canonical Three.js wrapper object:
+
+* `GameObject.id` -> `object.userData.prefabNodeId`
+* `GameObject.name` -> `object.name` and `object.userData.prefabNodeName`
+* `Data.properties.data` -> merged into `object.userData`
+
+That gives you a stable authored id for traversal-based integrations, while still making Three.js name lookup convenient:
 
 ```tsx
-import type { Component } from "react-three-game";
-
-const Rotator: Component = {
-  name: "Rotator",
-  Editor: () => null,
-  defaultProperties: { speed: 1 },
-  create(ctx) {
-    return {
-      update(dt) {
-        const speed = ctx.component.get<number>("speed") ?? 1;
-        ctx.object.rotation.y += dt * speed;
+const playerByName = editorRef.current?.root?.getObjectByName("Player");
+const playerById = editorRef.current?.root?.getObjectByProperty("userData.prefabNodeId", "player");
+```
+
+Treat names as a convenience surface, not the primary lookup key:
+
+* names are not guaranteed unique
+* `getObject(id)` is still the stable authored-node lookup
+* traversal metadata is applied to the prefab node transform object, not necessarily the inner mesh or model child
+
+You can author extra `userData` from the editor with a `Data` component:
+
+```json
+{
+  "data": {
+    "faction": "enemy",
+    "health": 100,
+    "loot": { "table": "crate" }
+  }
+}
+```
+
+For batched authored updates, write through the store once:
+
+```tsx
+editorRef.current?.store.getState().updateNodes([
+  {
+    id: "orb1",
+    update: (node) => ({
+      ...node,
+      components: {
+        ...node.components,
+        transform: {
+          ...node.components?.transform,
+          type: "Transform",
+          properties: {
+            ...node.components?.transform?.properties,
+            position: [1, 0, 0],
+          },
+        },
       },
-    };
+    }),
   },
-};
+  {
+    id: "orb2",
+    update: (node) => ({
+      ...node,
+      components: {
+        ...node.components,
+        transform: {
+          ...node.components?.transform,
+          type: "Transform",
+          properties: {
+            ...node.components?.transform?.properties,
+            position: [-1, 0, 0],
+          },
+        },
+      },
+    }),
+  },
+]);
 ```
 
-`View` handles composition and rendering. `create(ctx)` handles imperative runtime behavior.
+Custom component `View`s should use normal React and R3F behavior, such as `useFrame`, refs, and native Three.js APIs.
 
 ## Useful Exports
 
@@ -224,9 +279,6 @@ const Rotator: Component = {
 * `PrefabEditorMode`
 * `Prefab`
 * `GameObject`
-* `Scene`
-* `Entity`
-* `EntityComponent`
 * `registerComponent`
 * `createPrefabStore`
 * `usePrefabStoreApi`

package/dist/index.d.ts

@@ -10,19 +10,19 @@ export { useEditorContext } from './tools/prefabeditor/PrefabEditor';
 export type { EditorContextType } from './tools/prefabeditor/PrefabEditor';
 export { createPrefabStore, prefabStoreToPrefab, usePrefabStoreApi } from './tools/prefabeditor/prefabStore';
 export type { PrefabStoreApi, PrefabStoreState } from './tools/prefabeditor/prefabStore';
-export { createScene } from './tools/prefabeditor/scene';
 export { denormalizePrefab } from './tools/prefabeditor/prefab';
+export { gameEvents, getEntityIdFromRigidBody, useClickEvent, useGameEvent, usePhysicsEvent } from './tools/prefabeditor/GameEvents';
+export type { ClickEventPayload, GameEventHandler, GameEventMap, PhysicsEventPayload } from './tools/prefabeditor/GameEvents';
 export { registerComponent } from './tools/prefabeditor/components/ComponentRegistry';
 export { FieldRenderer, FieldGroup, ListEditor, Label, Vector3Input, Vector3Field, NumberField, ColorInput, ColorField, StringInput, StringField, BooleanInput, BooleanField, SelectInput, SelectField, } from './tools/prefabeditor/components/Input';
 export { loadJson, saveJson, exportGLB, exportGLBData, regenerateIds, computeParentWorldMatrix, } from './tools/prefabeditor/utils';
 export type { ExportGLBOptions } from './tools/prefabeditor/utils';
 export { createModelNode, createImageNode, } from './tools/prefabeditor/prefab';
 export type { PrefabEditorProps, PrefabEditorRef, } from './tools/prefabeditor/PrefabEditor';
-export type { SpawnOptions, Scene, Entity, EntityComponent, EntityData, EntityUpdate, PropertyPath, SceneUpdates, } from './tools/prefabeditor/scene';
+export type { Entity, EntityComponent, EntityData, EntityUpdate, PropertyPath, Scene, SceneUpdates, SpawnOptions, } from './tools/prefabeditor/scene';
 export type { PrefabRootProps } from './tools/prefabeditor/PrefabRoot';
-export type { AssetRuntime, EntityRuntime, LiveObjectRef, LiveRigidBodyRef } from './tools/prefabeditor/runtime';
-export { useAssetRuntime, useEntityRuntime, useEntityObjectRef, useEntityRigidBodyRef } from './tools/prefabeditor/runtime';
-export type { ComponentInstance, ComponentRuntimeContext } from './tools/prefabeditor/runtime';
+export type { AssetRuntime, EntityRuntime, LiveObjectRef, LiveRigidBodyRef } from './tools/prefabeditor/assetRuntime';
+export { useAssetRuntime, useEntityRuntime, useEntityObjectRef, useEntityRigidBodyRef } from './tools/prefabeditor/assetRuntime';
 export type { Component, ComponentViewProps } from './tools/prefabeditor/components/ComponentRegistry';
 export type { FieldDefinition, FieldType } from './tools/prefabeditor/components/Input';
 export { MaterialOverridesProvider, useMaterialOverrides } from './tools/prefabeditor/components/MaterialComponent';
@@ -30,8 +30,6 @@ export type { MaterialOverrides } from './tools/prefabeditor/components/Material
 export type { Prefab, GameObject, ComponentData } from './tools/prefabeditor/types';
 export { findComponent, findComponentEntry, hasComponent } from './tools/prefabeditor/types';
 export { float, positionLocal, sin, time, uniform, vec3, } from 'three/tsl';
-export { gameEvents, useGameEvent, usePhysicsEvent, useClickEvent, getEntityIdFromRigidBody } from './tools/prefabeditor/GameEvents';
-export type { GameEventType, GameEventMap, GameEventPayload, PhysicsEventType, InteractionEventType, PhysicsEventPayload, ClickEventPayload } from './tools/prefabeditor/GameEvents';
 export { loadFiles } from './tools/dragdrop/DragDropLoader';
 export type { AssetLoadOptions } from './tools/dragdrop/DragDropLoader';
 export { loadModel, loadSound, loadTexture } from './tools/dragdrop/modelLoader';

package/dist/index.js

@@ -10,8 +10,8 @@ export { default as PrefabRoot } from './tools/prefabeditor/PrefabRoot';
 export { useEditorContext } from './tools/prefabeditor/PrefabEditor';
 // Prefab Editor - Store & Scene API
 export { createPrefabStore, prefabStoreToPrefab, usePrefabStoreApi } from './tools/prefabeditor/prefabStore';
-export { createScene } from './tools/prefabeditor/scene';
 export { denormalizePrefab } from './tools/prefabeditor/prefab';
+export { gameEvents, getEntityIdFromRigidBody, useClickEvent, useGameEvent, usePhysicsEvent } from './tools/prefabeditor/GameEvents';
 // Prefab Editor - Component Registry
 export { registerComponent } from './tools/prefabeditor/components/ComponentRegistry';
 // Prefab Editor - Input Components
@@ -19,12 +19,10 @@ export { FieldRenderer, FieldGroup, ListEditor, Label, Vector3Input, Vector3Fiel
 // Prefab Editor - Utils
 export { loadJson, saveJson, exportGLB, exportGLBData, regenerateIds, computeParentWorldMatrix, } from './tools/prefabeditor/utils';
 export { createModelNode, createImageNode, } from './tools/prefabeditor/prefab';
-export { useAssetRuntime, useEntityRuntime, useEntityObjectRef, useEntityRigidBodyRef } from './tools/prefabeditor/runtime';
+export { useAssetRuntime, useEntityRuntime, useEntityObjectRef, useEntityRigidBodyRef } from './tools/prefabeditor/assetRuntime';
 export { MaterialOverridesProvider, useMaterialOverrides } from './tools/prefabeditor/components/MaterialComponent';
 export { findComponent, findComponentEntry, hasComponent } from './tools/prefabeditor/types';
 export { float, positionLocal, sin, time, uniform, vec3, } from 'three/tsl';
-// Game Events (physics + custom events)
-export { gameEvents, useGameEvent, usePhysicsEvent, useClickEvent, getEntityIdFromRigidBody } from './tools/prefabeditor/GameEvents';
 // Asset Loading
 export { loadFiles } from './tools/dragdrop/DragDropLoader';
 export { loadModel, loadSound, loadTexture } from './tools/dragdrop/modelLoader';

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

@@ -1,128 +1,47 @@
-import type { RapierRigidBody } from '@react-three/rapier';
-/** Physics event types (built-in) */
-export type PhysicsEventType = 'sensor:enter' | 'sensor:exit' | 'collision:enter' | 'collision:exit';
-export type InteractionEventType = 'click';
-/** Payload for physics events */
-export interface PhysicsEventPayload {
-    sourceEntityId: string;
-    targetEntityId: string | null;
-    targetRigidBody: RapierRigidBody | null | undefined;
-}
-export interface ClickEventPayload {
-    sourceEntityId: string;
+export type GameEventHandler<TPayload = unknown> = (payload: TPayload) => void;
+export type PhysicsEventPayload = {
+    sourceEntityId?: string;
+    sourceNodeId?: string;
+    sourceObject?: unknown;
+    sourceRigidBody?: unknown;
+    targetEntityId?: string | null;
+    targetNodeId?: string | null;
+    targetObject?: unknown;
+    targetRigidBody?: unknown;
+    rapierEvent?: unknown;
+};
+export type ClickEventPayload = {
+    sourceEntityId?: string;
+    sourceNodeId?: string;
     instanceEntityId?: string;
-    point: [number, number, number];
-    button: number;
-    altKey: boolean;
-    ctrlKey: boolean;
-    metaKey: boolean;
-    shiftKey: boolean;
-}
-/**
- * Register your custom event types here by extending this interface:
- *
- * declare module 'react-three-game' {
- *   interface GameEventMap {
- *     'player:death': { playerId: string; cause: string };
- *     'score:change': { delta: number; total: number };
- *   }
- * }
- */
+    nodeId?: string;
+    node?: unknown;
+    object?: unknown;
+    point?: [number, number, number];
+    button?: number;
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+    r3fEvent?: unknown;
+};
 export interface GameEventMap {
     'sensor:enter': PhysicsEventPayload;
     'sensor:exit': PhysicsEventPayload;
     'collision:enter': PhysicsEventPayload;
     'collision:exit': PhysicsEventPayload;
-    'click': ClickEventPayload;
+    click: ClickEventPayload;
+    [eventType: string]: unknown;
 }
-/** All registered event types */
-export type GameEventType = keyof GameEventMap | (string & {});
-/** Get payload type for an event, or fallback to generic */
-export type GameEventPayload<T extends string> = T extends keyof GameEventMap ? GameEventMap[T] : Record<string, unknown>;
-type EventHandler<T = unknown> = (payload: T) => void;
-type UnknownEventPayload = Record<string, unknown>;
-declare function emitGameEvent<TType extends keyof GameEventMap>(type: TType, payload: GameEventMap[TType]): void;
-declare function emitGameEvent(type: string, payload: UnknownEventPayload): void;
-declare function onGameEvent<TType extends keyof GameEventMap>(type: TType, handler: EventHandler<GameEventMap[TType]>): () => void;
-declare function onGameEvent(type: string, handler: EventHandler<UnknownEventPayload>): () => void;
-declare function offGameEvent<TType extends keyof GameEventMap>(type: TType, handler: EventHandler<GameEventMap[TType]>): void;
-declare function offGameEvent(type: string, handler: EventHandler<UnknownEventPayload>): void;
-/**
- * Game event system for all game interactions.
- *
- * Built-in events:
- * - sensor:enter - Something entered a sensor collider
- * - sensor:exit - Something exited a sensor collider
- * - collision:enter - A collision started
- * - collision:exit - A collision ended
- * - click - A prefab entity with a Click component was clicked in play mode
- *
- * Custom events:
- * - Emit any event type with any payload
- * - Extend GameEventMap interface for type safety
- *
- * @example
- * // Physics events (typed)
- * gameEvents.emit('sensor:enter', { sourceEntityId: 'zone', targetEntityId: 'player', targetRigidBody: rb });
- *
- * // Custom events
- * gameEvents.emit('player:death', { playerId: 'p1', cause: 'lava' });
- * gameEvents.emit('level:complete', { levelId: 3, time: 45.2 });
- */
 export declare const gameEvents: {
-    /**
-     * Emit an event to all subscribers
-     */
-    emit: typeof emitGameEvent;
-    /**
-     * Subscribe to an event type
-     * @returns Unsubscribe function
-     */
-    on: typeof onGameEvent;
-    /**
-     * Unsubscribe from an event type
-     */
-    off: typeof offGameEvent;
-    /**
-     * Remove all subscribers (useful for cleanup/reset)
-     */
+    emit<TType extends string>(type: TType, payload: TType extends keyof GameEventMap ? GameEventMap[TType] : unknown): void;
+    on<TType extends string>(type: TType, handler: GameEventHandler<TType extends keyof GameEventMap ? GameEventMap[TType] : unknown>): () => void;
     clear(): void;
-    /**
-     * Check if an event type has any subscribers
-     */
     hasListeners(type: string): boolean;
 };
-/**
- * React hook to subscribe to game events.
- * Automatically cleans up on unmount.
- *
- * @example
- * // Physics event
- * useGameEvent('sensor:enter', (payload) => {
- *   if (payload.sourceEntityId === 'coin') collectCoin();
- * }, []);
- *
- * // Custom event
- * useGameEvent('player:death', (payload) => {
- *   const cause = typeof payload.cause === 'string' ? payload.cause : 'unknown';
- *   showGameOver(cause);
- * }, []);
- */
-export declare function useGameEvent<TType extends keyof GameEventMap>(type: TType, handler: EventHandler<GameEventMap[TType]>, deps?: unknown[]): void;
-export declare function useGameEvent(type: string, handler: EventHandler<UnknownEventPayload>, deps?: unknown[]): void;
-/**
- * React hook to subscribe to any physics event payload.
- * Use this when the event name is dynamic but the payload comes from PhysicsComponent.
- */
-export declare function usePhysicsEvent(type: string, handler: EventHandler<PhysicsEventPayload>, deps?: unknown[]): void;
-/**
- * React hook to subscribe to click event payloads.
- * Use this when the event name is dynamic but the payload comes from ClickComponent.
- */
-export declare function useClickEvent(type: string, handler: EventHandler<ClickEventPayload>, deps?: unknown[]): void;
-/**
- * Helper to extract entity ID from Rapier collision data.
- * Entity IDs are stored in RigidBody userData.
- */
-export declare function getEntityIdFromRigidBody(rigidBody: RapierRigidBody | null | undefined): string | null;
-export {};
+export declare function useGameEvent<TType extends string>(type: TType, handler: GameEventHandler<TType extends keyof GameEventMap ? GameEventMap[TType] : unknown>, deps?: React.DependencyList): void;
+export declare function usePhysicsEvent<TType extends string>(type: TType, handler: GameEventHandler<TType extends keyof GameEventMap ? GameEventMap[TType] : unknown>, deps?: React.DependencyList): void;
+export declare function useClickEvent<TType extends string>(type: TType, handler: GameEventHandler<TType extends keyof GameEventMap ? GameEventMap[TType] : unknown>, deps?: React.DependencyList): void;
+export declare function getEntityIdFromRigidBody(rigidBody: {
+    userData?: unknown;
+} | null | undefined): string | null;

package/dist/tools/prefabeditor/GameEvents.js

@@ -1,118 +1,66 @@
-import { useEffect, useCallback } from 'react';
-// Internal subscriber storage
+import { useCallback, useEffect } from 'react';
 const subscribers = new Map();
-function emitGameEvent(type, payload) {
-    const handlers = subscribers.get(type);
-    if (handlers) {
+export const gameEvents = {
+    emit(type, payload) {
+        const trimmedType = type.trim();
+        if (!trimmedType)
+            return;
+        const handlers = subscribers.get(trimmedType);
+        if (!handlers)
+            return;
         handlers.forEach(handler => {
             try {
                 handler(payload);
             }
-            catch (e) {
-                console.error(`Error in gameEvents handler for ${type}:`, e);
+            catch (error) {
+                console.error(`Error in gameEvents handler for ${trimmedType}:`, error);
             }
         });
-    }
-}
-function onGameEvent(type, handler) {
-    if (!subscribers.has(type)) {
-        subscribers.set(type, new Set());
-    }
-    subscribers.get(type).add(handler);
-    return () => {
-        var _a;
-        (_a = subscribers.get(type)) === null || _a === void 0 ? void 0 : _a.delete(handler);
-    };
-}
-function offGameEvent(type, handler) {
-    var _a;
-    (_a = subscribers.get(type)) === null || _a === void 0 ? void 0 : _a.delete(handler);
-}
-function useTypedGameEvent(type, handler, deps = []) {
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    const stableHandler = useCallback(handler, deps);
-    useEffect(() => {
-        return onGameEvent(type, stableHandler);
-    }, [type, stableHandler]);
-}
-/**
- * Game event system for all game interactions.
- *
- * Built-in events:
- * - sensor:enter - Something entered a sensor collider
- * - sensor:exit - Something exited a sensor collider
- * - collision:enter - A collision started
- * - collision:exit - A collision ended
- * - click - A prefab entity with a Click component was clicked in play mode
- *
- * Custom events:
- * - Emit any event type with any payload
- * - Extend GameEventMap interface for type safety
- *
- * @example
- * // Physics events (typed)
- * gameEvents.emit('sensor:enter', { sourceEntityId: 'zone', targetEntityId: 'player', targetRigidBody: rb });
- *
- * // Custom events
- * gameEvents.emit('player:death', { playerId: 'p1', cause: 'lava' });
- * gameEvents.emit('level:complete', { levelId: 3, time: 45.2 });
- */
-export const gameEvents = {
-    /**
-     * Emit an event to all subscribers
-     */
-    emit: emitGameEvent,
-    /**
-     * Subscribe to an event type
-     * @returns Unsubscribe function
-     */
-    on: onGameEvent,
-    /**
-     * Unsubscribe from an event type
-     */
-    off: offGameEvent,
-    /**
-     * Remove all subscribers (useful for cleanup/reset)
-     */
+    },
+    on(type, handler) {
+        const trimmedType = type.trim();
+        if (!trimmedType) {
+            return () => { };
+        }
+        let handlers = subscribers.get(trimmedType);
+        if (!handlers) {
+            handlers = new Set();
+            subscribers.set(trimmedType, handlers);
+        }
+        handlers.add(handler);
+        return () => {
+            const currentHandlers = subscribers.get(trimmedType);
+            if (!currentHandlers)
+                return;
+            currentHandlers.delete(handler);
+            if (currentHandlers.size === 0) {
+                subscribers.delete(trimmedType);
+            }
+        };
+    },
     clear() {
         subscribers.clear();
     },
-    /**
-     * Check if an event type has any subscribers
-     */
     hasListeners(type) {
         var _a, _b;
-        return ((_b = (_a = subscribers.get(type)) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 0) > 0;
-    }
+        return ((_b = (_a = subscribers.get(type.trim())) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 0) > 0;
+    },
 };
 export function useGameEvent(type, handler, deps = []) {
-    useTypedGameEvent(type, handler, deps);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    const stableHandler = useCallback(handler, deps);
+    useEffect(() => {
+        return gameEvents.on(type, stableHandler);
+    }, [type, stableHandler]);
 }
-/**
- * React hook to subscribe to any physics event payload.
- * Use this when the event name is dynamic but the payload comes from PhysicsComponent.
- */
 export function usePhysicsEvent(type, handler, deps = []) {
-    useTypedGameEvent(type, handler, deps);
+    useGameEvent(type, handler, deps);
 }
-/**
- * React hook to subscribe to click event payloads.
- * Use this when the event name is dynamic but the payload comes from ClickComponent.
- */
 export function useClickEvent(type, handler, deps = []) {
-    useTypedGameEvent(type, handler, deps);
+    useGameEvent(type, handler, deps);
 }
-// ============================================================================
-// Helpers
-// ============================================================================
-/**
- * Helper to extract entity ID from Rapier collision data.
- * Entity IDs are stored in RigidBody userData.
- */
 export function getEntityIdFromRigidBody(rigidBody) {
     var _a;
-    if (!rigidBody)
-        return null;
-    const userData = rigidBody.userData;
-    return (_a = userData === null || userData === void 0 ? void 0 : userData.entityId) !== null && _a !== void 0 ? _a : null;
+    const entityId = (_a = rigidBody === null || rigidBody === void 0 ? void 0 : rigidBody.userData) === null || _a === void 0 ? void 0 : _a.entityId;
+    return typeof entityId === 'string' ? entityId : null;
 }

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

@@ -12,8 +12,6 @@ export declare function getRepeatAxesFromModelProperties(properties: Record<stri
 export type InstanceData = {
     id: string;
     sourceId: string;
-    clickable?: boolean;
-    clickEventName?: string;
     locked?: boolean;
     position: [number, number, number];
     rotation: [number, number, number];
@@ -35,8 +33,6 @@ export declare function useInstanceCheck(id: string): boolean;
 export declare const GameInstance: React.ForwardRefExoticComponent<{
     id: string;
     sourceId?: string;
-    clickable?: boolean;
-    clickEventName?: string;
     modelUrl: string;
     locked?: boolean;
     position: [number, number, number];