angular-three 0.0.0-replace

package/esm2022/lib/loop.mjs

@@ -0,0 +1,153 @@
+import { createInjectionToken } from 'ngxtension/create-injection-token';
+import { roots } from './roots';
+function createSubs(callback, subs) {
+    const sub = { callback };
+    subs.add(sub);
+    return () => void subs.delete(sub);
+}
+const globalEffects = new Set();
+const globalAfterEffects = new Set();
+const globalTailEffects = new Set();
+/**
+ * Adds a global render callback which is called each frame.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addEffect
+ */
+export const addEffect = (callback) => createSubs(callback, globalEffects);
+/**
+ * Adds a global after-render callback which is called each frame.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addAfterEffect
+ */
+export const addAfterEffect = (callback) => createSubs(callback, globalAfterEffects);
+/**
+ * Adds a global callback which is called when rendering stops.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addTail
+ */
+export const addTail = (callback) => createSubs(callback, globalTailEffects);
+function run(effects, timestamp) {
+    if (!effects.size)
+        return;
+    for (const { callback } of effects.values()) {
+        callback(timestamp);
+    }
+}
+export function flushGlobalEffects(type, timestamp) {
+    switch (type) {
+        case 'before':
+            return run(globalEffects, timestamp);
+        case 'after':
+            return run(globalAfterEffects, timestamp);
+        case 'tail':
+            return run(globalTailEffects, timestamp);
+    }
+}
+function render(timestamp, store, frame) {
+    const state = store.snapshot;
+    // Run local effects
+    let delta = state.clock.getDelta();
+    // In frameloop='never' mode, clock times are updated using the provided timestamp
+    if (state.frameloop === 'never' && typeof timestamp === 'number') {
+        delta = timestamp - state.clock.elapsedTime;
+        state.clock.oldTime = state.clock.elapsedTime;
+        state.clock.elapsedTime = timestamp;
+    }
+    // Call subscribers (beforeRender)
+    const subscribers = state.internal.subscribers;
+    for (let i = 0; i < subscribers.length; i++) {
+        const subscription = subscribers[i];
+        subscription.callback({ ...subscription.store.snapshot, delta, frame });
+    }
+    // Render content
+    if (!state.internal.priority && state.gl.render)
+        state.gl.render(state.scene, state.camera);
+    // Decrease frame count
+    state.internal.frames = Math.max(0, state.internal.frames - 1);
+    return state.frameloop === 'always' ? 1 : state.internal.frames;
+}
+function createLoop(roots) {
+    let running = false;
+    let injectBeforeRenderInProgress = false;
+    let repeat;
+    let frame;
+    function loop(timestamp) {
+        frame = requestAnimationFrame(loop);
+        running = true;
+        repeat = 0;
+        // Run effects
+        flushGlobalEffects('before', timestamp);
+        // Render all roots
+        injectBeforeRenderInProgress = true;
+        for (const root of roots.values()) {
+            const state = root.snapshot;
+            // If the frameloop is invalidated, do not run another frame
+            if (state.internal.active &&
+                (state.frameloop === 'always' || state.internal.frames > 0) &&
+                !state.gl.xr?.isPresenting) {
+                repeat += render(timestamp, root);
+            }
+        }
+        injectBeforeRenderInProgress = false;
+        // Run after-effects
+        flushGlobalEffects('after', timestamp);
+        // Stop the loop if nothing invalidates it
+        if (repeat === 0) {
+            // Tail call effects, they are called when rendering stops
+            flushGlobalEffects('tail', timestamp);
+            // Flag end of operation
+            running = false;
+            return cancelAnimationFrame(frame);
+        }
+    }
+    function invalidate(store, frames = 1) {
+        const state = store?.snapshot;
+        if (!state)
+            return roots.forEach((root) => invalidate(root, frames));
+        if (state.gl.xr?.isPresenting || !state.internal.active || state.frameloop === 'never')
+            return;
+        if (frames > 1) {
+            // legacy support for people using frames parameters
+            // Increase frames, do not go higher than 60
+            state.internal.frames = Math.min(60, state.internal.frames + frames);
+        }
+        else {
+            if (injectBeforeRenderInProgress) {
+                // called from within a injectBeforeRender, it means the user wants an additional frame
+                state.internal.frames = 2;
+            }
+            else {
+                // the user needs a new frame, no need to increment
+                state.internal.frames = 1;
+            }
+        }
+        // If the render-loop isn't active, start it
+        if (!running) {
+            running = true;
+            requestAnimationFrame(loop);
+        }
+    }
+    function advance(timestamp, runGlobalEffects = true, store, frame) {
+        if (runGlobalEffects)
+            flushGlobalEffects('before', timestamp);
+        if (!store)
+            for (const root of roots.values())
+                render(timestamp, root);
+        else
+            render(timestamp, store, frame);
+        if (runGlobalEffects)
+            flushGlobalEffects('after', timestamp);
+    }
+    return {
+        loop,
+        /**
+         * Invalidates the view, requesting a frame to be rendered. Will globally invalidate unless passed a root's state.
+         * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#invalidate
+         */
+        invalidate,
+        /**
+         * Advances the frameloop and runs render effects, useful for when manually rendering via `frameloop="never"`.
+         * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#advance
+         */
+        advance,
+    };
+}
+export const [injectNgtLoop] = createInjectionToken(() => createLoop(roots));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loop.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/loop.ts"],"names":[],"mappings":"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","sourcesContent":["import { createInjectionToken } from 'ngxtension/create-injection-token';\nimport { roots } from './roots';\nimport type { NgtState } from './store';\nimport type { NgtSignalStore } from './utils/signal-store';\n\nexport type NgtGlobalRenderCallback = (timeStamp: number) => void;\ntype SubItem = { callback: NgtGlobalRenderCallback };\n\nfunction createSubs(callback: NgtGlobalRenderCallback, subs: Set<SubItem>): () => void {\n\tconst sub = { callback };\n\tsubs.add(sub);\n\treturn () => void subs.delete(sub);\n}\n\nconst globalEffects: Set<SubItem> = new Set();\nconst globalAfterEffects: Set<SubItem> = new Set();\nconst globalTailEffects: Set<SubItem> = new Set();\n\n/**\n * Adds a global render callback which is called each frame.\n * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addEffect\n */\nexport const addEffect = (callback: NgtGlobalRenderCallback) => createSubs(callback, globalEffects);\n\n/**\n * Adds a global after-render callback which is called each frame.\n * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addAfterEffect\n */\nexport const addAfterEffect = (callback: NgtGlobalRenderCallback) => createSubs(callback, globalAfterEffects);\n\n/**\n * Adds a global callback which is called when rendering stops.\n * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addTail\n */\nexport const addTail = (callback: NgtGlobalRenderCallback) => createSubs(callback, globalTailEffects);\n\nfunction run(effects: Set<SubItem>, timestamp: number) {\n\tif (!effects.size) return;\n\tfor (const { callback } of effects.values()) {\n\t\tcallback(timestamp);\n\t}\n}\n\nexport type NgtGlobalEffectType = 'before' | 'after' | 'tail';\n\nexport function flushGlobalEffects(type: NgtGlobalEffectType, timestamp: number): void {\n\tswitch (type) {\n\t\tcase 'before':\n\t\t\treturn run(globalEffects, timestamp);\n\t\tcase 'after':\n\t\t\treturn run(globalAfterEffects, timestamp);\n\t\tcase 'tail':\n\t\t\treturn run(globalTailEffects, timestamp);\n\t}\n}\n\nfunction render(timestamp: number, store: NgtSignalStore<NgtState>, frame?: XRFrame) {\n\tconst state = store.snapshot;\n\t// Run local effects\n\tlet delta = state.clock.getDelta();\n\t// In frameloop='never' mode, clock times are updated using the provided timestamp\n\tif (state.frameloop === 'never' && typeof timestamp === 'number') {\n\t\tdelta = timestamp - state.clock.elapsedTime;\n\t\tstate.clock.oldTime = state.clock.elapsedTime;\n\t\tstate.clock.elapsedTime = timestamp;\n\t}\n\t// Call subscribers (beforeRender)\n\tconst subscribers = state.internal.subscribers;\n\tfor (let i = 0; i < subscribers.length; i++) {\n\t\tconst subscription = subscribers[i];\n\t\tsubscription.callback({ ...subscription.store.snapshot, delta, frame });\n\t}\n\t// Render content\n\tif (!state.internal.priority && state.gl.render) state.gl.render(state.scene, state.camera);\n\t// Decrease frame count\n\tstate.internal.frames = Math.max(0, state.internal.frames - 1);\n\treturn state.frameloop === 'always' ? 1 : state.internal.frames;\n}\n\nfunction createLoop<TCanvas>(roots: Map<TCanvas, NgtSignalStore<NgtState>>) {\n\tlet running = false;\n\tlet injectBeforeRenderInProgress = false;\n\tlet repeat: number;\n\tlet frame: number;\n\n\tfunction loop(timestamp: number): void {\n\t\tframe = requestAnimationFrame(loop);\n\t\trunning = true;\n\t\trepeat = 0;\n\n\t\t// Run effects\n\t\tflushGlobalEffects('before', timestamp);\n\n\t\t// Render all roots\n\t\tinjectBeforeRenderInProgress = true;\n\t\tfor (const root of roots.values()) {\n\t\t\tconst state = root.snapshot;\n\t\t\t// If the frameloop is invalidated, do not run another frame\n\t\t\tif (\n\t\t\t\tstate.internal.active &&\n\t\t\t\t(state.frameloop === 'always' || state.internal.frames > 0) &&\n\t\t\t\t!state.gl.xr?.isPresenting\n\t\t\t) {\n\t\t\t\trepeat += render(timestamp, root);\n\t\t\t}\n\t\t}\n\t\tinjectBeforeRenderInProgress = false;\n\n\t\t// Run after-effects\n\t\tflushGlobalEffects('after', timestamp);\n\n\t\t// Stop the loop if nothing invalidates it\n\t\tif (repeat === 0) {\n\t\t\t// Tail call effects, they are called when rendering stops\n\t\t\tflushGlobalEffects('tail', timestamp);\n\n\t\t\t// Flag end of operation\n\t\t\trunning = false;\n\t\t\treturn cancelAnimationFrame(frame);\n\t\t}\n\t}\n\n\tfunction invalidate(store?: NgtSignalStore<NgtState>, frames = 1): void {\n\t\tconst state = store?.snapshot;\n\t\tif (!state) return roots.forEach((root) => invalidate(root, frames));\n\t\tif (state.gl.xr?.isPresenting || !state.internal.active || state.frameloop === 'never') return;\n\n\t\tif (frames > 1) {\n\t\t\t// legacy support for people using frames parameters\n\t\t\t// Increase frames, do not go higher than 60\n\t\t\tstate.internal.frames = Math.min(60, state.internal.frames + frames);\n\t\t} else {\n\t\t\tif (injectBeforeRenderInProgress) {\n\t\t\t\t// called from within a injectBeforeRender, it means the user wants an additional frame\n\t\t\t\tstate.internal.frames = 2;\n\t\t\t} else {\n\t\t\t\t// the user needs a new frame, no need to increment\n\t\t\t\tstate.internal.frames = 1;\n\t\t\t}\n\t\t}\n\n\t\t// If the render-loop isn't active, start it\n\t\tif (!running) {\n\t\t\trunning = true;\n\t\t\trequestAnimationFrame(loop);\n\t\t}\n\t}\n\n\tfunction advance(\n\t\ttimestamp: number,\n\t\trunGlobalEffects = true,\n\t\tstore?: NgtSignalStore<NgtState>,\n\t\tframe?: XRFrame,\n\t): void {\n\t\tif (runGlobalEffects) flushGlobalEffects('before', timestamp);\n\t\tif (!store) for (const root of roots.values()) render(timestamp, root);\n\t\telse render(timestamp, store, frame);\n\t\tif (runGlobalEffects) flushGlobalEffects('after', timestamp);\n\t}\n\n\treturn {\n\t\tloop,\n\t\t/**\n\t\t * Invalidates the view, requesting a frame to be rendered. Will globally invalidate unless passed a root's state.\n\t\t * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#invalidate\n\t\t */\n\t\tinvalidate,\n\t\t/**\n\t\t * Advances the frameloop and runs render effects, useful for when manually rendering via `frameloop=\"never\"`.\n\t\t * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#advance\n\t\t */\n\t\tadvance,\n\t};\n}\n\nexport const [injectNgtLoop] = createInjectionToken(() => createLoop(roots));\n"]}

package/esm2022/lib/portal.mjs

@@ -0,0 +1,208 @@
+import { afterNextRender, ChangeDetectionStrategy, Component, computed, contentChild, CUSTOM_ELEMENTS_SCHEMA, DestroyRef, Directive, ElementRef, inject, Injector, input, signal, SkipSelf, TemplateRef, untracked, viewChild, ViewContainerRef, } from '@angular/core';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { createInjectionToken } from 'ngxtension/create-injection-token';
+import * as THREE from 'three';
+import { prepare } from './instance';
+import { injectNgtRef } from './ref';
+import { SPECIAL_INTERNAL_ADD_COMMENT } from './renderer/constants';
+import { injectNgtStore, NGT_STORE } from './store';
+import { injectBeforeRender } from './utils/before-render';
+import { is } from './utils/is';
+import { signalStore } from './utils/signal-store';
+import { updateCamera } from './utils/update';
+import * as i0 from "@angular/core";
+const privateKeys = [
+    'get',
+    'set',
+    'select',
+    'setSize',
+    'setDpr',
+    'setFrameloop',
+    'events',
+    'invalidate',
+    'advance',
+    'size',
+    'viewport',
+];
+const [, providePortalStore] = createInjectionToken((parentStore) => {
+    const parentState = parentStore.snapshot;
+    const pointer = new THREE.Vector2();
+    const raycaster = new THREE.Raycaster();
+    return signalStore(({ update }) => {
+        return {
+            ...parentState,
+            pointer,
+            raycaster,
+            previousRoot: parentStore,
+            // Layers are allowed to override events
+            setEvents: (events) => update((state) => ({ ...state, events: { ...state.events, ...events } })),
+        };
+    });
+}, { isRoot: false, token: NGT_STORE, deps: [[new SkipSelf(), NGT_STORE]] });
+export class NgtPortalBeforeRender {
+    constructor() {
+        this.portalStore = injectNgtStore();
+        this.injector = inject(Injector);
+        this.renderPriority = input(1);
+        this.parentScene = input.required();
+        this.parentCamera = input.required();
+        afterNextRender(() => {
+            let oldClear;
+            injectBeforeRender(() => {
+                const { gl, scene, camera } = this.portalStore.get();
+                oldClear = gl.autoClear;
+                if (this.renderPriority() === 1) {
+                    // clear scene and render with default
+                    gl.autoClear = true;
+                    gl.render(this.parentScene(), this.parentCamera());
+                }
+                // disable cleaning
+                gl.autoClear = false;
+                gl.clearDepth();
+                gl.render(scene, camera);
+                // restore
+                gl.autoClear = oldClear;
+            }, { priority: this.renderPriority(), injector: this.injector });
+        });
+    }
+    onPointerOver() {
+        /* noop */
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: NgtPortalBeforeRender, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.0.0", type: NgtPortalBeforeRender, isStandalone: true, selector: "ngt-portal-before-render", inputs: { renderPriority: { classPropertyName: "renderPriority", publicName: "renderPriority", isSignal: true, isRequired: false, transformFunction: null }, parentScene: { classPropertyName: "parentScene", publicName: "parentScene", isSignal: true, isRequired: true, transformFunction: null }, parentCamera: { classPropertyName: "parentCamera", publicName: "parentCamera", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0, template: `
+		<!-- Without an element that receives pointer events state.pointer will always be 0/0 -->
+		<ngt-group (pointerover)="onPointerOver()" attach="none" />
+	`, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: NgtPortalBeforeRender, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngt-portal-before-render',
+                    standalone: true,
+                    template: `
+		<!-- Without an element that receives pointer events state.pointer will always be 0/0 -->
+		<ngt-group (pointerover)="onPointerOver()" attach="none" />
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: () => [] });
+export class NgtPortalContent {
+    constructor(vcr, parentVcr) {
+        const commentNode = vcr.element.nativeElement;
+        if (commentNode[SPECIAL_INTERNAL_ADD_COMMENT]) {
+            commentNode[SPECIAL_INTERNAL_ADD_COMMENT](parentVcr.element.nativeElement);
+            delete commentNode[SPECIAL_INTERNAL_ADD_COMMENT];
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: NgtPortalContent, deps: [{ token: i0.ViewContainerRef }, { token: i0.ViewContainerRef, skipSelf: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.0", type: NgtPortalContent, isStandalone: true, selector: "ng-template[ngtPortalContent]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: NgtPortalContent, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ng-template[ngtPortalContent]', standalone: true }]
+        }], ctorParameters: () => [{ type: i0.ViewContainerRef }, { type: i0.ViewContainerRef, decorators: [{
+                    type: SkipSelf
+                }] }] });
+export class NgtPortal {
+    constructor() {
+        this.options = input({ container: injectNgtRef(prepare(new THREE.Scene())) }, {
+            transform: (value) => ({
+                container: injectNgtRef(prepare(new THREE.Scene())),
+                ...value,
+            }),
+        });
+        this.autoRender = input(false);
+        this.autoRenderPriority = input(1);
+        this.portalContentTemplate = contentChild.required(NgtPortalContent, { read: TemplateRef });
+        this.portalContentAnchor = viewChild.required('portalContentAnchor', { read: ViewContainerRef });
+        this.destroyRef = inject(DestroyRef);
+        this.autoEffect = injectAutoEffect();
+        this.parentStore = injectNgtStore({ skipSelf: true });
+        this.portalStore = injectNgtStore({ self: true });
+        this.portalRendered = signal(false);
+        this.renderAutoBeforeRender = computed(() => this.portalRendered() && this.autoRender());
+        this.parentScene = this.parentStore.get('scene');
+        this.parentCamera = this.parentStore.get('camera');
+        afterNextRender(() => {
+            const parentState = this.parentStore.snapshot;
+            const { container, state: { events = {}, size = {}, ...rest } = {} } = untracked(this.options);
+            this.portalStore.update({
+                scene: (is.ref(container) ? container.nativeElement : container),
+                events: { ...parentState.events, ...events },
+                size: { ...parentState.size, ...size },
+                ...rest,
+            });
+            this.autoEffect(() => {
+                const previous = this.parentStore.state();
+                this.portalStore.update((state) => this.inject(previous, state));
+            });
+            untracked(() => {
+                const portalView = this.portalContentAnchor().createEmbeddedView(this.portalContentTemplate());
+                portalView.detectChanges();
+                this.destroyRef.onDestroy(portalView.destroy.bind(portalView));
+            });
+            this.portalRendered.set(true);
+        });
+    }
+    inject(rootState, injectState) {
+        const intersect = { ...rootState };
+        Object.keys(intersect).forEach((key) => {
+            if (privateKeys.includes(key) ||
+                rootState[key] !== injectState[key]) {
+                delete intersect[key];
+            }
+        });
+        const inputs = untracked(this.options);
+        const { size, events, ...restInputsState } = inputs.state || {};
+        let viewport = undefined;
+        if (injectState && size) {
+            const camera = injectState.camera;
+            viewport = rootState.viewport.getCurrentViewport(camera, new THREE.Vector3(), size);
+            if (camera !== rootState.camera)
+                updateCamera(camera, size);
+        }
+        return {
+            ...intersect,
+            scene: is.ref(inputs.container) ? inputs.container.nativeElement : inputs.container,
+            previousRoot: this.parentStore,
+            events: { ...rootState.events, ...(injectState?.events || {}), ...events },
+            size: { ...rootState.size, ...size },
+            viewport: { ...rootState.viewport, ...(viewport || {}) },
+            ...restInputsState,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: NgtPortal, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.0", type: NgtPortal, isStandalone: true, selector: "ngt-portal", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null }, autoRender: { classPropertyName: "autoRender", publicName: "autoRender", isSignal: true, isRequired: false, transformFunction: null }, autoRenderPriority: { classPropertyName: "autoRenderPriority", publicName: "autoRenderPriority", isSignal: true, isRequired: false, transformFunction: null } }, providers: [providePortalStore()], queries: [{ propertyName: "portalContentTemplate", first: true, predicate: NgtPortalContent, descendants: true, read: TemplateRef, isSignal: true }], viewQueries: [{ propertyName: "portalContentAnchor", first: true, predicate: ["portalContentAnchor"], descendants: true, read: ViewContainerRef, isSignal: true }], ngImport: i0, template: `
+		<ng-container #portalContentAnchor>
+			@if (renderAutoBeforeRender()) {
+				<ngt-portal-before-render
+					[renderPriority]="autoRenderPriority()"
+					[parentScene]="parentScene"
+					[parentCamera]="parentCamera"
+				/>
+			}
+		</ng-container>
+	`, isInline: true, dependencies: [{ kind: "component", type: NgtPortalBeforeRender, selector: "ngt-portal-before-render", inputs: ["renderPriority", "parentScene", "parentCamera"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: NgtPortal, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngt-portal',
+                    standalone: true,
+                    template: `
+		<ng-container #portalContentAnchor>
+			@if (renderAutoBeforeRender()) {
+				<ngt-portal-before-render
+					[renderPriority]="autoRenderPriority()"
+					[parentScene]="parentScene"
+					[parentCamera]="parentCamera"
+				/>
+			}
+		</ng-container>
+	`,
+                    imports: [NgtPortalBeforeRender],
+                    providers: [providePortalStore()],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"portal.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/portal.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tafterNextRender,\n\tChangeDetectionStrategy,\n\tComponent,\n\tcomputed,\n\tcontentChild,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tDestroyRef,\n\tDirective,\n\tElementRef,\n\tinject,\n\tInjector,\n\tinput,\n\tsignal,\n\tSkipSelf,\n\tTemplateRef,\n\tuntracked,\n\tviewChild,\n\tViewContainerRef,\n} from '@angular/core';\nimport { injectAutoEffect } from 'ngxtension/auto-effect';\nimport { createInjectionToken } from 'ngxtension/create-injection-token';\nimport * as THREE from 'three';\nimport type { NgtEventManager } from './events';\nimport { prepare } from './instance';\nimport { injectNgtRef } from './ref';\nimport { SPECIAL_INTERNAL_ADD_COMMENT } from './renderer/constants';\nimport { injectNgtStore, NGT_STORE, type NgtSize, type NgtState } from './store';\nimport { injectBeforeRender } from './utils/before-render';\nimport { is } from './utils/is';\nimport { signalStore, type NgtSignalStore } from './utils/signal-store';\nimport { updateCamera } from './utils/update';\n\nconst privateKeys = [\n\t'get',\n\t'set',\n\t'select',\n\t'setSize',\n\t'setDpr',\n\t'setFrameloop',\n\t'events',\n\t'invalidate',\n\t'advance',\n\t'size',\n\t'viewport',\n] as const;\ntype PrivateKeys = (typeof privateKeys)[number];\n\nexport interface NgtPortalInputs {\n\tcontainer: ElementRef<THREE.Object3D> | THREE.Object3D;\n\tcamera: ElementRef<THREE.Camera> | THREE.Camera;\n\tstate: Partial<\n\t\tOmit<NgtState, PrivateKeys> & {\n\t\t\tevents: Partial<Pick<NgtEventManager<any>, 'enabled' | 'priority' | 'compute' | 'connected'>>;\n\t\t\tsize: NgtSize;\n\t\t}\n\t>;\n}\n\nconst [, providePortalStore] = createInjectionToken(\n\t(parentStore: NgtSignalStore<NgtState>) => {\n\t\tconst parentState = parentStore.snapshot;\n\t\tconst pointer = new THREE.Vector2();\n\t\tconst raycaster = new THREE.Raycaster();\n\t\treturn signalStore<NgtState>(({ update }) => {\n\t\t\treturn {\n\t\t\t\t...parentState,\n\t\t\t\tpointer,\n\t\t\t\traycaster,\n\t\t\t\tpreviousRoot: parentStore,\n\t\t\t\t// Layers are allowed to override events\n\t\t\t\tsetEvents: (events) => update((state) => ({ ...state, events: { ...state.events, ...events } })),\n\t\t\t};\n\t\t});\n\t},\n\t{ isRoot: false, token: NGT_STORE, deps: [[new SkipSelf(), NGT_STORE]] },\n);\n\n@Component({\n\tselector: 'ngt-portal-before-render',\n\tstandalone: true,\n\ttemplate: `\n\t\t<!-- Without an element that receives pointer events state.pointer will always be 0/0 -->\n\t\t<ngt-group (pointerover)=\"onPointerOver()\" attach=\"none\" />\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtPortalBeforeRender {\n\tprivate portalStore = injectNgtStore();\n\tprivate injector = inject(Injector);\n\n\trenderPriority = input(1);\n\tparentScene = input.required<THREE.Scene>();\n\tparentCamera = input.required<THREE.Camera>();\n\n\tconstructor() {\n\t\tafterNextRender(() => {\n\t\t\tlet oldClear: boolean;\n\t\t\tinjectBeforeRender(\n\t\t\t\t() => {\n\t\t\t\t\tconst { gl, scene, camera } = this.portalStore.get();\n\t\t\t\t\toldClear = gl.autoClear;\n\t\t\t\t\tif (this.renderPriority() === 1) {\n\t\t\t\t\t\t// clear scene and render with default\n\t\t\t\t\t\tgl.autoClear = true;\n\t\t\t\t\t\tgl.render(this.parentScene(), this.parentCamera());\n\t\t\t\t\t}\n\t\t\t\t\t// disable cleaning\n\t\t\t\t\tgl.autoClear = false;\n\t\t\t\t\tgl.clearDepth();\n\t\t\t\t\tgl.render(scene, camera);\n\t\t\t\t\t// restore\n\t\t\t\t\tgl.autoClear = oldClear;\n\t\t\t\t},\n\t\t\t\t{ priority: this.renderPriority(), injector: this.injector },\n\t\t\t);\n\t\t});\n\t}\n\n\tonPointerOver() {\n\t\t/* noop */\n\t}\n}\n\n@Directive({ selector: 'ng-template[ngtPortalContent]', standalone: true })\nexport class NgtPortalContent {\n\tconstructor(vcr: ViewContainerRef, @SkipSelf() parentVcr: ViewContainerRef) {\n\t\tconst commentNode = vcr.element.nativeElement;\n\t\tif (commentNode[SPECIAL_INTERNAL_ADD_COMMENT]) {\n\t\t\tcommentNode[SPECIAL_INTERNAL_ADD_COMMENT](parentVcr.element.nativeElement);\n\t\t\tdelete commentNode[SPECIAL_INTERNAL_ADD_COMMENT];\n\t\t}\n\t}\n}\n\n@Component({\n\tselector: 'ngt-portal',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ng-container #portalContentAnchor>\n\t\t\t@if (renderAutoBeforeRender()) {\n\t\t\t\t<ngt-portal-before-render\n\t\t\t\t\t[renderPriority]=\"autoRenderPriority()\"\n\t\t\t\t\t[parentScene]=\"parentScene\"\n\t\t\t\t\t[parentCamera]=\"parentCamera\"\n\t\t\t\t/>\n\t\t\t}\n\t\t</ng-container>\n\t`,\n\timports: [NgtPortalBeforeRender],\n\tproviders: [providePortalStore()],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtPortal {\n\toptions = input(\n\t\t{ container: injectNgtRef<THREE.Scene>(prepare(new THREE.Scene())) },\n\t\t{\n\t\t\ttransform: (value: Partial<NgtPortalInputs>) => ({\n\t\t\t\tcontainer: injectNgtRef<THREE.Scene>(prepare(new THREE.Scene())),\n\t\t\t\t...value,\n\t\t\t}),\n\t\t},\n\t);\n\n\tautoRender = input(false);\n\tautoRenderPriority = input(1);\n\n\tportalContentTemplate = contentChild.required(NgtPortalContent, { read: TemplateRef });\n\tportalContentAnchor = viewChild.required('portalContentAnchor', { read: ViewContainerRef });\n\n\tprivate destroyRef = inject(DestroyRef);\n\tprivate autoEffect = injectAutoEffect();\n\tprivate parentStore = injectNgtStore({ skipSelf: true });\n\tprivate portalStore = injectNgtStore({ self: true });\n\n\tprivate portalRendered = signal(false);\n\n\tprotected renderAutoBeforeRender = computed(() => this.portalRendered() && this.autoRender());\n\tprotected parentScene = this.parentStore.get('scene');\n\tprotected parentCamera = this.parentStore.get('camera');\n\n\tconstructor() {\n\t\tafterNextRender(() => {\n\t\t\tconst parentState = this.parentStore.snapshot;\n\t\t\tconst { container, state: { events = {}, size = {}, ...rest } = {} } = untracked(this.options);\n\n\t\t\tthis.portalStore.update({\n\t\t\t\tscene: (is.ref(container) ? container.nativeElement : container) as THREE.Scene,\n\t\t\t\tevents: { ...parentState.events, ...events },\n\t\t\t\tsize: { ...parentState.size, ...size },\n\t\t\t\t...rest,\n\t\t\t});\n\n\t\t\tthis.autoEffect(() => {\n\t\t\t\tconst previous = this.parentStore.state();\n\t\t\t\tthis.portalStore.update((state) => this.inject(previous, state));\n\t\t\t});\n\n\t\t\tuntracked(() => {\n\t\t\t\tconst portalView = this.portalContentAnchor().createEmbeddedView(this.portalContentTemplate());\n\t\t\t\tportalView.detectChanges();\n\t\t\t\tthis.destroyRef.onDestroy(portalView.destroy.bind(portalView));\n\t\t\t});\n\n\t\t\tthis.portalRendered.set(true);\n\t\t});\n\t}\n\n\tprivate inject(rootState: NgtState, injectState: NgtState) {\n\t\tconst intersect: Partial<NgtState> = { ...rootState };\n\n\t\tObject.keys(intersect).forEach((key) => {\n\t\t\tif (\n\t\t\t\tprivateKeys.includes(key as PrivateKeys) ||\n\t\t\t\trootState[key as keyof NgtState] !== injectState[key as keyof NgtState]\n\t\t\t) {\n\t\t\t\tdelete intersect[key as keyof NgtState];\n\t\t\t}\n\t\t});\n\n\t\tconst inputs = untracked(this.options);\n\t\tconst { size, events, ...restInputsState } = inputs.state || {};\n\n\t\tlet viewport = undefined;\n\t\tif (injectState && size) {\n\t\t\tconst camera = injectState.camera;\n\t\t\tviewport = rootState.viewport.getCurrentViewport(camera, new THREE.Vector3(), size);\n\t\t\tif (camera !== rootState.camera) updateCamera(camera, size);\n\t\t}\n\n\t\treturn {\n\t\t\t...intersect,\n\t\t\tscene: is.ref(inputs.container) ? inputs.container.nativeElement : inputs.container,\n\t\t\tpreviousRoot: this.parentStore,\n\t\t\tevents: { ...rootState.events, ...(injectState?.events || {}), ...events },\n\t\t\tsize: { ...rootState.size, ...size },\n\t\t\tviewport: { ...rootState.viewport, ...(viewport || {}) },\n\t\t\t...restInputsState,\n\t\t} as NgtState;\n\t}\n}\n"]}

package/esm2022/lib/ref.mjs

@@ -0,0 +1,46 @@
+import { DestroyRef, ElementRef, computed, inject, signal, untracked } from '@angular/core';
+import { assertInjector } from 'ngxtension/assert-injector';
+import { getLocalState } from './instance';
+import { is } from './utils/is';
+export function injectNgtRef(initial = null, injector) {
+    return assertInjector(injectNgtRef, injector, () => {
+        const ref = is.ref(initial) ? initial : new ElementRef(initial);
+        const refSignal = signal(ref.nativeElement, { equal: Object.is });
+        const readonlyRef = refSignal.asReadonly();
+        const computedCached = new Map();
+        inject(DestroyRef).onDestroy(() => void computedCached.clear());
+        const children = (type = 'objects') => {
+            if (!computedCached.has(type)) {
+                computedCached.set(type, computed(() => {
+                    const instance = readonlyRef();
+                    if (!instance)
+                        return [];
+                    const localState = getLocalState(instance);
+                    if (!localState?.instanceStore)
+                        return [];
+                    if (type === 'objects')
+                        return localState.objects();
+                    if (type === 'nonObjects')
+                        return localState.nonObjects();
+                    return [...localState.objects(), ...localState.nonObjects()];
+                }));
+            }
+            return computedCached.get(type);
+        };
+        Object.defineProperties(ref, {
+            nativeElement: {
+                set: (newElement) => {
+                    untracked(() => {
+                        if (newElement !== readonlyRef()) {
+                            refSignal.set(newElement);
+                        }
+                    });
+                },
+                get: readonlyRef,
+            },
+            children: { value: children },
+        });
+        return ref;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/renderer/catalogue.mjs

@@ -0,0 +1,7 @@
+import { createInjectionToken } from 'ngxtension/create-injection-token';
+const catalogue = {};
+export function extend(objects) {
+    Object.assign(catalogue, objects);
+}
+export const [injectNgtCatalogue] = createInjectionToken(() => catalogue);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2F0YWxvZ3VlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb3JlL3NyYy9saWIvcmVuZGVyZXIvY2F0YWxvZ3VlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBSXpFLE1BQU0sU0FBUyxHQUFzQyxFQUFFLENBQUM7QUFFeEQsTUFBTSxVQUFVLE1BQU0sQ0FBQyxPQUFlO0lBQ3JDLE1BQU0sQ0FBQyxNQUFNLENBQUMsU0FBUyxFQUFFLE9BQU8sQ0FBQyxDQUFDO0FBQ25DLENBQUM7QUFFRCxNQUFNLENBQUMsTUFBTSxDQUFDLGtCQUFrQixDQUFDLEdBQUcsb0JBQW9CLENBQUMsR0FBRyxFQUFFLENBQUMsU0FBUyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBjcmVhdGVJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ25neHRlbnNpb24vY3JlYXRlLWluamVjdGlvbi10b2tlbic7XG5cbmV4cG9ydCB0eXBlIE5ndEFueUNvbnN0cnVjdG9yID0gbmV3ICguLi5hcmdzOiBhbnlbXSkgPT4gYW55O1xuXG5jb25zdCBjYXRhbG9ndWU6IFJlY29yZDxzdHJpbmcsIE5ndEFueUNvbnN0cnVjdG9yPiA9IHt9O1xuXG5leHBvcnQgZnVuY3Rpb24gZXh0ZW5kKG9iamVjdHM6IG9iamVjdCk6IHZvaWQge1xuXHRPYmplY3QuYXNzaWduKGNhdGFsb2d1ZSwgb2JqZWN0cyk7XG59XG5cbmV4cG9ydCBjb25zdCBbaW5qZWN0Tmd0Q2F0YWxvZ3VlXSA9IGNyZWF0ZUluamVjdGlvblRva2VuKCgpID0+IGNhdGFsb2d1ZSk7XG4iXX0=

package/esm2022/lib/renderer/constants.mjs

@@ -0,0 +1,21 @@
+export const ROUTED_SCENE = '__ngt_renderer_is_routed_scene__';
+export const HTML = '__ngt_renderer_is_html';
+export const SPECIAL_INTERNAL_ADD_COMMENT = '__ngt_renderer_add_comment__';
+export const SPECIAL_DOM_TAG = {
+    NGT_PORTAL: 'ngt-portal',
+    NGT_PRIMITIVE: 'ngt-primitive',
+    NGT_VALUE: 'ngt-value',
+};
+export const SPECIAL_PROPERTIES = {
+    COMPOUND: 'ngtCompound',
+    RENDER_PRIORITY: 'priority',
+    ATTACH: 'attach',
+    RAW_VALUE: 'rawValue',
+    REF: 'ref',
+};
+export const SPECIAL_EVENTS = {
+    BEFORE_RENDER: 'beforeRender',
+    AFTER_UPDATE: 'afterUpdate',
+    AFTER_ATTACH: 'afterAttach',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb3JlL3NyYy9saWIvcmVuZGVyZXIvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLFlBQVksR0FBRyxrQ0FBa0MsQ0FBQztBQUMvRCxNQUFNLENBQUMsTUFBTSxJQUFJLEdBQUcsd0JBQXdCLENBQUM7QUFDN0MsTUFBTSxDQUFDLE1BQU0sNEJBQTRCLEdBQUcsOEJBQThCLENBQUM7QUFFM0UsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFHO0lBQzlCLFVBQVUsRUFBRSxZQUFZO0lBQ3hCLGFBQWEsRUFBRSxlQUFlO0lBQzlCLFNBQVMsRUFBRSxXQUFXO0NBQ2IsQ0FBQztBQUVYLE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHO0lBQ2pDLFFBQVEsRUFBRSxhQUFhO0lBQ3ZCLGVBQWUsRUFBRSxVQUFVO0lBQzNCLE1BQU0sRUFBRSxRQUFRO0lBQ2hCLFNBQVMsRUFBRSxVQUFVO0lBQ3JCLEdBQUcsRUFBRSxLQUFLO0NBQ0QsQ0FBQztBQUVYLE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRztJQUM3QixhQUFhLEVBQUUsY0FBYztJQUM3QixZQUFZLEVBQUUsYUFBYTtJQUMzQixZQUFZLEVBQUUsYUFBYTtDQUNsQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IFJPVVRFRF9TQ0VORSA9ICdfX25ndF9yZW5kZXJlcl9pc19yb3V0ZWRfc2NlbmVfXyc7XG5leHBvcnQgY29uc3QgSFRNTCA9ICdfX25ndF9yZW5kZXJlcl9pc19odG1sJztcbmV4cG9ydCBjb25zdCBTUEVDSUFMX0lOVEVSTkFMX0FERF9DT01NRU5UID0gJ19fbmd0X3JlbmRlcmVyX2FkZF9jb21tZW50X18nO1xuXG5leHBvcnQgY29uc3QgU1BFQ0lBTF9ET01fVEFHID0ge1xuXHROR1RfUE9SVEFMOiAnbmd0LXBvcnRhbCcsXG5cdE5HVF9QUklNSVRJVkU6ICduZ3QtcHJpbWl0aXZlJyxcblx0TkdUX1ZBTFVFOiAnbmd0LXZhbHVlJyxcbn0gYXMgY29uc3Q7XG5cbmV4cG9ydCBjb25zdCBTUEVDSUFMX1BST1BFUlRJRVMgPSB7XG5cdENPTVBPVU5EOiAnbmd0Q29tcG91bmQnLFxuXHRSRU5ERVJfUFJJT1JJVFk6ICdwcmlvcml0eScsXG5cdEFUVEFDSDogJ2F0dGFjaCcsXG5cdFJBV19WQUxVRTogJ3Jhd1ZhbHVlJyxcblx0UkVGOiAncmVmJyxcbn0gYXMgY29uc3Q7XG5cbmV4cG9ydCBjb25zdCBTUEVDSUFMX0VWRU5UUyA9IHtcblx0QkVGT1JFX1JFTkRFUjogJ2JlZm9yZVJlbmRlcicsXG5cdEFGVEVSX1VQREFURTogJ2FmdGVyVXBkYXRlJyxcblx0QUZURVJfQVRUQUNIOiAnYWZ0ZXJBdHRhY2gnLFxufSBhcyBjb25zdDtcbiJdfQ==