@tresjs/core 5.0.0-next.5 → 5.0.0-rc.0

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

@@ -25,39 +25,39 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
     context: import('vue').ShallowRef<TresContext | null, TresContext | null>;
     dispose: () => void;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    click: (event: PointerEvent<MouseEvent>) => any;
-    contextmenu: (event: PointerEvent<MouseEvent>) => any;
+    render: (context: TresContext) => any;
     pointermove: (event: PointerEvent<MouseEvent>) => any;
+    pointercancel: (event: PointerEvent<MouseEvent>) => any;
+    pointerdown: (event: PointerEvent<MouseEvent>) => any;
+    pointerup: (event: PointerEvent<MouseEvent>) => any;
     pointerenter: (event: PointerEvent<MouseEvent>) => any;
     pointerleave: (event: PointerEvent<MouseEvent>) => any;
     pointerover: (event: PointerEvent<MouseEvent>) => any;
     pointerout: (event: PointerEvent<MouseEvent>) => any;
+    click: (event: PointerEvent<MouseEvent>) => any;
     dblclick: (event: PointerEvent<MouseEvent>) => any;
-    pointerdown: (event: PointerEvent<MouseEvent>) => any;
-    pointerup: (event: PointerEvent<MouseEvent>) => any;
-    pointercancel: (event: PointerEvent<MouseEvent>) => any;
-    lostpointercapture: (event: PointerEvent<MouseEvent>) => any;
+    contextmenu: (event: PointerEvent<MouseEvent>) => any;
     wheel: (event: PointerEvent<MouseEvent>) => any;
-    render: (context: TresContext) => any;
+    lostpointercapture: (event: PointerEvent<MouseEvent>) => any;
     loop: (context: TresContextWithClock) => any;
     ready: (context: TresContext) => any;
     pointermissed: (event: PointerEvent<MouseEvent>) => any;
     beforeLoop: (context: TresContextWithClock) => any;
 }, string, import('vue').PublicProps, Readonly<TresCanvasProps> & Readonly<{
-    onClick?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
-    onContextmenu?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
+    onRender?: ((context: TresContext) => any) | undefined;
     onPointermove?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
+    onPointercancel?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
+    onPointerdown?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
+    onPointerup?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
     onPointerenter?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
     onPointerleave?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
     onPointerover?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
     onPointerout?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
+    onClick?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
     onDblclick?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
-    onPointerdown?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
-    onPointerup?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
-    onPointercancel?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
-    onLostpointercapture?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
+    onContextmenu?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
     onWheel?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
-    onRender?: ((context: TresContext) => any) | undefined;
+    onLostpointercapture?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
     onLoop?: ((context: TresContextWithClock) => any) | undefined;
     onReady?: ((context: TresContext) => any) | undefined;
     onPointermissed?: ((event: PointerEvent<MouseEvent>) => any) | undefined;

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

@@ -5,5 +5,5 @@ export * from './useLoader';
 export * from './useLoop';
 export * from './useRenderer/useRendererManager';
 export * from './useTres';
-export * from './useTresContextProvider';
+export { type TresContext, useTresContext, useTresContextProvider } from './useTresContextProvider';
 export { UseLoader };

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

@@ -2,17 +2,13 @@ export interface RafLoopContext {
     delta: number;
     elapsed: number;
 }
-type LoopFunction = (notifySuccess: () => void) => void;
 /**
- * @param defaultFunction the default function that is called before after the after event hook is triggered and after the before is triggered.
- * @param notifySuccess a callback that should be called to indicate a successfull cycle.
+ * @param cycleFn the function that is called before the after event hook is triggered and after the before event hook is triggered.
  */
-export declare const useCreateRafLoop: (defaultFunction: LoopFunction, notifySuccess: () => void) => {
+export declare const useCreateRafLoop: (cycleFn: () => void) => {
     start: () => void;
     stop: () => void;
     isActive: Readonly<import('vue').ShallowRef<boolean>>;
     onBeforeLoop: import('@vueuse/core').EventHookOn<RafLoopContext>;
     onLoop: import('@vueuse/core').EventHookOn<RafLoopContext>;
-    replaceLoopFunction: (fn: LoopFunction) => void;
 };
-export {};

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

@@ -1,3 +1,3 @@
 import { MaybeRef } from '@vueuse/core';
 import { TresObject } from '../../types';
-export declare function useGraph(object: MaybeRef<TresObject>): import('vue').ComputedRef<import('../..').TresObjectMap>;
+export declare const useGraph: (object: MaybeRef<TresObject | undefined>) => import('vue').ComputedRef<import('../..').TresObjectMap | undefined>;

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

@@ -5,7 +5,7 @@ declare const _default: <T extends TresObjectMap>(__VLS_props: NonNullable<Await
     props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
         readonly onLoaded?: ((result: T) => any) | undefined;
         readonly onError?: ((error: unknown) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onLoaded" | "onError"> & {
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onError" | "onLoaded"> & {
         /**
          * The THREE.js loader to use
          */

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

@@ -10,5 +10,5 @@ export declare const useLoop: () => {
     isActive: Readonly<import('vue').ShallowRef<boolean>>;
     onBeforeRender: import('../../utils/createPriorityEventHook').PriorityEventHookOn<LoopContext>;
     onRender: import('../../utils/createPriorityEventHook').PriorityEventHookOn<LoopContext>;
-    render: (fn: (notifySuccess: () => void) => void) => void;
+    render: (fn: import('..').RenderFunction) => void;
 };

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

@@ -0,0 +1,4 @@
+export declare const setPixelRatio: (renderer: {
+    setPixelRatio?: (dpr: number) => void;
+    getPixelRatio?: () => number;
+}, systemDpr: number, userDpr?: number | [number, number]) => void;

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

@@ -11,6 +11,7 @@ import { TresScene } from '../../types';
  * If set to 'always', the scene will be rendered every frame
  */
 export type RenderMode = 'always' | 'on-demand' | 'manual';
+export type RenderFunction = (notifySuccess: () => void) => void;
 export type TresRenderer = WebGLRenderer | Renderer;
 export interface RendererOptions {
     /**
@@ -180,7 +181,6 @@ export declare function useRendererManager({ scene, canvas, options, contextPart
         isActive: Readonly<ShallowRef<boolean>>;
         onBeforeLoop: import('@vueuse/core').EventHookOn<import('../useCreateRafLoop').RafLoopContext>;
         onLoop: import('@vueuse/core').EventHookOn<import('../useCreateRafLoop').RafLoopContext>;
-        replaceLoopFunction: (fn: (notifySuccess: () => void) => void) => void;
     };
     instance: TresRenderer;
     advance: () => void;
@@ -189,5 +189,6 @@ export declare function useRendererManager({ scene, canvas, options, contextPart
     invalidate: (amountOfFramesToInvalidate?: number) => void;
     canBeInvalidated: import('vue').ComputedRef<boolean>;
     mode: "always" | "on-demand" | "manual" | undefined;
+    replaceRenderFunction: (fn: RenderFunction) => void;
 };
 export type UseRendererManagerReturn = ReturnType<typeof useRendererManager>;

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

@@ -13,10 +13,12 @@ export interface TresContext {
     renderer: UseRendererManagerReturn;
     events: ReturnType<typeof useEventManager>;
 }
-export declare function useTresContextProvider({ scene, canvas, windowSize, rendererOptions, }: {
+export declare const INJECTION_KEY = "useTres";
+declare const useTresContextProvider: (args_0: {
     scene: TresScene;
     canvas: MaybeRef<HTMLCanvasElement>;
     windowSize: MaybeRefOrGetter<boolean>;
     rendererOptions: RendererOptions;
-}): TresContext;
-export declare function useTresContext(): TresContext;
+}) => TresContext;
+declare const useTresContext: () => TresContext;
+export { useTresContext, useTresContextProvider };

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

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

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

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 './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>;

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

@@ -1,4 +1,4 @@
-import { Mesh, Scene } from 'three';
+import { Mesh, Object3D, Scene } from 'three';
 import { TresMaterial, TresObject } from '../types';
 export interface TresObjectMap {
     nodes: {
@@ -12,4 +12,4 @@ export interface TresObjectMap {
     };
     scene?: Scene;
 }
-export declare function buildGraph(object: TresObject): TresObjectMap;
+export declare function buildGraph(object: Object3D | TresObject): TresObjectMap;

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

@@ -1,34 +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 * from './logger';
-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;
-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 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;
@@ -37,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, import('three').BufferGeometryEventMap>, 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, import('three').BufferGeometryEventMap>;
+/**
+ * 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/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/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;