angular-three 2.0.0-beta.9 → 2.1.0

package/esm2022/nativescript/lib/canvas.mjs

@@ -0,0 +1,127 @@
+import '@nativescript/canvas-three';
+import { DOCUMENT } from '@angular/common';
+import { booleanAttribute, ChangeDetectionStrategy, Component, createEnvironmentInjector, DestroyRef, EnvironmentInjector, inject, Injector, input, NgZone, NO_ERRORS_SCHEMA, output, untracked, viewChild, ViewContainerRef, } from '@angular/core';
+import { registerElement } from '@nativescript/angular';
+import { Canvas } from '@nativescript/canvas';
+import { injectCanvasRootInitializer, injectStore, makeDpr, NgtRoutedScene, provideNgtRenderer, provideStore, } from 'angular-three';
+import { WebGLRenderer } from 'three';
+import * as i0 from "@angular/core";
+registerElement('Canvas', () => Canvas);
+export class NgtCanvasNative {
+    constructor() {
+        this.sceneGraph = input.required({
+            transform: (value) => {
+                if (value === 'routed')
+                    return NgtRoutedScene;
+                return value;
+            },
+        });
+        this.gl = input();
+        this.size = input();
+        this.shadows = input(false, {
+            transform: (value) => {
+                if (value === '')
+                    return booleanAttribute(value);
+                return value;
+            },
+        });
+        this.legacy = input(false, { transform: booleanAttribute });
+        this.linear = input(false, { transform: booleanAttribute });
+        this.flat = input(false, { transform: booleanAttribute });
+        this.orthographic = input(false, { transform: booleanAttribute });
+        this.frameloop = input('always');
+        this.performance = input();
+        this.dpr = input([1, 2]);
+        this.raycaster = input();
+        this.scene = input();
+        this.camera = input();
+        this.lookAt = input();
+        this.created = output();
+        this.store = injectStore();
+        this.initRoot = injectCanvasRootInitializer();
+        this.injector = inject(Injector);
+        this.environmentInjector = inject(EnvironmentInjector);
+        this.destroyRef = inject(DestroyRef);
+        this.zone = inject(NgZone);
+        this.canvasViewContainerRef = viewChild.required('canvas', { read: ViewContainerRef });
+        this.destroyRef.onDestroy(() => {
+            this.glRef?.destroy();
+            this.glEnvironmentInjector?.destroy();
+            this.configurator?.destroy();
+        });
+    }
+    onReady(event) {
+        const canvas = event.object;
+        const dpr = makeDpr(untracked(this.dpr), window);
+        const canvasWidth = canvas.clientWidth * dpr;
+        const canvasHeight = canvas.clientHeight * dpr;
+        Object.assign(canvas, { width: canvasWidth, height: canvasHeight });
+        const context = canvas.getContext('webgl2');
+        const gl = new WebGLRenderer({
+            canvas,
+            context: context,
+            powerPreference: 'high-performance',
+            antialias: true,
+            alpha: true,
+            ...untracked(this.gl),
+        });
+        gl.setSize(canvasWidth, canvasHeight);
+        this.zone.runOutsideAngular(() => {
+            this.configurator = this.initRoot(canvas);
+            this.configurator.configure({
+                gl,
+                size: { width: canvasWidth, height: canvasHeight, top: 0, left: 0 },
+                shadows: untracked(this.shadows),
+                legacy: untracked(this.legacy),
+                linear: untracked(this.linear),
+                flat: untracked(this.flat),
+                orthographic: untracked(this.orthographic),
+                frameloop: untracked(this.frameloop),
+                performance: untracked(this.performance),
+                dpr: untracked(this.dpr),
+                raycaster: untracked(this.raycaster),
+                scene: untracked(this.scene),
+                camera: untracked(this.camera),
+                lookAt: untracked(this.lookAt),
+            });
+            untracked(this.noZoneRender.bind(this));
+        });
+    }
+    noZoneRender() {
+        // NOTE: destroy previous instances if existed
+        this.glEnvironmentInjector?.destroy();
+        this.glRef?.destroy();
+        // NOTE: Flag the canvas active, rendering will now begin
+        this.store.update((state) => ({ internal: { ...state.internal, active: true } }));
+        // emit created event if observed
+        this.created.emit(this.store.snapshot);
+        this.glEnvironmentInjector = createEnvironmentInjector([{ provide: DOCUMENT, useValue: document }, provideNgtRenderer(this.store)], this.environmentInjector);
+        this.glRef = untracked(this.canvasViewContainerRef).createComponent(untracked(this.sceneGraph), {
+            environmentInjector: this.glEnvironmentInjector,
+            injector: this.injector,
+        });
+        this.glRef.changeDetectorRef.detectChanges();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtCanvasNative, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.0", type: NgtCanvasNative, isStandalone: true, selector: "NgtCanvas", inputs: { sceneGraph: { classPropertyName: "sceneGraph", publicName: "sceneGraph", isSignal: true, isRequired: true, transformFunction: null }, gl: { classPropertyName: "gl", publicName: "gl", isSignal: true, isRequired: false, transformFunction: null }, size: { classPropertyName: "size", publicName: "size", isSignal: true, isRequired: false, transformFunction: null }, shadows: { classPropertyName: "shadows", publicName: "shadows", isSignal: true, isRequired: false, transformFunction: null }, legacy: { classPropertyName: "legacy", publicName: "legacy", isSignal: true, isRequired: false, transformFunction: null }, linear: { classPropertyName: "linear", publicName: "linear", isSignal: true, isRequired: false, transformFunction: null }, flat: { classPropertyName: "flat", publicName: "flat", isSignal: true, isRequired: false, transformFunction: null }, orthographic: { classPropertyName: "orthographic", publicName: "orthographic", isSignal: true, isRequired: false, transformFunction: null }, frameloop: { classPropertyName: "frameloop", publicName: "frameloop", isSignal: true, isRequired: false, transformFunction: null }, performance: { classPropertyName: "performance", publicName: "performance", isSignal: true, isRequired: false, transformFunction: null }, dpr: { classPropertyName: "dpr", publicName: "dpr", isSignal: true, isRequired: false, transformFunction: null }, raycaster: { classPropertyName: "raycaster", publicName: "raycaster", isSignal: true, isRequired: false, transformFunction: null }, scene: { classPropertyName: "scene", publicName: "scene", isSignal: true, isRequired: false, transformFunction: null }, camera: { classPropertyName: "camera", publicName: "camera", isSignal: true, isRequired: false, transformFunction: null }, lookAt: { classPropertyName: "lookAt", publicName: "lookAt", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { created: "created" }, providers: [{ provide: DOCUMENT, useValue: document }, provideStore()], viewQueries: [{ propertyName: "canvasViewContainerRef", first: true, predicate: ["canvas"], descendants: true, read: ViewContainerRef, isSignal: true }], ngImport: i0, template: `
+		<GridLayout>
+			<Canvas #canvas style="width: 100%; height: auto" (ready)="onReady($event)"></Canvas>
+		</GridLayout>
+	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtCanvasNative, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'NgtCanvas',
+                    standalone: true,
+                    template: `
+		<GridLayout>
+			<Canvas #canvas style="width: 100%; height: auto" (ready)="onReady($event)"></Canvas>
+		</GridLayout>
+	`,
+                    providers: [{ provide: DOCUMENT, useValue: document }, provideStore()],
+                    schemas: [NO_ERRORS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"canvas.js","sourceRoot":"","sources":["../../../../../../libs/core/nativescript/src/lib/canvas.ts"],"names":[],"mappings":"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","sourcesContent":["import '@nativescript/canvas-three';\n\nimport { DOCUMENT } from '@angular/common';\nimport {\n\tbooleanAttribute,\n\tChangeDetectionStrategy,\n\tComponent,\n\tComponentRef,\n\tcreateEnvironmentInjector,\n\tDestroyRef,\n\tEnvironmentInjector,\n\tinject,\n\tInjector,\n\tinput,\n\tNgZone,\n\tNO_ERRORS_SCHEMA,\n\toutput,\n\tType,\n\tuntracked,\n\tviewChild,\n\tViewContainerRef,\n} from '@angular/core';\nimport { registerElement } from '@nativescript/angular';\nimport { Canvas } from '@nativescript/canvas';\nimport {\n\tinjectCanvasRootInitializer,\n\tinjectStore,\n\tmakeDpr,\n\tNgtCanvasConfigurator,\n\tNgtCanvasOptions,\n\tNgtDpr,\n\tNgtGLOptions,\n\tNgtPerformance,\n\tNgtRoutedScene,\n\tNgtSize,\n\tNgtState,\n\tprovideNgtRenderer,\n\tprovideStore,\n} from 'angular-three';\nimport { Raycaster, Scene, Vector3, WebGLRenderer } from 'three';\n\nregisterElement('Canvas', () => Canvas);\n\n@Component({\n\tselector: 'NgtCanvas',\n\tstandalone: true,\n\ttemplate: `\n\t\t<GridLayout>\n\t\t\t<Canvas #canvas style=\"width: 100%; height: auto\" (ready)=\"onReady($event)\"></Canvas>\n\t\t</GridLayout>\n\t`,\n\tproviders: [{ provide: DOCUMENT, useValue: document }, provideStore()],\n\tschemas: [NO_ERRORS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtCanvasNative {\n\tsceneGraph = input.required<Type<any>, Type<any> | 'routed'>({\n\t\ttransform: (value) => {\n\t\t\tif (value === 'routed') return NgtRoutedScene;\n\t\t\treturn value;\n\t\t},\n\t});\n\tgl = input<NgtGLOptions>();\n\tsize = input<NgtSize>();\n\tshadows = input(false, {\n\t\ttransform: (value) => {\n\t\t\tif (value === '') return booleanAttribute(value);\n\t\t\treturn value as NonNullable<NgtCanvasOptions['shadows']>;\n\t\t},\n\t});\n\tlegacy = input(false, { transform: booleanAttribute });\n\tlinear = input(false, { transform: booleanAttribute });\n\tflat = input(false, { transform: booleanAttribute });\n\torthographic = input(false, { transform: booleanAttribute });\n\tframeloop = input<NonNullable<NgtCanvasOptions['frameloop']>>('always');\n\tperformance = input<Partial<Omit<NgtPerformance, 'regress'>>>();\n\tdpr = input<NgtDpr>([1, 2]);\n\traycaster = input<Partial<Raycaster>>();\n\tscene = input<Scene | Partial<Scene>>();\n\tcamera = input<NonNullable<NgtCanvasOptions['camera']>>();\n\tlookAt = input<Vector3 | Parameters<Vector3['set']>>();\n\tcreated = output<NgtState>();\n\n\tprivate store = injectStore();\n\tprivate initRoot = injectCanvasRootInitializer();\n\tprivate injector = inject(Injector);\n\tprivate environmentInjector = inject(EnvironmentInjector);\n\tprivate destroyRef = inject(DestroyRef);\n\tprivate zone = inject(NgZone);\n\n\tprivate canvasViewContainerRef = viewChild.required('canvas', { read: ViewContainerRef });\n\n\tprivate configurator?: NgtCanvasConfigurator;\n\tprivate glEnvironmentInjector?: EnvironmentInjector;\n\tprivate glRef?: ComponentRef<any>;\n\n\tconstructor() {\n\t\tthis.destroyRef.onDestroy(() => {\n\t\t\tthis.glRef?.destroy();\n\t\t\tthis.glEnvironmentInjector?.destroy();\n\t\t\tthis.configurator?.destroy();\n\t\t});\n\t}\n\n\tonReady(event: any) {\n\t\tconst canvas = event.object;\n\t\tconst dpr = makeDpr(untracked(this.dpr), window);\n\t\tconst canvasWidth = canvas.clientWidth * dpr;\n\t\tconst canvasHeight = canvas.clientHeight * dpr;\n\t\tObject.assign(canvas, { width: canvasWidth, height: canvasHeight });\n\n\t\tconst context = canvas.getContext('webgl2');\n\t\tconst gl = new WebGLRenderer({\n\t\t\tcanvas,\n\t\t\tcontext: context as unknown as WebGLRenderingContext,\n\t\t\tpowerPreference: 'high-performance',\n\t\t\tantialias: true,\n\t\t\talpha: true,\n\t\t\t...untracked(this.gl),\n\t\t});\n\t\tgl.setSize(canvasWidth, canvasHeight);\n\n\t\tthis.zone.runOutsideAngular(() => {\n\t\t\tthis.configurator = this.initRoot(canvas);\n\t\t\tthis.configurator.configure({\n\t\t\t\tgl,\n\t\t\t\tsize: { width: canvasWidth, height: canvasHeight, top: 0, left: 0 },\n\t\t\t\tshadows: untracked(this.shadows),\n\t\t\t\tlegacy: untracked(this.legacy),\n\t\t\t\tlinear: untracked(this.linear),\n\t\t\t\tflat: untracked(this.flat),\n\t\t\t\torthographic: untracked(this.orthographic),\n\t\t\t\tframeloop: untracked(this.frameloop),\n\t\t\t\tperformance: untracked(this.performance),\n\t\t\t\tdpr: untracked(this.dpr),\n\t\t\t\traycaster: untracked(this.raycaster),\n\t\t\t\tscene: untracked(this.scene),\n\t\t\t\tcamera: untracked(this.camera),\n\t\t\t\tlookAt: untracked(this.lookAt),\n\t\t\t});\n\t\t\tuntracked(this.noZoneRender.bind(this));\n\t\t});\n\t}\n\n\tprivate noZoneRender() {\n\t\t// NOTE: destroy previous instances if existed\n\t\tthis.glEnvironmentInjector?.destroy();\n\t\tthis.glRef?.destroy();\n\n\t\t// NOTE: Flag the canvas active, rendering will now begin\n\t\tthis.store.update((state) => ({ internal: { ...state.internal, active: true } }));\n\n\t\t// emit created event if observed\n\t\tthis.created.emit(this.store.snapshot);\n\n\t\tthis.glEnvironmentInjector = createEnvironmentInjector(\n\t\t\t[{ provide: DOCUMENT, useValue: document }, provideNgtRenderer(this.store)],\n\t\t\tthis.environmentInjector,\n\t\t);\n\t\tthis.glRef = untracked(this.canvasViewContainerRef).createComponent(untracked(this.sceneGraph), {\n\t\t\tenvironmentInjector: this.glEnvironmentInjector,\n\t\t\tinjector: this.injector,\n\t\t});\n\n\t\tthis.glRef.changeDetectorRef.detectChanges();\n\t}\n}\n"]}

package/esm2022/testing/angular-three-testing.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS10ZXN0aW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9jb3JlL3Rlc3Rpbmcvc3JjL2FuZ3VsYXItdGhyZWUtdGVzdGluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2022/testing/index.mjs

@@ -0,0 +1,3 @@
+export * from './lib/test-bed';
+export * from './lib/test-canvas';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2NvcmUvdGVzdGluZy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLG1CQUFtQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9saWIvdGVzdC1iZWQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdGVzdC1jYW52YXMnO1xuIl19

package/esm2022/testing/lib/test-bed.mjs

@@ -0,0 +1,130 @@
+import { CUSTOM_ELEMENTS_SCHEMA, ENVIRONMENT_INITIALIZER } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { getLocalState, injectCanvasRootInitializer, NGT_STORE, provideStore, } from 'angular-three';
+import { NgtTestCanvas } from './test-canvas';
+import { createMockCanvas } from './utils/mock-canvas';
+export class NgtTestBed {
+    static create(sceneGraph, { mockCanvasOptions = {}, canvasConfiguration = {}, errorOnUnknownElements, providers, declarations, imports, teardown, deferBlockBehavior, } = {}) {
+        const mockedCanvas = createMockCanvas(mockCanvasOptions);
+        const fixture = TestBed.configureTestingModule({
+            providers: [
+                provideStore(),
+                {
+                    provide: ENVIRONMENT_INITIALIZER,
+                    useFactory: () => {
+                        const initRoot = injectCanvasRootInitializer();
+                        return () => {
+                            const configurator = initRoot(mockedCanvas);
+                            configurator.configure({
+                                frameloop: 'never',
+                                size: {
+                                    width: mockCanvasOptions.width ?? 1280,
+                                    height: mockCanvasOptions.height ?? 800,
+                                    top: 0,
+                                    left: 0,
+                                },
+                                ...canvasConfiguration,
+                                events: undefined,
+                            });
+                        };
+                    },
+                    multi: true,
+                },
+                ...(providers ?? []),
+            ],
+            schemas: [CUSTOM_ELEMENTS_SCHEMA],
+            errorOnUnknownElements: errorOnUnknownElements ?? false,
+            declarations,
+            imports,
+            teardown,
+            deferBlockBehavior,
+        }).createComponent(NgtTestCanvas);
+        fixture.componentRef.setInput('sceneGraph', sceneGraph);
+        fixture.detectChanges();
+        const store = TestBed.inject(NGT_STORE);
+        TestBed.flushEffects();
+        return {
+            store,
+            fixture,
+            scene: store.snapshot.scene,
+            sceneInstanceNode: getLocalState(store.snapshot.scene),
+            canvas: mockedCanvas,
+            destroy: fixture.componentInstance.destroy.bind(fixture.componentInstance),
+            fireEvent: this.createEventFirer(store, fixture),
+            advance: this.createAdvance(store),
+            toGraph: this.createToGraph(store),
+        };
+    }
+    static createToGraph(store) {
+        function graphify(type, name, children) {
+            return { type, name, children };
+        }
+        function toGraph(node) {
+            return node.children.map((child) => graphify(child.type, child.name || '', toGraph(child)));
+        }
+        return () => {
+            const state = store.snapshot;
+            return toGraph(state.scene);
+        };
+    }
+    static createAdvance(store) {
+        return async (frames, delta = 1) => {
+            const state = store.snapshot;
+            const subscribers = state.internal.subscribers;
+            const promises = [];
+            for (const subscriber of subscribers) {
+                for (let i = 0; i < frames; i++) {
+                    if (Array.isArray(delta)) {
+                        promises.push(new Promise((res) => {
+                            subscriber.callback({ ...state, delta: delta[i] || delta[-1] });
+                            res();
+                        }));
+                    }
+                    else {
+                        promises.push(new Promise((res) => {
+                            subscriber.callback({ ...state, delta });
+                            res();
+                        }));
+                    }
+                }
+            }
+            await Promise.all(promises);
+        };
+    }
+    static createEventFirer(store, fixture) {
+        let autoDetectChanges = true;
+        async function fireEvent(el, eventName, eventData = {}) {
+            const localState = getLocalState(el);
+            if (!localState) {
+                console.warn(`[NGT Test] ${el} has no local state`);
+                return;
+            }
+            const handler = localState.handlers[eventName];
+            if (!handler) {
+                console.warn(`[NGT Test] ${el} has no ${eventName} handler`);
+                return;
+            }
+            const raycastEvent = {
+                camera: store.snapshot.camera,
+                stopPropagation: () => { },
+                target: el,
+                currentTarget: el,
+                sourceEvent: eventData,
+                nativeEvent: eventData,
+                object: el,
+                eventObject: el,
+                ...eventData,
+            };
+            const result = await handler(raycastEvent);
+            if (autoDetectChanges) {
+                fixture.detectChanges();
+            }
+            return result;
+        }
+        fireEvent.setAutoDetectChanges = (auto) => {
+            autoDetectChanges = auto;
+        };
+        return fireEvent;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-bed.js","sourceRoot":"","sources":["../../../../../../libs/core/testing/src/lib/test-bed.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAQ,MAAM,eAAe,CAAC;AACtF,OAAO,EAAoB,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,EACN,aAAa,EACb,2BAA2B,EAC3B,SAAS,EAOT,YAAY,GACZ,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAQvD,MAAM,OAAO,UAAU;IACtB,MAAM,CAAC,MAAM,CACZ,UAAa,EACb,EACC,iBAAiB,GAAG,EAAE,EACtB,mBAAmB,GAAG,EAAE,EACxB,sBAAsB,EACtB,SAAS,EACT,YAAY,EACZ,OAAO,EACP,QAAQ,EACR,kBAAkB,MAIqD,EAAE;QAE1E,MAAM,YAAY,GAAG,gBAAgB,CAAC,iBAAiB,CAAC,CAAC;QAEzD,MAAM,OAAO,GAAG,OAAO,CAAC,sBAAsB,CAAC;YAC9C,SAAS,EAAE;gBACV,YAAY,EAAE;gBACd;oBACC,OAAO,EAAE,uBAAuB;oBAChC,UAAU,EAAE,GAAG,EAAE;wBAChB,MAAM,QAAQ,GAAG,2BAA2B,EAAE,CAAC;wBAE/C,OAAO,GAAG,EAAE;4BACX,MAAM,YAAY,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;4BAC5C,YAAY,CAAC,SAAS,CAAC;gCACtB,SAAS,EAAE,OAAO;gCAClB,IAAI,EAAE;oCACL,KAAK,EAAE,iBAAiB,CAAC,KAAK,IAAI,IAAI;oCACtC,MAAM,EAAE,iBAAiB,CAAC,MAAM,IAAI,GAAG;oCACvC,GAAG,EAAE,CAAC;oCACN,IAAI,EAAE,CAAC;iCACP;gCACD,GAAG,mBAAmB;gCACtB,MAAM,EAAE,SAAS;6BACjB,CAAC,CAAC;wBACJ,CAAC,CAAC;oBACH,CAAC;oBACD,KAAK,EAAE,IAAI;iBACX;gBACD,GAAG,CAAC,SAAS,IAAI,EAAE,CAAC;aACpB;YACD,OAAO,EAAE,CAAC,sBAAsB,CAAC;YACjC,sBAAsB,EAAE,sBAAsB,IAAI,KAAK;YACvD,YAAY;YACZ,OAAO;YACP,QAAQ;YACR,kBAAkB;SAClB,CAAC,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC;QAElC,OAAO,CAAC,YAAY,CAAC,QAAQ,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;QACxD,OAAO,CAAC,aAAa,EAAE,CAAC;QAExB,MAAM,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QAExC,OAAO,CAAC,YAAY,EAAE,CAAC;QAEvB,OAAO;YACN,KAAK;YACL,OAAO;YACP,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK;YAC3B,iBAAiB,EAAE,aAAa,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAE;YACvD,MAAM,EAAE,YAAY;YACpB,OAAO,EAAE,OAAO,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC;YAC1E,SAAS,EAAE,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC;YAChD,OAAO,EAAE,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC;YAClC,OAAO,EAAE,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC;SAClC,CAAC;IACH,CAAC;IAED,MAAM,CAAC,aAAa,CAAC,KAA+B;QACnD,SAAS,QAAQ,CAAC,IAAY,EAAE,IAAY,EAAE,QAAgC;YAC7E,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;QACjC,CAAC;QAED,SAAS,OAAO,CAAC,IAAc;YAC9B,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,EAAE,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC7F,CAAC;QAED,OAAO,GAAG,EAAE;YACX,MAAM,KAAK,GAAG,KAAK,CAAC,QAAQ,CAAC;YAC7B,OAAO,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC,CAAC;IACH,CAAC;IAED,MAAM,CAAC,aAAa,CAAC,KAA+B;QACnD,OAAO,KAAK,EAAE,MAAc,EAAE,QAA2B,CAAC,EAAE,EAAE;YAC7D,MAAM,KAAK,GAAG,KAAK,CAAC,QAAQ,CAAC;YAC7B,MAAM,WAAW,GAAG,KAAK,CAAC,QAAQ,CAAC,WAAW,CAAC;YAE/C,MAAM,QAAQ,GAAoB,EAAE,CAAC;YAErC,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE,CAAC;gBACtC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBACjC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;wBAC1B,QAAQ,CAAC,IAAI,CACZ,IAAI,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;4BACnB,UAAU,CAAC,QAAQ,CAAC,EAAE,GAAG,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;4BAChE,GAAG,EAAE,CAAC;wBACP,CAAC,CAAC,CACF,CAAC;oBACH,CAAC;yBAAM,CAAC;wBACP,QAAQ,CAAC,IAAI,CACZ,IAAI,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;4BACnB,UAAU,CAAC,QAAQ,CAAC,EAAE,GAAG,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;4BACzC,GAAG,EAAE,CAAC;wBACP,CAAC,CAAC,CACF,CAAC;oBACH,CAAC;gBACF,CAAC;YACF,CAAC;YAED,MAAM,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC7B,CAAC,CAAC;IACH,CAAC;IAED,MAAM,CAAC,gBAAgB,CAAC,KAA+B,EAAE,OAAwC;QAChG,IAAI,iBAAiB,GAAG,IAAI,CAAC;QAE7B,KAAK,UAAU,SAAS,CAAC,EAAmB,EAAE,SAAiC,EAAE,YAA0B,EAAE;YAC5G,MAAM,UAAU,GAAG,aAAa,CAAC,EAAE,CAAC,CAAC;YACrC,IAAI,CAAC,UAAU,EAAE,CAAC;gBACjB,OAAO,CAAC,IAAI,CAAC,cAAc,EAAE,qBAAqB,CAAC,CAAC;gBACpD,OAAO;YACR,CAAC;YAED,MAAM,OAAO,GAAG,UAAU,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;YAC/C,IAAI,CAAC,OAAO,EAAE,CAAC;gBACd,OAAO,CAAC,IAAI,CAAC,cAAc,EAAE,WAAW,SAAS,UAAU,CAAC,CAAC;gBAC7D,OAAO;YACR,CAAC;YAED,MAAM,YAAY,GAAG;gBACpB,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,MAAM;gBAC7B,eAAe,EAAE,GAAG,EAAE,GAAE,CAAC;gBACzB,MAAM,EAAE,EAAE;gBACV,aAAa,EAAE,EAAE;gBACjB,WAAW,EAAE,SAAS;gBACtB,WAAW,EAAE,SAAS;gBACtB,MAAM,EAAE,EAAE;gBACV,WAAW,EAAE,EAAE;gBACf,GAAG,SAAS;aACZ,CAAC;YAEF,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,YAAmB,CAAC,CAAC;YAElD,IAAI,iBAAiB,EAAE,CAAC;gBACvB,OAAO,CAAC,aAAa,EAAE,CAAC;YACzB,CAAC;YAED,OAAO,MAAM,CAAC;QACf,CAAC;QAED,SAAS,CAAC,oBAAoB,GAAG,CAAC,IAAa,EAAE,EAAE;YAClD,iBAAiB,GAAG,IAAI,CAAC;QAC1B,CAAC,CAAC;QAEF,OAAO,SAAS,CAAC;IAClB,CAAC;CACD","sourcesContent":["import { CUSTOM_ELEMENTS_SCHEMA, ENVIRONMENT_INITIALIZER, Type } from '@angular/core';\nimport { ComponentFixture, TestBed } from '@angular/core/testing';\nimport {\n\tgetLocalState,\n\tinjectCanvasRootInitializer,\n\tNGT_STORE,\n\tNgtAnyRecord,\n\tNgtCanvasOptions,\n\tNgtEventHandlers,\n\tNgtInstanceNode,\n\tNgtSignalStore,\n\tNgtState,\n\tprovideStore,\n} from 'angular-three';\nimport { Object3D } from 'three';\nimport { NgtTestCanvas } from './test-canvas';\nimport { createMockCanvas } from './utils/mock-canvas';\n\nexport interface NgtTestGraphedObject {\n\ttype: string;\n\tname: string;\n\tchildren: NgtTestGraphedObject[];\n}\n\nexport class NgtTestBed {\n\tstatic create<T extends Type<any>>(\n\t\tsceneGraph: T,\n\t\t{\n\t\t\tmockCanvasOptions = {},\n\t\t\tcanvasConfiguration = {},\n\t\t\terrorOnUnknownElements,\n\t\t\tproviders,\n\t\t\tdeclarations,\n\t\t\timports,\n\t\t\tteardown,\n\t\t\tdeferBlockBehavior,\n\t\t}: {\n\t\t\tmockCanvasOptions?: { width?: number; height?: number; beforeReturn?: (canvas: HTMLCanvasElement) => void };\n\t\t\tcanvasConfiguration?: Partial<Omit<NgtCanvasOptions, 'frameloop' | 'size' | 'events'>>;\n\t\t} & Omit<Parameters<TestBed['configureTestingModule']>[0], 'schemas'> = {},\n\t) {\n\t\tconst mockedCanvas = createMockCanvas(mockCanvasOptions);\n\n\t\tconst fixture = TestBed.configureTestingModule({\n\t\t\tproviders: [\n\t\t\t\tprovideStore(),\n\t\t\t\t{\n\t\t\t\t\tprovide: ENVIRONMENT_INITIALIZER,\n\t\t\t\t\tuseFactory: () => {\n\t\t\t\t\t\tconst initRoot = injectCanvasRootInitializer();\n\n\t\t\t\t\t\treturn () => {\n\t\t\t\t\t\t\tconst configurator = initRoot(mockedCanvas);\n\t\t\t\t\t\t\tconfigurator.configure({\n\t\t\t\t\t\t\t\tframeloop: 'never',\n\t\t\t\t\t\t\t\tsize: {\n\t\t\t\t\t\t\t\t\twidth: mockCanvasOptions.width ?? 1280,\n\t\t\t\t\t\t\t\t\theight: mockCanvasOptions.height ?? 800,\n\t\t\t\t\t\t\t\t\ttop: 0,\n\t\t\t\t\t\t\t\t\tleft: 0,\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t...canvasConfiguration,\n\t\t\t\t\t\t\t\tevents: undefined,\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t};\n\t\t\t\t\t},\n\t\t\t\t\tmulti: true,\n\t\t\t\t},\n\t\t\t\t...(providers ?? []),\n\t\t\t],\n\t\t\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\t\t\terrorOnUnknownElements: errorOnUnknownElements ?? false,\n\t\t\tdeclarations,\n\t\t\timports,\n\t\t\tteardown,\n\t\t\tdeferBlockBehavior,\n\t\t}).createComponent(NgtTestCanvas);\n\n\t\tfixture.componentRef.setInput('sceneGraph', sceneGraph);\n\t\tfixture.detectChanges();\n\n\t\tconst store = TestBed.inject(NGT_STORE);\n\n\t\tTestBed.flushEffects();\n\n\t\treturn {\n\t\t\tstore,\n\t\t\tfixture,\n\t\t\tscene: store.snapshot.scene,\n\t\t\tsceneInstanceNode: getLocalState(store.snapshot.scene)!,\n\t\t\tcanvas: mockedCanvas,\n\t\t\tdestroy: fixture.componentInstance.destroy.bind(fixture.componentInstance),\n\t\t\tfireEvent: this.createEventFirer(store, fixture),\n\t\t\tadvance: this.createAdvance(store),\n\t\t\ttoGraph: this.createToGraph(store),\n\t\t};\n\t}\n\n\tstatic createToGraph(store: NgtSignalStore<NgtState>) {\n\t\tfunction graphify(type: string, name: string, children: NgtTestGraphedObject[]): NgtTestGraphedObject {\n\t\t\treturn { type, name, children };\n\t\t}\n\n\t\tfunction toGraph(node: Object3D): NgtTestGraphedObject[] {\n\t\t\treturn node.children.map((child) => graphify(child.type, child.name || '', toGraph(child)));\n\t\t}\n\n\t\treturn () => {\n\t\t\tconst state = store.snapshot;\n\t\t\treturn toGraph(state.scene);\n\t\t};\n\t}\n\n\tstatic createAdvance(store: NgtSignalStore<NgtState>) {\n\t\treturn async (frames: number, delta: number | number[] = 1) => {\n\t\t\tconst state = store.snapshot;\n\t\t\tconst subscribers = state.internal.subscribers;\n\n\t\t\tconst promises: Promise<void>[] = [];\n\n\t\t\tfor (const subscriber of subscribers) {\n\t\t\t\tfor (let i = 0; i < frames; i++) {\n\t\t\t\t\tif (Array.isArray(delta)) {\n\t\t\t\t\t\tpromises.push(\n\t\t\t\t\t\t\tnew Promise((res) => {\n\t\t\t\t\t\t\t\tsubscriber.callback({ ...state, delta: delta[i] || delta[-1] });\n\t\t\t\t\t\t\t\tres();\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tpromises.push(\n\t\t\t\t\t\t\tnew Promise((res) => {\n\t\t\t\t\t\t\t\tsubscriber.callback({ ...state, delta });\n\t\t\t\t\t\t\t\tres();\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tawait Promise.all(promises);\n\t\t};\n\t}\n\n\tstatic createEventFirer(store: NgtSignalStore<NgtState>, fixture: ComponentFixture<NgtTestCanvas>) {\n\t\tlet autoDetectChanges = true;\n\n\t\tasync function fireEvent(el: NgtInstanceNode, eventName: keyof NgtEventHandlers, eventData: NgtAnyRecord = {}) {\n\t\t\tconst localState = getLocalState(el);\n\t\t\tif (!localState) {\n\t\t\t\tconsole.warn(`[NGT Test] ${el} has no local state`);\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst handler = localState.handlers[eventName];\n\t\t\tif (!handler) {\n\t\t\t\tconsole.warn(`[NGT Test] ${el} has no ${eventName} handler`);\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst raycastEvent = {\n\t\t\t\tcamera: store.snapshot.camera,\n\t\t\t\tstopPropagation: () => {},\n\t\t\t\ttarget: el,\n\t\t\t\tcurrentTarget: el,\n\t\t\t\tsourceEvent: eventData,\n\t\t\t\tnativeEvent: eventData,\n\t\t\t\tobject: el,\n\t\t\t\teventObject: el,\n\t\t\t\t...eventData,\n\t\t\t};\n\n\t\t\tconst result = await handler(raycastEvent as any);\n\n\t\t\tif (autoDetectChanges) {\n\t\t\t\tfixture.detectChanges();\n\t\t\t}\n\n\t\t\treturn result;\n\t\t}\n\n\t\tfireEvent.setAutoDetectChanges = (auto: boolean) => {\n\t\t\tautoDetectChanges = auto;\n\t\t};\n\n\t\treturn fireEvent;\n\t}\n}\n"]}

package/esm2022/testing/lib/test-canvas.mjs

@@ -0,0 +1,45 @@
+import { afterNextRender, ChangeDetectionStrategy, Component, createEnvironmentInjector, DestroyRef, effect, EnvironmentInjector, inject, Injector, input, ViewContainerRef, } from '@angular/core';
+import { extend, injectStore, provideNgtRenderer } from 'angular-three';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+export class NgtTestCanvas {
+    constructor() {
+        this.sceneGraph = input.required();
+        extend(THREE);
+        const vcr = inject(ViewContainerRef);
+        const parentEnvironmentInjector = inject(EnvironmentInjector);
+        const parentInjector = inject(Injector);
+        const store = injectStore();
+        afterNextRender(() => {
+            effect(() => {
+                const sceneGraph = this.sceneGraph();
+                this.environmentInjector = createEnvironmentInjector([provideNgtRenderer(store)], parentEnvironmentInjector);
+                this.ref = vcr.createComponent(sceneGraph, {
+                    environmentInjector: this.environmentInjector,
+                    injector: parentInjector,
+                });
+                this.ref.changeDetectorRef.detectChanges();
+            }, { injector: parentInjector });
+        });
+        inject(DestroyRef).onDestroy(() => {
+            this.environmentInjector?.destroy();
+            this.ref?.destroy();
+        });
+    }
+    destroy() {
+        this.environmentInjector?.destroy();
+        this.ref?.destroy();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtTestCanvas, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.0", type: NgtTestCanvas, isStandalone: true, selector: "ngt-test-canvas", inputs: { sceneGraph: { classPropertyName: "sceneGraph", publicName: "sceneGraph", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtTestCanvas, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngt-test-canvas',
+                    template: '',
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/testing/lib/utils/mock-canvas.mjs

@@ -0,0 +1,37 @@
+import { WebGL2RenderingContext } from './web-gl-rendering-context';
+export function createMockCanvas({ width = 1280, height = 800, beforeReturn, }) {
+    let canvas;
+    if (typeof document !== 'undefined' && typeof document.createElement === 'function') {
+        canvas = document.createElement('canvas');
+    }
+    else {
+        canvas = {
+            style: {},
+            addEventListener: (() => { }),
+            removeEventListener: (() => { }),
+            clientWidth: width,
+            clientHeight: height,
+            getContext: (() => new WebGL2RenderingContext(canvas)),
+        };
+    }
+    canvas.width = width;
+    canvas.height = height;
+    if (globalThis.HTMLCanvasElement) {
+        const getContext = HTMLCanvasElement.prototype.getContext;
+        HTMLCanvasElement.prototype.getContext = function (...args) {
+            const id = args[0];
+            if (id.startsWith('webgl'))
+                return new WebGL2RenderingContext(this);
+            return getContext.apply(this, args);
+        };
+    }
+    beforeReturn?.(canvas);
+    class WebGLRenderingContext extends WebGL2RenderingContext {
+    }
+    // @ts-expect-error - WebGLRenderingContext is not defined in the global scope for non-browser
+    globalThis.WebGLRenderingContext ??= WebGLRenderingContext;
+    // @ts-expect-error - WebGL2RenderingContext is not defined in the global scope for non-browser
+    globalThis.WebGL2RenderingContext ??= WebGL2RenderingContext;
+    return canvas;
+}
+//# sourceMappingURL=data:application/json;base64,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