@react-three/fiber 9.0.0-alpha.2 → 9.0.0-alpha.4

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

@@ -1,8 +1,6 @@
-export * from './three-types';
-export type { AttachFnType, AttachType, ConstructorRepresentation, Catalogue, Args, InstanceProps, Instance, } from './core/renderer';
-export type { Intersection, Subscription, Dpr, Size, Viewport, RenderCallback, Performance, RootState, } from './core/store';
-export type { ThreeEvent, Events, EventManager, ComputeFunction } from './core/events';
-export type { ObjectMap, Camera } from './core/utils';
-export * from './native/Canvas';
-export { createTouchEvents as events } from './native/events';
-export * from './core';
+import * as ReactThreeFiber from "./three-types.js";
+export { ReactThreeFiber };
+export * from "./three-types.js";
+export * from "./core/index.js";
+export * from "./native/Canvas.js";
+export { createTouchEvents as events } from "./native/events.js";

package/dist/declarations/src/three-types.d.ts

@@ -1,47 +1,56 @@
-/// <reference types="react" />
-import type * as THREE from 'three';
-import type { EventHandlers } from './core/events';
-import type { InstanceProps, ConstructorRepresentation } from './core/renderer';
-declare type Mutable<P> = {
-    [K in keyof P]: P[K] | Readonly<P[K]>;
-};
-declare type NonFunctionKeys<P> = {
-    [K in keyof P]-?: P[K] extends Function ? never : K;
-}[keyof P];
-declare type Overwrite<P, O> = Omit<P, NonFunctionKeys<O>> & O;
-interface MathRepresentation {
-    set(...args: any[]): any;
-}
-interface VectorRepresentation extends MathRepresentation {
-    setScalar(s: number): any;
-}
-declare type MathProps<P> = {
-    [K in keyof P]: P[K] extends infer M ? M extends THREE.Color ? ConstructorParameters<typeof THREE.Color> | THREE.ColorRepresentation : M extends MathRepresentation ? M extends VectorRepresentation ? M | Parameters<M['set']> | Parameters<M['setScalar']>[0] : M | Parameters<M['set']> : {} : {};
-};
-interface RaycastableRepresentation {
-    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
-}
-declare type EventProps<P> = P extends RaycastableRepresentation ? Partial<EventHandlers> : {};
-interface ReactProps<P> {
-    children?: React.ReactNode;
-    ref?: React.Ref<P>;
-    key?: React.Key;
-}
-declare type ElementProps<T extends ConstructorRepresentation, P = InstanceType<T>> = Partial<Overwrite<P, ReactProps<P> & MathProps<P> & EventProps<P>>>;
-export declare type ThreeElement<T extends ConstructorRepresentation> = Mutable<Overwrite<ElementProps<T>, Omit<InstanceProps<InstanceType<T>>, 'object'>>>;
-declare type ThreeExports = typeof THREE;
-declare type ThreeElementsImpl = {
-    [K in keyof ThreeExports as Uncapitalize<K>]: ThreeExports[K] extends ConstructorRepresentation ? ThreeElement<ThreeExports[K]> : never;
-};
-export interface ThreeElements extends ThreeElementsImpl {
-    primitive: Omit<ThreeElement<any>, 'args'> & {
-        object: object;
-    };
-}
-declare global {
-    namespace JSX {
-        interface IntrinsicElements extends ThreeElements {
-        }
-    }
-}
-export {};
+import type * as THREE from 'three';
+import type { Args, EventHandlers, InstanceProps, ConstructorRepresentation } from "./core/index.js";
+type NonFunctionKeys<P> = {
+    [K in keyof P]-?: P[K] extends Function ? never : K;
+}[keyof P];
+export type Overwrite<P, O> = Omit<P, NonFunctionKeys<O>> & O;
+export type Properties<T> = Pick<T, NonFunctionKeys<T>>;
+export type Mutable<P> = {
+    [K in keyof P]: P[K] | Readonly<P[K]>;
+};
+export interface MathRepresentation {
+    set(...args: number[]): any;
+}
+export interface VectorRepresentation extends MathRepresentation {
+    setScalar(s: number): any;
+}
+export type MathType<T extends MathRepresentation | THREE.Euler> = T extends THREE.Color ? Args<typeof THREE.Color> | THREE.ColorRepresentation : T extends VectorRepresentation | THREE.Layers | THREE.Euler ? T | Parameters<T['set']> | number : T | Parameters<T['set']>;
+export type Vector2 = MathType<THREE.Vector2>;
+export type Vector3 = MathType<THREE.Vector3>;
+export type Vector4 = MathType<THREE.Vector4>;
+export type Color = MathType<THREE.Color>;
+export type Layers = MathType<THREE.Layers>;
+export type Quaternion = MathType<THREE.Quaternion>;
+export type Euler = MathType<THREE.Euler>;
+export type Matrix3 = MathType<THREE.Matrix3>;
+export type Matrix4 = MathType<THREE.Matrix4>;
+export type WithMathProps<P> = {
+    [K in keyof P]: P[K] extends MathRepresentation | THREE.Euler ? MathType<P[K]> : P[K];
+};
+export interface RaycastableRepresentation {
+    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
+}
+export type EventProps<P> = P extends RaycastableRepresentation ? Partial<EventHandlers> : {};
+export interface ReactProps<P> {
+    children?: React.ReactNode;
+    ref?: React.Ref<P>;
+    key?: React.Key;
+}
+export type ElementProps<T extends ConstructorRepresentation, P = InstanceType<T>> = Partial<Overwrite<WithMathProps<P>, ReactProps<P> & EventProps<P>>>;
+export type ThreeElement<T extends ConstructorRepresentation> = Mutable<Overwrite<ElementProps<T>, Omit<InstanceProps<InstanceType<T>, T>, 'object'>>>;
+type ThreeExports = typeof THREE;
+type ThreeElementsImpl = {
+    [K in keyof ThreeExports as Uncapitalize<K>]: ThreeExports[K] extends ConstructorRepresentation ? ThreeElement<ThreeExports[K]> : never;
+};
+export interface ThreeElements extends ThreeElementsImpl {
+    primitive: Omit<ThreeElement<any>, 'args'> & {
+        object: object;
+    };
+}
+declare module 'react' {
+    namespace JSX {
+        interface IntrinsicElements extends ThreeElements {
+        }
+    }
+}
+export {};

package/dist/declarations/src/web/Canvas.d.ts

@@ -1,11 +1,24 @@
-import * as React from 'react';
-import type { Options as ResizeOptions } from 'react-use-measure';
-import { RenderProps } from '../core';
-export interface CanvasProps extends Omit<RenderProps<HTMLCanvasElement>, 'size'>, React.HTMLAttributes<HTMLDivElement> {
-    children: React.ReactNode;
-    fallback?: React.ReactNode;
-    resize?: ResizeOptions;
-    eventSource?: HTMLElement | React.MutableRefObject<HTMLElement>;
-    eventPrefix?: 'offset' | 'client' | 'page' | 'layer' | 'screen';
-}
-export declare const Canvas: React.ForwardRefExoticComponent<CanvasProps & React.RefAttributes<HTMLCanvasElement>>;
+import * as React from 'react';
+import type { Options as ResizeOptions } from 'react-use-measure';
+import { RenderProps } from "../core/index.js";
+export interface CanvasProps extends Omit<RenderProps<HTMLCanvasElement>, 'size'>, React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    /** Canvas fallback content, similar to img's alt prop */
+    fallback?: React.ReactNode;
+    /**
+     * Options to pass to useMeasure.
+     * @see https://github.com/pmndrs/react-use-measure#api
+     */
+    resize?: ResizeOptions;
+    /** The target where events are being subscribed to, default: the div that wraps canvas */
+    eventSource?: HTMLElement | React.RefObject<HTMLElement>;
+    /** The event prefix that is cast into canvas pointer x/y events, default: "offset" */
+    eventPrefix?: 'offset' | 'client' | 'page' | 'layer' | 'screen';
+}
+export interface Props extends CanvasProps {
+}
+/**
+ * A DOM canvas which accepts threejs elements as children.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/canvas
+ */
+export declare const Canvas: React.ForwardRefExoticComponent<CanvasProps & React.RefAttributes<HTMLCanvasElement>>;

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

@@ -1,4 +1,4 @@
-import { UseBoundStore } from 'zustand';
-import { RootState } from '../core/store';
-import { EventManager } from '../core/events';
-export declare function createPointerEvents(store: UseBoundStore<RootState>): EventManager<HTMLElement>;
+import { RootStore } from "../core/store.js";
+import { EventManager } from "../core/events.js";
+/** Default R3F event manager for web */
+export declare function createPointerEvents(store: RootStore): EventManager<HTMLElement>;