angular-three 2.0.0-beta.31 → 2.0.0-beta.310

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":"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","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.1.3", ngImport: i0, type: NgtTestCanvas, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.1.3", 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.1.3", ngImport: i0, type: NgtTestCanvas, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngt-test-canvas',
+                    template: '',
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC1jYW52YXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvcmUvdGVzdGluZy9zcmMvbGliL3Rlc3QtY2FudmFzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTixlQUFlLEVBQ2YsdUJBQXVCLEVBQ3ZCLFNBQVMsRUFFVCx5QkFBeUIsRUFDekIsVUFBVSxFQUNWLE1BQU0sRUFDTixtQkFBbUIsRUFDbkIsTUFBTSxFQUNOLFFBQVEsRUFDUixLQUFLLEVBRUwsZ0JBQWdCLEdBQ2hCLE1BQU0sZUFBZSxDQUFDO0FBQ3ZCLE9BQU8sRUFBRSxNQUFNLEVBQUUsV0FBVyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3hFLE9BQU8sS0FBSyxLQUFLLE1BQU0sT0FBTyxDQUFDOztBQVEvQixNQUFNLE9BQU8sYUFBYTtJQU16QjtRQUxBLGVBQVUsR0FBRyxLQUFLLENBQUMsUUFBUSxFQUFhLENBQUM7UUFNeEMsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBRWQsTUFBTSxHQUFHLEdBQUcsTUFBTSxDQUFDLGdCQUFnQixDQUFDLENBQUM7UUFDckMsTUFBTSx5QkFBeUIsR0FBRyxNQUFNLENBQUMsbUJBQW1CLENBQUMsQ0FBQztRQUM5RCxNQUFNLGNBQWMsR0FBRyxNQUFNLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDeEMsTUFBTSxLQUFLLEdBQUcsV0FBVyxFQUFFLENBQUM7UUFFNUIsZUFBZSxDQUFDLEdBQUcsRUFBRTtZQUNwQixNQUFNLENBQ0wsR0FBRyxFQUFFO2dCQUNKLE1BQU0sVUFBVSxHQUFHLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQztnQkFFckMsSUFBSSxDQUFDLG1CQUFtQixHQUFHLHlCQUF5QixDQUFDLENBQUMsa0JBQWtCLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSx5QkFBeUIsQ0FBQyxDQUFDO2dCQUU3RyxJQUFJLENBQUMsR0FBRyxHQUFHLEdBQUcsQ0FBQyxlQUFlLENBQUMsVUFBVSxFQUFFO29CQUMxQyxtQkFBbUIsRUFBRSxJQUFJLENBQUMsbUJBQW1CO29CQUM3QyxRQUFRLEVBQUUsY0FBYztpQkFDeEIsQ0FBQyxDQUFDO2dCQUNILElBQUksQ0FBQyxHQUFHLENBQUMsaUJBQWlCLENBQUMsYUFBYSxFQUFFLENBQUM7WUFDNUMsQ0FBQyxFQUNELEVBQUUsUUFBUSxFQUFFLGNBQWMsRUFBRSxDQUM1QixDQUFDO1FBQ0gsQ0FBQyxDQUFDLENBQUM7UUFFSCxNQUFNLENBQUMsVUFBVSxDQUFDLENBQUMsU0FBUyxDQUFDLEdBQUcsRUFBRTtZQUNqQyxJQUFJLENBQUMsbUJBQW1CLEVBQUUsT0FBTyxFQUFFLENBQUM7WUFDcEMsSUFBSSxDQUFDLEdBQUcsRUFBRSxPQUFPLEVBQUUsQ0FBQztRQUNyQixDQUFDLENBQUMsQ0FBQztJQUNKLENBQUM7SUFFRCxPQUFPO1FBQ04sSUFBSSxDQUFDLG1CQUFtQixFQUFFLE9BQU8sRUFBRSxDQUFDO1FBQ3BDLElBQUksQ0FBQyxHQUFHLEVBQUUsT0FBTyxFQUFFLENBQUM7SUFDckIsQ0FBQzs4R0F4Q1csYUFBYTtrR0FBYixhQUFhLDZOQUpmLEVBQUU7OzJGQUlBLGFBQWE7a0JBTnpCLFNBQVM7bUJBQUM7b0JBQ1YsUUFBUSxFQUFFLGlCQUFpQjtvQkFDM0IsUUFBUSxFQUFFLEVBQUU7b0JBQ1osVUFBVSxFQUFFLElBQUk7b0JBQ2hCLGVBQWUsRUFBRSx1QkFBdUIsQ0FBQyxNQUFNO2lCQUMvQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG5cdGFmdGVyTmV4dFJlbmRlcixcblx0Q2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksXG5cdENvbXBvbmVudCxcblx0Q29tcG9uZW50UmVmLFxuXHRjcmVhdGVFbnZpcm9ubWVudEluamVjdG9yLFxuXHREZXN0cm95UmVmLFxuXHRlZmZlY3QsXG5cdEVudmlyb25tZW50SW5qZWN0b3IsXG5cdGluamVjdCxcblx0SW5qZWN0b3IsXG5cdGlucHV0LFxuXHRUeXBlLFxuXHRWaWV3Q29udGFpbmVyUmVmLFxufSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IGV4dGVuZCwgaW5qZWN0U3RvcmUsIHByb3ZpZGVOZ3RSZW5kZXJlciB9IGZyb20gJ2FuZ3VsYXItdGhyZWUnO1xuaW1wb3J0ICogYXMgVEhSRUUgZnJvbSAndGhyZWUnO1xuXG5AQ29tcG9uZW50KHtcblx0c2VsZWN0b3I6ICduZ3QtdGVzdC1jYW52YXMnLFxuXHR0ZW1wbGF0ZTogJycsXG5cdHN0YW5kYWxvbmU6IHRydWUsXG5cdGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxufSlcbmV4cG9ydCBjbGFzcyBOZ3RUZXN0Q2FudmFzIHtcblx0c2NlbmVHcmFwaCA9IGlucHV0LnJlcXVpcmVkPFR5cGU8YW55Pj4oKTtcblxuXHRwcml2YXRlIHJlZj86IENvbXBvbmVudFJlZjxhbnk+O1xuXHRwcml2YXRlIGVudmlyb25tZW50SW5qZWN0b3I/OiBFbnZpcm9ubWVudEluamVjdG9yO1xuXG5cdGNvbnN0cnVjdG9yKCkge1xuXHRcdGV4dGVuZChUSFJFRSk7XG5cblx0XHRjb25zdCB2Y3IgPSBpbmplY3QoVmlld0NvbnRhaW5lclJlZik7XG5cdFx0Y29uc3QgcGFyZW50RW52aXJvbm1lbnRJbmplY3RvciA9IGluamVjdChFbnZpcm9ubWVudEluamVjdG9yKTtcblx0XHRjb25zdCBwYXJlbnRJbmplY3RvciA9IGluamVjdChJbmplY3Rvcik7XG5cdFx0Y29uc3Qgc3RvcmUgPSBpbmplY3RTdG9yZSgpO1xuXG5cdFx0YWZ0ZXJOZXh0UmVuZGVyKCgpID0+IHtcblx0XHRcdGVmZmVjdChcblx0XHRcdFx0KCkgPT4ge1xuXHRcdFx0XHRcdGNvbnN0IHNjZW5lR3JhcGggPSB0aGlzLnNjZW5lR3JhcGgoKTtcblxuXHRcdFx0XHRcdHRoaXMuZW52aXJvbm1lbnRJbmplY3RvciA9IGNyZWF0ZUVudmlyb25tZW50SW5qZWN0b3IoW3Byb3ZpZGVOZ3RSZW5kZXJlcihzdG9yZSldLCBwYXJlbnRFbnZpcm9ubWVudEluamVjdG9yKTtcblxuXHRcdFx0XHRcdHRoaXMucmVmID0gdmNyLmNyZWF0ZUNvbXBvbmVudChzY2VuZUdyYXBoLCB7XG5cdFx0XHRcdFx0XHRlbnZpcm9ubWVudEluamVjdG9yOiB0aGlzLmVudmlyb25tZW50SW5qZWN0b3IsXG5cdFx0XHRcdFx0XHRpbmplY3RvcjogcGFyZW50SW5qZWN0b3IsXG5cdFx0XHRcdFx0fSk7XG5cdFx0XHRcdFx0dGhpcy5yZWYuY2hhbmdlRGV0ZWN0b3JSZWYuZGV0ZWN0Q2hhbmdlcygpO1xuXHRcdFx0XHR9LFxuXHRcdFx0XHR7IGluamVjdG9yOiBwYXJlbnRJbmplY3RvciB9LFxuXHRcdFx0KTtcblx0XHR9KTtcblxuXHRcdGluamVjdChEZXN0cm95UmVmKS5vbkRlc3Ryb3koKCkgPT4ge1xuXHRcdFx0dGhpcy5lbnZpcm9ubWVudEluamVjdG9yPy5kZXN0cm95KCk7XG5cdFx0XHR0aGlzLnJlZj8uZGVzdHJveSgpO1xuXHRcdH0pO1xuXHR9XG5cblx0ZGVzdHJveSgpIHtcblx0XHR0aGlzLmVudmlyb25tZW50SW5qZWN0b3I/LmRlc3Ryb3koKTtcblx0XHR0aGlzLnJlZj8uZGVzdHJveSgpO1xuXHR9XG59XG4iXX0=

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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