angular-three 0.0.2 → 0.0.3

package/esm2020/lib/canvas.mjs

@@ -0,0 +1,227 @@
+import { AsyncPipe, NgIf, NgTemplateOutlet } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ContentChild, ElementRef, EventEmitter, HostBinding, inject, Input, NgZone, Output, TemplateRef, ViewChild, } from '@angular/core';
+import { createPointerEvents } from './events';
+import { provideInstanceRef } from './instance';
+import { NgtResize } from './services/resize';
+import { NgtComponentStore } from './stores/component-store';
+import { NgtStore, rootStateMap } from './stores/store';
+import { NgtLoader } from './services/loader';
+import * as i0 from "@angular/core";
+export class NgtCanvasContainer {
+    constructor() {
+        this.resize = inject(NgtResize);
+    }
+}
+NgtCanvasContainer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtCanvasContainer, deps: [], target: i0.ɵɵFactoryTarget.Component });
+NgtCanvasContainer.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.0.0", type: NgtCanvasContainer, isStandalone: true, selector: "ngt-canvas-container", outputs: { resize: "resize" }, providers: [NgtResize], ngImport: i0, template: '<ng-content></ng-content>', isInline: true, styles: [":host{display:block;height:100%;width:100%}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtCanvasContainer, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngt-canvas-container', standalone: true, template: '<ng-content></ng-content>', providers: [NgtResize], styles: [":host{display:block;height:100%;width:100%}\n"] }]
+        }], propDecorators: { resize: [{
+                type: Output
+            }] } });
+export class NgtCanvas extends NgtComponentStore {
+    constructor() {
+        super(...arguments);
+        this.hostClass = true;
+        this.created = new EventEmitter();
+        this.canvasPointerMissed = new EventEmitter();
+        this.zone = inject(NgZone);
+        this.loader = inject(NgtLoader);
+        this.store = inject(NgtStore, { self: true });
+        this.host = inject(ElementRef);
+    }
+    get pointerEvents() {
+        return this.read((s) => s.eventSource) !== this.host.nativeElement ? 'none' : 'auto';
+    }
+    set linear(linear) {
+        this.write({ linear });
+    }
+    set legacy(legacy) {
+        this.write({ legacy });
+    }
+    set flat(flat) {
+        this.write({ flat });
+    }
+    set orthographic(orthographic) {
+        this.write({ orthographic });
+    }
+    set frameloop(frameloop) {
+        this.write({ frameloop });
+    }
+    set dpr(dpr) {
+        this.write({ dpr });
+    }
+    set raycaster(raycaster) {
+        this.write({ raycaster });
+    }
+    set shadows(shadows) {
+        this.write({
+            shadows: typeof shadows === 'object' ? shadows : shadows,
+        });
+    }
+    set camera(camera) {
+        this.write({ camera });
+    }
+    set gl(gl) {
+        this.write({ gl });
+    }
+    set eventSource(eventSource) {
+        this.write({ eventSource });
+    }
+    set eventPrefix(eventPrefix) {
+        this.write({ eventPrefix });
+    }
+    set lookAt(lookAt) {
+        this.write({ lookAt });
+    }
+    set performance(performance) {
+        this.write({ performance });
+    }
+    get sceneRef() {
+        return this.store.read((s) => s.sceneRef);
+    }
+    get isConfigured() {
+        return this.store.isConfigured;
+    }
+    initialize() {
+        super.initialize();
+        this.write({
+            shadows: false,
+            linear: false,
+            flat: false,
+            legacy: false,
+            orthographic: false,
+            frameloop: 'always',
+            dpr: [1, 2],
+            events: createPointerEvents,
+        });
+    }
+    ngOnInit() {
+        this.zone.runOutsideAngular(() => {
+            if (!this.eventSource) {
+                this.eventSource = this.host.nativeElement;
+            }
+            if (this.canvasPointerMissed.observed) {
+                // update pointerMissed event
+                this.store.write({
+                    onPointerMissed: (event) => {
+                        // go back into angular zone
+                        this.zone.run(() => {
+                            this.canvasPointerMissed.emit(event);
+                        });
+                    },
+                });
+            }
+            // set rootStateMap
+            rootStateMap.set(this.glCanvas.nativeElement, this.store.read);
+            // setup canvas state
+            this.store.init();
+            this.store.onReady(() => {
+                const state = this.store.read();
+                const inputs = this.read();
+                // canvas is ready
+                this.store.write((s) => ({ internal: { ...s.internal, active: true } }));
+                // Connect to eventsource
+                state.events.connect?.(inputs.eventSource instanceof ElementRef ? inputs.eventSource.nativeElement : inputs.eventSource);
+                // Set up compute function
+                if (inputs.eventPrefix) {
+                    state.setEvents({
+                        compute: (event, stateGetter) => {
+                            const innerState = stateGetter();
+                            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);
+                        },
+                    });
+                }
+                if (this.created.observed) {
+                    this.zone.run(() => {
+                        this.created.emit(this.store.read());
+                    });
+                }
+            });
+        });
+    }
+    onResize(resizeResult) {
+        this.zone.runOutsideAngular(() => {
+            const { width, height } = resizeResult;
+            if (width > 0 && height > 0) {
+                if (!this.store.isInit) {
+                    this.store.init();
+                }
+                this.store.configure(this.read(), this.glCanvas.nativeElement);
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.loader.destroy();
+        super.ngOnDestroy();
+    }
+}
+NgtCanvas.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtCanvas, deps: null, target: i0.ɵɵFactoryTarget.Component });
+NgtCanvas.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.0.0", type: NgtCanvas, isStandalone: true, selector: "ngt-canvas", inputs: { 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", canvasPointerMissed: "canvasPointerMissed" }, host: { properties: { "class.ngt-canvas": "this.hostClass", "style.pointerEvents": "this.pointerEvents" } }, providers: [NgtStore, provideInstanceRef(NgtCanvas, (canvas) => canvas.sceneRef)], queries: [{ propertyName: "canvasContent", first: true, predicate: TemplateRef, descendants: true, static: true }], viewQueries: [{ propertyName: "glCanvas", first: true, predicate: ["glCanvas"], descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: `
+        <ngt-canvas-container (resize)="onResize($event)">
+            <canvas #glCanvas style="display: block">
+                <ng-container *ngIf="isConfigured" [ngTemplateOutlet]="canvasContent"></ng-container>
+                <ng-content></ng-content>
+            </canvas>
+        </ngt-canvas-container>
+    `, isInline: true, styles: [":host{display:block;position:relative;width:100%;height:100%;overflow:hidden}\n"], dependencies: [{ kind: "component", type: NgtCanvasContainer, selector: "ngt-canvas-container", outputs: ["resize"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtCanvas, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngt-canvas', standalone: true, template: `
+        <ngt-canvas-container (resize)="onResize($event)">
+            <canvas #glCanvas style="display: block">
+                <ng-container *ngIf="isConfigured" [ngTemplateOutlet]="canvasContent"></ng-container>
+                <ng-content></ng-content>
+            </canvas>
+        </ngt-canvas-container>
+    `, changeDetection: ChangeDetectionStrategy.OnPush, imports: [NgtCanvasContainer, NgIf, NgTemplateOutlet, AsyncPipe], providers: [NgtStore, provideInstanceRef(NgtCanvas, (canvas) => canvas.sceneRef)], styles: [":host{display:block;position:relative;width:100%;height:100%;overflow:hidden}\n"] }]
+        }], propDecorators: { hostClass: [{
+                type: HostBinding,
+                args: ['class.ngt-canvas']
+            }], pointerEvents: [{
+                type: HostBinding,
+                args: ['style.pointerEvents']
+            }], 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
+            }], canvasPointerMissed: [{
+                type: Output
+            }], glCanvas: [{
+                type: ViewChild,
+                args: ['glCanvas', { static: true }]
+            }], canvasContent: [{
+                type: ContentChild,
+                args: [TemplateRef, { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"canvas.js","sourceRoot":"","sources":["../../../../../packages/angular-three/src/lib/canvas.ts"],"names":[],"mappings":"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","sourcesContent":["import { AsyncPipe, NgIf, NgTemplateOutlet } from '@angular/common';\nimport {\n    ChangeDetectionStrategy,\n    Component,\n    ContentChild,\n    ElementRef,\n    EventEmitter,\n    HostBinding,\n    inject,\n    Input,\n    NgZone,\n    OnDestroy,\n    OnInit,\n    Output,\n    TemplateRef,\n    ViewChild,\n} from '@angular/core';\nimport { Observable } from 'rxjs';\nimport * as THREE from 'three';\nimport { createPointerEvents } from './events';\nimport { provideInstanceRef } from './instance';\nimport { NgtResize, NgtResizeResult } from './services/resize';\nimport { NgtComponentStore } from './stores/component-store';\nimport { NgtStore, rootStateMap } from './stores/store';\nimport type { NgtCanvasInputs, NgtDomEvent, NgtDpr, NgtObservableInput, NgtVector3 } from './types';\nimport { NgtLoader } from './services/loader';\n\n@Component({\n    selector: 'ngt-canvas-container',\n    standalone: true,\n    template: '<ng-content></ng-content>',\n    providers: [NgtResize],\n    styles: [\n        `\n            :host {\n                display: block;\n                height: 100%;\n                width: 100%;\n            }\n        `,\n    ],\n})\nexport class NgtCanvasContainer {\n    @Output() resize = inject(NgtResize) as Observable<NgtResizeResult>;\n}\n\n@Component({\n    selector: 'ngt-canvas',\n    standalone: true,\n    template: `\n        <ngt-canvas-container (resize)=\"onResize($event)\">\n            <canvas #glCanvas style=\"display: block\">\n                <ng-container *ngIf=\"isConfigured\" [ngTemplateOutlet]=\"canvasContent\"></ng-container>\n                <ng-content></ng-content>\n            </canvas>\n        </ngt-canvas-container>\n    `,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    styles: [\n        `\n            :host {\n                display: block;\n                position: relative;\n                width: 100%;\n                height: 100%;\n                overflow: hidden;\n            }\n        `,\n    ],\n    imports: [NgtCanvasContainer, NgIf, NgTemplateOutlet, AsyncPipe],\n    providers: [NgtStore, provideInstanceRef(NgtCanvas, (canvas) => canvas.sceneRef)],\n})\nexport class NgtCanvas extends NgtComponentStore<NgtCanvasInputs> implements OnInit, OnDestroy {\n    @HostBinding('class.ngt-canvas') readonly hostClass = true;\n\n    @HostBinding('style.pointerEvents') get pointerEvents() {\n        return this.read((s) => s.eventSource) !== this.host.nativeElement ? 'none' : 'auto';\n    }\n\n    @Input() set linear(linear: NgtObservableInput<boolean>) {\n        this.write({ linear });\n    }\n\n    @Input() set legacy(legacy: NgtObservableInput<boolean>) {\n        this.write({ legacy });\n    }\n\n    @Input() set flat(flat: NgtObservableInput<boolean>) {\n        this.write({ flat });\n    }\n\n    @Input() set orthographic(orthographic: NgtObservableInput<boolean>) {\n        this.write({ orthographic });\n    }\n\n    @Input() set frameloop(frameloop: NgtObservableInput<'always' | 'demand' | 'never'>) {\n        this.write({ frameloop });\n    }\n\n    @Input() set dpr(dpr: NgtObservableInput<NgtDpr>) {\n        this.write({ dpr });\n    }\n\n    @Input() set raycaster(raycaster: Partial<THREE.Raycaster>) {\n        this.write({ raycaster });\n    }\n\n    @Input() set shadows(shadows: boolean | Partial<THREE.WebGLShadowMap>) {\n        this.write({\n            shadows: typeof shadows === 'object' ? (shadows as Partial<THREE.WebGLShadowMap>) : shadows,\n        });\n    }\n\n    @Input() set camera(camera: NgtCanvasInputs['camera']) {\n        this.write({ camera });\n    }\n\n    @Input() set gl(gl: NgtCanvasInputs['gl']) {\n        this.write({ gl });\n    }\n\n    @Input() set eventSource(eventSource: NgtCanvasInputs['eventSource']) {\n        this.write({ eventSource });\n    }\n\n    @Input() set eventPrefix(eventPrefix: NgtCanvasInputs['eventPrefix']) {\n        this.write({ eventPrefix });\n    }\n\n    @Input() set lookAt(lookAt: NgtObservableInput<NgtVector3>) {\n        this.write({ lookAt });\n    }\n\n    @Input() set performance(performance: NgtCanvasInputs['performance']) {\n        this.write({ performance });\n    }\n\n    @Output() created = new EventEmitter();\n    @Output() canvasPointerMissed = new EventEmitter();\n\n    @ViewChild('glCanvas', { static: true })\n    glCanvas!: ElementRef<HTMLCanvasElement>;\n\n    @ContentChild(TemplateRef, { static: true })\n    canvasContent!: TemplateRef<unknown>;\n\n    private readonly zone = inject(NgZone);\n    private readonly loader = inject(NgtLoader);\n    private readonly store = inject(NgtStore, { self: true });\n\n    private readonly host = inject(ElementRef) as ElementRef<HTMLElement>;\n\n    get sceneRef() {\n        return this.store.read((s) => s.sceneRef);\n    }\n\n    get isConfigured() {\n        return this.store.isConfigured;\n    }\n\n    override initialize() {\n        super.initialize();\n        this.write({\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    ngOnInit() {\n        this.zone.runOutsideAngular(() => {\n            if (!this.eventSource) {\n                this.eventSource = this.host.nativeElement;\n            }\n\n            if (this.canvasPointerMissed.observed) {\n                // update pointerMissed event\n                this.store.write({\n                    onPointerMissed: (event: MouseEvent) => {\n                        // go back into angular zone\n                        this.zone.run(() => {\n                            this.canvasPointerMissed.emit(event);\n                        });\n                    },\n                });\n            }\n\n            // set rootStateMap\n            rootStateMap.set(this.glCanvas.nativeElement, this.store.read);\n\n            // setup canvas state\n            this.store.init();\n\n            this.store.onReady(() => {\n                const state = this.store.read();\n                const inputs = this.read();\n\n                // canvas is ready\n                this.store.write((s) => ({ internal: { ...s.internal, active: true } }));\n\n                // Connect to eventsource\n                state.events.connect?.(\n                    inputs.eventSource instanceof ElementRef ? inputs.eventSource.nativeElement : inputs.eventSource\n                );\n\n                // Set up compute function\n                if (inputs.eventPrefix) {\n                    state.setEvents({\n                        compute: (event, stateGetter) => {\n                            const innerState = stateGetter();\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(\n                                (x / innerState.size.width) * 2 - 1,\n                                -(y / innerState.size.height) * 2 + 1\n                            );\n                            innerState.raycaster.setFromCamera(innerState.pointer, innerState.camera);\n                        },\n                    });\n                }\n\n                if (this.created.observed) {\n                    this.zone.run(() => {\n                        this.created.emit(this.store.read());\n                    });\n                }\n            });\n        });\n    }\n\n    onResize(resizeResult: NgtResizeResult) {\n        this.zone.runOutsideAngular(() => {\n            const { width, height } = resizeResult;\n            if (width > 0 && height > 0) {\n                if (!this.store.isInit) {\n                    this.store.init();\n                }\n                this.store.configure(this.read(), this.glCanvas.nativeElement);\n            }\n        });\n    }\n\n    override ngOnDestroy() {\n        this.loader.destroy();\n        super.ngOnDestroy();\n    }\n}\n"]}

package/esm2020/lib/di/resize.mjs

@@ -0,0 +1,19 @@
+import { createInjection } from '../utils/inject';
+import { injectWindow } from './window';
+export const defaultResizeOptions = {
+    box: 'content-box',
+    scroll: false,
+    offsetSize: false,
+    debounce: { scroll: 50, resize: 0 },
+};
+export const [injectResizeOptions, provideResizeOptions] = createInjection('ngtResize Options', {
+    defaultValueOrFactory: defaultResizeOptions,
+    provideValueFactory: (value) => ({ ...defaultResizeOptions, ...value }),
+});
+export const [injectResizeObserverSupport] = createInjection('Resize Observer API support', {
+    defaultValueOrFactory: () => {
+        const window = injectWindow();
+        return 'ResizeObserver' in window && window['ResizeObserver'] != null;
+    },
+});
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/di/window.mjs

@@ -0,0 +1,13 @@
+import { DOCUMENT } from '@angular/common';
+import { inject } from '@angular/core';
+import { createInjection } from '../utils/inject';
+export const [injectWindow] = createInjection('window', {
+    defaultValueOrFactory: () => {
+        const { defaultView } = inject(DOCUMENT);
+        if (!defaultView) {
+            throw `window is not available!`;
+        }
+        return defaultView;
+    },
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2luZG93LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvYW5ndWxhci10aHJlZS9zcmMvbGliL2RpL3dpbmRvdy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDM0MsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN2QyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFFbEQsTUFBTSxDQUFDLE1BQU0sQ0FBQyxZQUFZLENBQUMsR0FBRyxlQUFlLENBQTZCLFFBQVEsRUFBRTtJQUNoRixxQkFBcUIsRUFBRSxHQUFHLEVBQUU7UUFDeEIsTUFBTSxFQUFFLFdBQVcsRUFBRSxHQUFHLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUV6QyxJQUFJLENBQUMsV0FBVyxFQUFFO1lBQ2QsTUFBTSwwQkFBMEIsQ0FBQztTQUNwQztRQUVELE9BQU8sV0FBVyxDQUFDO0lBQ3ZCLENBQUM7Q0FDSixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBET0NVTUVOVCB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBpbmplY3QgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IGNyZWF0ZUluamVjdGlvbiB9IGZyb20gJy4uL3V0aWxzL2luamVjdCc7XG5cbmV4cG9ydCBjb25zdCBbaW5qZWN0V2luZG93XSA9IGNyZWF0ZUluamVjdGlvbjxXaW5kb3cgJiB0eXBlb2YgZ2xvYmFsVGhpcz4oJ3dpbmRvdycsIHtcbiAgICBkZWZhdWx0VmFsdWVPckZhY3Rvcnk6ICgpID0+IHtcbiAgICAgICAgY29uc3QgeyBkZWZhdWx0VmlldyB9ID0gaW5qZWN0KERPQ1VNRU5UKTtcblxuICAgICAgICBpZiAoIWRlZmF1bHRWaWV3KSB7XG4gICAgICAgICAgICB0aHJvdyBgd2luZG93IGlzIG5vdCBhdmFpbGFibGUhYDtcbiAgICAgICAgfVxuXG4gICAgICAgIHJldHVybiBkZWZhdWx0VmlldztcbiAgICB9LFxufSk7XG4iXX0=

package/esm2020/lib/directives/args.mjs

@@ -0,0 +1,30 @@
+import { Directive, inject, InjectionToken, Injector, Input, TemplateRef, ViewContainerRef, } from '@angular/core';
+import * as i0 from "@angular/core";
+export const NGT_ARGS = new InjectionToken('NgtArgs');
+export function injectArgs(options = {}) {
+    return inject(NGT_ARGS, options);
+}
+export class NgtArgs {
+    constructor() {
+        this.templateRef = inject(TemplateRef);
+        this.vcr = inject(ViewContainerRef);
+    }
+    set args(args) {
+        if (this.view) {
+            this.view.destroy();
+        }
+        this.view = this.vcr.createEmbeddedView(this.templateRef, {}, { injector: Injector.create({ providers: [{ provide: NGT_ARGS, useValue: args }] }) });
+    }
+}
+NgtArgs.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtArgs, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+NgtArgs.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.0", type: NgtArgs, isStandalone: true, selector: "[args]", inputs: { args: "args" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.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/esm2020/lib/events.mjs

@@ -0,0 +1,53 @@
+import { createEvents } from './utils/events';
+const DOM_EVENTS = {
+    click: false,
+    contextmenu: false,
+    dblclick: false,
+    wheel: false,
+    pointerdown: true,
+    pointerup: true,
+    pointerleave: true,
+    pointermove: true,
+    pointercancel: true,
+    lostpointercapture: true,
+};
+export function createPointerEvents(stateFactory) {
+    const { handlePointer } = createEvents(stateFactory);
+    return {
+        priority: 1,
+        enabled: true,
+        compute: (event, rootFactory) => {
+            const state = rootFactory();
+            // https://github.com/pmndrs/react-three-fiber/pull/782
+            // Events trigger outside of canvas when moved, use offsetX/Y by default and allow overrides
+            state.pointer.set((event.offsetX / state.size.width) * 2 - 1, -(event.offsetY / state.size.height) * 2 + 1);
+            state.raycaster.setFromCamera(state.pointer, state.camera);
+        },
+        connected: undefined,
+        handlers: Object.keys(DOM_EVENTS).reduce((handlers, supportedEventName) => {
+            handlers[supportedEventName] = handlePointer(supportedEventName);
+            return handlers;
+        }, {}),
+        connect: (target) => {
+            const state = stateFactory();
+            state.events.disconnect?.();
+            state.setEvents({ connected: target });
+            Object.entries(state.events.handlers ?? {}).forEach(([eventName, eventHandler]) => {
+                const passive = DOM_EVENTS[eventName];
+                target.addEventListener(eventName, eventHandler, { passive });
+            });
+        },
+        disconnect: () => {
+            const { events, setEvents } = stateFactory();
+            if (events.connected) {
+                Object.entries(events.handlers ?? {}).forEach(([eventName, eventHandler]) => {
+                    if (events.connected instanceof HTMLElement) {
+                        events.connected.removeEventListener(eventName, eventHandler);
+                    }
+                });
+                setEvents({ connected: undefined });
+            }
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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