@tresjs/core 3.7.0 → 3.8.1

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

@@ -1,5 +1,6 @@
-import type { Object3D } from 'three';
-export interface TresLoader<T> extends THREE.Loader {
+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>;
 }

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,6 +1,7 @@
-import type { Intersection, Event, Object3D } from 'three';
-import type { TresScene } from 'src/types';
-import type { TresContext } from '../useTresContextProvider';
+import { TresContext } from '../useTresContextProvider';
+import { TresScene } from 'src/types';
+import { Intersection, Event, Object3D } from 'three';
+
 type CallbackFn = (intersection: Intersection<Object3D<Event>>, event: PointerEvent) => void;
 type CallbackFnPointerLeave = (object: Object3D<Event>, event: PointerEvent) => void;
 export interface EventProps {

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

@@ -1,7 +1,8 @@
-import type { Object3D, type Intersection } from 'three';
-import type { Ref } from 'vue';
-import { type TresContext } from '../useTresContextProvider';
-export type Intersects = Intersection<THREE.Object3D<THREE.Event>>[];
+import { TresContext } from '../useTresContextProvider';
+import { Ref } from 'vue';
+import { Object3D, Intersection, Object3DEventMap } from 'three';
+
+export type Intersects = Intersection<Object3D<Object3DEventMap>>[];
 interface PointerMoveEventPayload {
     intersects?: Intersects;
     event: PointerEvent;
@@ -10,8 +11,8 @@ interface PointerClickEventPayload {
     intersects: Intersects;
     event: PointerEvent;
 }
-export declare const useRaycaster: (objects: Ref<THREE.Object3D[]>, { renderer, camera, raycaster }: Pick<TresContext, 'renderer' | 'camera' | 'raycaster'>) => {
-    intersects: import("vue").ComputedRef<Intersects>;
+export declare const useRaycaster: (objects: Ref<Object3D[]>, { renderer, camera, raycaster }: Pick<TresContext, 'renderer' | 'camera' | 'raycaster'>) => {
+    intersects: import('vue').ComputedRef<Intersects>;
     onClick: (fn: (value: PointerClickEventPayload) => void) => () => void;
     onPointerMove: (fn: (value: PointerMoveEventPayload) => void) => () => 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 { TresColor } from '../../types';
+import { MaybeRefOrGetter } from '@vueuse/core';
+import { MaybeRef } from 'vue';
+import { WebGLRenderer, Scene, ToneMapping, ColorSpace, ShadowMapType, WebGLRendererParameters } from 'three';
+
 type TransformToMaybeRefOrGetter<T> = {
     [K in keyof T]: MaybeRefOrGetter<T[K]> | MaybeRefOrGetter<T[K]>;
 };
@@ -83,7 +83,7 @@ export declare function useRenderer({ scene, canvas, options, disableRender, con
     contextParts: Pick<TresContext, 'sizes' | 'camera'>;
     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

@@ -1,3 +1,5 @@
+import { Scene, Object3D } from 'three';
+
 /**
  * Seek composable return type
  *
@@ -5,10 +7,10 @@
  * @interface UseSeekReturn
  */
 export interface UseSeekReturn {
-    seek: (parent: THREE.Scene | THREE.Object3D, property: string, value: string) => THREE.Object3D | null;
-    seekByName: (parent: THREE.Scene | THREE.Object3D, value: string) => THREE.Object3D | null;
-    seekAll: (parent: THREE.Scene | THREE.Object3D, property: string, value: string) => THREE.Object3D[];
-    seekAllByName: (parent: THREE.Scene | THREE.Object3D, value: string) => THREE.Object3D[];
+    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

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

@@ -0,0 +1,12 @@
+import { MaybeRefOrGetter, MaybeRef, ComputedRef, Ref } from 'vue';
+
+export interface SizesType {
+    height: Readonly<Ref<number>>;
+    width: Readonly<Ref<number>>;
+    aspectRatio: ComputedRef<number>;
+}
+export default function useSizes(windowSize: MaybeRefOrGetter<boolean>, canvas: MaybeRef<HTMLCanvasElement>, debounceMs?: number): {
+    height: Readonly<Ref<number>>;
+    width: Readonly<Ref<number>>;
+    aspectRatio: ComputedRef<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,14 +1,11 @@
-import type { Camera, EventDispatcher, Scene, WebGLRenderer } from 'three';
-import { Raycaster } from 'three';
-import type { ComputedRef, DeepReadonly, MaybeRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
-import type { UseRendererOptions } from '../useRenderer';
+import { SizesType } from '../useSizes';
+import { UseRendererOptions } from '../useRenderer';
+import { ComputedRef, DeepReadonly, MaybeRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
+import { Camera, EventDispatcher, Scene, WebGLRenderer, Raycaster } from 'three';
+
 export interface TresContext {
     scene: ShallowRef<Scene>;
-    sizes: {
-        height: Ref<number>;
-        width: Ref<number>;
-        aspectRatio: ComputedRef<number>;
-    };
+    sizes: SizesType;
     extend: (objects: any) => void;
     camera: ComputedRef<Camera | undefined>;
     cameras: DeepReadonly<Ref<Camera[]>>;

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,3 +1,4 @@
-import type { RendererOptions } from 'vue';
-import type { TresObject } from '../types';
+import { TresObject } from '../types';
+import { RendererOptions } from 'vue';
+
 export declare const nodeOps: RendererOptions<TresObject, TresObject>;

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

@@ -1,4 +1,4 @@
-export declare const render: import("vue").RootRenderFunction<import("..").TresObject>;
+export declare const render: import('vue').RootRenderFunction<import("src").TresObject>;
 declare const _default: {
     extend: (objects: any) => any;
 };

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,6 @@
-import { vLog } from './vLog';
-import { vLightHelper } from './vLightHelper';
-import { vAlwaysLookAt } from './vAlwaysLookAt';
 import { vDistanceTo } from './vDistanceTo';
+import { vAlwaysLookAt } from './vAlwaysLookAt';
+import { vLightHelper } from './vLightHelper';
+import { vLog } from './vLog';
+
 export { vLog, vLightHelper, vAlwaysLookAt, vDistanceTo };

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/index.d.ts

@@ -1,6 +1,7 @@
-import type { App } from 'vue';
+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';

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

@@ -1,6 +1,7 @@
-import type { DefineComponent, VNode, VNodeRef } from 'vue';
+import { EventProps as PointerEventHandlerEventProps } from '../composables/usePointerEventHandler';
+import { DefineComponent, VNode, VNodeRef } from 'vue';
+
 import type * as THREE from 'three';
-import type { EventProps as PointerEventHandlerEventProps } from '../composables/usePointerEventHandler';
 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;

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

@@ -1,5 +1,5 @@
-import { MeshBasicMaterial, Vector3 } from 'three';
-import type { Mesh, Scene, Object3D } from 'three';
+import { MeshBasicMaterial, Vector3, Mesh, Scene, Object3D } 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;

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

@@ -1,5 +1,5 @@
-import type { ColorRepresentation } from 'three';
-import { Vector3, Color } from 'three';
+import { ColorRepresentation, Vector3, Color } 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 @@
-export declare function withSetup(composable: any): (import("vue").App<Element> | undefined)[];
+export declare function withSetup(composable: any): (import('vue').App<Element> | undefined)[];