@tresjs/core 3.8.1 → 3.9.0

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

@@ -1,8 +1,8 @@
 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>;
+    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;

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

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

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

@@ -1,6 +1,6 @@
 import { TresContext } from '../useTresContextProvider';
 import { Ref } from 'vue';
-import { Object3D, Intersection, Object3DEventMap } from 'three';
+import { Intersection, Object3D, Object3DEventMap } from 'three';
 
 export type Intersects = Intersection<Object3D<Object3DEventMap>>[];
 interface PointerMoveEventPayload {

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

@@ -3,7 +3,7 @@ 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';
+import { WebGLRenderer, ColorSpace, Scene, ShadowMapType, ToneMapping, WebGLRendererParameters } from 'three';
 
 type TransformToMaybeRefOrGetter<T> = {
     [K in keyof T]: MaybeRefOrGetter<T[K]> | MaybeRefOrGetter<T[K]>;
@@ -70,12 +70,6 @@ export interface UseRendererOptions extends TransformToMaybeRefOrGetter<WebGLRen
     windowSize?: MaybeRefOrGetter<boolean | string>;
     preset?: MaybeRefOrGetter<RendererPresetsType>;
 }
-/**
- * Reactive three.js WebGLRenderer instance
- *
- * @param canvas
- * @param {UseRendererOptions} [options]
- */
 export declare function useRenderer({ scene, canvas, options, disableRender, contextParts: { sizes, camera }, }: {
     canvas: MaybeRef<HTMLCanvasElement>;
     scene: Scene;

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

@@ -1,4 +1,4 @@
-import { Scene, Object3D } from 'three';
+import { Object3D, Scene } from 'three';
 
 /**
  * Seek composable return type

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

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

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

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

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

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

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

@@ -108,10 +108,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;
@@ -130,11 +130,11 @@ 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,4 +1,4 @@
-import { MeshBasicMaterial, Vector3, Mesh, Scene, Object3D } from 'three';
+import { MeshBasicMaterial, Vector3, Mesh, Object3D, Scene } from 'three';
 
 export declare function toSetMethodName(key: string): string;
 export declare const merge: (target: any, source: any) => any;

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

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