angular-three 2.0.0-beta.6 → 2.0.0-beta.8

package/esm2022/lib/store.mjs

@@ -0,0 +1,207 @@
+import { DOCUMENT } from '@angular/common';
+import { ChangeDetectorRef, ElementRef, InjectionToken, Injector, Optional, SkipSelf, effect, inject, runInInjectionContext, } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as THREE from 'three';
+import { NGT_LOOP } from './loop';
+import { createInjectionToken } from './utils/create-injection-token';
+import { is } from './utils/is';
+import { makeDpr } from './utils/make';
+import { safeDetectChanges } from './utils/safe-detect-changes';
+import { signalStore } from './utils/signal-store';
+import { updateCamera } from './utils/update';
+function storeFactory(loop, document, injector, parent) {
+    return runInInjectionContext(injector, () => {
+        const window = document.defaultView;
+        if (!window) {
+            // TODO: revisit this when we need to support multiple platforms
+            throw new Error(`[NGT] Window is not available.`);
+        }
+        const cdr = inject(ChangeDetectorRef);
+        // NOTE: using Subject because we do not care about late-subscribers
+        const pointerMissed$ = new Subject();
+        const store = signalStore(({ get, set }) => {
+            const { invalidate, advance } = loop;
+            const position = new THREE.Vector3();
+            const defaultTarget = new THREE.Vector3();
+            const tempTarget = new THREE.Vector3();
+            function getCurrentViewport(camera = get('camera'), target = defaultTarget, size = get('size')) {
+                const { width, height, top, left } = size;
+                const aspect = width / height;
+                if (target instanceof THREE.Vector3)
+                    tempTarget.copy(target);
+                else
+                    tempTarget.set(...target);
+                const distance = camera.getWorldPosition(position).distanceTo(tempTarget);
+                if (is.orthographicCamera(camera)) {
+                    return {
+                        width: width / camera.zoom,
+                        height: height / camera.zoom,
+                        top,
+                        left,
+                        factor: 1,
+                        distance,
+                        aspect,
+                    };
+                }
+                else {
+                    const fov = (camera.fov * Math.PI) / 180; // convert vertical fov to radians
+                    const h = 2 * Math.tan(fov / 2) * distance; // visible height
+                    const w = h * (width / height);
+                    return { width: w, height: h, top, left, factor: width / w, distance, aspect };
+                }
+            }
+            let performanceTimeout = undefined;
+            const setPerformanceCurrent = (current) => set((state) => ({ performance: { ...state.performance, current } }));
+            const pointer = new THREE.Vector2();
+            return {
+                pointerMissed$: pointerMissed$.asObservable(),
+                events: { priority: 1, enabled: true, connected: false },
+                invalidate: (frames = 1) => invalidate(store, frames),
+                advance: (timestamp, runGlobalEffects) => advance(timestamp, runGlobalEffects, store),
+                legacy: false,
+                linear: false,
+                flat: false,
+                controls: null,
+                clock: new THREE.Clock(),
+                pointer,
+                frameloop: 'always',
+                performance: {
+                    current: 1,
+                    min: 0.5,
+                    max: 1,
+                    debounce: 200,
+                    regress: () => {
+                        const state = get();
+                        // Clear timeout
+                        if (performanceTimeout)
+                            clearTimeout(performanceTimeout);
+                        // Set lower bound performance
+                        if (state.performance.current !== state.performance.min)
+                            setPerformanceCurrent(state.performance.min);
+                        // Go back to upper bound performance after a while unless something regresses meanwhile
+                        performanceTimeout = setTimeout(() => {
+                            setPerformanceCurrent(get('performance', 'max'));
+                            safeDetectChanges(cdr);
+                        }, state.performance.debounce);
+                    },
+                },
+                size: { width: 0, height: 0, top: 0, left: 0, updateStyle: false },
+                viewport: {
+                    initialDpr: 0,
+                    dpr: 0,
+                    width: 0,
+                    height: 0,
+                    top: 0,
+                    left: 0,
+                    aspect: 0,
+                    distance: 0,
+                    factor: 0,
+                    getCurrentViewport,
+                },
+                setEvents: (events) => set((state) => ({ ...state, events: { ...state.events, ...events } })),
+                setSize: (width, height, top, left) => {
+                    const camera = get('camera');
+                    const size = { width, height, top: top || 0, left: left || 0 };
+                    set((state) => ({
+                        size,
+                        viewport: { ...state.viewport, ...getCurrentViewport(camera, defaultTarget, size) },
+                    }));
+                },
+                setDpr: (dpr) => set((state) => {
+                    const resolved = makeDpr(dpr, window);
+                    return {
+                        viewport: {
+                            ...state.viewport,
+                            dpr: resolved,
+                            initialDpr: state.viewport.initialDpr || resolved,
+                        },
+                    };
+                }),
+                setFrameloop: (frameloop = 'always') => {
+                    const clock = get('clock');
+                    // if frameloop === "never" clock.elapsedTime is updated using advance(timestamp)
+                    clock.stop();
+                    clock.elapsedTime = 0;
+                    if (frameloop !== 'never') {
+                        clock.start();
+                        clock.elapsedTime = 0;
+                    }
+                    set(() => ({ frameloop }));
+                },
+                previousRoot: parent,
+                internal: {
+                    active: false,
+                    priority: 0,
+                    frames: 0,
+                    lastEvent: new ElementRef(null),
+                    interaction: [],
+                    hovered: new Map(),
+                    subscribers: [],
+                    initialClick: [0, 0],
+                    initialHits: [],
+                    capturedMap: new Map(),
+                    subscribe: (callback, priority = 0, _store = store) => {
+                        const internal = get('internal');
+                        // If this subscription was given a priority, it takes rendering into its own hands
+                        // For that reason we switch off automatic rendering and increase the manual flag
+                        // As long as this flag is positive there can be no internal rendering at all
+                        // because there could be multiple render subscriptions
+                        internal.priority = internal.priority + (priority > 0 ? 1 : 0);
+                        internal.subscribers.push({ callback, priority, store });
+                        // Register subscriber and sort layers from lowest to highest, meaning,
+                        // highest priority renders last (on top of the other frames)
+                        internal.subscribers = internal.subscribers.sort((a, b) => (a.priority || 0) - (b.priority || 0));
+                        return () => {
+                            const internal = get('internal');
+                            if (internal?.subscribers) {
+                                // Decrease manual flag if this subscription had a priority
+                                internal.priority = internal.priority - (priority > 0 ? 1 : 0);
+                                // Remove subscriber from list
+                                internal.subscribers = internal.subscribers.filter((s) => s.callback !== callback);
+                            }
+                        };
+                    },
+                },
+            };
+        });
+        // NOTE: assign pointerMissed$ so we can use it in events
+        Object.defineProperty(store, 'pointerMissed$', { get: () => pointerMissed$ });
+        const state = store.get();
+        let oldSize = state.size;
+        let oldDpr = state.viewport.dpr;
+        let oldCamera = state.camera;
+        const _camera = store.select('camera');
+        const _size = store.select('size');
+        const _viewport = store.select('viewport');
+        effect(() => {
+            const [camera, size, viewport, gl] = [_camera(), _size(), _viewport(), store.get('gl')];
+            // Resize camera and renderer on changes to size and pixelratio
+            if (size !== oldSize || viewport.dpr !== oldDpr) {
+                oldSize = size;
+                oldDpr = viewport.dpr;
+                // Update camera & renderer
+                updateCamera(camera, size);
+                gl.setPixelRatio(viewport.dpr);
+                const updateStyle = typeof HTMLCanvasElement !== 'undefined' && gl.domElement instanceof HTMLCanvasElement;
+                gl.setSize(size.width, size.height, updateStyle);
+            }
+            // Update viewport once the camera changes
+            if (camera !== oldCamera) {
+                oldCamera = camera;
+                updateCamera(camera, size);
+                // Update viewport
+                store.set((state) => ({
+                    viewport: { ...state.viewport, ...state.viewport.getCurrentViewport(camera) },
+                }));
+            }
+        });
+        return store;
+    });
+}
+export const NGT_STORE = new InjectionToken('NgtStore token');
+export const [injectNgtStore, provideNgtStore] = createInjectionToken(storeFactory, {
+    isRoot: false,
+    deps: [NGT_LOOP, DOCUMENT, Injector, [new Optional(), new SkipSelf(), NGT_STORE]],
+    token: NGT_STORE,
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/store.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport {\n\tChangeDetectorRef,\n\tElementRef,\n\tInjectionToken,\n\tInjector,\n\tOptional,\n\tSkipSelf,\n\teffect,\n\tinject,\n\trunInInjectionContext,\n} from '@angular/core';\nimport { Subject, type Observable } from 'rxjs';\nimport * as THREE from 'three';\nimport type { NgtCamera, NgtDomEvent, NgtEventManager, NgtPointerCaptureTarget, NgtThreeEvent } from './events';\nimport type { NgtInstanceNode } from './instance';\nimport { NGT_LOOP, type NgtLoop } from './loop';\nimport { createInjectionToken } from './utils/create-injection-token';\nimport { is } from './utils/is';\nimport { makeDpr } from './utils/make';\nimport { safeDetectChanges } from './utils/safe-detect-changes';\nimport { signalStore, type NgtSignalStore } from './utils/signal-store';\nimport { updateCamera } from './utils/update';\n\nexport type NgtRenderer = { render: (scene: THREE.Scene, camera: THREE.Camera) => any };\nexport type NgtCameraManual = NgtCamera & { manual?: boolean };\n\nexport type NgtDpr = number | [min: number, max: number];\nexport type NgtSize = {\n\twidth: number;\n\theight: number;\n\ttop: number;\n\tleft: number;\n};\n\nexport type NgtViewport = NgtSize & {\n\t/** The initial pixel ratio */\n\tinitialDpr: number;\n\t/** Current pixel ratio */\n\tdpr: number;\n\t/** size.width / viewport.width */\n\tfactor: number;\n\t/** Camera distance */\n\tdistance: number;\n\t/** Camera aspect ratio: width / height */\n\taspect: number;\n};\n\nexport type NgtPerformance = {\n\t/** Current performance normal, between min and max */\n\tcurrent: number;\n\t/** How low the performance can go, between 0 and max */\n\tmin: number;\n\t/** How high the performance can go, between min and max */\n\tmax: number;\n\t/** Time until current returns to max in ms */\n\tdebounce: number;\n\t/** Sets current to min, puts the system in regression */\n\tregress: () => void;\n};\n\nexport type NgtRenderState = NgtState & { delta: number; frame?: XRFrame };\n\nexport type NgtBeforeRenderEvent<TObject extends NgtInstanceNode = NgtInstanceNode> = {\n\tstate: NgtRenderState;\n\tobject: TObject;\n};\n\nexport type NgtBeforeRenderRecord = {\n\tcallback: (state: NgtRenderState) => void;\n\tstore: NgtSignalStore<NgtState>;\n\tpriority?: number;\n};\n\nexport type NgtInternalState = {\n\tactive: boolean;\n\tpriority: number;\n\tframes: number;\n\tlastEvent: ElementRef<NgtDomEvent | null>;\n\tinteraction: THREE.Object3D[];\n\thovered: Map<string, NgtThreeEvent<NgtDomEvent>>;\n\tcapturedMap: Map<number, Map<THREE.Object3D, NgtPointerCaptureTarget>>;\n\tinitialClick: [x: number, y: number];\n\tinitialHits: THREE.Object3D[];\n\tsubscribers: NgtBeforeRenderRecord[];\n\tsubscribe: (\n\t\tcallback: NgtBeforeRenderRecord['callback'],\n\t\tpriority?: number,\n\t\tstore?: NgtSignalStore<NgtState>,\n\t) => () => void;\n};\n\nexport type NgtState = {\n\t/** when all building blocks are initialized */\n\tready: boolean;\n\t/** The instance of the renderer */\n\tgl: THREE.WebGLRenderer;\n\t/** Default camera */\n\tcamera: NgtCameraManual;\n\t/** Default scene */\n\tscene: THREE.Scene;\n\t/** Default raycaster */\n\traycaster: THREE.Raycaster;\n\t/** Default clock */\n\tclock: THREE.Clock;\n\t/** Event layer interface, contains the event handler and the node they're connected to */\n\tevents: NgtEventManager<any>;\n\t/** XR interface */\n\txr: { connect: () => void; disconnect: () => void };\n\t/** Currently used controls */\n\tcontrols: THREE.EventDispatcher | null;\n\t/** Normalized event coordinates */\n\tpointer: THREE.Vector2;\n\t/* Whether to enable r139's THREE.ColorManagement */\n\tlegacy: boolean;\n\t/** Shortcut to gl.outputColorSpace = THREE.LinearSRGBColorSpace */\n\tlinear: boolean;\n\t/** Shortcut to gl.toneMapping = NoTonemapping */\n\tflat: boolean;\n\t/** Render loop flags */\n\tframeloop: 'always' | 'demand' | 'never';\n\t/** Adaptive performance interface */\n\tperformance: NgtPerformance;\n\t/** Reactive pixel-size of the canvas */\n\tsize: NgtSize;\n\t/** Reactive size of the viewport in threejs units */\n\tviewport: NgtViewport & {\n\t\tgetCurrentViewport: (\n\t\t\tcamera?: NgtCamera,\n\t\t\ttarget?: THREE.Vector3 | Parameters<THREE.Vector3['set']>,\n\t\t\tsize?: NgtSize,\n\t\t) => Omit<NgtViewport, 'dpr' | 'initialDpr'>;\n\t};\n\t/** Flags the canvas for render, but doesn't render in itself */\n\tinvalidate: (frames?: number) => void;\n\t/** Advance (render) one step */\n\tadvance: (timestamp: number, runGlobalEffects?: boolean) => void;\n\t/** Shortcut to setting the event layer */\n\tsetEvents: (events: Partial<NgtEventManager<any>>) => void;\n\t/**\n\t * Shortcut to manual sizing\n\t */\n\tsetSize: (width: number, height: number, top?: number, left?: number) => void;\n\t/** Shortcut to manual setting the pixel ratio */\n\tsetDpr: (dpr: NgtDpr) => void;\n\t/** Shortcut to frameloop flags */\n\tsetFrameloop: (frameloop?: 'always' | 'demand' | 'never') => void;\n\t/** When the canvas was clicked but nothing was hit */\n\t/** PointerMissed Observable */\n\tpointerMissed$: Observable<MouseEvent>;\n\t/** If this state model is layerd (via createPortal) then this contains the previous layer */\n\tpreviousRoot: NgtSignalStore<NgtState> | null;\n\t/** Internals */\n\tinternal: NgtInternalState;\n};\n\nfunction storeFactory(loop: NgtLoop, document: Document, injector: Injector, parent: NgtSignalStore<NgtState> | null) {\n\treturn runInInjectionContext(injector, () => {\n\t\tconst window = document.defaultView;\n\n\t\tif (!window) {\n\t\t\t// TODO: revisit this when we need to support multiple platforms\n\t\t\tthrow new Error(`[NGT] Window is not available.`);\n\t\t}\n\n\t\tconst cdr = inject(ChangeDetectorRef);\n\n\t\t// NOTE: using Subject because we do not care about late-subscribers\n\t\tconst pointerMissed$ = new Subject<MouseEvent>();\n\n\t\tconst store: NgtSignalStore<NgtState> = signalStore<NgtState>(({ get, set }) => {\n\t\t\tconst { invalidate, advance } = loop;\n\n\t\t\tconst position = new THREE.Vector3();\n\t\t\tconst defaultTarget = new THREE.Vector3();\n\t\t\tconst tempTarget = new THREE.Vector3();\n\n\t\t\tfunction getCurrentViewport(\n\t\t\t\tcamera: NgtCamera = get('camera'),\n\t\t\t\ttarget: THREE.Vector3 | Parameters<THREE.Vector3['set']> = defaultTarget,\n\t\t\t\tsize: NgtSize = get('size'),\n\t\t\t): Omit<NgtViewport, 'dpr' | 'initialDpr'> {\n\t\t\t\tconst { width, height, top, left } = size;\n\t\t\t\tconst aspect = width / height;\n\t\t\t\tif (target instanceof THREE.Vector3) tempTarget.copy(target);\n\t\t\t\telse tempTarget.set(...target);\n\t\t\t\tconst distance = camera.getWorldPosition(position).distanceTo(tempTarget);\n\t\t\t\tif (is.orthographicCamera(camera)) {\n\t\t\t\t\treturn {\n\t\t\t\t\t\twidth: width / camera.zoom,\n\t\t\t\t\t\theight: height / camera.zoom,\n\t\t\t\t\t\ttop,\n\t\t\t\t\t\tleft,\n\t\t\t\t\t\tfactor: 1,\n\t\t\t\t\t\tdistance,\n\t\t\t\t\t\taspect,\n\t\t\t\t\t};\n\t\t\t\t} else {\n\t\t\t\t\tconst fov = (camera.fov * Math.PI) / 180; // convert vertical fov to radians\n\t\t\t\t\tconst h = 2 * Math.tan(fov / 2) * distance; // visible height\n\t\t\t\t\tconst w = h * (width / height);\n\t\t\t\t\treturn { width: w, height: h, top, left, factor: width / w, distance, aspect };\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tlet performanceTimeout: ReturnType<typeof setTimeout> | undefined = undefined;\n\t\t\tconst setPerformanceCurrent = (current: number) =>\n\t\t\t\tset((state) => ({ performance: { ...state.performance, current } }));\n\n\t\t\tconst pointer = new THREE.Vector2();\n\n\t\t\treturn {\n\t\t\t\tpointerMissed$: pointerMissed$.asObservable(),\n\t\t\t\tevents: { priority: 1, enabled: true, connected: false },\n\n\t\t\t\tinvalidate: (frames = 1) => invalidate(store, frames),\n\t\t\t\tadvance: (timestamp: number, runGlobalEffects?: boolean) => advance(timestamp, runGlobalEffects, store),\n\n\t\t\t\tlegacy: false,\n\t\t\t\tlinear: false,\n\t\t\t\tflat: false,\n\n\t\t\t\tcontrols: null,\n\t\t\t\tclock: new THREE.Clock(),\n\t\t\t\tpointer,\n\n\t\t\t\tframeloop: 'always',\n\n\t\t\t\tperformance: {\n\t\t\t\t\tcurrent: 1,\n\t\t\t\t\tmin: 0.5,\n\t\t\t\t\tmax: 1,\n\t\t\t\t\tdebounce: 200,\n\t\t\t\t\tregress: () => {\n\t\t\t\t\t\tconst state = get();\n\t\t\t\t\t\t// Clear timeout\n\t\t\t\t\t\tif (performanceTimeout) clearTimeout(performanceTimeout);\n\t\t\t\t\t\t// Set lower bound performance\n\t\t\t\t\t\tif (state.performance.current !== state.performance.min)\n\t\t\t\t\t\t\tsetPerformanceCurrent(state.performance.min);\n\n\t\t\t\t\t\t// Go back to upper bound performance after a while unless something regresses meanwhile\n\t\t\t\t\t\tperformanceTimeout = setTimeout(() => {\n\t\t\t\t\t\t\tsetPerformanceCurrent(get('performance', 'max'));\n\t\t\t\t\t\t\tsafeDetectChanges(cdr);\n\t\t\t\t\t\t}, state.performance.debounce);\n\t\t\t\t\t},\n\t\t\t\t},\n\n\t\t\t\tsize: { width: 0, height: 0, top: 0, left: 0, updateStyle: false },\n\t\t\t\tviewport: {\n\t\t\t\t\tinitialDpr: 0,\n\t\t\t\t\tdpr: 0,\n\t\t\t\t\twidth: 0,\n\t\t\t\t\theight: 0,\n\t\t\t\t\ttop: 0,\n\t\t\t\t\tleft: 0,\n\t\t\t\t\taspect: 0,\n\t\t\t\t\tdistance: 0,\n\t\t\t\t\tfactor: 0,\n\t\t\t\t\tgetCurrentViewport,\n\t\t\t\t},\n\n\t\t\t\tsetEvents: (events: Partial<NgtEventManager<any>>) =>\n\t\t\t\t\tset((state) => ({ ...state, events: { ...state.events, ...events } })),\n\t\t\t\tsetSize: (width: number, height: number, top?: number, left?: number) => {\n\t\t\t\t\tconst camera = get('camera');\n\t\t\t\t\tconst size = { width, height, top: top || 0, left: left || 0 };\n\t\t\t\t\tset((state) => ({\n\t\t\t\t\t\tsize,\n\t\t\t\t\t\tviewport: { ...state.viewport, ...getCurrentViewport(camera, defaultTarget, size) },\n\t\t\t\t\t}));\n\t\t\t\t},\n\t\t\t\tsetDpr: (dpr: NgtDpr) =>\n\t\t\t\t\tset((state) => {\n\t\t\t\t\t\tconst resolved = makeDpr(dpr, window);\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\tviewport: {\n\t\t\t\t\t\t\t\t...state.viewport,\n\t\t\t\t\t\t\t\tdpr: resolved,\n\t\t\t\t\t\t\t\tinitialDpr: state.viewport.initialDpr || resolved,\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t};\n\t\t\t\t\t}),\n\t\t\t\tsetFrameloop: (frameloop: 'always' | 'demand' | 'never' = 'always') => {\n\t\t\t\t\tconst clock = get('clock');\n\n\t\t\t\t\t// if frameloop === \"never\" clock.elapsedTime is updated using advance(timestamp)\n\t\t\t\t\tclock.stop();\n\t\t\t\t\tclock.elapsedTime = 0;\n\n\t\t\t\t\tif (frameloop !== 'never') {\n\t\t\t\t\t\tclock.start();\n\t\t\t\t\t\tclock.elapsedTime = 0;\n\t\t\t\t\t}\n\t\t\t\t\tset(() => ({ frameloop }));\n\t\t\t\t},\n\n\t\t\t\tpreviousRoot: parent,\n\t\t\t\tinternal: {\n\t\t\t\t\tactive: false,\n\t\t\t\t\tpriority: 0,\n\t\t\t\t\tframes: 0,\n\t\t\t\t\tlastEvent: new ElementRef(null),\n\t\t\t\t\tinteraction: [],\n\t\t\t\t\thovered: new Map(),\n\t\t\t\t\tsubscribers: [],\n\t\t\t\t\tinitialClick: [0, 0],\n\t\t\t\t\tinitialHits: [],\n\t\t\t\t\tcapturedMap: new Map(),\n\n\t\t\t\t\tsubscribe: (\n\t\t\t\t\t\tcallback: NgtBeforeRenderRecord['callback'],\n\t\t\t\t\t\tpriority = 0,\n\t\t\t\t\t\t_store: NgtSignalStore<NgtState> = store,\n\t\t\t\t\t) => {\n\t\t\t\t\t\tconst internal = get('internal');\n\t\t\t\t\t\t// If this subscription was given a priority, it takes rendering into its own hands\n\t\t\t\t\t\t// For that reason we switch off automatic rendering and increase the manual flag\n\t\t\t\t\t\t// As long as this flag is positive there can be no internal rendering at all\n\t\t\t\t\t\t// because there could be multiple render subscriptions\n\t\t\t\t\t\tinternal.priority = internal.priority + (priority > 0 ? 1 : 0);\n\t\t\t\t\t\tinternal.subscribers.push({ callback, priority, store });\n\t\t\t\t\t\t// Register subscriber and sort layers from lowest to highest, meaning,\n\t\t\t\t\t\t// highest priority renders last (on top of the other frames)\n\t\t\t\t\t\tinternal.subscribers = internal.subscribers.sort(\n\t\t\t\t\t\t\t(a, b) => (a.priority || 0) - (b.priority || 0),\n\t\t\t\t\t\t);\n\t\t\t\t\t\treturn () => {\n\t\t\t\t\t\t\tconst internal = get('internal');\n\t\t\t\t\t\t\tif (internal?.subscribers) {\n\t\t\t\t\t\t\t\t// Decrease manual flag if this subscription had a priority\n\t\t\t\t\t\t\t\tinternal.priority = internal.priority - (priority > 0 ? 1 : 0);\n\t\t\t\t\t\t\t\t// Remove subscriber from list\n\t\t\t\t\t\t\t\tinternal.subscribers = internal.subscribers.filter((s) => s.callback !== callback);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t};\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t};\n\t\t});\n\n\t\t// NOTE: assign pointerMissed$ so we can use it in events\n\t\tObject.defineProperty(store, 'pointerMissed$', { get: () => pointerMissed$ });\n\n\t\tconst state = store.get();\n\n\t\tlet oldSize = state.size;\n\t\tlet oldDpr = state.viewport.dpr;\n\t\tlet oldCamera = state.camera;\n\n\t\tconst _camera = store.select('camera');\n\t\tconst _size = store.select('size');\n\t\tconst _viewport = store.select('viewport');\n\n\t\teffect(() => {\n\t\t\tconst [camera, size, viewport, gl] = [_camera(), _size(), _viewport(), store.get('gl')];\n\n\t\t\t// Resize camera and renderer on changes to size and pixelratio\n\t\t\tif (size !== oldSize || viewport.dpr !== oldDpr) {\n\t\t\t\toldSize = size;\n\t\t\t\toldDpr = viewport.dpr;\n\t\t\t\t// Update camera & renderer\n\t\t\t\tupdateCamera(camera, size);\n\t\t\t\tgl.setPixelRatio(viewport.dpr);\n\n\t\t\t\tconst updateStyle =\n\t\t\t\t\ttypeof HTMLCanvasElement !== 'undefined' && gl.domElement instanceof HTMLCanvasElement;\n\t\t\t\tgl.setSize(size.width, size.height, updateStyle);\n\t\t\t}\n\n\t\t\t// Update viewport once the camera changes\n\t\t\tif (camera !== oldCamera) {\n\t\t\t\toldCamera = camera;\n\t\t\t\tupdateCamera(camera, size);\n\t\t\t\t// Update viewport\n\t\t\t\tstore.set((state) => ({\n\t\t\t\t\tviewport: { ...state.viewport, ...state.viewport.getCurrentViewport(camera) },\n\t\t\t\t}));\n\t\t\t}\n\t\t});\n\n\t\treturn store;\n\t});\n}\n\nexport type NgtStore = ReturnType<typeof storeFactory>;\n\nexport const NGT_STORE = new InjectionToken<NgtStore>('NgtStore token');\nexport const [injectNgtStore, provideNgtStore] = createInjectionToken(storeFactory, {\n\tisRoot: false,\n\tdeps: [NGT_LOOP, DOCUMENT, Injector, [new Optional(), new SkipSelf(), NGT_STORE]],\n\ttoken: NGT_STORE,\n});\n"]}

package/esm2022/lib/three-types.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"three-types.js","sourceRoot":"","sources":["../../../../../libs/angular-three/src/lib/three-types.ts"],"names":[],"mappings":"","sourcesContent":["import * as THREE from 'three';\nimport type { NgtInjectedRef } from './di/ref';\nimport type {\n    NgtAfterAttach,\n    NgtAnyRecord,\n    NgtAttachFunction,\n    NgtBeforeRenderEvent,\n    NgtEventHandlers,\n    NgtInstanceNode,\n} from './types';\n\nexport type NgtNonFunctionKeys<T> = { [K in keyof T]-?: T[K] extends Function ? never : K }[keyof T];\nexport type NgtOverwrite<T, O> = Omit<T, NgtNonFunctionKeys<O>> & O;\n\nexport type NgtExtendedColors<T> = {\n    [K in keyof T]: T[K] extends THREE.Color | undefined ? THREE.ColorRepresentation : T[K];\n};\n\n/**\n * If **T** contains a constructor, @see ConstructorParameters must be used, otherwise **T**.\n */\ntype NgtArgs<T> = T extends new (...args: any) => any ? ConstructorParameters<T> : T;\n\nexport type NgtEuler = THREE.Euler | Parameters<THREE.Euler['set']>;\nexport type NgtMatrix4 = THREE.Matrix4 | Parameters<THREE.Matrix4['set']> | Readonly<THREE.Matrix4['set']>;\n\n/**\n * Turn an implementation of THREE.Vector in to the type that an r3f component would accept as a prop.\n */\ntype NgtVectorLike<VectorClass extends THREE.Vector> =\n    | VectorClass\n    | Parameters<VectorClass['set']>\n    | Readonly<Parameters<VectorClass['set']>>\n    | Parameters<VectorClass['setScalar']>[0];\n\nexport type NgtVector2 = NgtVectorLike<THREE.Vector2>;\nexport type NgtVector3 = NgtVectorLike<THREE.Vector3>;\nexport type NgtVector4 = NgtVectorLike<THREE.Vector4>;\nexport type NgtLayers = THREE.Layers | Parameters<THREE.Layers['set']>[0];\nexport type NgtQuaternion = THREE.Quaternion | Parameters<THREE.Quaternion['set']>;\n\nexport interface NgtNodeEventMap<TOriginal> {\n    afterAttach: NgtAfterAttach<NgtInstanceNode, TOriginal>;\n    afterUpdate: TOriginal;\n    beforeRender: NgtBeforeRenderEvent<TOriginal>;\n}\n\nexport type NgtNodeElement<TOriginal, TConstructor> = {\n    attach: string | string[] | NgtAttachFunction;\n    ref: NgtInjectedRef<TOriginal>;\n    addEventListener<TEventKey extends keyof NgtNodeEventMap<TOriginal>>(\n        type: TEventKey,\n        listener: (this: NgtNodeElement<TOriginal, TConstructor>, ev: NgtNodeEventMap<TOriginal>[TEventKey]) => any\n    ): void;\n    removeEventListener<TEventKey extends keyof NgtNodeEventMap<TOriginal>>(\n        type: TEventKey,\n        listener: (this: NgtNodeElement<TOriginal, TConstructor>, ev: NgtNodeEventMap<TOriginal>[TEventKey]) => any\n    ): void;\n    __ngt_args__: NgtArgs<TConstructor>;\n};\n\nexport type NgtNode<TOriginal, TConstructor, TNoEvent = NoEvent<TOriginal>> = NgtExtendedColors<\n    NgtOverwrite<Partial<TNoEvent>, NgtNodeElement<TOriginal, TConstructor>>\n>;\n\nexport type NgtObject3DEventsMap = {\n    [TEvent in keyof NgtEventHandlers]-?: Parameters<NonNullable<NgtEventHandlers[TEvent]>>[0];\n};\n\nexport type NgtObject3DNode<TOriginal, TConstructor, TNoEvent = NoEvent<TOriginal>> = NgtOverwrite<\n    NgtNode<TOriginal, TConstructor, TNoEvent>,\n    {\n        position: NgtVector3;\n        up: NgtVector3;\n        scale: NgtVector3;\n        rotation: NgtEuler;\n        matrix: NgtMatrix4;\n        quaternion: NgtQuaternion;\n        layers: NgtLayers;\n        dispose: (() => void) | null;\n        addEventListener<TEventKey extends keyof NgtObject3DEventsMap>(\n            type: TEventKey,\n            listener: (this: NgtObject3DNode<TOriginal, TConstructor>, ev: NgtObject3DEventsMap[TEventKey]) => any\n        ): void;\n        removeEventListener<TEventKey extends keyof NgtObject3DEventsMap>(\n            type: TEventKey,\n            listener: (this: NgtObject3DNode<TOriginal, TConstructor>, ev: NgtObject3DEventsMap[TEventKey]) => any\n        ): void;\n    }\n>;\n\ntype NoEvent<T> = Omit<T, 'addEventListener' | 'removeEventListener'>;\n\nexport type NgtGeometry<TGeometry extends THREE.BufferGeometry, TConstructor> = NgtNode<TGeometry, TConstructor>;\nexport type NgtMaterial<TMaterial extends THREE.Material, TConstructor> = NgtNode<TMaterial, TConstructor>;\nexport type NgtLight<T extends THREE.Light, P> = NgtObject3DNode<T, P>;\n\nexport type NgtObject3D = NgtObject3DNode<THREE.Object3D, typeof THREE.Object3D>;\nexport type NgtAudio = NgtObject3DNode<THREE.Audio, typeof THREE.Audio>;\nexport type NgtAudioListener = NgtObject3DNode<THREE.AudioListener, typeof THREE.AudioListener>;\nexport type NgtPositionalAudio = NgtObject3DNode<THREE.PositionalAudio, typeof THREE.PositionalAudio>;\n\nexport type NgtMesh = NgtObject3DNode<THREE.Mesh, typeof THREE.Mesh>;\nexport type NgtInstancedMesh = NgtObject3DNode<THREE.InstancedMesh, typeof THREE.InstancedMesh>;\nexport type NgtScene = NgtObject3DNode<THREE.Scene, typeof THREE.Scene>;\nexport type NgtSprite = NgtObject3DNode<THREE.Sprite, typeof THREE.Sprite>;\nexport type NgtLOD = NgtObject3DNode<THREE.LOD, typeof THREE.LOD>;\nexport type NgtSkinnedMesh = NgtObject3DNode<THREE.SkinnedMesh, typeof THREE.SkinnedMesh>;\n\nexport type NgtSkeleton = NgtObject3DNode<THREE.Skeleton, typeof THREE.Skeleton>;\nexport type NgtBone = NgtObject3DNode<THREE.Bone, typeof THREE.Bone>;\nexport type NgtLine = NgtObject3DNode<THREE.Line, typeof THREE.Line>;\nexport type NgtLineSegments = NgtObject3DNode<THREE.LineSegments, typeof THREE.LineSegments>;\nexport type NgtLineLoop = NgtObject3DNode<THREE.LineLoop, typeof THREE.LineLoop>;\nexport type NgtPoints = NgtObject3DNode<THREE.Points, typeof THREE.Points>;\nexport type NgtGroup = NgtObject3DNode<THREE.Group, typeof THREE.Group>;\n\nexport type NgtCameraNode = NgtObject3DNode<THREE.Camera, typeof THREE.Camera>;\nexport type NgtPerspectiveCamera = NgtObject3DNode<THREE.PerspectiveCamera, typeof THREE.PerspectiveCamera>;\nexport type NgtOrthographicCamera = NgtObject3DNode<THREE.OrthographicCamera, typeof THREE.OrthographicCamera>;\nexport type NgtCubeCamera = NgtObject3DNode<THREE.CubeCamera, typeof THREE.CubeCamera>;\nexport type NgtArrayCamera = NgtObject3DNode<THREE.ArrayCamera, typeof THREE.ArrayCamera>;\n\nexport type NgtInstancedBufferGeometry = NgtGeometry<\n    THREE.InstancedBufferGeometry,\n    typeof THREE.InstancedBufferGeometry\n>;\nexport type NgtBufferGeometry = NgtGeometry<THREE.BufferGeometry, typeof THREE.BufferGeometry>;\nexport type NgtWireframeGeometry = NgtGeometry<THREE.WireframeGeometry, typeof THREE.WireframeGeometry>;\nexport type NgtTetrahedronGeometry = NgtGeometry<THREE.TetrahedronGeometry, typeof THREE.TetrahedronGeometry>;\nexport type NgtOctahedronGeometry = NgtGeometry<THREE.OctahedronGeometry, typeof THREE.OctahedronGeometry>;\nexport type NgtIcosahedronGeometry = NgtGeometry<THREE.IcosahedronGeometry, typeof THREE.IcosahedronGeometry>;\nexport type NgtDodecahedronGeometry = NgtGeometry<THREE.DodecahedronGeometry, typeof THREE.DodecahedronGeometry>;\nexport type NgtPolyhedronGeometry = NgtGeometry<THREE.PolyhedronGeometry, typeof THREE.PolyhedronGeometry>;\nexport type NgtTubeGeometry = NgtGeometry<THREE.TubeGeometry, typeof THREE.TubeGeometry>;\nexport type NgtTorusKnotGeometry = NgtGeometry<THREE.TorusKnotGeometry, typeof THREE.TorusKnotGeometry>;\nexport type NgtTorusGeometry = NgtGeometry<THREE.TorusGeometry, typeof THREE.TorusGeometry>;\nexport type NgtSphereGeometry = NgtGeometry<THREE.SphereGeometry, typeof THREE.SphereGeometry>;\nexport type NgtRingGeometry = NgtGeometry<THREE.RingGeometry, typeof THREE.RingGeometry>;\nexport type NgtPlaneGeometry = NgtGeometry<THREE.PlaneGeometry, typeof THREE.PlaneGeometry>;\nexport type NgtLatheGeometry = NgtGeometry<THREE.LatheGeometry, typeof THREE.LatheGeometry>;\nexport type NgtShapeGeometry = NgtGeometry<THREE.ShapeGeometry, typeof THREE.ShapeGeometry>;\nexport type NgtExtrudeGeometry = NgtGeometry<THREE.ExtrudeGeometry, typeof THREE.ExtrudeGeometry>;\nexport type NgtEdgesGeometry = NgtGeometry<THREE.EdgesGeometry, typeof THREE.EdgesGeometry>;\nexport type NgtConeGeometry = NgtGeometry<THREE.ConeGeometry, typeof THREE.ConeGeometry>;\nexport type NgtCylinderGeometry = NgtGeometry<THREE.CylinderGeometry, typeof THREE.CylinderGeometry>;\nexport type NgtCircleGeometry = NgtGeometry<THREE.CircleGeometry, typeof THREE.CircleGeometry>;\nexport type NgtBoxGeometry = NgtGeometry<THREE.BoxGeometry, typeof THREE.BoxGeometry>;\nexport type NgtCapsuleGeometry = NgtGeometry<THREE.CapsuleGeometry, typeof THREE.CapsuleGeometry>;\n\nexport type NgtShadowMaterial = NgtMaterial<THREE.ShadowMaterial, [THREE.ShaderMaterialParameters]>;\nexport type NgtSpriteMaterial = NgtMaterial<THREE.SpriteMaterial, [THREE.SpriteMaterialParameters]>;\nexport type NgtRawShaderMaterial = NgtMaterial<THREE.RawShaderMaterial, [THREE.ShaderMaterialParameters]>;\nexport type NgtShaderMaterial = NgtMaterial<THREE.ShaderMaterial, [THREE.ShaderMaterialParameters]>;\nexport type NgtPointsMaterial = NgtMaterial<THREE.PointsMaterial, [THREE.PointsMaterialParameters]>;\nexport type NgtMeshPhysicalMaterial = NgtMaterial<THREE.MeshPhysicalMaterial, [THREE.MeshPhysicalMaterialParameters]>;\nexport type NgtMeshStandardMaterial = NgtMaterial<THREE.MeshStandardMaterial, [THREE.MeshStandardMaterialParameters]>;\nexport type NgtMeshPhongMaterial = NgtMaterial<THREE.MeshPhongMaterial, [THREE.MeshPhongMaterialParameters]>;\nexport type NgtMeshToonMaterial = NgtMaterial<THREE.MeshToonMaterial, [THREE.MeshToonMaterialParameters]>;\nexport type NgtMeshNormalMaterial = NgtMaterial<THREE.MeshNormalMaterial, [THREE.MeshNormalMaterialParameters]>;\nexport type NgtMeshLambertMaterial = NgtMaterial<THREE.MeshLambertMaterial, [THREE.MeshLambertMaterialParameters]>;\nexport type NgtMeshDepthMaterial = NgtMaterial<THREE.MeshDepthMaterial, [THREE.MeshDepthMaterialParameters]>;\nexport type NgtMeshDistanceMaterial = NgtMaterial<THREE.MeshDistanceMaterial, [THREE.MeshDistanceMaterialParameters]>;\nexport type NgtMeshBasicMaterial = NgtMaterial<THREE.MeshBasicMaterial, [THREE.MeshBasicMaterialParameters]>;\nexport type NgtMeshMatcapMaterial = NgtMaterial<THREE.MeshMatcapMaterial, [THREE.MeshMatcapMaterialParameters]>;\nexport type NgtLineDashedMaterial = NgtMaterial<THREE.LineDashedMaterial, [THREE.LineDashedMaterialParameters]>;\nexport type NgtLineBasicMaterial = NgtMaterial<THREE.LineBasicMaterial, [THREE.LineBasicMaterialParameters]>;\n\nexport type NgtPrimitive = NgtNodeElement<NgtAnyRecord, any>;\nexport type NgtValue = NgtNode<{ rawValue: any }, {}>;\n\nexport type NgtLightShadow = NgtNode<THREE.LightShadow, typeof THREE.LightShadow>;\nexport type NgtSpotLightShadow = NgtNode<THREE.SpotLightShadow, typeof THREE.SpotLightShadow>;\nexport type NgtDirectionalLightShadow = NgtNode<THREE.DirectionalLightShadow, typeof THREE.DirectionalLightShadow>;\n\nexport type NgtSpotLight = NgtLight<THREE.SpotLight, typeof THREE.SpotLight>;\nexport type NgtPointLight = NgtLight<THREE.PointLight, typeof THREE.PointLight>;\nexport type NgtRectAreaLight = NgtLight<THREE.RectAreaLight, typeof THREE.RectAreaLight>;\nexport type NgtHemisphereLight = NgtLight<THREE.HemisphereLight, typeof THREE.HemisphereLight>;\nexport type NgtDirectionalLight = NgtLight<THREE.DirectionalLight, typeof THREE.DirectionalLight>;\nexport type NgtAmbientLight = NgtLight<THREE.AmbientLight, typeof THREE.AmbientLight>;\nexport type NgtAmbientLightProbe = NgtLight<THREE.AmbientLightProbe, typeof THREE.AmbientLightProbe>;\nexport type NgtHemisphereLightProbe = NgtLight<THREE.HemisphereLightProbe, typeof THREE.HemisphereLightProbe>;\nexport type NgtLightProbe = NgtLight<THREE.LightProbe, typeof THREE.LightProbe>;\n\nexport type NgtSpotLightHelper = NgtObject3DNode<THREE.SpotLightHelper, typeof THREE.SpotLightHelper>;\nexport type NgtSkeletonHelper = NgtObject3DNode<THREE.SkeletonHelper, typeof THREE.SkeletonHelper>;\nexport type NgtPointLightHelper = NgtObject3DNode<THREE.PointLightHelper, typeof THREE.PointLightHelper>;\nexport type NgtHemisphereLightHelper = NgtObject3DNode<THREE.HemisphereLightHelper, typeof THREE.HemisphereLightHelper>;\nexport type NgtGridHelper = NgtObject3DNode<THREE.GridHelper, typeof THREE.GridHelper>;\nexport type NgtPolarGridHelper = NgtObject3DNode<THREE.PolarGridHelper, typeof THREE.PolarGridHelper>;\nexport type NgtDirectionalLightHelper = NgtObject3DNode<\n    THREE.DirectionalLightHelper,\n    typeof THREE.DirectionalLightHelper\n>;\nexport type NgtCameraHelper = NgtObject3DNode<THREE.CameraHelper, typeof THREE.CameraHelper>;\nexport type NgtBoxHelper = NgtObject3DNode<THREE.BoxHelper, typeof THREE.BoxHelper>;\nexport type NgtBox3Helper = NgtObject3DNode<THREE.Box3Helper, typeof THREE.Box3Helper>;\nexport type NgtPlaneHelper = NgtObject3DNode<THREE.PlaneHelper, typeof THREE.PlaneHelper>;\nexport type NgtArrowHelper = NgtObject3DNode<THREE.ArrowHelper, typeof THREE.ArrowHelper>;\nexport type NgtAxesHelper = NgtObject3DNode<THREE.AxesHelper, typeof THREE.AxesHelper>;\n\nexport type NgtTexture = NgtNode<THREE.Texture, typeof THREE.Texture>;\nexport type NgtVideoTexture = NgtNode<THREE.VideoTexture, typeof THREE.VideoTexture>;\nexport type NgtDataTexture = NgtNode<THREE.DataTexture, typeof THREE.DataTexture>;\nexport type NgtData3DTexture = NgtNode<THREE.Data3DTexture, typeof THREE.Data3DTexture>;\nexport type NgtCompressedTexture = NgtNode<THREE.CompressedTexture, typeof THREE.CompressedTexture>;\nexport type NgtCubeTexture = NgtNode<THREE.CubeTexture, typeof THREE.CubeTexture>;\nexport type NgtCanvasTexture = NgtNode<THREE.CanvasTexture, typeof THREE.CanvasTexture>;\nexport type NgtDepthTexture = NgtNode<THREE.DepthTexture, typeof THREE.DepthTexture>;\n\nexport type NgtRaycaster = NgtNode<THREE.Raycaster, typeof THREE.Raycaster>;\nexport type NgtVector2Node = NgtNode<THREE.Vector2, typeof THREE.Vector2>;\nexport type NgtVector3Node = NgtNode<THREE.Vector3, typeof THREE.Vector3>;\nexport type NgtVector4Node = NgtNode<THREE.Vector4, typeof THREE.Vector4>;\nexport type NgtEulerNode = NgtNode<THREE.Euler, typeof THREE.Euler>;\nexport type NgtMatrix3Node = NgtNode<THREE.Matrix3, typeof THREE.Matrix3>;\nexport type NgtMatrix4Node = NgtNode<THREE.Matrix4, typeof THREE.Matrix4>;\nexport type NgtQuaternionNode = NgtNode<THREE.Quaternion, typeof THREE.Quaternion>;\nexport type NgtBufferAttribute = NgtNode<THREE.BufferAttribute, typeof THREE.BufferAttribute>;\nexport type NgtFloat16BufferAttribute = NgtNode<THREE.Float16BufferAttribute, typeof THREE.Float16BufferAttribute>;\nexport type NgtFloat32BufferAttribute = NgtNode<THREE.Float32BufferAttribute, typeof THREE.Float32BufferAttribute>;\nexport type NgtFloat64BufferAttribute = NgtNode<THREE.Float64BufferAttribute, typeof THREE.Float64BufferAttribute>;\nexport type NgtInt8BufferAttribute = NgtNode<THREE.Int8BufferAttribute, typeof THREE.Int8BufferAttribute>;\nexport type NgtInt16BufferAttribute = NgtNode<THREE.Int16BufferAttribute, typeof THREE.Int16BufferAttribute>;\nexport type NgtInt32BufferAttribute = NgtNode<THREE.Int32BufferAttribute, typeof THREE.Int32BufferAttribute>;\nexport type NgtUint8BufferAttribute = NgtNode<THREE.Uint8BufferAttribute, typeof THREE.Uint8BufferAttribute>;\nexport type NgtUint16BufferAttribute = NgtNode<THREE.Uint16BufferAttribute, typeof THREE.Uint16BufferAttribute>;\nexport type NgtUint32BufferAttribute = NgtNode<THREE.Uint32BufferAttribute, typeof THREE.Uint32BufferAttribute>;\nexport type NgtInstancedBufferAttribute = NgtNode<\n    THREE.InstancedBufferAttribute,\n    typeof THREE.InstancedBufferAttribute\n>;\nexport type NgtColor = NgtNode<THREE.Color, THREE.ColorRepresentation>;\nexport type NgtFog = NgtNode<THREE.Fog, typeof THREE.Fog>;\nexport type NgtFogExp2 = NgtNode<THREE.FogExp2, typeof THREE.FogExp2>;\nexport type NgtShape = NgtNode<THREE.Shape, typeof THREE.Shape>;\n\nexport interface ThreeElements {\n    'ngt-object3D': NgtObject3D;\n\n    // `audio` works but conflicts with @types/react. Try using PositionalAudio from @react-three/drei instead\n    'ngt-audio': NgtAudio;\n    'ngt-audio-listener': NgtAudioListener;\n    'ngt-positional-audio': NgtPositionalAudio;\n\n    'ngt-mesh': NgtMesh;\n    'ngt-instanced-mesh': NgtInstancedMesh;\n    'ngt-scene': NgtScene;\n    'ngt-sprite': NgtSprite;\n    'ngt-lOD': NgtLOD;\n    'ngt-skinned-mesh': NgtSkinnedMesh;\n    'ngt-skeleton': NgtSkeleton;\n    'ngt-bone': NgtBone;\n\n    'ngt-line': NgtLine;\n    'ngt-line-segments': NgtLineSegments;\n    'ngt-line-loop': NgtLineLoop;\n    'ngt-points': NgtPoints;\n    'ngt-group': NgtGroup;\n\n    // cameras\n    'ngt-camera': NgtCameraNode;\n    'ngt-perspective-camera': NgtPerspectiveCamera;\n    'ngt-orthographic-camera': NgtOrthographicCamera;\n    'ngt-cube-camera': NgtCubeCamera;\n    'ngt-array-camera': NgtArrayCamera;\n\n    // geometry\n    'ngt-instanced-buffer-geometry': NgtInstancedBufferGeometry;\n    'ngt-buffer-geometry': NgtBufferGeometry;\n    'ngt-wireframe-geometry': NgtWireframeGeometry;\n    'ngt-tetrahedron-geometry': NgtTetrahedronGeometry;\n    'ngt-octahedron-geometry': NgtOctahedronGeometry;\n    'ngt-icosahedron-geometry': NgtIcosahedronGeometry;\n    'ngt-polyhedron-geometry': NgtPolyhedronGeometry;\n    'ngt-dodecahedron-geometry': NgtDodecahedronGeometry;\n    'ngt-tube-geometry': NgtTubeGeometry;\n    'ngt-torus-knot-geometry': NgtTorusKnotGeometry;\n    'ngt-torus-geometry': NgtTorusGeometry;\n    'ngt-sphere-geometry': NgtSphereGeometry;\n    'ngt-ring-geometry': NgtRingGeometry;\n    'ngt-plane-geometry': NgtPlaneGeometry;\n    'ngt-lathe-geometry': NgtLatheGeometry;\n    'ngt-shape-geometry': NgtShapeGeometry;\n    'ngt-extrude-geometry': NgtExtrudeGeometry;\n    'ngt-edges-geometry': NgtEdgesGeometry;\n    'ngt-cone-geometry': NgtConeGeometry;\n    'ngt-cylinder-geometry': NgtCylinderGeometry;\n    'ngt-circle-geometry': NgtCircleGeometry;\n    'ngt-box-geometry': NgtBoxGeometry;\n    'ngt-capsule-geometry': NgtCapsuleGeometry;\n\n    // materials\n    'ngt-shadow-material': NgtShadowMaterial;\n    'ngt-sprite-material': NgtSpriteMaterial;\n    'ngt-raw-shader-material': NgtRawShaderMaterial;\n    'ngt-shader-material': NgtShaderMaterial;\n    'ngt-points-material': NgtPointsMaterial;\n    'ngt-mesh-physical-material': NgtMeshPhysicalMaterial;\n    'ngt-mesh-standard-material': NgtMeshStandardMaterial;\n    'ngt-mesh-phong-material': NgtMeshPhongMaterial;\n    'ngt-mesh-toon-material': NgtMeshToonMaterial;\n    'ngt-mesh-normal-material': NgtMeshNormalMaterial;\n    'ngt-mesh-lambert-material': NgtMeshLambertMaterial;\n    'ngt-mesh-depth-material': NgtMeshDepthMaterial;\n    'ngt-mesh-distance-material': NgtMeshDistanceMaterial;\n    'ngt-mesh-basic-material': NgtMeshBasicMaterial;\n    'ngt-mesh-matcap-material': NgtMeshMatcapMaterial;\n    'ngt-line-dashed-material': NgtLineDashedMaterial;\n    'ngt-line-basic-material': NgtLineBasicMaterial;\n\n    // primitive\n    'ngt-primitive': NgtPrimitive;\n\n    // rawValue\n    'ngt-value': NgtValue;\n\n    // lights and other\n    'ngt-spot-light-shadow': NgtSpotLightShadow;\n    'ngt-spot-light': NgtSpotLight;\n    'ngt-point-light': NgtPointLight;\n    'ngt-rect-area-light': NgtRectAreaLight;\n    'ngt-hemisphere-light': NgtHemisphereLight;\n    'ngt-directional-light-shadow': NgtDirectionalLightShadow;\n    'ngt-directional-light': NgtDirectionalLight;\n    'ngt-ambient-light': NgtAmbientLight;\n    'ngt-light-shadow': NgtLightShadow;\n    'ngt-ambient-light-probe': NgtAmbientLightProbe;\n    'ngt-hemisphere-light-probe': NgtHemisphereLightProbe;\n    'ngt-light-probe': NgtLightProbe;\n\n    // helpers\n    'ngt-spot-light-helper': NgtSpotLightHelper;\n    'ngt-skeleton-helper': NgtSkeletonHelper;\n    'ngt-point-light-helper': NgtPointLightHelper;\n    'ngt-hemisphere-light-helper': NgtHemisphereLightHelper;\n    'ngt-grid-helper': NgtGridHelper;\n    'ngt-polar-grid-helper': NgtPolarGridHelper;\n    'ngt-directional-light-helper': NgtDirectionalLightHelper;\n    'ngt-camera-helper': NgtCameraHelper;\n    'ngt-box-helper': NgtBoxHelper;\n    'ngt-box3-helper': NgtBox3Helper;\n    'ngt-plane-helper': NgtPlaneHelper;\n    'ngt-arrow-helper': NgtArrowHelper;\n    'ngt-axes-helper': NgtAxesHelper;\n\n    // textures\n    'ngt-texture': NgtTexture;\n    'ngt-video-texture': NgtVideoTexture;\n    'ngt-data-texture': NgtDataTexture;\n    'ngt-data3D-texture': NgtData3DTexture;\n    'ngt-compressed-texture': NgtCompressedTexture;\n    'ngt-cube-texture': NgtCubeTexture;\n    'ngt-canvas-texture': NgtCanvasTexture;\n    'ngt-depth-texture': NgtDepthTexture;\n\n    // misc\n    'ngt-raycaster': NgtRaycaster;\n    'ngt-vector2': NgtVector2Node;\n    'ngt-vector3': NgtVector3Node;\n    'ngt-vector4': NgtVector4Node;\n    'ngt-euler': NgtEulerNode;\n    'ngt-matrix3': NgtMatrix3Node;\n    'ngt-matrix4': NgtMatrix4Node;\n    'ngt-quaternion': NgtQuaternionNode;\n    'ngt-buffer-attribute': NgtBufferAttribute;\n    'ngt-float16-buffer-attribute': NgtFloat16BufferAttribute;\n    'ngt-float32-buffer-attribute': NgtFloat32BufferAttribute;\n    'ngt-float64-buffer-attribute': NgtFloat64BufferAttribute;\n    'ngt-int8-buffer-attribute': NgtInt8BufferAttribute;\n    'ngt-int16-buffer-attribute': NgtInt16BufferAttribute;\n    'ngt-int32-buffer-attribute': NgtInt32BufferAttribute;\n    'ngt-unit8-buffer-attribute': NgtUint8BufferAttribute;\n    'ngt-unit16-buffer-attribute': NgtUint16BufferAttribute;\n    'ngt-unit32-buffer-attribute': NgtUint32BufferAttribute;\n    'ngt-instanced-buffer-attribute': NgtInstancedBufferAttribute;\n    'ngt-color': NgtColor;\n    'ngt-fog': NgtFog;\n    'ngt-fog-exp2': NgtFogExp2;\n    'ngt-shape': NgtShape;\n}\n\ndeclare global {\n    interface HTMLElementTagNameMap extends ThreeElements {}\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"three-types.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/three-types.ts"],"names":[],"mappings":"","sourcesContent":["import * as THREE from 'three';\nimport type { NgtEventHandlers } from './events';\nimport type { NgtAfterAttach, NgtAttachFunction, NgtInstanceNode } from './instance';\nimport type { NgtBeforeRenderEvent } from './store';\n\ntype NoEvent<T> = Omit<T, 'addEventListener' | 'removeEventListener'>;\n\nexport type NgtNonFunctionKeys<T> = { [K in keyof T]-?: T[K] extends Function ? never : K }[keyof T];\nexport type NgtOverwrite<T, O> = Omit<T, NgtNonFunctionKeys<O>> & O;\n\nexport type NgtExtendedColors<T> = {\n\t[K in keyof T]: T[K] extends THREE.Color | undefined ? THREE.ColorRepresentation : T[K];\n};\n\n/**\n * If **T** contains a constructor, @see ConstructorParameters must be used, otherwise **T**.\n */\ntype NgtArgs<T> = T extends new (...args: any) => any ? ConstructorParameters<T> : T;\n\nexport type NgtEuler = THREE.Euler | Parameters<THREE.Euler['set']>;\nexport type NgtMatrix4 = THREE.Matrix4 | Parameters<THREE.Matrix4['set']> | Readonly<THREE.Matrix4['set']>;\n\n/**\n * Turn an implementation of THREE.Vector in to the type that an r3f component would accept as a prop.\n */\ntype NgtVectorLike<VectorClass extends THREE.Vector> =\n\t| VectorClass\n\t| Parameters<VectorClass['set']>\n\t| Readonly<Parameters<VectorClass['set']>>\n\t| Parameters<VectorClass['setScalar']>[0];\n\nexport type NgtVector2 = NgtVectorLike<THREE.Vector2>;\nexport type NgtVector3 = NgtVectorLike<THREE.Vector3>;\nexport type NgtVector4 = NgtVectorLike<THREE.Vector4>;\nexport type NgtLayers = THREE.Layers | Parameters<THREE.Layers['set']>[0];\nexport type NgtQuaternion = THREE.Quaternion | Parameters<THREE.Quaternion['set']>;\n\nexport interface NgtNodeEventMap<TOriginal> {\n\tafterAttach: NgtAfterAttach<NgtInstanceNode, TOriginal>;\n\tafterUpdate: TOriginal;\n\tbeforeRender: NgtBeforeRenderEvent<TOriginal>;\n}\n\nexport type NgtNodeElement<TOriginal, TConstructor> = {\n\tattach: string | string[] | NgtAttachFunction;\n\t// ref: NgtInjectedRef<TOriginal>;\n\taddEventListener<TEventKey extends keyof NgtNodeEventMap<TOriginal>>(\n\t\ttype: TEventKey,\n\t\tlistener: (this: NgtNodeElement<TOriginal, TConstructor>, ev: NgtNodeEventMap<TOriginal>[TEventKey]) => any,\n\t): void;\n\tremoveEventListener<TEventKey extends keyof NgtNodeEventMap<TOriginal>>(\n\t\ttype: TEventKey,\n\t\tlistener: (this: NgtNodeElement<TOriginal, TConstructor>, ev: NgtNodeEventMap<TOriginal>[TEventKey]) => any,\n\t): void;\n\t__ngt_args__: NgtArgs<TConstructor>;\n};\n\nexport type NgtNode<TOriginal, TConstructor, TNoEvent = NoEvent<TOriginal>> = NgtExtendedColors<\n\tNgtOverwrite<Partial<TNoEvent>, NgtNodeElement<TOriginal, TConstructor>>\n>;\n\nexport type NgtObject3DEventsMap = {\n\t[TEvent in keyof NgtEventHandlers]-?: Parameters<NonNullable<NgtEventHandlers[TEvent]>>[0];\n};\n\nexport type NgtObject3DNode<TOriginal, TConstructor, TNoEvent = NoEvent<TOriginal>> = NgtOverwrite<\n\tNgtNode<TOriginal, TConstructor, TNoEvent>,\n\t{\n\t\tposition: NgtVector3;\n\t\tup: NgtVector3;\n\t\tscale: NgtVector3;\n\t\trotation: NgtEuler;\n\t\tmatrix: NgtMatrix4;\n\t\tquaternion: NgtQuaternion;\n\t\tlayers: NgtLayers;\n\t\tdispose: (() => void) | null;\n\t\taddEventListener<TEventKey extends keyof NgtObject3DEventsMap>(\n\t\t\ttype: TEventKey,\n\t\t\tlistener: (this: NgtObject3DNode<TOriginal, TConstructor>, ev: NgtObject3DEventsMap[TEventKey]) => any,\n\t\t): void;\n\t\tremoveEventListener<TEventKey extends keyof NgtObject3DEventsMap>(\n\t\t\ttype: TEventKey,\n\t\t\tlistener: (this: NgtObject3DNode<TOriginal, TConstructor>, ev: NgtObject3DEventsMap[TEventKey]) => any,\n\t\t): void;\n\t}\n>;\n\nexport type NgtGeometry<TGeometry extends THREE.BufferGeometry, TConstructor> = NgtNode<TGeometry, TConstructor>;\nexport type NgtMaterial<TMaterial extends THREE.Material, TConstructor> = NgtNode<TMaterial, TConstructor>;\nexport type NgtLight<T extends THREE.Light, P> = NgtObject3DNode<T, P>;\n\nexport type NgtObject3D = NgtObject3DNode<THREE.Object3D, typeof THREE.Object3D>;\nexport type NgtAudio = NgtObject3DNode<THREE.Audio, typeof THREE.Audio>;\nexport type NgtAudioListener = NgtObject3DNode<THREE.AudioListener, typeof THREE.AudioListener>;\nexport type NgtPositionalAudio = NgtObject3DNode<THREE.PositionalAudio, typeof THREE.PositionalAudio>;\n\nexport type NgtMesh = NgtObject3DNode<THREE.Mesh, typeof THREE.Mesh>;\nexport type NgtInstancedMesh = NgtObject3DNode<THREE.InstancedMesh, typeof THREE.InstancedMesh>;\nexport type NgtScene = NgtObject3DNode<THREE.Scene, typeof THREE.Scene>;\nexport type NgtSprite = NgtObject3DNode<THREE.Sprite, typeof THREE.Sprite>;\nexport type NgtLOD = NgtObject3DNode<THREE.LOD, typeof THREE.LOD>;\nexport type NgtSkinnedMesh = NgtObject3DNode<THREE.SkinnedMesh, typeof THREE.SkinnedMesh>;\n\nexport type NgtSkeleton = NgtObject3DNode<THREE.Skeleton, typeof THREE.Skeleton>;\nexport type NgtBone = NgtObject3DNode<THREE.Bone, typeof THREE.Bone>;\nexport type NgtLine = NgtObject3DNode<THREE.Line, typeof THREE.Line>;\nexport type NgtLineSegments = NgtObject3DNode<THREE.LineSegments, typeof THREE.LineSegments>;\nexport type NgtLineLoop = NgtObject3DNode<THREE.LineLoop, typeof THREE.LineLoop>;\nexport type NgtPoints = NgtObject3DNode<THREE.Points, typeof THREE.Points>;\nexport type NgtGroup = NgtObject3DNode<THREE.Group, typeof THREE.Group>;\n\nexport type NgtCameraNode = NgtObject3DNode<THREE.Camera, typeof THREE.Camera>;\nexport type NgtPerspectiveCamera = NgtObject3DNode<THREE.PerspectiveCamera, typeof THREE.PerspectiveCamera>;\nexport type NgtOrthographicCamera = NgtObject3DNode<THREE.OrthographicCamera, typeof THREE.OrthographicCamera>;\nexport type NgtCubeCamera = NgtObject3DNode<THREE.CubeCamera, typeof THREE.CubeCamera>;\nexport type NgtArrayCamera = NgtObject3DNode<THREE.ArrayCamera, typeof THREE.ArrayCamera>;\n\nexport type NgtInstancedBufferGeometry = NgtGeometry<\n\tTHREE.InstancedBufferGeometry,\n\ttypeof THREE.InstancedBufferGeometry\n>;\nexport type NgtBufferGeometry = NgtGeometry<THREE.BufferGeometry, typeof THREE.BufferGeometry>;\nexport type NgtWireframeGeometry = NgtGeometry<THREE.WireframeGeometry, typeof THREE.WireframeGeometry>;\nexport type NgtTetrahedronGeometry = NgtGeometry<THREE.TetrahedronGeometry, typeof THREE.TetrahedronGeometry>;\nexport type NgtOctahedronGeometry = NgtGeometry<THREE.OctahedronGeometry, typeof THREE.OctahedronGeometry>;\nexport type NgtIcosahedronGeometry = NgtGeometry<THREE.IcosahedronGeometry, typeof THREE.IcosahedronGeometry>;\nexport type NgtDodecahedronGeometry = NgtGeometry<THREE.DodecahedronGeometry, typeof THREE.DodecahedronGeometry>;\nexport type NgtPolyhedronGeometry = NgtGeometry<THREE.PolyhedronGeometry, typeof THREE.PolyhedronGeometry>;\nexport type NgtTubeGeometry = NgtGeometry<THREE.TubeGeometry, typeof THREE.TubeGeometry>;\nexport type NgtTorusKnotGeometry = NgtGeometry<THREE.TorusKnotGeometry, typeof THREE.TorusKnotGeometry>;\nexport type NgtTorusGeometry = NgtGeometry<THREE.TorusGeometry, typeof THREE.TorusGeometry>;\nexport type NgtSphereGeometry = NgtGeometry<THREE.SphereGeometry, typeof THREE.SphereGeometry>;\nexport type NgtRingGeometry = NgtGeometry<THREE.RingGeometry, typeof THREE.RingGeometry>;\nexport type NgtPlaneGeometry = NgtGeometry<THREE.PlaneGeometry, typeof THREE.PlaneGeometry>;\nexport type NgtLatheGeometry = NgtGeometry<THREE.LatheGeometry, typeof THREE.LatheGeometry>;\nexport type NgtShapeGeometry = NgtGeometry<THREE.ShapeGeometry, typeof THREE.ShapeGeometry>;\nexport type NgtExtrudeGeometry = NgtGeometry<THREE.ExtrudeGeometry, typeof THREE.ExtrudeGeometry>;\nexport type NgtEdgesGeometry = NgtGeometry<THREE.EdgesGeometry, typeof THREE.EdgesGeometry>;\nexport type NgtConeGeometry = NgtGeometry<THREE.ConeGeometry, typeof THREE.ConeGeometry>;\nexport type NgtCylinderGeometry = NgtGeometry<THREE.CylinderGeometry, typeof THREE.CylinderGeometry>;\nexport type NgtCircleGeometry = NgtGeometry<THREE.CircleGeometry, typeof THREE.CircleGeometry>;\nexport type NgtBoxGeometry = NgtGeometry<THREE.BoxGeometry, typeof THREE.BoxGeometry>;\nexport type NgtCapsuleGeometry = NgtGeometry<THREE.CapsuleGeometry, typeof THREE.CapsuleGeometry>;\n\nexport type NgtShadowMaterial = NgtMaterial<THREE.ShadowMaterial, [THREE.ShaderMaterialParameters]>;\nexport type NgtSpriteMaterial = NgtMaterial<THREE.SpriteMaterial, [THREE.SpriteMaterialParameters]>;\nexport type NgtRawShaderMaterial = NgtMaterial<THREE.RawShaderMaterial, [THREE.ShaderMaterialParameters]>;\nexport type NgtShaderMaterial = NgtMaterial<THREE.ShaderMaterial, [THREE.ShaderMaterialParameters]>;\nexport type NgtPointsMaterial = NgtMaterial<THREE.PointsMaterial, [THREE.PointsMaterialParameters]>;\nexport type NgtMeshPhysicalMaterial = NgtMaterial<THREE.MeshPhysicalMaterial, [THREE.MeshPhysicalMaterialParameters]>;\nexport type NgtMeshStandardMaterial = NgtMaterial<THREE.MeshStandardMaterial, [THREE.MeshStandardMaterialParameters]>;\nexport type NgtMeshPhongMaterial = NgtMaterial<THREE.MeshPhongMaterial, [THREE.MeshPhongMaterialParameters]>;\nexport type NgtMeshToonMaterial = NgtMaterial<THREE.MeshToonMaterial, [THREE.MeshToonMaterialParameters]>;\nexport type NgtMeshNormalMaterial = NgtMaterial<THREE.MeshNormalMaterial, [THREE.MeshNormalMaterialParameters]>;\nexport type NgtMeshLambertMaterial = NgtMaterial<THREE.MeshLambertMaterial, [THREE.MeshLambertMaterialParameters]>;\nexport type NgtMeshDepthMaterial = NgtMaterial<THREE.MeshDepthMaterial, [THREE.MeshDepthMaterialParameters]>;\nexport type NgtMeshDistanceMaterial = NgtMaterial<THREE.MeshDistanceMaterial, [THREE.MeshDistanceMaterialParameters]>;\nexport type NgtMeshBasicMaterial = NgtMaterial<THREE.MeshBasicMaterial, [THREE.MeshBasicMaterialParameters]>;\nexport type NgtMeshMatcapMaterial = NgtMaterial<THREE.MeshMatcapMaterial, [THREE.MeshMatcapMaterialParameters]>;\nexport type NgtLineDashedMaterial = NgtMaterial<THREE.LineDashedMaterial, [THREE.LineDashedMaterialParameters]>;\nexport type NgtLineBasicMaterial = NgtMaterial<THREE.LineBasicMaterial, [THREE.LineBasicMaterialParameters]>;\n\nexport type NgtPrimitive = NgtNodeElement<any, any>;\nexport type NgtValue = NgtNode<{ rawValue: any }, {}>;\n\nexport type NgtLightShadow = NgtNode<THREE.LightShadow, typeof THREE.LightShadow>;\nexport type NgtSpotLightShadow = NgtNode<THREE.SpotLightShadow, typeof THREE.SpotLightShadow>;\nexport type NgtDirectionalLightShadow = NgtNode<THREE.DirectionalLightShadow, typeof THREE.DirectionalLightShadow>;\n\nexport type NgtSpotLight = NgtLight<THREE.SpotLight, typeof THREE.SpotLight>;\nexport type NgtPointLight = NgtLight<THREE.PointLight, typeof THREE.PointLight>;\nexport type NgtRectAreaLight = NgtLight<THREE.RectAreaLight, typeof THREE.RectAreaLight>;\nexport type NgtHemisphereLight = NgtLight<THREE.HemisphereLight, typeof THREE.HemisphereLight>;\nexport type NgtDirectionalLight = NgtLight<THREE.DirectionalLight, typeof THREE.DirectionalLight>;\nexport type NgtAmbientLight = NgtLight<THREE.AmbientLight, typeof THREE.AmbientLight>;\nexport type NgtAmbientLightProbe = NgtLight<THREE.AmbientLightProbe, typeof THREE.AmbientLightProbe>;\nexport type NgtHemisphereLightProbe = NgtLight<THREE.HemisphereLightProbe, typeof THREE.HemisphereLightProbe>;\nexport type NgtLightProbe = NgtLight<THREE.LightProbe, typeof THREE.LightProbe>;\n\nexport type NgtSpotLightHelper = NgtObject3DNode<THREE.SpotLightHelper, typeof THREE.SpotLightHelper>;\nexport type NgtSkeletonHelper = NgtObject3DNode<THREE.SkeletonHelper, typeof THREE.SkeletonHelper>;\nexport type NgtPointLightHelper = NgtObject3DNode<THREE.PointLightHelper, typeof THREE.PointLightHelper>;\nexport type NgtHemisphereLightHelper = NgtObject3DNode<THREE.HemisphereLightHelper, typeof THREE.HemisphereLightHelper>;\nexport type NgtGridHelper = NgtObject3DNode<THREE.GridHelper, typeof THREE.GridHelper>;\nexport type NgtPolarGridHelper = NgtObject3DNode<THREE.PolarGridHelper, typeof THREE.PolarGridHelper>;\nexport type NgtDirectionalLightHelper = NgtObject3DNode<\n\tTHREE.DirectionalLightHelper,\n\ttypeof THREE.DirectionalLightHelper\n>;\nexport type NgtCameraHelper = NgtObject3DNode<THREE.CameraHelper, typeof THREE.CameraHelper>;\nexport type NgtBoxHelper = NgtObject3DNode<THREE.BoxHelper, typeof THREE.BoxHelper>;\nexport type NgtBox3Helper = NgtObject3DNode<THREE.Box3Helper, typeof THREE.Box3Helper>;\nexport type NgtPlaneHelper = NgtObject3DNode<THREE.PlaneHelper, typeof THREE.PlaneHelper>;\nexport type NgtArrowHelper = NgtObject3DNode<THREE.ArrowHelper, typeof THREE.ArrowHelper>;\nexport type NgtAxesHelper = NgtObject3DNode<THREE.AxesHelper, typeof THREE.AxesHelper>;\n\nexport type NgtTexture = NgtNode<THREE.Texture, typeof THREE.Texture>;\nexport type NgtVideoTexture = NgtNode<THREE.VideoTexture, typeof THREE.VideoTexture>;\nexport type NgtDataTexture = NgtNode<THREE.DataTexture, typeof THREE.DataTexture>;\nexport type NgtData3DTexture = NgtNode<THREE.Data3DTexture, typeof THREE.Data3DTexture>;\nexport type NgtCompressedTexture = NgtNode<THREE.CompressedTexture, typeof THREE.CompressedTexture>;\nexport type NgtCubeTexture = NgtNode<THREE.CubeTexture, typeof THREE.CubeTexture>;\nexport type NgtCanvasTexture = NgtNode<THREE.CanvasTexture, typeof THREE.CanvasTexture>;\nexport type NgtDepthTexture = NgtNode<THREE.DepthTexture, typeof THREE.DepthTexture>;\n\nexport type NgtRaycaster = NgtNode<THREE.Raycaster, typeof THREE.Raycaster>;\nexport type NgtVector2Node = NgtNode<THREE.Vector2, typeof THREE.Vector2>;\nexport type NgtVector3Node = NgtNode<THREE.Vector3, typeof THREE.Vector3>;\nexport type NgtVector4Node = NgtNode<THREE.Vector4, typeof THREE.Vector4>;\nexport type NgtEulerNode = NgtNode<THREE.Euler, typeof THREE.Euler>;\nexport type NgtMatrix3Node = NgtNode<THREE.Matrix3, typeof THREE.Matrix3>;\nexport type NgtMatrix4Node = NgtNode<THREE.Matrix4, typeof THREE.Matrix4>;\nexport type NgtQuaternionNode = NgtNode<THREE.Quaternion, typeof THREE.Quaternion>;\nexport type NgtBufferAttribute = NgtNode<THREE.BufferAttribute, typeof THREE.BufferAttribute>;\nexport type NgtFloat16BufferAttribute = NgtNode<THREE.Float16BufferAttribute, typeof THREE.Float16BufferAttribute>;\nexport type NgtFloat32BufferAttribute = NgtNode<THREE.Float32BufferAttribute, typeof THREE.Float32BufferAttribute>;\nexport type NgtFloat64BufferAttribute = NgtNode<THREE.Float64BufferAttribute, typeof THREE.Float64BufferAttribute>;\nexport type NgtInt8BufferAttribute = NgtNode<THREE.Int8BufferAttribute, typeof THREE.Int8BufferAttribute>;\nexport type NgtInt16BufferAttribute = NgtNode<THREE.Int16BufferAttribute, typeof THREE.Int16BufferAttribute>;\nexport type NgtInt32BufferAttribute = NgtNode<THREE.Int32BufferAttribute, typeof THREE.Int32BufferAttribute>;\nexport type NgtUint8BufferAttribute = NgtNode<THREE.Uint8BufferAttribute, typeof THREE.Uint8BufferAttribute>;\nexport type NgtUint16BufferAttribute = NgtNode<THREE.Uint16BufferAttribute, typeof THREE.Uint16BufferAttribute>;\nexport type NgtUint32BufferAttribute = NgtNode<THREE.Uint32BufferAttribute, typeof THREE.Uint32BufferAttribute>;\nexport type NgtInstancedBufferAttribute = NgtNode<\n\tTHREE.InstancedBufferAttribute,\n\ttypeof THREE.InstancedBufferAttribute\n>;\nexport type NgtColor = NgtNode<THREE.Color, THREE.ColorRepresentation>;\nexport type NgtFog = NgtNode<THREE.Fog, typeof THREE.Fog>;\nexport type NgtFogExp2 = NgtNode<THREE.FogExp2, typeof THREE.FogExp2>;\nexport type NgtShape = NgtNode<THREE.Shape, typeof THREE.Shape>;\n\nexport interface ThreeElements {\n\t'ngt-object3D': NgtObject3D;\n\n\t// `audio` works but conflicts with @types/react. Try using PositionalAudio from @react-three/drei instead\n\t'ngt-audio': NgtAudio;\n\t'ngt-audio-listener': NgtAudioListener;\n\t'ngt-positional-audio': NgtPositionalAudio;\n\n\t'ngt-mesh': NgtMesh;\n\t'ngt-instanced-mesh': NgtInstancedMesh;\n\t'ngt-scene': NgtScene;\n\t'ngt-sprite': NgtSprite;\n\t'ngt-lOD': NgtLOD;\n\t'ngt-skinned-mesh': NgtSkinnedMesh;\n\t'ngt-skeleton': NgtSkeleton;\n\t'ngt-bone': NgtBone;\n\n\t'ngt-line': NgtLine;\n\t'ngt-line-segments': NgtLineSegments;\n\t'ngt-line-loop': NgtLineLoop;\n\t'ngt-points': NgtPoints;\n\t'ngt-group': NgtGroup;\n\n\t// cameras\n\t'ngt-camera': NgtCameraNode;\n\t'ngt-perspective-camera': NgtPerspectiveCamera;\n\t'ngt-orthographic-camera': NgtOrthographicCamera;\n\t'ngt-cube-camera': NgtCubeCamera;\n\t'ngt-array-camera': NgtArrayCamera;\n\n\t// geometry\n\t'ngt-instanced-buffer-geometry': NgtInstancedBufferGeometry;\n\t'ngt-buffer-geometry': NgtBufferGeometry;\n\t'ngt-wireframe-geometry': NgtWireframeGeometry;\n\t'ngt-tetrahedron-geometry': NgtTetrahedronGeometry;\n\t'ngt-octahedron-geometry': NgtOctahedronGeometry;\n\t'ngt-icosahedron-geometry': NgtIcosahedronGeometry;\n\t'ngt-polyhedron-geometry': NgtPolyhedronGeometry;\n\t'ngt-dodecahedron-geometry': NgtDodecahedronGeometry;\n\t'ngt-tube-geometry': NgtTubeGeometry;\n\t'ngt-torus-knot-geometry': NgtTorusKnotGeometry;\n\t'ngt-torus-geometry': NgtTorusGeometry;\n\t'ngt-sphere-geometry': NgtSphereGeometry;\n\t'ngt-ring-geometry': NgtRingGeometry;\n\t'ngt-plane-geometry': NgtPlaneGeometry;\n\t'ngt-lathe-geometry': NgtLatheGeometry;\n\t'ngt-shape-geometry': NgtShapeGeometry;\n\t'ngt-extrude-geometry': NgtExtrudeGeometry;\n\t'ngt-edges-geometry': NgtEdgesGeometry;\n\t'ngt-cone-geometry': NgtConeGeometry;\n\t'ngt-cylinder-geometry': NgtCylinderGeometry;\n\t'ngt-circle-geometry': NgtCircleGeometry;\n\t'ngt-box-geometry': NgtBoxGeometry;\n\t'ngt-capsule-geometry': NgtCapsuleGeometry;\n\n\t// materials\n\t'ngt-shadow-material': NgtShadowMaterial;\n\t'ngt-sprite-material': NgtSpriteMaterial;\n\t'ngt-raw-shader-material': NgtRawShaderMaterial;\n\t'ngt-shader-material': NgtShaderMaterial;\n\t'ngt-points-material': NgtPointsMaterial;\n\t'ngt-mesh-physical-material': NgtMeshPhysicalMaterial;\n\t'ngt-mesh-standard-material': NgtMeshStandardMaterial;\n\t'ngt-mesh-phong-material': NgtMeshPhongMaterial;\n\t'ngt-mesh-toon-material': NgtMeshToonMaterial;\n\t'ngt-mesh-normal-material': NgtMeshNormalMaterial;\n\t'ngt-mesh-lambert-material': NgtMeshLambertMaterial;\n\t'ngt-mesh-depth-material': NgtMeshDepthMaterial;\n\t'ngt-mesh-distance-material': NgtMeshDistanceMaterial;\n\t'ngt-mesh-basic-material': NgtMeshBasicMaterial;\n\t'ngt-mesh-matcap-material': NgtMeshMatcapMaterial;\n\t'ngt-line-dashed-material': NgtLineDashedMaterial;\n\t'ngt-line-basic-material': NgtLineBasicMaterial;\n\n\t// primitive\n\t'ngt-primitive': NgtPrimitive;\n\n\t// rawValue\n\t'ngt-value': NgtValue;\n\n\t// lights and other\n\t'ngt-spot-light-shadow': NgtSpotLightShadow;\n\t'ngt-spot-light': NgtSpotLight;\n\t'ngt-point-light': NgtPointLight;\n\t'ngt-rect-area-light': NgtRectAreaLight;\n\t'ngt-hemisphere-light': NgtHemisphereLight;\n\t'ngt-directional-light-shadow': NgtDirectionalLightShadow;\n\t'ngt-directional-light': NgtDirectionalLight;\n\t'ngt-ambient-light': NgtAmbientLight;\n\t'ngt-light-shadow': NgtLightShadow;\n\t'ngt-ambient-light-probe': NgtAmbientLightProbe;\n\t'ngt-hemisphere-light-probe': NgtHemisphereLightProbe;\n\t'ngt-light-probe': NgtLightProbe;\n\n\t// helpers\n\t'ngt-spot-light-helper': NgtSpotLightHelper;\n\t'ngt-skeleton-helper': NgtSkeletonHelper;\n\t'ngt-point-light-helper': NgtPointLightHelper;\n\t'ngt-hemisphere-light-helper': NgtHemisphereLightHelper;\n\t'ngt-grid-helper': NgtGridHelper;\n\t'ngt-polar-grid-helper': NgtPolarGridHelper;\n\t'ngt-directional-light-helper': NgtDirectionalLightHelper;\n\t'ngt-camera-helper': NgtCameraHelper;\n\t'ngt-box-helper': NgtBoxHelper;\n\t'ngt-box3-helper': NgtBox3Helper;\n\t'ngt-plane-helper': NgtPlaneHelper;\n\t'ngt-arrow-helper': NgtArrowHelper;\n\t'ngt-axes-helper': NgtAxesHelper;\n\n\t// textures\n\t'ngt-texture': NgtTexture;\n\t'ngt-video-texture': NgtVideoTexture;\n\t'ngt-data-texture': NgtDataTexture;\n\t'ngt-data3D-texture': NgtData3DTexture;\n\t'ngt-compressed-texture': NgtCompressedTexture;\n\t'ngt-cube-texture': NgtCubeTexture;\n\t'ngt-canvas-texture': NgtCanvasTexture;\n\t'ngt-depth-texture': NgtDepthTexture;\n\n\t// misc\n\t'ngt-raycaster': NgtRaycaster;\n\t'ngt-vector2': NgtVector2Node;\n\t'ngt-vector3': NgtVector3Node;\n\t'ngt-vector4': NgtVector4Node;\n\t'ngt-euler': NgtEulerNode;\n\t'ngt-matrix3': NgtMatrix3Node;\n\t'ngt-matrix4': NgtMatrix4Node;\n\t'ngt-quaternion': NgtQuaternionNode;\n\t'ngt-buffer-attribute': NgtBufferAttribute;\n\t'ngt-float16-buffer-attribute': NgtFloat16BufferAttribute;\n\t'ngt-float32-buffer-attribute': NgtFloat32BufferAttribute;\n\t'ngt-float64-buffer-attribute': NgtFloat64BufferAttribute;\n\t'ngt-int8-buffer-attribute': NgtInt8BufferAttribute;\n\t'ngt-int16-buffer-attribute': NgtInt16BufferAttribute;\n\t'ngt-int32-buffer-attribute': NgtInt32BufferAttribute;\n\t'ngt-unit8-buffer-attribute': NgtUint8BufferAttribute;\n\t'ngt-unit16-buffer-attribute': NgtUint16BufferAttribute;\n\t'ngt-unit32-buffer-attribute': NgtUint32BufferAttribute;\n\t'ngt-instanced-buffer-attribute': NgtInstancedBufferAttribute;\n\t'ngt-color': NgtColor;\n\t'ngt-fog': NgtFog;\n\t'ngt-fog-exp2': NgtFogExp2;\n\t'ngt-shape': NgtShape;\n}\n\ndeclare global {\n\tinterface HTMLElementTagNameMap extends ThreeElements {}\n}\n"]}

package/esm2022/lib/types.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../libs/angular-three/src/lib/types.ts"],"names":[],"mappings":"","sourcesContent":["import type { ElementRef, EventEmitter, WritableSignal } from '@angular/core';\nimport * as THREE from 'three';\nimport type { NgtSignalStore } from './stores/signal.store';\nimport { NgtObject3DNode } from './three-types';\n\nexport type NgtAnyRecord = Record<string, any>;\nexport type NgtProperties<T> = Pick<T, { [K in keyof T]: T[K] extends (_: any) => any ? never : K }[keyof T]>;\n\nexport type NgtEquConfig = {\n    /** Compare arrays by reference equality a === b (default), or by shallow equality */\n    arrays?: 'reference' | 'shallow';\n    /** Compare objects by reference equality a === b (default), or by shallow equality */\n    objects?: 'reference' | 'shallow';\n    /** If true the keys in both a and b must match 1:1 (default), if false a's keys must intersect b's */\n    strict?: boolean;\n};\n\nexport type NgtDpr = number | [min: number, max: number];\nexport type NgtSize = {\n    width: number;\n    height: number;\n    top: number;\n    left: number;\n};\nexport type NgtViewport = NgtSize & {\n    /** The initial pixel ratio */\n    initialDpr: number;\n    /** Current pixel ratio */\n    dpr: number;\n    /** size.width / viewport.width */\n    factor: number;\n    /** Camera distance */\n    distance: number;\n    /** Camera aspect ratio: width / height */\n    aspect: number;\n};\nexport type NgtPerformance = {\n    /** Current performance normal, between min and max */\n    current: number;\n    /** How low the performance can go, between 0 and max */\n    min: number;\n    /** How high the performance can go, between min and max */\n    max: number;\n    /** Time until current returns to max in ms */\n    debounce: number;\n    /** Sets current to min, puts the system in regression */\n    regress: () => void;\n};\nexport type NgtRenderer = { render: (scene: THREE.Scene, camera: THREE.Camera) => any };\nexport type NgtCamera = THREE.OrthographicCamera | THREE.PerspectiveCamera;\nexport type NgtCameraManual = NgtCamera & { manual?: boolean };\nexport type NgtIntersection = THREE.Intersection & {\n    /** The event source (the object which registered the handler) */\n    eventObject: THREE.Object3D;\n};\n\nexport type NgtIntersectionEvent<TSourceEvent> = NgtIntersection & {\n    /** The event source (the object which registered the handler) */\n    eventObject: THREE.Object3D;\n    /** An array of intersections */\n    intersections: NgtIntersection[];\n    /** vec3.set(pointer.x, pointer.y, 0).unproject(camera) */\n    unprojectedPoint: THREE.Vector3;\n    /** Normalized event coordinates */\n    pointer: THREE.Vector2;\n    /** Delta between first click and this event */\n    delta: number;\n    /** The ray that pierced it */\n    ray: THREE.Ray;\n    /** The camera that was used by the raycaster */\n    camera: NgtCameraManual;\n    /** stopPropagation will stop underlying handlers from firing */\n    stopPropagation: () => void;\n    /** The original host event */\n    nativeEvent: TSourceEvent;\n    /** If the event was stopped by calling stopPropagation */\n    stopped: boolean;\n};\n\nexport type NgtThreeEvent<TEvent> = NgtIntersectionEvent<TEvent> & NgtProperties<TEvent>;\nexport type NgtDomEvent = PointerEvent | MouseEvent | WheelEvent;\n\nexport type NgtEventHandlers = {\n    click?: (event: NgtThreeEvent<MouseEvent>) => void;\n    contextmenu?: (event: NgtThreeEvent<MouseEvent>) => void;\n    dblclick?: (event: NgtThreeEvent<MouseEvent>) => void;\n    pointerup?: (event: NgtThreeEvent<PointerEvent>) => void;\n    pointerdown?: (event: NgtThreeEvent<PointerEvent>) => void;\n    pointerover?: (event: NgtThreeEvent<PointerEvent>) => void;\n    pointerout?: (event: NgtThreeEvent<PointerEvent>) => void;\n    pointerenter?: (event: NgtThreeEvent<PointerEvent>) => void;\n    pointerleave?: (event: NgtThreeEvent<PointerEvent>) => void;\n    pointermove?: (event: NgtThreeEvent<PointerEvent>) => void;\n    pointermissed?: (event: MouseEvent) => void;\n    pointercancel?: (event: NgtThreeEvent<PointerEvent>) => void;\n    wheel?: (event: NgtThreeEvent<WheelEvent>) => void;\n};\n\nexport type NgtEvents = {\n    [TEvent in keyof NgtEventHandlers]-?: EventListener;\n};\n\nexport type NgtFilterFunction = (items: THREE.Intersection[], store: NgtSignalStore<NgtState>) => THREE.Intersection[];\nexport type NgtComputeFunction = (\n    event: NgtDomEvent,\n    root: NgtSignalStore<NgtState>,\n    previous?: NgtSignalStore<NgtState>\n) => void;\n\nexport type NgtEventManager<TTarget> = {\n    /** Determines if the event layer is active */\n    enabled: boolean;\n    /** Event layer priority, higher prioritized layers come first and may stop(-propagate) lower layer  */\n    priority: number;\n    /** The compute function needs to set up the raycaster and an xy- pointer  */\n    compute?: NgtComputeFunction;\n    /** The filter can re-order or re-structure the intersections  */\n    filter?: NgtFilterFunction;\n    /** The target node the event layer is tied to */\n    connected?: TTarget;\n    /** All the pointer event handlers through which the host forwards native events */\n    handlers?: NgtEvents;\n    /** Allows re-connecting to another target */\n    connect?: (target: TTarget) => void;\n    /** Removes all existing events handlers from the target */\n    disconnect?: () => void;\n    /** Triggers a onPointerMove with the last known event. This can be useful to enable raycasting without\n     *  explicit user interaction, for instance when the camera moves a hoverable object underneath the cursor.\n     */\n    update?: () => void;\n};\n\nexport type NgtPointerCaptureTarget = {\n    intersection: NgtIntersection;\n    target: Element;\n};\n\nexport type NgtRenderState = NgtState & { delta: number; frame?: XRFrame };\n\nexport type NgtBeforeRenderEvent<TObject extends NgtInstanceNode = NgtInstanceNode> = {\n    state: NgtRenderState;\n    object: TObject;\n};\n\nexport type NgtBeforeRenderRecord = {\n    callback: (state: NgtRenderState) => void;\n    store: NgtSignalStore<NgtState>;\n    priority?: number;\n};\n\nexport type NgtInternalState = {\n    active: boolean;\n    priority: number;\n    frames: number;\n    lastEvent: ElementRef<NgtDomEvent | null>;\n    interaction: THREE.Object3D[];\n    hovered: Map<string, NgtThreeEvent<NgtDomEvent>>;\n    subscribers: NgtBeforeRenderRecord[];\n    capturedMap: Map<number, Map<THREE.Object3D, NgtPointerCaptureTarget>>;\n    initialClick: [x: number, y: number];\n    initialHits: THREE.Object3D[];\n    subscribe: (\n        callback: NgtBeforeRenderRecord['callback'],\n        priority?: number,\n        store?: NgtSignalStore<NgtState>\n    ) => () => void;\n};\n\nexport type NgtState = {\n    get: NgtSignalStore<NgtState>['get'];\n    set: NgtSignalStore<NgtState>['set'];\n    /** when all building blocks are initialized */\n    ready: boolean;\n    /** The instance of the renderer */\n    gl: THREE.WebGLRenderer;\n    /** Default camera */\n    camera: NgtCameraManual;\n    /** Default scene */\n    scene: THREE.Scene;\n    /** Default raycaster */\n    raycaster: THREE.Raycaster;\n    /** Default clock */\n    clock: THREE.Clock;\n    /** Event layer interface, contains the event handler and the node they're connected to */\n    events: NgtEventManager<any>;\n    /** XR interface */\n    xr: { connect: () => void; disconnect: () => void };\n    /** Currently used controls */\n    controls: THREE.EventDispatcher | null;\n    /** Normalized event coordinates */\n    pointer: THREE.Vector2;\n    /* Whether to enable r139's THREE.ColorManagement.legacyMode */\n    legacy: boolean;\n    /** Shortcut to gl.outputEncoding = LinearEncoding */\n    linear: boolean;\n    /** Shortcut to gl.toneMapping = NoTonemapping */\n    flat: boolean;\n    /** Render loop flags */\n    frameloop: 'always' | 'demand' | 'never';\n    /** Adaptive performance interface */\n    performance: NgtPerformance;\n    /** Reactive pixel-size of the canvas */\n    size: NgtSize;\n    /** Reactive size of the viewport in threejs units */\n    viewport: NgtViewport & {\n        getCurrentViewport: (\n            camera?: NgtCameraManual,\n            target?: THREE.Vector3 | Parameters<THREE.Vector3['set']>,\n            size?: NgtSize\n        ) => Omit<NgtViewport, 'dpr' | 'initialDpr'>;\n    };\n    /** Flags the canvas for render, but doesn't render in itself */\n    invalidate: (frames?: number) => void;\n    /** Advance (render) one step */\n    advance: (timestamp: number, runGlobalEffects?: boolean) => void;\n    /** Shortcut to setting the event layer */\n    setEvents: (events: Partial<NgtEventManager<any>>) => void;\n    /**\n     * Shortcut to manual sizing\n     */\n    setSize: (width: number, height: number, top?: number, left?: number) => void;\n    /** Shortcut to manual setting the pixel ratio */\n    setDpr: (dpr: NgtDpr) => void;\n    /** Shortcut to frameloop flags */\n    setFrameloop: (frameloop?: 'always' | 'demand' | 'never') => void;\n    /** When the canvas was clicked but nothing was hit */\n    onPointerMissed?: (event: MouseEvent) => void;\n    /** If this state model is layerd (via createPortal) then this contains the previous layer */\n    previousStore?: NgtSignalStore<NgtState>;\n    /** Internals */\n    internal: NgtInternalState;\n};\n\nexport type NgtAttachFunction<TChild = any, TParent = any> = (\n    parent: TParent,\n    child: TChild,\n    store: NgtSignalStore<NgtState>\n) => void | (() => void);\n\nexport type NgtAfterAttach<\n    TParent extends NgtInstanceNode = NgtInstanceNode,\n    TChild extends NgtInstanceNode = NgtInstanceNode\n> = { parent: TParent; node: TChild };\n\nexport type NgtInstanceLocalState = {\n    /** the state getter of the canvas that the instance is being rendered to */\n    store: NgtSignalStore<NgtState>;\n    // objects and parent are used when children are added with `attach` instead of being added to the Object3D scene graph\n    nonObjects: WritableSignal<NgtInstanceNode[]>;\n    // objects that are Object3D\n    objects: WritableSignal<NgtInstanceNode[]>;\n    // shortcut to add/remove object to list\n    add: (instance: NgtInstanceNode, type: 'objects' | 'nonObjects') => void;\n    remove: (instance: NgtInstanceNode, type: 'objects' | 'nonObjects') => void;\n    // native props signal\n    nativeProps: NgtSignalStore<NgtAnyRecord>;\n    // parent based on attach three instance\n    parent: WritableSignal<NgtInstanceNode | null>;\n    // if this THREE instance is a ngt-primitive\n    primitive?: boolean;\n    // if this THREE object has any events bound to it\n    eventCount: number;\n    // list of handlers to handle the events\n    handlers: Partial<NgtEventHandlers>;\n    // previous args\n    args?: unknown[];\n    // attach information so that we can detach as well as reset\n    attach?: string[] | NgtAttachFunction;\n    // previously attach information so we can reset as well as clean up\n    previousAttach?: unknown | (() => void);\n    // is raw value\n    isRaw?: boolean;\n    // priority for before render\n    priority?: number;\n    // emitter after props update\n    afterUpdate?: EventEmitter<NgtInstanceNode>;\n    // emitter after attaching to parent\n    afterAttach?: EventEmitter<NgtAfterAttach>;\n};\n\nexport type NgtInstanceNode<TNode = any> = {\n    __ngt__: NgtInstanceLocalState;\n} & NgtAnyRecord &\n    TNode;\n\nexport type NgtGLRenderer = {\n    render: (scene: THREE.Scene, camera: THREE.Camera) => void;\n};\n\nexport type NgtGLOptions =\n    | NgtGLRenderer\n    | ((canvas: HTMLCanvasElement) => NgtGLRenderer)\n    | Partial<NgtProperties<THREE.WebGLRenderer> | THREE.WebGLRendererParameters>\n    | undefined;\n\nexport type NgtObjectMap = {\n    nodes: { [name: string]: THREE.Object3D };\n    materials: { [name: string]: THREE.Material };\n    [key: string]: any;\n};\n\nexport type NgtCanvasInputs = {\n    /** A threejs renderer instance or props that go into the default renderer */\n    gl?: NgtGLOptions;\n    size?: NgtSize;\n\n    /**\n     * Enables shadows (by default PCFsoft). Can accept `gl.shadowMap` options for fine-tuning,\n     * but also strings: 'basic' | 'percentage' | 'soft' | 'variance'.\n     * @see https://threejs.org/docs/#api/en/renderers/WebGLRenderer.shadowMap\n     */\n    shadows?: boolean | 'basic' | 'percentage' | 'soft' | 'variance' | Partial<THREE.WebGLShadowMap>;\n    /**\n     * Disables three r139 color management.\n     * @see https://threejs.org/docs/#manual/en/introduction/Color-management\n     */\n    legacy?: boolean;\n    /** Switch off automatic sRGB encoding and gamma correction */\n    linear?: boolean;\n    /** Use `THREE.NoToneMapping` instead of `THREE.ACESFilmicToneMapping` */\n    flat?: boolean;\n    /** Creates an orthographic camera */\n    orthographic?: boolean;\n    /**\n     * R3F's render mode. Set to `demand` to only render on state change or `never` to take control.\n     * @see https://docs.pmnd.rs/react-three-fiber/advanced/scaling-performance#on-demand-rendering\n     */\n    frameloop?: 'always' | 'demand' | 'never';\n    /**\n     * R3F performance options for adaptive performance.\n     * @see https://docs.pmnd.rs/react-three-fiber/advanced/scaling-performance#movement-regression\n     */\n    performance?: Partial<Omit<NgtPerformance, 'regress'>>;\n    /** Target pixel ratio. Can clamp between a range: `[min, max]` */\n    dpr?: NgtDpr;\n    /** Props that go into the default raycaster */\n    raycaster?: Partial<THREE.Raycaster>;\n    /** A `THREE.Scene` instance or props that go into the default scene */\n    scene?: THREE.Scene | Partial<THREE.Scene>;\n    /** A `Camera` instance or props that go into the default camera */\n    camera?: (\n        | NgtCamera\n        | Partial<\n              NgtObject3DNode<THREE.Camera, typeof THREE.Camera> &\n                  NgtObject3DNode<THREE.PerspectiveCamera, typeof THREE.PerspectiveCamera> &\n                  NgtObject3DNode<THREE.OrthographicCamera, typeof THREE.OrthographicCamera>\n          >\n    ) & {\n        /** Flags the camera as manual, putting projection into your own hands */\n        manual?: boolean;\n    };\n    /** An R3F event manager to manage elements' pointer events */\n    events?: (store: NgtSignalStore<NgtState>) => NgtEventManager<HTMLElement>;\n    /** The target where events are being subscribed to, default: the div that wraps canvas */\n    eventSource?: HTMLElement | ElementRef<HTMLElement>;\n    /** The event prefix that is cast into canvas pointer x/y events, default: \"offset\" */\n    eventPrefix?: 'offset' | 'client' | 'page' | 'layer' | 'screen';\n    /** Default coordinate for the camera to look at */\n    lookAt?: THREE.Vector3 | Parameters<THREE.Vector3['set']>;\n};\n\nexport interface NgtLoader<T> extends THREE.Loader {\n    load(\n        url: string,\n        onLoad?: (result: T) => void,\n        onProgress?: (event: ProgressEvent) => void,\n        onError?: (event: ErrorEvent) => void\n    ): unknown;\n    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<T>;\n}\n\nexport type NgtLoaderProto<T> = new (...args: any) => NgtLoader<T extends unknown ? any : T>;\nexport type NgtLoaderReturnType<T, L extends NgtLoaderProto<T>> = T extends unknown\n    ? Awaited<ReturnType<InstanceType<L>['loadAsync']>>\n    : T;\nexport type NgtLoaderExtensions<T extends { prototype: NgtLoaderProto<any> }> = (loader: T['prototype']) => void;\nexport type NgtConditionalType<Child, Parent, Truthy, Falsy> = Child extends Parent ? Truthy : Falsy;\nexport type NgtBranchingReturn<T, Parent, Coerced> = NgtConditionalType<T, Parent, Coerced, T>;\n"]}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2NvcmUvc3JjL2xpYi90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgTmd0UHJvcGVydGllczxUPiA9IFBpY2s8VCwgeyBbSyBpbiBrZXlvZiBUXTogVFtLXSBleHRlbmRzIChfOiBhbnkpID0+IGFueSA/IG5ldmVyIDogSyB9W2tleW9mIFRdPjtcbmV4cG9ydCB0eXBlIE5ndEFueVJlY29yZCA9IFJlY29yZDxzdHJpbmcsIGFueT47XG5cbmV4cG9ydCB0eXBlIE5ndEVxdUNvbmZpZyA9IHtcblx0LyoqIENvbXBhcmUgYXJyYXlzIGJ5IHJlZmVyZW5jZSBlcXVhbGl0eSBhID09PSBiIChkZWZhdWx0KSwgb3IgYnkgc2hhbGxvdyBlcXVhbGl0eSAqL1xuXHRhcnJheXM/OiAncmVmZXJlbmNlJyB8ICdzaGFsbG93Jztcblx0LyoqIENvbXBhcmUgb2JqZWN0cyBieSByZWZlcmVuY2UgZXF1YWxpdHkgYSA9PT0gYiAoZGVmYXVsdCksIG9yIGJ5IHNoYWxsb3cgZXF1YWxpdHkgKi9cblx0b2JqZWN0cz86ICdyZWZlcmVuY2UnIHwgJ3NoYWxsb3cnO1xuXHQvKiogSWYgdHJ1ZSB0aGUga2V5cyBpbiBib3RoIGEgYW5kIGIgbXVzdCBtYXRjaCAxOjEgKGRlZmF1bHQpLCBpZiBmYWxzZSBhJ3Mga2V5cyBtdXN0IGludGVyc2VjdCBiJ3MgKi9cblx0c3RyaWN0PzogYm9vbGVhbjtcbn07XG4iXX0=

package/esm2022/lib/utils/apply-props.mjs

@@ -1,9 +1,10 @@
 import { untracked } from '@angular/core';
 import * as THREE from 'three';
-import { getLocalState, invalidateInstance } from './instance';
+import { getLocalState, invalidateInstance } from '../instance';
 import { is } from './is';
 import { checkUpdate } from './update';
-function diffProps(instance, props) {
+// This function prepares a set of changes to be applied to the instance
+export function diffProps(instance, props) {
     const propsEntries = Object.entries(props);
     const changes = [];
     for (const [propKey, propValue] of propsEntries) {
@@ -22,19 +23,21 @@ function diffProps(instance, props) {
     }
     return changes;
 }
+// This function applies a set of changes to the instance
 export function applyProps(instance, props) {
     // if props is empty
     if (!Object.keys(props).length)
         return instance;
+    // Filter equals, events and reserved props
     // filter equals, events , and reserved props
     const localState = getLocalState(instance);
     const rootState = localState.store?.get();
     const changes = diffProps(instance, props);
     for (let i = 0; i < changes.length; i++) {
-        const currentInstance = instance;
-        let key = changes[i][0];
-        let value = changes[i][1];
-        if (is.colorSpaceExist(currentInstance)) {
+        let [key, value] = changes[i];
+        // Alias (output)encoding => (output)colorSpace (since r152)
+        // https://github.com/pmndrs/react-three-fiber/pull/2829
+        if (is.colorSpaceExist(instance)) {
             const sRGBEncoding = 3001;
             const SRGBColorSpace = 'srgb';
             const LinearSRGBColorSpace = 'srgb-linear';
@@ -47,6 +50,7 @@ export function applyProps(instance, props) {
                 value = value === sRGBEncoding ? SRGBColorSpace : LinearSRGBColorSpace;
             }
         }
+        const currentInstance = instance;
         const targetProp = currentInstance[key];
         // special treatmen for objects with support for set/copy, and layers
         if (targetProp && targetProp['set'] && (targetProp['copy'] || targetProp instanceof THREE.Layers)) {
@@ -100,6 +104,7 @@ export function applyProps(instance, props) {
                 }
             }
         }
+        checkUpdate(currentInstance[key]);
         checkUpdate(targetProp);
         invalidateInstance(instance);
     }
@@ -119,4 +124,4 @@ export function applyProps(instance, props) {
     }
     return instance;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apply-props.js","sourceRoot":"","sources":["../../../../../../libs/angular-three/src/lib/utils/apply-props.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,EAAE,EAAE,EAAE,MAAM,MAAM,CAAC;AAC1B,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEvC,SAAS,SAAS,CAAC,QAAsB,EAAE,KAAmB;IAC1D,MAAM,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAC3C,MAAM,OAAO,GAAoC,EAAE,CAAC;IAEpD,KAAK,MAAM,CAAC,OAAO,EAAE,SAAS,CAAC,IAAI,YAAY,EAAE;QAC7C,IAAI,GAAG,GAAG,OAAO,CAAC;QAClB,IAAI,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE;YAC9B,IAAI,OAAO,KAAK,UAAU,EAAE;gBACxB,GAAG,GAAG,YAAY,CAAC;aACtB;iBAAM,IAAI,OAAO,KAAK,gBAAgB,EAAE;gBACrC,GAAG,GAAG,kBAAkB,CAAC;aAC5B;SACJ;QACD,IAAI,EAAE,CAAC,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;YAAE,SAAS;QAC/C,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC;KACtC;IAED,OAAO,OAAO,CAAC;AACnB,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,QAAyB,EAAE,KAAmB;IACrE,oBAAoB;IACpB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM;QAAE,OAAO,QAAQ,CAAC;IAEhD,6CAA6C;IAC7C,MAAM,UAAU,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAC;IAC3C,MAAM,SAAS,GAAG,UAAU,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC;IAC1C,MAAM,OAAO,GAAG,SAAS,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAE3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACrC,MAAM,eAAe,GAAG,QAAQ,CAAC;QACjC,IAAI,GAAG,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACxB,IAAI,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAE1B,IAAI,EAAE,CAAC,eAAe,CAAC,eAAe,CAAC,EAAE;YACrC,MAAM,YAAY,GAAG,IAAI,CAAC;YAC1B,MAAM,cAAc,GAAG,MAAM,CAAC;YAC9B,MAAM,oBAAoB,GAAG,aAAa,CAAC;YAE3C,IAAI,GAAG,KAAK,UAAU,EAAE;gBACpB,GAAG,GAAG,YAAY,CAAC;gBACnB,KAAK,GAAG,KAAK,KAAK,YAAY,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,oBAAoB,CAAC;aAC1E;iBAAM,IAAI,GAAG,KAAK,gBAAgB,EAAE;gBACjC,GAAG,GAAG,kBAAkB,CAAC;gBACzB,KAAK,GAAG,KAAK,KAAK,YAAY,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,oBAAoB,CAAC;aAC1E;SACJ;QAED,MAAM,UAAU,GAAG,eAAe,CAAC,GAAG,CAAiB,CAAC;QAExD,qEAAqE;QACrE,IAAI,UAAU,IAAI,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,UAAU,YAAY,KAAK,CAAC,MAAM,CAAC,EAAE;YAC/F,MAAM,OAAO,GAAG,UAAU,YAAY,KAAK,CAAC,KAAK,CAAC;YAClD,uBAAuB;YACvB,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;gBACtB,IAAK,UAA2B,CAAC,WAAW,CAAC;oBAAG,UAA2B,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,CAAC;;oBAC3F,UAAU,CAAC,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC;aACpC;YACD,yBAAyB;iBACpB,IACA,UAA2B,CAAC,MAAM,CAAC;gBACpC,KAAK;gBACL,KAAK,CAAC,WAAW;gBACjB,UAAU,CAAC,WAAW,CAAC,IAAI,KAAK,KAAK,CAAC,WAAW,CAAC,IAAI,EACxD;gBACG,UAA2B,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC;gBAC5C,IAAI,CAAC,KAAK,CAAC,eAAe,IAAI,CAAC,SAAS,CAAC,MAAM,IAAI,OAAO;oBAAE,UAAU,CAAC,qBAAqB,CAAC,EAAE,CAAC;aACnG;YACD,oEAAoE;iBAC/D,IAAI,KAAK,KAAK,SAAS,EAAE;gBAC1B,MAAM,OAAO,GAAG,UAAU,YAAY,KAAK,CAAC,KAAK,CAAC;gBAClD,8BAA8B;gBAC9B,IAAI,CAAC,OAAO,IAAK,UAA2B,CAAC,WAAW,CAAC;oBACpD,UAA2B,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,CAAC;gBACrD,8CAA8C;qBACzC,IAAI,UAAU,YAAY,KAAK,CAAC,MAAM,IAAI,KAAK,YAAY,KAAK,CAAC,MAAM;oBACxE,UAAU,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;gBACjC,yBAAyB;;oBACpB,UAAU,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC;gBAE9B,oBAAoB;gBACpB,IAAI,CAAC,KAAK,CAAC,eAAe,IAAI,CAAC,SAAS,EAAE,MAAM,IAAI,OAAO;oBAAE,UAAU,CAAC,mBAAmB,EAAE,CAAC;aACjG;SACJ;QACD,gCAAgC;aAC3B;YACD,eAAe,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;YAC7B,6BAA6B;YAC7B,IACI,eAAe,CAAC,GAAG,CAAC,YAAY,KAAK,CAAC,OAAO;gBAC7C,eAAe,CAAC,GAAG,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,UAAU;gBAChD,eAAe,CAAC,GAAG,CAAC,CAAC,IAAI,KAAK,KAAK,CAAC,gBAAgB,EACtD;gBACE,MAAM,OAAO,GAAG,eAAe,CAAC,GAAG,CAAkB,CAAC;gBACtD,IAAI,SAAS,EAAE,EAAE,EAAE;oBACf,IAAI,EAAE,CAAC,eAAe,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,eAAe,CAAC,SAAS,CAAC,EAAE,CAAC;wBAC/D,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,EAAE,CAAC,gBAAgB,CAAC;;wBAClD,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,EAAE,CAAC,cAAc,CAAC;iBACvD;aACJ;SACJ;QAED,WAAW,CAAC,UAAU,CAAC,CAAC;QACxB,kBAAkB,CAAC,QAAQ,CAAC,CAAC;KAChC;IAED,MAAM,gBAAgB,GAAG,UAAU,CAAC,UAAU,CAAC;IAC/C,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAEvE,IAAI,MAAM,IAAI,SAAS,CAAC,QAAQ,IAAI,QAAQ,CAAC,SAAS,CAAC,IAAI,gBAAgB,KAAK,UAAU,CAAC,UAAU,EAAE;QACnG,iEAAiE;QACjE,MAAM,KAAK,GAAG,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC/D,IAAI,KAAK,GAAG,CAAC,CAAC;YAAE,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAChE,wEAAwE;QACxE,IAAI,UAAU,CAAC,UAAU;YAAE,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;KAC5E;IAED,IAAI,MAAM,IAAI,UAAU,CAAC,WAAW,IAAI,UAAU,CAAC,WAAW,CAAC,QAAQ,IAAI,OAAO,CAAC,MAAM,EAAE;QACvF,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;KACzC;IAED,OAAO,QAAQ,CAAC;AACpB,CAAC","sourcesContent":["import { untracked } from '@angular/core';\nimport * as THREE from 'three';\nimport type { NgtAnyRecord, NgtInstanceNode } from '../types';\nimport { getLocalState, invalidateInstance } from './instance';\nimport { is } from './is';\nimport { checkUpdate } from './update';\n\nfunction diffProps(instance: NgtAnyRecord, props: NgtAnyRecord) {\n    const propsEntries = Object.entries(props);\n    const changes: [key: string, value: unknown][] = [];\n\n    for (const [propKey, propValue] of propsEntries) {\n        let key = propKey;\n        if (is.colorSpaceExist(instance)) {\n            if (propKey === 'encoding') {\n                key = 'colorSpace';\n            } else if (propKey === 'outputEncoding') {\n                key = 'outputColorSpace';\n            }\n        }\n        if (is.equ(propValue, instance[key])) continue;\n        changes.push([propKey, propValue]);\n    }\n\n    return changes;\n}\n\nexport function applyProps(instance: NgtInstanceNode, props: NgtAnyRecord): NgtInstanceNode {\n    // if props is empty\n    if (!Object.keys(props).length) return instance;\n\n    // filter equals, events , and reserved props\n    const localState = getLocalState(instance);\n    const rootState = localState.store?.get();\n    const changes = diffProps(instance, props);\n\n    for (let i = 0; i < changes.length; i++) {\n        const currentInstance = instance;\n        let key = changes[i][0];\n        let value = changes[i][1];\n\n        if (is.colorSpaceExist(currentInstance)) {\n            const sRGBEncoding = 3001;\n            const SRGBColorSpace = 'srgb';\n            const LinearSRGBColorSpace = 'srgb-linear';\n\n            if (key === 'encoding') {\n                key = 'colorSpace';\n                value = value === sRGBEncoding ? SRGBColorSpace : LinearSRGBColorSpace;\n            } else if (key === 'outputEncoding') {\n                key = 'outputColorSpace';\n                value = value === sRGBEncoding ? SRGBColorSpace : LinearSRGBColorSpace;\n            }\n        }\n\n        const targetProp = currentInstance[key] as NgtAnyRecord;\n\n        // special treatmen for objects with support for set/copy, and layers\n        if (targetProp && targetProp['set'] && (targetProp['copy'] || targetProp instanceof THREE.Layers)) {\n            const isColor = targetProp instanceof THREE.Color;\n            // if value is an array\n            if (Array.isArray(value)) {\n                if ((targetProp as NgtAnyRecord)['fromArray']) (targetProp as NgtAnyRecord)['fromArray'](value);\n                else targetProp['set'](...value);\n            }\n            // test again target.copy\n            else if (\n                (targetProp as NgtAnyRecord)['copy'] &&\n                value &&\n                value.constructor &&\n                targetProp.constructor.name === value.constructor.name\n            ) {\n                (targetProp as NgtAnyRecord)['copy'](value);\n                if (!THREE.ColorManagement && !rootState.linear && isColor) targetProp['convertSRGBToLinear']();\n            }\n            // if nothing else fits, just set the single value, ignore undefined\n            else if (value !== undefined) {\n                const isColor = targetProp instanceof THREE.Color;\n                // allow setting array scalars\n                if (!isColor && (targetProp as NgtAnyRecord)['setScalar'])\n                    (targetProp as NgtAnyRecord)['setScalar'](value);\n                // layers have no copy function, copy the mask\n                else if (targetProp instanceof THREE.Layers && value instanceof THREE.Layers)\n                    targetProp.mask = value.mask;\n                // otherwise just set ...\n                else targetProp['set'](value);\n\n                // auto-convert srgb\n                if (!THREE.ColorManagement && !rootState?.linear && isColor) targetProp.convertSRGBToLinear();\n            }\n        }\n        // else just overwrite the value\n        else {\n            currentInstance[key] = value;\n            // auto-convert srgb textures\n            if (\n                currentInstance[key] instanceof THREE.Texture &&\n                currentInstance[key].format === THREE.RGBAFormat &&\n                currentInstance[key].type === THREE.UnsignedByteType\n            ) {\n                const texture = currentInstance[key] as THREE.Texture;\n                if (rootState?.gl) {\n                    if (is.colorSpaceExist(texture) && is.colorSpaceExist(rootState.gl))\n                        texture.colorSpace = rootState.gl.outputColorSpace;\n                    else texture.encoding = rootState.gl.outputEncoding;\n                }\n            }\n        }\n\n        checkUpdate(targetProp);\n        invalidateInstance(instance);\n    }\n\n    const instanceHandlers = localState.eventCount;\n    const parent = localState.parent ? untracked(localState.parent) : null;\n\n    if (parent && rootState.internal && instance['raycast'] && instanceHandlers !== localState.eventCount) {\n        // Pre-emptively remove the instance from the interaction manager\n        const index = rootState.internal.interaction.indexOf(instance);\n        if (index > -1) rootState.internal.interaction.splice(index, 1);\n        // Add the instance to the interaction manager only when it has handlers\n        if (localState.eventCount) rootState.internal.interaction.push(instance);\n    }\n\n    if (parent && localState.afterUpdate && localState.afterUpdate.observed && changes.length) {\n        localState.afterUpdate.emit(instance);\n    }\n\n    return instance;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apply-props.js","sourceRoot":"","sources":["../../../../../../libs/core/src/lib/utils/apply-props.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAwB,MAAM,aAAa,CAAC;AAEtF,OAAO,EAAE,EAAE,EAAE,MAAM,MAAM,CAAC;AAC1B,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEvC,wEAAwE;AACxE,MAAM,UAAU,SAAS,CAAC,QAAsB,EAAE,KAAmB;IACpE,MAAM,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAC3C,MAAM,OAAO,GAAoC,EAAE,CAAC;IAEpD,KAAK,MAAM,CAAC,OAAO,EAAE,SAAS,CAAC,IAAI,YAAY,EAAE;QAChD,IAAI,GAAG,GAAG,OAAO,CAAC;QAClB,IAAI,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE;YACjC,IAAI,OAAO,KAAK,UAAU,EAAE;gBAC3B,GAAG,GAAG,YAAY,CAAC;aACnB;iBAAM,IAAI,OAAO,KAAK,gBAAgB,EAAE;gBACxC,GAAG,GAAG,kBAAkB,CAAC;aACzB;SACD;QACD,IAAI,EAAE,CAAC,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;YAAE,SAAS;QAC/C,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC;KACnC;IAED,OAAO,OAAO,CAAC;AAChB,CAAC;AAED,yDAAyD;AACzD,MAAM,UAAU,UAAU,CAAC,QAAyB,EAAE,KAAmB;IACxE,oBAAoB;IACpB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM;QAAE,OAAO,QAAQ,CAAC;IAEhD,2CAA2C;IAC3C,6CAA6C;IAC7C,MAAM,UAAU,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAC;IAC3C,MAAM,SAAS,GAAG,UAAU,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC;IAC1C,MAAM,OAAO,GAAG,SAAS,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAE3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACxC,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QAE9B,4DAA4D;QAC5D,wDAAwD;QACxD,IAAI,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE;YACjC,MAAM,YAAY,GAAG,IAAI,CAAC;YAC1B,MAAM,cAAc,GAAG,MAAM,CAAC;YAC9B,MAAM,oBAAoB,GAAG,aAAa,CAAC;YAE3C,IAAI,GAAG,KAAK,UAAU,EAAE;gBACvB,GAAG,GAAG,YAAY,CAAC;gBACnB,KAAK,GAAG,KAAK,KAAK,YAAY,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,oBAAoB,CAAC;aACvE;iBAAM,IAAI,GAAG,KAAK,gBAAgB,EAAE;gBACpC,GAAG,GAAG,kBAAkB,CAAC;gBACzB,KAAK,GAAG,KAAK,KAAK,YAAY,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,oBAAoB,CAAC;aACvE;SACD;QAED,MAAM,eAAe,GAAG,QAAQ,CAAC;QACjC,MAAM,UAAU,GAAG,eAAe,CAAC,GAAG,CAAiB,CAAC;QAExD,qEAAqE;QACrE,IAAI,UAAU,IAAI,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,UAAU,YAAY,KAAK,CAAC,MAAM,CAAC,EAAE;YAClG,MAAM,OAAO,GAAG,UAAU,YAAY,KAAK,CAAC,KAAK,CAAC;YAClD,uBAAuB;YACvB,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;gBACzB,IAAK,UAA2B,CAAC,WAAW,CAAC;oBAAG,UAA2B,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,CAAC;;oBAC3F,UAAU,CAAC,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC;aACjC;YACD,yBAAyB;iBACpB,IACH,UAA2B,CAAC,MAAM,CAAC;gBACpC,KAAK;gBACL,KAAK,CAAC,WAAW;gBACjB,UAAU,CAAC,WAAW,CAAC,IAAI,KAAK,KAAK,CAAC,WAAW,CAAC,IAAI,EACrD;gBACA,UAA2B,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC;gBAC5C,IAAI,CAAC,KAAK,CAAC,eAAe,IAAI,CAAC,SAAS,CAAC,MAAM,IAAI,OAAO;oBAAE,UAAU,CAAC,qBAAqB,CAAC,EAAE,CAAC;aAChG;YACD,oEAAoE;iBAC/D,IAAI,KAAK,KAAK,SAAS,EAAE;gBAC7B,MAAM,OAAO,GAAG,UAAU,YAAY,KAAK,CAAC,KAAK,CAAC;gBAClD,8BAA8B;gBAC9B,IAAI,CAAC,OAAO,IAAK,UAA2B,CAAC,WAAW,CAAC;oBACvD,UAA2B,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,CAAC;gBAClD,8CAA8C;qBACzC,IAAI,UAAU,YAAY,KAAK,CAAC,MAAM,IAAI,KAAK,YAAY,KAAK,CAAC,MAAM;oBAC3E,UAAU,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;gBAC9B,yBAAyB;;oBACpB,UAAU,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC;gBAE9B,oBAAoB;gBACpB,IAAI,CAAC,KAAK,CAAC,eAAe,IAAI,CAAC,SAAS,EAAE,MAAM,IAAI,OAAO;oBAAE,UAAU,CAAC,mBAAmB,EAAE,CAAC;aAC9F;SACD;QACD,gCAAgC;aAC3B;YACJ,eAAe,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;YAC7B,6BAA6B;YAC7B,IACC,eAAe,CAAC,GAAG,CAAC,YAAY,KAAK,CAAC,OAAO;gBAC7C,eAAe,CAAC,GAAG,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,UAAU;gBAChD,eAAe,CAAC,GAAG,CAAC,CAAC,IAAI,KAAK,KAAK,CAAC,gBAAgB,EACnD;gBACD,MAAM,OAAO,GAAG,eAAe,CAAC,GAAG,CAAkB,CAAC;gBAEtD,IAAI,SAAS,EAAE,EAAE,EAAE;oBAClB,IAAI,EAAE,CAAC,eAAe,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,eAAe,CAAC,SAAS,CAAC,EAAE,CAAC;wBAClE,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,EAAE,CAAC,gBAAgB,CAAC;;wBAC/C,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,EAAE,CAAC,cAAc,CAAC;iBACpD;aACD;SACD;QAED,WAAW,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC;QAClC,WAAW,CAAC,UAAU,CAAC,CAAC;QACxB,kBAAkB,CAAC,QAAQ,CAAC,CAAC;KAC7B;IAED,MAAM,gBAAgB,GAAG,UAAU,CAAC,UAAU,CAAC;IAC/C,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAEvE,IAAI,MAAM,IAAI,SAAS,CAAC,QAAQ,IAAI,QAAQ,CAAC,SAAS,CAAC,IAAI,gBAAgB,KAAK,UAAU,CAAC,UAAU,EAAE;QACtG,iEAAiE;QACjE,MAAM,KAAK,GAAG,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC/D,IAAI,KAAK,GAAG,CAAC,CAAC;YAAE,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAChE,wEAAwE;QACxE,IAAI,UAAU,CAAC,UAAU;YAAE,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;KACzE;IAED,IAAI,MAAM,IAAI,UAAU,CAAC,WAAW,IAAI,UAAU,CAAC,WAAW,CAAC,QAAQ,IAAI,OAAO,CAAC,MAAM,EAAE;QAC1F,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;KACtC;IAED,OAAO,QAAQ,CAAC;AACjB,CAAC","sourcesContent":["import { untracked } from '@angular/core';\nimport * as THREE from 'three';\nimport { getLocalState, invalidateInstance, type NgtInstanceNode } from '../instance';\nimport type { NgtAnyRecord } from '../types';\nimport { is } from './is';\nimport { checkUpdate } from './update';\n\n// This function prepares a set of changes to be applied to the instance\nexport function diffProps(instance: NgtAnyRecord, props: NgtAnyRecord) {\n\tconst propsEntries = Object.entries(props);\n\tconst changes: [key: string, value: unknown][] = [];\n\n\tfor (const [propKey, propValue] of propsEntries) {\n\t\tlet key = propKey;\n\t\tif (is.colorSpaceExist(instance)) {\n\t\t\tif (propKey === 'encoding') {\n\t\t\t\tkey = 'colorSpace';\n\t\t\t} else if (propKey === 'outputEncoding') {\n\t\t\t\tkey = 'outputColorSpace';\n\t\t\t}\n\t\t}\n\t\tif (is.equ(propValue, instance[key])) continue;\n\t\tchanges.push([propKey, propValue]);\n\t}\n\n\treturn changes;\n}\n\n// This function applies a set of changes to the instance\nexport function applyProps(instance: NgtInstanceNode, props: NgtAnyRecord) {\n\t// if props is empty\n\tif (!Object.keys(props).length) return instance;\n\n\t// Filter equals, events and reserved props\n\t// filter equals, events , and reserved props\n\tconst localState = getLocalState(instance);\n\tconst rootState = localState.store?.get();\n\tconst changes = diffProps(instance, props);\n\n\tfor (let i = 0; i < changes.length; i++) {\n\t\tlet [key, value] = changes[i];\n\n\t\t// Alias (output)encoding => (output)colorSpace (since r152)\n\t\t// https://github.com/pmndrs/react-three-fiber/pull/2829\n\t\tif (is.colorSpaceExist(instance)) {\n\t\t\tconst sRGBEncoding = 3001;\n\t\t\tconst SRGBColorSpace = 'srgb';\n\t\t\tconst LinearSRGBColorSpace = 'srgb-linear';\n\n\t\t\tif (key === 'encoding') {\n\t\t\t\tkey = 'colorSpace';\n\t\t\t\tvalue = value === sRGBEncoding ? SRGBColorSpace : LinearSRGBColorSpace;\n\t\t\t} else if (key === 'outputEncoding') {\n\t\t\t\tkey = 'outputColorSpace';\n\t\t\t\tvalue = value === sRGBEncoding ? SRGBColorSpace : LinearSRGBColorSpace;\n\t\t\t}\n\t\t}\n\n\t\tconst currentInstance = instance;\n\t\tconst targetProp = currentInstance[key] as NgtAnyRecord;\n\n\t\t// special treatmen for objects with support for set/copy, and layers\n\t\tif (targetProp && targetProp['set'] && (targetProp['copy'] || targetProp instanceof THREE.Layers)) {\n\t\t\tconst isColor = targetProp instanceof THREE.Color;\n\t\t\t// if value is an array\n\t\t\tif (Array.isArray(value)) {\n\t\t\t\tif ((targetProp as NgtAnyRecord)['fromArray']) (targetProp as NgtAnyRecord)['fromArray'](value);\n\t\t\t\telse targetProp['set'](...value);\n\t\t\t}\n\t\t\t// test again target.copy\n\t\t\telse if (\n\t\t\t\t(targetProp as NgtAnyRecord)['copy'] &&\n\t\t\t\tvalue &&\n\t\t\t\tvalue.constructor &&\n\t\t\t\ttargetProp.constructor.name === value.constructor.name\n\t\t\t) {\n\t\t\t\t(targetProp as NgtAnyRecord)['copy'](value);\n\t\t\t\tif (!THREE.ColorManagement && !rootState.linear && isColor) targetProp['convertSRGBToLinear']();\n\t\t\t}\n\t\t\t// if nothing else fits, just set the single value, ignore undefined\n\t\t\telse if (value !== undefined) {\n\t\t\t\tconst isColor = targetProp instanceof THREE.Color;\n\t\t\t\t// allow setting array scalars\n\t\t\t\tif (!isColor && (targetProp as NgtAnyRecord)['setScalar'])\n\t\t\t\t\t(targetProp as NgtAnyRecord)['setScalar'](value);\n\t\t\t\t// layers have no copy function, copy the mask\n\t\t\t\telse if (targetProp instanceof THREE.Layers && value instanceof THREE.Layers)\n\t\t\t\t\ttargetProp.mask = value.mask;\n\t\t\t\t// otherwise just set ...\n\t\t\t\telse targetProp['set'](value);\n\n\t\t\t\t// auto-convert srgb\n\t\t\t\tif (!THREE.ColorManagement && !rootState?.linear && isColor) targetProp.convertSRGBToLinear();\n\t\t\t}\n\t\t}\n\t\t// else just overwrite the value\n\t\telse {\n\t\t\tcurrentInstance[key] = value;\n\t\t\t// auto-convert srgb textures\n\t\t\tif (\n\t\t\t\tcurrentInstance[key] instanceof THREE.Texture &&\n\t\t\t\tcurrentInstance[key].format === THREE.RGBAFormat &&\n\t\t\t\tcurrentInstance[key].type === THREE.UnsignedByteType\n\t\t\t) {\n\t\t\t\tconst texture = currentInstance[key] as THREE.Texture;\n\n\t\t\t\tif (rootState?.gl) {\n\t\t\t\t\tif (is.colorSpaceExist(texture) && is.colorSpaceExist(rootState.gl))\n\t\t\t\t\t\ttexture.colorSpace = rootState.gl.outputColorSpace;\n\t\t\t\t\telse texture.encoding = rootState.gl.outputEncoding;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tcheckUpdate(currentInstance[key]);\n\t\tcheckUpdate(targetProp);\n\t\tinvalidateInstance(instance);\n\t}\n\n\tconst instanceHandlers = localState.eventCount;\n\tconst parent = localState.parent ? untracked(localState.parent) : null;\n\n\tif (parent && rootState.internal && instance['raycast'] && instanceHandlers !== localState.eventCount) {\n\t\t// Pre-emptively remove the instance from the interaction manager\n\t\tconst index = rootState.internal.interaction.indexOf(instance);\n\t\tif (index > -1) rootState.internal.interaction.splice(index, 1);\n\t\t// Add the instance to the interaction manager only when it has handlers\n\t\tif (localState.eventCount) rootState.internal.interaction.push(instance);\n\t}\n\n\tif (parent && localState.afterUpdate && localState.afterUpdate.observed && changes.length) {\n\t\tlocalState.afterUpdate.emit(instance);\n\t}\n\n\treturn instance;\n}\n"]}

package/esm2022/lib/utils/assert-injection-context.mjs

@@ -0,0 +1,14 @@
+import { Injector, assertInInjectionContext, inject } from '@angular/core';
+export function assertInjectionContext(fn, injector) {
+    try {
+        if (!injector) {
+            return inject(Injector);
+        }
+        return injector;
+    }
+    catch {
+        !injector && assertInInjectionContext(fn);
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNzZXJ0LWluamVjdGlvbi1jb250ZXh0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb3JlL3NyYy9saWIvdXRpbHMvYXNzZXJ0LWluamVjdGlvbi1jb250ZXh0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTNFLE1BQU0sVUFBVSxzQkFBc0IsQ0FBQyxFQUFZLEVBQUUsUUFBbUI7SUFDdkUsSUFBSTtRQUNILElBQUksQ0FBQyxRQUFRLEVBQUU7WUFDZCxPQUFPLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQztTQUN4QjtRQUNELE9BQU8sUUFBUSxDQUFDO0tBQ2hCO0lBQUMsTUFBTTtRQUNQLENBQUMsUUFBUSxJQUFJLHdCQUF3QixDQUFDLEVBQUUsQ0FBQyxDQUFDO1FBQzFDLE9BQU8sSUFBSyxDQUFDO0tBQ2I7QUFDRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0b3IsIGFzc2VydEluSW5qZWN0aW9uQ29udGV4dCwgaW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBmdW5jdGlvbiBhc3NlcnRJbmplY3Rpb25Db250ZXh0KGZuOiBGdW5jdGlvbiwgaW5qZWN0b3I/OiBJbmplY3Rvcik6IEluamVjdG9yIHtcblx0dHJ5IHtcblx0XHRpZiAoIWluamVjdG9yKSB7XG5cdFx0XHRyZXR1cm4gaW5qZWN0KEluamVjdG9yKTtcblx0XHR9XG5cdFx0cmV0dXJuIGluamVjdG9yO1xuXHR9IGNhdGNoIHtcblx0XHQhaW5qZWN0b3IgJiYgYXNzZXJ0SW5JbmplY3Rpb25Db250ZXh0KGZuKTtcblx0XHRyZXR1cm4gbnVsbCE7XG5cdH1cbn1cbiJdfQ==