angular-three 0.0.0-replace

package/esm2022/lib/store.mjs

@@ -0,0 +1,181 @@
+import { DOCUMENT } from '@angular/common';
+import { ElementRef, InjectionToken, Optional, SkipSelf, effect, inject } from '@angular/core';
+import { createInjectionToken } from 'ngxtension/create-injection-token';
+import { Subject } from 'rxjs';
+import * as THREE from 'three';
+import { injectNgtLoop } from './loop';
+import { is } from './utils/is';
+import { makeDpr } from './utils/make';
+import { signalStore } from './utils/signal-store';
+import { updateCamera } from './utils/update';
+function storeFactory(previousStore) {
+    const document = inject(DOCUMENT);
+    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 loop = injectNgtLoop();
+    // NOTE: using Subject because we do not care about late-subscribers
+    const pointerMissed$ = new Subject();
+    const store = signalStore(({ get, update }) => {
+        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 };
+            }
+            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) => update((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) => update((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 };
+                update((state) => ({
+                    size,
+                    viewport: { ...state.viewport, ...getCurrentViewport(camera, defaultTarget, size) },
+                }));
+            },
+            setDpr: (dpr) => update((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;
+                }
+                update(() => ({ frameloop }));
+            },
+            previousRoot: previousStore,
+            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: _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);
+                        }
+                    };
+                },
+            },
+        };
+    });
+    Object.defineProperty(store, 'pointerMissed$', { get: () => pointerMissed$ });
+    let { size: oldSize, viewport: { dpr: oldDpr }, camera: oldCamera, } = store.snapshot;
+    const [camera, size, viewportDpr] = [store.select('camera'), store.select('size'), store.select('viewport', 'dpr')];
+    effect(() => {
+        const [newCamera, newSize, newDpr, gl] = [camera(), size(), viewportDpr(), store.snapshot.gl];
+        // Resize camera and renderer on changes to size and pixel-ratio
+        if (newSize !== oldSize || newDpr !== oldDpr) {
+            oldSize = newSize;
+            oldDpr = newDpr;
+            // Update camera & renderer
+            updateCamera(newCamera, newSize);
+            gl.setPixelRatio(newDpr);
+            const updateStyle = typeof HTMLCanvasElement !== 'undefined' && gl.domElement instanceof HTMLCanvasElement;
+            gl.setSize(newSize.width, newSize.height, updateStyle);
+        }
+        // Update viewport once the camera changes
+        if (newCamera !== oldCamera) {
+            oldCamera = newCamera;
+            updateCamera(newCamera, newSize);
+            // Update viewport
+            store.update((state) => ({ viewport: { ...state.viewport, ...state.viewport.getCurrentViewport(newCamera) } }));
+        }
+    });
+    return store;
+}
+export const NGT_STORE = new InjectionToken('NgtStore Token');
+export const [injectNgtStore, provideNgtStore] = createInjectionToken(storeFactory, {
+    isRoot: false,
+    deps: [[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 { ElementRef, InjectionToken, Optional, SkipSelf, effect, inject } from '@angular/core';\nimport { createInjectionToken } from 'ngxtension/create-injection-token';\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 { injectNgtLoop } from './loop';\nimport { is } from './utils/is';\nimport { makeDpr } from './utils/make';\nimport { signalStore, type NgtSignalStore } from './utils/signal-store';\nimport { updateCamera } from './utils/update';\n\nexport type NgtRendererLike = { render: (scene: THREE.Scene, camera: THREE.Camera) => any };\nexport type NgtCameraManual = NgtCamera & { manual?: boolean };\nexport type NgtDpr = number | [min: number, max: number];\nexport type NgtSize = { width: number; height: number; top: number; left: number };\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/** 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 layered (via createPortal) then this contains the previous layer */\n\tpreviousRoot: NgtSignalStore<NgtState> | null;\n\t/** Internals */\n\tinternal: NgtInternalState;\n};\n\nfunction storeFactory(previousStore: NgtSignalStore<NgtState> | null) {\n\tconst document = inject(DOCUMENT);\n\tconst window = document.defaultView;\n\n\tif (!window) {\n\t\t// TODO: revisit this when we need to support multiple platforms\n\t\tthrow new Error(`[NGT] Window is not available.`);\n\t}\n\n\tconst loop = injectNgtLoop();\n\n\t// NOTE: using Subject because we do not care about late-subscribers\n\tconst pointerMissed$ = new Subject<MouseEvent>();\n\n\tconst store: NgtSignalStore<NgtState> = signalStore<NgtState>(({ get, update }) => {\n\t\tconst { invalidate, advance } = loop;\n\n\t\tconst position = new THREE.Vector3();\n\t\tconst defaultTarget = new THREE.Vector3();\n\t\tconst tempTarget = new THREE.Vector3();\n\n\t\tfunction getCurrentViewport(\n\t\t\tcamera: NgtCamera = get('camera'),\n\t\t\ttarget: THREE.Vector3 | Parameters<THREE.Vector3['set']> = defaultTarget,\n\t\t\tsize: NgtSize = get('size'),\n\t\t): Omit<NgtViewport, 'dpr' | 'initialDpr'> {\n\t\t\tconst { width, height, top, left } = size;\n\t\t\tconst aspect = width / height;\n\n\t\t\tif (target instanceof THREE.Vector3) tempTarget.copy(target);\n\t\t\telse tempTarget.set(...target);\n\n\t\t\tconst distance = camera.getWorldPosition(position).distanceTo(tempTarget);\n\n\t\t\tif (is.orthographicCamera(camera)) {\n\t\t\t\treturn { width: width / camera.zoom, height: height / camera.zoom, top, left, factor: 1, distance, aspect };\n\t\t\t}\n\n\t\t\tconst fov = (camera.fov * Math.PI) / 180; // convert vertical fov to radians\n\t\t\tconst h = 2 * Math.tan(fov / 2) * distance; // visible height\n\t\t\tconst w = h * (width / height);\n\t\t\treturn { width: w, height: h, top, left, factor: width / w, distance, aspect };\n\t\t}\n\n\t\tlet performanceTimeout: ReturnType<typeof setTimeout> | undefined = undefined;\n\t\tconst setPerformanceCurrent = (current: number) =>\n\t\t\tupdate((state) => ({ performance: { ...state.performance, current } }));\n\n\t\tconst pointer = new THREE.Vector2();\n\n\t\treturn {\n\t\t\tpointerMissed$: pointerMissed$.asObservable(),\n\t\t\tevents: { priority: 1, enabled: true, connected: false },\n\n\t\t\tinvalidate: (frames = 1) => invalidate(store, frames),\n\t\t\tadvance: (timestamp: number, runGlobalEffects?: boolean) => advance(timestamp, runGlobalEffects, store),\n\n\t\t\tlegacy: false,\n\t\t\tlinear: false,\n\t\t\tflat: false,\n\n\t\t\tcontrols: null,\n\t\t\tclock: new THREE.Clock(),\n\t\t\tpointer,\n\n\t\t\tframeloop: 'always',\n\n\t\t\tperformance: {\n\t\t\t\tcurrent: 1,\n\t\t\t\tmin: 0.5,\n\t\t\t\tmax: 1,\n\t\t\t\tdebounce: 200,\n\t\t\t\tregress: () => {\n\t\t\t\t\tconst state = get();\n\t\t\t\t\t// Clear timeout\n\t\t\t\t\tif (performanceTimeout) clearTimeout(performanceTimeout);\n\t\t\t\t\t// Set lower bound performance\n\t\t\t\t\tif (state.performance.current !== state.performance.min) setPerformanceCurrent(state.performance.min);\n\t\t\t\t\t// Go back to upper bound performance after a while unless something regresses meanwhile\n\t\t\t\t\tperformanceTimeout = setTimeout(() => {\n\t\t\t\t\t\tsetPerformanceCurrent(get('performance', 'max'));\n\t\t\t\t\t\t// safeDetectChanges(cdr);\n\t\t\t\t\t}, state.performance.debounce);\n\t\t\t\t},\n\t\t\t},\n\n\t\t\tsize: { width: 0, height: 0, top: 0, left: 0, updateStyle: false },\n\t\t\tviewport: {\n\t\t\t\tinitialDpr: 0,\n\t\t\t\tdpr: 0,\n\t\t\t\twidth: 0,\n\t\t\t\theight: 0,\n\t\t\t\ttop: 0,\n\t\t\t\tleft: 0,\n\t\t\t\taspect: 0,\n\t\t\t\tdistance: 0,\n\t\t\t\tfactor: 0,\n\t\t\t\tgetCurrentViewport,\n\t\t\t},\n\n\t\t\tsetEvents: (events: Partial<NgtEventManager<any>>) =>\n\t\t\t\tupdate((state) => ({ ...state, events: { ...state.events, ...events } })),\n\t\t\tsetSize: (width: number, height: number, top?: number, left?: number) => {\n\t\t\t\tconst camera = get('camera');\n\t\t\t\tconst size = { width, height, top: top || 0, left: left || 0 };\n\t\t\t\tupdate((state) => ({\n\t\t\t\t\tsize,\n\t\t\t\t\tviewport: { ...state.viewport, ...getCurrentViewport(camera, defaultTarget, size) },\n\t\t\t\t}));\n\t\t\t},\n\t\t\tsetDpr: (dpr: NgtDpr) =>\n\t\t\t\tupdate((state) => {\n\t\t\t\t\tconst resolved = makeDpr(dpr, window);\n\t\t\t\t\treturn { viewport: { ...state.viewport, dpr: resolved, initialDpr: state.viewport.initialDpr || resolved } };\n\t\t\t\t}),\n\t\t\tsetFrameloop: (frameloop: 'always' | 'demand' | 'never' = 'always') => {\n\t\t\t\tconst clock = get('clock');\n\n\t\t\t\t// if frameloop === \"never\" clock.elapsedTime is updated using advance(timestamp)\n\t\t\t\tclock.stop();\n\t\t\t\tclock.elapsedTime = 0;\n\n\t\t\t\tif (frameloop !== 'never') {\n\t\t\t\t\tclock.start();\n\t\t\t\t\tclock.elapsedTime = 0;\n\t\t\t\t}\n\n\t\t\t\tupdate(() => ({ frameloop }));\n\t\t\t},\n\n\t\t\tpreviousRoot: previousStore,\n\t\t\tinternal: {\n\t\t\t\tactive: false,\n\t\t\t\tpriority: 0,\n\t\t\t\tframes: 0,\n\t\t\t\tlastEvent: new ElementRef(null),\n\t\t\t\tinteraction: [],\n\t\t\t\thovered: new Map(),\n\t\t\t\tsubscribers: [],\n\t\t\t\tinitialClick: [0, 0],\n\t\t\t\tinitialHits: [],\n\t\t\t\tcapturedMap: new Map(),\n\t\t\t\tsubscribe: (\n\t\t\t\t\tcallback: NgtBeforeRenderRecord['callback'],\n\t\t\t\t\tpriority = 0,\n\t\t\t\t\t_store: NgtSignalStore<NgtState> = store,\n\t\t\t\t) => {\n\t\t\t\t\tconst internal = get('internal');\n\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// For that reason we switch off automatic rendering and increase the manual flag\n\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// because there could be multiple render subscriptions\n\t\t\t\t\tinternal.priority = internal.priority + (priority > 0 ? 1 : 0);\n\t\t\t\t\tinternal.subscribers.push({ callback, priority, store: _store });\n\t\t\t\t\t// Register subscriber and sort layers from lowest to highest, meaning,\n\t\t\t\t\t// highest priority renders last (on top of the other frames)\n\t\t\t\t\tinternal.subscribers = internal.subscribers.sort((a, b) => (a.priority || 0) - (b.priority || 0));\n\n\t\t\t\t\treturn () => {\n\t\t\t\t\t\tconst internal = get('internal');\n\t\t\t\t\t\tif (internal?.subscribers) {\n\t\t\t\t\t\t\t// Decrease manual flag if this subscription had a priority\n\t\t\t\t\t\t\tinternal.priority = internal.priority - (priority > 0 ? 1 : 0);\n\t\t\t\t\t\t\t// Remove subscriber from list\n\t\t\t\t\t\t\tinternal.subscribers = internal.subscribers.filter((s) => s.callback !== callback);\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\t});\n\n\tObject.defineProperty(store, 'pointerMissed$', { get: () => pointerMissed$ });\n\n\tlet {\n\t\tsize: oldSize,\n\t\tviewport: { dpr: oldDpr },\n\t\tcamera: oldCamera,\n\t} = store.snapshot;\n\n\tconst [camera, size, viewportDpr] = [store.select('camera'), store.select('size'), store.select('viewport', 'dpr')];\n\n\teffect(() => {\n\t\tconst [newCamera, newSize, newDpr, gl] = [camera(), size(), viewportDpr(), store.snapshot.gl];\n\n\t\t// Resize camera and renderer on changes to size and pixel-ratio\n\t\tif (newSize !== oldSize || newDpr !== oldDpr) {\n\t\t\toldSize = newSize;\n\t\t\toldDpr = newDpr;\n\t\t\t// Update camera & renderer\n\t\t\tupdateCamera(newCamera, newSize);\n\t\t\tgl.setPixelRatio(newDpr);\n\n\t\t\tconst updateStyle = typeof HTMLCanvasElement !== 'undefined' && gl.domElement instanceof HTMLCanvasElement;\n\t\t\tgl.setSize(newSize.width, newSize.height, updateStyle);\n\t\t}\n\n\t\t// Update viewport once the camera changes\n\t\tif (newCamera !== oldCamera) {\n\t\t\toldCamera = newCamera;\n\t\t\tupdateCamera(newCamera, newSize);\n\t\t\t// Update viewport\n\t\t\tstore.update((state) => ({ viewport: { ...state.viewport, ...state.viewport.getCurrentViewport(newCamera) } }));\n\t\t}\n\t});\n\n\treturn store;\n}\n\nexport const NGT_STORE = new InjectionToken<NgtSignalStore<NgtState>>('NgtStore Token');\nexport const [injectNgtStore, provideNgtStore] = createInjectionToken(storeFactory, {\n\tisRoot: false,\n\tdeps: [[new Optional(), new SkipSelf(), NGT_STORE]],\n\ttoken: NGT_STORE,\n});\n"]}

package/esm2022/lib/three-types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"three-types.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/three-types.ts"],"names":[],"mappings":"","sourcesContent":["import type * 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 NgtArguments<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.Vector2 | THREE.Vector3 | THREE.Vector4> =\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__: NgtArguments<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 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>;\n// @ts-expect-error - old versions still have this\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-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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2NvcmUvc3JjL2xpYi90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgTmd0UHJvcGVydGllczxUPiA9IFBpY2s8VCwgeyBbSyBpbiBrZXlvZiBUXTogVFtLXSBleHRlbmRzIChfOiBhbnkpID0+IGFueSA/IG5ldmVyIDogSyB9W2tleW9mIFRdPjtcbmV4cG9ydCB0eXBlIE5ndEFueVJlY29yZCA9IFJlY29yZDxzdHJpbmcsIGFueT47XG5cbmV4cG9ydCB0eXBlIE5ndEVxdUNvbmZpZyA9IHtcblx0LyoqIENvbXBhcmUgYXJyYXlzIGJ5IHJlZmVyZW5jZSBlcXVhbGl0eSBhID09PSBiIChkZWZhdWx0KSwgb3IgYnkgc2hhbGxvdyBlcXVhbGl0eSAqL1xuXHRhcnJheXM/OiAncmVmZXJlbmNlJyB8ICdzaGFsbG93Jztcblx0LyoqIENvbXBhcmUgb2JqZWN0cyBieSByZWZlcmVuY2UgZXF1YWxpdHkgYSA9PT0gYiAoZGVmYXVsdCksIG9yIGJ5IHNoYWxsb3cgZXF1YWxpdHkgKi9cblx0b2JqZWN0cz86ICdyZWZlcmVuY2UnIHwgJ3NoYWxsb3cnO1xuXHQvKiogSWYgdHJ1ZSB0aGUga2V5cyBpbiBib3RoIGEgYW5kIGIgbXVzdCBtYXRjaCAxOjEgKGRlZmF1bHQpLCBpZiBmYWxzZSBhJ3Mga2V5cyBtdXN0IGludGVyc2VjdCBiJ3MgKi9cblx0c3RyaWN0PzogYm9vbGVhbjtcbn07XG4iXX0=

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

@@ -0,0 +1,123 @@
+import * as THREE from 'three';
+import { getLocalState, invalidateInstance } from '../instance';
+import { is } from './is';
+import { checkUpdate } from './update';
+// This function prepares a set of changes to be applied to the instance
+function diffProps(instance, props) {
+    const propsEntries = Object.entries(props);
+    const changes = [];
+    for (const [propKey, propValue] of propsEntries) {
+        let key = propKey;
+        if (is.colorSpaceExist(instance)) {
+            if (propKey === 'encoding') {
+                key = 'colorSpace';
+            }
+            else if (propKey === 'outputEncoding') {
+                key = 'outputColorSpace';
+            }
+        }
+        if (is.equ(propValue, instance[key]))
+            continue;
+        changes.push([propKey, propValue]);
+    }
+    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, and reserved props
+    const localState = getLocalState(instance);
+    const rootState = localState?.store?.snapshot ?? {};
+    const changes = diffProps(instance, props);
+    for (let i = 0; i < changes.length; i++) {
+        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';
+            if (key === 'encoding') {
+                key = 'colorSpace';
+                value = value === sRGBEncoding ? SRGBColorSpace : LinearSRGBColorSpace;
+            }
+            else if (key === 'outputEncoding') {
+                key = 'outputColorSpace';
+                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)) {
+            const isColor = targetProp instanceof THREE.Color;
+            // if value is an array
+            if (Array.isArray(value)) {
+                if (targetProp['fromArray'])
+                    targetProp['fromArray'](value);
+                else
+                    targetProp['set'](...value);
+            } // test again target.copy
+            else if (targetProp['copy'] &&
+                value &&
+                value.constructor &&
+                targetProp.constructor.name === value.constructor.name) {
+                targetProp['copy'](value);
+                if (!THREE.ColorManagement && !rootState.linear && isColor)
+                    targetProp['convertSRGBToLinear']();
+            } // if nothing else fits, just set the single value, ignore undefined
+            else if (value !== undefined) {
+                const isColor = targetProp instanceof THREE.Color;
+                // allow setting array scalars
+                if (!isColor && targetProp['setScalar'])
+                    targetProp['setScalar'](value);
+                // layers have no copy function, copy the mask
+                else if (targetProp instanceof THREE.Layers && value instanceof THREE.Layers)
+                    targetProp.mask = value.mask;
+                // otherwise just set ...
+                else
+                    targetProp['set'](value);
+                // auto-convert srgb
+                if (!THREE.ColorManagement && !rootState?.linear && isColor)
+                    targetProp.convertSRGBToLinear();
+            }
+        } // else just overwrite the value
+        else {
+            currentInstance[key] = value;
+            // auto-convert srgb textures
+            if (currentInstance[key] instanceof THREE.Texture &&
+                currentInstance[key].format === THREE.RGBAFormat &&
+                currentInstance[key].type === THREE.UnsignedByteType) {
+                const texture = currentInstance[key];
+                if (rootState?.gl) {
+                    if (is.colorSpaceExist(texture) && is.colorSpaceExist(rootState.gl))
+                        texture.colorSpace = rootState.gl.outputColorSpace;
+                    // @ts-expect-error - these are removed in new version of three but still available in older versions
+                    else
+                        texture['encoding'] = rootState.gl['outputEncoding'];
+                }
+            }
+        }
+        checkUpdate(currentInstance[key]);
+        checkUpdate(targetProp);
+        invalidateInstance(instance);
+    }
+    const instanceHandlersCount = localState?.eventCount;
+    const parent = localState?.instanceStore?.get('parent');
+    if (parent && rootState.internal && instance['raycast'] && instanceHandlersCount !== localState?.eventCount) {
+        // Pre-emptively remove the instance from the interaction manager
+        const index = rootState.internal.interaction.indexOf(instance);
+        if (index > -1)
+            rootState.internal.interaction.splice(index, 1);
+        // Add the instance to the interaction manager only when it has handlers
+        if (localState?.eventCount)
+            rootState.internal.interaction.push(instance);
+    }
+    if (parent && localState?.afterUpdate && localState.afterUpdate.observed && changes.length) {
+        localState.afterUpdate.next(instance);
+    }
+    return instance;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apply-props.js","sourceRoot":"","sources":["../../../../../../libs/core/src/lib/utils/apply-props.ts"],"names":[],"mappings":"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","sourcesContent":["import * as THREE from 'three';\nimport { getLocalState, invalidateInstance, type NgtInstanceNode } from '../instance';\nimport type { NgtState } from '../store';\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\nfunction 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, and reserved props\n\tconst localState = getLocalState(instance);\n\tconst rootState = localState?.store?.snapshot ?? ({} as NgtState);\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];\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['fromArray']) targetProp['fromArray'](value);\n\t\t\t\telse targetProp['set'](...value);\n\t\t\t} // test again target.copy\n\t\t\telse if (\n\t\t\t\ttargetProp['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\ttargetProp['copy'](value);\n\t\t\t\tif (!THREE.ColorManagement && !rootState.linear && isColor) targetProp['convertSRGBToLinear']();\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['setScalar']) targetProp['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) targetProp.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} // 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\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\t// @ts-expect-error - these are removed in new version of three but still available in older versions\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 instanceHandlersCount = localState?.eventCount;\n\tconst parent = localState?.instanceStore?.get('parent');\n\n\tif (parent && rootState.internal && instance['raycast'] && instanceHandlersCount !== 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.next(instance);\n\t}\n\n\treturn instance;\n}\n"]}

package/esm2022/lib/utils/attach.mjs

@@ -0,0 +1,32 @@
+import { getLocalState } from '../instance';
+import { applyProps } from './apply-props';
+export function attach(object, value, paths = []) {
+    const [base, ...remaining] = paths;
+    if (!base)
+        return;
+    if (remaining.length === 0) {
+        applyProps(object, { [base]: value });
+    }
+    else {
+        assignEmpty(object, base);
+        attach(object[base], value, remaining);
+    }
+}
+export function detach(parent, child, attachProp) {
+    const childLocalState = getLocalState(child);
+    if (childLocalState) {
+        if (Array.isArray(attachProp))
+            attach(parent, childLocalState.previousAttach, attachProp);
+        else
+            childLocalState.previousAttach();
+    }
+}
+function assignEmpty(obj, base) {
+    if ((!Object.hasOwn(obj, base) && Reflect && !!Reflect.has && !Reflect.has(obj, base)) || obj[base] === undefined) {
+        obj[base] = {};
+    }
+}
+export function createAttachFunction(cb) {
+    return (parent, child, store) => cb({ parent, child, store });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/before-render.mjs

@@ -0,0 +1,12 @@
+import { DestroyRef, Injector, inject } from '@angular/core';
+import { assertInjector } from 'ngxtension/assert-injector';
+import { injectNgtStore } from '../store';
+export function injectBeforeRender(cb, { priority = 0, injector } = {}) {
+    return assertInjector(injectBeforeRender, injector, () => {
+        const store = injectNgtStore();
+        const sub = store.get('internal').subscribe(cb, priority, store);
+        inject(DestroyRef).onDestroy(() => void sub());
+        return sub;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmVmb3JlLXJlbmRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29yZS9zcmMvbGliL3V0aWxzL2JlZm9yZS1yZW5kZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzdELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUM1RCxPQUFPLEVBQUUsY0FBYyxFQUE4QixNQUFNLFVBQVUsQ0FBQztBQUV0RSxNQUFNLFVBQVUsa0JBQWtCLENBQ2pDLEVBQXFDLEVBQ3JDLEVBQUUsUUFBUSxHQUFHLENBQUMsRUFBRSxRQUFRLEtBQWlELEVBQUU7SUFFM0UsT0FBTyxjQUFjLENBQUMsa0JBQWtCLEVBQUUsUUFBUSxFQUFFLEdBQUcsRUFBRTtRQUN4RCxNQUFNLEtBQUssR0FBRyxjQUFjLEVBQUUsQ0FBQztRQUMvQixNQUFNLEdBQUcsR0FBRyxLQUFLLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxFQUFFLEVBQUUsUUFBUSxFQUFFLEtBQUssQ0FBQyxDQUFDO1FBQ2pFLE1BQU0sQ0FBQyxVQUFVLENBQUMsQ0FBQyxTQUFTLENBQUMsR0FBRyxFQUFFLENBQUMsS0FBSyxHQUFHLEVBQUUsQ0FBQyxDQUFDO1FBQy9DLE9BQU8sR0FBRyxDQUFDO0lBQ1osQ0FBQyxDQUFDLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGVzdHJveVJlZiwgSW5qZWN0b3IsIGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgYXNzZXJ0SW5qZWN0b3IgfSBmcm9tICduZ3h0ZW5zaW9uL2Fzc2VydC1pbmplY3Rvcic7XG5pbXBvcnQgeyBpbmplY3ROZ3RTdG9yZSwgdHlwZSBOZ3RCZWZvcmVSZW5kZXJSZWNvcmQgfSBmcm9tICcuLi9zdG9yZSc7XG5cbmV4cG9ydCBmdW5jdGlvbiBpbmplY3RCZWZvcmVSZW5kZXIoXG5cdGNiOiBOZ3RCZWZvcmVSZW5kZXJSZWNvcmRbJ2NhbGxiYWNrJ10sXG5cdHsgcHJpb3JpdHkgPSAwLCBpbmplY3RvciB9OiB7IHByaW9yaXR5PzogbnVtYmVyOyBpbmplY3Rvcj86IEluamVjdG9yIH0gPSB7fSxcbikge1xuXHRyZXR1cm4gYXNzZXJ0SW5qZWN0b3IoaW5qZWN0QmVmb3JlUmVuZGVyLCBpbmplY3RvciwgKCkgPT4ge1xuXHRcdGNvbnN0IHN0b3JlID0gaW5qZWN0Tmd0U3RvcmUoKTtcblx0XHRjb25zdCBzdWIgPSBzdG9yZS5nZXQoJ2ludGVybmFsJykuc3Vic2NyaWJlKGNiLCBwcmlvcml0eSwgc3RvcmUpO1xuXHRcdGluamVjdChEZXN0cm95UmVmKS5vbkRlc3Ryb3koKCkgPT4gdm9pZCBzdWIoKSk7XG5cdFx0cmV0dXJuIHN1Yjtcblx0fSk7XG59XG4iXX0=

package/esm2022/lib/utils/create-api-token.mjs

@@ -0,0 +1,13 @@
+import { forwardRef } from '@angular/core';
+import { createInjectionToken } from 'ngxtension/create-injection-token';
+function apiFactory(obj) {
+    return obj.api;
+}
+export function createApiToken(forwardedObject) {
+    const [injectFn, provideFn] = createInjectionToken((apiFactory), {
+        isRoot: false,
+        deps: [forwardRef(forwardedObject)],
+    });
+    return [injectFn, () => provideFn()];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLWFwaS10b2tlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29yZS9zcmMvbGliL3V0aWxzL2NyZWF0ZS1hcGktdG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBYSxNQUFNLGVBQWUsQ0FBQztBQUN0RCxPQUFPLEVBQUUsb0JBQW9CLEVBQW9DLE1BQU0sbUNBQW1DLENBQUM7QUFFM0csU0FBUyxVQUFVLENBQ2xCLEdBQVk7SUFFWixPQUFPLEdBQUcsQ0FBQyxHQUFHLENBQUM7QUFDaEIsQ0FBQztBQUVELE1BQU0sVUFBVSxjQUFjLENBQzdCLGVBQW9DO0lBRXBDLE1BQU0sQ0FBQyxRQUFRLEVBQUUsU0FBUyxDQUFDLEdBQUcsb0JBQW9CLENBQUMsQ0FBQSxVQUF5QixDQUFBLEVBQUU7UUFDN0UsTUFBTSxFQUFFLEtBQUs7UUFDYixJQUFJLEVBQUUsQ0FBQyxVQUFVLENBQUMsZUFBZSxDQUFDLENBQUM7S0FDcUMsQ0FBQyxDQUFDO0lBRTNFLE9BQU8sQ0FBQyxRQUFRLEVBQUUsR0FBRyxFQUFFLENBQUMsU0FBUyxFQUFFLENBQVUsQ0FBQztBQUMvQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZm9yd2FyZFJlZiwgdHlwZSBUeXBlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBjcmVhdGVJbmplY3Rpb25Ub2tlbiwgdHlwZSBDcmVhdGVJbmplY3Rpb25Ub2tlbk9wdGlvbnMgfSBmcm9tICduZ3h0ZW5zaW9uL2NyZWF0ZS1pbmplY3Rpb24tdG9rZW4nO1xuXG5mdW5jdGlvbiBhcGlGYWN0b3J5PFRPYmplY3QgZXh0ZW5kcyB7IGFwaTogYW55IH0sIFRBcGkgPSBUT2JqZWN0IGV4dGVuZHMgeyBhcGk6IGluZmVyIEFwaSB9ID8gQXBpIDogbmV2ZXI+KFxuXHRvYmo6IFRPYmplY3QsXG4pOiBUQXBpIHtcblx0cmV0dXJuIG9iai5hcGk7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBjcmVhdGVBcGlUb2tlbjxUT2JqZWN0IGV4dGVuZHMgeyBhcGk6IGFueSB9LCBUQXBpID0gVE9iamVjdCBleHRlbmRzIHsgYXBpOiBpbmZlciBBcGkgfSA/IEFwaSA6IG5ldmVyPihcblx0Zm9yd2FyZGVkT2JqZWN0OiAoKSA9PiBUeXBlPFRPYmplY3Q+LFxuKSB7XG5cdGNvbnN0IFtpbmplY3RGbiwgcHJvdmlkZUZuXSA9IGNyZWF0ZUluamVjdGlvblRva2VuKGFwaUZhY3Rvcnk8VE9iamVjdCwgVEFwaT4sIHtcblx0XHRpc1Jvb3Q6IGZhbHNlLFxuXHRcdGRlcHM6IFtmb3J3YXJkUmVmKGZvcndhcmRlZE9iamVjdCldLFxuXHR9IGFzIHVua25vd24gYXMgQ3JlYXRlSW5qZWN0aW9uVG9rZW5PcHRpb25zPHR5cGVvZiBhcGlGYWN0b3J5LCBbVE9iamVjdF0+KTtcblxuXHRyZXR1cm4gW2luamVjdEZuLCAoKSA9PiBwcm92aWRlRm4oKV0gYXMgY29uc3Q7XG59XG4iXX0=

package/esm2022/lib/utils/inputs.mjs

@@ -0,0 +1,18 @@
+import { computed, isSignal, reflectComponentType } from '@angular/core';
+export function injectInputs(dir, dirType) {
+    const mirror = reflectComponentType(dirType);
+    if (!mirror) {
+        throw new Error(`[NGT] The provided symbol is not a component nor a directive`);
+    }
+    const inputs = mirror.inputs.reduce((inputs, cur) => {
+        if (dir[cur.propName] && isSignal(dir[cur.propName])) {
+            inputs[cur.propName] = dir[cur.propName];
+        }
+        return inputs;
+    }, {});
+    return computed(() => Object.keys(inputs).reduce((acc, key) => {
+        acc[key] = inputs[key]();
+        return acc;
+    }, {}));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/is.mjs

@@ -0,0 +1,52 @@
+import { ElementRef } from '@angular/core';
+export const is = {
+    obj: (a) => a === Object(a) && !Array.isArray(a) && typeof a !== 'function',
+    material: (a) => !!a && a.isMaterial,
+    geometry: (a) => !!a && a.isBufferGeometry,
+    orthographicCamera: (a) => !!a && a.isOrthographicCamera,
+    perspectiveCamera: (a) => !!a && a.isPerspectiveCamera,
+    camera: (a) => !!a && a.isCamera,
+    renderer: (a) => !!a && typeof a === 'object' && 'render' in a && typeof a['render'] === 'function',
+    scene: (a) => !!a && a.isScene,
+    ref: (a) => a instanceof ElementRef,
+    instance: (a) => !!a && !!a['__ngt__'],
+    object3D: (a) => !!a && a.isObject3D,
+    // instance: (a: unknown): a is NgtInstanceNode => !!a && !!(a as NgtAnyRecord)['__ngt__'],
+    // ref: (a: unknown): a is ElementRef => a instanceof ElementRef,
+    colorSpaceExist: (object) => 'colorSpace' in object || 'outputColorSpace' in object,
+    equ(a, b, { arrays = 'shallow', objects = 'reference', strict = true } = {}) {
+        // Wrong type or one of the two undefined, doesn't match
+        if (typeof a !== typeof b || !!a !== !!b)
+            return false;
+        // Atomic, just compare a against b
+        if (typeof a === 'string' || typeof a === 'number')
+            return a === b;
+        const isObj = is.obj(a);
+        if (isObj && objects === 'reference')
+            return a === b;
+        const isArr = Array.isArray(a);
+        if (isArr && arrays === 'reference')
+            return a === b;
+        // Array or Object, shallow compare first to see if it's a match
+        if ((isArr || isObj) && a === b)
+            return true;
+        // Last resort, go through keys
+        let i;
+        for (i in a)
+            if (!(i in b))
+                return false;
+        for (i in strict ? b : a)
+            if (a[i] !== b[i])
+                return false;
+        if (i === void 0) {
+            if (isArr && a.length === 0 && b.length === 0)
+                return true;
+            if (isObj && Object.keys(a).length === 0 && Object.keys(b).length === 0)
+                return true;
+            if (a !== b)
+                return false;
+        }
+        return true;
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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