@tresjs/core 4.2.10 → 4.3.0

package/dist/src/components/TresCanvas.vue.d.ts

@@ -1,7 +1,7 @@
 import { ColorSpace, ShadowMapType, ToneMapping, WebGLRendererParameters } from 'three';
-import { TresContext } from '../composables';
 import { RendererPresetsType } from '../composables/useRenderer/const';
 import { TresCamera } from '../types/';
+import { TresContext } from '../composables';
 export interface TresCanvasProps extends Omit<WebGLRendererParameters, 'canvas'> {
     shadows?: boolean;
     clearColor?: string;
@@ -15,13 +15,20 @@ export interface TresCanvasProps extends Omit<WebGLRendererParameters, 'canvas'>
     camera?: TresCamera;
     preset?: RendererPresetsType;
     windowSize?: boolean;
-    disableRender?: boolean;
+    enableProvideBridge?: boolean;
 }
-declare function __VLS_template(): Readonly<{
-    default: () => any;
-}> & {
-    default: () => any;
+declare function __VLS_template(): {
+    slots: Readonly<{
+        default: () => any;
+    }> & {
+        default: () => any;
+    };
+    refs: {
+        canvas: HTMLCanvasElement;
+    };
+    attrs: Partial<{}>;
 };
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<TresCanvasProps, {
     context: import('vue').ShallowRef<TresContext | null>;
     dispose: () => void;
@@ -40,7 +47,7 @@ declare const __VLS_component: import('vue').DefineComponent<TresCanvasProps, {
     "pointer-over": (...args: any[]) => void;
     "pointer-out": (...args: any[]) => void;
     "pointer-missed": (...args: any[]) => void;
-}, string, import('vue').PublicProps, Readonly<TresCanvasProps & {
+}, string, import('vue').PublicProps, Readonly<TresCanvasProps> & Readonly<{
     onRender?: ((...args: any[]) => any) | undefined;
     onClick?: ((...args: any[]) => any) | undefined;
     onWheel?: ((...args: any[]) => any) | undefined;
@@ -67,11 +74,10 @@ declare const __VLS_component: import('vue').DefineComponent<TresCanvasProps, {
     useLegacyLights: boolean;
     windowSize: boolean;
     renderMode: "always" | "on-demand" | "manual";
-    disableRender: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+    enableProvideBridge: boolean;
+}, {}, {}, {}, 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/index.d.ts

@@ -1,12 +1,15 @@
+import { default as UseLoader } from './useLoader/component.vue';
+import { default as UseTexture } from './useTexture/component.vue';
 export * from './useCamera/';
-export * from './useRenderLoop';
-export * from './useRenderer/';
 export * from './useLoader';
-export * from './useTexture';
-export * from './useRaycaster';
 export * from './useLogger';
+export * from './useLoop';
+export * from './useRaycaster';
+export * from './useRenderer/';
+export * from './useRenderLoop';
 export * from './useSeek';
+export * from './useTexture';
 export * from './useTresContextProvider';
-export * from './useLoop';
 export * from './useTresEventManager';
 export { onTresReady } from './useTresReady';
+export { UseLoader, UseTexture };

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

@@ -1,6 +1,6 @@
-import { Camera } from 'three';
 import { TresScene } from '../../types';
 import { TresContext } from '../useTresContextProvider';
+import { Camera } from 'three';
 export declare const useCamera: ({ sizes }: Pick<TresContext, "sizes"> & {
     scene: TresScene;
 }) => {

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

@@ -1,6 +1,6 @@
+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>>[]>;

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

@@ -1,9 +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]>;
 };
@@ -84,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/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/useTresContextProvider/index.d.ts

@@ -1,10 +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>;
@@ -63,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,5 +1,5 @@
-import { Scene } from 'three';
 import { EmitEventFn } from 'src/types';
+import { Scene } from 'three';
 import { TresContext } from '../useTresContextProvider';
 export interface TresEventManager {
     /**

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

@@ -1,6 +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,4 +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/directives/index.d.ts

@@ -1,4 +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/index.d.ts

@@ -1,13 +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>;
 }
@@ -17,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

@@ -6,7 +6,7 @@ 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>>;
@@ -31,6 +31,7 @@ export interface InstanceProps<T = any, P = any> {
     object?: T;
     visible?: boolean;
     dispose?: null;
+    attach?: AttachType;
 }
 interface TresBaseObject {
     removeFromParent?: () => void;
@@ -158,7 +159,7 @@ 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 {
@@ -170,7 +171,7 @@ export interface VueProps {
     ref?: VNodeRef;
     key?: string | number | symbol;
 }
-type ElementProps<T extends ConstructorRepresentation, P = InstanceType<T>> = Partial<Overwrite<P, WithMathProps<P> & VueProps & 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/index.d.ts

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

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

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