angular-three 0.0.7 → 1.0.0-beta.0

package/lib/types.d.ts

@@ -1,10 +1,17 @@
 /// <reference types="webxr" />
-import { ElementRef } from '@angular/core';
-import { ObservableInput } from 'rxjs';
+import type { ElementRef, EventEmitter } from '@angular/core';
+import type { BehaviorSubject } from 'rxjs';
 import * as THREE from 'three';
-import { Renderer, WebGLRenderer, WebGLRendererParameters } from 'three';
-import { NgtRef } from './ref';
-export declare type NgtEquConfig = {
+import type { NgtRxStore } from './stores/rx-store';
+export type NgtAnyRecord = Record<string, any>;
+export type NgtNonFunctionKeys<T> = {
+    [K in keyof T]-?: T[K] extends Function ? never : K;
+}[keyof T];
+export type NgtProperties<T> = Pick<T, {
+    [K in keyof T]: T[K] extends (_: any) => any ? never : K;
+}[keyof T]>;
+export type NgtOverwrite<T, O> = Omit<T, NgtNonFunctionKeys<O>> & O;
+export type NgtEquConfig = {
     /** Compare arrays by reference equality a === b (default), or by shallow equality */
     arrays?: 'reference' | 'shallow';
     /** Compare objects by reference equality a === b (default), or by shallow equality */
@@ -12,82 +19,54 @@ export declare 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 declare type NgtObservableInput<T> = T | ObservableInput<T>;
-export declare type NgtAnyRecord = Record<string, any>;
-export declare type NgtAnyFunction<TReturn = any> = (...args: any[]) => TReturn;
-export declare type NgtAnyConstructor<TObject = any> = new (...args: any[]) => TObject;
-export declare type NgtAnyAbstractConstructor<TObject = any> = abstract new (...args: any[]) => TObject;
-export declare type NgtAnyCtor<TObject = any> = NgtAnyConstructor<TObject> | NgtAnyAbstractConstructor<TObject>;
-export declare type NgtProperties<T> = Pick<T, {
-    [K in keyof T]: T[K] extends (_: any) => any ? never : K;
-}[keyof T]>;
-export declare type NgtNonFunctionKeys<T> = {
-    [K in keyof T]-?: T[K] extends Function ? never : K;
-}[keyof T];
-export declare type NgtOverwrite<T, O> = Omit<T, NgtNonFunctionKeys<O>> & O;
-export declare type NgtDpr = number | [min: number, max: number];
-export declare type NgtSize = {
-    width: number;
-    height: number;
-    top: number;
-    left: number;
-    updateStyle?: boolean;
-};
-export declare 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 declare 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 interface NgtIntersection extends THREE.Intersection {
+    /** The event source (the object which registered the handler) */
+    eventObject: THREE.Object3D;
+}
+export interface NgtPointerCaptureTarget {
+    intersection: NgtIntersection;
+    target: Element;
+}
+export type NgtCamera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
+export type NgtCameraManual = NgtCamera & {
+    manual?: boolean;
 };
-export declare type NgtCamera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
-export declare type NgtDomEvent = PointerEvent | MouseEvent | WheelEvent;
 export interface NgtIntersectionEvent<TSourceEvent> extends NgtIntersection {
+    /** The event source (the object which registered the handler) */
+    eventObject: THREE.Object3D;
     /** An array of intersections */
     intersections: NgtIntersection[];
     /** vec3.set(pointer.x, pointer.y, 0).unproject(camera) */
     unprojectedPoint: THREE.Vector3;
-    /** Normalized event coordinates (x: [-1, 1], y: [-1, 1]) */
+    /** Normalized event coordinates */
     pointer: THREE.Vector2;
-    /** delta between first click and this event */
+    /** Delta between first click and this event */
     delta: number;
-    /** the ray casted from the camera */
+    /** The ray that pierced it */
     ray: THREE.Ray;
-    /** the camera used to raycast */
+    /** The camera that was used by the raycaster */
     camera: NgtCamera;
     /** stopPropagation will stop underlying handlers from firing */
     stopPropagation: () => void;
-    /** the original event */
+    /** The original host event */
     nativeEvent: TSourceEvent;
-    /** if the event was stopped by calling stopPropagation */
+    /** If the event was stopped by calling stopPropagation */
     stopped: boolean;
 }
-export interface NgtIntersection extends THREE.Intersection {
-    /** The event source (the object which registered the handler) */
-    eventObject: THREE.Object3D;
-}
-export interface NgtPointerCaptureTarget {
-    intersection: NgtIntersection;
-    target: Element;
+export type NgtThreeEvent<TEvent> = NgtIntersectionEvent<TEvent> & NgtProperties<TEvent>;
+export type NgtDomEvent = PointerEvent | MouseEvent | WheelEvent;
+export interface NgtEvents {
+    click: EventListener;
+    contextmenu: EventListener;
+    dblclick: EventListener;
+    wheel: EventListener;
+    pointerdown: EventListener;
+    pointerup: EventListener;
+    pointerleave: EventListener;
+    pointermove: EventListener;
+    pointercancel: EventListener;
+    lostpointercapture: EventListener;
 }
-export declare type NgtThreeEvent<TEvent> = NgtIntersectionEvent<TEvent>;
 export interface NgtEventHandlers {
     click?: (event: NgtThreeEvent<MouseEvent>) => void;
     contextmenu?: (event: NgtThreeEvent<MouseEvent>) => void;
@@ -103,114 +82,103 @@ export interface NgtEventHandlers {
     pointercancel?: (event: NgtThreeEvent<PointerEvent>) => void;
     wheel?: (event: NgtThreeEvent<WheelEvent>) => void;
 }
-export declare type NgtEvents = {
-    click: EventListener;
-    contextmenu: EventListener;
-    dblclick: EventListener;
-    wheel: EventListener;
-    pointerdown: EventListener;
-    pointerup: EventListener;
-    pointerleave: EventListener;
-    pointermove: EventListener;
-    pointercancel: EventListener;
-    lostpointercapture: EventListener;
-};
-export declare type NgtConditionalType<Child, Parent, Truthy, Falsy> = Child extends Parent ? Truthy : Falsy;
-export interface NgtLoaderProto<T> extends THREE.Loader {
-    load(url: string | string[], onLoad?: (result: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): unknown;
-}
-export interface NgtLoaderExtensions {
-    (loader: THREE.Loader): void;
+export type NgtFilterFunction = (items: THREE.Intersection[], store: NgtRxStore<NgtState>) => THREE.Intersection[];
+export type NgtComputeFunction = (event: NgtDomEvent, root: NgtRxStore<NgtState>, previous?: NgtRxStore<NgtState>) => void;
+export interface NgtEventManager<TTarget = any> {
+    /** 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;
 }
-export declare type NgtLoaderResult<T> = T extends any[] ? NgtLoaderProto<T[number]> : NgtLoaderProto<T>;
-export declare type NgtBranchingReturn<T = any, Parent = any, Coerced = any> = NgtConditionalType<T, Parent, Coerced, T>;
-export interface NgtObjectMap {
-    nodes: {
-        [name: string]: THREE.Object3D;
-    };
-    materials: {
-        [name: string]: THREE.Material;
-    };
-    [key: string]: any;
+export interface 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;
 }
-/**
- * If **T** contains a constructor, @see ConstructorParameters must be used, otherwise **T**.
- */
-export declare type NgtNodeArgs<T> = T extends new (...args: any) => any ? ConstructorParameters<T> : T;
-/**
- * Turn an implementation of THREE.Vector in to the type that an r3f component would accept as a prop.
- */
-declare type NgtVectorLike<VectorClass extends THREE.Vector> = VectorClass | Parameters<VectorClass['set']> | Readonly<Parameters<VectorClass['set']>> | Parameters<VectorClass['setScalar']>[0];
-export declare type NgtVector2 = NgtVectorLike<THREE.Vector2>;
-export declare type NgtVector3 = NgtVectorLike<THREE.Vector3>;
-export declare type NgtVector4 = NgtVectorLike<THREE.Vector4>;
-export declare type NgtLayers = THREE.Layers | Parameters<THREE.Layers['set']>[0];
-export declare type NgtQuaternion = THREE.Quaternion | Parameters<THREE.Quaternion['set']>;
-export declare type NgtEuler = THREE.Euler | Parameters<THREE.Euler['set']>;
-export declare type NgtMatrix4 = THREE.Matrix4 | Parameters<THREE.Matrix4['set']> | Readonly<THREE.Matrix4['set']>;
-export declare type NgtColor = ConstructorParameters<typeof THREE.Color> | THREE.ColorRepresentation;
-export declare type NgtExtendedColors<T> = {
-    [K in keyof T]: T[K] extends THREE.Color | undefined ? NgtColor : T[K];
+export type NgtDpr = number | [min: number, max: number];
+export type NgtSize = {
+    width: number;
+    height: number;
+    top: number;
+    left: number;
 };
-export interface NgtNodeProps<P> {
-    attach?: string[];
-    /** Constructor arguments */
-    args?: NgtNodeArgs<P>;
-}
-export declare type NgtNode<T, P> = NgtExtendedColors<NgtOverwrite<Partial<T>, NgtNodeProps<P>>>;
-export declare type NgtObject3DNode<T, P> = NgtOverwrite<NgtNode<T, P>, {
-    position?: NgtVector3;
-    up?: NgtVector3;
-    scale?: NgtVector3;
-    rotation?: NgtEuler;
-    matrix?: NgtMatrix4;
-    quaternion?: NgtQuaternion;
-    layers?: NgtLayers;
-    dispose?: (() => void) | null;
-}> & NgtEventHandlers;
-export declare type NgtCameraWithManual = NgtCamera & {
-    manual?: boolean;
+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 interface NgtRenderState extends NgtState {
     delta: number;
     frame?: XRFrame;
 }
-export declare type NgtBeforeRenderCallback<TObject = any> = (state: NgtRenderState, obj: TObject) => void;
+export interface NgtBeforeRenderEvent<TObject extends NgtInstanceNode = NgtInstanceNode> {
+    state: NgtRenderState;
+    object: TObject;
+}
 export interface NgtBeforeRenderRecord {
-    obj?: THREE.Object3D | NgtRef;
-    callback: NgtBeforeRenderCallback<THREE.Object3D | undefined>;
+    callback: (state: NgtRenderState) => void;
+    store: NgtRxStore<NgtState>;
     priority?: number;
-    stateFactory: NgtStateFactory;
 }
 export interface NgtInternalState {
     active: boolean;
     priority: number;
     frames: number;
-    lastEvent: NgtDomEvent | null;
+    lastEvent: NgtDomEvent;
     interaction: THREE.Object3D[];
     hovered: Map<string, NgtThreeEvent<NgtDomEvent>>;
     subscribers: NgtBeforeRenderRecord[];
     capturedMap: Map<number, Map<THREE.Object3D, NgtPointerCaptureTarget>>;
     initialClick: [x: number, y: number];
     initialHits: THREE.Object3D[];
-    subscribe: (callback: NgtBeforeRenderCallback, priority?: number, stateFactory?: NgtStateFactory, obj?: THREE.Object3D | NgtRef) => () => void;
+    subscribe: (callback: NgtBeforeRenderRecord['callback'], priority?: number, store?: NgtRxStore<NgtState>) => () => void;
 }
 export interface NgtState {
-    /** The flag to notify if the Canvas is ready to render */
+    /** Set current state */
+    set: NgtRxStore<NgtState>['set'];
+    /** Get current state */
+    get: NgtRxStore<NgtState>['get'];
+    select: NgtRxStore<NgtState>['select'];
+    /** canvas ready state */
     ready: boolean;
     /** The instance of the renderer */
     gl: THREE.WebGLRenderer;
     /** Default camera */
-    camera: NgtCameraWithManual /** Default scene */;
-    cameraRef: NgtRef<NgtCameraWithManual>;
+    camera: NgtCameraManual;
+    /** Default scene */
     scene: THREE.Scene;
-    sceneRef: NgtRef<THREE.Scene>;
     /** Default raycaster */
     raycaster: THREE.Raycaster;
     /** Default clock */
     clock: THREE.Clock;
     /** Event layer interface, contains the event handler and the node they're connected to */
-    events: NgtEventManager<any>;
+    events: NgtEventManager;
     /** XR interface */
     xr: {
         connect: () => void;
@@ -233,7 +201,7 @@ export interface NgtState {
     size: NgtSize;
     /** Reactive size of the viewport in threejs units */
     viewport: NgtViewport & {
-        getCurrentViewport: (camera?: NgtCamera, target?: THREE.Vector3 | Parameters<THREE.Vector3['set']>, size?: NgtSize) => Omit<NgtViewport, 'dpr' | 'initialDpr'>;
+        getCurrentViewport: (camera?: NgtCameraManual, target?: THREE.Vector3 | Parameters<THREE.Vector3['set']>, size?: NgtSize) => Omit<NgtViewport, 'dpr' | 'initialDpr'>;
     };
     /** Flags the canvas for render, but doesn't render in itself */
     invalidate: (frames?: number) => void;
@@ -249,63 +217,87 @@ export interface NgtState {
     setDpr: (dpr: NgtDpr) => void;
     /** Shortcut to frameloop flags */
     setFrameloop: (frameloop?: 'always' | 'demand' | 'never') => void;
-    /** Shortcut to set performance.current for performance regressing */
-    setPerformanceCurrent: (current: number) => void;
-    /** Shortcut to set the current camera */
-    setCamera: (camera: NgtCamera) => void;
-    /** Shortcut to add an object as an Event interaction */
-    addInteraction(interaction: THREE.Object3D): void;
-    /** Shortcut to remove an object UUID from participating in Events */
-    removeInteraction(uuid: string): void;
     /** When the canvas was clicked but nothing was hit */
     onPointerMissed?: (event: MouseEvent) => void;
-    internal: NgtInternalState;
     /** If this state model is layerd (via createPortal) then this contains the previous layer */
-    previousStateFactory?: NgtStateFactory;
-}
-export declare type NgtStateFactory = () => NgtState;
-export declare type NgtFilterFunction = (items: THREE.Intersection[], stateFactory: NgtStateFactory) => THREE.Intersection[];
-export declare type NgtComputeFunction = (event: NgtDomEvent, rootStateFactory: NgtStateFactory, previousStateFactory?: NgtStateFactory) => void;
-export interface 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;
+    previousStore?: NgtRxStore<NgtState>;
+    /** Internals */
+    internal: NgtInternalState;
+    /** shortcuts for add and remove interaction */
+    addInteraction: (interaction: THREE.Object3D) => void;
+    removeInteraction: (uuid: string) => void;
 }
-export declare type NgtAttachFunction<TChild = any, TParent = any> = (parent: NgtRef<TParent>, child: NgtRef<TChild>, stateFactory: NgtStateFactory) => void | (() => void);
+export type NgtAttachFunction<TChild = any, TParent = any> = (parent: TParent, child: TChild, store: NgtRxStore<NgtState>) => void | (() => void);
+export type NgtAfterAttach<TParent extends NgtInstanceNode = NgtInstanceNode, TChild extends NgtInstanceNode = NgtInstanceNode> = {
+    parent: TParent;
+    node: TChild;
+};
 export interface NgtInstanceLocalState {
     /** the state getter of the canvas that the instance is being rendered to */
-    stateFactory: NgtStateFactory;
-    rootFactory: NgtStateFactory;
-    instancesRefs: NgtRef<NgtRef[]>;
-    objectsRefs: NgtRef<NgtRef[]>;
-    parentRef: NgtRef<NgtInstanceNode> | null;
-    isPrimitive?: boolean;
-    isRaw?: boolean;
+    store: NgtRxStore<NgtState>;
+    nonObjects: BehaviorSubject<NgtInstanceNode[]>;
+    objects: BehaviorSubject<NgtInstanceNode[]>;
+    add: (instance: NgtInstanceNode, type: 'objects' | 'nonObjects') => void;
+    remove: (instance: NgtInstanceNode, type: 'objects' | 'nonObjects') => void;
+    parent: NgtInstanceNode | null;
+    primitive?: boolean;
     eventCount: number;
     handlers: Partial<NgtEventHandlers>;
     args?: unknown[];
-    attach?: string[] | (() => void);
-    attachValue?: unknown;
-    memoized?: NgtAnyRecord;
+    attach?: string[] | NgtAttachFunction;
+    previousAttach?: unknown | (() => void);
+    isRaw?: boolean;
+    priority?: number;
+    afterUpdate?: EventEmitter<NgtInstanceNode>;
+    afterAttach?: EventEmitter<NgtAfterAttach>;
 }
-export declare type NgtInstanceNode<TNode = any> = TNode & {
+export type NgtInstanceNode<TNode = any> = TNode & {
     __ngt__: NgtInstanceLocalState;
-    [key: string]: any;
+} & NgtAnyRecord;
+export type NgtGLRenderer = {
+    render: (scene: THREE.Scene, camera: THREE.Camera) => void;
+};
+export type NgtGLOptions = NgtGLRenderer | ((canvas: HTMLCanvasElement) => NgtGLRenderer) | Partial<NgtProperties<THREE.WebGLRenderer> | THREE.WebGLRendererParameters> | undefined;
+export type NgtExtendedColors<T> = {
+    [K in keyof T]: T[K] extends THREE.Color | undefined ? THREE.ColorRepresentation : T[K];
 };
-export declare type NgtGLOptions = Renderer | ((canvas: HTMLCanvasElement) => Renderer) | Partial<NgtProperties<WebGLRenderer> | WebGLRendererParameters> | undefined;
+/**
+ * If **T** contains a constructor, @see ConstructorParameters must be used, otherwise **T**.
+ */
+export type NgtNodeArgs<T> = T extends new (...args: any) => any ? ConstructorParameters<T> : T;
+export interface NgtNodeProps<P> {
+    attach?: string[];
+    /** Constructor arguments */
+    args?: NgtNodeArgs<P>;
+}
+export type NgtNode<T, P> = NgtExtendedColors<NgtOverwrite<Partial<T>, NgtNodeProps<P>>>;
+export type NgtObject3DNode<T, P> = NgtOverwrite<NgtNode<T, P>, {
+    position?: THREE.Vector3 | Parameters<THREE.Vector3['set']>;
+    up?: THREE.Vector3 | Parameters<THREE.Vector3['set']>;
+    scale?: THREE.Vector3 | Parameters<THREE.Vector3['set']>;
+    rotation?: THREE.Euler | Parameters<THREE.Euler['set']>;
+    matrix?: THREE.Matrix4 | Parameters<THREE.Matrix4['set']>;
+    quaternion?: THREE.Quaternion | Parameters<THREE.Quaternion['set']>;
+    layers?: THREE.Layers | Parameters<THREE.Layers['set']>;
+}> & NgtEventHandlers;
+export type NgtConditionalType<Child, Parent, Truthy, Falsy> = Child extends Parent ? Truthy : Falsy;
+export interface NgtLoaderProto<T> extends THREE.Loader {
+    load(url: string | string[], onLoad?: (result: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): unknown;
+}
+export interface NgtLoaderExtensions {
+    (loader: THREE.Loader): void;
+}
+export type NgtLoaderResult<T> = T extends any[] ? NgtLoaderProto<T[number]> : NgtLoaderProto<T>;
+export type NgtBranchingReturn<T = any, Parent = any, Coerced = any> = NgtConditionalType<T, Parent, Coerced, T>;
+export interface NgtObjectMap {
+    nodes: {
+        [name: string]: THREE.Object3D;
+    };
+    materials: {
+        [name: string]: THREE.Material;
+    };
+    [key: string]: any;
+}
 export interface NgtCanvasInputs {
     /** A threejs renderer instance or props that go into the default renderer */
     gl?: NgtGLOptions;
@@ -323,7 +315,7 @@ export interface NgtCanvasInputs {
     legacy?: boolean;
     /** Switch off automatic sRGB encoding and gamma correction */
     linear?: boolean;
-    /** Use `THREE.NoToneMapping` instead of `THREE.ACESFilmicToneMapping` */
+    /** Use `NoToneMapping` instead of `ACESFilmicToneMapping` */
     flat?: boolean;
     /** Creates an orthographic camera */
     orthographic?: boolean;
@@ -341,18 +333,17 @@ export interface NgtCanvasInputs {
     dpr?: NgtDpr;
     /** Props that go into the default raycaster */
     raycaster?: Partial<THREE.Raycaster>;
-    /** A `THREE.Camera` instance or props that go into the default camera */
+    /** A `Camera` instance or props that go into the default camera */
     camera?: (NgtCamera | Partial<NgtObject3DNode<THREE.Camera, typeof THREE.Camera> & NgtObject3DNode<THREE.PerspectiveCamera, typeof THREE.PerspectiveCamera> & NgtObject3DNode<THREE.OrthographicCamera, typeof THREE.OrthographicCamera>>) & {
         /** Flags the camera as manual, putting projection into your own hands */
         manual?: boolean;
     };
     /** An R3F event manager to manage elements' pointer events */
-    events?: (stateFactory: NgtStateFactory) => NgtEventManager<HTMLElement>;
+    events?: (store: NgtRxStore<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?: THREE.Vector3;
+    lookAt?: THREE.Vector3 | Parameters<THREE.Vector3['set']>;
 }
-export {};

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

@@ -1,6 +1,2 @@
-import type { NgtAnyRecord } from '../types';
-export declare function diffProps<TInstance extends object>(instance: TInstance, props: NgtAnyRecord, previousProps?: NgtAnyRecord, remove?: boolean): {
-    changes: [key: string, value: unknown][];
-    memoized: NgtAnyRecord;
-};
-export declare function applyProps<TInstance extends object>(instance: TInstance, props: NgtAnyRecord): TInstance;
+import type { NgtAnyRecord, NgtInstanceNode } from '../types';
+export declare function applyProps(instance: NgtInstanceNode, props: NgtAnyRecord): NgtInstanceNode;

package/lib/utils/attach.d.ts

@@ -0,0 +1,3 @@
+import type { NgtAnyRecord, NgtAttachFunction } from '../types';
+export declare function attach(object: NgtAnyRecord, value: unknown, paths?: string[]): void;
+export declare function detach(parent: NgtAnyRecord, child: NgtAnyRecord, attachProp: string[] | NgtAttachFunction): void;

package/lib/utils/instance.d.ts

@@ -1,4 +1,4 @@
-import { NgtRef } from '../ref';
-import type { NgtAnyRecord, NgtInstanceNode, NgtStateFactory } from '../types';
+import type { NgtAnyRecord, NgtInstanceLocalState, NgtInstanceNode } from '../types';
+export declare function getLocalState<TInstance extends object = NgtAnyRecord>(obj: TInstance | undefined): NgtInstanceLocalState;
 export declare function invalidateInstance<TInstance extends object>(instance: TInstance): void;
-export declare function prepare<TInstance extends object = NgtAnyRecord>(instance: TInstance, parentStateFactory: NgtStateFactory, rootStateFactory: NgtStateFactory, parentInstance?: NgtRef, previousInstance?: NgtRef, isPrimitive?: boolean): NgtInstanceNode<TInstance>;
+export declare function prepare<TInstance extends object = NgtAnyRecord>(object: TInstance, localState?: Partial<NgtInstanceLocalState>): NgtInstanceNode<TInstance>;

package/lib/utils/is.d.ts

@@ -1,21 +1,17 @@
+import { ElementRef } from '@angular/core';
 import * as THREE from 'three';
-import { NgtRef } from '../ref';
 import type { NgtEquConfig } from '../types';
 export declare const is: {
     obj: (a: unknown) => a is object;
     material: (a: unknown) => a is THREE.Material;
     geometry: (a: unknown) => a is THREE.BufferGeometry;
-    mesh: (a: unknown) => a is THREE.Mesh<THREE.BufferGeometry, THREE.Material | THREE.Material[]>;
-    color: (a: unknown) => a is THREE.Color;
-    orthographic: (a: unknown) => a is THREE.OrthographicCamera;
-    perspective: (a: unknown) => a is THREE.PerspectiveCamera;
+    orthographicCamera: (a: unknown) => a is THREE.OrthographicCamera;
+    perspectiveCamera: (a: unknown) => a is THREE.PerspectiveCamera;
     camera: (a: unknown) => a is THREE.Camera;
-    glRenderer: (a: unknown) => a is THREE.WebGLRenderer;
+    renderer: (a: unknown) => a is THREE.WebGLRenderer;
     scene: (a: unknown) => a is THREE.Scene;
-    object3d: (a: unknown) => a is THREE.Object3D<THREE.Event>;
+    object3D: (a: unknown) => a is THREE.Object3D<THREE.Event>;
     instance: (a: unknown) => a is any;
-    ref: (a: unknown) => a is NgtRef<any>;
-    supportColorManagement: () => boolean;
-    canvas: (a: unknown) => a is HTMLCanvasElement;
+    ref: (a: unknown) => a is ElementRef<any>;
     equ(a: any, b: any, { arrays, objects, strict }?: NgtEquConfig): boolean;
 };

package/lib/utils/make.d.ts

@@ -1,4 +1,7 @@
-import type { NgtAnyConstructor, NgtDpr, NgtIntersection } from '../types';
+import * as THREE from 'three';
+import type { NgtDpr, NgtGLOptions, NgtIntersection, NgtObjectMap, NgtSize } from '../types';
 export declare function makeId(event?: NgtIntersection): string;
 export declare function makeDpr(dpr: NgtDpr, window?: Window): number;
-export declare function make<TType extends NgtAnyConstructor>(type: TType, input?: InstanceType<TType> | Parameters<typeof type.prototype['set']> | Parameters<typeof type.prototype['setScalar']>[0] | ConstructorParameters<TType>): InstanceType<TType>;
+export declare function makeDefaultCamera(isOrthographic: boolean, size: NgtSize): THREE.OrthographicCamera | THREE.PerspectiveCamera;
+export declare function makeDefaultRenderer(glOptions: NgtGLOptions, canvasElement: HTMLCanvasElement): THREE.WebGLRenderer;
+export declare function makeObjectGraph(object: THREE.Object3D): NgtObjectMap;

package/lib/utils/update.d.ts

@@ -0,0 +1,4 @@
+import type { NgtCameraManual, NgtSize } from '../types';
+export declare function checkNeedsUpdate(value: unknown): void;
+export declare function checkUpdate(value: unknown): void;
+export declare function updateCamera(camera: NgtCameraManual, size: NgtSize): void;

package/lib/web/events.d.ts

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