angular-three 2.0.0-beta.242 → 2.0.0-beta.244

package/lib/directives/args.d.ts

@@ -1,10 +1,17 @@
-import { NgtCommonDirective } from './common';
 import * as i0 from "@angular/core";
-export declare class NgtArgs<TArgs extends any[] = any[]> extends NgtCommonDirective<TArgs> {
+export declare class NgtArgs<TArgs extends any[] = any[]> {
     args: import("@angular/core").InputSignal<TArgs | null>;
-    protected inputValue: import("@angular/core").InputSignal<TArgs | null>;
-    protected shouldSkipCreateView(value: TArgs | null): boolean;
+    private vcr;
+    private zone;
+    private template;
+    private autoEffect;
+    protected injected: boolean;
+    protected injectedArgs: TArgs | null;
+    private view?;
+    constructor();
+    get value(): TArgs | null;
     validate(): boolean;
+    private createView;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtArgs<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgtArgs<any>, "ng-template[args]", never, { "args": { "alias": "args"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/instance.d.ts

@@ -1,43 +1,38 @@
 import { Signal } from '@angular/core';
-import { ReplaySubject } from 'rxjs';
 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 type NgtAfterAttach<TChild extends NgtInstanceNode = NgtInstanceNode, TParent extends NgtInstanceNode = NgtInstanceNode> = {
+export interface NgtAfterAttach<TChild extends NgtInstanceNode = NgtInstanceNode, TParent extends NgtInstanceNode = NgtInstanceNode> {
     parent: TParent;
     node: TChild;
-};
-export type NgtLocalInstanceState = {
+}
+export interface NgtLocalInstanceState {
     objects: NgtInstanceNode[];
     nonObjects: NgtInstanceNode[];
     parent: NgtInstanceNode | null;
-    nativeProps: NgtAnyRecord;
-};
-export type NgtLocalState = {
+}
+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']>;
-    nativeProps: Signal<NgtLocalInstanceState['nativeProps']>;
     add: (instance: NgtInstanceNode, type: 'objects' | 'nonObjects') => void;
     remove: (instance: NgtInstanceNode, type: 'objects' | 'nonObjects') => void;
-    setNativeProps: (key: string, value: any) => void;
     setParent: (parent: NgtInstanceNode | null) => void;
     primitive?: boolean;
     eventCount: number;
     handlers: Partial<NgtEventHandlers>;
-    args?: unknown[];
     attach?: string[] | NgtAttachFunction;
     previousAttach?: unknown | (() => void);
     isRaw?: boolean;
     priority?: number;
-    afterUpdate?: ReplaySubject<NgtInstanceNode>;
-    afterAttach?: ReplaySubject<NgtAfterAttach>;
-};
+    onUpdate?: (node: NgtInstanceNode) => void;
+    onAttach?: (afterAttach: NgtAfterAttach) => void;
+}
 export type NgtInstanceNode<TNode = any> = {
     __ngt__: NgtLocalState;
 } & NgtAnyRecord & TNode;

package/lib/loop.d.ts

@@ -19,7 +19,7 @@ export declare const addAfterEffect: (callback: NgtGlobalRenderCallback) => () =
 export declare const addTail: (callback: NgtGlobalRenderCallback) => () => void;
 export type NgtGlobalEffectType = 'before' | 'after' | 'tail';
 export declare function flushGlobalEffects(type: NgtGlobalEffectType, timestamp: number): void;
-export declare const injectNgtLoop: {
+export declare const injectLoop: {
     (): {
         loop: (timestamp: number) => void;
         invalidate: (store?: NgtSignalStore<NgtState>, frames?: number) => void;

package/lib/portal.d.ts

@@ -1,21 +1,10 @@
-import { ElementRef, TemplateRef, ViewContainerRef } from '@angular/core';
+import { Injector, TemplateRef, ViewContainerRef } from '@angular/core';
 import { Camera, Object3D, Scene } from 'three';
-import { NgtEventManager } from './events';
+import { NgtComputeFunction } from './events';
 import { NgtSize, NgtState } from './store';
 import * as i0 from "@angular/core";
-declare const privateKeys: readonly ["get", "set", "select", "setSize", "setDpr", "setFrameloop", "events", "invalidate", "advance", "size", "viewport"];
-type PrivateKeys = (typeof privateKeys)[number];
-export interface NgtPortalInputs {
-    container: ElementRef<Object3D> | Object3D;
-    camera: ElementRef<Camera> | Camera;
-    state: Partial<Omit<NgtState, PrivateKeys> & {
-        events: Partial<Pick<NgtEventManager<any>, 'enabled' | 'priority' | 'compute' | 'connected'>>;
-        size: NgtSize;
-    }>;
-}
 export declare class NgtPortalBeforeRender {
     private portalStore;
-    private injector;
     renderPriority: import("@angular/core").InputSignal<number>;
     parentScene: import("@angular/core").InputSignal<Scene>;
     parentCamera: import("@angular/core").InputSignal<Camera>;
@@ -25,34 +14,55 @@ export declare class NgtPortalBeforeRender {
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtPortalBeforeRender, "ngt-portal-before-render", never, { "renderPriority": { "alias": "renderPriority"; "required": false; "isSignal": true; }; "parentScene": { "alias": "parentScene"; "required": true; "isSignal": true; }; "parentCamera": { "alias": "parentCamera"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 export declare class NgtPortalContent {
-    constructor(vcr: ViewContainerRef, parentVcr: ViewContainerRef);
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtPortalContent, [null, { skipSelf: true; }]>;
+    constructor();
+    static ngTemplateContextGuard(_: NgtPortalContent, ctx: unknown): ctx is {
+        container: Object3D;
+        injector: Injector;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtPortalContent, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgtPortalContent, "ng-template[portalContent]", never, {}, {}, never, never, true, never>;
 }
+export declare const privateKeys: readonly ["setSize", "setFrameloop", "setDpr", "events", "setEvents", "invalidate", "advance", "size", "viewport"];
+export type NgtPortalPrivateKeys = (typeof privateKeys)[number];
+export type NgtPortalInjectableState = Partial<Omit<NgtState, NgtPortalPrivateKeys> & {
+    events?: {
+        enabled?: boolean;
+        priority?: number;
+        compute?: NgtComputeFunction;
+        connected?: any;
+    };
+    size?: NgtSize;
+}>;
 export declare class NgtPortal {
     container: import("@angular/core").InputSignal<Object3D<import("three").Object3DEventMap>>;
-    camera: import("@angular/core").InputSignal<Camera | ElementRef<Camera> | undefined>;
-    state: import("@angular/core").InputSignal<Partial<Omit<NgtState, "set" | "setSize" | "get" | "select" | "viewport" | "events" | "size" | "invalidate" | "advance" | "setDpr" | "setFrameloop"> & {
-        events: Partial<Pick<NgtEventManager<any>, 'enabled' | 'priority' | 'compute' | 'connected'>>;
-        size: NgtSize;
-    }> | undefined>;
+    state: import("@angular/core").InputSignal<Partial<Omit<NgtState, "setSize" | "viewport" | "events" | "size" | "invalidate" | "advance" | "setEvents" | "setDpr" | "setFrameloop"> & {
+        events?: {
+            enabled?: boolean | undefined;
+            priority?: number | undefined;
+            compute?: NgtComputeFunction | undefined;
+            connected?: any;
+        } | undefined;
+        size?: NgtSize | undefined;
+    }>>;
+    /**
+     * @decsription turn this on to enable "HUD" like rendering
+     */
     autoRender: import("@angular/core").InputSignal<boolean>;
     autoRenderPriority: import("@angular/core").InputSignal<number>;
-    portalContentTemplate: import("@angular/core").Signal<TemplateRef<any>>;
-    portalContentAnchor: import("@angular/core").Signal<ViewContainerRef>;
-    private destroyRef;
-    private autoEffect;
-    private parentStore;
+    portalContent: import("@angular/core").Signal<TemplateRef<any>>;
+    portalAnchor: import("@angular/core").Signal<ViewContainerRef>;
+    private injector;
     private portalStore;
-    private portalRendered;
-    protected renderAutoBeforeRender: import("@angular/core").Signal<boolean>;
-    protected parentScene: Scene;
-    protected parentCamera: import("./store").NgtCameraManual;
+    private parentStore;
+    parentScene: import("@angular/core").Signal<Scene>;
+    parentCamera: import("@angular/core").Signal<import("./store").NgtCameraManual>;
     private raycaster;
     private pointer;
+    private portalRendered;
+    renderAutoBeforeRender: import("@angular/core").Signal<boolean>;
+    private portalView?;
     constructor();
     private inject;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtPortal, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtPortal, "ngt-portal", never, { "container": { "alias": "container"; "required": false; "isSignal": true; }; "camera": { "alias": "camera"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "autoRender": { "alias": "autoRender"; "required": false; "isSignal": true; }; "autoRenderPriority": { "alias": "autoRenderPriority"; "required": false; "isSignal": true; }; }, {}, ["portalContentTemplate"], never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtPortal, "ngt-portal", never, { "container": { "alias": "container"; "required": true; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "autoRender": { "alias": "autoRender"; "required": false; "isSignal": true; }; "autoRenderPriority": { "alias": "autoRenderPriority"; "required": false; "isSignal": true; }; }, {}, ["portalContent"], never, true, never>;
 }
-export {};

package/lib/renderer/catalogue.d.ts

@@ -1,6 +1,6 @@
 export type NgtAnyConstructor = new (...args: any[]) => any;
 export declare function extend(objects: object): void;
-export declare const injectNgtCatalogue: {
+export declare const injectCatalogue: {
     (): Record<string, NgtAnyConstructor>;
     (injectOptions: import("@angular/core").InjectOptions & {
         optional?: false | undefined;

package/lib/renderer/constants.d.ts

@@ -7,15 +7,13 @@ export declare const SPECIAL_DOM_TAG: {
     readonly NGT_VALUE: "ngt-value";
 };
 export declare const SPECIAL_PROPERTIES: {
-    readonly COMPOUND: "ngtCompound";
     readonly RENDER_PRIORITY: "priority";
     readonly ATTACH: "attach";
     readonly RAW_VALUE: "rawValue";
     readonly PARAMETERS: "parameters";
-    readonly REF: "ref";
 };
 export declare const SPECIAL_EVENTS: {
     readonly BEFORE_RENDER: "beforeRender";
-    readonly AFTER_UPDATE: "afterUpdate";
-    readonly AFTER_ATTACH: "afterAttach";
+    readonly UPDATED: "updated";
+    readonly ATTACHED: "attached";
 };

package/lib/renderer/index.d.ts

@@ -3,24 +3,29 @@ import { NgtState } from '../store';
 import { NgtAnyRecord } from '../types';
 import { NgtSignalStore } from '../utils/signal-store';
 import { NgtAnyConstructor } from './catalogue';
-import { NgtRendererNode, NgtRendererState, NgtRendererStore } from './store';
+import { NgtRendererNode, NgtRendererState } from './state';
 import * as i0 from "@angular/core";
 export declare class NgtRendererFactory implements RendererFactory2 {
     private delegateRendererFactory;
+    private document;
     private catalogue;
+    private rootStore;
+    private portalCommentsNodes;
     private rendererMap;
     private routedSet;
-    private rendererStore;
     createRenderer(hostElement: any, type: RendererType2 | null): Renderer2;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtRendererFactory, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NgtRendererFactory>;
 }
 export declare class NgtRenderer implements Renderer2 {
     private delegate;
-    private store;
+    private rootStore;
+    private document;
+    private portalCommentsNodes;
     private catalogue;
     private isRoot;
-    constructor(delegate: Renderer2, store: NgtRendererStore, catalogue: Record<string, NgtAnyConstructor>, isRoot?: boolean);
+    private argsCommentNodes;
+    constructor(delegate: Renderer2, rootStore: NgtSignalStore<NgtState>, document: Document, portalCommentsNodes: Array<NgtRendererNode>, catalogue: Record<string, NgtAnyConstructor>, isRoot?: boolean);
     createElement(name: string, namespace?: string | null | undefined): NgtAnyRecord & {
         __ngt_renderer__: NgtRendererState;
     };
@@ -36,7 +41,12 @@ export declare class NgtRenderer implements Renderer2 {
     removeAttribute(el: NgtRendererNode, name: string, namespace?: string | null | undefined): void;
     setProperty(el: NgtRendererNode, name: string, value: any): void;
     listen(target: NgtRendererNode, eventName: string, callback: (event: any) => boolean | void): () => void;
+    private destroyInternal;
+    private removeCommentNode;
+    private processPortalContainer;
     private shouldFindGrandparentInstance;
+    private getNgtArgs;
+    private tryGetPortalStore;
     createText: (value: string) => any;
     destroy: () => void;
     destroyNode: ((node: any) => void) | null;
@@ -51,6 +61,6 @@ export declare class NgtRenderer implements Renderer2 {
         [key: string]: any;
     };
 }
-export declare function provideNgtRenderer(store: NgtSignalStore<NgtState>, compoundPrefixes: string[]): import("@angular/core").EnvironmentProviders;
+export declare function provideNgtRenderer(store: NgtSignalStore<NgtState>): import("@angular/core").EnvironmentProviders;
 export { extend } from './catalogue';
 export { HTML, ROUTED_SCENE } from './constants';

package/lib/renderer/state.d.ts

@@ -0,0 +1,23 @@
+import { Injector } from '@angular/core';
+import { NgtAnyRecord } from '../types';
+import { NgtRendererClassId } from './utils';
+export type NgtRendererState = [
+    type: 'three' | 'portal' | 'comment' | 'dom',
+    parent: NgtRendererNode | null,
+    children: NgtRendererNode[],
+    destroyed: boolean,
+    rawValue: any,
+    portalContainer: NgtRendererNode,
+    injectorFactory: () => Injector | undefined
+];
+export interface NgtRendererNode {
+    __ngt_renderer__: NgtRendererState;
+}
+export declare function createNode(type: NgtRendererState[NgtRendererClassId.type], node: NgtAnyRecord, document: Document): NgtAnyRecord & {
+    __ngt_renderer__: NgtRendererState;
+};
+export declare function isDOM(node: NgtAnyRecord): boolean;
+export declare function getClosestParentWithInstance(node: NgtRendererNode): NgtRendererNode | null;
+export declare function setParent(node: NgtRendererNode, parent: NgtRendererNode): void;
+export declare function addChild(node: NgtRendererNode, child: NgtRendererNode): void;
+export declare function removeChild(node: NgtRendererNode, child: NgtRendererNode): void;

package/lib/renderer/utils.d.ts

@@ -2,28 +2,11 @@ import { NgtInstanceNode } from '../instance';
 export declare const enum NgtRendererClassId {
     type = 0,
     parent = 1,
-    injectedParent = 2,
-    children = 3,
-    destroyed = 4,
-    compound = 5,
-    compoundParent = 6,
-    compounded = 7,
-    queueOps = 8,
-    attributes = 9,
-    properties = 10,
-    rawValue = 11,
-    ref = 12,
-    portalContainer = 13,
-    injectorFactory = 14
-}
-export declare const enum NgtCompoundClassId {
-    applyFirst = 0,
-    props = 1
-}
-export declare const enum NgtQueueOpClassId {
-    type = 0,
-    op = 1,
-    done = 2
+    children = 2,
+    destroyed = 3,
+    rawValue = 4,
+    portalContainer = 5,
+    injectorFactory = 6
 }
 export declare function kebabToPascal(str: string): string;
 export declare function attachThreeChild(parent: NgtInstanceNode, child: NgtInstanceNode): void;

package/lib/roots.d.ts

@@ -10,3 +10,8 @@ export declare function injectCanvasRootInitializer(injector?: Injector): (canva
     configure: (inputs: NgtCanvasInputs) => void;
 };
 export type NgtCanvasConfigurator = ReturnType<ReturnType<typeof injectCanvasRootInitializer>>;
+export declare function dispose<TObj extends {
+    dispose?: () => void;
+    type?: string;
+    [key: string]: any;
+}>(obj: TObj): void;

package/lib/store.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="webxr" />
-import { ElementRef, InjectionToken } from '@angular/core';
+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';
@@ -127,15 +127,15 @@ export type NgtState = {
     /** Internals */
     internal: NgtInternalState;
 };
+declare function storeFactory(previousStore: NgtSignalStore<NgtState> | null): NgtSignalStore<NgtState>;
 export declare const NGT_STORE: InjectionToken<NgtSignalStore<NgtState>>;
-export declare const injectNgtStore: {
-    (): NgtSignalStore<NgtState>;
-    (injectOptions: import("@angular/core").InjectOptions & {
-        optional?: false | undefined;
-    } & {
-        injector?: import("@angular/core").Injector | undefined;
-    }): NgtSignalStore<NgtState>;
-    (injectOptions: import("@angular/core").InjectOptions & {
-        injector?: import("@angular/core").Injector | undefined;
-    }): NgtSignalStore<NgtState> | null;
-}, provideNgtStore: (() => import("@angular/core").Provider) & ((value: NgtSignalStore<NgtState> | (() => NgtSignalStore<NgtState>)) => import("@angular/core").Provider);
+export declare function provideStore(store?: () => NgtSignalStore<NgtState>): {
+    provide: InjectionToken<NgtSignalStore<NgtState>>;
+    useFactory: typeof storeFactory;
+};
+export declare function injectStore(options: InjectOptions & {
+    optional?: false;
+}): NgtSignalStore<NgtState>;
+export declare function injectStore(options: InjectOptions): NgtSignalStore<NgtState> | null;
+export declare function injectStore(): NgtSignalStore<NgtState>;
+export {};

package/lib/three-types.d.ts

@@ -2,6 +2,9 @@ import { AmbientLight, ArrayCamera, ArrowHelper, Audio, AxesHelper, Bone, Box3He
 import { NgtEventHandlers } from './events';
 import { NgtAfterAttach, NgtAttachFunction, NgtInstanceNode } from './instance';
 import { NgtBeforeRenderEvent } from './store';
+type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
 type NoEvent<T> = Omit<T, 'addEventListener' | 'removeEventListener'>;
 export type NgtNonFunctionKeys<T> = {
     [K in keyof T]-?: T[K] extends Function ? never : K;
@@ -26,8 +29,8 @@ export type NgtVector4 = NgtVectorLike<Vector4>;
 export type NgtLayers = Layers | Parameters<Layers['set']>[0];
 export type NgtQuaternion = Quaternion | Parameters<Quaternion['set']>;
 export interface NgtNodeEventMap<TOriginal> {
-    afterAttach: NgtAfterAttach<NgtInstanceNode, TOriginal>;
-    afterUpdate: TOriginal;
+    attached: NgtAfterAttach<NgtInstanceNode, TOriginal>;
+    updated: TOriginal;
     beforeRender: NgtBeforeRenderEvent<TOriginal>;
 }
 export type NgtNodeElement<TOriginal, TConstructor> = {
@@ -36,11 +39,11 @@ export type NgtNodeElement<TOriginal, TConstructor> = {
     removeEventListener<TEventKey extends keyof NgtNodeEventMap<TOriginal>>(type: TEventKey, listener: (this: NgtNodeElement<TOriginal, TConstructor>, ev: NgtNodeEventMap<TOriginal>[TEventKey]) => any): void;
     __ngt_args__: NgtArguments<TConstructor>;
 };
-export type NgtNode<TOriginal, TConstructor, TNoEvent = NoEvent<TOriginal>> = NgtExtendedColors<NgtOverwrite<Partial<TNoEvent>, NgtNodeElement<TOriginal, TConstructor>>>;
+export type NgtNode<TOriginal, TConstructor, TNoEvent = NoEvent<TOriginal>> = Expand<NgtExtendedColors<NgtOverwrite<Partial<TNoEvent>, NgtNodeElement<TOriginal, TConstructor>>>>;
 export type NgtObject3DEventsMap = {
     [TEvent in keyof NgtEventHandlers]-?: Parameters<NonNullable<NgtEventHandlers[TEvent]>>[0];
 };
-export type NgtObject3DNode<TOriginal, TConstructor, TNoEvent = NoEvent<TOriginal>> = NgtOverwrite<NgtNode<TOriginal, TConstructor, TNoEvent>, {
+export type NgtObject3DNode<TOriginal, TConstructor, TNoEvent = NoEvent<TOriginal>> = Expand<NgtOverwrite<NgtNode<TOriginal, TConstructor, TNoEvent>, {
     position: NgtVector3;
     up: NgtVector3;
     scale: NgtVector3;
@@ -51,7 +54,7 @@ export type NgtObject3DNode<TOriginal, TConstructor, TNoEvent = NoEvent<TOrigina
     dispose: (() => void) | null;
     addEventListener<TEventKey extends keyof NgtObject3DEventsMap>(type: TEventKey, listener: (this: NgtObject3DNode<TOriginal, TConstructor>, ev: NgtObject3DEventsMap[TEventKey]) => any): void;
     removeEventListener<TEventKey extends keyof NgtObject3DEventsMap>(type: TEventKey, listener: (this: NgtObject3DNode<TOriginal, TConstructor>, ev: NgtObject3DEventsMap[TEventKey]) => any): void;
-}>;
+}>>;
 export type NgtGeometry<TGeometry extends BufferGeometry, TConstructor> = NgtNode<TGeometry, TConstructor>;
 export type NgtMaterial<TMaterial extends Material, TConstructor> = NgtNode<TMaterial, TConstructor>;
 export type NgtLight<T extends Light, P> = NgtObject3DNode<T, P>;

package/lib/utils/parameters.d.ts

@@ -1,18 +1,15 @@
 import { Signal } from '@angular/core';
 import { Vector2, Vector3 } from 'three';
 import { NgtVector2, NgtVector3 } from '../three-types';
-export type Excluded<TOptions extends object, TKeys extends (keyof TOptions)[]> = {
-    [K in Exclude<keyof TOptions, TKeys[number]>]: TOptions[K];
-};
-export declare function exclude<TOptions extends object, TKeys extends (keyof TOptions)[]>(options: () => TOptions, keysToExclude: TKeys): Signal<Excluded<TOptions, TKeys>>;
-export type Picked<TOptions extends object, TKeyOption extends (keyof TOptions)[]> = {
-    [K in TKeyOption[number]]: TOptions[K];
-};
-export declare function pick<TOptions extends object, TKeyOption extends keyof TOptions | (keyof TOptions)[]>(options: () => TOptions, keys: TKeyOption): TKeyOption extends keyof TOptions ? Signal<TOptions[TKeyOption]> : TKeyOption extends (keyof TOptions)[] ? Signal<Picked<TOptions, TKeyOption>> : never;
-export declare function merge<TOptions extends object>(options: () => TOptions, toMerge: Partial<TOptions>, mode?: 'override' | 'backfill'): Signal<TOptions & Partial<TOptions>>;
 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>>;
 export declare function vector2<TObject extends object>(options: Signal<TObject>, key: KeysOfType<TObject, NgtVector2>): Signal<Vector2>;
+export declare function vector2<TObject extends object>(options: Signal<TObject>, key: KeysOfType<TObject, NgtVector2>, keepUndefined: true): Signal<Vector2 | undefined>;
 export declare function vector3<TObject extends object>(options: Signal<TObject>, key: KeysOfType<TObject, NgtVector3>): Signal<Vector3>;
+export declare function vector3<TObject extends object>(options: Signal<TObject>, key: KeysOfType<TObject, NgtVector3>, keepUndefined: true): Signal<Vector3 | undefined>;
 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

@@ -14,10 +14,6 @@ export type NgtSignalStore<State extends object> = {
      * New state takes precedence
      */
     update(state: Partial<State> | ((previous: State) => Partial<State>)): void;
-    /**
-     * Non-undefined old state takes precedence
-     */
-    patch(state: Partial<State> | ((previous: State) => Partial<State>)): void;
     /**
      * Equivalence to select()
      */
@@ -27,4 +23,4 @@ export type NgtSignalStore<State extends object> = {
      */
     get snapshot(): State;
 };
-export declare function signalStore<State extends object>(initialState?: Partial<State> | ((storeApi: Pick<NgtSignalStore<State>, 'get' | 'update' | '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>;