angular-three 2.0.0-beta.21 → 2.0.0-beta.223

package/lib/store.d.ts

@@ -1,12 +1,11 @@
 /// <reference types="webxr" />
-import { ElementRef, InjectionToken, Injector } from '@angular/core';
+import { ElementRef, InjectionToken } from '@angular/core';
 import { type Observable } from 'rxjs';
 import * as THREE from 'three';
 import type { NgtCamera, NgtDomEvent, NgtEventManager, NgtPointerCaptureTarget, NgtThreeEvent } from './events';
 import type { NgtInstanceNode } from './instance';
-import { type NgtLoop } from './loop';
 import { type NgtSignalStore } from './utils/signal-store';
-export type NgtRenderer = {
+export type NgtRendererLike = {
     render: (scene: THREE.Scene, camera: THREE.Camera) => any;
 };
 export type NgtCameraManual = NgtCamera & {
@@ -70,8 +69,6 @@ export type NgtInternalState = {
     subscribe: (callback: NgtBeforeRenderRecord['callback'], priority?: number, store?: NgtSignalStore<NgtState>) => () => void;
 };
 export type NgtState = {
-    /** when all building blocks are initialized */
-    ready: boolean;
     /** The instance of the renderer */
     gl: THREE.WebGLRenderer;
     /** Default camera */
@@ -125,19 +122,20 @@ export type NgtState = {
     /** When the canvas was clicked but nothing was hit */
     /** PointerMissed Observable */
     pointerMissed$: Observable<MouseEvent>;
-    /** If this state model is layerd (via createPortal) then this contains the previous layer */
+    /** If this state model is layered (via createPortal) then this contains the previous layer */
     previousRoot: NgtSignalStore<NgtState> | null;
     /** Internals */
     internal: NgtInternalState;
 };
-declare function storeFactory(loop: NgtLoop, document: Document, injector: Injector, parent: NgtSignalStore<NgtState> | null): NgtSignalStore<NgtState>;
-export type NgtStore = ReturnType<typeof storeFactory>;
 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; /** Current performance normal, between min and max */
     }): NgtSignalStore<NgtState>;
-    (injectOptions: import("@angular/core").InjectOptions): NgtSignalStore<NgtState> | null;
-}, provideNgtStore: (value?: NgtSignalStore<NgtState> | undefined) => import("@angular/core").Provider;
-export {};
+    (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);

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

@@ -1,4 +1,3 @@
 import { type NgtInstanceNode } from '../instance';
 import type { NgtAnyRecord } from '../types';
-export declare function diffProps(instance: NgtAnyRecord, props: NgtAnyRecord): [key: string, value: unknown][];
 export declare function applyProps(instance: NgtInstanceNode, props: NgtAnyRecord): any;

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 { type NgtBeforeRenderRecord } from '../store';
 export declare function injectBeforeRender(cb: NgtBeforeRenderRecord['callback'], { priority, injector }?: {
     priority?: number;
     injector?: Injector;

package/lib/utils/cd-aware-signal.d.ts

@@ -0,0 +1,4 @@
+import { type CreateSignalOptions, type Injector } from '@angular/core';
+export declare function cdAwareSignal<T>(initialValue: T, { injector, ...options }?: CreateSignalOptions<T> & {
+    injector?: Injector;
+}): import("@angular/core").WritableSignal<T>;

package/lib/utils/create-api-token.d.ts

@@ -0,0 +1,23 @@
+import { type Type } from '@angular/core';
+import { type CreateInjectionTokenOptions } from 'ngxtension/create-injection-token';
+declare function apiFactory<TObject extends {
+    api: any;
+}, TApi = TObject extends {
+    api: infer Api;
+} ? Api : never>(obj: TObject): TApi;
+export declare function createApiToken<TObject extends {
+    api: any;
+}, TApi = TObject extends {
+    api: infer Api;
+} ? Api : never>(forwardedObject: () => Type<TObject>): readonly [{
+    (): CreateInjectionTokenOptions<typeof apiFactory, [TObject]>["multi"] extends true ? TApi[] : TApi;
+    (injectOptions: import("@angular/core").InjectOptions & {
+        optional?: false | undefined;
+    } & {
+        injector?: import("@angular/core").Injector | undefined;
+    }): CreateInjectionTokenOptions<typeof apiFactory, [TObject]>["multi"] extends true ? TApi[] : TApi;
+    (injectOptions: import("@angular/core").InjectOptions & {
+        injector?: import("@angular/core").Injector | undefined;
+    }): (CreateInjectionTokenOptions<typeof apiFactory, [TObject]>["multi"] extends true ? TApi[] : TApi) | null;
+}, () => import("@angular/core").Provider];
+export {};

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

package/lib/utils/make.d.ts

@@ -1,11 +1,12 @@
 import * as THREE from 'three';
 import type { NgtGLOptions } from '../canvas';
 import type { NgtIntersection } from '../events';
+import type { NgtCanvasElement } from '../roots';
 import type { NgtDpr, NgtSize } from '../store';
 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): THREE.WebGLRenderer;
+export declare function makeCameraInstance(isOrthographic: boolean, size: NgtSize): THREE.OrthographicCamera | THREE.PerspectiveCamera;
 export type NgtObjectMap = {
     nodes: {
         [name: string]: THREE.Object3D;

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

@@ -10,8 +10,21 @@ 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;
+    /**
+     * Non-undefined old state takes precedence
+     */
+    patch(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'>) => Partial<State>), options?: CreateSignalOptions<State>): NgtSignalStore<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>;