angular-three 0.0.2 → 0.0.4

package/esm2020/lib/instance.mjs

@@ -0,0 +1,368 @@
+import { Directive, EventEmitter, inject, InjectionToken, Input, NgZone, Output, } from '@angular/core';
+import { filter, tap } from 'rxjs';
+import { NgtRef } from './ref';
+import { NgtComponentStore, tapEffect } from './stores/component-store';
+import { NgtStore } from './stores/store';
+import { applyProps } from './utils/apply-props';
+import { removeInteractivity } from './utils/events';
+import { getInstanceLocalState } from './utils/get-instance-local-state';
+import { invalidateInstance } from './utils/instance';
+import { is } from './utils/is';
+import { mutate } from './utils/mutate';
+import * as i0 from "@angular/core";
+export const NGT_PROXY_INSTANCE = Symbol.for('__ngt__proxy__instance__');
+export const NGT_INSTANCE_REF_FACTORY = new InjectionToken('NgtInstance[instanceRef] factory');
+export function provideInstanceRef(ctor, factory) {
+    return {
+        provide: NGT_INSTANCE_REF_FACTORY,
+        useFactory: (instance) => {
+            if (factory) {
+                return () => factory(instance);
+            }
+            return () => instance['instanceRef'] || instance['instance']['instanceRef'];
+        },
+        deps: [ctor],
+    };
+}
+export function injectInstanceRef(options = {}) {
+    return inject(NGT_INSTANCE_REF_FACTORY, options);
+}
+export function injectInstance(options = {}) {
+    return inject(NgtInstance, options);
+}
+const supportedEvents = [
+    'click',
+    'contextmenu',
+    'dblclick',
+    'pointerup',
+    'pointerdown',
+    'pointerover',
+    'pointerout',
+    'pointerenter',
+    'pointerleave',
+    'pointermove',
+    'pointermissed',
+    'pointercancel',
+    'wheel',
+];
+export class NgtInstance extends NgtComponentStore {
+    constructor() {
+        super(...arguments);
+        this.priority = 0;
+        this.click = new EventEmitter();
+        this.contextmenu = new EventEmitter();
+        this.dblclick = new EventEmitter();
+        this.pointerup = new EventEmitter();
+        this.pointerdown = new EventEmitter();
+        this.pointerover = new EventEmitter();
+        this.pointerout = new EventEmitter();
+        this.pointerenter = new EventEmitter();
+        this.pointerleave = new EventEmitter();
+        this.pointermove = new EventEmitter();
+        this.pointermissed = new EventEmitter();
+        this.pointercancel = new EventEmitter();
+        this.wheel = new EventEmitter();
+        this.zone = inject(NgZone);
+        this.store = inject(NgtStore);
+        this.parentRef = injectInstanceRef({ skipSelf: true, optional: true });
+        this._isRaw = false;
+        this.hasEmittedAlready = false;
+        this.instanceReady = this.effect(tapEffect(() => {
+            this.handleEvents();
+            let attachToParentSubscription;
+            if (this.parentRef) {
+                attachToParentSubscription = this.attachToParent(this.parent.pipe(filter((parent) => !!parent)));
+                const { noAttach, skipWrapper } = this.read();
+                if (!noAttach && !skipWrapper) {
+                    const parentInstanceNode = getInstanceLocalState(getInstanceLocalState(this.instanceValue)?.parentRef?.value);
+                    if (parentInstanceNode) {
+                        const collections = is.object3d(this.instanceValue)
+                            ? parentInstanceNode.objectsRefs
+                            : parentInstanceNode.instancesRefs;
+                        collections.set((s) => [...s, this.instanceRef]);
+                    }
+                }
+            }
+            let beforeRenderCleanUp;
+            if (this.beforeRender && is.object3d(this.instanceValue) && is.object3d(this.proxyInstance)) {
+                beforeRenderCleanUp = this.store
+                    .read((s) => s.internal)
+                    .subscribe((state, object) => this.beforeRender(state, object), this.priority, this.store.read, this.proxyInstance);
+            }
+            if (this.readyCallback)
+                this.readyCallback(this.instanceValue);
+            return () => {
+                beforeRenderCleanUp?.();
+                attachToParentSubscription?.unsubscribe();
+            };
+        }));
+        this.handleEvents = this.effect(tapEffect(() => {
+            if (this.instanceValue && is.object3d(this.instanceValue)) {
+                const observedEvents = supportedEvents.reduce((result, event) => {
+                    const controllerEvent = this[event].observed ? this[event] : null;
+                    if (controllerEvent) {
+                        result.handlers[event] = this.eventNameToHandler(controllerEvent);
+                        result.eventCount += 1;
+                    }
+                    return result;
+                }, { handlers: {}, eventCount: 0 });
+                // patch __ngt__ with events
+                applyProps(this.__ngt__, observedEvents);
+                // add as an interaction if there are events observed
+                if (observedEvents.eventCount > 0) {
+                    getInstanceLocalState(this.instanceValue)?.rootFactory().addInteraction(this.instanceValue);
+                }
+            }
+            return () => {
+                if (is.object3d(this.instanceValue) && this.__ngt__.eventCount > 0) {
+                    getInstanceLocalState(this.instanceValue)?.rootFactory().removeInteraction(this.instanceValue.uuid);
+                }
+            };
+        }));
+        this.attachToParent = this.effect(tap(() => {
+            const attach = this.read((s) => s.attach);
+            let parentInstanceRef = this.__ngt__?.parentRef;
+            // if no parentInstance, try re-run the factory due to late init
+            if (!parentInstanceRef || !parentInstanceRef.value) {
+                // return early if failed to retrieve
+                if (!this.parent?.value)
+                    return;
+                // reassign on instance internal state
+                if (this.__ngt__) {
+                    this.__ngt__.parentRef = this.parent;
+                }
+                parentInstanceRef = this.parent;
+            }
+            if (typeof attach === 'function') {
+                const attachCleanUp = attach(parentInstanceRef, this.instanceRef, this.store.read);
+                if (attachCleanUp) {
+                    this.__ngt__.attach = attachCleanUp;
+                }
+            }
+            else {
+                const propertyToAttach = [...attach];
+                // if propertyToAttach is empty
+                if (propertyToAttach.length === 0) {
+                    // this might be the case where we are attaching an object3D to the parent object3D
+                    if (is.object3d(this.instanceValue) &&
+                        is.object3d(this.proxyInstance) &&
+                        is.object3d(this.parent?.value)) {
+                        this.parent?.value.add(this.proxyInstance);
+                    }
+                }
+                else {
+                    // array material handling
+                    if (propertyToAttach[0] === 'material' &&
+                        propertyToAttach[1] &&
+                        typeof Number(propertyToAttach[1]) === 'number' &&
+                        is.material(this.instanceValue)) {
+                        if (!Array.isArray(parentInstanceRef.value.material)) {
+                            parentInstanceRef.value.material = [];
+                        }
+                    }
+                    // retrieve the current value on the parentInstance, so we can reset it later
+                    if (this.__ngt__) {
+                        this.__ngt__.attachValue = propertyToAttach.reduce((value, property) => value[property], parentInstanceRef.value);
+                    }
+                    // attach the instance value on the parent
+                    mutate(parentInstanceRef.value, this.proxyInstance, propertyToAttach);
+                }
+                // validate on the instance
+                invalidateInstance(this.instanceValue);
+                // validate on the parent
+                if (getInstanceLocalState(parentInstanceRef.value)) {
+                    invalidateInstance(parentInstanceRef.value);
+                }
+                // save the attach
+                if (this.__ngt__) {
+                    this.__ngt__.attach = propertyToAttach;
+                }
+                this.write({ attach: propertyToAttach });
+            }
+        }));
+    }
+    set ref(instance) {
+        this.write({ instanceRef: is.ref(instance) ? instance : new NgtRef(instance) });
+    }
+    set skipWrapper(skipWrapper) {
+        this.write({ skipWrapper });
+        this.write({ skipWrapperExplicit: true });
+    }
+    set skipInit(skipInit) {
+        this.write({ skipInit });
+        this.write({ skipInitExplicit: true });
+    }
+    set noAttach(noAttach) {
+        this.write({ noAttach });
+        this.write({ noAttachExplicit: true });
+    }
+    set attach(value) {
+        if (value) {
+            const attach = typeof value === 'function'
+                ? value
+                : Array.isArray(value)
+                    ? value.map((item) => (typeof item === 'number' ? item.toString() : item))
+                    : [value];
+            this.write({ attach, attachExplicit: true });
+        }
+    }
+    set isRaw(val) {
+        this._isRaw = val;
+    }
+    initialize() {
+        super.initialize();
+        this.write({
+            instanceRef: new NgtRef(null),
+            attach: [],
+            noAttach: false,
+            skipWrapper: false,
+            skipInit: false,
+        });
+    }
+    ngOnInit() {
+        this.zone.runOutsideAngular(() => {
+            this.store.onReady(() => {
+                this.instanceReady(this.instanceRef.pipe(filter((instance) => !!instance)));
+            });
+        });
+    }
+    get instanceRef() {
+        return this.read((s) => s.instanceRef);
+    }
+    get instanceValue() {
+        if (!this.instanceRef.value)
+            return this.instanceRef.value;
+        return this._isRaw ? this.instanceRef.value?.valueOf() : this.instanceRef.value;
+    }
+    get proxyInstance() {
+        return this.instanceValue?.[NGT_PROXY_INSTANCE];
+    }
+    get __ngt__() {
+        return getInstanceLocalState(this._isRaw ? this.instanceRef.value : this.instanceValue);
+    }
+    get parent() {
+        return this.parentRef?.();
+    }
+    ngOnDestroy() {
+        this.zone.runOutsideAngular(() => {
+            this.destroy();
+        });
+        super.ngOnDestroy();
+    }
+    destroy() {
+        if (this.instanceValue) {
+            if (is.object3d(this.instanceValue)) {
+                const parentInstance = this.parent;
+                if (parentInstance && is.object3d(parentInstance.value)) {
+                    removeInteractivity(this.__ngt__.stateFactory.bind(this.__ngt__), this.instanceValue);
+                    parentInstance.value.remove(this.instanceValue);
+                    invalidateInstance(parentInstance.value);
+                }
+                if (this.instanceValue.clear != null) {
+                    this.instanceValue.clear();
+                }
+            }
+            else {
+                if (this.__ngt__) {
+                    // non-scene objects
+                    const previousAttach = this.__ngt__.attach;
+                    if (previousAttach != null) {
+                        if (typeof previousAttach === 'function') {
+                            previousAttach();
+                        }
+                        else {
+                            const previousAttachValue = this.__ngt__.attachValue;
+                            if (this.__ngt__.parentRef && this.__ngt__.parentRef.value) {
+                                mutate(this.__ngt__.parentRef.value, previousAttachValue, previousAttach);
+                            }
+                        }
+                        if (this.__ngt__.parentRef && this.__ngt__.parentRef.value) {
+                            invalidateInstance(this.__ngt__.parentRef.value);
+                        }
+                    }
+                }
+            }
+            const dispose = this.instanceValue['dispose'];
+            if (dispose && typeof dispose === 'function') {
+                dispose.apply(this.instanceValue);
+            }
+        }
+        this.write({ attach: [] });
+        this.instanceRef.complete();
+    }
+    eventNameToHandler(controllerEvent) {
+        return (event) => {
+            // go back into Angular Zone so that state updates on these events trigger CD
+            this.zone.run(() => {
+                controllerEvent.emit(event);
+            });
+        };
+    }
+}
+NgtInstance.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtInstance, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+NgtInstance.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.0", type: NgtInstance, isStandalone: true, selector: "[ngtInstance]", inputs: { ref: "ref", skipWrapper: "skipWrapper", skipInit: "skipInit", noAttach: "noAttach", attach: "attach", priority: "priority", beforeRender: "beforeRender", readyCallback: "readyCallback", updateCallback: "updateCallback" }, outputs: { click: "click", contextmenu: "contextmenu", dblclick: "dblclick", pointerup: "pointerup", pointerdown: "pointerdown", pointerover: "pointerover", pointerout: "pointerout", pointerenter: "pointerenter", pointerleave: "pointerleave", pointermove: "pointermove", pointermissed: "pointermissed", pointercancel: "pointercancel", wheel: "wheel" }, exportAs: ["ngtInstance"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtInstance, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ngtInstance]',
+                    exportAs: 'ngtInstance',
+                    standalone: true,
+                }]
+        }], propDecorators: { ref: [{
+                type: Input
+            }], skipWrapper: [{
+                type: Input
+            }], skipInit: [{
+                type: Input
+            }], noAttach: [{
+                type: Input
+            }], attach: [{
+                type: Input
+            }], priority: [{
+                type: Input
+            }], beforeRender: [{
+                type: Input
+            }], readyCallback: [{
+                type: Input
+            }], updateCallback: [{
+                type: Input
+            }], click: [{
+                type: Output
+            }], contextmenu: [{
+                type: Output
+            }], dblclick: [{
+                type: Output
+            }], pointerup: [{
+                type: Output
+            }], pointerdown: [{
+                type: Output
+            }], pointerover: [{
+                type: Output
+            }], pointerout: [{
+                type: Output
+            }], pointerenter: [{
+                type: Output
+            }], pointerleave: [{
+                type: Output
+            }], pointermove: [{
+                type: Output
+            }], pointermissed: [{
+                type: Output
+            }], pointercancel: [{
+                type: Output
+            }], wheel: [{
+                type: Output
+            }] } });
+export const NGT_INSTANCE_INPUTS = [
+    'ref',
+    'attach',
+    'skipWrapper',
+    'skipInit',
+    'noAttach',
+    'beforeRender',
+    'priority',
+    'updateCallback',
+    'readyCallback',
+];
+export const NGT_INSTANCE_OUTPUTS = [...supportedEvents];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"instance.js","sourceRoot":"","sources":["../../../../../packages/angular-three/src/lib/instance.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Directive,\n    EventEmitter,\n    inject,\n    InjectionToken,\n    InjectOptions,\n    Input,\n    NgZone,\n    OnDestroy,\n    OnInit,\n    Output,\n} from '@angular/core';\nimport { filter, Subscription, tap } from 'rxjs';\nimport { NgtRef } from './ref';\nimport { NgtComponentStore, tapEffect } from './stores/component-store';\nimport { NgtStore } from './stores/store';\nimport type {\n    NgtAnyCtor,\n    NgtAnyFunction,\n    NgtAnyRecord,\n    NgtAttachFunction,\n    NgtBeforeRenderCallback,\n    NgtEventHandlers,\n    NgtInstanceLocalState,\n    NgtObservableInput,\n    NgtThreeEvent,\n} from './types';\nimport { applyProps } from './utils/apply-props';\nimport { removeInteractivity } from './utils/events';\nimport { getInstanceLocalState } from './utils/get-instance-local-state';\nimport { invalidateInstance } from './utils/instance';\nimport { is } from './utils/is';\nimport { mutate } from './utils/mutate';\n\nexport const NGT_PROXY_INSTANCE = Symbol.for('__ngt__proxy__instance__');\n\nexport const NGT_INSTANCE_REF_FACTORY = new InjectionToken<NgtAnyFunction<NgtRef>>('NgtInstance[instanceRef] factory');\nexport function provideInstanceRef<\n    TInstanceType extends object = any,\n    TCtor extends NgtAnyCtor<TInstanceType> = NgtAnyCtor<TInstanceType>\n>(ctor: TCtor, factory?: (instance: InstanceType<TCtor>) => NgtRef) {\n    return {\n        provide: NGT_INSTANCE_REF_FACTORY,\n        useFactory: (instance: InstanceType<TCtor>) => {\n            if (factory) {\n                return () => factory(instance);\n            }\n\n            return () =>\n                (instance as NgtAnyRecord)['instanceRef'] || (instance as NgtAnyRecord)['instance']['instanceRef'];\n        },\n        deps: [ctor],\n    };\n}\nexport function injectInstanceRef(): NgtAnyFunction<NgtRef>;\nexport function injectInstanceRef(options: InjectOptions & { optional?: false }): NgtAnyFunction<NgtRef>;\nexport function injectInstanceRef(options: InjectOptions & { optional?: true }): NgtAnyFunction<NgtRef> | null;\nexport function injectInstanceRef(options: InjectOptions = {}) {\n    return inject(NGT_INSTANCE_REF_FACTORY, options);\n}\n\nexport interface NgtInstanceState<TInstance extends object = NgtAnyRecord> {\n    instanceRef: NgtRef<TInstance>;\n    instanceArgs: unknown[];\n    attach: string[] | NgtAttachFunction;\n    noAttach: boolean;\n    skipWrapper: boolean;\n    skipInit: boolean;\n}\nexport function injectInstance<T extends object>(): NgtInstance<T>;\nexport function injectInstance<T extends object>(options: InjectOptions & { optional?: false }): NgtInstance<T>;\nexport function injectInstance<T extends object>(options: InjectOptions & { optional?: true }): NgtInstance<T> | null;\nexport function injectInstance(options: InjectOptions = {}) {\n    return inject(NgtInstance, options);\n}\n\nconst supportedEvents = [\n    'click',\n    'contextmenu',\n    'dblclick',\n    'pointerup',\n    'pointerdown',\n    'pointerover',\n    'pointerout',\n    'pointerenter',\n    'pointerleave',\n    'pointermove',\n    'pointermissed',\n    'pointercancel',\n    'wheel',\n] as const;\n\n@Directive({\n    selector: '[ngtInstance]',\n    exportAs: 'ngtInstance',\n    standalone: true,\n})\nexport class NgtInstance<\n        TInstance extends object = any,\n        TInstanceState extends NgtInstanceState<TInstance> = NgtInstanceState<TInstance>\n    >\n    extends NgtComponentStore<TInstanceState>\n    implements OnInit, OnDestroy\n{\n    @Input() set ref(instance: TInstance | NgtRef<TInstance>) {\n        this.write({ instanceRef: is.ref(instance) ? instance : new NgtRef(instance) });\n    }\n\n    @Input() set skipWrapper(skipWrapper: NgtObservableInput<boolean>) {\n        this.write({ skipWrapper });\n        this.write({ skipWrapperExplicit: true });\n    }\n\n    @Input() set skipInit(skipInit: NgtObservableInput<boolean>) {\n        this.write({ skipInit });\n        this.write({ skipInitExplicit: true });\n    }\n\n    @Input() set noAttach(noAttach: NgtObservableInput<boolean>) {\n        this.write({ noAttach });\n        this.write({ noAttachExplicit: true });\n    }\n\n    @Input() set attach(value: string | string[] | [string, ...(string | number)[]] | NgtAttachFunction | undefined) {\n        if (value) {\n            const attach =\n                typeof value === 'function'\n                    ? value\n                    : Array.isArray(value)\n                    ? value.map((item) => (typeof item === 'number' ? item.toString() : item))\n                    : [value];\n\n            this.write({ attach, attachExplicit: true });\n        }\n    }\n\n    @Input() priority = 0;\n    @Input() beforeRender?: NgtBeforeRenderCallback<TInstance>;\n\n    @Input() readyCallback?: ((instance: TInstance) => void) | (() => void);\n    @Input() updateCallback?: ((instance: TInstance) => void) | (() => void);\n\n    @Output() click = new EventEmitter<NgtThreeEvent<MouseEvent>>();\n    @Output() contextmenu = new EventEmitter<NgtThreeEvent<MouseEvent>>();\n    @Output() dblclick = new EventEmitter<NgtThreeEvent<MouseEvent>>();\n    @Output() pointerup = new EventEmitter<NgtThreeEvent<PointerEvent>>();\n    @Output() pointerdown = new EventEmitter<NgtThreeEvent<PointerEvent>>();\n    @Output() pointerover = new EventEmitter<NgtThreeEvent<PointerEvent>>();\n    @Output() pointerout = new EventEmitter<NgtThreeEvent<PointerEvent>>();\n    @Output() pointerenter = new EventEmitter<NgtThreeEvent<PointerEvent>>();\n    @Output() pointerleave = new EventEmitter<NgtThreeEvent<PointerEvent>>();\n    @Output() pointermove = new EventEmitter<NgtThreeEvent<PointerEvent>>();\n    @Output() pointermissed = new EventEmitter<NgtThreeEvent<PointerEvent>>();\n    @Output() pointercancel = new EventEmitter<NgtThreeEvent<PointerEvent>>();\n    @Output() wheel = new EventEmitter<NgtThreeEvent<WheelEvent>>();\n\n    private readonly zone = inject(NgZone);\n    private readonly store = inject(NgtStore);\n\n    private readonly parentRef = injectInstanceRef({ skipSelf: true, optional: true });\n    private _isRaw = false;\n\n    set isRaw(val: boolean) {\n        this._isRaw = val;\n    }\n\n    private hasEmittedAlready = false;\n\n    private readonly instanceReady = this.effect(\n        tapEffect(() => {\n            this.handleEvents();\n\n            let attachToParentSubscription: Subscription;\n            if (this.parentRef) {\n                attachToParentSubscription = this.attachToParent(this.parent!.pipe(filter((parent) => !!parent)));\n                const { noAttach, skipWrapper } = this.read();\n                if (!noAttach && !skipWrapper) {\n                    const parentInstanceNode = getInstanceLocalState(\n                        getInstanceLocalState(this.instanceValue)?.parentRef?.value\n                    );\n\n                    if (parentInstanceNode) {\n                        const collections = is.object3d(this.instanceValue)\n                            ? parentInstanceNode.objectsRefs\n                            : parentInstanceNode.instancesRefs;\n                        collections.set((s) => [...s, this.instanceRef]);\n                    }\n                }\n            }\n\n            let beforeRenderCleanUp: () => void;\n            if (this.beforeRender && is.object3d(this.instanceValue) && is.object3d(this.proxyInstance)) {\n                beforeRenderCleanUp = this.store\n                    .read((s) => s.internal)\n                    .subscribe(\n                        (state, object) => this.beforeRender!(state, object),\n                        this.priority,\n                        this.store.read,\n                        this.proxyInstance\n                    );\n            }\n\n            if (this.readyCallback) this.readyCallback(this.instanceValue);\n\n            return () => {\n                beforeRenderCleanUp?.();\n                attachToParentSubscription?.unsubscribe();\n            };\n        })\n    );\n\n    private handleEvents = this.effect<void>(\n        tapEffect(() => {\n            if (this.instanceValue && is.object3d(this.instanceValue)) {\n                const observedEvents = supportedEvents.reduce(\n                    (result, event) => {\n                        const controllerEvent = this[event].observed ? this[event] : null;\n                        if (controllerEvent) {\n                            result.handlers[event] = this.eventNameToHandler(\n                                controllerEvent as EventEmitter<NgtThreeEvent<any>>\n                            );\n                            result.eventCount += 1;\n                        }\n                        return result;\n                    },\n                    { handlers: {}, eventCount: 0 } as {\n                        handlers: NgtEventHandlers;\n                        eventCount: number;\n                    }\n                );\n\n                // patch __ngt__ with events\n                applyProps(this.__ngt__, observedEvents);\n\n                // add as an interaction if there are events observed\n                if (observedEvents.eventCount > 0) {\n                    getInstanceLocalState(this.instanceValue)?.rootFactory().addInteraction(this.instanceValue);\n                }\n            }\n            return () => {\n                if (is.object3d(this.instanceValue) && this.__ngt__.eventCount > 0) {\n                    getInstanceLocalState(this.instanceValue)?.rootFactory().removeInteraction(this.instanceValue.uuid);\n                }\n            };\n        })\n    );\n\n    private readonly attachToParent = this.effect(\n        tap(() => {\n            const attach = this.read((s) => s.attach);\n\n            let parentInstanceRef = this.__ngt__?.parentRef;\n\n            // if no parentInstance, try re-run the factory due to late init\n            if (!parentInstanceRef || !parentInstanceRef.value) {\n                // return early if failed to retrieve\n                if (!this.parent?.value) return;\n\n                // reassign on instance internal state\n                if (this.__ngt__) {\n                    this.__ngt__.parentRef = this.parent;\n                }\n                parentInstanceRef = this.parent;\n            }\n\n            if (typeof attach === 'function') {\n                const attachCleanUp = attach(parentInstanceRef, this.instanceRef, this.store.read);\n                if (attachCleanUp) {\n                    this.__ngt__.attach = attachCleanUp;\n                }\n            } else {\n                const propertyToAttach = [...attach];\n\n                // if propertyToAttach is empty\n                if (propertyToAttach.length === 0) {\n                    // this might be the case where we are attaching an object3D to the parent object3D\n                    if (\n                        is.object3d(this.instanceValue) &&\n                        is.object3d(this.proxyInstance) &&\n                        is.object3d(this.parent?.value)\n                    ) {\n                        this.parent?.value.add(this.proxyInstance);\n                    }\n                } else {\n                    // array material handling\n                    if (\n                        propertyToAttach[0] === 'material' &&\n                        propertyToAttach[1] &&\n                        typeof Number(propertyToAttach[1]) === 'number' &&\n                        is.material(this.instanceValue)\n                    ) {\n                        if (!Array.isArray(parentInstanceRef.value.material)) {\n                            parentInstanceRef.value.material = [];\n                        }\n                    }\n\n                    // retrieve the current value on the parentInstance, so we can reset it later\n                    if (this.__ngt__) {\n                        this.__ngt__.attachValue = propertyToAttach.reduce(\n                            (value, property) => value[property],\n                            parentInstanceRef.value\n                        );\n                    }\n\n                    // attach the instance value on the parent\n                    mutate(parentInstanceRef.value, this.proxyInstance, propertyToAttach);\n                }\n\n                // validate on the instance\n                invalidateInstance(this.instanceValue);\n\n                // validate on the parent\n                if (getInstanceLocalState(parentInstanceRef.value)) {\n                    invalidateInstance(parentInstanceRef.value);\n                }\n\n                // save the attach\n                if (this.__ngt__) {\n                    this.__ngt__.attach = propertyToAttach;\n                }\n                this.write({ attach: propertyToAttach });\n            }\n        })\n    );\n\n    override initialize() {\n        super.initialize();\n        this.write({\n            instanceRef: new NgtRef(null),\n            attach: [],\n            noAttach: false,\n            skipWrapper: false,\n            skipInit: false,\n        });\n    }\n\n    ngOnInit() {\n        this.zone.runOutsideAngular(() => {\n            this.store.onReady(() => {\n                this.instanceReady(this.instanceRef.pipe(filter((instance) => !!instance)));\n            });\n        });\n    }\n\n    get instanceRef(): NgtRef<TInstance> {\n        return this.read((s) => s.instanceRef);\n    }\n\n    get instanceValue(): TInstance {\n        if (!this.instanceRef.value) return this.instanceRef.value;\n        return this._isRaw ? (this.instanceRef.value?.valueOf() as TInstance) : this.instanceRef.value;\n    }\n\n    get proxyInstance(): TInstance {\n        return (this.instanceValue as any)?.[NGT_PROXY_INSTANCE];\n    }\n\n    get __ngt__(): NgtInstanceLocalState {\n        return getInstanceLocalState(\n            this._isRaw ? this.instanceRef.value : this.instanceValue\n        ) as NgtInstanceLocalState;\n    }\n\n    get parent(): NgtRef | undefined {\n        return this.parentRef?.();\n    }\n\n    override ngOnDestroy() {\n        this.zone.runOutsideAngular(() => {\n            this.destroy();\n        });\n        super.ngOnDestroy();\n    }\n\n    private destroy() {\n        if (this.instanceValue) {\n            if (is.object3d(this.instanceValue)) {\n                const parentInstance = this.parent;\n                if (parentInstance && is.object3d(parentInstance.value)) {\n                    removeInteractivity(this.__ngt__.stateFactory.bind(this.__ngt__), this.instanceValue);\n                    parentInstance.value.remove(this.instanceValue);\n                    invalidateInstance(parentInstance.value);\n                }\n\n                if (this.instanceValue.clear != null) {\n                    this.instanceValue.clear();\n                }\n            } else {\n                if (this.__ngt__) {\n                    // non-scene objects\n                    const previousAttach = this.__ngt__.attach;\n                    if (previousAttach != null) {\n                        if (typeof previousAttach === 'function') {\n                            previousAttach();\n                        } else {\n                            const previousAttachValue = this.__ngt__.attachValue;\n                            if (this.__ngt__.parentRef && this.__ngt__.parentRef.value) {\n                                mutate(this.__ngt__.parentRef.value, previousAttachValue, previousAttach);\n                            }\n                        }\n\n                        if (this.__ngt__.parentRef && this.__ngt__.parentRef.value) {\n                            invalidateInstance(this.__ngt__.parentRef.value);\n                        }\n                    }\n                }\n            }\n\n            const dispose = (this.instanceValue as NgtAnyRecord)['dispose'];\n            if (dispose && typeof dispose === 'function') {\n                dispose.apply(this.instanceValue);\n            }\n        }\n\n        this.write({ attach: [] });\n        this.instanceRef.complete();\n    }\n\n    private eventNameToHandler(\n        controllerEvent: EventEmitter<NgtThreeEvent<PointerEvent>> | EventEmitter<NgtThreeEvent<WheelEvent>>\n    ) {\n        return (event: Parameters<Exclude<NgtEventHandlers[typeof supportedEvents[number]], undefined>>[0]) => {\n            // go back into Angular Zone so that state updates on these events trigger CD\n            this.zone.run(() => {\n                controllerEvent.emit(event as NgtThreeEvent<any>);\n            });\n        };\n    }\n}\n\nexport const NGT_INSTANCE_INPUTS = [\n    'ref',\n    'attach',\n    'skipWrapper',\n    'skipInit',\n    'noAttach',\n    'beforeRender',\n    'priority',\n    'updateCallback',\n    'readyCallback',\n];\n\nexport const NGT_INSTANCE_OUTPUTS = [...supportedEvents];\n"]}

package/esm2020/lib/pipes/math.mjs

@@ -0,0 +1,15 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NgtMathPipe {
+    transform(value, keyOfMath) {
+        const params = Array.isArray(value) ? value : [value];
+        return Math[keyOfMath](...params);
+    }
+}
+NgtMathPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtMathPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NgtMathPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.0.0", ngImport: i0, type: NgtMathPipe, isStandalone: true, name: "math" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtMathPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'math', standalone: true }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWF0aC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2FuZ3VsYXItdGhyZWUvc3JjL2xpYi9waXBlcy9tYXRoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDOztBQUdwRCxNQUFNLE9BQU8sV0FBVztJQUNwQixTQUFTLENBQ0wsS0FBd0IsRUFDeEIsU0FBOEc7UUFFOUcsTUFBTSxNQUFNLEdBQUcsS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ3RELE9BQVEsSUFBSSxDQUFDLFNBQVMsQ0FBOEMsQ0FBQyxHQUFHLE1BQU0sQ0FFN0UsQ0FBQztJQUNOLENBQUM7O3dHQVRRLFdBQVc7c0dBQVgsV0FBVzsyRkFBWCxXQUFXO2tCQUR2QixJQUFJO21CQUFDLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AUGlwZSh7IG5hbWU6ICdtYXRoJywgc3RhbmRhbG9uZTogdHJ1ZSB9KVxuZXhwb3J0IGNsYXNzIE5ndE1hdGhQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gICAgdHJhbnNmb3JtKFxuICAgICAgICB2YWx1ZTogbnVtYmVyIHwgbnVtYmVyW10sXG4gICAgICAgIGtleU9mTWF0aDoga2V5b2YgT21pdDxNYXRoLCAnUEknIHwgJ0UnIHwgJ0xOMicgfCAnTE9HMkUnIHwgJ0xOMTAnIHwgJ0xPRzEwRScgfCAnU1FSVDFfMicgfCAnU1FSVDInIHwgJ3JhbmRvbSc+XG4gICAgKTogUmV0dXJuVHlwZTxFeHRyYWN0PE1hdGhbdHlwZW9mIGtleU9mTWF0aF0sICdzdHJpbmcnPj4ge1xuICAgICAgICBjb25zdCBwYXJhbXMgPSBBcnJheS5pc0FycmF5KHZhbHVlKSA/IHZhbHVlIDogW3ZhbHVlXTtcbiAgICAgICAgcmV0dXJuIChNYXRoW2tleU9mTWF0aF0gYXMgdW5rbm93biBhcyAoLi4uYXJnczogbnVtYmVyW10pID0+IG51bWJlcikoLi4ucGFyYW1zKSBhcyBSZXR1cm5UeXBlPFxuICAgICAgICAgICAgRXh0cmFjdDxNYXRoW3R5cGVvZiBrZXlPZk1hdGhdLCAnc3RyaW5nJz5cbiAgICAgICAgPjtcbiAgICB9XG59XG4iXX0=

package/esm2020/lib/pipes/pi.mjs

@@ -0,0 +1,14 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NgtPiPipe {
+    transform(value) {
+        return value * Math.PI;
+    }
+}
+NgtPiPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtPiPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NgtPiPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.0.0", ngImport: i0, type: NgtPiPipe, isStandalone: true, name: "pi" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtPiPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'pi', standalone: true }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9hbmd1bGFyLXRocmVlL3NyYy9saWIvcGlwZXMvcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7O0FBR3BELE1BQU0sT0FBTyxTQUFTO0lBQ2xCLFNBQVMsQ0FBQyxLQUFhO1FBQ25CLE9BQU8sS0FBSyxHQUFHLElBQUksQ0FBQyxFQUFFLENBQUM7SUFDM0IsQ0FBQzs7c0dBSFEsU0FBUztvR0FBVCxTQUFTOzJGQUFULFNBQVM7a0JBRHJCLElBQUk7bUJBQUMsRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRSxJQUFJLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBQaXBlKHsgbmFtZTogJ3BpJywgc3RhbmRhbG9uZTogdHJ1ZSB9KVxuZXhwb3J0IGNsYXNzIE5ndFBpUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICAgIHRyYW5zZm9ybSh2YWx1ZTogbnVtYmVyKTogbnVtYmVyIHtcbiAgICAgICAgcmV0dXJuIHZhbHVlICogTWF0aC5QSTtcbiAgICB9XG59XG4iXX0=

package/esm2020/lib/pipes/radian.mjs

@@ -0,0 +1,14 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NgtRadianPipe {
+    transform(degree) {
+        return (degree * Math.PI) / 180;
+    }
+}
+NgtRadianPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtRadianPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NgtRadianPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.0.0", ngImport: i0, type: NgtRadianPipe, isStandalone: true, name: "radian" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtRadianPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'radian', standalone: true }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmFkaWFuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvYW5ndWxhci10aHJlZS9zcmMvbGliL3BpcGVzL3JhZGlhbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQzs7QUFHcEQsTUFBTSxPQUFPLGFBQWE7SUFDdEIsU0FBUyxDQUFDLE1BQWM7UUFDcEIsT0FBTyxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUMsRUFBRSxDQUFDLEdBQUcsR0FBRyxDQUFDO0lBQ3BDLENBQUM7OzBHQUhRLGFBQWE7d0dBQWIsYUFBYTsyRkFBYixhQUFhO2tCQUR6QixJQUFJO21CQUFDLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AUGlwZSh7IG5hbWU6ICdyYWRpYW4nLCBzdGFuZGFsb25lOiB0cnVlIH0pXG5leHBvcnQgY2xhc3MgTmd0UmFkaWFuUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICAgIHRyYW5zZm9ybShkZWdyZWU6IG51bWJlcik6IG51bWJlciB7XG4gICAgICAgIHJldHVybiAoZGVncmVlICogTWF0aC5QSSkgLyAxODA7XG4gICAgfVxufVxuIl19

package/esm2020/lib/pipes/side.mjs

@@ -0,0 +1,22 @@
+import { Pipe } from '@angular/core';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+export class NgtSidePipe {
+    transform(side) {
+        switch (side) {
+            case 'front':
+                return THREE.FrontSide;
+            case 'back':
+                return THREE.BackSide;
+            case 'double':
+                return THREE.DoubleSide;
+        }
+    }
+}
+NgtSidePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtSidePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NgtSidePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.0.0", ngImport: i0, type: NgtSidePipe, isStandalone: true, name: "side" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtSidePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'side', standalone: true }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lkZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2FuZ3VsYXItdGhyZWUvc3JjL2xpYi9waXBlcy9zaWRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDO0FBQ3BELE9BQU8sS0FBSyxLQUFLLE1BQU0sT0FBTyxDQUFDOztBQUcvQixNQUFNLE9BQU8sV0FBVztJQUNwQixTQUFTLENBQUMsSUFBaUM7UUFDdkMsUUFBUSxJQUFJLEVBQUU7WUFDVixLQUFLLE9BQU87Z0JBQ1IsT0FBTyxLQUFLLENBQUMsU0FBUyxDQUFDO1lBQzNCLEtBQUssTUFBTTtnQkFDUCxPQUFPLEtBQUssQ0FBQyxRQUFRLENBQUM7WUFDMUIsS0FBSyxRQUFRO2dCQUNULE9BQU8sS0FBSyxDQUFDLFVBQVUsQ0FBQztTQUMvQjtJQUNMLENBQUM7O3dHQVZRLFdBQVc7c0dBQVgsV0FBVzsyRkFBWCxXQUFXO2tCQUR2QixJQUFJO21CQUFDLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0ICogYXMgVEhSRUUgZnJvbSAndGhyZWUnO1xuXG5AUGlwZSh7IG5hbWU6ICdzaWRlJywgc3RhbmRhbG9uZTogdHJ1ZSB9KVxuZXhwb3J0IGNsYXNzIE5ndFNpZGVQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gICAgdHJhbnNmb3JtKHNpZGU6ICdmcm9udCcgfCAnYmFjaycgfCAnZG91YmxlJyk6IFRIUkVFLlNpZGUge1xuICAgICAgICBzd2l0Y2ggKHNpZGUpIHtcbiAgICAgICAgICAgIGNhc2UgJ2Zyb250JzpcbiAgICAgICAgICAgICAgICByZXR1cm4gVEhSRUUuRnJvbnRTaWRlO1xuICAgICAgICAgICAgY2FzZSAnYmFjayc6XG4gICAgICAgICAgICAgICAgcmV0dXJuIFRIUkVFLkJhY2tTaWRlO1xuICAgICAgICAgICAgY2FzZSAnZG91YmxlJzpcbiAgICAgICAgICAgICAgICByZXR1cm4gVEhSRUUuRG91YmxlU2lkZTtcbiAgICAgICAgfVxuICAgIH1cbn1cbiJdfQ==

package/esm2020/lib/ref.mjs

@@ -0,0 +1,15 @@
+import { BehaviorSubject } from 'rxjs';
+export class NgtRef extends BehaviorSubject {
+    constructor(value) {
+        super(value ? value : null);
+    }
+    set(valueOrFactory) {
+        if (typeof valueOrFactory === 'function') {
+            this.next(valueOrFactory(this.value));
+        }
+        else {
+            this.next(valueOrFactory);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVmLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvYW5ndWxhci10aHJlZS9zcmMvbGliL3JlZi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBRXZDLE1BQU0sT0FBTyxNQUFnQixTQUFRLGVBQWtCO0lBQ25ELFlBQVksS0FBZ0I7UUFDeEIsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxJQUFLLENBQUMsQ0FBQztJQUNqQyxDQUFDO0lBRUQsR0FBRyxDQUFDLGNBQXdDO1FBQ3hDLElBQUksT0FBTyxjQUFjLEtBQUssVUFBVSxFQUFFO1lBQ3RDLElBQUksQ0FBQyxJQUFJLENBQUUsY0FBcUMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztTQUNqRTthQUFNO1lBQ0gsSUFBSSxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsQ0FBQztTQUM3QjtJQUNMLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJlaGF2aW9yU3ViamVjdCB9IGZyb20gJ3J4anMnO1xuXG5leHBvcnQgY2xhc3MgTmd0UmVmPFQgPSBhbnk+IGV4dGVuZHMgQmVoYXZpb3JTdWJqZWN0PFQ+IHtcbiAgICBjb25zdHJ1Y3Rvcih2YWx1ZT86IFQgfCBudWxsKSB7XG4gICAgICAgIHN1cGVyKHZhbHVlID8gdmFsdWUgOiBudWxsISk7XG4gICAgfVxuXG4gICAgc2V0KHZhbHVlT3JGYWN0b3J5OiBUIHwgKChwcmV2aW91czogVCkgPT4gVCkpIHtcbiAgICAgICAgaWYgKHR5cGVvZiB2YWx1ZU9yRmFjdG9yeSA9PT0gJ2Z1bmN0aW9uJykge1xuICAgICAgICAgICAgdGhpcy5uZXh0KCh2YWx1ZU9yRmFjdG9yeSBhcyAocHJldmlvdXM6IFQpID0+IFQpKHRoaXMudmFsdWUpKTtcbiAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICAgIHRoaXMubmV4dCh2YWx1ZU9yRmFjdG9yeSk7XG4gICAgICAgIH1cbiAgICB9XG59XG4iXX0=

package/esm2020/lib/services/loader.mjs

@@ -0,0 +1,45 @@
+import { Injectable } from '@angular/core';
+import { catchError, forkJoin, from, map, of, ReplaySubject, retry, share, tap } from 'rxjs';
+import { buildGraph } from '../utils/build-graph';
+import * as i0 from "@angular/core";
+export class NgtLoader {
+    constructor() {
+        this.cached = new Map();
+    }
+    use(loadConstructor, input, extensions, onProgress) {
+        const urls = Array.isArray(input) ? input : [input];
+        const loader = new loadConstructor();
+        if (extensions) {
+            extensions(loader);
+        }
+        const observables$ = urls.map((url) => {
+            if (!this.cached.has(url)) {
+                this.cached.set(url, from(loader.loadAsync(url, onProgress)).pipe(tap((data) => {
+                    if (data.scene) {
+                        Object.assign(data, buildGraph(data.scene));
+                    }
+                }), retry(2), catchError((err) => {
+                    console.error(`[NgtLoader]: Error loading ${url}: ${err.message}`);
+                    return of(null);
+                }), share({
+                    connector: () => new ReplaySubject(1),
+                    resetOnComplete: true,
+                    resetOnRefCountZero: true,
+                    resetOnError: true,
+                })));
+            }
+            return this.cached.get(url);
+        });
+        return forkJoin(observables$).pipe(map((results) => (Array.isArray(input) ? results : results[0])));
+    }
+    destroy() {
+        this.cached.clear();
+    }
+}
+NgtLoader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+NgtLoader.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtLoader, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtLoader, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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