@tresjs/core 4.3.5 → 5.0.0-next.1

package/dist/src/composables/useGraph/index.d.ts

@@ -0,0 +1,4 @@
+import { Object3D } from 'three';
+import { MaybeRef } from '@vueuse/core';
+import { TresObject } from '../../types';
+export declare function useGraph(object: MaybeRef<Object3D | TresObject>): import('vue').ComputedRef<import('../..').TresObjectMap>;

package/dist/src/composables/useLoader/component.vue.d.ts

@@ -1,24 +1,38 @@
+import { LoadingManager } from 'three';
 import { LoaderProto } from './index';
-type __VLS_Props = {
-    loader: LoaderProto<unknown>;
-    url: string | string[];
-};
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
+import { TresObjectMap } from '../../utils/graph';
+declare const _default: <T extends TresObjectMap>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onLoaded?: ((result: T) => any) | undefined;
+        readonly onError?: ((error: unknown) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onLoaded" | "onError"> & {
+        /**
+         * The THREE.js loader to use
+         */
+        loader: LoaderProto<T>;
+        /**
+         * Path to resource
+         */
+        path: string;
+        /**
+         * Optional THREE.js LoadingManager
+         */
+        manager?: LoadingManager;
+    } & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
     slots: {
         default?(_: {
-            data: unknown;
+            state: import('vue').UnwrapRef<T>;
+            isLoading: boolean;
+            error: unknown;
         }): any;
     };
-    refs: {};
-    rootEl: any;
+    emit: ((evt: "loaded", result: T) => void) & ((evt: "error", error: unknown) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
 };
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
-type __VLS_WithTemplateSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/src/composables/useLoader/index.d.ts

@@ -1,44 +1,51 @@
-import { Loader, LoadingManager, Object3D } from 'three';
-export interface TresLoader<T> extends Loader {
-    load: (url: string | string[], onLoad: (result: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) => void;
-    loadAsync: (url: string, onProgress?: (event: ProgressEvent) => void) => Promise<T>;
+import { UseAsyncStateOptions, UseAsyncStateReturn } from '@vueuse/core';
+import { Loader, LoadingManager } from 'three';
+import { MaybeRef } from 'vue';
+export interface LoaderMethods {
+    setDRACOLoader: (dracoLoader: any) => void;
+    setMeshoptDecoder: (meshoptDecoder: any) => void;
+    setKTX2Loader: (ktx2Loader: any) => void;
 }
+export type TresLoader<T> = Loader & Partial<LoaderMethods> & {
+    load: (url: string, onLoad: (result: T) => void, onProgress?: (event: ProgressEvent<EventTarget>) => void, onError?: (err: unknown) => void) => void;
+    loadAsync: (url: string, onProgress?: (event: ProgressEvent) => void) => Promise<T>;
+};
 export type LoaderProto<T> = new (manager?: LoadingManager) => TresLoader<T>;
-export type LoaderReturnType<T, L extends LoaderProto<T>> = T extends unknown ? Awaited<ReturnType<InstanceType<L>['loadAsync']>> : T;
+export interface TresLoaderOptions<T, Shallow extends boolean> {
+    manager?: LoadingManager;
+    extensions?: (loader: TresLoader<T>) => void;
+    initialValue?: T;
+    asyncOptions?: UseAsyncStateOptions<Shallow, any | null>;
+}
 /**
- * Traverse an object and return all the nodes and materials
- *
- * @export
- * @param {Object3D} object
- * @return { [key: string]: any }
+ * Return type for the useLoader composable
+ * @template T - The type of the loaded asset (e.g., GLTF, Texture, etc.)
+ * @template Shallow - Whether to use shallow reactivity for better performance
+ * @extends {UseAsyncStateReturn<T, [string], Shallow>} - Extends VueUse's useAsyncState return type
  */
-export declare function traverseObjects(object: Object3D): {
-    [key: string]: any;
+export type UseLoaderReturn<T, Shallow extends boolean> = UseAsyncStateReturn<T, [string], Shallow> & {
+    /**
+     * Loads a new asset from the given path
+     * @param path - The URL or path to the asset to load
+     */
+    load: (path: string) => void;
+    /**
+     * Progress of the loading process
+     * @property loaded - The number of bytes loaded
+     * @property total - The total number of bytes to load
+     * @property percentage - The percentage of the loading process
+     */
+    progress: {
+        loaded: number;
+        total: number;
+        percentage: number;
+    };
 };
-export type Extensions<T extends {
-    prototype: LoaderProto<any>;
-}> = (loader: T['prototype']) => void;
 /**
- * Load resources using THREE loaders and return the result as a promise
- *
- * @see https://tresjs.org/api/composables.html#useloader
- * @see https://threejs.org/docs/index.html?q=loader#api/en/loaders/Loader
- *
- * ```ts
- * import { useLoader } from '@tresjs/core'
- * import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader'
- *
- * const { scene } = await useLoader(THREE.GLTFLoader, 'path/to/asset.gltf')
- * ```
- *
- * @export
- * @template LoaderProto<T>
- * @template string | string[],
- * @param {LoaderProto<T>} Loader
- * @param {string | string[],} url
- * @param {Extensions<TresLoader<T>>} [extensions]
- * @param {(event: ProgressEvent<EventTarget>) => void} [onProgress]
- * @param {(proto: TresLoader<T>) => void} [cb]
- * @return {*}
+ * Vue composable for loading 3D models using Three.js loaders
+ * @param Loader - The Three.js loader constructor
+ * @param path - The path to the model file
+ * @param options - Optional configuration for the loader
+ * @returns UseAsyncState composable with the loaded model
  */
-export declare function useLoader<T>(Loader: LoaderProto<T>, url: string | string[], extensions?: (loader: TresLoader<T>) => void, onProgress?: (event: ProgressEvent<EventTarget>) => void, cb?: (proto: TresLoader<T>) => void): Promise<T | T[]>;
+export declare function useLoader<T, Shallow extends boolean = false>(Loader: LoaderProto<T>, path: MaybeRef<string>, options?: TresLoaderOptions<T, Shallow>): UseLoaderReturn<T, Shallow>;

package/dist/src/composables/useRaycaster/index.d.ts

@@ -1,6 +1,6 @@
-import { TresEvent, TresInstance } from 'src/types';
 import { Intersection, Object3D, Object3DEventMap } from 'three';
 import { ShallowRef } from 'vue';
+import { TresEvent, TresInstance } from '../../types';
 import { TresContext } from '../useTresContextProvider';
 export declare const useRaycaster: (objectsWithEvents: ShallowRef<TresInstance[]>, ctx: TresContext) => {
     intersects: ShallowRef<Intersection<Object3D<Object3DEventMap>>[]>;

package/dist/src/composables/useRenderer/{index.d.ts → useRendererManager.d.ts}

@@ -1,5 +1,5 @@
 import { ColorSpace, Scene, ShadowMapType, ToneMapping, WebGLRendererParameters, WebGLRenderer } from 'three';
-import { EmitEventFn, TresColor } from '../../types';
+import { TresColor } from '../../types';
 import { TresContext } from '../useTresContextProvider';
 import { RendererPresetsType } from './const';
 import { MaybeRefOrGetter } from '@vueuse/core';
@@ -7,6 +7,12 @@ import { MaybeRef } from 'vue';
 type TransformToMaybeRefOrGetter<T> = {
     [K in keyof T]: MaybeRefOrGetter<T[K]> | MaybeRefOrGetter<T[K]>;
 };
+/**
+ * If set to 'on-demand', the scene will only be rendered when the current frame is invalidated
+ * If set to 'manual', the scene will only be rendered when advance() is called
+ * If set to 'always', the scene will be rendered every frame
+ */
+export type RenderMode = 'always' | 'on-demand' | 'manual';
 export interface UseRendererOptions extends TransformToMaybeRefOrGetter<WebGLRendererParameters> {
     /**
      * Enable shadows in the Renderer
@@ -68,24 +74,26 @@ export interface UseRendererOptions extends TransformToMaybeRefOrGetter<WebGLRen
     clearColor?: MaybeRefOrGetter<TresColor>;
     windowSize?: MaybeRefOrGetter<boolean | string>;
     preset?: MaybeRefOrGetter<RendererPresetsType>;
-    renderMode?: MaybeRefOrGetter<'always' | 'on-demand' | 'manual'>;
+    renderMode?: MaybeRef<RenderMode>;
     /**
      * A `number` sets the renderer's device pixel ratio.
      * `[number, number]` clamp's the renderer's device pixel ratio.
      */
     dpr?: MaybeRefOrGetter<number | [number, number]>;
 }
-export declare function useRenderer({ canvas, options, contextParts: { sizes, render, invalidate, advance }, }: {
-    canvas: MaybeRef<HTMLCanvasElement>;
+export declare function useRendererManager({ scene, canvas, options, contextParts: { sizes, loop, camera }, }: {
     scene: Scene;
+    canvas: MaybeRef<HTMLCanvasElement>;
     options: UseRendererOptions;
-    emit: EmitEventFn;
-    contextParts: Pick<TresContext, 'sizes' | 'camera' | 'render'> & {
-        invalidate: () => void;
-        advance: () => void;
-    };
+    contextParts: Pick<TresContext, 'sizes' | 'camera' | 'loop'>;
 }): {
-    renderer: import('vue').ShallowRef<WebGLRenderer, WebGLRenderer>;
+    instance: import('vue').ShallowRef<WebGLRenderer, WebGLRenderer>;
+    isReady: Readonly<import('vue').Ref<boolean, boolean>>;
+    advance: () => void;
+    onRender: import('@vueuse/core').EventHook<WebGLRenderer>;
+    invalidate: (amountOfFramesToInvalidate?: number) => void;
+    canBeInvalidated: import('vue').ComputedRef<boolean>;
+    amountOfFramesToRender: import('vue').Ref<number, number>;
 };
-export type UseRendererReturn = ReturnType<typeof useRenderer>;
+export type UseRendererManagerReturn = ReturnType<typeof useRendererManager>;
 export {};

package/dist/src/composables/useTres/index.d.ts

@@ -0,0 +1,36 @@
+import { ComputedRef } from 'vue';
+import { TresContext } from '../useTresContextProvider';
+import { Camera, WebGLRenderer } from 'three';
+export interface TresPartialContext extends Omit<TresContext, 'renderer' | 'camera'> {
+    /**
+     * The renderer instance
+     *
+     * @type {WebGLRenderer}
+     * @memberof TresPartialContext
+     */
+    renderer: WebGLRenderer;
+    /**
+     * The current active camera
+     *
+     * @type {ComputedRef<Camera | undefined>}
+     * @memberof TresPartialContext
+     */
+    camera: ComputedRef<Camera | undefined>;
+    /**
+     * Marks the scene as needing an update in the next frame.
+     * This is used in on-demand rendering mode to schedule a render.
+     *
+     * @type {() => void}
+     * @memberof TresPartialContext
+     */
+    invalidate: () => void;
+    /**
+     * Manually advances the render loop by one frame.
+     * This is particularly useful in manual rendering mode where you want explicit control over when frames are rendered.
+     *
+     * @type {() => void}
+     * @memberof TresPartialContext
+     */
+    advance: () => void;
+}
+export declare function useTres(): TresPartialContext;

package/dist/src/composables/useTresContextProvider/index.d.ts

@@ -1,74 +1,30 @@
-import { Camera, WebGLRenderer, Raycaster } from 'three';
-import { ComputedRef, DeepReadonly, MaybeRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
+import { Raycaster } from 'three';
+import { MaybeRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
 import { RendererLoop } from '../../core/loop';
-import { EmitEventFn, TresControl, TresObject, TresScene } from '../../types';
-import { UseRendererOptions } from '../useRenderer';
+import { TresControl, TresObject, TresScene } from '../../types';
+import { UseRendererManagerReturn, UseRendererOptions } from '../useRenderer/useRendererManager';
+import { UseCameraReturn } from '../useCamera/';
 import { SizesType } from '../useSizes';
 import { TresEventManager } from '../useTresEventManager';
-export interface InternalState {
-    priority: Ref<number>;
-    frames: Ref<number>;
-    maxFrames: number;
-}
-export interface RenderState {
-    /**
-     * If set to 'on-demand', the scene will only be rendered when the current frame is invalidated
-     * If set to 'manual', the scene will only be rendered when advance() is called
-     * If set to 'always', the scene will be rendered every frame
-     */
-    mode: Ref<'always' | 'on-demand' | 'manual'>;
-    priority: Ref<number>;
-    frames: Ref<number>;
-    maxFrames: number;
-    canBeInvalidated: ComputedRef<boolean>;
-}
-export interface PerformanceState {
-    maxFrames: number;
-    fps: {
-        value: number;
-        accumulator: number[];
-    };
-    memory: {
-        currentMem: number;
-        allocatedMem: number;
-        accumulator: number[];
-    };
-}
 export interface TresContext {
     scene: ShallowRef<TresScene>;
     sizes: SizesType;
     extend: (objects: any) => void;
-    camera: ComputedRef<Camera | undefined>;
-    cameras: DeepReadonly<Ref<Camera[]>>;
+    camera: UseCameraReturn;
     controls: Ref<TresControl | null>;
-    renderer: ShallowRef<WebGLRenderer>;
+    renderer: UseRendererManagerReturn;
     raycaster: ShallowRef<Raycaster>;
-    perf: PerformanceState;
-    render: RenderState;
     loop: RendererLoop;
-    /**
-     * Invalidates the current frame when renderMode === 'on-demand'
-     */
-    invalidate: () => void;
-    /**
-     * Advance one frame when renderMode === 'manual'
-     */
-    advance: () => void;
-    registerCamera: (maybeCamera: unknown) => void;
-    setCameraActive: (cameraOrUuid: Camera | string) => void;
-    deregisterCamera: (maybeCamera: unknown) => void;
     eventManager?: TresEventManager;
     registerObjectAtPointerEventHandler?: (object: TresObject) => void;
     deregisterObjectAtPointerEventHandler?: (object: TresObject) => void;
     registerBlockingObjectAtPointerEventHandler?: (object: TresObject) => void;
     deregisterBlockingObjectAtPointerEventHandler?: (object: TresObject) => void;
 }
-export declare function useTresContextProvider({ scene, canvas, windowSize, rendererOptions, emit, }: {
+export declare function useTresContextProvider({ scene, canvas, windowSize, rendererOptions, }: {
     scene: TresScene;
     canvas: MaybeRef<HTMLCanvasElement>;
     windowSize: MaybeRefOrGetter<boolean>;
     rendererOptions: UseRendererOptions;
-    emit: EmitEventFn;
 }): TresContext;
 export declare function useTresContext(): TresContext;
-export declare const useTres: typeof useTresContext;

package/dist/src/composables/useTresEventManager/index.d.ts

@@ -1,7 +1,9 @@
-import { EmitEventFn } from 'src/types';
+import { TresPointerEvent } from 'src/types';
 import { Scene } from 'three';
 import { TresContext } from '../useTresContextProvider';
+import { EventHookOff } from '@vueuse/core';
 export interface TresEventManager {
+    onEvent: EventHookOff<TresPointerEvent>;
     /**
      * Forces the event system to refire events with the previous mouse event
      */
@@ -16,7 +18,8 @@ export interface TresEventManager {
     registerPointerMissedObject: (object: unknown) => void;
     deregisterPointerMissedObject: (object: unknown) => void;
 }
-export declare function useTresEventManager(scene: Scene, context: TresContext, emit: EmitEventFn): {
+export declare function useTresEventManager(scene: Scene, context: TresContext): {
+    onEvent: import('@vueuse/core').EventHookOn<TresPointerEvent>;
     forceUpdate: () => void;
     registerObject: (maybeTresObject: unknown) => void;
     deregisterObject: (maybeTresObject: unknown) => void;

package/dist/src/core/loop.d.ts

@@ -15,8 +15,6 @@ export interface LoopCallbackWithCtx extends LoopCallback {
     controls: Ref<(EventDispatcher<object> & {
         enabled: boolean;
     }) | null>;
-    invalidate: Fn;
-    advance: Fn;
 }
 export type LoopCallbackFn = (params: LoopCallbackWithCtx) => void;
 export interface RendererLoop {

package/dist/src/devtools/inspectorHandlers.d.ts

@@ -0,0 +1,60 @@
+import { Mesh } from 'three';
+import { TresObject } from '../types';
+import { SceneGraphObject } from './types';
+import { TresContext } from '../composables/useTresContextProvider';
+/**
+ * Creates a node representation of a Three.js object for the inspector tree
+ * @param object - The Three.js object to create a node for
+ * @returns A SceneGraphObject representing the Three.js object with relevant metadata
+ */
+export declare const createNode: (object: TresObject) => SceneGraphObject;
+/**
+ * Creates a context node for the inspector tree
+ * @param key - The key identifier for the context node
+ * @param uuid - The unique identifier for the context
+ * @param parentKey - Optional parent key for nested context nodes
+ * @returns A SceneGraphObject representing the context node
+ */
+export declare function createContextNode(key: string, uuid: string, parentKey?: string): SceneGraphObject;
+/**
+ * Recursively builds a graph representation of Three.js objects for the inspector
+ * @param object - The root Three.js object to build the graph from
+ * @param node - The current node in the graph being built
+ * @param filter - Optional filter string to filter objects by type or name
+ */
+export declare function buildGraph(object: TresObject, node: SceneGraphObject, filter?: string): void;
+/**
+ * Recursively builds a graph representation of context objects for the inspector
+ * @param object - The root object to build the context graph from
+ * @param node - The current node in the graph being built
+ * @param visited - WeakSet to track visited objects and prevent circular references
+ * @param depth - Current depth in the object tree
+ * @param maxDepth - Maximum depth to traverse
+ * @param contextUuid - Optional UUID for the context
+ * @param parentKey - Optional parent key for nested objects
+ */
+export declare function buildContextGraph(object: any, node: SceneGraphObject, visited?: WeakSet<WeakKey>, depth?: number, maxDepth?: number, contextUuid?: string, parentKey?: string): void;
+/**
+ * Handler for inspector tree updates
+ * @param tres - The TresContext instance
+ * @returns A function that handles inspector tree payload updates
+ */
+export declare const inspectorTreeHandler: (tres: TresContext) => (payload: any) => void;
+/**
+ * Handler for inspector state updates
+ * @param tres - The TresContext instance
+ * @param options - Options for the handler
+ * @param options.highlightMesh - The currently highlighted mesh
+ * @param options.prevInstance - The previously selected instance
+ * @returns A function that handles inspector state payload updates
+ */
+export declare const inspectorStateHandler: (tres: TresContext, { highlightMesh, prevInstance }: {
+    highlightMesh: Mesh | null;
+    prevInstance: TresObject | null;
+}) => (payload: any) => void;
+/**
+ * Handler for inspector state edits
+ * @param tres - The TresContext instance
+ * @returns A function that handles inspector state edit payload updates
+ */
+export declare const inspectorEditStateHandler: (tres: TresContext) => (payload: any) => void;

package/dist/src/devtools/plugin.d.ts

@@ -1,15 +1,10 @@
-import { App as DevtoolsApp } from '@vue/devtools-api';
 import { TresContext } from '../composables';
+import { App } from 'vue';
 export interface Tags {
     label: string;
     textColor: number;
     backgroundColor: number;
     tooltip?: string;
 }
-export interface SceneGraphObject {
-    id: string;
-    label: string;
-    children: SceneGraphObject[];
-    tags: Tags[];
-}
-export declare function registerTresDevtools(app: DevtoolsApp, tres: TresContext): void;
+export declare const INSPECTOR_ID = "tres:inspector";
+export declare function registerTresDevtools(app: App, tres: TresContext): void;

package/dist/src/devtools/setupDevtools.d.ts

@@ -0,0 +1,14 @@
+import { TresContext } from '../composables';
+export interface PerformanceState {
+    maxFrames: number;
+    fps: {
+        value: number;
+        accumulator: number[];
+    };
+    memory: {
+        currentMem: number;
+        allocatedMem: number;
+        accumulator: number[];
+    };
+}
+export declare function setupTresDevtools(ctx: TresContext): void;

package/dist/src/devtools/types.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Represents a tag that can be displayed in the inspector UI
+ * @interface Tags
+ */
+export interface Tags {
+    /** The text to display in the tag */
+    label: string;
+    /** The color of the text in hexadecimal format (e.g., 0xFFFFFF) */
+    textColor: number;
+    /** The background color of the tag in hexadecimal format (e.g., 0x000000) */
+    backgroundColor: number;
+    /** Optional tooltip text to show on hover */
+    tooltip?: string;
+}
+/**
+ * Represents a node in the scene graph that can be displayed in the inspector
+ * @interface SceneGraphObject
+ */
+export interface SceneGraphObject {
+    /** Unique identifier for the node */
+    id: string;
+    /** Display name of the node */
+    label: string;
+    /** Array of child nodes */
+    children: SceneGraphObject[];
+    /** Array of tags associated with the node */
+    tags: Tags[];
+}
+/**
+ * Represents memory usage statistics for Three.js resources
+ * @interface MemoryStats
+ */
+export interface MemoryStats {
+    /** Map of geometry names to their memory usage in bytes */
+    geometries: Map<string, number>;
+    /** Map of material names to their memory usage in bytes */
+    materials: Map<string, number>;
+    /** Map of texture names to their memory usage in bytes */
+    textures: Map<string, number>;
+}
+/**
+ * Represents a property in the inspector state
+ * @interface InspectorStateProperty
+ */
+export interface InspectorStateProperty {
+    /** The name of the property */
+    key: string;
+    /** The value of the property */
+    value: unknown;
+    /** Whether the property can be edited in the inspector */
+    editable: boolean;
+}
+/**
+ * Represents the state of an inspector panel
+ * @interface InspectorState
+ */
+export interface InspectorState {
+    /** Array of properties to display in the inspector */
+    object: InspectorStateProperty[];
+}
+/**
+ * Represents the internal state of the devtools
+ * @interface DevtoolsState
+ */
+export interface DevtoolsState {
+    /** The current scene graph representation */
+    sceneGraph: SceneGraphObject | null;
+    /** Timestamp of the last update */
+    lastUpdate: number;
+    /** Minimum time between updates in milliseconds */
+    updateThreshold: number;
+    /** Current memory usage statistics */
+    memoryStats: MemoryStats;
+}
+/**
+ * Represents a payload sent to or received from the devtools
+ * @interface DevtoolsPayload
+ */
+export interface DevtoolsPayload {
+    /** The ID of the inspector panel */
+    inspectorId: string;
+    /** The ID of the node being inspected */
+    nodeId: string;
+    /** Optional filter string for searching */
+    filter?: string;
+    /** Optional state to update */
+    state?: InspectorState;
+    /** Optional path to the property being edited */
+    path?: string[];
+}

package/dist/src/index.d.ts

@@ -8,6 +8,8 @@ export * from './core/catalogue';
 export * from './core/loop';
 export * from './directives';
 export * from './types';
+export * from './utils/graph';
+export * from './utils/logger';
 export interface TresOptions {
     extends?: Record<string, unknown>;
 }

package/dist/src/types/index.d.ts

@@ -17,8 +17,13 @@ export type Args<T> = T extends ConstructorRepresentation ? ConstructorParameter
 export interface TresCatalogue {
     [name: string]: ConstructorRepresentation;
 }
-export type EmitEventName = 'render' | 'ready' | 'click' | 'double-click' | 'context-menu' | 'pointer-move' | 'pointer-up' | 'pointer-down' | 'pointer-enter' | 'pointer-leave' | 'pointer-over' | 'pointer-out' | 'pointer-missed' | 'wheel';
-export type EmitEventFn = (event: EmitEventName, ...args: any[]) => void;
+export declare const pointerEventTypes: readonly ["click", "double-click", "context-menu", "pointer-move", "pointer-up", "pointer-down", "pointer-enter", "pointer-leave", "pointer-over", "pointer-out", "pointer-missed", "wheel"];
+export type PointerEventType = typeof pointerEventTypes[number];
+export interface TresPointerEvent {
+    type: PointerEventType;
+    event: TresEvent;
+    intersection?: Intersection;
+}
 export type TresCamera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
 /**
  * Represents the properties of an instance.
@@ -90,7 +95,7 @@ export interface IntersectionEvent<TSourceEvent> extends Intersection {
     /** The ray that pierced it */
     ray: THREE.Ray;
     /** The camera that was used by the raycaster */
-    camera: TresCamera;
+    camera: THREE.Camera;
     /** stopPropagation will stop underlying handlers from firing */
     stopPropagation: () => void;
     /** The original host event */

package/dist/src/utils/createPriorityEventHook.d.ts

@@ -9,7 +9,7 @@ export type PriorityEventHookOff<T> = EventHookOff<T>;
 export type PriorityEventHookTrigger<T = any> = (param?: T) => void;
 export interface PriorityEventHook<T = any> {
     on: PriorityEventHookOn<T>;
-    off: EventHookOff<T>;
+    off: (fn: Callback<T>) => void;
     trigger: PriorityEventHookTrigger<T>;
     dispose: () => void;
     count: number;

package/dist/src/utils/graph.d.ts

@@ -0,0 +1,14 @@
+import { Material, Mesh, Object3D, Scene } from 'three';
+export interface TresObjectMap {
+    nodes: {
+        [name: string]: Object3D;
+    };
+    materials: {
+        [name: string]: Material;
+    };
+    meshes: {
+        [name: string]: Mesh;
+    };
+    scene?: Scene;
+}
+export declare function buildGraph(object: Object3D): TresObjectMap;

package/dist/src/utils/index.d.ts

@@ -2,6 +2,7 @@ import { nodeOps } from 'src/core/nodeOps';
 import { AttachType, LocalState, TresInstance, TresObject, TresPrimitive } from 'src/types';
 import { Material, Mesh, MeshBasicMaterial, Scene, Vector3 } from 'three';
 import { TresContext } from '../composables/useTresContextProvider';
+export * from './logger';
 export declare function toSetMethodName(key: string): string;
 export declare const merge: (target: any, source: any) => any;
 export declare const isHTMLTag: (key: string) => boolean;
@@ -14,10 +15,6 @@ export declare const get: <T>(obj: any, path: string | string[]) => T | undefine
 export declare const set: (obj: any, path: string | string[], value: any) => void;
 export declare function deepEqual(a: any, b: any): boolean;
 export declare function deepArrayEqual(arr1: any[], arr2: any[]): boolean;
-/**
- * TypeSafe version of Array.isArray
- */
-export declare const isArray: (a: any) => a is any[] | readonly any[];
 export declare function editSceneObject(scene: Scene, objectUuid: string, propertyPath: string[], value: any): void;
 export declare function createHighlightMaterial(): MeshBasicMaterial;
 export declare function animateHighlight(highlightMesh: Mesh, startTime: number): void;