@tresjs/core 5.1.0 → 5.1.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tresjs/core",
   "type": "module",
-  "version": "5.1.0",
+  "version": "5.1.1",
   "description": "Declarative ThreeJS using Vue Components",
   "author": "Alvaro Saburido <hola@alvarosaburido.dev> (https://github.com/alvarosabu/)",
   "license": "MIT",
@@ -19,27 +19,20 @@
   ],
   "sideEffects": false,
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/tres.js",
-      "default": "./dist/tres.js"
-    },
-    "./components": {
-      "types": "./dist/src/components/index.d.ts"
-    },
-    "./composables": {
-      "types": "./dist/src/composables/index.d.ts"
-    },
-    "./types": {
-      "types": "./dist/src/types/index.d.ts"
-    },
-    "./utils": {
-      "types": "./dist/src/utils/index.d.ts"
-    },
-    "./*": "./*"
+    ".": "./dist/tres.js",
+    "./template-compiler-options": "./dist/template-compiler-options.mjs",
+    "./package.json": "./package.json"
   },
+  "main": "./dist/tres.js",
   "module": "./dist/tres.js",
-  "types": "./dist/index.d.ts",
+  "types": "./dist/tres.d.ts",
+  "typesVersions": {
+    "*": {
+      "template-compiler-options": [
+        "dist/template-compiler-options.d.mts"
+      ]
+    }
+  },
   "files": [
     "*.d.ts",
     "dist"
@@ -55,7 +48,8 @@
     "@pmndrs/pointer-events": "^6.6.17",
     "@vue/devtools-api": "^7.7.2",
     "@vueuse/core": "^13.9.0",
-    "radashi": "^12.6.2"
+    "radashi": "^12.6.2",
+    "typescript": "^5.8.3"
   },
   "devDependencies": {
     "@types/three": "^0.180.0",
@@ -74,15 +68,16 @@
     "rollup-plugin-copy": "^3.5.0",
     "rollup-plugin-visualizer": "^6.0.3",
     "three": "^0.180.0",
-    "vite": "^7.1.6",
+    "tsdown": "0.16.1",
+    "vite": "^7.1.9",
     "vite-plugin-banner": "^0.8.1",
     "vite-plugin-dts": "4.5.4",
     "vite-plugin-inspect": "^11.3.3",
     "vitest": "3.2.4",
-    "vue": "^3.5.21",
+    "vue": "^3.5.22",
     "vue-demi": "^0.14.10",
-    "vue-tsc": "^3.0.7",
-    "@tresjs/eslint-config": "1.5.0"
+    "vue-tsc": "^3.1.1",
+    "@tresjs/eslint-config": "1.5.1"
   },
   "nx": {
     "implicitDependencies": [
@@ -90,7 +85,7 @@
     ]
   },
   "scripts": {
-    "build": "vite build",
+    "build": "tsdown",
     "test": "vitest",
     "test:ci": "vitest run",
     "test:ui": "vitest --ui --coverage.enabled=true",

package/components.d.ts

@@ -1 +0,0 @@
-export * from '../../dist/src/components/index.js'

package/composables.d.ts

@@ -1 +0,0 @@
-export * from '../../dist/src/composables/index.js'

package/dist/index.d.ts

@@ -1,6 +0,0 @@
-export * from './src/index'
-export {}
-import Tres from './src/index'
-export default Tres
-export * from './src/index'
-export {}

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

@@ -1,94 +0,0 @@
-import { TresCamera, TresContextWithClock } from '../types/';
-import { PointerEvent } from '@pmndrs/pointer-events';
-import { RendererOptions, TresContext } from '../composables';
-import * as THREE from 'three';
-export interface TresCanvasProps extends RendererOptions {
-    /**
-     * Custom camera instance to use as main camera
-     * If not provided, a default PerspectiveCamera will be created
-     */
-    camera?: TresCamera;
-    /**
-     * Whether the canvas should be sized to the window
-     * When true, canvas will be fixed positioned and full viewport size
-     * @default false
-     */
-    windowSize?: boolean;
-    /**
-     * Whether to enable the provide/inject bridge between Vue and TresJS
-     * When true, Vue's provide/inject will work across the TresJS boundary
-     * @default true
-     */
-    enableProvideBridge?: boolean;
-}
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<TresCanvasProps, {
-    context: import('vue').ShallowRef<TresContext | null, TresContext | null>;
-    dispose: () => void;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    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;
-    contextmenu: (event: PointerEvent<MouseEvent>) => any;
-    wheel: (event: PointerEvent<MouseEvent>) => 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<{
-    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;
-    onContextmenu?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
-    onWheel?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
-    onLostpointercapture?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
-    onLoop?: ((context: TresContextWithClock) => any) | undefined;
-    onReady?: ((context: TresContext) => any) | undefined;
-    onPointermissed?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
-    onBeforeLoop?: ((context: TresContextWithClock) => any) | undefined;
-}>, {
-    antialias: boolean;
-    stencil: boolean;
-    depth: boolean;
-    logarithmicDepthBuffer: boolean;
-    preserveDrawingBuffer: boolean;
-    alpha: boolean;
-    failIfMajorPerformanceCaveat: boolean;
-    clearColor: THREE.ColorRepresentation;
-    clearAlpha: number;
-    shadows: boolean;
-    toneMapping: THREE.ToneMapping;
-    shadowMapType: THREE.ShadowMapType;
-    useLegacyLights: boolean;
-    renderMode: "always" | "on-demand" | "manual";
-    windowSize: boolean;
-    enableProvideBridge: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
-    canvasRef: HTMLCanvasElement;
-}, HTMLCanvasElement>, Readonly<{
-    default: () => any;
-}> & {
-    default: () => any;
-}>;
-export default _default;
-type __VLS_WithTemplateSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};

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

@@ -1,2 +0,0 @@
-import { default as TresCanvas } from './TresCanvas.vue';
-export { TresCanvas };

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

@@ -1,9 +0,0 @@
-import { default as UseLoader } from './useLoader/component.vue';
-export * from './useCamera';
-export * from './useGraph';
-export * from './useLoader';
-export * from './useLoop';
-export * from './useRenderer/useRendererManager';
-export * from './useTres';
-export { type TresContext, useTresContext, useTresContextProvider } from './useTresContextProvider';
-export { UseLoader };

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

@@ -1,43 +0,0 @@
-import { TresContext } from '../useTresContextProvider';
-import { ComputedRef, Ref } from 'vue';
-import { TresCamera } from '../../types';
-/**
- * Interface for the return value of the useCamera composable
- */
-export interface UseCameraReturn {
-    activeCamera: ComputedRef<TresCamera>;
-    /**
-     * The list of cameras
-     */
-    cameras: Ref<TresCamera[]>;
-    /**
-     * Register a camera
-     * @param camera - The camera to register
-     * @param active - Whether to set the camera as active
-     */
-    registerCamera: (camera: TresCamera, active?: boolean) => void;
-    /**
-     * Deregister a camera
-     * @param camera - The camera to deregister
-     */
-    deregisterCamera: (camera: TresCamera) => void;
-    /**
-     * Set the active camera
-     * @param cameraOrUuid - The camera or its UUID to set as active
-     */
-    setActiveCamera: (cameraOrUuid: string | TresCamera) => void;
-}
-/**
- * Interface for the parameters of the useCamera composable
- */
-interface UseCameraParams {
-    sizes: TresContext['sizes'];
-}
-/**
- * Composable for managing cameras in a Three.js scene
- * @param params - The parameters for the composable
- * @param params.sizes - The sizes object containing window dimensions
- * @returns The camera management functions and state
- */
-export declare const useCameraManager: ({ sizes }: UseCameraParams) => UseCameraReturn;
-export {};

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

@@ -1,14 +0,0 @@
-export interface RafLoopContext {
-    delta: number;
-    elapsed: number;
-}
-/**
- * @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: (cycleFn: () => void) => {
-    start: () => void;
-    stop: () => void;
-    isActive: Readonly<import('vue').ShallowRef<boolean>>;
-    onBeforeLoop: import('@vueuse/core').EventHookOn<RafLoopContext>;
-    onLoop: import('@vueuse/core').EventHookOn<RafLoopContext>;
-};

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

@@ -1,10 +0,0 @@
-import { PointerEvent, PointerEventsMap } from '@pmndrs/pointer-events';
-import { Event, Object3D, Object3DEventMap } from 'three';
-import { MaybeRef } from 'vue';
-import { TresContext } from '../useTresContextProvider';
-export declare function useEventManager({ canvas, contextParts: { scene, camera, renderer }, }: {
-    canvas: MaybeRef<HTMLCanvasElement>;
-    contextParts: Pick<TresContext, 'scene' | 'camera' | 'renderer'>;
-}): {
-    onPointerMissed: import('@vueuse/core').EventHookOn<PointerEvent<MouseEvent> & Event<"click", Object3D<Object3DEventMap & PointerEventsMap>>>;
-};

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

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

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

@@ -1,38 +0,0 @@
-import { LoadingManager } from 'three';
-import { LoaderProto } from './index';
-import { TresObjectMap } from '../../utils/graph';
-declare const _default: <T extends TresObjectMap>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    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>, "onError" | "onLoaded"> & {
-        /**
-         * The THREE.js loader to use
-         */
-        loader: LoaderProto<T>;
-        /**
-         * Path to resource
-         */
-        path: string;
-        /**
-         * Optional THREE.js LoadingManager
-         */
-        manager?: LoadingManager;
-    } & Partial<{}>> & import('vue').PublicProps;
-    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
-    attrs: any;
-    slots: {
-        default?(_: {
-            state: import('vue').UnwrapRef<T>;
-            isLoading: boolean;
-            error: unknown;
-        }): any;
-    };
-    emit: ((evt: "loaded", result: T) => void) & ((evt: "error", error: unknown) => void);
-}>) => import('vue').VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
-};
-export default _default;
-type __VLS_PrettifyLocal<T> = {
-    [K in keyof T]: T[K];
-} & {};

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

@@ -1,51 +0,0 @@
-import { UseAsyncStateOptions, UseAsyncStateReturn } from '@vueuse/core';
-import { Loader, LoadingManager } from 'three';
-import { MaybeRef } from 'vue';
-export interface LoaderMethods {
-    setDRACOLoader: (dracoLoader: any) => void;
-    setMeshoptDecoder: (meshoptDecoder: any) => void;
-    setKTX2Loader: (ktx2Loader: any) => void;
-}
-export type TresLoader<T> = Loader & Partial<LoaderMethods> & {
-    load: (url: string, onLoad: (result: T) => void, onProgress?: (event: ProgressEvent<EventTarget>) => void, onError?: (err: unknown) => void) => void;
-    loadAsync: (url: string, onProgress?: (event: ProgressEvent) => void) => Promise<T>;
-};
-export type LoaderProto<T> = new (manager?: LoadingManager) => TresLoader<T>;
-export interface TresLoaderOptions<T, Shallow extends boolean> {
-    manager?: LoadingManager;
-    extensions?: (loader: TresLoader<T>) => void;
-    initialValue?: T;
-    asyncOptions?: UseAsyncStateOptions<Shallow, any | null>;
-}
-/**
- * Return type for the useLoader composable
- * @template T - The type of the loaded asset (e.g., GLTF, Texture, etc.)
- * @template Shallow - Whether to use shallow reactivity for better performance
- * @extends {UseAsyncStateReturn<T, [string], Shallow>} - Extends VueUse's useAsyncState return type
- */
-export type UseLoaderReturn<T, Shallow extends boolean> = UseAsyncStateReturn<T, [string], Shallow> & {
-    /**
-     * Loads a new asset from the given path
-     * @param path - The URL or path to the asset to load
-     */
-    load: (path: string) => void;
-    /**
-     * Progress of the loading process
-     * @property loaded - The number of bytes loaded
-     * @property total - The total number of bytes to load
-     * @property percentage - The percentage of the loading process
-     */
-    progress: {
-        loaded: number;
-        total: number;
-        percentage: number;
-    };
-};
-/**
- * Vue composable for loading 3D models using Three.js loaders
- * @param Loader - The Three.js loader constructor
- * @param path - The path to the model file
- * @param options - Optional configuration for the loader
- * @returns UseAsyncState composable with the loaded model
- */
-export declare function useLoader<T, Shallow extends boolean = false>(Loader: LoaderProto<T>, path: MaybeRef<string>, options?: TresLoaderOptions<T, Shallow>): UseLoaderReturn<T, Shallow>;

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

@@ -1,14 +0,0 @@
-import { RafLoopContext } from '../useCreateRafLoop';
-import { TresPartialContext } from '../useTres';
-export type LoopContext = RafLoopContext & TresPartialContext;
-/**
- * Composable that provides control over the render loop and animation lifecycle.
- */
-export declare const useLoop: () => {
-    stop: () => void;
-    start: () => void;
-    isActive: Readonly<import('vue').ShallowRef<boolean>>;
-    onBeforeRender: import('../../utils/createPriorityEventHook').PriorityEventHookOn<LoopContext>;
-    onRender: import('../../utils/createPriorityEventHook').PriorityEventHookOn<LoopContext>;
-    render: (fn: import('..').RenderFunction) => void;
-};

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

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

@@ -1,194 +0,0 @@
-import { ColorRepresentation, ColorSpace, ShadowMapType, ToneMapping, WebGLRenderer } from 'three';
-import { TresContext } from '../useTresContextProvider';
-import { MaybeRef, Reactive, ShallowRef } from 'vue';
-import { Renderer } from 'three/webgpu';
-import { SizesType } from '../useSizes';
-import { UseCameraReturn } from '../useCamera';
-import { TresScene } from '../../types';
-/**
- * If set to 'on-demand', the scene will only be rendered when the current frame is invalidated
- * If set to 'manual', the scene will only be rendered when advance() is called
- * 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 {
-    /**
-     * WebGL Context options (Readonly because they are passed to the renderer constructor)
-     * They can't be changed after the renderer is created because they are passed to the canvas context
-     */
-    antialias?: boolean;
-    /**
-     * Enables stencil buffer with 8 bits.
-     * Required for stencil-based operations like shadow volumes or post-processing effects.
-     * @readonly
-     * @default true
-     */
-    stencil?: boolean;
-    /**
-     * Enables depth buffer with at least 16 bits.
-     * Required for proper 3D rendering and depth testing.
-     * @readonly
-     * @default true
-     */
-    depth?: boolean;
-    /**
-     * Sets the shader precision of the renderer.
-     * @see {@link https://threejs.org/docs/#api/en/renderers/WebGLRenderer}
-     * @default 'highp'
-     */
-    precision?: 'highp' | 'mediump' | 'lowp';
-    /**
-     * Enables logarithmic depth buffer. Useful for scenes with large differences in scale.
-     * Helps prevent z-fighting in scenes with objects very close and very far from the camera.
-     * @readonly
-     * @default false
-     */
-    logarithmicDepthBuffer?: boolean;
-    /**
-     * Preserves the buffers until manually cleared or overwritten.
-     * Needed for screenshots or when reading pixels from the canvas.
-     * Warning: This may impact performance.
-     * @readonly
-     * @default false
-     */
-    preserveDrawingBuffer?: boolean;
-    /**
-     * Power preference for the renderer.
-      * Power preference for the renderer.
-      * - `default`: Automatically chooses the most suitable power setting.
-      * - `high-performance`: Prioritizes rendering performance.
-      * - `low-power`: Tries to reduce power usage.
-     * @see {@link https://threejs.org/docs/#api/en/renderers/WebGLRenderer}
-     * @default 'default'
-     * @readonly
-     */
-    powerPreference?: WebGLPowerPreference;
-    /**
-       * Whether to create the WebGL context with an alpha buffer.
-       * This is a WebGL context option that must be set during context creation and cannot be changed later.
-       * When true, the canvas can be transparent, showing content behind it.
-       * @readonly
-       * @default false
-       */
-    alpha?: boolean;
-    /**
-     * Whether to premultiply the alpha of the canvas.
-     * @see {@link https://threejs.org/docs/#api/en/renderers/WebGLRenderer}
-     * @default true
-     */
-    premultipliedAlpha?: boolean;
-    /**
-     * Whether to fail if the major performance caveat is detected.
-     * @see {@link https://threejs.org/docs/#api/en/renderers/WebGLRenderer}
-     * @default false
-     */
-    failIfMajorPerformanceCaveat?: boolean;
-    /**
-     * WebGL options with set methods
-     * @see {@link https://threejs.org/docs/#api/en/renderers/WebGLRenderer}
-     */
-    /**
-     * Clear color for the canvas
-     * Can include alpha value (e.g. '#00808000' for fully transparent teal)
-     */
-    clearColor?: ColorRepresentation;
-    /**
-     * The opacity of the clear color (0-1)
-     * Controls the transparency of the clear color
-     * @default 1
-     */
-    clearAlpha?: number;
-    /**
-     * Enable shadow rendering in the scene
-     * @default false
-     */
-    shadows?: boolean;
-    /**
-     * Tone mapping technique to use for the scene
-     * - `NoToneMapping`: No tone mapping is applied.
-     * - `LinearToneMapping`: Linear tone mapping.
-     * - `ReinhardToneMapping`: Reinhard tone mapping.
-     * - `CineonToneMapping`: Cineon tone mapping.
-     * - `ACESFilmicToneMapping`: ACES Filmic tone mapping.
-     * - `AgXToneMapping`: AgX tone mapping.
-     * - `NeutralToneMapping`: Neutral tone mapping.
-     * @see {@link https://threejs.org/docs/#api/en/constants/Renderer}
-     * @default ACESFilmicToneMapping (Opinionated default by TresJS)
-     */
-    toneMapping?: ToneMapping;
-    /**
-     * Type of shadow map to use for shadow calculations
-     * - `BasicShadowMap`: Basic shadow map.
-     * - `PCFShadowMap`: Percentage-Closer Filtering shadow map.
-     * - `PCFSoftShadowMap`: Percentage-Closer Filtering soft shadow map.
-     * - `VSMShadowMap`: Variance shadow map.
-     * @see {@link https://threejs.org/docs/#api/en/constants/Renderer}
-     * @default PCFSoftShadowMap (Opinionated default by TresJS)
-     */
-    shadowMapType?: ShadowMapType;
-    /**
-     * Whether to use legacy lights system instead of the new one
-     * @deprecated Use `useLegacyLights: false` for the new lighting system
-     */
-    useLegacyLights?: boolean;
-    /**
-     * Color space for the output render
-     * @see {@link https://threejs.org/docs/#api/en/constants/Renderer}
-     */
-    outputColorSpace?: ColorSpace;
-    /**
-     * Exposure level of tone mapping
-     * @default 1
-     */
-    toneMappingExposure?: number;
-    /**
-     * Rendering mode for the canvas
-     * - 'always': Renders every frame
-     * - 'on-demand': Renders only when changes are detected
-     * - 'manual': Renders only when explicitly called
-     * @default 'always'
-     */
-    renderMode?: 'always' | 'on-demand' | 'manual';
-    /**
-     * Device Pixel Ratio for the renderer
-     * Can be a single number or a tuple defining a range [min, max]
-     */
-    dpr?: number | [number, number];
-    /**
-     * Custom WebGL renderer instance
-     * Allows using a pre-configured renderer instead of creating a new one
-     */
-    renderer?: (ctx: TresRendererSetupContext) => TresRenderer;
-}
-export interface TresRendererSetupContext {
-    sizes: SizesType;
-    scene: ShallowRef<TresScene>;
-    camera: UseCameraReturn;
-    canvas: MaybeRef<HTMLCanvasElement>;
-}
-export interface UseRendererOptions {
-    scene: ShallowRef<TresScene>;
-    canvas: MaybeRef<HTMLCanvasElement>;
-    options: Reactive<RendererOptions>;
-    contextParts: Pick<TresContext, 'sizes' | 'camera'>;
-}
-export declare function useRendererManager({ scene, canvas, options, contextParts: { sizes, camera }, }: UseRendererOptions): {
-    loop: {
-        start: () => void;
-        stop: () => void;
-        isActive: Readonly<ShallowRef<boolean>>;
-        onBeforeLoop: import('@vueuse/core').EventHookOn<import('../useCreateRafLoop').RafLoopContext>;
-        onLoop: import('@vueuse/core').EventHookOn<import('../useCreateRafLoop').RafLoopContext>;
-    };
-    instance: TresRenderer;
-    advance: () => void;
-    onReady: import('@vueuse/core').EventHookOn<TresRenderer>;
-    onRender: import('@vueuse/core').EventHookOn<TresRenderer>;
-    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/useSizes/index.d.ts

@@ -1,11 +0,0 @@
-import { ComputedRef, MaybeRef, MaybeRefOrGetter, 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, number>>;
-    width: Readonly<Ref<number, number>>;
-    aspectRatio: ComputedRef<number>;
-};

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;