@tresjs/core 4.0.0-next.2 → 4.0.0-rc.0

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

@@ -0,0 +1,45 @@
+import { Loader, Object3D } from 'three';
+
+export interface TresLoader<T> extends Loader {
+    load: (url: string, onLoad?: (result: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) => unknown;
+    loadAsync: (url: string, onProgress?: (event: ProgressEvent) => void) => Promise<T>;
+}
+export type LoaderProto<T> = new (...args: any) => TresLoader<T extends unknown ? any : T>;
+export type LoaderReturnType<T, L extends LoaderProto<T>> = T extends unknown ? Awaited<ReturnType<InstanceType<L>['loadAsync']>> : T;
+/**
+ * Traverse an object and return all the nodes and materials
+ *
+ * @export
+ * @param {Object3D} object
+ * @return { [key: string]: any }
+ */
+export declare function trasverseObjects(object: Object3D): {
+    [key: string]: any;
+};
+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 T
+ * @template U
+ * @param {T} Loader
+ * @param {U} url
+ * @param {Extensions<T>} [extensions]
+ * @param {(event: ProgressEvent<EventTarget>) => void} [onProgress]
+ * @param {(proto: TresLoader<T>) => void} [cb]
+ * @return {*}
+ */
+export declare function useLoader<T extends LoaderProto<T>, U extends string | string[]>(Loader: T, url: U, extensions?: Extensions<T>, onProgress?: (event: ProgressEvent<EventTarget>) => void, cb?: (proto: TresLoader<T>) => void): Promise<U extends any[] ? LoaderReturnType<T, T>[] : LoaderReturnType<T, T>>;

package/dist/src/composables/useLogger.d.ts

@@ -1,7 +1,10 @@
 export declare const isProd: boolean;
+type OneOrMore<T> = {
+    0: T;
+} & Array<T>;
 interface LoggerComposition {
-    logError: (message: string, error?: Error | ErrorEvent) => void;
-    logWarning: (message: string) => void;
+    logError: (...args: OneOrMore<any>) => void;
+    logWarning: (...args: OneOrMore<any>) => void;
     logMessage: (name: string, value: any) => void;
 }
 export declare function useLogger(): LoggerComposition;

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

@@ -1,5 +1,7 @@
-import type { Intersection, Object3D, Object3DEventMap } from 'three';
-import type { TresContext } from '../useTresContextProvider';
+import { TresContext } from '../useTresContextProvider';
+import { TresObject } from 'src/types';
+import { Intersection, Object3D, Object3DEventMap } from 'three';
+
 type CallbackFn = (intersection: Intersection<Object3D<Object3DEventMap>>, event: PointerEvent) => void;
 type CallbackFnPointerLeave = (object: Object3D, event: PointerEvent) => void;
 export interface EventProps {
@@ -9,9 +11,9 @@ export interface EventProps {
     onPointerLeave?: CallbackFnPointerLeave;
 }
 export declare const usePointerEventHandler: (ctx: TresContext) => {
-    registerObject: (object: Object3D & EventProps) => void;
-    deregisterObject: (object: Object3D) => void;
-    registerBlockingObject: (object: Object3D) => void;
-    deregisterBlockingObject: (object: Object3D) => void;
+    registerObject: (object: TresObject & EventProps) => void;
+    deregisterObject: (object: TresObject) => void;
+    registerBlockingObject: (object: TresObject) => void;
+    deregisterBlockingObject: (object: TresObject) => void;
 };
 export {};

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

@@ -0,0 +1,17 @@
+import { TresContext } from '../useTresContextProvider';
+import { TresEvent } from 'src/types';
+import { Ref, ShallowRef } from 'vue';
+import { Intersection, Object3D } from 'three';
+
+export declare const useRaycaster: (objects: Ref<Object3D[]>, ctx: TresContext) => {
+    intersects: ShallowRef<Intersection<Object3D<import('three').Object3DEventMap>>[]>;
+    onClick: (fn: (value: TresEvent) => void) => () => void;
+    onDblClick: (fn: (value: TresEvent) => void) => () => void;
+    onContextMenu: (fn: (value: TresEvent) => void) => () => void;
+    onPointerMove: (fn: (value: TresEvent) => void) => () => void;
+    onPointerUp: (fn: (value: TresEvent) => void) => () => void;
+    onPointerDown: (fn: (value: TresEvent) => void) => () => void;
+    onPointerMissed: (fn: (value: TresEvent) => void) => () => void;
+    onWheel: (fn: (value: TresEvent) => void) => () => void;
+    forceUpdate: () => void;
+};

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

@@ -1,6 +1,7 @@
-import type { EventHookOn, Fn } from '@vueuse/core';
-import type { Ref } from 'vue';
 import { Clock } from 'three';
+import { Ref } from 'vue';
+import { EventHookOn, Fn } from '@vueuse/core';
+
 export interface RenderLoop {
     delta: number;
     elapsed: number;

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

@@ -1,10 +1,10 @@
-import { WebGLRenderer } from 'three';
-import { type MaybeRef } from 'vue';
-import { type MaybeRefOrGetter } from '@vueuse/core';
-import type { Scene, ToneMapping, ColorSpace, ShadowMapType, WebGLRendererParameters } from 'three';
-import type { TresColor } from '../../types';
-import type { TresContext } from '../useTresContextProvider';
-import type { RendererPresetsType } from './const';
+import { RendererPresetsType } from './const';
+import { TresContext } from '../useTresContextProvider';
+import { EmitEventFn, TresColor } from '../../types';
+import { MaybeRefOrGetter } from '@vueuse/core';
+import { MaybeRef } from 'vue';
+import { WebGLRenderer, ColorSpace, Scene, ShadowMapType, ToneMapping, WebGLRendererParameters } from 'three';
+
 type TransformToMaybeRefOrGetter<T> = {
     [K in keyof T]: MaybeRefOrGetter<T[K]> | MaybeRefOrGetter<T[K]>;
 };
@@ -71,24 +71,18 @@ export interface UseRendererOptions extends TransformToMaybeRefOrGetter<WebGLRen
     preset?: MaybeRefOrGetter<RendererPresetsType>;
     renderMode?: MaybeRefOrGetter<'always' | 'on-demand' | 'manual'>;
 }
-/**
- * Reactive three.js WebGLRenderer instance
- *
- * @param canvas
- * @param {UseRendererOptions} [options]
- */
 export declare function useRenderer({ scene, canvas, options, disableRender, emit, contextParts: { sizes, camera, render, invalidate, advance }, }: {
     canvas: MaybeRef<HTMLCanvasElement>;
     scene: Scene;
     options: UseRendererOptions;
-    emit: (event: string, ...args: any[]) => void;
+    emit: EmitEventFn;
     contextParts: Pick<TresContext, 'sizes' | 'camera' | 'render'> & {
         invalidate: () => void;
         advance: () => void;
     };
     disableRender: MaybeRefOrGetter<boolean>;
 }): {
-    renderer: import("vue").ShallowRef<WebGLRenderer>;
+    renderer: import('vue').ShallowRef<WebGLRenderer>;
 };
 export type UseRendererReturn = ReturnType<typeof useRenderer>;
 export {};

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

@@ -0,0 +1,21 @@
+import { Object3D, Scene } from 'three';
+
+/**
+ * Seek composable return type
+ *
+ * @export
+ * @interface UseSeekReturn
+ */
+export interface UseSeekReturn {
+    seek: (parent: Scene | Object3D, property: string, value: string) => Object3D | null;
+    seekByName: (parent: Scene | Object3D, value: string) => Object3D | null;
+    seekAll: (parent: Scene | Object3D, property: string, value: string) => Object3D[];
+    seekAllByName: (parent: Scene | Object3D, value: string) => Object3D[];
+}
+/**
+ * Composable that provides utilities to easily traverse and navigate through complex scenes and object children graphs
+ *
+ * @export
+ * @return {*}  {UseSeekReturn}
+ */
+export declare function useSeek(): UseSeekReturn;

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

@@ -1,4 +1,5 @@
-import type { MaybeRefOrGetter, MaybeRef, ComputedRef, Ref } from 'vue';
+import { ComputedRef, MaybeRef, MaybeRefOrGetter, Ref } from 'vue';
+
 export interface SizesType {
     height: Readonly<Ref<number>>;
     width: Readonly<Ref<number>>;

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

@@ -1,4 +1,5 @@
-import type { Texture } from 'three';
+import { Texture } from 'three';
+
 export interface PBRMaterialOptions {
     /**
      * List of texture maps to load.

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

@@ -1,10 +1,11 @@
-import type { Camera, EventDispatcher, Object3D, WebGLRenderer } from 'three';
-import { Raycaster } from 'three';
-import type { ComputedRef, DeepReadonly, MaybeRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
-import type { UseRendererOptions } from '../useRenderer';
-import type { TresScene } from '../../types';
-import type { EventProps } from '../usePointerEventHandler';
-import { type SizesType } from '../useSizes';
+import { SizesType } from '../useSizes';
+import { TresEventManager } from '../useTresEventManager';
+import { EventProps } from '../usePointerEventHandler';
+import { EmitEventFn, TresObject, TresScene } from '../../types';
+import { UseRendererOptions } from '../useRenderer';
+import { ComputedRef, DeepReadonly, MaybeRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
+import { Camera, EventDispatcher, WebGLRenderer, Raycaster } from 'three';
+
 export interface InternalState {
     priority: Ref<number>;
     frames: Ref<number>;
@@ -52,16 +53,17 @@ export interface TresContext {
      */
     invalidate: () => void;
     /**
-       * Advance one frame when renderMode === 'manual'
-       */
+     * Advance one frame when renderMode === 'manual'
+     */
     advance: () => void;
     registerCamera: (camera: Camera) => void;
     setCameraActive: (cameraOrUuid: Camera | string) => void;
     deregisterCamera: (camera: Camera) => void;
-    registerObjectAtPointerEventHandler: (object: Object3D & EventProps) => void;
-    deregisterObjectAtPointerEventHandler: (object: Object3D) => void;
-    registerBlockingObjectAtPointerEventHandler: (object: Object3D) => void;
-    deregisterBlockingObjectAtPointerEventHandler: (object: Object3D) => void;
+    eventManager?: TresEventManager;
+    registerObjectAtPointerEventHandler?: (object: TresObject & EventProps) => void;
+    deregisterObjectAtPointerEventHandler?: (object: TresObject) => void;
+    registerBlockingObjectAtPointerEventHandler?: (object: TresObject) => void;
+    deregisterBlockingObjectAtPointerEventHandler?: (object: TresObject) => void;
 }
 export declare function useTresContextProvider({ scene, canvas, windowSize, disableRender, rendererOptions, emit, }: {
     scene: TresScene;
@@ -69,7 +71,7 @@ export declare function useTresContextProvider({ scene, canvas, windowSize, disa
     windowSize: MaybeRefOrGetter<boolean>;
     disableRender: MaybeRefOrGetter<boolean>;
     rendererOptions: UseRendererOptions;
-    emit: (event: string, ...args: any[]) => void;
+    emit: EmitEventFn;
 }): TresContext;
 export declare function useTresContext(): TresContext;
 export declare const useTres: typeof useTresContext;

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

@@ -0,0 +1,22 @@
+import { TresContext } from '../useTresContextProvider';
+import { EmitEventFn, TresObject } from 'src/types';
+import { Scene } from 'three';
+
+export interface TresEventManager {
+    /**
+     * Forces the event system to refire events with the previous mouse event
+     */
+    forceUpdate: () => void;
+    /**
+     * pointer-missed events by definition are fired when the pointer missed every object in the scene
+     * So we need to track them separately
+     * Note: These are used in nodeOps
+     */
+    registerPointerMissedObject: (object: TresObject) => void;
+    deregisterPointerMissedObject: (object: TresObject) => void;
+}
+export declare function useTresEventManager(scene: Scene, context: TresContext, emit: EmitEventFn): {
+    forceUpdate: () => void;
+    registerPointerMissedObject: (object: TresObject) => void;
+    deregisterPointerMissedObject: (object: TresObject) => void;
+};

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

@@ -1,5 +1,6 @@
-import type { Ref } from 'vue';
-import type { TresCatalogue } from '../types';
+import { TresCatalogue } from '../types';
+import { Ref } from 'vue';
+
 export declare const catalogue: Ref<TresCatalogue>;
 export declare const extend: (objects: any) => any;
 declare const _default: {

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

@@ -1,4 +1,5 @@
-import { type RendererOptions } from 'vue';
-import type { TresObject } from '../types';
+import { TresObject } from '../types';
+import { RendererOptions } from 'vue';
+
 export declare function invalidateInstance(instance: TresObject): void;
 export declare const nodeOps: () => RendererOptions<TresObject, TresObject | null>;

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

@@ -2,6 +2,6 @@ import * as THREE from 'three';
 export declare class HightlightMesh extends THREE.Mesh {
     type: string;
     createTime: number;
-    constructor(...args: THREE.Mesh['args']);
+    constructor(...args: any[]);
     onBeforeRender(): void;
 }

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

@@ -1,5 +1,6 @@
-import type { App as DevtoolsApp } from '@vue/devtools-api';
-import type { TresContext } from '../composables';
+import { TresContext } from '../composables';
+import { App as DevtoolsApp } from '@vue/devtools-api';
+
 export interface Tags {
     label: string;
     textColor: number;

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

@@ -1,5 +1,7 @@
-import { vLog } from './vLog';
-import { vLightHelper } from './vLightHelper';
-import { vAlwaysLookAt } from './vAlwaysLookAt';
+import { vRotate } from './vRotate';
 import { vDistanceTo } from './vDistanceTo';
-export { vLog, vLightHelper, vAlwaysLookAt, vDistanceTo };
+import { vAlwaysLookAt } from './vAlwaysLookAt';
+import { vLightHelper } from './vLightHelper';
+import { vLog } from './vLog';
+
+export { vLog, vLightHelper, vAlwaysLookAt, vDistanceTo, vRotate };

package/dist/src/directives/vAlwaysLookAt.d.ts

@@ -1,6 +1,7 @@
-import type { Object3D } from 'three';
-import type { Ref } from 'vue';
-import type { TresVector3 } from '../types';
+import { TresVector3 } from '../types';
+import { Ref } from 'vue';
+import { Object3D } from 'three';
+
 export declare const vAlwaysLookAt: {
     updated: (el: Object3D, binding: Ref<TresVector3>) => void;
 };

package/dist/src/directives/vDistanceTo.d.ts

@@ -1,5 +1,6 @@
-import type { Ref } from 'vue';
-import type { TresObject } from '../types';
+import { TresObject } from '../types';
+import { Ref } from 'vue';
+
 export declare const vDistanceTo: {
     updated: (el: TresObject, binding: Ref<TresObject>) => void;
     unmounted: (el: TresObject) => void;

package/dist/src/directives/vLightHelper.d.ts

@@ -1,4 +1,5 @@
-import type { TresObject } from '../types';
+import { TresObject } from '../types';
+
 export declare const vLightHelper: {
     mounted: (el: TresObject) => void;
     updated: (el: TresObject) => void;

package/dist/src/directives/vLog.d.ts

@@ -1,4 +1,5 @@
-import type { TresObject } from '../types';
+import { TresObject } from '../types';
+
 export declare const vLog: {
     mounted: (el: TresObject, binding: {
         arg: string;

package/dist/src/directives/vRotate.d.ts

@@ -0,0 +1,13 @@
+import { TresObject } from '../types';
+
+export declare const vRotate: {
+    mounted: (el: TresObject, binding: {
+        arg: 'x' | 'y' | 'z';
+        value: number;
+        modifiers: Partial<{
+            x: boolean;
+            y: boolean;
+            z: boolean;
+        }>;
+    }) => void;
+};

package/dist/src/index.d.ts

@@ -1,6 +1,8 @@
-import type { App } from 'vue';
+import { disposeObject3D as dispose } from './utils';
+import { default as templateCompilerOptions } from './utils/template-compiler-options';
 import { normalizeColor, normalizeVectorFlexibleParam } from './utils/normalize';
-import templateCompilerOptions from './utils/template-compiler-options';
+import { App } from 'vue';
+
 export * from './composables';
 export * from './core/catalogue';
 export * from './components';
@@ -15,4 +17,4 @@ export interface TresPlugin {
 }
 declare const plugin: TresPlugin;
 export default plugin;
-export { normalizeColor, normalizeVectorFlexibleParam, templateCompilerOptions, };
+export { normalizeColor, normalizeVectorFlexibleParam, templateCompilerOptions, dispose, };

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

@@ -1,6 +1,7 @@
-import type { DefineComponent, VNode, VNodeRef } from 'vue';
+import { TresContext } from '../composables/useTresContextProvider';
+import { DefineComponent, VNode, VNodeRef } from 'vue';
+
 import type * as THREE from 'three';
-import type { TresContext } from '../composables/useTresContextProvider';
 export type AttachFnType<O = any> = (parent: any, self: O) => () => void;
 export type AttachType<O = any> = string | AttachFnType<O>;
 export type ConstructorRepresentation = new (...args: any[]) => any;
@@ -16,6 +17,8 @@ export type Args<T> = T extends ConstructorRepresentation ? ConstructorParameter
 export interface TresCatalogue {
     [name: string]: ConstructorRepresentation;
 }
+export type EmitEventName = 'render' | '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;
 export interface InstanceProps<T = any, P = any> {
     args?: Args<P>;
@@ -23,6 +26,7 @@ export interface InstanceProps<T = any, P = any> {
     visible?: boolean;
     dispose?: null;
     attach?: AttachType<T>;
+    [prop: string]: any;
 }
 interface TresBaseObject {
     attach?: string;
@@ -32,23 +36,23 @@ interface TresBaseObject {
 }
 export interface LocalState {
     type: string;
-    objects: TresObject3D[];
-    parent: TresObject3D | null;
+    objects?: TresObject3D[];
+    parent?: TresObject3D | null;
     primitive?: boolean;
-    eventCount: number;
-    handlers: Partial<EventHandlers>;
-    memoizedProps: {
+    eventCount?: number;
+    handlers?: Partial<EventHandlers>;
+    memoizedProps?: {
         [key: string]: any;
     };
-    disposable: boolean;
-    root: TresContext;
+    disposable?: boolean;
+    root?: TresContext;
 }
 export interface TresObject3D extends THREE.Object3D<THREE.Object3DEventMap> {
     geometry?: THREE.BufferGeometry & TresBaseObject;
     material?: THREE.Material & TresBaseObject;
 }
 export type TresObject = TresBaseObject & (TresObject3D | THREE.BufferGeometry | THREE.Material | THREE.Fog) & {
-    __tres: LocalState;
+    __tres?: LocalState;
 };
 export interface TresScene extends THREE.Scene {
     __tres: {
@@ -83,6 +87,14 @@ export interface IntersectionEvent<TSourceEvent> extends Intersection {
 }
 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;
@@ -111,10 +123,10 @@ export interface EventHandlers {
     onWheel?: (event: ThreeEvent<WheelEvent>) => void;
 }
 interface MathRepresentation {
-    set(...args: number[] | [THREE.ColorRepresentation]): any;
+    set: (...args: number[] | [THREE.ColorRepresentation]) => any;
 }
 interface VectorRepresentation extends MathRepresentation {
-    setScalar(s: number): any;
+    setScalar: (s: number) => any;
 }
 export interface VectorCoordinates {
     x: number;
@@ -122,22 +134,24 @@ export interface VectorCoordinates {
     z: number;
 }
 export type MathType<T extends MathRepresentation | THREE.Euler> = T extends THREE.Color ? ConstructorParameters<typeof THREE.Color> | THREE.ColorRepresentation : T extends VectorRepresentation | THREE.Layers | THREE.Euler ? T | Parameters<T['set']> | number | VectorCoordinates : T | Parameters<T['set']>;
-export type TresVector2 = MathType<THREE.Vector2>;
-export type TresVector3 = MathType<THREE.Vector3>;
-export type TresVector4 = MathType<THREE.Vector4>;
-export type TresColor = MathType<THREE.Color>;
-export type TresLayers = MathType<THREE.Layers>;
-export type TresQuaternion = MathType<THREE.Quaternion>;
-export type TresEuler = MathType<THREE.Euler>;
+type VectorLike<VectorClass extends THREE.Vector2 | THREE.Vector3 | THREE.Vector4> = VectorClass | Parameters<VectorClass['set']> | Readonly<Parameters<VectorClass['set']>> | Parameters<VectorClass['setScalar']>[0];
+export type TresVector2 = VectorLike<THREE.Vector2>;
+export type TresVector3 = VectorLike<THREE.Vector3>;
+export type TresVector4 = VectorLike<THREE.Vector4>;
+export type TresColor = ConstructorParameters<typeof THREE.Color> | THREE.Color | number | string;
+export type TresColorArray = typeof THREE.Color | [color: THREE.ColorRepresentation];
+export type TresLayers = THREE.Layers | Parameters<THREE.Layers['set']>[0];
+export type TresQuaternion = THREE.Quaternion | Parameters<THREE.Quaternion['set']>;
+export type TresEuler = THREE.Euler;
 type WithMathProps<P> = {
     [K in keyof P]: P[K] extends MathRepresentation | THREE.Euler ? MathType<P[K]> : P[K];
 };
 interface RaycastableRepresentation {
-    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
+    raycast: (raycaster: THREE.Raycaster, intersects: THREE.Intersection[]) => void;
 }
 type EventProps<P> = P extends RaycastableRepresentation ? Partial<EventHandlers> : unknown;
 export interface VueProps<P> {
-    children?: VNode[];
+    children?: VNode<P>[];
     ref?: VNodeRef;
     key?: string | number | symbol;
 }

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

@@ -1,10 +1,12 @@
-import { MeshBasicMaterial, Vector3 } from 'three';
-import type { Mesh, Scene, Object3D } from 'three';
+import { TresObject } from 'src/types';
+import { Material, Mesh, MeshBasicMaterial, Scene, Vector3 } from 'three';
+
 export declare function toSetMethodName(key: string): string;
 export declare const merge: (target: any, source: any) => any;
 export declare const isHTMLTag: (key: string) => boolean;
 export declare function isDOMElement(obj: any): obj is HTMLElement;
 export declare function kebabToCamel(str: string): string;
+export declare function hyphenate(str: string): string;
 export declare function makeMap(str: string, expectsLowerCase?: boolean): (key: string) => boolean;
 export declare const uniqueBy: <T, K>(array: T[], iteratee: (value: T) => K) => T[];
 export declare const get: <T>(obj: any, path: string | string[]) => T | undefined;
@@ -19,5 +21,7 @@ export declare function editSceneObject(scene: Scene, objectUuid: string, proper
 export declare function createHighlightMaterial(): MeshBasicMaterial;
 export declare function animateHighlight(highlightMesh: Mesh, startTime: number): void;
 export declare function stopHighlightAnimation(): void;
-export declare function createHighlightMesh(object: Object3D): Mesh;
+export declare function createHighlightMesh(object: TresObject): Mesh;
 export declare function extractBindingPosition(binding: any): Vector3;
+export declare function disposeMaterial(material: Material): void;
+export declare function disposeObject3D(object: TresObject): void;

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

@@ -1,5 +1,5 @@
-import type { ColorRepresentation } from 'three';
-import { Vector3, Color } from 'three';
+import { ColorRepresentation, Color, Vector3 } from 'three';
+
 export type SizeFlexibleParams = number[] | {
     width: number;
     height: number;

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

@@ -1,5 +1,6 @@
-import type { Scene } from 'three';
-import type { TresObject } from './../types';
+import { TresObject } from './../types';
+import { Scene } from 'three';
+
 export declare function calculateMemoryUsage(object: TresObject | Scene): number;
 export declare function bytesToKB(bytes: number): string;
 export declare function bytesToMB(bytes: number): string;

package/dist/src/utils/test-utils.d.ts

@@ -1 +1,3 @@
-export declare function withSetup(composable: any): (import("vue").App<Element> | undefined)[];
+import { Fn } from '@vueuse/core';
+
+export declare function withSetup(composable: Fn): (import('vue').App<Element> | undefined)[];