@tresjs/core 5.0.0-next.0 → 5.0.0-next.2

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

@@ -0,0 +1,10 @@
+import { PointerEvent, PointerEventsMap } from '@pmndrs/pointer-events';
+import { Event, Object3D, Object3DEventMap } from 'three';
+import { MaybeRef } from 'vue';
+import { TresContext } from '../useTresContextProvider';
+export declare function useEventManager({ canvas, contextParts: { scene, camera, loop }, }: {
+    canvas: MaybeRef<HTMLCanvasElement>;
+    contextParts: Pick<TresContext, 'scene' | 'camera' | 'loop'>;
+}): {
+    onPointerMissed: import('@vueuse/core').EventHookOn<PointerEvent<MouseEvent> & Event<"click", Object3D<Object3DEventMap & PointerEventsMap>>>;
+};

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

@@ -14,6 +14,7 @@ export type LoaderProto<T> = new (manager?: LoadingManager) => TresLoader<T>;
 export interface TresLoaderOptions<T, Shallow extends boolean> {
     manager?: LoadingManager;
     extensions?: (loader: TresLoader<T>) => void;
+    initialValue?: T;
     asyncOptions?: UseAsyncStateOptions<Shallow, any | null>;
 }
 /**

package/dist/src/composables/useRenderer/useRendererManager.d.ts

@@ -0,0 +1,187 @@
+import { RendererLoop } from './../../core/loop';
+import { ColorRepresentation, ColorSpace, ShadowMapType, ToneMapping, WebGLRenderer } from 'three';
+import { TresContext } from '../useTresContextProvider';
+import { MaybeRef, ShallowRef } from 'vue';
+import { Renderer } from 'three/webgpu';
+import { SizesType } from '../useSizes';
+import { UseCameraReturn } from '../useCamera';
+import { TresScene } from '../../types';
+/**
+ * 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 type TresRenderer = WebGLRenderer | Renderer;
+export interface RendererOptions {
+    /**
+     * WebGL Context options (Readonly because they are passed to the renderer constructor)
+     * They can't be changed after the renderer is created because they are passed to the canvas context
+     */
+    antialias?: boolean;
+    /**
+     * Enables stencil buffer with 8 bits.
+     * Required for stencil-based operations like shadow volumes or post-processing effects.
+     * @readonly
+     * @default true
+     */
+    stencil?: boolean;
+    /**
+     * Enables depth buffer with at least 16 bits.
+     * Required for proper 3D rendering and depth testing.
+     * @readonly
+     * @default true
+     */
+    depth?: boolean;
+    /**
+     * Sets the shader precision of the renderer.
+     * @see {@link https://threejs.org/docs/#api/en/renderers/WebGLRenderer}
+     * @default 'highp'
+     */
+    precision?: 'highp' | 'mediump' | 'lowp';
+    /**
+     * Enables logarithmic depth buffer. Useful for scenes with large differences in scale.
+     * Helps prevent z-fighting in scenes with objects very close and very far from the camera.
+     * @readonly
+     * @default false
+     */
+    logarithmicDepthBuffer?: boolean;
+    /**
+     * Preserves the buffers until manually cleared or overwritten.
+     * Needed for screenshots or when reading pixels from the canvas.
+     * Warning: This may impact performance.
+     * @readonly
+     * @default false
+     */
+    preserveDrawingBuffer?: boolean;
+    /**
+     * Power preference for the renderer.
+      * Power preference for the renderer.
+      * - `default`: Automatically chooses the most suitable power setting.
+      * - `high-performance`: Prioritizes rendering performance.
+      * - `low-power`: Tries to reduce power usage.
+     * @see {@link https://threejs.org/docs/#api/en/renderers/WebGLRenderer}
+     * @default 'default'
+     * @readonly
+     */
+    powerPreference?: WebGLPowerPreference;
+    /**
+       * Whether to create the WebGL context with an alpha buffer.
+       * This is a WebGL context option that must be set during context creation and cannot be changed later.
+       * When true, the canvas can be transparent, showing content behind it.
+       * @readonly
+       * @default false
+       */
+    alpha?: boolean;
+    /**
+     * Whether to premultiply the alpha of the canvas.
+     * @see {@link https://threejs.org/docs/#api/en/renderers/WebGLRenderer}
+     * @default true
+     */
+    premultipliedAlpha?: boolean;
+    /**
+     * Whether to fail if the major performance caveat is detected.
+     * @see {@link https://threejs.org/docs/#api/en/renderers/WebGLRenderer}
+     * @default false
+     */
+    failIfMajorPerformanceCaveat?: boolean;
+    /**
+     * WebGL options with set methods
+     * @see {@link https://threejs.org/docs/#api/en/renderers/WebGLRenderer}
+     */
+    /**
+     * Clear color for the canvas
+     * Can include alpha value (e.g. '#00808000' for fully transparent teal)
+     */
+    clearColor?: ColorRepresentation;
+    /**
+     * The opacity of the clear color (0-1)
+     * Controls the transparency of the clear color
+     * @default 1
+     */
+    clearAlpha?: number;
+    /**
+     * Enable shadow rendering in the scene
+     * @default false
+     */
+    shadows?: boolean;
+    /**
+     * Tone mapping technique to use for the scene
+     * - `NoToneMapping`: No tone mapping is applied.
+     * - `LinearToneMapping`: Linear tone mapping.
+     * - `ReinhardToneMapping`: Reinhard tone mapping.
+     * - `CineonToneMapping`: Cineon tone mapping.
+     * - `ACESFilmicToneMapping`: ACES Filmic tone mapping.
+     * - `AgXToneMapping`: AgX tone mapping.
+     * - `NeutralToneMapping`: Neutral tone mapping.
+     * @see {@link https://threejs.org/docs/#api/en/constants/Renderer}
+     * @default ACESFilmicToneMapping (Opinionated default by TresJS)
+     */
+    toneMapping?: ToneMapping;
+    /**
+     * Type of shadow map to use for shadow calculations
+     * - `BasicShadowMap`: Basic shadow map.
+     * - `PCFShadowMap`: Percentage-Closer Filtering shadow map.
+     * - `PCFSoftShadowMap`: Percentage-Closer Filtering soft shadow map.
+     * - `VSMShadowMap`: Variance shadow map.
+     * @see {@link https://threejs.org/docs/#api/en/constants/Renderer}
+     * @default PCFSoftShadowMap (Opinionated default by TresJS)
+     */
+    shadowMapType?: ShadowMapType;
+    /**
+     * Whether to use legacy lights system instead of the new one
+     * @deprecated Use `useLegacyLights: false` for the new lighting system
+     */
+    useLegacyLights?: boolean;
+    /**
+     * Color space for the output render
+     * @see {@link https://threejs.org/docs/#api/en/constants/Renderer}
+     */
+    outputColorSpace?: ColorSpace;
+    /**
+     * Exposure level of tone mapping
+     * @default 1
+     */
+    toneMappingExposure?: number;
+    /**
+     * Rendering mode for the canvas
+     * - 'always': Renders every frame
+     * - 'on-demand': Renders only when changes are detected
+     * - 'manual': Renders only when explicitly called
+     * @default 'always'
+     */
+    renderMode?: 'always' | 'on-demand' | 'manual';
+    /**
+     * Device Pixel Ratio for the renderer
+     * Can be a single number or a tuple defining a range [min, max]
+     */
+    dpr?: number | [number, number];
+    /**
+     * Custom WebGL renderer instance
+     * Allows using a pre-configured renderer instead of creating a new one
+     */
+    renderer?: (ctx: TresRendererSetupContext) => TresRenderer;
+}
+export interface TresRendererSetupContext {
+    sizes: SizesType;
+    scene: ShallowRef<TresScene>;
+    camera: UseCameraReturn;
+    loop: RendererLoop;
+    canvas: MaybeRef<HTMLCanvasElement>;
+}
+export interface UseRendererOptions {
+    scene: ShallowRef<TresScene>;
+    canvas: MaybeRef<HTMLCanvasElement>;
+    options: RendererOptions;
+    contextParts: Pick<TresContext, 'sizes' | 'camera' | 'loop'>;
+}
+export declare function useRendererManager({ scene, canvas, options, contextParts: { sizes, loop, camera }, }: UseRendererOptions): {
+    instance: TresRenderer;
+    advance: () => void;
+    onRender: import('@vueuse/core').EventHookOn<TresRenderer>;
+    onReady: import('@vueuse/core').EventHookOn<TresRenderer>;
+    invalidate: (amountOfFramesToInvalidate?: number) => void;
+    canBeInvalidated: import('vue').ComputedRef<boolean>;
+    frames: import('vue').Ref<number, number>;
+};
+export type UseRendererManagerReturn = ReturnType<typeof useRendererManager>;

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

@@ -0,0 +1,37 @@
+import { ComputedRef } from 'vue';
+import { TresContext } from '../useTresContextProvider';
+import { Camera } from 'three';
+import { TresRenderer } from '..';
+export interface TresPartialContext extends Omit<TresContext, 'renderer' | 'camera'> {
+    /**
+     * The renderer instance
+     *
+     * @type {TresRenderer}
+     * @memberof TresPartialContext
+     */
+    renderer: TresRenderer;
+    /**
+     * 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,24 @@
-import { Camera, WebGLRenderer, Raycaster } from 'three';
-import { ComputedRef, DeepReadonly, MaybeRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
+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, TresScene } from '../../types';
+import { RendererOptions, UseRendererManagerReturn } 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[];
-    };
-}
+import { useEventManager } from '../useEventManager';
 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>;
-    raycaster: ShallowRef<Raycaster>;
-    perf: PerformanceState;
-    render: RenderState;
+    renderer: UseRendererManagerReturn;
     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;
+    events: ReturnType<typeof useEventManager>;
 }
-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;
+    rendererOptions: RendererOptions;
 }): TresContext;
 export declare function useTresContext(): TresContext;
-export declare const useTres: typeof useTresContext;

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,14 +1,10 @@
 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: any, 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

@@ -1,2 +1,14 @@
 import { TresContext } from '../composables';
-export declare function setupDevtools(ctx: TresContext): void;
+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/types/index.d.ts

@@ -1,5 +1,6 @@
 import { DefineComponent, VNode, VNodeRef } from 'vue';
 import { TresContext } from '../composables/useTresContextProvider';
+import { PointerEventHandlers } from '../utils/pointerEvents';
 import type * as THREE from 'three';
 export type AttachFnType = (parent: any, self: TresInstance) => () => void;
 export type AttachType = string | AttachFnType;
@@ -17,8 +18,6 @@ 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 type TresCamera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
 /**
  * Represents the properties of an instance.
@@ -40,9 +39,7 @@ interface TresBaseObject {
 }
 export interface LocalState {
     type: string;
-    eventCount: number;
     root: TresContext;
-    handlers: Partial<EventHandlers>;
     memoizedProps: {
         [key: string]: any;
     };
@@ -72,69 +69,6 @@ export interface TresScene extends THREE.Scene {
         root: TresContext;
     };
 }
-export interface Intersection extends THREE.Intersection {
-    /** The event source (the object which registered the handler) */
-    eventObject: TresObject;
-}
-export interface IntersectionEvent<TSourceEvent> extends Intersection {
-    /** The event source (the object which registered the handler) */
-    eventObject: TresObject;
-    /** An array of intersections */
-    intersections: Intersection[];
-    /** vec3.set(pointer.x, pointer.y, 0).unproject(camera) */
-    unprojectedPoint: THREE.Vector3;
-    /** Normalized event coordinates */
-    pointer: THREE.Vector2;
-    /** Delta between first click and this event */
-    delta: number;
-    /** The ray that pierced it */
-    ray: THREE.Ray;
-    /** The camera that was used by the raycaster */
-    camera: TresCamera;
-    /** stopPropagation will stop underlying handlers from firing */
-    stopPropagation: () => void;
-    /** The original host event */
-    nativeEvent: TSourceEvent;
-    /** If the event was stopped by calling stopPropagation */
-    stopped: boolean;
-}
-export type ThreeEvent<TEvent> = IntersectionEvent<TEvent> & Properties<TEvent>;
-export type DomEvent = PointerEvent | MouseEvent | WheelEvent;
-export interface TresEvent {
-    eventObject: TresObject;
-    event: DomEvent;
-    stopPropagation: () => void;
-    stopPropagating: boolean;
-    intersections: Intersection[];
-    intersects: Intersection[];
-}
-export interface Events {
-    onClick: EventListener;
-    onContextMenu: EventListener;
-    onDoubleClick: EventListener;
-    onWheel: EventListener;
-    onPointerDown: EventListener;
-    onPointerUp: EventListener;
-    onPointerLeave: EventListener;
-    onPointerMove: EventListener;
-    onPointerCancel: EventListener;
-    onLostPointerCapture: EventListener;
-}
-export interface EventHandlers {
-    onClick?: (event: ThreeEvent<MouseEvent>) => void;
-    onContextMenu?: (event: ThreeEvent<MouseEvent>) => void;
-    onDoubleClick?: (event: ThreeEvent<MouseEvent>) => void;
-    onPointerUp?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerDown?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerOver?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerOut?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerEnter?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerLeave?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerMove?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerMissed?: (event: MouseEvent) => void;
-    onPointerCancel?: (event: ThreeEvent<PointerEvent>) => void;
-    onWheel?: (event: ThreeEvent<WheelEvent>) => void;
-}
 interface MathRepresentation {
     set(...args: number[] | [THREE.ColorRepresentation]): any;
 }
@@ -165,7 +99,8 @@ export type WithMathProps<P> = {
 interface RaycastableRepresentation {
     raycast: (raycaster: THREE.Raycaster, intersects: THREE.Intersection[]) => void;
 }
-type EventProps<P> = P extends RaycastableRepresentation ? Partial<EventHandlers> : unknown;
+type EventProps<P> = P extends RaycastableRepresentation ? Partial<PointerEventHandlers> : unknown;
+export type { TresPointerEvent } from '../utils/pointerEvents';
 export interface VueProps {
     children?: VNode[];
     ref?: VNodeRef;
@@ -190,4 +125,3 @@ declare module 'vue' {
         primitive: DefineComponent<TresPrimitive>;
     }
 }
-export {};

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;