@tresjs/core 3.7.0-next.0 → 3.8.0

package/dist/{composables → 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/{composables → 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/{composables → 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/{composables → 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").Ref<WebGLRenderer> | import("vue").ShallowRef<WebGLRenderer>;
+    renderer: import('vue').ShallowRef<WebGLRenderer>;
 };
 export type UseRendererReturn = ReturnType<typeof useRenderer>;
 export {};

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/{composables → 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/{composables → 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/{core → 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

@@ -0,0 +1,4 @@
+import { TresObject } from '../types';
+import { RendererOptions } from 'vue';
+
+export declare const nodeOps: RendererOptions<TresObject, TresObject>;

package/dist/{core → 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/highlight.d.ts

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

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

@@ -0,0 +1 @@
+export { registerTresDevtools } from './plugin';

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

@@ -0,0 +1,16 @@
+import { TresContext } from '../composables';
+import { App as DevtoolsApp } from '@vue/devtools-api';
+
+export interface Tags {
+    label: string;
+    textColor: number;
+    backgroundColor: number;
+    tooltip?: string;
+}
+export interface SceneGraphObject {
+    id: string;
+    label: string;
+    children: SceneGraphObject[];
+    tags: Tags[];
+}
+export declare function registerTresDevtools(app: DevtoolsApp, tres: TresContext): void;

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

@@ -0,0 +1,7 @@
+/**
+ * Shows a toast or console.log
+ *
+ * @param message - message to log
+ * @param type - different color of the tooltip
+ */
+export declare function toastMessage(message: string, type?: 'normal' | 'error' | 'warn' | undefined): void;

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

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

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

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

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

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

@@ -0,0 +1,7 @@
+import { TresObject } from '../types';
+
+export declare const vLog: {
+    mounted: (el: TresObject, binding: {
+        arg: string;
+    }) => void;
+};

package/dist/src/index.d.ts

@@ -0,0 +1,19 @@
+import { default as templateCompilerOptions } from './utils/template-compiler-options';
+import { normalizeColor, normalizeVectorFlexibleParam } from './utils/normalize';
+import { App } from 'vue';
+
+export * from './composables';
+export * from './core/catalogue';
+export * from './components';
+export * from './types';
+export * from './directives';
+export interface TresOptions {
+    extends?: Record<string, unknown>;
+}
+export interface TresPlugin {
+    [key: string]: any;
+    install: (app: App, options?: TresOptions) => void;
+}
+declare const plugin: TresPlugin;
+export default plugin;
+export { normalizeColor, normalizeVectorFlexibleParam, templateCompilerOptions, };

package/dist/{types → 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/{utils → src/utils}/index.d.ts

@@ -1,4 +1,5 @@
-import { 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;
@@ -14,10 +15,9 @@ export declare function deepArrayEqual(arr1: any[], arr2: any[]): boolean;
  * TypeSafe version of Array.isArray
  */
 export declare const isArray: (a: any) => a is any[] | readonly any[];
-export declare function dispose<TresObj extends {
-    dispose?: () => void;
-    type?: string;
-    [key: string]: any;
-}>(obj: TresObj): void;
-export declare function disposeObject3D(object: Object3D): void;
-export default disposeObject3D;
+export declare function editSceneObject(scene: Scene, objectUuid: string, propertyPath: string[], value: any): void;
+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 extractBindingPosition(binding: any): Vector3;

package/dist/{utils → 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/{utils → 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

@@ -0,0 +1 @@
+export declare function withSetup(composable: any): (import('vue').App<Element> | undefined)[];