@tresjs/core 4.2.9 → 4.3.0

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

@@ -0,0 +1,25 @@
+import { LoaderProto } from './index';
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {
+            data: unknown;
+        }): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{
+    loader: LoaderProto<unknown>;
+    url: string | string[];
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    loader: LoaderProto<unknown>;
+    url: string | string[];
+}> & 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;
+    };
+};

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

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

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

@@ -1,11 +1,10 @@
 import { LoopCallbackFn } from './../../core/loop';
-
 export declare function useLoop(): {
     pause: import('@vueuse/core').Fn;
     resume: import('@vueuse/core').Fn;
     pauseRender: import('@vueuse/core').Fn;
     resumeRender: import('@vueuse/core').Fn;
-    isActive: import('vue').Ref<boolean>;
+    isActive: import('vue').Ref<boolean, boolean>;
     onBeforeRender: (cb: LoopCallbackFn, index?: number) => {
         off: import('@vueuse/core').Fn;
     };

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

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

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

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

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

@@ -1,10 +1,9 @@
-import { WebGLRenderer, ColorSpace, Scene, ShadowMapType, ToneMapping, WebGLRendererParameters } from 'three';
-import { MaybeRef } from 'vue';
-import { MaybeRefOrGetter } from '@vueuse/core';
+import { ColorSpace, Scene, ShadowMapType, ToneMapping, WebGLRendererParameters, WebGLRenderer } from 'three';
 import { EmitEventFn, TresColor } from '../../types';
 import { TresContext } from '../useTresContextProvider';
 import { RendererPresetsType } from './const';
-
+import { MaybeRefOrGetter } from '@vueuse/core';
+import { MaybeRef } from 'vue';
 type TransformToMaybeRefOrGetter<T> = {
     [K in keyof T]: MaybeRefOrGetter<T[K]> | MaybeRefOrGetter<T[K]>;
 };
@@ -85,7 +84,6 @@ export declare function useRenderer({ canvas, options, contextParts: { sizes, re
         invalidate: () => void;
         advance: () => void;
     };
-    disableRender: MaybeRefOrGetter<boolean>;
 }): {
     renderer: import('vue').ShallowRef<WebGLRenderer>;
 };

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

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

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

@@ -1,12 +1,11 @@
 import { ComputedRef, MaybeRef, MaybeRefOrGetter, 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>>;
+    height: Readonly<Ref<number, number>>;
+    width: Readonly<Ref<number, number>>;
     aspectRatio: ComputedRef<number>;
 };

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

@@ -0,0 +1,28 @@
+import { PBRUseTextureMap } from './index';
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {
+            textures: {
+                map: import('three').Texture;
+                displacementMap: import('three').Texture;
+                normalMap: import('three').Texture;
+                roughnessMap: import('three').Texture;
+                metalnessMap: import('three').Texture;
+                aoMap: import('three').Texture;
+                alphaMap: import('three').Texture;
+                matcap: import('three').Texture;
+            };
+        }): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<PBRUseTextureMap, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<PBRUseTextureMap> & 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;
+    };
+};

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

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

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

@@ -1,11 +1,10 @@
 import { Camera, WebGLRenderer, Raycaster } from 'three';
 import { ComputedRef, DeepReadonly, MaybeRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
-import { UseRendererOptions } from '../useRenderer';
+import { RendererLoop } from '../../core/loop';
 import { EmitEventFn, TresControl, TresObject, TresScene } from '../../types';
-import { TresEventManager } from '../useTresEventManager';
+import { UseRendererOptions } from '../useRenderer';
 import { SizesType } from '../useSizes';
-import { RendererLoop } from '../../core/loop';
-
+import { TresEventManager } from '../useTresEventManager';
 export interface InternalState {
     priority: Ref<number>;
     frames: Ref<number>;
@@ -64,11 +63,10 @@ export interface TresContext {
     registerBlockingObjectAtPointerEventHandler?: (object: TresObject) => void;
     deregisterBlockingObjectAtPointerEventHandler?: (object: TresObject) => void;
 }
-export declare function useTresContextProvider({ scene, canvas, windowSize, disableRender, rendererOptions, emit, }: {
+export declare function useTresContextProvider({ scene, canvas, windowSize, rendererOptions, emit, }: {
     scene: TresScene;
     canvas: MaybeRef<HTMLCanvasElement>;
     windowSize: MaybeRefOrGetter<boolean>;
-    disableRender: MaybeRefOrGetter<boolean>;
     rendererOptions: UseRendererOptions;
     emit: EmitEventFn;
 }): TresContext;

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

@@ -1,7 +1,6 @@
-import { Scene } from 'three';
 import { EmitEventFn } from 'src/types';
+import { Scene } from 'three';
 import { TresContext } from '../useTresContextProvider';
-
 export interface TresEventManager {
     /**
      * Forces the event system to refire events with the previous mouse event

package/dist/src/composables/useTresReady/createReadyEventHook/index.d.ts

@@ -1,5 +1,4 @@
 import { EventHook } from '@vueuse/core';
-
 export declare function createReadyEventHook<T>(getIsReady: () => boolean, triggerParams: T, pollIntervalMs?: number): EventHook<T> & {
     cancel: () => void;
 };

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

@@ -1,5 +1,4 @@
 import { TresContext } from '../useTresContextProvider';
-
 export declare function useTresReady(ctx?: TresContext): import('@vueuse/core').EventHook<TresContext> & {
     cancel: () => void;
 };

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

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

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

@@ -1,7 +1,6 @@
-import { Ref } from 'vue';
-import { Camera, EventDispatcher, Raycaster, Scene, WebGLRenderer, Clock } from 'three';
 import { Fn } from '@vueuse/core';
-
+import { Camera, EventDispatcher, Raycaster, Scene, WebGLRenderer, Clock } from 'three';
+import { Ref } from 'vue';
 export type LoopStage = 'before' | 'render' | 'after';
 export interface LoopCallback {
     delta: number;

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

@@ -1,5 +1,4 @@
-import { RendererOptions } from 'vue';
 import { TresContext } from '../composables';
 import { TresObject } from '../types';
-
+import { RendererOptions } from 'vue';
 export declare const nodeOps: (context: TresContext) => RendererOptions<TresObject, TresObject | null>;

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

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

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

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

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

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

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

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

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

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

package/dist/src/index.d.ts

@@ -1,14 +1,13 @@
 import { App } from 'vue';
+import { disposeObject3D as dispose } from './utils';
 import { normalizeColor, normalizeVectorFlexibleParam } from './utils/normalize';
 import { default as templateCompilerOptions } from './utils/template-compiler-options';
-import { disposeObject3D as dispose } from './utils';
-
+export * from './components';
 export * from './composables';
 export * from './core/catalogue';
-export * from './components';
-export * from './types';
-export * from './directives';
 export * from './core/loop';
+export * from './directives';
+export * from './types';
 export interface TresOptions {
     extends?: Record<string, unknown>;
 }
@@ -18,5 +17,5 @@ export interface TresPlugin {
 }
 declare const plugin: TresPlugin;
 export default plugin;
-export { normalizeColor, normalizeVectorFlexibleParam, templateCompilerOptions, dispose, };
+export { dispose, normalizeColor, normalizeVectorFlexibleParam, templateCompilerOptions, };
 export type { VectorFlexibleParams } from './utils/normalize';

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

@@ -1,13 +1,12 @@
 import { DefineComponent, VNode, VNodeRef } from 'vue';
 import { TresContext } from '../composables/useTresContextProvider';
-
 import type * as THREE from 'three';
 export type AttachFnType = (parent: any, self: TresInstance) => () => void;
 export type AttachType = string | AttachFnType;
 export type DisposeType = ((self: TresInstance) => void) | boolean | 'default';
 export type ConstructorRepresentation = new (...args: any[]) => any;
 export type NonFunctionKeys<P> = {
-    [K in keyof P]-?: P[K] extends Function ? never : K;
+    [K in keyof P]-?: P[K] extends (...args: any[]) => any ? never : K;
 }[keyof P];
 export type Overwrite<P, O> = Omit<P, NonFunctionKeys<O>> & O;
 export type Properties<T> = Pick<T, NonFunctionKeys<T>>;
@@ -21,12 +20,18 @@ export interface TresCatalogue {
 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.
+ *
+ * @template T - The type of the object.
+ * @template P - The type of the arguments.
+ */
 export interface InstanceProps<T = any, P = any> {
     args?: Args<P>;
     object?: T;
     visible?: boolean;
     dispose?: null;
-    [prop: string]: any;
+    attach?: AttachType;
 }
 interface TresBaseObject {
     removeFromParent?: () => void;
@@ -131,10 +136,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;
@@ -154,19 +159,19 @@ export type TresEuler = THREE.Euler;
 export type TresControl = THREE.EventDispatcher & {
     enabled: boolean;
 };
-type WithMathProps<P> = {
+export 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;
 }
 type EventProps<P> = P extends RaycastableRepresentation ? Partial<EventHandlers> : unknown;
-export interface VueProps<P> {
-    children?: VNode<P>[];
+export interface VueProps {
+    children?: VNode[];
     ref?: VNodeRef;
     key?: string | number | symbol;
 }
-type ElementProps<T extends ConstructorRepresentation, P = InstanceType<T>> = Partial<Overwrite<WithMathProps<P>, VueProps<P> & EventProps<P>>>;
+export type ElementProps<T extends ConstructorRepresentation, P = InstanceType<T>> = Partial<Overwrite<P, WithMathProps<P> & VueProps & EventProps<P>>>;
 export type ThreeElement<T extends ConstructorRepresentation> = Mutable<Overwrite<ElementProps<T>, Omit<InstanceProps<InstanceType<T>, T>, 'object'>>>;
 type ThreeExports = typeof THREE;
 type ThreeInstancesImpl = {

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

@@ -1,5 +1,4 @@
 import { EventHookOff, IsAny } from '@vueuse/core';
-
 export type Callback<T> = IsAny<T> extends true ? (param: any) => void : ([
     T
 ] extends [void] ? () => void : (param: T) => void);

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

@@ -1,8 +1,7 @@
-import { Material, Mesh, MeshBasicMaterial, Scene, Vector3 } from 'three';
-import { AttachType, LocalState, TresInstance, TresObject, TresPrimitive } from 'src/types';
 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 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/is.d.ts

@@ -1,12 +1,11 @@
 import { TresObject, TresPrimitive } from 'src/types';
 import { BufferGeometry, Camera, Fog, Light, Material, Object3D, Scene } from 'three';
-
 export declare function und(u: unknown): u is undefined;
 export declare function arr(u: unknown): u is any[];
 export declare function num(u: unknown): u is number;
 export declare function str(u: unknown): u is string;
 export declare function bool(u: unknown): u is boolean;
-export declare function fun(u: unknown): u is Function;
+export declare function fun(u: unknown): u is (...args: any[]) => any;
 export declare function obj(u: unknown): u is Record<string | number | symbol, unknown>;
 export declare function object3D(u: unknown): u is Object3D;
 export declare function camera(u: unknown): u is Camera;

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

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

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

@@ -1,6 +1,5 @@
 import { Scene } from 'three';
 import { TresObject } from './../types';
-
 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,3 +1,2 @@
 import { Fn } from '@vueuse/core';
-
 export declare function withSetup(composable: Fn): (import('vue').App<Element> | undefined)[];