@react-three/fiber 7.0.28 → 7.0.29

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @react-three/fiber
 
+## 7.0.29
+
+### Patch Changes
+
+- c99a175: fix native entrypoint
+
 ## 7.0.28
 
 ### Patch Changes

package/dist/declarations/src/core/events.d.ts

@@ -1,63 +1,63 @@
-import * as THREE from 'three';
-import type { UseBoundStore } from 'zustand';
-import type { RootState } from './store';
-export interface Intersection extends THREE.Intersection {
-    eventObject: THREE.Object3D;
-}
-export interface IntersectionEvent<TSourceEvent> extends Intersection {
-    intersections: Intersection[];
-    stopped: boolean;
-    unprojectedPoint: THREE.Vector3;
-    ray: THREE.Ray;
-    camera: Camera;
-    stopPropagation: () => void;
-    sourceEvent: TSourceEvent;
-    nativeEvent: TSourceEvent;
-    delta: number;
-    spaceX: number;
-    spaceY: number;
-}
-export declare type Camera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
-export declare type ThreeEvent<TEvent> = IntersectionEvent<TEvent>;
-export declare type DomEvent = PointerEvent | MouseEvent | WheelEvent;
-export declare type Events = {
-    onClick: EventListener;
-    onContextMenu: EventListener;
-    onDoubleClick: EventListener;
-    onWheel: EventListener;
-    onPointerDown: EventListener;
-    onPointerUp: EventListener;
-    onPointerLeave: EventListener;
-    onPointerMove: EventListener;
-    onPointerCancel: EventListener;
-    onLostPointerCapture: EventListener;
-};
-export declare type 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;
-};
-export interface EventManager<TTarget> {
-    connected: TTarget | boolean;
-    handlers?: Events;
-    connect?: (target: TTarget) => void;
-    disconnect?: () => void;
-}
-export interface PointerCaptureTarget {
-    intersection: Intersection;
-    target: Element;
-}
-export declare function removeInteractivity(store: UseBoundStore<RootState>, object: THREE.Object3D): void;
-export declare function createEvents(store: UseBoundStore<RootState>): {
-    handlePointer: (name: string) => (event: DomEvent) => void;
-};
+import * as THREE from 'three';
+import type { UseBoundStore } from 'zustand';
+import type { RootState } from './store';
+export interface Intersection extends THREE.Intersection {
+    eventObject: THREE.Object3D;
+}
+export interface IntersectionEvent<TSourceEvent> extends Intersection {
+    intersections: Intersection[];
+    stopped: boolean;
+    unprojectedPoint: THREE.Vector3;
+    ray: THREE.Ray;
+    camera: Camera;
+    stopPropagation: () => void;
+    sourceEvent: TSourceEvent;
+    nativeEvent: TSourceEvent;
+    delta: number;
+    spaceX: number;
+    spaceY: number;
+}
+export declare type Camera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
+export declare type ThreeEvent<TEvent> = IntersectionEvent<TEvent>;
+export declare type DomEvent = PointerEvent | MouseEvent | WheelEvent;
+export declare type Events = {
+    onClick: EventListener;
+    onContextMenu: EventListener;
+    onDoubleClick: EventListener;
+    onWheel: EventListener;
+    onPointerDown: EventListener;
+    onPointerUp: EventListener;
+    onPointerLeave: EventListener;
+    onPointerMove: EventListener;
+    onPointerCancel: EventListener;
+    onLostPointerCapture: EventListener;
+};
+export declare type 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;
+};
+export interface EventManager<TTarget> {
+    connected: TTarget | boolean;
+    handlers?: Events;
+    connect?: (target: TTarget) => void;
+    disconnect?: () => void;
+}
+export interface PointerCaptureTarget {
+    intersection: Intersection;
+    target: Element;
+}
+export declare function removeInteractivity(store: UseBoundStore<RootState>, object: THREE.Object3D): void;
+export declare function createEvents(store: UseBoundStore<RootState>): {
+    handlePointer: (name: string) => (event: DomEvent) => void;
+};

package/dist/declarations/src/core/hooks.d.ts

@@ -1,32 +1,32 @@
-import * as THREE from 'three';
-import { StateSelector, EqualityChecker } from 'zustand';
-import type { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
-import { RootState, RenderCallback } from './store';
-export interface Loader<T> extends THREE.Loader {
-    load(url: string, onLoad?: (result: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): unknown;
-}
-declare type Extensions = (loader: THREE.Loader) => void;
-declare type LoaderResult<T> = T extends any[] ? Loader<T[number]> : Loader<T>;
-declare type ConditionalType<Child, Parent, Truthy, Falsy> = Child extends Parent ? Truthy : Falsy;
-declare type BranchingReturn<T, Parent, Coerced> = ConditionalType<T, Parent, Coerced, T>;
-declare type noop = (...args: any[]) => any;
-declare type PickFunction<T extends noop> = (...args: Parameters<T>) => ReturnType<T>;
-export declare type ObjectMap = {
-    nodes: {
-        [name: string]: THREE.Object3D;
-    };
-    materials: {
-        [name: string]: THREE.Material;
-    };
-};
-export declare function useStore(): import("zustand").UseBoundStore<RootState, import("zustand").StoreApi<RootState>>;
-export declare function useThree<T = RootState>(selector?: StateSelector<RootState, T>, equalityFn?: EqualityChecker<T>): T;
-export declare function useFrame(callback: RenderCallback, renderPriority?: number): null;
-export declare function useGraph(object: THREE.Object3D): ObjectMap;
-export declare function useMemoizedFn<T extends noop>(fn?: T): PickFunction<T>;
-export declare function useLoader<T, U extends string | string[]>(Proto: new () => LoaderResult<T>, input: U, extensions?: Extensions, onProgress?: (event: ProgressEvent<EventTarget>) => void): U extends any[] ? BranchingReturn<T, GLTF, GLTF & ObjectMap>[] : BranchingReturn<T, GLTF, GLTF & ObjectMap>;
-export declare namespace useLoader {
-    var preload: <T, U extends string | string[]>(Proto: new () => LoaderResult<T>, input: U, extensions?: Extensions | undefined) => undefined;
-    var clear: <T, U extends string | string[]>(Proto: new () => LoaderResult<T>, input: U) => void;
-}
-export {};
+import * as THREE from 'three';
+import { StateSelector, EqualityChecker } from 'zustand';
+import type { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
+import { RootState, RenderCallback } from './store';
+export interface Loader<T> extends THREE.Loader {
+    load(url: string, onLoad?: (result: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): unknown;
+}
+declare type Extensions = (loader: THREE.Loader) => void;
+declare type LoaderResult<T> = T extends any[] ? Loader<T[number]> : Loader<T>;
+declare type ConditionalType<Child, Parent, Truthy, Falsy> = Child extends Parent ? Truthy : Falsy;
+declare type BranchingReturn<T, Parent, Coerced> = ConditionalType<T, Parent, Coerced, T>;
+declare type noop = (...args: any[]) => any;
+declare type PickFunction<T extends noop> = (...args: Parameters<T>) => ReturnType<T>;
+export declare type ObjectMap = {
+    nodes: {
+        [name: string]: THREE.Object3D;
+    };
+    materials: {
+        [name: string]: THREE.Material;
+    };
+};
+export declare function useStore(): import("zustand").UseBoundStore<RootState, import("zustand").StoreApi<RootState>>;
+export declare function useThree<T = RootState>(selector?: StateSelector<RootState, T>, equalityFn?: EqualityChecker<T>): T;
+export declare function useFrame(callback: RenderCallback, renderPriority?: number): null;
+export declare function useGraph(object: THREE.Object3D): ObjectMap;
+export declare function useMemoizedFn<T extends noop>(fn?: T): PickFunction<T>;
+export declare function useLoader<T, U extends string | string[]>(Proto: new () => LoaderResult<T>, input: U, extensions?: Extensions, onProgress?: (event: ProgressEvent<EventTarget>) => void): U extends any[] ? BranchingReturn<T, GLTF, GLTF & ObjectMap>[] : BranchingReturn<T, GLTF, GLTF & ObjectMap>;
+export declare namespace useLoader {
+    var preload: <T, U extends string | string[]>(Proto: new () => LoaderResult<T>, input: U, extensions?: Extensions | undefined) => undefined;
+    var clear: <T, U extends string | string[]>(Proto: new () => LoaderResult<T>, input: U) => void;
+}
+export {};

package/dist/declarations/src/core/is.d.ts

@@ -1,9 +1,9 @@
-export declare const is: {
-    obj: (a: any) => boolean;
-    fun: (a: any) => a is Function;
-    str: (a: any) => a is string;
-    num: (a: any) => a is number;
-    und: (a: any) => boolean;
-    arr: (a: any) => boolean;
-    equ(a: any, b: any): boolean;
-};
+export declare const is: {
+    obj: (a: any) => boolean;
+    fun: (a: any) => a is Function;
+    str: (a: any) => a is string;
+    num: (a: any) => a is number;
+    und: (a: any) => boolean;
+    arr: (a: any) => boolean;
+    equ(a: any, b: any): boolean;
+};

package/dist/declarations/src/core/loop.d.ts

@@ -1,12 +1,12 @@
-import { Root } from './renderer';
-import { RootState } from './store';
-declare type GlobalRenderCallback = (timeStamp: number) => void;
-export declare const addEffect: (callback: GlobalRenderCallback) => () => void;
-export declare const addAfterEffect: (callback: GlobalRenderCallback) => () => void;
-export declare const addTail: (callback: GlobalRenderCallback) => () => void;
-export declare function createLoop<TCanvas>(roots: Map<TCanvas, Root>): {
-    loop: (timestamp: number) => number | undefined;
-    invalidate: (state?: RootState | undefined) => void;
-    advance: (timestamp: number, runGlobalEffects?: boolean, state?: RootState | undefined) => void;
-};
-export {};
+import { Root } from './renderer';
+import { RootState } from './store';
+declare type GlobalRenderCallback = (timeStamp: number) => void;
+export declare const addEffect: (callback: GlobalRenderCallback) => () => void;
+export declare const addAfterEffect: (callback: GlobalRenderCallback) => () => void;
+export declare const addTail: (callback: GlobalRenderCallback) => () => void;
+export declare function createLoop<TCanvas>(roots: Map<TCanvas, Root>): {
+    loop: (timestamp: number) => number | undefined;
+    invalidate: (state?: RootState | undefined) => void;
+    advance: (timestamp: number, runGlobalEffects?: boolean, state?: RootState | undefined) => void;
+};
+export {};

package/dist/declarations/src/core/renderer.d.ts

@@ -1,61 +1,61 @@
-import * as THREE from 'three';
-import Reconciler from 'react-reconciler';
-import { UseBoundStore } from 'zustand';
-import { RootState } from './store';
-import { EventHandlers } from './events';
-export declare type Root = {
-    fiber: Reconciler.FiberRoot;
-    store: UseBoundStore<RootState>;
-};
-export declare type LocalState = {
-    root: UseBoundStore<RootState>;
-    objects: Instance[];
-    parent: Instance | null;
-    primitive?: boolean;
-    eventCount: number;
-    handlers: Partial<EventHandlers>;
-    memoizedProps: {
-        [key: string]: any;
-    };
-};
-export declare type ClassConstructor = {
-    new (): void;
-};
-export declare type AttachFnType = (self: Instance, parent: Instance) => void;
-export declare type AttachFnsType = [attach: string | AttachFnType, detach: string | AttachFnType];
-export declare type BaseInstance = Omit<THREE.Object3D, 'children' | 'attach' | 'add' | 'remove' | 'raycast'> & {
-    __r3f: LocalState;
-    children: Instance[];
-    attach?: string;
-    attachFns?: AttachFnsType;
-    remove: (...object: Instance[]) => Instance;
-    add: (...object: Instance[]) => Instance;
-    raycast?: (raycaster: THREE.Raycaster, intersects: THREE.Intersection[]) => void;
-};
-export declare type Instance = BaseInstance & {
-    [key: string]: any;
-};
-export declare type InstanceProps = {
-    [key: string]: unknown;
-} & {
-    args?: any[];
-    object?: object;
-    visible?: boolean;
-    dispose?: null;
-    attach?: string;
-};
-export declare type DiffSet = {
-    accumulative: boolean;
-    memoized: {
-        [key: string]: any;
-    };
-    changes: [key: string, value: unknown, isEvent: boolean, keys: string[]][];
-};
-export declare const isDiffSet: (def: any) => def is DiffSet;
-declare let extend: (objects: object) => void;
-declare function prepare<T = THREE.Object3D>(object: T, state?: Partial<LocalState>): T;
-declare function createRenderer<TCanvas>(roots: Map<TCanvas, Root>): {
-    reconciler: Reconciler.Reconciler<unknown, unknown, unknown, unknown, unknown>;
-    applyProps: (instance: Instance, data: InstanceProps | DiffSet) => Instance;
-};
-export { prepare, createRenderer, extend };
+import * as THREE from 'three';
+import Reconciler from 'react-reconciler';
+import { UseBoundStore } from 'zustand';
+import { RootState } from './store';
+import { EventHandlers } from './events';
+export declare type Root = {
+    fiber: Reconciler.FiberRoot;
+    store: UseBoundStore<RootState>;
+};
+export declare type LocalState = {
+    root: UseBoundStore<RootState>;
+    objects: Instance[];
+    parent: Instance | null;
+    primitive?: boolean;
+    eventCount: number;
+    handlers: Partial<EventHandlers>;
+    memoizedProps: {
+        [key: string]: any;
+    };
+};
+export declare type ClassConstructor = {
+    new (): void;
+};
+export declare type AttachFnType = (self: Instance, parent: Instance) => void;
+export declare type AttachFnsType = [attach: string | AttachFnType, detach: string | AttachFnType];
+export declare type BaseInstance = Omit<THREE.Object3D, 'children' | 'attach' | 'add' | 'remove' | 'raycast'> & {
+    __r3f: LocalState;
+    children: Instance[];
+    attach?: string;
+    attachFns?: AttachFnsType;
+    remove: (...object: Instance[]) => Instance;
+    add: (...object: Instance[]) => Instance;
+    raycast?: (raycaster: THREE.Raycaster, intersects: THREE.Intersection[]) => void;
+};
+export declare type Instance = BaseInstance & {
+    [key: string]: any;
+};
+export declare type InstanceProps = {
+    [key: string]: unknown;
+} & {
+    args?: any[];
+    object?: object;
+    visible?: boolean;
+    dispose?: null;
+    attach?: string;
+};
+export declare type DiffSet = {
+    accumulative: boolean;
+    memoized: {
+        [key: string]: any;
+    };
+    changes: [key: string, value: unknown, isEvent: boolean, keys: string[]][];
+};
+export declare const isDiffSet: (def: any) => def is DiffSet;
+declare let extend: (objects: object) => void;
+declare function prepare<T = THREE.Object3D>(object: T, state?: Partial<LocalState>): T;
+declare function createRenderer<TCanvas>(roots: Map<TCanvas, Root>): {
+    reconciler: Reconciler.Reconciler<unknown, unknown, unknown, unknown, unknown>;
+    applyProps: (instance: Instance, data: InstanceProps | DiffSet) => Instance;
+};
+export { prepare, createRenderer, extend };

package/dist/declarations/src/core/store.d.ts

@@ -1,118 +1,118 @@
-import * as THREE from 'three';
-import * as React from 'react';
-import * as ReactThreeFiber from '../three-types';
-import { GetState, SetState, UseBoundStore } from 'zustand';
-import { Instance, InstanceProps } from './renderer';
-import { DomEvent, EventManager, PointerCaptureTarget, ThreeEvent } from './events';
-export interface Intersection extends THREE.Intersection {
-    eventObject: THREE.Object3D;
-}
-export declare type Subscription = {
-    ref: React.MutableRefObject<RenderCallback>;
-    priority: number;
-};
-export declare type Dpr = number | [min: number, max: number];
-export declare type Size = {
-    width: number;
-    height: number;
-};
-export declare type Viewport = Size & {
-    initialDpr: number;
-    dpr: number;
-    factor: number;
-    distance: number;
-    aspect: number;
-};
-export declare type Camera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
-export declare type Raycaster = THREE.Raycaster & {
-    enabled: boolean;
-    filter?: FilterFunction;
-    computeOffsets?: ComputeOffsetsFunction;
-};
-export declare type RenderCallback = (state: RootState, delta: number) => void;
-export declare type Performance = {
-    current: number;
-    min: number;
-    max: number;
-    debounce: number;
-    regress: () => void;
-};
-export declare type Renderer = {
-    render: (scene: THREE.Scene, camera: THREE.Camera) => any;
-};
-export declare const isRenderer: (def: Renderer) => boolean;
-export declare const isOrthographicCamera: (def: THREE.Camera) => def is THREE.OrthographicCamera;
-export declare type InternalState = {
-    active: boolean;
-    priority: number;
-    frames: number;
-    lastProps: StoreProps;
-    lastEvent: React.MutableRefObject<DomEvent | null>;
-    interaction: THREE.Object3D[];
-    hovered: Map<string, ThreeEvent<DomEvent>>;
-    subscribers: Subscription[];
-    capturedMap: Map<number, Map<THREE.Object3D, PointerCaptureTarget>>;
-    initialClick: [x: number, y: number];
-    initialHits: THREE.Object3D[];
-    subscribe: (callback: React.MutableRefObject<RenderCallback>, priority?: number) => () => void;
-};
-export declare type RootState = {
-    gl: THREE.WebGLRenderer;
-    scene: THREE.Scene;
-    camera: Camera & {
-        manual?: boolean;
-    };
-    controls: THREE.EventDispatcher | null;
-    raycaster: Raycaster;
-    mouse: THREE.Vector2;
-    clock: THREE.Clock;
-    vr: boolean;
-    linear: boolean;
-    flat: boolean;
-    frameloop: 'always' | 'demand' | 'never';
-    performance: Performance;
-    size: Size;
-    viewport: Viewport & {
-        getCurrentViewport: (camera?: Camera, target?: THREE.Vector3, size?: Size) => Omit<Viewport, 'dpr' | 'initialDpr'>;
-    };
-    set: SetState<RootState>;
-    get: GetState<RootState>;
-    invalidate: () => void;
-    advance: (timestamp: number, runGlobalEffects?: boolean) => void;
-    setSize: (width: number, height: number) => void;
-    setDpr: (dpr: Dpr) => void;
-    setFrameloop: (frameloop?: 'always' | 'demand' | 'never') => void;
-    onPointerMissed?: (event: MouseEvent) => void;
-    events: EventManager<any>;
-    internal: InternalState;
-};
-export declare type FilterFunction = (items: THREE.Intersection[], state: RootState) => THREE.Intersection[];
-export declare type ComputeOffsetsFunction = (event: any, state: RootState) => {
-    offsetX: number;
-    offsetY: number;
-    width?: number;
-    height?: number;
-};
-export declare type StoreProps = {
-    gl: THREE.WebGLRenderer;
-    size: Size;
-    vr?: boolean;
-    shadows?: boolean | Partial<THREE.WebGLShadowMap>;
-    linear?: boolean;
-    flat?: boolean;
-    orthographic?: boolean;
-    frameloop?: 'always' | 'demand' | 'never';
-    performance?: Partial<Omit<Performance, 'regress'>>;
-    dpr?: Dpr;
-    clock?: THREE.Clock;
-    raycaster?: Partial<Raycaster>;
-    camera?: (Camera | Partial<ReactThreeFiber.Object3DNode<THREE.Camera, typeof THREE.Camera> & ReactThreeFiber.Object3DNode<THREE.PerspectiveCamera, typeof THREE.PerspectiveCamera> & ReactThreeFiber.Object3DNode<THREE.OrthographicCamera, typeof THREE.OrthographicCamera>>) & {
-        manual?: boolean;
-    };
-    onPointerMissed?: (event: MouseEvent) => void;
-};
-export declare type ApplyProps = (instance: Instance, newProps: InstanceProps) => void;
-export declare function calculateDpr(dpr: Dpr): number;
-declare const context: React.Context<UseBoundStore<RootState, import("zustand").StoreApi<RootState>>>;
-declare const createStore: (applyProps: ApplyProps, invalidate: (state?: RootState | undefined) => void, advance: (timestamp: number, runGlobalEffects?: boolean | undefined, state?: RootState | undefined) => void, props: StoreProps) => UseBoundStore<RootState>;
-export { createStore, context };
+import * as THREE from 'three';
+import * as React from 'react';
+import * as ReactThreeFiber from '../three-types';
+import { GetState, SetState, UseBoundStore } from 'zustand';
+import { Instance, InstanceProps } from './renderer';
+import { DomEvent, EventManager, PointerCaptureTarget, ThreeEvent } from './events';
+export interface Intersection extends THREE.Intersection {
+    eventObject: THREE.Object3D;
+}
+export declare type Subscription = {
+    ref: React.MutableRefObject<RenderCallback>;
+    priority: number;
+};
+export declare type Dpr = number | [min: number, max: number];
+export declare type Size = {
+    width: number;
+    height: number;
+};
+export declare type Viewport = Size & {
+    initialDpr: number;
+    dpr: number;
+    factor: number;
+    distance: number;
+    aspect: number;
+};
+export declare type Camera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
+export declare type Raycaster = THREE.Raycaster & {
+    enabled: boolean;
+    filter?: FilterFunction;
+    computeOffsets?: ComputeOffsetsFunction;
+};
+export declare type RenderCallback = (state: RootState, delta: number) => void;
+export declare type Performance = {
+    current: number;
+    min: number;
+    max: number;
+    debounce: number;
+    regress: () => void;
+};
+export declare type Renderer = {
+    render: (scene: THREE.Scene, camera: THREE.Camera) => any;
+};
+export declare const isRenderer: (def: Renderer) => boolean;
+export declare const isOrthographicCamera: (def: THREE.Camera) => def is THREE.OrthographicCamera;
+export declare type InternalState = {
+    active: boolean;
+    priority: number;
+    frames: number;
+    lastProps: StoreProps;
+    lastEvent: React.MutableRefObject<DomEvent | null>;
+    interaction: THREE.Object3D[];
+    hovered: Map<string, ThreeEvent<DomEvent>>;
+    subscribers: Subscription[];
+    capturedMap: Map<number, Map<THREE.Object3D, PointerCaptureTarget>>;
+    initialClick: [x: number, y: number];
+    initialHits: THREE.Object3D[];
+    subscribe: (callback: React.MutableRefObject<RenderCallback>, priority?: number) => () => void;
+};
+export declare type RootState = {
+    gl: THREE.WebGLRenderer;
+    scene: THREE.Scene;
+    camera: Camera & {
+        manual?: boolean;
+    };
+    controls: THREE.EventDispatcher | null;
+    raycaster: Raycaster;
+    mouse: THREE.Vector2;
+    clock: THREE.Clock;
+    vr: boolean;
+    linear: boolean;
+    flat: boolean;
+    frameloop: 'always' | 'demand' | 'never';
+    performance: Performance;
+    size: Size;
+    viewport: Viewport & {
+        getCurrentViewport: (camera?: Camera, target?: THREE.Vector3, size?: Size) => Omit<Viewport, 'dpr' | 'initialDpr'>;
+    };
+    set: SetState<RootState>;
+    get: GetState<RootState>;
+    invalidate: () => void;
+    advance: (timestamp: number, runGlobalEffects?: boolean) => void;
+    setSize: (width: number, height: number) => void;
+    setDpr: (dpr: Dpr) => void;
+    setFrameloop: (frameloop?: 'always' | 'demand' | 'never') => void;
+    onPointerMissed?: (event: MouseEvent) => void;
+    events: EventManager<any>;
+    internal: InternalState;
+};
+export declare type FilterFunction = (items: THREE.Intersection[], state: RootState) => THREE.Intersection[];
+export declare type ComputeOffsetsFunction = (event: any, state: RootState) => {
+    offsetX: number;
+    offsetY: number;
+    width?: number;
+    height?: number;
+};
+export declare type StoreProps = {
+    gl: THREE.WebGLRenderer;
+    size: Size;
+    vr?: boolean;
+    shadows?: boolean | Partial<THREE.WebGLShadowMap>;
+    linear?: boolean;
+    flat?: boolean;
+    orthographic?: boolean;
+    frameloop?: 'always' | 'demand' | 'never';
+    performance?: Partial<Omit<Performance, 'regress'>>;
+    dpr?: Dpr;
+    clock?: THREE.Clock;
+    raycaster?: Partial<Raycaster>;
+    camera?: (Camera | Partial<ReactThreeFiber.Object3DNode<THREE.Camera, typeof THREE.Camera> & ReactThreeFiber.Object3DNode<THREE.PerspectiveCamera, typeof THREE.PerspectiveCamera> & ReactThreeFiber.Object3DNode<THREE.OrthographicCamera, typeof THREE.OrthographicCamera>>) & {
+        manual?: boolean;
+    };
+    onPointerMissed?: (event: MouseEvent) => void;
+};
+export declare type ApplyProps = (instance: Instance, newProps: InstanceProps) => void;
+export declare function calculateDpr(dpr: Dpr): number;
+declare const context: React.Context<UseBoundStore<RootState, import("zustand").StoreApi<RootState>>>;
+declare const createStore: (applyProps: ApplyProps, invalidate: (state?: RootState | undefined) => void, advance: (timestamp: number, runGlobalEffects?: boolean | undefined, state?: RootState | undefined) => void, props: StoreProps) => UseBoundStore<RootState>;
+export { createStore, context };

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

@@ -1,8 +1,8 @@
-export * from './three-types';
-import * as ReactThreeFiber from './three-types';
-export { ReactThreeFiber };
-export type { BaseInstance, LocalState } from './core/renderer';
-export type { Intersection, Subscription, Dpr, Size, Viewport, Camera, RenderCallback, Performance, RootState, } from './core/store';
-export type { ThreeEvent, Events, EventManager } from './core/events';
-export type { Props } from './web/Canvas';
-export * from './web';
+export * from './three-types';
+import * as ReactThreeFiber from './three-types';
+export { ReactThreeFiber };
+export type { BaseInstance, LocalState } from './core/renderer';
+export type { Intersection, Subscription, Dpr, Size, Viewport, Camera, RenderCallback, Performance, RootState, } from './core/store';
+export type { ThreeEvent, Events, EventManager } from './core/events';
+export type { Props } from './web/Canvas';
+export * from './web';