angular-three 0.0.2 → 0.0.3

package/lib/stores/component-store.d.ts

@@ -0,0 +1,69 @@
+import { ComponentStore } from '@ngrx/component-store';
+import { MonoTypeOperatorFunction, Observable } from 'rxjs';
+import type { NgtAnyRecord } from '../types';
+import * as i0 from "@angular/core";
+/**
+ * a default Selector that consumers can quickly use for their selectors projector
+ */
+export declare const defaultProjector: () => {};
+/**
+ * A custom operator that skips the first undefined value but allows subsequent undefined values.
+ * NgRxComponentStore#select always emits the first value regardless of undefined or not after initialize
+ */
+export declare const skipFirstUndefined: <T>() => MonoTypeOperatorFunction<T>;
+declare type EffectFn<TValue> = (value: TValue) => void | undefined | ((cleanUpParams: {
+    prev: TValue | undefined;
+    complete: boolean;
+    error: boolean;
+}) => void);
+/**
+ * An extended `tap` operator that accepts an `effectFn` which:
+ * - runs on every `next` notification from `source$`
+ * - can optionally return a `cleanUp` function that
+ * invokes from the 2nd `next` notification onward and on `unsubscribe` (destroyed)
+ *
+ *
+ * @example
+ * ```typescript
+ * source$.pipe(
+ *  tapEffect((sourceValue) = {
+ *    const cb = () => {
+ *      doStuff(sourceValue);
+ *    };
+ *    addListener('event', cb);
+ *
+ *    return () => {
+ *      removeListener('event', cb);
+ *    }
+ *  })
+ * )
+ * ```
+ */
+export declare function tapEffect<TValue>(effectFn: EffectFn<TValue>): MonoTypeOperatorFunction<TValue>;
+export declare class NgtComponentStore<TState extends object = any, TInternalState extends object = TState & NgtAnyRecord> extends ComponentStore<TInternalState> {
+    constructor();
+    readonly read: {
+        (): TInternalState;
+        <R>(projector: (s: TInternalState) => R): R;
+    };
+    /**
+     * A custom patchState that allows for:
+     * - Partial state updates and Observable of partial state updates like patchState
+     * - Pass a Record<string, ObservableInput> to update a specific key with an Observable.
+     * This is similar to `RxState.connect()` API
+     */
+    write(partialStateOrFactory: ((state: TInternalState) => Record<string, any>) | ((state: TInternalState) => Observable<Partial<TInternalState>>) | Observable<Partial<TInternalState>> | Record<string, any>): void;
+    protected initialize(): void;
+    /**
+     * A utility class method to select a state on the template as Observable
+     * - This method always debounce the Observable
+     */
+    selectKey<TKey extends keyof TInternalState & string>(key: TKey, skipFirst?: boolean): Observable<TInternalState[TKey]>;
+    /**
+     * A utility class method to get a state on the template as imperative Value
+     */
+    readKey<TKey extends keyof TInternalState & string>(key: TKey): TInternalState[TKey];
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtComponentStore<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgtComponentStore<any, any>>;
+}
+export {};

package/lib/stores/store.d.ts

@@ -0,0 +1,32 @@
+import { Subscription } from 'rxjs';
+import type { NgtCanvasInputs, NgtState, NgtStateFactory } from '../types';
+import { NgtComponentStore, tapEffect } from './component-store';
+import * as i0 from "@angular/core";
+export declare const rootStateMap: Map<Element, NgtStateFactory>;
+export declare class NgtStore extends NgtComponentStore<NgtState> {
+    private readonly parentStore;
+    private readonly zone;
+    private readonly window;
+    private readonly position;
+    private readonly defaultTarget;
+    private readonly tempTarget;
+    get rootStateFactory(): NgtStateFactory;
+    private readonly resize;
+    private readonly invalidate;
+    isInit: boolean;
+    isConfigured: boolean;
+    init(): void;
+    private readonly addInteraction;
+    private readonly removeInteraction;
+    private readonly setPerformanceCurrent;
+    private readonly setEvents;
+    private readonly setSize;
+    private readonly setCamera;
+    private readonly setDpr;
+    private readonly setFrameloop;
+    private readonly getCurrentViewport;
+    configure(inputs: NgtCanvasInputs, canvasElement: HTMLCanvasElement): void;
+    onReady(cb: Parameters<typeof tapEffect>[0]): Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgtStore>;
+}

package/lib/types.d.ts

@@ -0,0 +1,358 @@
+/// <reference types="webxr" />
+import { ElementRef } from '@angular/core';
+import { ObservableInput } from 'rxjs';
+import * as THREE from 'three';
+import { Renderer, WebGLRenderer, WebGLRendererParameters } from 'three';
+import { NgtRef } from './ref';
+export declare 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 */
+    objects?: 'reference' | 'shallow';
+    /** 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 declare type NgtCamera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
+export declare type NgtDomEvent = PointerEvent | MouseEvent | WheelEvent;
+export interface NgtIntersectionEvent<TSourceEvent> extends NgtIntersection {
+    /** 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]) */
+    pointer: THREE.Vector2;
+    /** delta between first click and this event */
+    delta: number;
+    /** the ray casted from the camera */
+    ray: THREE.Ray;
+    /** the camera used to raycast */
+    camera: NgtCamera;
+    /** stopPropagation will stop underlying handlers from firing */
+    stopPropagation: () => void;
+    /** the original event */
+    nativeEvent: TSourceEvent;
+    /** 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 declare type NgtThreeEvent<TEvent> = NgtIntersectionEvent<TEvent>;
+export interface 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 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 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;
+}
+/**
+ * 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 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 interface NgtRenderState extends NgtState {
+    delta: number;
+    frame?: XRFrame;
+}
+export declare type NgtBeforeRenderCallback<TObject = any> = (state: NgtRenderState, obj: TObject) => void;
+export interface NgtBeforeRenderRecord {
+    obj?: THREE.Object3D | NgtRef;
+    callback: NgtBeforeRenderCallback<THREE.Object3D | undefined>;
+    priority?: number;
+    stateFactory: NgtStateFactory;
+}
+export interface NgtInternalState {
+    active: boolean;
+    priority: number;
+    frames: number;
+    lastEvent: NgtDomEvent | null;
+    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;
+}
+export interface NgtState {
+    /** The flag to notify if the Canvas is ready to render */
+    ready: boolean;
+    /** The instance of the renderer */
+    gl: THREE.WebGLRenderer;
+    /** Default camera */
+    camera: NgtCameraWithManual /** Default scene */;
+    cameraRef: NgtRef<NgtCameraWithManual>;
+    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>;
+    /** XR interface */
+    xr: {
+        connect: () => void;
+        disconnect: () => void;
+    };
+    /** Currently used controls */
+    controls: THREE.EventDispatcher | null;
+    /** Normalized event coordinates */
+    pointer: THREE.Vector2;
+    legacy: boolean;
+    /** Shortcut to gl.outputEncoding = LinearEncoding */
+    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?: 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;
+    /** 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, updateStyle?: boolean) => void;
+    /** Shortcut to manual setting the pixel ratio */
+    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;
+}
+export declare type NgtAttachFunction<TChild = any, TParent = any> = (parent: NgtRef<TParent>, child: NgtRef<TChild>, stateFactory: NgtStateFactory) => void | (() => void);
+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;
+    eventCount: number;
+    handlers: Partial<NgtEventHandlers>;
+    args?: unknown[];
+    attach?: string[] | (() => void);
+    attachValue?: unknown;
+    memoized?: NgtAnyRecord;
+}
+export declare type NgtInstanceNode<TNode = any> = TNode & {
+    __ngt__: NgtInstanceLocalState;
+    [key: string]: any;
+};
+export declare type NgtGLOptions = Renderer | ((canvas: HTMLCanvasElement) => Renderer) | Partial<NgtProperties<WebGLRenderer> | WebGLRendererParameters> | undefined;
+export interface 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.
+     * @see https://threejs.org/docs/#api/en/renderers/WebGLRenderer.shadowMap
+     */
+    shadows?: boolean | Partial<THREE.WebGLShadowMap>;
+    /**
+     * Disables three r139 color management.
+     * @see https://threejs.org/docs/#manual/en/introduction/Color-management
+     */
+    legacy?: boolean;
+    /** Switch off automatic sRGB encoding 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<THREE.Raycaster>;
+    /** A `THREE.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>;
+    /** 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;
+}
+export {};

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

@@ -0,0 +1,6 @@
+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;

package/lib/utils/build-graph.d.ts

@@ -0,0 +1,3 @@
+import * as THREE from 'three';
+import type { NgtObjectMap } from '../types';
+export declare function buildGraph(object: THREE.Object3D): NgtObjectMap;

package/lib/utils/camera.d.ts

@@ -0,0 +1,4 @@
+import * as THREE from 'three';
+import type { NgtCameraWithManual, NgtSize } from '../types';
+export declare function updateCamera(camera: NgtCameraWithManual, size: NgtSize): void;
+export declare function createDefaultCamera(isOrthographic: boolean, size: NgtSize): THREE.OrthographicCamera | THREE.PerspectiveCamera;

package/lib/utils/capitalize.d.ts

@@ -0,0 +1 @@
+export declare function capitalize(str: string): string;

package/lib/utils/check-update.d.ts

@@ -0,0 +1,2 @@
+export declare function checkNeedsUpdate(value: unknown): void;
+export declare function checkUpdate(value: unknown): void;

package/lib/utils/events.d.ts

@@ -0,0 +1,6 @@
+import * as THREE from 'three';
+import type { NgtDomEvent, NgtStateFactory } from '../types';
+export declare function removeInteractivity(stateFactory: NgtStateFactory, object: THREE.Object3D): void;
+export declare function createEvents(stateFactory: NgtStateFactory): {
+    handlePointer: (name: string) => (event: NgtDomEvent) => void;
+};

package/lib/utils/get-instance-local-state.d.ts

@@ -0,0 +1,2 @@
+import type { NgtAnyRecord, NgtInstanceLocalState } from '../types';
+export declare function getInstanceLocalState<TInstance extends object = NgtAnyRecord>(obj: TInstance | undefined): NgtInstanceLocalState | undefined;

package/lib/utils/inject.d.ts

@@ -0,0 +1,9 @@
+import { InjectionToken, InjectOptions, Provider } from '@angular/core';
+export declare function createInjection<TTokenValue, TProvideValue = TTokenValue extends object ? Partial<TTokenValue> : TTokenValue>(description: string, { defaultValueOrFactory, provideValueFactory, }?: {
+    defaultValueOrFactory?: TTokenValue | (() => TTokenValue);
+    provideValueFactory?: (value: TProvideValue) => TTokenValue;
+}): [
+    injectFn: (options?: InjectOptions) => TTokenValue,
+    provideFn: (value: TProvideValue) => Provider,
+    token: InjectionToken<TTokenValue>
+];

package/lib/utils/instance.d.ts

@@ -0,0 +1,4 @@
+import { NgtRef } from '../ref';
+import type { NgtAnyRecord, NgtInstanceNode, NgtStateFactory } from '../types';
+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>;

package/lib/utils/is.d.ts

@@ -0,0 +1,21 @@
+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;
+    camera: (a: unknown) => a is THREE.Camera;
+    glRenderer: (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;
+    ref: (a: unknown) => a is NgtRef<any>;
+    supportColorManagement: () => boolean;
+    canvas: (a: unknown) => a is HTMLCanvasElement;
+    equ(a: any, b: any, { arrays, objects, strict }?: NgtEquConfig): boolean;
+};

package/lib/utils/loop.d.ts

@@ -0,0 +1,32 @@
+import type { NgtStateFactory } from '../types';
+export declare type NgtGlobalRenderCallback = (timeStamp: number) => void;
+/**
+ * Adds a global render callback which is called each frame.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addEffect
+ */
+export declare const addEffect: (callback: NgtGlobalRenderCallback) => () => void;
+/**
+ * Adds a global after-render callback which is called each frame.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addAfterEffect
+ */
+export declare const addAfterEffect: (callback: NgtGlobalRenderCallback) => () => void;
+/**
+ * Adds a global callback which is called when rendering stops.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addTail
+ */
+export declare const addTail: (callback: NgtGlobalRenderCallback) => () => void;
+export declare type GlobalEffectType = 'before' | 'after' | 'tail';
+export declare function flushGlobalEffects(type: GlobalEffectType, timestamp: number): void;
+export declare function createLoop<TCanvas>(roots: Map<TCanvas, NgtStateFactory>): {
+    loop: (timestamp: number) => void;
+    /**
+     * Invalidates the view, requesting a frame to be rendered. Will globally invalidate unless passed a root's state.
+     * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#invalidate
+     */
+    invalidate: (stateFactory?: NgtStateFactory, frames?: number) => void;
+    /**
+     * Advances the frameloop and runs render effects, useful for when manually rendering via `frameloop="never"`.
+     * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#advance
+     */
+    advance: (timestamp: number, runGlobalEffects?: boolean, stateFactory?: NgtStateFactory, frame?: XRFrame) => void;
+};

package/lib/utils/make.d.ts

@@ -0,0 +1,4 @@
+import type { NgtAnyConstructor, NgtDpr, NgtIntersection } 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>;

package/lib/utils/mutate.d.ts

@@ -0,0 +1,2 @@
+import type { NgtAnyRecord } from '../types';
+export declare function mutate<T extends NgtAnyRecord>(object: T, value: unknown, paths?: string[]): void;

package/lib/utils/proxy.d.ts

@@ -0,0 +1,7 @@
+import { NgtInstance } from '../instance';
+import { NgtAttachFunction, NgtStateFactory } from '../types';
+export declare function proxify<T extends object>(instance: T, proxifyOptions?: {
+    attach?: string | string[] | NgtAttachFunction<T>;
+    created?: (instance: T, stateFactory: NgtStateFactory, ngtInstance: NgtInstance) => void;
+    primitive?: boolean;
+}): T;

package/lib/utils/renderer.d.ts

@@ -0,0 +1,3 @@
+import * as THREE from 'three';
+import type { NgtGLOptions } from '../types';
+export declare function createRenderer(glOptions: NgtGLOptions, canvasElement: HTMLCanvasElement): THREE.WebGLRenderer;

package/lights/README.md

@@ -0,0 +1,3 @@
+# angular-three/lights
+
+Secondary entry point of `angular-three`. It can be used by importing from `angular-three/lights`.

package/lights/index.d.ts

@@ -0,0 +1,9 @@
+export * from './lib/light-probe/light-probe';
+export * from './lib/ambient-light/ambient-light';
+export * from './lib/ambient-light-probe/ambient-light-probe';
+export * from './lib/hemisphere-light/hemisphere-light';
+export * from './lib/hemisphere-light-probe/hemisphere-light-probe';
+export * from './lib/directional-light/directional-light';
+export * from './lib/point-light/point-light';
+export * from './lib/spot-light/spot-light';
+export * from './lib/rect-area-light/rect-area-light';