angular-three 1.9.16 → 1.10.1

package/lib/canvas.d.ts

@@ -42,5 +42,5 @@ export declare class NgtCanvas extends NgtRxStore<NgtCanvasInputs> implements On
     private overrideDetectChanges;
     private setSceneGraphInputs;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtCanvas, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtCanvas, "ngt-canvas", never, { "sceneGraph": "sceneGraph"; "sceneGraphInputs": "sceneGraphInputs"; "compoundPrefixes": "compoundPrefixes"; "linear": "linear"; "legacy": "legacy"; "flat": "flat"; "orthographic": "orthographic"; "frameloop": "frameloop"; "dpr": "dpr"; "raycaster": "raycaster"; "shadows": "shadows"; "camera": "camera"; "gl": "gl"; "eventSource": "eventSource"; "eventPrefix": "eventPrefix"; "lookAt": "lookAt"; "performance": "performance"; }, { "created": "created"; "pointerMissed": "pointerMissed"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtCanvas, "ngt-canvas", never, { "sceneGraph": { "alias": "sceneGraph"; "required": false; }; "sceneGraphInputs": { "alias": "sceneGraphInputs"; "required": false; }; "compoundPrefixes": { "alias": "compoundPrefixes"; "required": false; }; "linear": { "alias": "linear"; "required": false; }; "legacy": { "alias": "legacy"; "required": false; }; "flat": { "alias": "flat"; "required": false; }; "orthographic": { "alias": "orthographic"; "required": false; }; "frameloop": { "alias": "frameloop"; "required": false; }; "dpr": { "alias": "dpr"; "required": false; }; "raycaster": { "alias": "raycaster"; "required": false; }; "shadows": { "alias": "shadows"; "required": false; }; "camera": { "alias": "camera"; "required": false; }; "gl": { "alias": "gl"; "required": false; }; "eventSource": { "alias": "eventSource"; "required": false; }; "eventPrefix": { "alias": "eventPrefix"; "required": false; }; "lookAt": { "alias": "lookAt"; "required": false; }; "performance": { "alias": "performance"; "required": false; }; }, { "created": "created"; "pointerMissed": "pointerMissed"; }, never, never, true, never>;
 }

package/lib/directives/args.d.ts

@@ -6,5 +6,5 @@ export declare class NgtArgs extends NgtCommonDirective {
     get args(): any[] | null;
     validate(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtArgs, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtArgs, "[args]", never, { "args": "args"; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtArgs, "[args]", never, { "args": { "alias": "args"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/directives/parent.d.ts

@@ -7,5 +7,5 @@ export declare class NgtParent extends NgtCommonDirective {
     get parent(): string | THREE.Object3D | NgtInjectedRef<THREE.Object3D>;
     validate(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtParent, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtParent, "[parent]", never, { "parent": "parent"; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtParent, "[parent]", never, { "parent": { "alias": "parent"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/directives/repeat.d.ts

@@ -3,5 +3,5 @@ import * as i0 from "@angular/core";
 export declare class NgtRepeat extends NgForOf<number> {
     set ngForRepeat(count: number);
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtRepeat, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtRepeat, "[ngFor][ngForRepeat]", never, { "ngForRepeat": "ngForRepeat"; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtRepeat, "[ngFor][ngForRepeat]", never, { "ngForRepeat": { "alias": "ngForRepeat"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/loader.d.ts

@@ -1,15 +1,7 @@
-import { Observable } from 'rxjs';
+import { type Observable } from 'rxjs';
 import type { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
-import type { NgtBranchingReturn, NgtLoaderExtensions, NgtLoaderResult, NgtObjectMap } from './types';
-interface NgtLoader {
-    <TReturnType, TUrl extends string | string[] | Record<string, string>>(loaderConstructorFactory: (inputs: TUrl) => new (...args: any[]) => NgtLoaderResult<TReturnType>, input: TUrl | Observable<TUrl>, extensions?: NgtLoaderExtensions<NgtLoaderResult<TReturnType>>, onProgress?: (event: ProgressEvent) => void): Observable<TUrl extends string[] ? Array<NgtBranchingReturn<TReturnType, GLTF, GLTF & NgtObjectMap>> : TUrl extends object ? {
-        [key in keyof TUrl]: NgtBranchingReturn<TReturnType, GLTF, GLTF & NgtObjectMap>;
-    } : NgtBranchingReturn<TReturnType, GLTF, GLTF & NgtObjectMap>>;
-    destroy: () => void;
-    preLoad: <TReturnType, TUrl extends string | string[] | Record<string, string>>(loaderConstructorFactory: (inputs: TUrl) => new (...args: any[]) => NgtLoaderResult<TReturnType>, inputs: TUrl | Observable<TUrl>, extensions?: NgtLoaderExtensions) => void;
-}
+import type { NgtBranchingReturn, NgtLoaderExtensions, NgtLoaderProto, NgtLoaderReturnType, NgtObjectMap } from './types';
 export type NgtLoaderResults<TInput extends string | string[] | Record<string, string>, TReturn> = TInput extends string[] ? TReturn[] : TInput extends object ? {
     [key in keyof TInput]: TReturn;
 } : TReturn;
-export declare const injectNgtLoader: NgtLoader;
-export {};
+export declare function injectNgtLoader<TData, TUrl extends string | string[] | Record<string, string>, TLoaderConstructor extends NgtLoaderProto<TData>, TReturn = NgtLoaderReturnType<TData, TLoaderConstructor>>(loaderConstructorFactory: (inputs: TUrl) => TLoaderConstructor, input: TUrl | Observable<TUrl>, extensions?: NgtLoaderExtensions<TLoaderConstructor>, onProgress?: (event: ProgressEvent) => void): Observable<NgtLoaderResults<TUrl, NgtBranchingReturn<TReturn, GLTF, GLTF & NgtObjectMap>>>;

package/lib/portal.d.ts

@@ -23,7 +23,7 @@ export declare class NgtPortalBeforeRender implements OnInit, OnDestroy {
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtPortalBeforeRender, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtPortalBeforeRender, "[ngtPortalBeforeRender]", never, { "renderPriority": "renderPriority"; "parentScene": "parentScene"; "parentCamera": "parentCamera"; }, { "beforeRender": "beforeRender"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtPortalBeforeRender, "[ngtPortalBeforeRender]", never, { "renderPriority": { "alias": "renderPriority"; "required": false; }; "parentScene": { "alias": "parentScene"; "required": false; }; "parentCamera": { "alias": "parentCamera"; "required": false; }; }, { "beforeRender": "beforeRender"; }, never, never, true, never>;
 }
 export declare class NgtPortalContent {
     constructor(vcr: ViewContainerRef, parentVcr: ViewContainerRef);
@@ -55,6 +55,6 @@ export declare class NgtPortal extends NgtRxStore<NgtPortalInputs> implements On
     ngOnDestroy(): void;
     private inject;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtPortal, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtPortal, "ngt-portal", never, { "container": "container"; "state": "state"; "autoRender": "autoRender"; "autoRenderPriority": "autoRenderPriority"; }, { "beforeRender": "beforeRender"; }, ["portalContentTemplate"], never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtPortal, "ngt-portal", never, { "container": { "alias": "container"; "required": false; }; "state": { "alias": "state"; "required": false; }; "autoRender": { "alias": "autoRender"; "required": false; }; "autoRenderPriority": { "alias": "autoRenderPriority"; "required": false; }; }, { "beforeRender": "beforeRender"; }, ["portalContentTemplate"], never, true, never>;
 }
 export {};

package/lib/types.d.ts

@@ -4,13 +4,9 @@ import type { BehaviorSubject } from 'rxjs';
 import * as THREE from 'three';
 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';
@@ -19,18 +15,48 @@ 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 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 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 NgtRenderer = {
+    render: (scene: THREE.Scene, camera: THREE.Camera) => any;
+};
 export type NgtCamera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
 export type NgtCameraManual = NgtCamera & {
     manual?: boolean;
 };
+export interface NgtIntersection extends THREE.Intersection {
+    /** The event source (the object which registered the handler) */
+    eventObject: THREE.Object3D;
+}
 export interface NgtIntersectionEvent<TSourceEvent> extends NgtIntersection {
     /** The event source (the object which registered the handler) */
     eventObject: THREE.Object3D;
@@ -45,7 +71,7 @@ export interface NgtIntersectionEvent<TSourceEvent> extends NgtIntersection {
     /** The ray that pierced it */
     ray: THREE.Ray;
     /** The camera that was used by the raycaster */
-    camera: NgtCamera;
+    camera: NgtCameraManual;
     /** stopPropagation will stop underlying handlers from firing */
     stopPropagation: () => void;
     /** The original host event */
@@ -55,19 +81,7 @@ export interface NgtIntersectionEvent<TSourceEvent> extends NgtIntersection {
 }
 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 interface NgtEventHandlers {
+export type NgtEventHandlers = {
     click?: (event: NgtThreeEvent<MouseEvent>) => void;
     contextmenu?: (event: NgtThreeEvent<MouseEvent>) => void;
     dblclick?: (event: NgtThreeEvent<MouseEvent>) => void;
@@ -81,10 +95,13 @@ export interface NgtEventHandlers {
     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: THREE.Intersection[], store: NgtRxStore<NgtState>) => THREE.Intersection[];
 export type NgtComputeFunction = (event: NgtDomEvent, root: NgtRxStore<NgtState>, previous?: NgtRxStore<NgtState>) => void;
-export interface NgtEventManager<TTarget = any> {
+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  */
@@ -101,56 +118,33 @@ export interface NgtEventManager<TTarget = any> {
     connect?: (target: TTarget) => void;
     /** Removes all existing events handlers from the target */
     disconnect?: () => void;
-}
-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;
-}
-export type NgtDpr = number | [min: number, max: number];
-export type NgtSize = {
-    width: number;
-    height: number;
-    top: number;
-    left: number;
+    /** 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 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 NgtPointerCaptureTarget = {
+    intersection: NgtIntersection;
+    target: Element;
 };
-export interface NgtRenderState extends NgtState {
+export type NgtRenderState = NgtState & {
     delta: number;
     frame?: XRFrame;
-}
-export interface NgtBeforeRenderEvent<TObject extends NgtInstanceNode = NgtInstanceNode> {
+};
+export type NgtBeforeRenderEvent<TObject extends NgtInstanceNode = NgtInstanceNode> = {
     state: NgtRenderState;
     object: TObject;
-}
-export interface NgtBeforeRenderRecord {
+};
+export type NgtBeforeRenderRecord = {
     callback: (state: NgtRenderState) => void;
     store: NgtRxStore<NgtState>;
     priority?: number;
-}
-export interface NgtInternalState {
+};
+export type NgtInternalState = {
     active: boolean;
     priority: number;
     frames: number;
-    lastEvent: NgtDomEvent;
+    lastEvent: NgtDomEvent | null;
     interaction: THREE.Object3D[];
     hovered: Map<string, NgtThreeEvent<NgtDomEvent>>;
     subscribers: NgtBeforeRenderRecord[];
@@ -158,14 +152,11 @@ export interface NgtInternalState {
     initialClick: [x: number, y: number];
     initialHits: THREE.Object3D[];
     subscribe: (callback: NgtBeforeRenderRecord['callback'], priority?: number, store?: NgtRxStore<NgtState>) => () => void;
-}
-export interface NgtState {
-    /** Set current state */
-    set: NgtRxStore<NgtState>['set'];
-    /** Get current state */
+};
+export type NgtState = {
     get: NgtRxStore<NgtState>['get'];
-    select: NgtRxStore<NgtState>['select'];
-    /** canvas ready state */
+    set: NgtRxStore<NgtState>['set'];
+    /** when all building blocks are initialized */
     ready: boolean;
     /** The instance of the renderer */
     gl: THREE.WebGLRenderer;
@@ -178,7 +169,7 @@ export interface NgtState {
     /** Default clock */
     clock: THREE.Clock;
     /** Event layer interface, contains the event handler and the node they're connected to */
-    events: NgtEventManager;
+    events: NgtEventManager<any>;
     /** XR interface */
     xr: {
         connect: () => void;
@@ -212,7 +203,7 @@ export interface NgtState {
     /**
      * Shortcut to manual sizing
      */
-    setSize: (width: number, height: number, top?: number, left?: number, updateStyle?: boolean) => void;
+    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 */
@@ -223,16 +214,15 @@ export interface NgtState {
     previousStore?: NgtRxStore<NgtState>;
     /** Internals */
     internal: NgtInternalState;
-    /** shortcuts for add and remove interaction */
-    addInteraction: (interaction: THREE.Object3D) => void;
+    addInteraction: (instance: THREE.Object3D) => void;
     removeInteraction: (uuid: string) => 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 {
+export type NgtInstanceLocalState = {
     /** the state getter of the canvas that the instance is being rendered to */
     store: NgtRxStore<NgtState>;
     nonObjects: BehaviorSubject<NgtInstanceNode[]>;
@@ -250,46 +240,14 @@ export interface NgtInstanceLocalState {
     priority?: number;
     afterUpdate?: EventEmitter<NgtInstanceNode>;
     afterAttach?: EventEmitter<NgtAfterAttach>;
-}
-export type NgtInstanceNode<TNode = any> = TNode & {
+};
+export type NgtInstanceNode<TNode = any> = {
     __ngt__: NgtInstanceLocalState;
-} & NgtAnyRecord;
+} & NgtAnyRecord & TNode;
 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];
-};
-/**
- * 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;
-    loadAsync(url: string | string[], onProgress?: (event: ProgressEvent) => void): Promise<any>;
-}
-export interface NgtLoaderExtensions<TLoader extends THREE.Loader = THREE.Loader> {
-    (loader: TLoader): 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;
@@ -299,16 +257,16 @@ export interface NgtObjectMap {
     };
     [key: string]: any;
 }
-export interface NgtCanvasInputs {
+export type NgtCanvasInputs = {
     /** 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 PCFsoft shadows. Can accept `gl.shadowMap` options for fine-tuning.
+     * 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 | Partial<THREE.WebGLShadowMap>;
+    shadows?: boolean | 'basic' | 'percentage' | 'soft' | 'variance' | Partial<THREE.WebGLShadowMap>;
     /**
      * Disables three r139 color management.
      * @see https://threejs.org/docs/#manual/en/introduction/Color-management
@@ -316,7 +274,7 @@ export interface NgtCanvasInputs {
     legacy?: boolean;
     /** Switch off automatic sRGB encoding and gamma correction */
     linear?: boolean;
-    /** Use `NoToneMapping` instead of `ACESFilmicToneMapping` */
+    /** Use `THREE.NoToneMapping` instead of `THREE.ACESFilmicToneMapping` */
     flat?: boolean;
     /** Creates an orthographic camera */
     orthographic?: boolean;
@@ -334,8 +292,10 @@ export interface NgtCanvasInputs {
     dpr?: NgtDpr;
     /** Props that go into the default raycaster */
     raycaster?: Partial<THREE.Raycaster>;
+    /** A `THREE.Scene` instance or props that go into the default scene */
+    scene?: THREE.Scene | Partial<THREE.Scene>;
     /** 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>>) & {
+    camera?: (NgtCamera | Partial<THREE.Camera>) & {
         /** Flags the camera as manual, putting projection into your own hands */
         manual?: boolean;
     };
@@ -347,4 +307,15 @@ export interface NgtCanvasInputs {
     eventPrefix?: 'offset' | 'client' | 'page' | 'layer' | 'screen';
     /** Default coordinate for the camera to look at */
     lookAt?: THREE.Vector3 | Parameters<THREE.Vector3['set']>;
+};
+export interface NgtLoader<T> extends THREE.Loader {
+    load(url: string, onLoad?: (result: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): unknown;
+    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<T>;
 }
+export type NgtLoaderProto<T> = new (...args: any) => NgtLoader<T extends unknown ? any : T>;
+export type NgtLoaderReturnType<T, L extends NgtLoaderProto<T>> = T extends unknown ? Awaited<ReturnType<InstanceType<L>['loadAsync']>> : T;
+export type NgtLoaderExtensions<T extends {
+    prototype: NgtLoaderProto<any>;
+}> = (loader: T['prototype']) => void;
+export type NgtConditionalType<Child, Parent, Truthy, Falsy> = Child extends Parent ? Truthy : Falsy;
+export type NgtBranchingReturn<T, Parent, Coerced> = NgtConditionalType<T, Parent, Coerced, T>;

package/lib/utils/is.d.ts

@@ -1,6 +1,6 @@
 import { ElementRef } from '@angular/core';
 import * as THREE from 'three';
-import type { NgtEquConfig } from '../types';
+import type { NgtEquConfig, NgtGLRenderer } from '../types';
 export declare const is: {
     obj: (a: unknown) => a is object;
     material: (a: unknown) => a is THREE.Material;
@@ -13,5 +13,10 @@ export declare const is: {
     object3D: (a: unknown) => a is THREE.Object3D<THREE.Event>;
     instance: (a: unknown) => a is any;
     ref: (a: unknown) => a is ElementRef<any>;
+    colorSpaceExist: <T extends object | NgtGLRenderer | THREE.Texture, P = T extends NgtGLRenderer ? {
+        outputColorSpace: string;
+    } : {
+        colorSpace: string;
+    }>(object: T) => object is T & P;
     equ(a: any, b: any, { arrays, objects, strict }?: NgtEquConfig): boolean;
 };