@tresjs/core 5.0.3 → 5.1.1

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

@@ -1,37 +0,0 @@
-import { ComputedRef } from 'vue';
-import { TresContext } from '../useTresContextProvider';
-import { Camera } from 'three';
-import { TresRenderer } from '..';
-export interface TresPartialContext extends Omit<TresContext, 'renderer' | 'camera'> {
-    /**
-     * The renderer instance
-     *
-     * @type {TresRenderer}
-     * @memberof TresPartialContext
-     */
-    renderer: TresRenderer;
-    /**
-     * The current active camera
-     *
-     * @type {ComputedRef<Camera | undefined>}
-     * @memberof TresPartialContext
-     */
-    camera: ComputedRef<Camera | undefined>;
-    /**
-     * Marks the scene as needing an update in the next frame.
-     * This is used in on-demand rendering mode to schedule a render.
-     *
-     * @type {() => void}
-     * @memberof TresPartialContext
-     */
-    invalidate: () => void;
-    /**
-     * Manually advances the render loop by one frame.
-     * This is particularly useful in manual rendering mode where you want explicit control over when frames are rendered.
-     *
-     * @type {() => void}
-     * @memberof TresPartialContext
-     */
-    advance: () => void;
-}
-export declare function useTres(): TresPartialContext;

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

@@ -1,24 +0,0 @@
-import { MaybeRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
-import { TresControl, TresScene } from '../../types';
-import { RendererOptions, UseRendererManagerReturn } from '../useRenderer/useRendererManager';
-import { UseCameraReturn } from '../useCamera/';
-import { SizesType } from '../useSizes';
-import { useEventManager } from '../useEventManager';
-export interface TresContext {
-    scene: ShallowRef<TresScene>;
-    sizes: SizesType;
-    extend: (objects: any) => void;
-    camera: UseCameraReturn;
-    controls: Ref<TresControl | null>;
-    renderer: UseRendererManagerReturn;
-    events: ReturnType<typeof useEventManager>;
-}
-export declare const INJECTION_KEY = "useTres";
-declare const useTresContextProvider: (args_0: {
-    scene: TresScene;
-    canvas: MaybeRef<HTMLCanvasElement>;
-    windowSize: MaybeRefOrGetter<boolean>;
-    rendererOptions: RendererOptions;
-}) => TresContext;
-declare const useTresContext: () => TresContext;
-export { useTresContext, useTresContextProvider };

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

@@ -1,9 +0,0 @@
-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, TresCatalogue>;
-    extend: (objects: any) => any;
-};
-export default _default;

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

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

@@ -1 +0,0 @@
-export declare const revision: number;

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

@@ -1,53 +0,0 @@
-export type DevtoolsMessageType = 'performance' | 'context' | 'asset-load';
-export interface AssetLoadData {
-    url: string;
-    type: string;
-    loaded: boolean;
-    size: number;
-    asset: HTMLImageElement | HTMLScriptElement | HTMLLinkElement | Blob | ArrayBuffer | null;
-}
-export interface DevtoolsMessage<T = any> {
-    type: DevtoolsMessageType;
-    data: T;
-    timestamp?: number;
-}
-export type DevtoolsSubscriber = (message: DevtoolsMessage) => void;
-/**
- * Messenger class for communicating with Tres DevTools
- * This class will be attached to window.__TRES__DEVTOOLS__
- */
-export declare class DevtoolsMessenger {
-    private subscribers;
-    private messageQueue;
-    private maxQueueSize;
-    /**
-     * Send a message to devtools subscribers
-     * If no subscribers are available, only queueable message types are queued
-     */
-    send<T>(type: DevtoolsMessageType, data: T): void;
-    /**
-     * Queue a message for later delivery
-     */
-    private queueMessage;
-    /**
-     * Flush all queued messages to current subscribers
-     */
-    private flushQueue;
-    /**
-     * Subscribe to devtools messages
-     * When a new subscriber is added, all queued messages (asset-load events) are immediately delivered
-     */
-    subscribe(subscriber: DevtoolsSubscriber): () => void;
-    /**
-     * Check if there are any subscribers
-     */
-    get hasSubscribers(): boolean;
-    /**
-     * Get the current queue size
-     */
-    get queueSize(): number;
-    /**
-     * Clear all queued messages
-     */
-    clearQueue(): void;
-}

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

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

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

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

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

@@ -1,60 +0,0 @@
-import { Mesh } from 'three';
-import { TresObject } from '../types';
-import { SceneGraphObject } from './types';
-import { TresContext } from '../composables/useTresContextProvider';
-/**
- * Creates a node representation of a Three.js object for the inspector tree
- * @param object - The Three.js object to create a node for
- * @returns A SceneGraphObject representing the Three.js object with relevant metadata
- */
-export declare const createNode: (object: TresObject) => SceneGraphObject;
-/**
- * Creates a context node for the inspector tree
- * @param key - The key identifier for the context node
- * @param uuid - The unique identifier for the context
- * @param parentKey - Optional parent key for nested context nodes
- * @returns A SceneGraphObject representing the context node
- */
-export declare function createContextNode(key: string, uuid: string, parentKey?: string): SceneGraphObject;
-/**
- * Recursively builds a graph representation of Three.js objects for the inspector
- * @param object - The root Three.js object to build the graph from
- * @param node - The current node in the graph being built
- * @param filter - Optional filter string to filter objects by type or name
- */
-export declare function buildGraph(object: TresObject, node: SceneGraphObject, filter?: string): void;
-/**
- * Recursively builds a graph representation of context objects for the inspector
- * @param object - The root object to build the context graph from
- * @param node - The current node in the graph being built
- * @param visited - WeakSet to track visited objects and prevent circular references
- * @param depth - Current depth in the object tree
- * @param maxDepth - Maximum depth to traverse
- * @param contextUuid - Optional UUID for the context
- * @param parentKey - Optional parent key for nested objects
- */
-export declare function buildContextGraph(object: any, node: SceneGraphObject, visited?: WeakSet<WeakKey>, depth?: number, maxDepth?: number, contextUuid?: string, parentKey?: string): void;
-/**
- * Handler for inspector tree updates
- * @param tres - The TresContext instance
- * @returns A function that handles inspector tree payload updates
- */
-export declare const inspectorTreeHandler: (tres: TresContext) => (payload: any) => void;
-/**
- * Handler for inspector state updates
- * @param tres - The TresContext instance
- * @param options - Options for the handler
- * @param options.highlightMesh - The currently highlighted mesh
- * @param options.prevInstance - The previously selected instance
- * @returns A function that handles inspector state payload updates
- */
-export declare const inspectorStateHandler: (tres: TresContext, { highlightMesh, prevInstance }: {
-    highlightMesh: Mesh | null;
-    prevInstance: TresObject | null;
-}) => (payload: any) => void;
-/**
- * Handler for inspector state edits
- * @param tres - The TresContext instance
- * @returns A function that handles inspector state edit payload updates
- */
-export declare const inspectorEditStateHandler: (tres: TresContext) => (payload: any) => void;

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

@@ -1,10 +0,0 @@
-import { TresContext } from '../composables';
-import { App } from 'vue';
-export interface Tags {
-    label: string;
-    textColor: number;
-    backgroundColor: number;
-    tooltip?: string;
-}
-export declare const INSPECTOR_ID = "tres:inspector";
-export declare function registerTresDevtools(app: App, tres: TresContext): void;

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

@@ -1,14 +0,0 @@
-import { TresContext } from '../composables';
-export interface PerformanceState {
-    maxFrames: number;
-    fps: {
-        value: number;
-        accumulator: number[];
-    };
-    memory: {
-        currentMem: number;
-        allocatedMem: number;
-        accumulator: number[];
-    };
-}
-export declare function setupTresDevtools(ctx: TresContext): void;

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

@@ -1,90 +0,0 @@
-/**
- * Represents a tag that can be displayed in the inspector UI
- * @interface Tags
- */
-export interface Tags {
-    /** The text to display in the tag */
-    label: string;
-    /** The color of the text in hexadecimal format (e.g., 0xFFFFFF) */
-    textColor: number;
-    /** The background color of the tag in hexadecimal format (e.g., 0x000000) */
-    backgroundColor: number;
-    /** Optional tooltip text to show on hover */
-    tooltip?: string;
-}
-/**
- * Represents a node in the scene graph that can be displayed in the inspector
- * @interface SceneGraphObject
- */
-export interface SceneGraphObject {
-    /** Unique identifier for the node */
-    id: string;
-    /** Display name of the node */
-    label: string;
-    /** Array of child nodes */
-    children: SceneGraphObject[];
-    /** Array of tags associated with the node */
-    tags: Tags[];
-}
-/**
- * Represents memory usage statistics for Three.js resources
- * @interface MemoryStats
- */
-export interface MemoryStats {
-    /** Map of geometry names to their memory usage in bytes */
-    geometries: Map<string, number>;
-    /** Map of material names to their memory usage in bytes */
-    materials: Map<string, number>;
-    /** Map of texture names to their memory usage in bytes */
-    textures: Map<string, number>;
-}
-/**
- * Represents a property in the inspector state
- * @interface InspectorStateProperty
- */
-export interface InspectorStateProperty {
-    /** The name of the property */
-    key: string;
-    /** The value of the property */
-    value: unknown;
-    /** Whether the property can be edited in the inspector */
-    editable: boolean;
-}
-/**
- * Represents the state of an inspector panel
- * @interface InspectorState
- */
-export interface InspectorState {
-    /** Array of properties to display in the inspector */
-    object: InspectorStateProperty[];
-}
-/**
- * Represents the internal state of the devtools
- * @interface DevtoolsState
- */
-export interface DevtoolsState {
-    /** The current scene graph representation */
-    sceneGraph: SceneGraphObject | null;
-    /** Timestamp of the last update */
-    lastUpdate: number;
-    /** Minimum time between updates in milliseconds */
-    updateThreshold: number;
-    /** Current memory usage statistics */
-    memoryStats: MemoryStats;
-}
-/**
- * Represents a payload sent to or received from the devtools
- * @interface DevtoolsPayload
- */
-export interface DevtoolsPayload {
-    /** The ID of the inspector panel */
-    inspectorId: string;
-    /** The ID of the node being inspected */
-    nodeId: string;
-    /** Optional filter string for searching */
-    filter?: string;
-    /** Optional state to update */
-    state?: InspectorState;
-    /** Optional path to the property being edited */
-    path?: string[];
-}

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

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

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

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

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

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

package/dist/src/index.d.ts

@@ -1,25 +0,0 @@
-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';
-export * from './components';
-export * from './composables';
-export * from './core/catalogue';
-export * from './devtools';
-export * from './directives';
-export * from './types';
-export * from './utils/graph';
-export * from './utils/is/three';
-export * from './utils/is/tres';
-export * from './utils/logger';
-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 { dispose, normalizeColor, normalizeVectorFlexibleParam, templateCompilerOptions, };
-export type { VectorFlexibleParams } from './utils/normalize';

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

@@ -1,137 +0,0 @@
-import { DefineComponent, VNode, VNodeRef } from 'vue';
-import { TresContext } from '../composables/useTresContextProvider';
-import { PointerEventHandlers } from '../utils/pointerEvents';
-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 (...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>>;
-export type Mutable<P> = {
-    [K in keyof P]: P[K] | Readonly<P[K]>;
-};
-export type Args<T> = T extends ConstructorRepresentation ? ConstructorParameters<T> : any[];
-export interface TresCatalogue {
-    [name: string]: ConstructorRepresentation;
-}
-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;
-    attach?: AttachType;
-}
-interface TresBaseObject {
-    removeFromParent?: () => void;
-    dispose?: () => void;
-    [prop: string]: any;
-}
-export interface LocalState {
-    type: string;
-    root: TresContext;
-    memoizedProps: {
-        [key: string]: any;
-    };
-    objects: TresObject[];
-    parent: TresObject | null;
-    primitive?: boolean;
-    dispose?: DisposeType;
-    attach?: AttachType;
-    previousAttach: any;
-}
-export interface TresObject3D extends THREE.Object3D<THREE.Object3DEventMap> {
-    geometry?: THREE.BufferGeometry & TresBaseObject;
-    material?: THREE.Material & TresBaseObject;
-}
-export type TresObject = TresBaseObject & (TresObject3D | THREE.BufferGeometry | THREE.Material | THREE.Fog) & {
-    __tres?: LocalState;
-};
-/**
- * Union type covering all common Three.js material types
- * This provides better TypeScript intellisense and type checking
- * when accessing specific material properties
- */
-export type TresMaterial = THREE.MeshBasicMaterial | THREE.MeshStandardMaterial | THREE.MeshPhysicalMaterial | THREE.MeshLambertMaterial | THREE.MeshPhongMaterial | THREE.MeshToonMaterial | THREE.MeshNormalMaterial | THREE.MeshMatcapMaterial | THREE.MeshDepthMaterial | THREE.MeshDistanceMaterial | THREE.LineBasicMaterial | THREE.LineDashedMaterial | THREE.PointsMaterial | THREE.SpriteMaterial | THREE.ShaderMaterial | THREE.RawShaderMaterial | THREE.ShadowMaterial | THREE.Material;
-export type TresInstance = TresObject & {
-    __tres: LocalState;
-};
-export type TresPrimitive = TresInstance & {
-    object: TresInstance;
-    isPrimitive: true;
-};
-export interface TresScene extends THREE.Scene {
-    __tres: {
-        root: TresContext;
-    };
-}
-interface MathRepresentation {
-    set(...args: number[] | [THREE.ColorRepresentation]): any;
-}
-interface VectorRepresentation extends MathRepresentation {
-    setScalar(s: number): any;
-}
-export interface VectorCoordinates {
-    x: number;
-    y: number;
-    z: number;
-}
-export type MathType<T extends MathRepresentation | THREE.Euler> = T extends THREE.Color ? ConstructorParameters<typeof THREE.Color> | THREE.ColorRepresentation : T extends VectorRepresentation | THREE.Layers | THREE.Euler ? T | Parameters<T['set']> | number | VectorCoordinates : T | Parameters<T['set']>;
-type VectorLike<VectorClass extends THREE.Vector2 | THREE.Vector3 | THREE.Vector4> = VectorClass | Parameters<VectorClass['set']> | Readonly<Parameters<VectorClass['set']>> | Parameters<VectorClass['setScalar']>[0];
-export type TresVector2 = VectorLike<THREE.Vector2>;
-export type TresVector3 = VectorLike<THREE.Vector3>;
-export type TresVector4 = VectorLike<THREE.Vector4>;
-export type TresColor = ConstructorParameters<typeof THREE.Color> | THREE.Color | number | string;
-export type TresColorArray = typeof THREE.Color | [color: THREE.ColorRepresentation];
-export type TresLayers = THREE.Layers | Parameters<THREE.Layers['set']>[0];
-export type TresQuaternion = THREE.Quaternion | Parameters<THREE.Quaternion['set']>;
-export type TresEuler = THREE.Euler;
-export type TresControl = THREE.EventDispatcher & {
-    enabled: boolean;
-};
-export type TresContextWithClock = TresContext & {
-    delta: number;
-    elapsed: number;
-};
-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<PointerEventHandlers> : unknown;
-export type { TresPointerEvent } from '../utils/pointerEvents';
-export interface VueProps {
-    children?: VNode[];
-    ref?: VNodeRef;
-    key?: string | number | symbol;
-}
-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 = {
-    [K in keyof ThreeExports as Uncapitalize<K>]: ThreeExports[K] extends ConstructorRepresentation ? ThreeElement<ThreeExports[K]> : never;
-};
-export interface ThreeInstances extends ThreeInstancesImpl {
-    primitive: Omit<ThreeElement<any>, 'args'> & {
-        object: object;
-    };
-}
-type TresComponents = {
-    [K in keyof ThreeInstances as `Tres${Capitalize<string & K>}`]: DefineComponent<ThreeInstances[K]>;
-};
-declare module 'vue' {
-    interface GlobalComponents extends TresComponents {
-        primitive: DefineComponent<TresPrimitive>;
-    }
-}

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

@@ -1,6 +0,0 @@
-/**
- * Like Array.filter, but modifies the array in place.
- * @param array - Array to modify
- * @param callbackFn - A function called for each element of the array. It should return a truthy value to keep the element in the array.
- */
-export declare const filterInPlace: <T>(array: T[], callbackFn: (element: T, index: number) => unknown) => T[];

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

@@ -1,15 +0,0 @@
-import { EventHookOff, EventHookTrigger } from '@vueuse/core';
-export type Callback<T> = Parameters<EventHookOff<T>>[0];
-export type PriorityEventHookOn<T> = (fn: Callback<T>, priority?: number) => {
-    off: () => void;
-};
-export type PriorityEventHookOff<T> = EventHookOff<T>;
-export type PriorityEventHookTrigger<T> = EventHookTrigger<T>;
-export interface PriorityEventHook<T = any> {
-    on: PriorityEventHookOn<T>;
-    off: (fn: Callback<T>) => void;
-    trigger: PriorityEventHookTrigger<T>;
-    dispose: () => void;
-    count: number;
-}
-export declare function createPriorityEventHook<T>(): PriorityEventHook<T>;

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

@@ -1,15 +0,0 @@
-import { Mesh, Object3D, Scene } from 'three';
-import { TresMaterial, TresObject } from '../types';
-export interface TresObjectMap {
-    nodes: {
-        [name: string]: TresObject;
-    };
-    materials: {
-        [name: string]: TresMaterial;
-    };
-    meshes: {
-        [name: string]: Mesh;
-    };
-    scene?: Scene;
-}
-export declare function buildGraph(object: Object3D | TresObject): TresObjectMap;

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

@@ -1,19 +0,0 @@
-import { nodeOps } from 'src/core/nodeOps';
-import { AttachType, LocalState, TresInstance, TresObject, TresPrimitive } from 'src/types';
-import { Material } from 'three';
-import { TresContext } from '../composables/useTresContextProvider';
-export * from './logger';
-export declare function disposeMaterial(material: Material): void;
-export declare function disposeObject3D(object: TresObject): void;
-export declare function resolve(obj: Record<string, any>, key: string): {
-    target: Record<string, any>;
-    key: string;
-};
-export declare function attach(parent: TresInstance, child: TresInstance, type: AttachType): void;
-export declare function detach(parent: any, child: TresInstance, type: AttachType): void;
-export declare function prepareTresInstance<T extends TresObject>(obj: T, state: Partial<LocalState>, context: TresContext): TresInstance;
-export declare function invalidateInstance(instance: TresObject): void;
-export declare function setPrimitiveObject(newObject: TresObject, primitive: TresPrimitive, setTarget: (object: TresObject) => void, nodeOpsFns: Pick<ReturnType<typeof nodeOps>, 'patchProp' | 'insert' | 'remove'>, context: TresContext): boolean;
-export declare function unboxTresPrimitive<T>(maybePrimitive: T): T | TresInstance;
-export declare function doRemoveDetach(node: TresObject, context: TresContext): void;
-export declare function doRemoveDeregister(node: TresObject, context: TresContext): void;

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

@@ -1 +0,0 @@
-export declare const isHTMLTag: (key: string) => boolean;

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

@@ -1,4 +0,0 @@
-export * from './dom';
-export * from './three';
-export * from './tres';
-export * from './typed';