@tresjs/core 4.3.6 → 5.0.0-alpha.0

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

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

@@ -5,9 +5,12 @@ import { default as templateCompilerOptions } from './utils/template-compiler-op
 export * from './components';
 export * from './composables';
 export * from './core/catalogue';
-export * from './core/loop';
 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>;
 }

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

@@ -1,5 +1,6 @@
 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;
@@ -17,8 +18,6 @@ export type Args<T> = T extends ConstructorRepresentation ? ConstructorParameter
 export interface TresCatalogue {
     [name: string]: ConstructorRepresentation;
 }
-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.
@@ -40,9 +39,7 @@ interface TresBaseObject {
 }
 export interface LocalState {
     type: string;
-    eventCount: number;
     root: TresContext;
-    handlers: Partial<EventHandlers>;
     memoizedProps: {
         [key: string]: any;
     };
@@ -60,6 +57,12 @@ export interface TresObject3D extends THREE.Object3D<THREE.Object3DEventMap> {
 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;
 };
@@ -72,69 +75,6 @@ export interface TresScene extends THREE.Scene {
         root: TresContext;
     };
 }
-export interface Intersection extends THREE.Intersection {
-    /** The event source (the object which registered the handler) */
-    eventObject: TresObject;
-}
-export interface IntersectionEvent<TSourceEvent> extends Intersection {
-    /** The event source (the object which registered the handler) */
-    eventObject: TresObject;
-    /** An array of intersections */
-    intersections: Intersection[];
-    /** vec3.set(pointer.x, pointer.y, 0).unproject(camera) */
-    unprojectedPoint: THREE.Vector3;
-    /** Normalized event coordinates */
-    pointer: THREE.Vector2;
-    /** Delta between first click and this event */
-    delta: number;
-    /** The ray that pierced it */
-    ray: THREE.Ray;
-    /** The camera that was used by the raycaster */
-    camera: TresCamera;
-    /** stopPropagation will stop underlying handlers from firing */
-    stopPropagation: () => void;
-    /** The original host event */
-    nativeEvent: TSourceEvent;
-    /** If the event was stopped by calling stopPropagation */
-    stopped: boolean;
-}
-export type ThreeEvent<TEvent> = IntersectionEvent<TEvent> & Properties<TEvent>;
-export type DomEvent = PointerEvent | MouseEvent | WheelEvent;
-export interface TresEvent {
-    eventObject: TresObject;
-    event: DomEvent;
-    stopPropagation: () => void;
-    stopPropagating: boolean;
-    intersections: Intersection[];
-    intersects: Intersection[];
-}
-export interface Events {
-    onClick: EventListener;
-    onContextMenu: EventListener;
-    onDoubleClick: EventListener;
-    onWheel: EventListener;
-    onPointerDown: EventListener;
-    onPointerUp: EventListener;
-    onPointerLeave: EventListener;
-    onPointerMove: EventListener;
-    onPointerCancel: EventListener;
-    onLostPointerCapture: EventListener;
-}
-export interface EventHandlers {
-    onClick?: (event: ThreeEvent<MouseEvent>) => void;
-    onContextMenu?: (event: ThreeEvent<MouseEvent>) => void;
-    onDoubleClick?: (event: ThreeEvent<MouseEvent>) => void;
-    onPointerUp?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerDown?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerOver?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerOut?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerEnter?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerLeave?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerMove?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerMissed?: (event: MouseEvent) => void;
-    onPointerCancel?: (event: ThreeEvent<PointerEvent>) => void;
-    onWheel?: (event: ThreeEvent<WheelEvent>) => void;
-}
 interface MathRepresentation {
     set(...args: number[] | [THREE.ColorRepresentation]): any;
 }
@@ -159,13 +99,18 @@ 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<EventHandlers> : unknown;
+type EventProps<P> = P extends RaycastableRepresentation ? Partial<PointerEventHandlers> : unknown;
+export type { TresPointerEvent } from '../utils/pointerEvents';
 export interface VueProps {
     children?: VNode[];
     ref?: VNodeRef;
@@ -190,4 +135,3 @@ declare module 'vue' {
         primitive: DefineComponent<TresPrimitive>;
     }
 }
-export {};

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

@@ -0,0 +1,6 @@
+/**
+ * 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 +1,13 @@
-import { EventHookOff, IsAny } from '@vueuse/core';
-export type Callback<T> = IsAny<T> extends true ? (param: any) => void : ([
-    T
-] extends [void] ? () => void : (param: T) => void);
+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 = any> = (param?: T) => void;
+export type PriorityEventHookTrigger<T> = EventHookTrigger<T>;
 export interface PriorityEventHook<T = any> {
     on: PriorityEventHookOn<T>;
-    off: EventHookOff<T>;
+    off: (fn: Callback<T>) => void;
     trigger: PriorityEventHookTrigger<T>;
     dispose: () => void;
     count: number;

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

@@ -0,0 +1,15 @@
+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,37 +1,10 @@
 import { nodeOps } from 'src/core/nodeOps';
 import { AttachType, LocalState, TresInstance, TresObject, TresPrimitive } from 'src/types';
-import { Material, Mesh, MeshBasicMaterial, Scene, Vector3 } from 'three';
+import { Material } 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;
-export declare function isDOMElement(obj: any): obj is HTMLElement;
-export declare function kebabToCamel(str: string): string;
-export declare function hyphenate(str: string): string;
-export declare function makeMap(str: string, expectsLowerCase?: boolean): (key: string) => boolean;
-export declare const uniqueBy: <T, K>(array: T[], iteratee: (value: T) => K) => T[];
-export declare const get: <T>(obj: any, path: string | string[]) => T | undefined;
-export declare const set: (obj: any, path: string | string[], value: any) => void;
-export declare function deepEqual(a: any, b: any): boolean;
-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 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: TresObject): Mesh;
-export declare function extractBindingPosition(binding: any): Vector3;
+export * from './logger';
 export declare function disposeMaterial(material: Material): void;
 export declare function disposeObject3D(object: TresObject): void;
-/**
- * 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 function filterInPlace<T>(array: T[], callbackFn: (element: T, index: number) => unknown): T[];
 export declare function resolve(obj: Record<string, any>, key: string): {
     target: Record<string, any>;
     key: string;
@@ -40,11 +13,6 @@ export declare function attach(parent: TresInstance, child: TresInstance, type:
 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 noop(fn: string): any;
-export declare function setPixelRatio(renderer: {
-    setPixelRatio?: (dpr: number) => void;
-    getPixelRatio?: () => number;
-}, systemDpr: number, userDpr?: number | [number, number]): 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;

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

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

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

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

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

@@ -0,0 +1,162 @@
+import { BufferGeometry, Camera, Color, ColorRepresentation, Fog, Group, Light, Material, Mesh, Object3D, OrthographicCamera, PerspectiveCamera, Scene, Layers } from 'three';
+/**
+ * Type guard to check if a value is a Three.js Object3D
+ * @param value - The value to check
+ * @returns True if the value is a Three.js Object3D instance, false otherwise
+ * @example
+ * ```ts
+ * const value = new THREE.Object3D()
+ * if (isObject3D(value)) {
+ *   // TypeScript knows value is Object3D here
+ *   value.position // OK
+ *   value.rotation // OK
+ *   value.scale // OK
+ * }
+ * ```
+ */
+export declare const isObject3D: (value: unknown) => value is Object3D<import('three').Object3DEventMap>;
+/**
+ * Type guard to check if a value is a Three.js Mesh
+ * @param value - The value to check
+ * @returns True if the value is a Three.js Mesh instance, false otherwise
+ * @example
+ * ```ts
+ * const value = new THREE.Mesh()
+ * if (isMesh(value)) {
+ *   // TypeScript knows value is Mesh here
+ *   value.geometry // OK
+ */
+export declare const isMesh: (value: unknown) => value is Mesh<BufferGeometry<import('three').NormalBufferAttributes>, Material | Material[], import('three').Object3DEventMap>;
+/**
+ * Type guard to check if a value is a Three.js Camera
+ * @param value - The value to check
+ * @returns True if the value is a Three.js Camera instance, false otherwise
+ * @example
+ * ```ts
+ * const value = new THREE.PerspectiveCamera()
+ * if (isCamera(value)) {
+ *   // TypeScript knows value is Camera here
+ *   value.fov // OK
+ *   value.near // OK
+ *   value.far // OK
+ * }
+ * ```
+ */
+export declare const isCamera: (value: unknown) => value is Camera;
+/**
+ * Type guard to check if a value is a Three.js OrthographicCamera
+ * @param value - The value to check
+ * @returns True if the value is a Three.js OrthographicCamera instance, false otherwise
+ */
+export declare const isOrthographicCamera: (value: unknown) => value is OrthographicCamera;
+/**
+ * Type guard to check if a value is a Three.js PerspectiveCamera
+ * @param value - The value to check
+ * @returns True if the value is a Three.js PerspectiveCamera instance, false otherwise
+ */
+export declare const isPerspectiveCamera: (value: unknown) => value is PerspectiveCamera;
+/**
+ * Type guard to check if a value is a Three.js Color
+ * @param value - The value to check
+ * @returns True if the value is a Three.js Color instance, false otherwise
+ */
+export declare const isColor: (value: unknown) => value is Color;
+/**
+ * Type guard to check if a value is a Three.js ColorRepresentation
+ * @param value - The value to check
+ * @returns True if the value is a Three.js ColorRepresentation instance, false otherwise
+ */
+export declare const isColorRepresentation: (value: unknown) => value is ColorRepresentation;
+/**
+ * Type guard to check if a value is a Three.js Layers
+ * @param value - The value to check
+ * @returns True if the value is a Three.js Layers instance, false otherwise
+ */
+export declare const isLayers: (value: unknown) => value is Layers;
+/**
+ * Type guard to check if a value is a Three.js BufferGeometry
+ * @param value - The value to check
+ * @returns True if the value is a Three.js BufferGeometry instance, false otherwise
+ * @example
+ * ```ts
+ * const value = new THREE.BufferGeometry()
+ * if (isBufferGeometry(value)) {
+ *   // TypeScript knows value is BufferGeometry here
+ *   value.attributes // OK
+ *   value.index // OK
+ *   value.computeVertexNormals() // OK
+ * }
+ * ```
+ */
+export declare const isBufferGeometry: (value: unknown) => value is BufferGeometry<import('three').NormalBufferAttributes>;
+/**
+ * Type guard to check if a value is a Three.js Material
+ * @param value - The value to check
+ * @returns True if the value is a Three.js Material instance, false otherwise
+ * @example
+ * ```ts
+ * const value = new THREE.MeshStandardMaterial()
+ * if (isMaterial(value)) {
+ *   // TypeScript knows value is Material here
+ *   value.color // OK
+ *   value.metalness // OK
+ *   value.roughness // OK
+ * }
+ * ```
+ */
+export declare const isMaterial: (value: unknown) => value is Material;
+/**
+ * Type guard to check if a value is a Three.js Light
+ * @param value - The value to check
+ * @returns True if the value is a Three.js Light instance, false otherwise
+ * @example
+ * ```ts
+ * const value = new THREE.DirectionalLight()
+ * if (isLight(value)) {
+ *   // TypeScript knows value is Light here
+ *   value.intensity // OK
+ *   value.color // OK
+ *   value.position // OK
+ * }
+ * ```
+ */
+export declare const isLight: (value: unknown) => value is Light<import('three').LightShadow<Camera> | undefined>;
+/**
+ * Type guard to check if a value is a Three.js Fog
+ * @param value - The value to check
+ * @returns True if the value is a Three.js Fog instance, false otherwise
+ * @example
+ * ```ts
+ * const value = new THREE.Fog(0x000000, 1, 1000)
+ * if (isFog(value)) {
+ *   // TypeScript knows value is Fog here
+ *   value.color // OK
+ *   value.near // OK
+ *   value.far // OK
+ * }
+ * ```
+ */
+export declare const isFog: (value: unknown) => value is Fog;
+/**
+ * Type guard to check if a value is a Three.js Scene
+ * @param value - The value to check
+ * @returns True if the value is a Three.js Scene instance, false otherwise
+ * @example
+ * ```ts
+ * const value = new THREE.Scene()
+ * if (isScene(value)) {
+ *   // TypeScript knows value is Scene here
+ *   value.children // OK
+ *   value.add(new THREE.Object3D()) // OK
+ *   value.remove(new THREE.Object3D()) // OK
+ * }
+ * ```
+ */
+export declare const isScene: (value: unknown) => value is Scene;
+/**
+ * Type guard to check if a value is a Three.js Group
+ * @param value - The value to check
+ * @returns True if the value is a Three.js Group instance, false otherwise
+ * ```
+ */
+export declare const isGroup: (value: unknown) => value is Group<import('three').Object3DEventMap>;

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

@@ -0,0 +1,70 @@
+import { TresCamera, TresInstance, TresObject, TresPrimitive } from 'src/types';
+interface VectorLike {
+    set: (...args: any[]) => void;
+    constructor?: (...args: any[]) => any;
+}
+export declare const isVectorLike: (value: unknown) => value is VectorLike;
+interface Copyable {
+    copy: (...args: any[]) => void;
+    constructor?: (...args: any[]) => any;
+}
+export declare const isCopyable: (value: unknown) => value is Copyable;
+interface ClassInstance {
+    constructor?: (...args: any[]) => any;
+}
+export declare const isClassInstance: (object: unknown) => object is ClassInstance;
+/**
+ * Type guard to check if a value is a TresCamera
+ * @param value - The value to check
+ * @returns True if the value is a TresCamera instance, false otherwise
+ */
+export declare const isTresCamera: (value: unknown) => value is TresCamera;
+/**
+ * Type guard to check if a value is a TresObject
+ * @param value - The value to check
+ * @returns True if the value is a TresObject (Object3D | BufferGeometry | Material | Fog), false otherwise
+ * @example
+ * ```ts
+ * const value = new THREE.Mesh()
+ * if (isTresObject(value)) {
+ *   // TypeScript knows value is TresObject here
+ *   // You can use common properties and methods shared by all TresObjects
+ * }
+ * ```
+ * @remarks
+ * TresObject is a union type that represents the core Three.js objects that can be used in TresJS.
+ * This includes Object3D, BufferGeometry, Material, and Fog instances.
+ */
+export declare const isTresObject: (value: unknown) => value is TresObject;
+/**
+ * Type guard to check if a value is a TresPrimitive
+ * @param value - The value to check
+ * @returns True if the value is a TresPrimitive instance, false otherwise
+ * @example
+ * ```ts
+ * const value = { isPrimitive: true }
+ * if (isTresPrimitive(value)) {
+ *   // TypeScript knows value is TresPrimitive here
+ *   // You can use properties and methods specific to TresPrimitives
+ * }
+ * ```
+ * @remarks
+ * TresPrimitive is a special type in TresJS that represents primitive objects
+ * that can be used directly in the scene without needing to be wrapped in a Three.js object.
+ */
+export declare const isTresPrimitive: (value: unknown) => value is TresPrimitive;
+/**
+ * Type guard to check if a value is a TresInstance (has __tres property)
+ * @param value - The value to check
+ * @returns True if the value is a TresInstance (has __tres property), false otherwise
+ * @example
+ * ```ts
+ * const value = new THREE.Mesh()
+ * if (isTresInstance(value)) {
+ *   // TypeScript knows value is TresInstance here
+ *   // You can safely access value.__tres
+ * }
+ * ```
+ */
+export declare const isTresInstance: (value: unknown) => value is TresInstance;
+export {};

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

@@ -0,0 +1 @@
+export { isBoolean, isEqual, isFunction, isNumber, isObject, isString, isUndefined } from 'radashi';

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

@@ -0,0 +1 @@
+export declare const createTypeGuard: <T>(property: keyof T) => (value: unknown) => value is T;

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

@@ -0,0 +1,25 @@
+/**
+ * Logger utility for TresJS
+ * @module logger
+ */
+export declare const isProd: boolean;
+type OneOrMore<T> = {
+    0: T;
+} & Array<T>;
+/**
+ * Logs an error message with the TresJS prefix
+ * @param args - Arguments to log
+ */
+export declare function logError(...args: OneOrMore<any>): void;
+/**
+ * Logs a warning message with the TresJS prefix
+ * @param args - Arguments to log
+ */
+export declare function logWarning(...args: OneOrMore<any>): void;
+/**
+ * Logs a message with the TresJS prefix (only in development mode)
+ * @param name - Name of the message
+ * @param value - Value to log
+ */
+export declare function logMessage(name: string, value: any): void;
+export {};

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

@@ -0,0 +1,9 @@
+/**
+ * Make a map and return a function for checking if a key
+ * is in that map.
+ * IMPORTANT: all calls of this function must be prefixed with
+ * \/\*#\_\_PURE\_\_\*\/
+ * So that rollup can tree-shake them if necessary.
+ */
+/*! #__NO_SIDE_EFFECTS__ */
+export declare function makeMap(str: string): (key: string) => boolean;

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

@@ -1,6 +1,7 @@
 import { Scene } from 'three';
 import { TresObject } from './../types';
 export declare function calculateMemoryUsage(object: TresObject | Scene): number;
+export declare function boundedPush<T>(arr: T[], value: T, max: number): void;
 export declare function bytesToKB(bytes: number): string;
 export declare function bytesToMB(bytes: number): string;
 export declare function bytesToGB(bytes: number): string;

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

@@ -0,0 +1,10 @@
+import { PointerEvent } from '@pmndrs/pointer-events';
+export declare const supportedPointerEvents: readonly ["onClick", "onContextmenu", "onPointermove", "onPointerenter", "onPointerleave", "onPointerover", "onPointerout", "onDblclick", "onPointerdown", "onPointerup", "onPointercancel", "onLostpointercapture", "onWheel"];
+export type SupportedVuePointerEvent = typeof supportedPointerEvents[number];
+export type TresPointerEventName = 'click' | 'contextmenu' | 'pointermove' | 'pointerenter' | 'pointerleave' | 'pointerover' | 'pointerout' | 'dblclick' | 'pointerdown' | 'pointerup' | 'pointercancel' | 'lostpointercapture' | 'wheel';
+export declare const pointerEventsMapVueToThree: Record<SupportedVuePointerEvent, TresPointerEventName>;
+export declare const isSupportedPointerEvent: (event: string) => event is SupportedVuePointerEvent;
+export type TresPointerEvent = PointerEvent<MouseEvent>;
+export type PointerEventHandlers = {
+    [key in SupportedVuePointerEvent]: (event: TresPointerEvent) => void;
+};

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

@@ -0,0 +1 @@
+export { camel } from 'radashi';

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

@@ -0,0 +1,9 @@
+import { Object3D } from 'three';
+/**
+ * Recursively searches for an Object3D with the specified UUID within a Three.js scene graph.
+ *
+ * @param node - The root Object3D to start searching from
+ * @param uuid - The unique identifier of the object to find
+ * @returns The Object3D with the matching UUID, or undefined if not found
+ */
+export declare const getObjectByUuid: (node: Object3D, uuid: string) => Object3D | undefined;