angular-three 2.0.0-beta.273 → 2.0.0-beta.275

package/lib/dom/events.d.ts

@@ -1,5 +1,4 @@
-import { NgtEventManager } from '../events';
-import { NgtState } from '../store';
+import { NgtEventManager, NgtState } from '../types';
 import { NgtSignalStore } from '../utils/signal-store';
 export declare const supportedEvents: readonly ["click", "contextmenu", "dblclick", "pointerup", "pointerdown", "pointerover", "pointerout", "pointerenter", "pointerleave", "pointermove", "pointermissed", "pointercancel", "wheel"];
 export declare function createPointerEvents(store: NgtSignalStore<NgtState>): NgtEventManager<HTMLElement>;

package/lib/events.d.ts

@@ -1,82 +1,6 @@
-import { Intersection, Object3D, OrthographicCamera, PerspectiveCamera, Ray, Vector2, Vector3 } from 'three';
-import { NgtState } from './store';
-import { NgtProperties } from './types';
+import { Object3D } from 'three';
+import { NgtDomEvent, NgtState } from './types';
 import { NgtSignalStore } from './utils/signal-store';
-export interface NgtIntersection extends Intersection {
-    /** The event source (the object which registered the handler) */
-    eventObject: Object3D;
-}
-export interface NgtIntersectionEvent<TSourceEvent> extends NgtIntersection {
-    /** The event source (the object which registered the handler) */
-    eventObject: Object3D;
-    /** An array of intersections */
-    intersections: NgtIntersection[];
-    /** vec3.set(pointer.x, pointer.y, 0).unproject(camera) */
-    unprojectedPoint: Vector3;
-    /** Normalized event coordinates */
-    pointer: Vector2;
-    /** Delta between first click and this event */
-    delta: number;
-    /** The ray that pierced it */
-    ray: Ray;
-    /** The camera that was used by the raycaster */
-    camera: NgtCamera;
-    /** 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 NgtCamera = OrthographicCamera | PerspectiveCamera;
-export type NgtThreeEvent<TEvent> = NgtIntersectionEvent<TEvent> & NgtProperties<TEvent>;
-export type NgtDomEvent = PointerEvent | MouseEvent | WheelEvent;
-export type NgtEventHandlers = {
-    click?: (event: NgtThreeEvent<MouseEvent>) => void;
-    contextmenu?: (event: NgtThreeEvent<MouseEvent>) => void;
-    dblclick?: (event: NgtThreeEvent<MouseEvent>) => void;
-    pointerup?: (event: NgtThreeEvent<PointerEvent>) => void;
-    pointerdown?: (event: NgtThreeEvent<PointerEvent>) => void;
-    pointerover?: (event: NgtThreeEvent<PointerEvent>) => void;
-    pointerout?: (event: NgtThreeEvent<PointerEvent>) => void;
-    pointerenter?: (event: NgtThreeEvent<PointerEvent>) => void;
-    pointerleave?: (event: NgtThreeEvent<PointerEvent>) => void;
-    pointermove?: (event: NgtThreeEvent<PointerEvent>) => void;
-    pointermissed?: (event: MouseEvent) => void;
-    pointercancel?: (event: NgtThreeEvent<PointerEvent>) => void;
-    wheel?: (event: NgtThreeEvent<WheelEvent>) => void;
-};
-export type NgtEvents = {
-    [TEvent in keyof NgtEventHandlers]-?: EventListener;
-};
-export type NgtFilterFunction = (items: Intersection[], store: NgtSignalStore<NgtState>) => Intersection[];
-export type NgtComputeFunction = (event: NgtDomEvent, root: NgtSignalStore<NgtState>, previous: NgtSignalStore<NgtState> | null) => void;
-export type NgtEventManager<TTarget> = {
-    /** Determines if the event layer is active */
-    enabled: boolean;
-    /** Event layer priority, higher prioritized layers come first and may stop(-propagate) lower layer  */
-    priority: number;
-    /** The compute function needs to set up the raycaster and an xy- pointer  */
-    compute?: NgtComputeFunction;
-    /** The filter can re-order or re-structure the intersections  */
-    filter?: NgtFilterFunction;
-    /** The target node the event layer is tied to */
-    connected?: TTarget;
-    /** All the pointer event handlers through which the host forwards native events */
-    handlers?: NgtEvents;
-    /** Allows re-connecting to another target */
-    connect?: (target: TTarget) => void;
-    /** Removes all existing events handlers from the target */
-    disconnect?: () => void;
-    /** Triggers a onPointerMove with the last known event. This can be useful to enable raycasting without
-     *  explicit user interaction, for instance when the camera moves a hoverable object underneath the cursor.
-     */
-    update?: () => void;
-};
-export interface NgtPointerCaptureTarget {
-    intersection: NgtIntersection;
-    target: Element;
-}
 export declare function removeInteractivity(store: NgtSignalStore<NgtState>, object: Object3D): void;
 export declare function createEvents(store: NgtSignalStore<NgtState>): {
     handlePointer: (name: string) => (event: NgtDomEvent) => void;

package/lib/html.d.ts

@@ -7,7 +7,7 @@ export declare function provideHTMLDomElement<TDeps extends Array<ProviderToken<
 }>(deps: TDeps, factory: (...args: TValues) => HTMLElement): Provider;
 export declare abstract class NgtHTML {
     static [HTML]: boolean;
-    protected store: import("angular-three").NgtSignalStore<import("./store").NgtState>;
+    protected store: import("angular-three").NgtSignalStore<import("./types").NgtState>;
     protected destroyRef: DestroyRef;
     protected host: ElementRef<HTMLElement>;
     protected domElement: HTMLElement | "gl" | null;

package/lib/instance.d.ts

@@ -1,41 +1,4 @@
-import { Signal } from '@angular/core';
-import { NgtEventHandlers } from './events';
-import { NgtState } from './store';
-import { NgtAnyRecord } from './types';
-import { NgtSignalStore } from './utils/signal-store';
-export type NgtAttachFunction<TChild = any, TParent = any> = (parent: TParent, child: TChild, store: NgtSignalStore<NgtState>) => void | (() => void);
-export interface NgtAfterAttach<TChild extends NgtInstanceNode = NgtInstanceNode, TParent extends NgtInstanceNode = NgtInstanceNode> {
-    parent: TParent;
-    node: TChild;
-}
-export interface NgtLocalInstanceState {
-    objects: NgtInstanceNode[];
-    nonObjects: NgtInstanceNode[];
-    parent: NgtInstanceNode | null;
-}
-export interface NgtLocalState {
-    /** the store of the canvas that the instance is being rendered to */
-    store: NgtSignalStore<NgtState>;
-    instanceStore: NgtSignalStore<NgtLocalInstanceState>;
-    parent: Signal<NgtLocalInstanceState['parent']>;
-    objects: Signal<NgtLocalInstanceState['objects']>;
-    nonObjects: Signal<NgtLocalInstanceState['nonObjects']>;
-    add: (instance: NgtInstanceNode, type: 'objects' | 'nonObjects') => void;
-    remove: (instance: NgtInstanceNode, type: 'objects' | 'nonObjects') => void;
-    setParent: (parent: NgtInstanceNode | null) => void;
-    primitive?: boolean;
-    eventCount: number;
-    handlers: Partial<NgtEventHandlers>;
-    attach?: string[] | NgtAttachFunction;
-    previousAttach?: unknown | (() => void);
-    isRaw?: boolean;
-    priority?: number;
-    onUpdate?: (node: NgtInstanceNode) => void;
-    onAttach?: (afterAttach: NgtAfterAttach) => void;
-}
-export type NgtInstanceNode<TNode = any> = {
-    __ngt__: NgtLocalState;
-} & NgtAnyRecord & TNode;
+import { NgtAnyRecord, NgtInstanceNode, NgtLocalState } from './types';
 export declare function getLocalState<TInstance extends object>(obj: TInstance | undefined): NgtLocalState | undefined;
 export declare function invalidateInstance<TInstance extends object>(instance: TInstance): void;
 export declare function prepare<TInstance extends object = NgtAnyRecord>(object: TInstance, localState?: Partial<NgtLocalState>): NgtInstanceNode<TInstance>;

package/lib/loop.d.ts

@@ -1,6 +1,6 @@
-import { NgtState } from './store';
+import { NgtCanvasElement, NgtGlobalRenderCallback, NgtState } from './types';
 import { NgtSignalStore } from './utils/signal-store';
-export type NgtGlobalRenderCallback = (timeStamp: number) => void;
+export declare const roots: Map<NgtCanvasElement, NgtSignalStore<NgtState>>;
 /**
  * Adds a global render callback which is called each frame.
  * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addEffect

package/lib/portal.d.ts

@@ -1,7 +1,6 @@
 import { Injector, TemplateRef, ViewContainerRef } from '@angular/core';
 import { Camera, Object3D, Scene } from 'three';
-import { NgtComputeFunction } from './events';
-import { NgtSize, NgtState } from './store';
+import { NgtComputeFunction, NgtSize, NgtState } from './types';
 import * as i0 from "@angular/core";
 export declare class NgtPortalBeforeRender {
     private portalStore;
@@ -35,7 +34,7 @@ export type NgtPortalInjectableState = Partial<Omit<NgtState, NgtPortalPrivateKe
 }>;
 export declare class NgtPortal {
     container: import("@angular/core").InputSignal<Object3D<import("three").Object3DEventMap>>;
-    state: import("@angular/core").InputSignal<Partial<Omit<NgtState, "setSize" | "viewport" | "events" | "size" | "invalidate" | "advance" | "setEvents" | "setDpr" | "setFrameloop"> & {
+    state: import("@angular/core").InputSignal<Partial<Omit<NgtState, "viewport" | "size" | "setSize" | "events" | "invalidate" | "advance" | "setEvents" | "setDpr" | "setFrameloop"> & {
         events?: {
             enabled?: boolean;
             priority?: number;
@@ -55,7 +54,7 @@ export declare class NgtPortal {
     private portalStore;
     private parentStore;
     parentScene: import("@angular/core").Signal<Scene>;
-    parentCamera: import("@angular/core").Signal<import("./store").NgtCameraManual>;
+    parentCamera: import("@angular/core").Signal<import("./types").NgtCameraManual>;
     private raycaster;
     private pointer;
     private portalRendered;

package/lib/renderer/index.d.ts

@@ -1,6 +1,5 @@
 import { Renderer2, RendererFactory2, RendererType2 } from '@angular/core';
-import { NgtState } from '../store';
-import { NgtAnyRecord } from '../types';
+import { NgtAnyRecord, NgtState } from '../types';
 import { NgtSignalStore } from '../utils/signal-store';
 import { NgtAnyConstructor } from './catalogue';
 import { NgtRendererNode, NgtRendererState } from './state';

package/lib/renderer/utils.d.ts

@@ -1,4 +1,4 @@
-import { NgtInstanceNode } from '../instance';
+import { NgtInstanceNode } from '../types';
 export declare const enum NgtRendererClassId {
     type = 0,
     parent = 1,

package/lib/roots.d.ts

@@ -1,9 +1,5 @@
 import { Injector } from '@angular/core';
-import { NgtCanvasOptions } from './canvas';
-import { NgtState } from './store';
-import { NgtSignalStore } from './utils/signal-store';
-export type NgtCanvasElement = HTMLCanvasElement | OffscreenCanvas;
-export declare const roots: Map<NgtCanvasElement, NgtSignalStore<NgtState>>;
+import { NgtCanvasElement, NgtCanvasOptions } from './types';
 export declare function injectCanvasRootInitializer(injector?: Injector): (canvas: NgtCanvasElement) => {
     isConfigured: boolean;
     destroy: (timeout?: number) => void;

package/lib/store.d.ts

@@ -1,131 +1,6 @@
-import { ElementRef, InjectOptions, InjectionToken } from '@angular/core';
-import { Observable } from 'rxjs';
-import { Camera, Clock, EventDispatcher, Object3D, Raycaster, Scene, Vector2, Vector3, WebGLRenderer } from 'three';
-import { NgtCamera, NgtDomEvent, NgtEventManager, NgtPointerCaptureTarget, NgtThreeEvent } from './events';
-import { NgtInstanceNode } from './instance';
+import { InjectOptions, InjectionToken } from '@angular/core';
+import { NgtState } from './types';
 import { NgtSignalStore } from './utils/signal-store';
-export type NgtRendererLike = {
-    render: (scene: Scene, camera: Camera) => any;
-};
-export type NgtCameraManual = NgtCamera & {
-    manual?: boolean;
-};
-export type NgtDpr = number | [min: number, max: number];
-export type NgtSize = {
-    width: number;
-    height: number;
-    top: number;
-    left: number;
-};
-export type NgtViewport = NgtSize & {
-    /** The initial pixel ratio */
-    initialDpr: number;
-    /** Current pixel ratio */
-    dpr: number;
-    /** size.width / viewport.width */
-    factor: number;
-    /** Camera distance */
-    distance: number;
-    /** Camera aspect ratio: width / height */
-    aspect: number;
-};
-export type NgtPerformance = {
-    /** Current performance normal, between min and max */
-    current: number;
-    /** How low the performance can go, between 0 and max */
-    min: number;
-    /** How high the performance can go, between min and max */
-    max: number;
-    /** Time until current returns to max in ms */
-    debounce: number;
-    /** Sets current to min, puts the system in regression */
-    regress: () => void;
-};
-export type NgtRenderState = NgtState & {
-    delta: number;
-    frame?: XRFrame;
-};
-export type NgtBeforeRenderEvent<TObject extends NgtInstanceNode = NgtInstanceNode> = {
-    state: NgtRenderState;
-    object: TObject;
-};
-export type NgtBeforeRenderRecord = {
-    callback: (state: NgtRenderState) => void;
-    store: NgtSignalStore<NgtState>;
-    priority?: number;
-};
-export type NgtInternalState = {
-    active: boolean;
-    priority: number;
-    frames: number;
-    lastEvent: ElementRef<NgtDomEvent | null>;
-    interaction: Object3D[];
-    hovered: Map<string, NgtThreeEvent<NgtDomEvent>>;
-    capturedMap: Map<number, Map<Object3D, NgtPointerCaptureTarget>>;
-    initialClick: [x: number, y: number];
-    initialHits: Object3D[];
-    subscribers: NgtBeforeRenderRecord[];
-    subscribe: (callback: NgtBeforeRenderRecord['callback'], priority?: number, store?: NgtSignalStore<NgtState>) => () => void;
-};
-export type NgtState = {
-    /** The instance of the renderer */
-    gl: WebGLRenderer;
-    /** Default camera */
-    camera: NgtCameraManual;
-    /** Default scene */
-    scene: Scene;
-    /** Default raycaster */
-    raycaster: Raycaster;
-    /** Default clock */
-    clock: Clock;
-    /** Event layer interface, contains the event handler and the node they're connected to */
-    events: NgtEventManager<any>;
-    /** XR interface */
-    xr: {
-        connect: () => void;
-        disconnect: () => void;
-    };
-    /** Currently used controls */
-    controls: EventDispatcher | null;
-    /** Normalized event coordinates */
-    pointer: Vector2;
-    legacy: boolean;
-    /** Shortcut to gl.outputColorSpace = LinearSRGBColorSpace */
-    linear: boolean;
-    /** Shortcut to gl.toneMapping = NoTonemapping */
-    flat: boolean;
-    /** Render loop flags */
-    frameloop: 'always' | 'demand' | 'never';
-    /** Adaptive performance interface */
-    performance: NgtPerformance;
-    /** Reactive pixel-size of the canvas */
-    size: NgtSize;
-    /** Reactive size of the viewport in threejs units */
-    viewport: NgtViewport & {
-        getCurrentViewport: (camera?: NgtCamera, target?: Vector3 | Parameters<Vector3['set']>, size?: NgtSize) => Omit<NgtViewport, 'dpr' | 'initialDpr'>;
-    };
-    /** Flags the canvas for render, but doesn't render in itself */
-    invalidate: (frames?: number) => void;
-    /** Advance (render) one step */
-    advance: (timestamp: number, runGlobalEffects?: boolean) => void;
-    /** Shortcut to setting the event layer */
-    setEvents: (events: Partial<NgtEventManager<any>>) => void;
-    /**
-     * Shortcut to manual sizing
-     */
-    setSize: (width: number, height: number, top?: number, left?: number) => void;
-    /** Shortcut to manual setting the pixel ratio */
-    setDpr: (dpr: NgtDpr) => void;
-    /** Shortcut to frameloop flags */
-    setFrameloop: (frameloop?: 'always' | 'demand' | 'never') => void;
-    /** When the canvas was clicked but nothing was hit */
-    /** PointerMissed Observable */
-    pointerMissed$: Observable<MouseEvent>;
-    /** If this state model is layered (via createPortal) then this contains the previous layer */
-    previousRoot: NgtSignalStore<NgtState> | null;
-    /** Internals */
-    internal: NgtInternalState;
-};
 declare function storeFactory(previousStore: NgtSignalStore<NgtState> | null): NgtSignalStore<NgtState>;
 export declare const NGT_STORE: InjectionToken<NgtSignalStore<NgtState>>;
 export declare function provideStore(store?: () => NgtSignalStore<NgtState>): {

package/lib/three-types.d.ts

@@ -1,7 +1,5 @@
 import { AmbientLight, ArrayCamera, ArrowHelper, Audio, AxesHelper, BatchedMesh, Bone, Box3Helper, BoxGeometry, BoxHelper, BufferAttribute, BufferGeometry, Camera, CameraHelper, CanvasTexture, CapsuleGeometry, CircleGeometry, Color, ColorRepresentation, CompressedTexture, ConeGeometry, CubeCamera, CubeTexture, CylinderGeometry, Data3DTexture, DataTexture, DepthTexture, DirectionalLight, DirectionalLightHelper, DirectionalLightShadow, DodecahedronGeometry, EdgesGeometry, Euler, ExtrudeGeometry, Float16BufferAttribute, Float32BufferAttribute, Fog, FogExp2, GridHelper, Group, HemisphereLight, HemisphereLightHelper, IcosahedronGeometry, InstancedBufferAttribute, InstancedBufferGeometry, InstancedMesh, Int16BufferAttribute, Int32BufferAttribute, Int8BufferAttribute, LOD, LatheGeometry, Layers, Light, LightProbe, LightShadow, Line, LineBasicMaterial, LineBasicMaterialParameters, LineDashedMaterial, LineDashedMaterialParameters, LineLoop, LineSegments, Material, Matrix3, Matrix4, Mesh, MeshBasicMaterial, MeshBasicMaterialParameters, MeshDepthMaterial, MeshDepthMaterialParameters, MeshDistanceMaterial, MeshDistanceMaterialParameters, MeshLambertMaterial, MeshLambertMaterialParameters, MeshMatcapMaterial, MeshMatcapMaterialParameters, MeshNormalMaterial, MeshNormalMaterialParameters, MeshPhongMaterial, MeshPhongMaterialParameters, MeshPhysicalMaterial, MeshPhysicalMaterialParameters, MeshStandardMaterial, MeshStandardMaterialParameters, MeshToonMaterial, MeshToonMaterialParameters, Object3D, OctahedronGeometry, OrthographicCamera, PerspectiveCamera, PlaneGeometry, PlaneHelper, PointLight, PointLightHelper, Points, PointsMaterial, PointsMaterialParameters, PolarGridHelper, PolyhedronGeometry, PositionalAudio, Quaternion, RawShaderMaterial, Raycaster, RectAreaLight, RingGeometry, Scene, ShaderMaterial, ShaderMaterialParameters, ShadowMaterial, Shape, ShapeGeometry, Skeleton, SkeletonHelper, SkinnedMesh, SphereGeometry, SpotLight, SpotLightHelper, SpotLightShadow, Sprite, SpriteMaterial, SpriteMaterialParameters, TetrahedronGeometry, Texture, TorusGeometry, TorusKnotGeometry, TubeGeometry, Uint16BufferAttribute, Uint32BufferAttribute, Uint8BufferAttribute, Vector2, Vector3, Vector4, VideoTexture, WireframeGeometry } from 'three';
-import { NgtEventHandlers } from './events';
-import { NgtAfterAttach, NgtAttachFunction, NgtInstanceNode } from './instance';
-import { NgtBeforeRenderEvent } from './store';
+import { NgtAfterAttach, NgtAttachFunction, NgtBeforeRenderEvent, NgtEventHandlers, NgtInstanceNode } from './types';
 type Expand<T> = T extends infer O ? {
     [K in keyof O]: O[K];
 } : never;

package/lib/types.d.ts

@@ -1,3 +1,8 @@
+import { ElementRef, Signal } from '@angular/core';
+import { Observable } from 'rxjs';
+import { Camera, Clock, EventDispatcher, Intersection, Object3D, OrthographicCamera, PerspectiveCamera, Ray, Raycaster, Scene, Vector2, Vector3, WebGLRenderer, WebGLRendererParameters, WebGLShadowMap } from 'three';
+import { NgtObject3DNode } from './three-types';
+import { NgtSignalStore } from './utils/signal-store';
 export type NgtProperties<T> = Pick<T, {
     [K in keyof T]: T[K] extends (_: any) => any ? never : K;
 }[keyof T]>;
@@ -10,3 +15,288 @@ export type NgtEquConfig = {
     /** If true the keys in both a and b must match 1:1 (default), if false a's keys must intersect b's */
     strict?: boolean;
 };
+export type NgtGLOptions = NgtRendererLike | ((canvas: NgtCanvasElement) => NgtRendererLike) | Partial<NgtProperties<WebGLRenderer> | WebGLRendererParameters> | undefined;
+export interface NgtCanvasOptions {
+    /** A threejs renderer instance or props that go into the default renderer */
+    gl?: NgtGLOptions;
+    /** Dimensions to fit the renderer to. Will measure canvas dimensions if omitted */
+    size?: NgtSize;
+    /**
+     * Enables shadows (by default PCFsoft). Can accept `gl.shadowMap` options for fine-tuning,
+     * but also strings: 'basic' | 'percentage' | 'soft' | 'variance'.
+     * @see https://threejs.org/docs/#api/en/renderers/WebGLRenderer.shadowMap
+     */
+    shadows?: boolean | 'basic' | 'percentage' | 'soft' | 'variance' | Partial<WebGLShadowMap>;
+    /**
+     * Disables three r139 color management.
+     * @see https://threejs.org/docs/#manual/en/introduction/Color-management
+     */
+    legacy?: boolean;
+    /** Switch off automatic sRGB color space and gamma correction */
+    linear?: boolean;
+    /** Use `THREE.NoToneMapping` instead of `THREE.ACESFilmicToneMapping` */
+    flat?: boolean;
+    /** Creates an orthographic camera */
+    orthographic?: boolean;
+    /**
+     * R3F's render mode. Set to `demand` to only render on state change or `never` to take control.
+     * @see https://docs.pmnd.rs/react-three-fiber/advanced/scaling-performance#on-demand-rendering
+     */
+    frameloop?: 'always' | 'demand' | 'never';
+    /**
+     * R3F performance options for adaptive performance.
+     * @see https://docs.pmnd.rs/react-three-fiber/advanced/scaling-performance#movement-regression
+     */
+    performance?: Partial<Omit<NgtPerformance, 'regress'>>;
+    /** Target pixel ratio. Can clamp between a range: `[min, max]` */
+    dpr?: NgtDpr;
+    /** Props that go into the default raycaster */
+    raycaster?: Partial<Raycaster>;
+    /** A `Scene` instance or props that go into the default scene */
+    scene?: Scene | Partial<Scene>;
+    /** A `Camera` instance or props that go into the default camera */
+    camera?: (NgtCamera | Partial<NgtObject3DNode<Camera, typeof Camera> & NgtObject3DNode<PerspectiveCamera, typeof PerspectiveCamera> & NgtObject3DNode<OrthographicCamera, typeof OrthographicCamera>>) & {
+        /** Flags the camera as manual, putting projection into your own hands */
+        manual?: boolean;
+    };
+    /** An R3F event manager to manage elements' pointer events */
+    events?: (store: NgtSignalStore<NgtState>) => NgtEventManager<HTMLElement>;
+    /** The target where events are being subscribed to, default: the div that wraps canvas */
+    eventSource?: HTMLElement | ElementRef<HTMLElement>;
+    /** The event prefix that is cast into canvas pointer x/y events, default: "offset" */
+    eventPrefix?: 'offset' | 'client' | 'page' | 'layer' | 'screen';
+    /** Default coordinate for the camera to look at */
+    lookAt?: Vector3 | Parameters<Vector3['set']>;
+}
+export interface NgtIntersection extends Intersection {
+    /** The event source (the object which registered the handler) */
+    eventObject: Object3D;
+}
+export interface NgtIntersectionEvent<TSourceEvent> extends NgtIntersection {
+    /** The event source (the object which registered the handler) */
+    eventObject: Object3D;
+    /** An array of intersections */
+    intersections: NgtIntersection[];
+    /** vec3.set(pointer.x, pointer.y, 0).unproject(camera) */
+    unprojectedPoint: Vector3;
+    /** Normalized event coordinates */
+    pointer: Vector2;
+    /** Delta between first click and this event */
+    delta: number;
+    /** The ray that pierced it */
+    ray: Ray;
+    /** The camera that was used by the raycaster */
+    camera: NgtCamera;
+    /** 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 NgtCamera = OrthographicCamera | PerspectiveCamera;
+export type NgtThreeEvent<TEvent> = NgtIntersectionEvent<TEvent> & NgtProperties<TEvent>;
+export type NgtDomEvent = PointerEvent | MouseEvent | WheelEvent;
+export type NgtEventHandlers = {
+    click?: (event: NgtThreeEvent<MouseEvent>) => void;
+    contextmenu?: (event: NgtThreeEvent<MouseEvent>) => void;
+    dblclick?: (event: NgtThreeEvent<MouseEvent>) => void;
+    pointerup?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointerdown?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointerover?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointerout?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointerenter?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointerleave?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointermove?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointermissed?: (event: MouseEvent) => void;
+    pointercancel?: (event: NgtThreeEvent<PointerEvent>) => void;
+    wheel?: (event: NgtThreeEvent<WheelEvent>) => void;
+};
+export type NgtEvents = {
+    [TEvent in keyof NgtEventHandlers]-?: EventListener;
+};
+export type NgtFilterFunction = (items: Intersection[], store: NgtSignalStore<NgtState>) => Intersection[];
+export type NgtComputeFunction = (event: NgtDomEvent, root: NgtSignalStore<NgtState>, previous: NgtSignalStore<NgtState> | null) => void;
+export type NgtEventManager<TTarget> = {
+    /** Determines if the event layer is active */
+    enabled: boolean;
+    /** Event layer priority, higher prioritized layers come first and may stop(-propagate) lower layer  */
+    priority: number;
+    /** The compute function needs to set up the raycaster and an xy- pointer  */
+    compute?: NgtComputeFunction;
+    /** The filter can re-order or re-structure the intersections  */
+    filter?: NgtFilterFunction;
+    /** The target node the event layer is tied to */
+    connected?: TTarget;
+    /** All the pointer event handlers through which the host forwards native events */
+    handlers?: NgtEvents;
+    /** Allows re-connecting to another target */
+    connect?: (target: TTarget) => void;
+    /** Removes all existing events handlers from the target */
+    disconnect?: () => void;
+    /** Triggers a onPointerMove with the last known event. This can be useful to enable raycasting without
+     *  explicit user interaction, for instance when the camera moves a hoverable object underneath the cursor.
+     */
+    update?: () => void;
+};
+export interface NgtPointerCaptureTarget {
+    intersection: NgtIntersection;
+    target: Element;
+}
+export type NgtAttachFunction<TChild = any, TParent = any> = (parent: TParent, child: TChild, store: NgtSignalStore<NgtState>) => void | (() => void);
+export interface NgtAfterAttach<TChild extends NgtInstanceNode = NgtInstanceNode, TParent extends NgtInstanceNode = NgtInstanceNode> {
+    parent: TParent;
+    node: TChild;
+}
+export interface NgtLocalInstanceState {
+    objects: NgtInstanceNode[];
+    nonObjects: NgtInstanceNode[];
+    parent: NgtInstanceNode | null;
+}
+export interface NgtLocalState {
+    /** the store of the canvas that the instance is being rendered to */
+    store: NgtSignalStore<NgtState>;
+    instanceStore: NgtSignalStore<NgtLocalInstanceState>;
+    parent: Signal<NgtLocalInstanceState['parent']>;
+    objects: Signal<NgtLocalInstanceState['objects']>;
+    nonObjects: Signal<NgtLocalInstanceState['nonObjects']>;
+    add: (instance: NgtInstanceNode, type: 'objects' | 'nonObjects') => void;
+    remove: (instance: NgtInstanceNode, type: 'objects' | 'nonObjects') => void;
+    setParent: (parent: NgtInstanceNode | null) => void;
+    primitive?: boolean;
+    eventCount: number;
+    handlers: Partial<NgtEventHandlers>;
+    attach?: string[] | NgtAttachFunction;
+    previousAttach?: unknown | (() => void);
+    isRaw?: boolean;
+    priority?: number;
+    onUpdate?: (node: NgtInstanceNode) => void;
+    onAttach?: (afterAttach: NgtAfterAttach) => void;
+}
+export type NgtInstanceNode<TNode = any> = {
+    __ngt__: NgtLocalState;
+} & NgtAnyRecord & TNode;
+export type NgtCanvasElement = HTMLCanvasElement | OffscreenCanvas;
+export type NgtGlobalRenderCallback = (timeStamp: number) => void;
+export type NgtRendererLike = {
+    render: (scene: Scene, camera: Camera) => any;
+};
+export type NgtCameraManual = NgtCamera & {
+    manual?: boolean;
+};
+export type NgtDpr = number | [min: number, max: number];
+export type NgtSize = {
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+};
+export type NgtViewport = NgtSize & {
+    /** The initial pixel ratio */
+    initialDpr: number;
+    /** Current pixel ratio */
+    dpr: number;
+    /** size.width / viewport.width */
+    factor: number;
+    /** Camera distance */
+    distance: number;
+    /** Camera aspect ratio: width / height */
+    aspect: number;
+};
+export type NgtPerformance = {
+    /** Current performance normal, between min and max */
+    current: number;
+    /** How low the performance can go, between 0 and max */
+    min: number;
+    /** How high the performance can go, between min and max */
+    max: number;
+    /** Time until current returns to max in ms */
+    debounce: number;
+    /** Sets current to min, puts the system in regression */
+    regress: () => void;
+};
+export type NgtRenderState = NgtState & {
+    delta: number;
+    frame?: XRFrame;
+};
+export type NgtBeforeRenderEvent<TObject extends NgtInstanceNode = NgtInstanceNode> = {
+    state: NgtRenderState;
+    object: TObject;
+};
+export type NgtBeforeRenderRecord = {
+    callback: (state: NgtRenderState) => void;
+    store: NgtSignalStore<NgtState>;
+    priority?: number;
+};
+export type NgtInternalState = {
+    active: boolean;
+    priority: number;
+    frames: number;
+    lastEvent: ElementRef<NgtDomEvent | null>;
+    interaction: Object3D[];
+    hovered: Map<string, NgtThreeEvent<NgtDomEvent>>;
+    capturedMap: Map<number, Map<Object3D, NgtPointerCaptureTarget>>;
+    initialClick: [x: number, y: number];
+    initialHits: Object3D[];
+    subscribers: NgtBeforeRenderRecord[];
+    subscribe: (callback: NgtBeforeRenderRecord['callback'], priority?: number, store?: NgtSignalStore<NgtState>) => () => void;
+};
+export type NgtState = {
+    /** The instance of the renderer */
+    gl: WebGLRenderer;
+    /** Default camera */
+    camera: NgtCameraManual;
+    /** Default scene */
+    scene: Scene;
+    /** Default raycaster */
+    raycaster: Raycaster;
+    /** Default clock */
+    clock: Clock;
+    /** Event layer interface, contains the event handler and the node they're connected to */
+    events: NgtEventManager<any>;
+    /** XR interface */
+    xr: {
+        connect: () => void;
+        disconnect: () => void;
+    };
+    /** Currently used controls */
+    controls: EventDispatcher | null;
+    /** Normalized event coordinates */
+    pointer: Vector2;
+    legacy: boolean;
+    /** Shortcut to gl.outputColorSpace = LinearSRGBColorSpace */
+    linear: boolean;
+    /** Shortcut to gl.toneMapping = NoTonemapping */
+    flat: boolean;
+    /** Render loop flags */
+    frameloop: 'always' | 'demand' | 'never';
+    /** Adaptive performance interface */
+    performance: NgtPerformance;
+    /** Reactive pixel-size of the canvas */
+    size: NgtSize;
+    /** Reactive size of the viewport in threejs units */
+    viewport: NgtViewport & {
+        getCurrentViewport: (camera?: NgtCamera, target?: Vector3 | Parameters<Vector3['set']>, size?: NgtSize) => Omit<NgtViewport, 'dpr' | 'initialDpr'>;
+    };
+    /** Flags the canvas for render, but doesn't render in itself */
+    invalidate: (frames?: number) => void;
+    /** Advance (render) one step */
+    advance: (timestamp: number, runGlobalEffects?: boolean) => void;
+    /** Shortcut to setting the event layer */
+    setEvents: (events: Partial<NgtEventManager<any>>) => void;
+    /**
+     * Shortcut to manual sizing
+     */
+    setSize: (width: number, height: number, top?: number, left?: number) => void;
+    /** Shortcut to manual setting the pixel ratio */
+    setDpr: (dpr: NgtDpr) => void;
+    /** Shortcut to frameloop flags */
+    setFrameloop: (frameloop?: 'always' | 'demand' | 'never') => void;
+    /** When the canvas was clicked but nothing was hit */
+    /** PointerMissed Observable */
+    pointerMissed$: Observable<MouseEvent>;
+    /** If this state model is layered (via createPortal) then this contains the previous layer */
+    previousRoot: NgtSignalStore<NgtState> | null;
+    /** Internals */
+    internal: NgtInternalState;
+};

package/lib/utils/apply-props.d.ts

@@ -1,3 +1,2 @@
-import { NgtInstanceNode } from '../instance';
-import { NgtAnyRecord } from '../types';
+import { NgtAnyRecord, NgtInstanceNode } from '../types';
 export declare function applyProps(instance: NgtInstanceNode, props: NgtAnyRecord): any;