angular-three 1.9.16 → 1.10.1

package/esm2022/lib/canvas.mjs

@@ -0,0 +1,243 @@
+import { ChangeDetectorRef, Component, createEnvironmentInjector, ElementRef, EnvironmentInjector, EventEmitter, HostBinding, inject, Input, Output, Type, ViewChild, ViewContainerRef, } from '@angular/core';
+import { NgxResize, provideNgxResizeOptions } from 'ngx-resize';
+import { filter } from 'rxjs';
+import { injectNgtLoader } from './loader';
+import { provideNgtRenderer } from './renderer/provider';
+import { NgtRxStore } from './stores/rx-store';
+import { NgtStore, rootStateMap } from './stores/store';
+import { is } from './utils/is';
+import { safeDetectChanges } from './utils/safe-detect-changes';
+import { createPointerEvents } from './web/events';
+import * as i0 from "@angular/core";
+class NgtCanvas extends NgtRxStore {
+    constructor() {
+        super(...arguments);
+        this.cdr = inject(ChangeDetectorRef);
+        this.envInjector = inject(EnvironmentInjector);
+        this.host = inject(ElementRef);
+        this.store = inject(NgtStore);
+        this.hbClass = true;
+        this.sceneGraphInputs = {};
+        this.compoundPrefixes = [];
+        this.created = new EventEmitter();
+        this.pointerMissed = new EventEmitter();
+    }
+    initialize() {
+        super.initialize();
+        this.set({
+            shadows: false,
+            linear: false,
+            flat: false,
+            legacy: false,
+            orthographic: false,
+            frameloop: 'always',
+            dpr: [1, 2],
+            events: createPointerEvents,
+        });
+    }
+    get hbPointerEvents() {
+        return this.get('eventSource') !== this.host.nativeElement ? 'none' : 'auto';
+    }
+    set linear(linear) {
+        this.set({ linear });
+    }
+    set legacy(legacy) {
+        this.set({ legacy });
+    }
+    set flat(flat) {
+        this.set({ flat });
+    }
+    set orthographic(orthographic) {
+        this.set({ orthographic });
+    }
+    set frameloop(frameloop) {
+        this.set({ frameloop });
+    }
+    set dpr(dpr) {
+        this.set({ dpr });
+    }
+    set raycaster(raycaster) {
+        this.set({ raycaster });
+    }
+    set shadows(shadows) {
+        this.set({
+            shadows: typeof shadows === 'object' ? shadows : shadows,
+        });
+    }
+    set camera(camera) {
+        this.set({ camera });
+    }
+    set gl(gl) {
+        this.set({ gl });
+    }
+    set eventSource(eventSource) {
+        this.set({ eventSource });
+    }
+    set eventPrefix(eventPrefix) {
+        this.set({ eventPrefix });
+    }
+    set lookAt(lookAt) {
+        this.set({ lookAt });
+    }
+    set performance(performance) {
+        this.set({ performance });
+    }
+    ngOnChanges(changes) {
+        if (changes['sceneGraphInputs'] && this.glRef) {
+            this.setSceneGraphInputs();
+        }
+    }
+    ngOnInit() {
+        if (!this.get('eventSource')) {
+            // set default event source to the host element
+            this.eventSource = this.host.nativeElement;
+        }
+        if (this.pointerMissed.observed) {
+            this.store.set({
+                onPointerMissed: (event) => {
+                    this.pointerMissed.emit(event);
+                    safeDetectChanges(this.cdr);
+                },
+            });
+        }
+        // setup NgtStore
+        this.store.init();
+        // set rootStateMap
+        rootStateMap.set(this.glCanvas.nativeElement, this.store);
+        // subscribe to store to listen for ready state
+        this.hold(this.store.select('ready').pipe(filter((ready) => ready)), () => this.storeReady());
+    }
+    onResize({ width, height }) {
+        if (width > 0 && height > 0) {
+            if (!this.store.isInit)
+                this.store.init();
+            this.store.configure(this.get(), this.glCanvas.nativeElement);
+        }
+    }
+    storeReady() {
+        // canvas is ready, let's activate the loop
+        this.store.set((state) => ({ internal: { ...state.internal, active: true } }));
+        const inputs = this.get();
+        const state = this.store.get();
+        // connect to event source
+        state.events.connect?.(is.ref(inputs.eventSource) ? inputs.eventSource.nativeElement : inputs.eventSource);
+        // setup compute function for events
+        if (inputs.eventPrefix) {
+            state.setEvents({
+                compute: (event, store) => {
+                    const innerState = store.get();
+                    const x = event[(inputs.eventPrefix + 'X')];
+                    const y = event[(inputs.eventPrefix + 'Y')];
+                    innerState.pointer.set((x / innerState.size.width) * 2 - 1, -(y / innerState.size.height) * 2 + 1);
+                    innerState.raycaster.setFromCamera(innerState.pointer, innerState.camera);
+                },
+            });
+        }
+        // emit created event if observed
+        if (this.created.observed)
+            this.created.emit(this.store.get());
+        // render
+        if (this.glRef)
+            this.glRef.destroy();
+        requestAnimationFrame(() => {
+            const { store, cdr: changeDetectorRef, compoundPrefixes } = this;
+            this.glEnvInjector = createEnvironmentInjector([provideNgtRenderer({ store, changeDetectorRef, compoundPrefixes })], this.envInjector);
+            this.glRef = this.glAnchor.createComponent(this.sceneGraph, { environmentInjector: this.glEnvInjector });
+            // detach the Scene graph from Change Detection mechanism
+            // everything from this point forward will trigger CD manually with detectChanges
+            this.glRef.changeDetectorRef.detach();
+            this.setSceneGraphInputs();
+            // here, we override the detectChanges to also call detectChanges on the ComponentRef
+            this.overrideDetectChanges();
+            this.cdr.detectChanges();
+        });
+    }
+    ngOnDestroy() {
+        if (this.glRef)
+            this.glRef.destroy();
+        if (this.glEnvInjector)
+            this.glEnvInjector.destroy();
+        injectNgtLoader.destroy();
+        this.store.destroy(this.glCanvas.nativeElement);
+        super.ngOnDestroy();
+    }
+    overrideDetectChanges() {
+        const originalDetectChanges = this.cdr.detectChanges.bind(this.cdr);
+        this.cdr.detectChanges = () => {
+            originalDetectChanges();
+            safeDetectChanges(this.glRef?.changeDetectorRef);
+        };
+    }
+    setSceneGraphInputs() {
+        for (const key of Object.keys(this.sceneGraphInputs)) {
+            this.glRef.setInput(key, this.sceneGraphInputs[key]);
+        }
+        safeDetectChanges(this.cdr);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtCanvas, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtCanvas, isStandalone: true, selector: "ngt-canvas", inputs: { sceneGraph: "sceneGraph", sceneGraphInputs: "sceneGraphInputs", compoundPrefixes: "compoundPrefixes", linear: "linear", legacy: "legacy", flat: "flat", orthographic: "orthographic", frameloop: "frameloop", dpr: "dpr", raycaster: "raycaster", shadows: "shadows", camera: "camera", gl: "gl", eventSource: "eventSource", eventPrefix: "eventPrefix", lookAt: "lookAt", performance: "performance" }, outputs: { created: "created", pointerMissed: "pointerMissed" }, host: { properties: { "class.ngt-canvas": "this.hbClass", "style.pointerEvents": "this.hbPointerEvents" } }, providers: [NgtStore, provideNgxResizeOptions({ emitInZone: false })], viewQueries: [{ propertyName: "glCanvas", first: true, predicate: ["glCanvas"], descendants: true, static: true }, { propertyName: "glAnchor", first: true, predicate: ["glCanvas"], descendants: true, read: ViewContainerRef, static: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: `
+        <div (ngxResize)="onResize($event)" style="height: 100%; width: 100%;">
+            <canvas #glCanvas style="display: block;"></canvas>
+        </div>
+    `, isInline: true, styles: [":host{display:block;position:relative;width:100%;height:100%;overflow:hidden}\n"], dependencies: [{ kind: "directive", type: NgxResize, selector: "[ngxResize]", inputs: ["ngxResizeOptions"], outputs: ["ngxResize"] }] }); }
+}
+export { NgtCanvas };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtCanvas, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngt-canvas', standalone: true, template: `
+        <div (ngxResize)="onResize($event)" style="height: 100%; width: 100%;">
+            <canvas #glCanvas style="display: block;"></canvas>
+        </div>
+    `, imports: [NgxResize], providers: [NgtStore, provideNgxResizeOptions({ emitInZone: false })], styles: [":host{display:block;position:relative;width:100%;height:100%;overflow:hidden}\n"] }]
+        }], propDecorators: { hbClass: [{
+                type: HostBinding,
+                args: ['class.ngt-canvas']
+            }], hbPointerEvents: [{
+                type: HostBinding,
+                args: ['style.pointerEvents']
+            }], sceneGraph: [{
+                type: Input
+            }], sceneGraphInputs: [{
+                type: Input
+            }], compoundPrefixes: [{
+                type: Input
+            }], linear: [{
+                type: Input
+            }], legacy: [{
+                type: Input
+            }], flat: [{
+                type: Input
+            }], orthographic: [{
+                type: Input
+            }], frameloop: [{
+                type: Input
+            }], dpr: [{
+                type: Input
+            }], raycaster: [{
+                type: Input
+            }], shadows: [{
+                type: Input
+            }], camera: [{
+                type: Input
+            }], gl: [{
+                type: Input
+            }], eventSource: [{
+                type: Input
+            }], eventPrefix: [{
+                type: Input
+            }], lookAt: [{
+                type: Input
+            }], performance: [{
+                type: Input
+            }], created: [{
+                type: Output
+            }], pointerMissed: [{
+                type: Output
+            }], glCanvas: [{
+                type: ViewChild,
+                args: ['glCanvas', { static: true }]
+            }], glAnchor: [{
+                type: ViewChild,
+                args: ['glCanvas', { static: true, read: ViewContainerRef }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"canvas.js","sourceRoot":"","sources":["../../../../../libs/angular-three/src/lib/canvas.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    ChangeDetectorRef,\n    Component,\n    ComponentRef,\n    createEnvironmentInjector,\n    ElementRef,\n    EnvironmentInjector,\n    EventEmitter,\n    HostBinding,\n    inject,\n    Input,\n    OnChanges,\n    OnDestroy,\n    OnInit,\n    Output,\n    SimpleChanges,\n    Type,\n    ViewChild,\n    ViewContainerRef,\n} from '@angular/core';\nimport { NgxResize, NgxResizeResult, provideNgxResizeOptions } from 'ngx-resize';\nimport { filter } from 'rxjs';\nimport { injectNgtLoader } from './loader';\nimport { provideNgtRenderer } from './renderer/provider';\nimport { NgtRxStore } from './stores/rx-store';\nimport { NgtStore, rootStateMap } from './stores/store';\nimport type { NgtAnyRecord, NgtCanvasInputs, NgtDomEvent, NgtDpr, NgtState } from './types';\nimport { is } from './utils/is';\nimport { safeDetectChanges } from './utils/safe-detect-changes';\nimport { createPointerEvents } from './web/events';\n\n@Component({\n    selector: 'ngt-canvas',\n    standalone: true,\n    template: `\n        <div (ngxResize)=\"onResize($event)\" style=\"height: 100%; width: 100%;\">\n            <canvas #glCanvas style=\"display: block;\"></canvas>\n        </div>\n    `,\n    imports: [NgxResize],\n    providers: [NgtStore, provideNgxResizeOptions({ emitInZone: false })],\n    styles: [\n        `\n            :host {\n                display: block;\n                position: relative;\n                width: 100%;\n                height: 100%;\n                overflow: hidden;\n            }\n        `,\n    ],\n})\nexport class NgtCanvas extends NgtRxStore<NgtCanvasInputs> implements OnInit, OnDestroy, OnChanges {\n    private readonly cdr = inject(ChangeDetectorRef);\n    private readonly envInjector = inject(EnvironmentInjector);\n    private readonly host = inject(ElementRef) as ElementRef<HTMLElement>;\n    private readonly store = inject(NgtStore);\n\n    override initialize() {\n        super.initialize();\n        this.set({\n            shadows: false,\n            linear: false,\n            flat: false,\n            legacy: false,\n            orthographic: false,\n            frameloop: 'always',\n            dpr: [1, 2],\n            events: createPointerEvents,\n        });\n    }\n\n    @HostBinding('class.ngt-canvas') readonly hbClass = true;\n    @HostBinding('style.pointerEvents') get hbPointerEvents() {\n        return this.get('eventSource') !== this.host.nativeElement ? 'none' : 'auto';\n    }\n\n    @Input() sceneGraph!: Type<any>;\n    @Input() sceneGraphInputs: NgtAnyRecord = {};\n    @Input() compoundPrefixes: string[] = [];\n\n    @Input() set linear(linear: boolean) {\n        this.set({ linear });\n    }\n\n    @Input() set legacy(legacy: boolean) {\n        this.set({ legacy });\n    }\n\n    @Input() set flat(flat: boolean) {\n        this.set({ flat });\n    }\n\n    @Input() set orthographic(orthographic: boolean) {\n        this.set({ orthographic });\n    }\n\n    @Input() set frameloop(frameloop: NgtCanvasInputs['frameloop']) {\n        this.set({ frameloop });\n    }\n\n    @Input() set dpr(dpr: NgtDpr) {\n        this.set({ dpr });\n    }\n\n    @Input() set raycaster(raycaster: Partial<THREE.Raycaster>) {\n        this.set({ raycaster });\n    }\n\n    @Input() set shadows(shadows: boolean | Partial<THREE.WebGLShadowMap>) {\n        this.set({\n            shadows: typeof shadows === 'object' ? (shadows as Partial<THREE.WebGLShadowMap>) : shadows,\n        });\n    }\n\n    @Input() set camera(camera: NgtCanvasInputs['camera']) {\n        this.set({ camera });\n    }\n\n    @Input() set gl(gl: NgtCanvasInputs['gl']) {\n        this.set({ gl });\n    }\n\n    @Input() set eventSource(eventSource: NgtCanvasInputs['eventSource']) {\n        this.set({ eventSource });\n    }\n\n    @Input() set eventPrefix(eventPrefix: NgtCanvasInputs['eventPrefix']) {\n        this.set({ eventPrefix });\n    }\n\n    @Input() set lookAt(lookAt: NgtCanvasInputs['lookAt']) {\n        this.set({ lookAt });\n    }\n\n    @Input() set performance(performance: NgtCanvasInputs['performance']) {\n        this.set({ performance });\n    }\n\n    @Output() created = new EventEmitter<NgtState>();\n    @Output() pointerMissed = new EventEmitter<MouseEvent>();\n\n    @ViewChild('glCanvas', { static: true }) glCanvas!: ElementRef<HTMLCanvasElement>;\n    @ViewChild('glCanvas', { static: true, read: ViewContainerRef }) glAnchor!: ViewContainerRef;\n\n    private glRef?: ComponentRef<unknown>;\n    private glEnvInjector?: EnvironmentInjector;\n\n    ngOnChanges(changes: SimpleChanges) {\n        if (changes['sceneGraphInputs'] && this.glRef) {\n            this.setSceneGraphInputs();\n        }\n    }\n\n    ngOnInit() {\n        if (!this.get('eventSource')) {\n            // set default event source to the host element\n            this.eventSource = this.host.nativeElement;\n        }\n\n        if (this.pointerMissed.observed) {\n            this.store.set({\n                onPointerMissed: (event: MouseEvent) => {\n                    this.pointerMissed.emit(event);\n                    safeDetectChanges(this.cdr);\n                },\n            });\n        }\n\n        // setup NgtStore\n        this.store.init();\n\n        // set rootStateMap\n        rootStateMap.set(this.glCanvas.nativeElement, this.store);\n\n        // subscribe to store to listen for ready state\n        this.hold(this.store.select('ready').pipe(filter((ready) => ready)), () => this.storeReady());\n    }\n\n    onResize({ width, height }: NgxResizeResult) {\n        if (width > 0 && height > 0) {\n            if (!this.store.isInit) this.store.init();\n            this.store.configure(this.get(), this.glCanvas.nativeElement);\n        }\n    }\n\n    private storeReady() {\n        // canvas is ready, let's activate the loop\n        this.store.set((state) => ({ internal: { ...state.internal, active: true } }));\n\n        const inputs = this.get();\n        const state = this.store.get();\n\n        // connect to event source\n        state.events.connect?.(is.ref(inputs.eventSource) ? inputs.eventSource.nativeElement : inputs.eventSource);\n\n        // setup compute function for events\n        if (inputs.eventPrefix) {\n            state.setEvents({\n                compute: (event, store) => {\n                    const innerState = store.get();\n                    const x = event[(inputs.eventPrefix + 'X') as keyof NgtDomEvent] as number;\n                    const y = event[(inputs.eventPrefix + 'Y') as keyof NgtDomEvent] as number;\n                    innerState.pointer.set((x / innerState.size.width) * 2 - 1, -(y / innerState.size.height) * 2 + 1);\n                    innerState.raycaster.setFromCamera(innerState.pointer, innerState.camera);\n                },\n            });\n        }\n\n        // emit created event if observed\n        if (this.created.observed) this.created.emit(this.store.get());\n\n        // render\n        if (this.glRef) this.glRef.destroy();\n\n        requestAnimationFrame(() => {\n            const { store, cdr: changeDetectorRef, compoundPrefixes } = this;\n            this.glEnvInjector = createEnvironmentInjector(\n                [provideNgtRenderer({ store, changeDetectorRef, compoundPrefixes })],\n                this.envInjector\n            );\n            this.glRef = this.glAnchor.createComponent(this.sceneGraph, { environmentInjector: this.glEnvInjector });\n            // detach the Scene graph from Change Detection mechanism\n            // everything from this point forward will trigger CD manually with detectChanges\n            this.glRef.changeDetectorRef.detach();\n            this.setSceneGraphInputs();\n\n            // here, we override the detectChanges to also call detectChanges on the ComponentRef\n            this.overrideDetectChanges();\n            this.cdr.detectChanges();\n        });\n    }\n\n    override ngOnDestroy() {\n        if (this.glRef) this.glRef.destroy();\n        if (this.glEnvInjector) this.glEnvInjector.destroy();\n        injectNgtLoader.destroy();\n        this.store.destroy(this.glCanvas.nativeElement);\n        super.ngOnDestroy();\n    }\n\n    private overrideDetectChanges() {\n        const originalDetectChanges = this.cdr.detectChanges.bind(this.cdr);\n        this.cdr.detectChanges = () => {\n            originalDetectChanges();\n            safeDetectChanges(this.glRef?.changeDetectorRef);\n        };\n    }\n\n    private setSceneGraphInputs() {\n        for (const key of Object.keys(this.sceneGraphInputs)) {\n            this.glRef!.setInput(key, this.sceneGraphInputs[key]);\n        }\n        safeDetectChanges(this.cdr);\n    }\n}\n"]}

package/esm2022/lib/directives/args.mjs

@@ -0,0 +1,36 @@
+import { Directive, Input } from '@angular/core';
+import { NgtCommonDirective } from './common';
+import * as i0 from "@angular/core";
+class NgtArgs extends NgtCommonDirective {
+    constructor() {
+        super(...arguments);
+        this.injectedArgs = [];
+    }
+    set args(args) {
+        if (args == null || !Array.isArray(args) || (args.length === 1 && args[0] === null))
+            return;
+        this.injected = false;
+        this.injectedArgs = args;
+        this.createView();
+    }
+    get args() {
+        if (this.validate()) {
+            this.injected = true;
+            return this.injectedArgs;
+        }
+        return null;
+    }
+    validate() {
+        return !this.injected && !!this.injectedArgs.length;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtArgs, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgtArgs, isStandalone: true, selector: "[args]", inputs: { args: "args" }, usesInheritance: true, ngImport: i0 }); }
+}
+export { NgtArgs };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtArgs, decorators: [{
+            type: Directive,
+            args: [{ selector: '[args]', standalone: true }]
+        }], propDecorators: { args: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/common.mjs

@@ -0,0 +1,32 @@
+import { Directive, inject, TemplateRef, ViewContainerRef } from '@angular/core';
+import { safeDetectChanges } from '../utils/safe-detect-changes';
+import * as i0 from "@angular/core";
+class NgtCommonDirective {
+    constructor() {
+        this.vcr = inject(ViewContainerRef);
+        this.template = inject(TemplateRef);
+        this.injected = false;
+        this.shouldCreateView = true;
+        const commentNode = this.vcr.element.nativeElement;
+        if (commentNode['__ngt_renderer_add_comment__']) {
+            commentNode['__ngt_renderer_add_comment__']();
+            delete commentNode['__ngt_renderer_add_comment__'];
+        }
+    }
+    createView() {
+        if (this.shouldCreateView) {
+            if (this.view && !this.view.destroyed) {
+                this.view.destroy();
+            }
+            this.view = this.vcr.createEmbeddedView(this.template);
+            safeDetectChanges(this.view);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtCommonDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgtCommonDirective, ngImport: i0 }); }
+}
+export { NgtCommonDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtCommonDirective, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyLXRocmVlL3NyYy9saWIvZGlyZWN0aXZlcy9jb21tb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBbUIsTUFBTSxFQUFFLFdBQVcsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNsRyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQzs7QUFFakUsTUFDc0Isa0JBQWtCO0lBUXBDO1FBUG1CLFFBQUcsR0FBRyxNQUFNLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztRQUMvQixhQUFRLEdBQUcsTUFBTSxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBRXhDLGFBQVEsR0FBRyxLQUFLLENBQUM7UUFDakIscUJBQWdCLEdBQUcsSUFBSSxDQUFDO1FBSTlCLE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLGFBQWEsQ0FBQztRQUNuRCxJQUFJLFdBQVcsQ0FBQyw4QkFBOEIsQ0FBQyxFQUFFO1lBQzdDLFdBQVcsQ0FBQyw4QkFBOEIsQ0FBQyxFQUFFLENBQUM7WUFDOUMsT0FBTyxXQUFXLENBQUMsOEJBQThCLENBQUMsQ0FBQztTQUN0RDtJQUNMLENBQUM7SUFJUyxVQUFVO1FBQ2hCLElBQUksSUFBSSxDQUFDLGdCQUFnQixFQUFFO1lBQ3ZCLElBQUksSUFBSSxDQUFDLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUFFO2dCQUNuQyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO2FBQ3ZCO1lBQ0QsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLGtCQUFrQixDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztZQUN2RCxpQkFBaUIsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7U0FDaEM7SUFDTCxDQUFDOzhHQTFCaUIsa0JBQWtCO2tHQUFsQixrQkFBa0I7O1NBQWxCLGtCQUFrQjsyRkFBbEIsa0JBQWtCO2tCQUR2QyxTQUFTIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBFbWJlZGRlZFZpZXdSZWYsIGluamVjdCwgVGVtcGxhdGVSZWYsIFZpZXdDb250YWluZXJSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IHNhZmVEZXRlY3RDaGFuZ2VzIH0gZnJvbSAnLi4vdXRpbHMvc2FmZS1kZXRlY3QtY2hhbmdlcyc7XG5cbkBEaXJlY3RpdmUoKVxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIE5ndENvbW1vbkRpcmVjdGl2ZSB7XG4gICAgcHJvdGVjdGVkIHJlYWRvbmx5IHZjciA9IGluamVjdChWaWV3Q29udGFpbmVyUmVmKTtcbiAgICBwcm90ZWN0ZWQgcmVhZG9ubHkgdGVtcGxhdGUgPSBpbmplY3QoVGVtcGxhdGVSZWYpO1xuXG4gICAgcHJvdGVjdGVkIGluamVjdGVkID0gZmFsc2U7XG4gICAgcHJvdGVjdGVkIHNob3VsZENyZWF0ZVZpZXcgPSB0cnVlO1xuICAgIHByaXZhdGUgdmlldz86IEVtYmVkZGVkVmlld1JlZjx1bmtub3duPjtcblxuICAgIGNvbnN0cnVjdG9yKCkge1xuICAgICAgICBjb25zdCBjb21tZW50Tm9kZSA9IHRoaXMudmNyLmVsZW1lbnQubmF0aXZlRWxlbWVudDtcbiAgICAgICAgaWYgKGNvbW1lbnROb2RlWydfX25ndF9yZW5kZXJlcl9hZGRfY29tbWVudF9fJ10pIHtcbiAgICAgICAgICAgIGNvbW1lbnROb2RlWydfX25ndF9yZW5kZXJlcl9hZGRfY29tbWVudF9fJ10oKTtcbiAgICAgICAgICAgIGRlbGV0ZSBjb21tZW50Tm9kZVsnX19uZ3RfcmVuZGVyZXJfYWRkX2NvbW1lbnRfXyddO1xuICAgICAgICB9XG4gICAgfVxuXG4gICAgYWJzdHJhY3QgdmFsaWRhdGUoKTogYm9vbGVhbjtcblxuICAgIHByb3RlY3RlZCBjcmVhdGVWaWV3KCkge1xuICAgICAgICBpZiAodGhpcy5zaG91bGRDcmVhdGVWaWV3KSB7XG4gICAgICAgICAgICBpZiAodGhpcy52aWV3ICYmICF0aGlzLnZpZXcuZGVzdHJveWVkKSB7XG4gICAgICAgICAgICAgICAgdGhpcy52aWV3LmRlc3Ryb3koKTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgICAgIHRoaXMudmlldyA9IHRoaXMudmNyLmNyZWF0ZUVtYmVkZGVkVmlldyh0aGlzLnRlbXBsYXRlKTtcbiAgICAgICAgICAgIHNhZmVEZXRlY3RDaGFuZ2VzKHRoaXMudmlldyk7XG4gICAgICAgIH1cbiAgICB9XG59XG4iXX0=

package/esm2022/lib/directives/parent.mjs

@@ -0,0 +1,36 @@
+import { Directive, Input } from '@angular/core';
+import { NgtCommonDirective } from './common';
+import * as i0 from "@angular/core";
+class NgtParent extends NgtCommonDirective {
+    constructor() {
+        super(...arguments);
+        this.injectedParent = null;
+    }
+    set parent(parent) {
+        if (!parent)
+            return;
+        this.injected = false;
+        this.injectedParent = parent;
+        this.createView();
+    }
+    get parent() {
+        if (this.validate()) {
+            this.injected = true;
+            return this.injectedParent;
+        }
+        return null;
+    }
+    validate() {
+        return !this.injected && !!this.injectedParent;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtParent, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgtParent, isStandalone: true, selector: "[parent]", inputs: { parent: "parent" }, usesInheritance: true, ngImport: i0 }); }
+}
+export { NgtParent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtParent, decorators: [{
+            type: Directive,
+            args: [{ selector: '[parent]', standalone: true }]
+        }], propDecorators: { parent: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/repeat.mjs

@@ -0,0 +1,18 @@
+import { NgForOf } from '@angular/common';
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+class NgtRepeat extends NgForOf {
+    set ngForRepeat(count) {
+        this.ngForOf = Number.isInteger(count) ? Array.from({ length: count }, (_, i) => i) : [];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtRepeat, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgtRepeat, isStandalone: true, selector: "[ngFor][ngForRepeat]", inputs: { ngForRepeat: "ngForRepeat" }, usesInheritance: true, ngImport: i0 }); }
+}
+export { NgtRepeat };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtRepeat, decorators: [{
+            type: Directive,
+            args: [{ selector: '[ngFor][ngForRepeat]', standalone: true }]
+        }], propDecorators: { ngForRepeat: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVwZWF0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyLXRocmVlL3NyYy9saWIvZGlyZWN0aXZlcy9yZXBlYXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQzFDLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUVqRCxNQUNhLFNBQVUsU0FBUSxPQUFlO0lBQzFDLElBQWEsV0FBVyxDQUFDLEtBQWE7UUFDbEMsSUFBSSxDQUFDLE9BQU8sR0FBRyxNQUFNLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztJQUM3RixDQUFDOzhHQUhRLFNBQVM7a0dBQVQsU0FBUzs7U0FBVCxTQUFTOzJGQUFULFNBQVM7a0JBRHJCLFNBQVM7bUJBQUMsRUFBRSxRQUFRLEVBQUUsc0JBQXNCLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRTs4QkFFaEQsV0FBVztzQkFBdkIsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nRm9yT2YgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgRGlyZWN0aXZlLCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ARGlyZWN0aXZlKHsgc2VsZWN0b3I6ICdbbmdGb3JdW25nRm9yUmVwZWF0XScsIHN0YW5kYWxvbmU6IHRydWUgfSlcbmV4cG9ydCBjbGFzcyBOZ3RSZXBlYXQgZXh0ZW5kcyBOZ0Zvck9mPG51bWJlcj4ge1xuICAgIEBJbnB1dCgpIHNldCBuZ0ZvclJlcGVhdChjb3VudDogbnVtYmVyKSB7XG4gICAgICAgIHRoaXMubmdGb3JPZiA9IE51bWJlci5pc0ludGVnZXIoY291bnQpID8gQXJyYXkuZnJvbSh7IGxlbmd0aDogY291bnQgfSwgKF8sIGkpID0+IGkpIDogW107XG4gICAgfVxufVxuIl19

package/esm2022/lib/loader.mjs

@@ -0,0 +1,55 @@
+import { ChangeDetectorRef, inject } from '@angular/core';
+import { ReplaySubject, catchError, forkJoin, from, isObservable, map, of, retry, share, switchMap, take, tap, } from 'rxjs';
+import { makeObjectGraph } from './utils/make';
+import { safeDetectChanges } from './utils/safe-detect-changes';
+const cached = new Map();
+function load(loaderConstructorFactory, input, extensions, onProgress) {
+    const urls$ = isObservable(input) ? input : of(input);
+    return urls$.pipe(map((inputs) => {
+        const loaderConstructor = loaderConstructorFactory(inputs);
+        const loader = new loaderConstructor();
+        if (extensions)
+            extensions(loader);
+        const urls = Array.isArray(inputs) ? inputs : typeof inputs === 'string' ? [inputs] : Object.values(inputs);
+        return [
+            urls.map((url) => {
+                if (!cached.has(url)) {
+                    cached.set(url, from(loader.loadAsync(url, onProgress)).pipe(tap((data) => {
+                        if (data['scene'])
+                            Object.assign(data, makeObjectGraph(data['scene']));
+                    }), retry(2), catchError((err) => {
+                        console.error(`[NGT] Error loading ${url}: ${err.message}`);
+                        return of([]);
+                    }), share({ connector: () => new ReplaySubject(1) })));
+                }
+                return cached.get(url);
+            }),
+            inputs,
+        ];
+    }));
+}
+export function injectNgtLoader(loaderConstructorFactory, input, extensions, onProgress) {
+    const cdr = inject(ChangeDetectorRef);
+    return load(loaderConstructorFactory, input, extensions, onProgress).pipe(switchMap(([observables$, inputs]) => {
+        return forkJoin(observables$).pipe(map((results) => {
+            if (Array.isArray(inputs))
+                return results;
+            if (typeof inputs === 'string')
+                return results[0];
+            const keys = Object.keys(inputs);
+            return keys.reduce((result, key) => {
+                result[key] = results[keys.indexOf(key)];
+                return result;
+            }, {});
+        }), tap(() => {
+            requestAnimationFrame(() => void safeDetectChanges(cdr));
+        }));
+    }));
+}
+injectNgtLoader['destroy'] = () => {
+    cached.clear();
+};
+injectNgtLoader['preLoad'] = (loaderConstructorFactory, inputs, extensions) => {
+    load(loaderConstructorFactory, inputs, extensions).pipe(take(1)).subscribe();
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loader.js","sourceRoot":"","sources":["../../../../../libs/angular-three/src/lib/loader.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, inject } from '@angular/core';\nimport {\n    ReplaySubject,\n    catchError,\n    forkJoin,\n    from,\n    isObservable,\n    map,\n    of,\n    retry,\n    share,\n    switchMap,\n    take,\n    tap,\n    type Observable,\n} from 'rxjs';\nimport type { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';\nimport type {\n    NgtAnyRecord,\n    NgtBranchingReturn,\n    NgtLoaderExtensions,\n    NgtLoaderProto,\n    NgtLoaderReturnType,\n    NgtObjectMap,\n} from './types';\nimport { makeObjectGraph } from './utils/make';\nimport { safeDetectChanges } from './utils/safe-detect-changes';\n\nexport type NgtLoaderResults<\n    TInput extends string | string[] | Record<string, string>,\n    TReturn\n> = TInput extends string[] ? TReturn[] : TInput extends object ? { [key in keyof TInput]: TReturn } : TReturn;\n\nconst cached = new Map<string, Observable<any>>();\n\nfunction load<\n    TData,\n    TUrl extends string | string[] | Record<string, string>,\n    TLoaderConstructor extends NgtLoaderProto<TData>\n>(\n    loaderConstructorFactory: (inputs: TUrl) => TLoaderConstructor,\n    input: TUrl | Observable<TUrl>,\n    extensions?: NgtLoaderExtensions<TLoaderConstructor>,\n    onProgress?: (event: ProgressEvent) => void\n) {\n    const urls$ = isObservable(input) ? input : of(input);\n    return urls$.pipe(\n        map((inputs) => {\n            const loaderConstructor = loaderConstructorFactory(inputs);\n            const loader = new loaderConstructor();\n            if (extensions) extensions(loader);\n            const urls = Array.isArray(inputs) ? inputs : typeof inputs === 'string' ? [inputs] : Object.values(inputs);\n            return [\n                urls.map((url) => {\n                    if (!cached.has(url)) {\n                        cached.set(\n                            url,\n                            from(loader.loadAsync(url, onProgress)).pipe(\n                                tap((data) => {\n                                    if ((data as NgtAnyRecord)['scene'])\n                                        Object.assign(\n                                            data as NgtAnyRecord,\n                                            makeObjectGraph((data as NgtAnyRecord)['scene'])\n                                        );\n                                }),\n                                retry(2),\n                                catchError((err) => {\n                                    console.error(`[NGT] Error loading ${url}: ${err.message}`);\n                                    return of([]);\n                                }),\n                                share({ connector: () => new ReplaySubject(1) })\n                            )\n                        );\n                    }\n                    return cached.get(url);\n                }),\n                inputs,\n            ] as [Array<Observable<any>>, TUrl | TUrl[]];\n        })\n    );\n}\n\nexport function injectNgtLoader<\n    TData,\n    TUrl extends string | string[] | Record<string, string>,\n    TLoaderConstructor extends NgtLoaderProto<TData>,\n    TReturn = NgtLoaderReturnType<TData, TLoaderConstructor>\n>(\n    loaderConstructorFactory: (inputs: TUrl) => TLoaderConstructor,\n    input: TUrl | Observable<TUrl>,\n    extensions?: NgtLoaderExtensions<TLoaderConstructor>,\n    onProgress?: (event: ProgressEvent) => void\n): Observable<NgtLoaderResults<TUrl, NgtBranchingReturn<TReturn, GLTF, GLTF & NgtObjectMap>>> {\n    const cdr = inject(ChangeDetectorRef);\n\n    return load(loaderConstructorFactory, input, extensions, onProgress).pipe(\n        switchMap(([observables$, inputs]) => {\n            return forkJoin(observables$).pipe(\n                map((results) => {\n                    if (Array.isArray(inputs)) return results;\n                    if (typeof inputs === 'string') return results[0];\n                    const keys = Object.keys(inputs);\n                    return keys.reduce((result, key) => {\n                        result[key as keyof typeof result] = results[keys.indexOf(key)];\n                        return result;\n                    }, {} as { [key in keyof TUrl]: NgtBranchingReturn<TReturn, GLTF, GLTF & NgtObjectMap> });\n                }),\n                tap(() => {\n                    requestAnimationFrame(() => void safeDetectChanges(cdr));\n                })\n            );\n        })\n    );\n}\n\ninjectNgtLoader['destroy'] = () => {\n    cached.clear();\n};\n\ninjectNgtLoader['preLoad'] = <\n    TData,\n    TUrl extends string | string[] | Record<string, string>,\n    TLoaderConstructor extends NgtLoaderProto<TData>\n>(\n    loaderConstructorFactory: (inputs: TUrl) => TLoaderConstructor,\n    inputs: TUrl | Observable<TUrl>,\n    extensions?: NgtLoaderExtensions<TLoaderConstructor>\n) => {\n    load(loaderConstructorFactory, inputs, extensions).pipe(take(1)).subscribe();\n};\n"]}

package/esm2022/lib/pipes/push.mjs

@@ -0,0 +1,50 @@
+import { ChangeDetectorRef, EnvironmentInjector, inject, Pipe } from '@angular/core';
+import { isObservable } from 'rxjs';
+import { safeDetectChanges } from '../utils/safe-detect-changes';
+import * as i0 from "@angular/core";
+function isPromise(value) {
+    return ((value instanceof Promise || Object.prototype.toString.call(value) === '[object Promise]') &&
+        typeof value['then'] === 'function');
+}
+class NgtPush {
+    constructor() {
+        this.cdr = inject(ChangeDetectorRef);
+        this.parentCdr = inject(ChangeDetectorRef, { skipSelf: true, optional: true });
+        this.envCdr = inject(EnvironmentInjector).get(ChangeDetectorRef, null);
+    }
+    transform(value, defaultValue = null) {
+        if (this.obj === value)
+            return this.latestValue;
+        this.obj = value;
+        this.latestValue = defaultValue;
+        if (this.sub)
+            this.sub.unsubscribe();
+        if (isObservable(this.obj))
+            this.sub = this.obj.subscribe(this.updateValue.bind(this));
+        else if (isPromise(this.obj))
+            this.obj.then(this.updateValue.bind(this));
+        else
+            throw new Error(`[NGT] Invalid value passed to ngtPush pipe`);
+        return this.latestValue;
+    }
+    updateValue(val) {
+        this.latestValue = val;
+        safeDetectChanges(this.cdr);
+        safeDetectChanges(this.parentCdr);
+        safeDetectChanges(this.envCdr);
+    }
+    ngOnDestroy() {
+        if (this.sub)
+            this.sub.unsubscribe();
+        this.latestValue = undefined;
+        this.obj = undefined;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtPush, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: NgtPush, isStandalone: true, name: "ngtPush", pure: false }); }
+}
+export { NgtPush };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtPush, decorators: [{
+            type: Pipe,
+            args: [{ name: 'ngtPush', pure: false, standalone: true }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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