angular-three 2.0.0-beta.31 → 2.0.0-beta.310

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,289 @@ 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 type NgtAttachable<TChild = any, TParent = any> = NgtAttachFunction<TChild, TParent> | string | string[];
+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,4 +1,2 @@
-import { type NgtInstanceNode } from '../instance';
-import type { NgtAnyRecord } from '../types';
-export declare function diffProps(instance: NgtAnyRecord, props: NgtAnyRecord): [key: string, value: unknown][];
+import { NgtAnyRecord, NgtInstanceNode } from '../types';
 export declare function applyProps(instance: NgtInstanceNode, props: NgtAnyRecord): any;

package/lib/utils/attach.d.ts

@@ -1,8 +1,6 @@
-import { type NgtAttachFunction } from '../instance';
-import type { NgtState } from '../store';
-import type { NgtAnyRecord } from '../types';
-import type { NgtSignalStore } from './signal-store';
-export declare function attach(object: NgtAnyRecord, value: unknown, paths?: string[]): void;
+import { NgtAnyRecord, NgtAttachFunction, NgtState } from '../types';
+import { NgtSignalStore } from './signal-store';
+export declare function attach(object: NgtAnyRecord, value: unknown, paths?: string[], useApplyProps?: boolean): void;
 export declare function detach(parent: NgtAnyRecord, child: NgtAnyRecord, attachProp: string[] | NgtAttachFunction): void;
 export declare function createAttachFunction<TChild = any, TParent = any>(cb: (params: {
     parent: TParent;

package/lib/{before-render.d.ts → utils/before-render.d.ts}

@@ -1,5 +1,5 @@
 import { Injector } from '@angular/core';
-import { type NgtBeforeRenderRecord } from './store';
+import { NgtBeforeRenderRecord } from '../types';
 export declare function injectBeforeRender(cb: NgtBeforeRenderRecord['callback'], { priority, injector }?: {
     priority?: number;
     injector?: Injector;

package/lib/utils/is.d.ts

@@ -1,20 +1,19 @@
 import { ElementRef } from '@angular/core';
-import * as THREE from 'three';
-import type { NgtRenderer } from '../store';
-import type { NgtEquConfig } from '../types';
+import { BufferGeometry, Camera, Material, Object3D, OrthographicCamera, PerspectiveCamera, Scene, Texture } from 'three';
+import { NgtEquConfig, NgtInstanceNode, NgtRendererLike } 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<THREE.NormalBufferAttributes>;
-    orthographicCamera: (a: unknown) => a is THREE.OrthographicCamera;
-    perspectiveCamera: (a: unknown) => a is THREE.PerspectiveCamera;
-    camera: (a: unknown) => a is THREE.Camera;
-    renderer: (a: unknown) => a is THREE.WebGLRenderer;
-    scene: (a: unknown) => a is THREE.Scene;
-    object3D: (a: unknown) => a is THREE.Object3D<THREE.Object3DEventMap>;
-    instance: (a: unknown) => a is any;
-    ref: (a: unknown) => a is ElementRef<any>;
-    colorSpaceExist: <T extends object | NgtRenderer | THREE.Texture, P = T extends NgtRenderer ? {
+    material: (a: unknown) => a is Material;
+    geometry: (a: unknown) => a is BufferGeometry;
+    orthographicCamera: (a: unknown) => a is OrthographicCamera;
+    perspectiveCamera: (a: unknown) => a is PerspectiveCamera;
+    camera: (a: unknown) => a is Camera;
+    renderer: (a: unknown) => boolean;
+    scene: (a: unknown) => a is Scene;
+    ref: (a: unknown) => a is ElementRef;
+    instance: (a: unknown) => a is NgtInstanceNode;
+    object3D: (a: unknown) => a is Object3D;
+    colorSpaceExist: <T extends NgtRendererLike | Texture | object, P = T extends NgtRendererLike ? {
         outputColorSpace: string;
     } : {
         colorSpace: string;

package/lib/utils/make.d.ts

@@ -1,18 +1,12 @@
-import * as THREE from 'three';
-import type { NgtGLOptions } from '../canvas';
-import type { NgtIntersection } from '../events';
-import type { NgtDpr, NgtSize } from '../store';
+import { Material, Object3D, OrthographicCamera, PerspectiveCamera, WebGLRenderer } from 'three';
+import { NgtCanvasElement, NgtDpr, NgtGLOptions, NgtIntersection, NgtSize } from '../types';
 export declare function makeId(event?: NgtIntersection): string;
 export declare function makeDpr(dpr: NgtDpr, window?: Window): number;
-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 makeRendererInstance<TCanvas extends NgtCanvasElement>(glOptions: NgtGLOptions, canvas: TCanvas): WebGLRenderer;
+export declare function makeCameraInstance(isOrthographic: boolean, size: NgtSize): PerspectiveCamera | OrthographicCamera;
 export type NgtObjectMap = {
-    nodes: {
-        [name: string]: THREE.Object3D;
-    };
-    materials: {
-        [name: string]: THREE.Material;
-    };
+    nodes: Record<string, Object3D<any>>;
+    materials: Record<string, Material>;
     [key: string]: any;
 };
-export declare function makeObjectGraph(object: THREE.Object3D): NgtObjectMap;
+export declare function makeObjectGraph(object: Object3D): NgtObjectMap;

package/lib/utils/non-nullish.d.ts

@@ -0,0 +1,4 @@
+import { Injector, Signal } from '@angular/core';
+export declare function injectNonNullish$(sig: Signal<unknown>, { injector }?: {
+    injector?: Injector;
+}): import("rxjs").Observable<boolean>;

package/lib/utils/object-events.d.ts

@@ -0,0 +1,34 @@
+import { ElementRef, Injector } from '@angular/core';
+import { Object3D } from 'three';
+import { supportedEvents } from '../dom/events';
+import { NgtDomEvent, NgtThreeEvent } from '../types';
+import * as i0 from "@angular/core";
+export declare class NgtObjectEvents {
+    click: import("@angular/core").OutputEmitterRef<NgtThreeEvent<MouseEvent>>;
+    dblclick: import("@angular/core").OutputEmitterRef<NgtThreeEvent<MouseEvent>>;
+    contextmenu: import("@angular/core").OutputEmitterRef<NgtThreeEvent<MouseEvent>>;
+    pointerup: import("@angular/core").OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointerdown: import("@angular/core").OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointerover: import("@angular/core").OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointerout: import("@angular/core").OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointerenter: import("@angular/core").OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointerleave: import("@angular/core").OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointermove: import("@angular/core").OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointermissed: import("@angular/core").OutputEmitterRef<NgtThreeEvent<MouseEvent>>;
+    pointercancel: import("@angular/core").OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    wheel: import("@angular/core").OutputEmitterRef<NgtThreeEvent<WheelEvent>>;
+    ngtObjectEvents: import("@angular/core").ModelSignal<Object3D<import("three").Object3DEventMap> | ElementRef<Object3D<import("three").Object3DEventMap>> | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtObjectEvents, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtObjectEvents, "[ngtObjectEvents]", never, { "ngtObjectEvents": { "alias": "ngtObjectEvents"; "required": false; "isSignal": true; }; }, { "click": "click"; "dblclick": "dblclick"; "contextmenu": "contextmenu"; "pointerup": "pointerup"; "pointerdown": "pointerdown"; "pointerover": "pointerover"; "pointerout": "pointerout"; "pointerenter": "pointerenter"; "pointerleave": "pointerleave"; "pointermove": "pointermove"; "pointermissed": "pointermissed"; "pointercancel": "pointercancel"; "wheel": "wheel"; "ngtObjectEvents": "ngtObjectEventsChange"; }, never, never, true, never>;
+}
+export declare const NgtObjectEventsHostDirective: {
+    directive: typeof NgtObjectEvents;
+    inputs: string[];
+    outputs: string[];
+};
+export declare function injectObjectEvents(target: () => ElementRef<Object3D> | Object3D | null | undefined, events: {
+    [K in (typeof supportedEvents)[number]]?: (event: NgtThreeEvent<NgtDomEvent>) => void;
+}, { injector }?: {
+    injector?: Injector;
+}): (() => void)[];

package/lib/utils/parameters.d.ts

@@ -0,0 +1,20 @@
+import { Signal } from '@angular/core';
+import { Vector2, Vector3, Vector4 } from 'three';
+import { NgtVector2, NgtVector3, NgtVector4 } from '../three-types';
+type KeysOfType<TObject extends object, TType> = Exclude<{
+    [K in keyof TObject]: TObject[K] extends TType | undefined | null ? K : never;
+}[keyof TObject], undefined>;
+export declare function omit<TObject extends object, TKeys extends (keyof TObject)[]>(objFn: () => TObject, keysToOmit: TKeys): Signal<Omit<TObject, TKeys[number]>>;
+export declare function pick<TObject extends object, TKey extends keyof TObject>(objFn: () => TObject, key: TKey): Signal<TObject[TKey]>;
+export declare function pick<TObject extends object, TKeys extends (keyof TObject)[]>(objFn: () => TObject, keys: TKeys): Signal<Pick<TObject, TKeys[number]>>;
+export declare function merge<TObject extends object>(objFn: () => TObject, toMerge: Partial<TObject>, mode?: 'override' | 'backfill'): Signal<TObject & Partial<TObject>>;
+type NgtVectorComputed<TVector extends Vector2 | Vector3 | Vector4, TNgtVector = TVector extends Vector2 ? NgtVector2 : TVector extends Vector3 ? NgtVector3 : NgtVector4> = {
+    (input: Signal<TNgtVector>): Signal<TVector>;
+    (input: Signal<TNgtVector>, keepUndefined: true): Signal<TVector | undefined>;
+    <TObject extends object>(options: Signal<TObject>, key: KeysOfType<TObject, TNgtVector>): Signal<TVector>;
+    <TObject extends object>(options: Signal<TObject>, key: KeysOfType<TObject, TNgtVector>, keepUndefined: true): Signal<TVector | undefined>;
+};
+export declare const vector2: NgtVectorComputed<Vector2, NgtVector2>;
+export declare const vector3: NgtVectorComputed<Vector3, NgtVector3>;
+export declare const vector4: NgtVectorComputed<Vector4, NgtVector4>;
+export {};

package/lib/utils/resolve-ref.d.ts

@@ -0,0 +1,2 @@
+import { ElementRef } from '@angular/core';
+export declare function resolveRef<TObject>(ref: ElementRef<TObject | undefined> | TObject | undefined): TObject | undefined;

package/lib/utils/signal-store.d.ts

@@ -1,4 +1,4 @@
-import { type CreateComputedOptions, type CreateSignalOptions, type Signal } from '@angular/core';
+import { CreateComputedOptions, CreateSignalOptions, Signal } from '@angular/core';
 export type NgtSignalStore<State extends object> = {
     select<Key1 extends keyof State, Key2 extends keyof State[Key1], Key3 extends keyof State[Key1][Key2], Key4 extends keyof State[Key1][Key2][Key3]>(key1: Key1, key2: Key2, key3: Key3, key4: Key4, options?: CreateComputedOptions<State[Key1][Key2][Key3][Key4]>): Signal<State[Key1][Key2][Key3][Key4]>;
     select<Key1 extends keyof State, Key2 extends keyof State[Key1], Key3 extends keyof State[Key1][Key2]>(key1: Key1, key2: Key2, key3: Key3, options?: CreateComputedOptions<State[Key1][Key2][Key3]>): Signal<State[Key1][Key2][Key3]>;
@@ -10,8 +10,17 @@ export type NgtSignalStore<State extends object> = {
     get<Key1 extends keyof State, Key2 extends keyof State[Key1]>(key1: Key1, key2: Key2): State[Key1][Key2];
     get<Key extends keyof State>(key: Key): State[Key];
     get(): State;
-    set(state: Partial<State> | ((previous: State) => Partial<State>)): void;
-    patch(state: Partial<State>): void;
+    /**
+     * New state takes precedence
+     */
+    update(state: Partial<State> | ((previous: State) => Partial<State>)): void;
+    /**
+     * Equivalence to select()
+     */
     state: Signal<State>;
+    /**
+     * Equivalence to get()
+     */
+    get snapshot(): State;
 };
-export declare function signalStore<State extends object>(initialState?: Partial<State> | ((storeApi: Pick<NgtSignalStore<State>, 'get' | 'set' | 'patch' | 'select'>) => Partial<State>), options?: CreateSignalOptions<State>): NgtSignalStore<State>;
+export declare function signalStore<State extends object>(initialState?: Partial<State> | ((storeApi: Pick<NgtSignalStore<State>, 'get' | 'update' | 'select'>) => Partial<State>), options?: CreateSignalOptions<State>): NgtSignalStore<State>;

package/lib/utils/update.d.ts

@@ -1,4 +1,4 @@
-import type { NgtCameraManual, NgtSize } from '../store';
+import { 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;