angular-three 1.0.0-beta.3 → 1.0.0-beta.5

package/fesm2020/angular-three.mjs

@@ -1,7 +1,7 @@
 import * as i0 from '@angular/core';
 import { ElementRef, Injectable, inject, InjectionToken, ViewContainerRef, TemplateRef, Directive, Input, EventEmitter, getDebugNode, ChangeDetectorRef, RendererFactory2, Component, Output, EnvironmentInjector, createEnvironmentInjector, HostBinding, ViewChild } from '@angular/core';
 import { injectNgxResize, provideNgxResizeOptions } from 'ngx-resize';
-import { BehaviorSubject, startWith, tap, isObservable, of, map, from, retry, catchError, share, ReplaySubject, switchMap, forkJoin, take, filter } from 'rxjs';
+import { BehaviorSubject, startWith, tap, isObservable, of, map, from, retry, catchError, share, ReplaySubject, switchMap, forkJoin, take, filter, distinctUntilChanged, takeUntil, merge } from 'rxjs';
 import { DOCUMENT, NgForOf } from '@angular/common';
 import { RxState, selectSlice } from '@rx-angular/state';
 import * as THREE from 'three';
@@ -2488,9 +2488,97 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.1", ngImpor
                 type: Input
             }] } });
 
+/**
+ * A utility injection fn that can be used in other injection fn to provide the destroy capability.
+ */
+function injectNgtDestroy(cb) {
+    try {
+        const cdr = inject(ChangeDetectorRef);
+        const destroy$ = new ReplaySubject();
+        queueMicrotask(() => {
+            cdr.onDestroy(() => {
+                destroy$.next();
+                destroy$.complete();
+                cb?.();
+            });
+        });
+        return { destroy$, cdr };
+    }
+    catch (e) {
+        console.warn(`[NGT] injectNgtDestroy is being called outside of Constructor Context`);
+        return {};
+    }
+}
+
+function injectNgtRef(initialValue = null) {
+    let ref = new ElementRef(initialValue);
+    if (is.ref(initialValue)) {
+        ref = initialValue;
+    }
+    let lastValue = ref.nativeElement;
+    const cdRefs = [];
+    const ref$ = new BehaviorSubject(lastValue);
+    const { destroy$, cdr } = injectNgtDestroy(() => {
+        ref$.complete();
+    });
+    cdRefs.push(cdr);
+    const obs$ = ref$.asObservable().pipe(distinctUntilChanged(), takeUntil(destroy$));
+    const subscribe = (callback) => {
+        return obs$.subscribe((current) => {
+            callback(current, lastValue);
+            lastValue = current;
+        });
+    };
+    const $ = obs$.pipe(filter((value, index) => index > 0 || value != null), takeUntil(destroy$));
+    const children$ = (type = 'objects') => $.pipe(switchMap((instance) => {
+        const localState = getLocalState(instance);
+        if (localState.objects && localState.nonObjects) {
+            return merge(localState.objects, localState.nonObjects).pipe(map(() => {
+                try {
+                    return type === 'both'
+                        ? [...localState.objects.value, ...localState.nonObjects.value]
+                        : localState[type].value;
+                }
+                catch (e) {
+                    console.error(`[NGT] Exception in accessing children of ${instance}`);
+                    return [];
+                }
+            }));
+        }
+        return of([]);
+    }), filter((children, index) => index > 0 || children.length > 0), takeUntil(destroy$));
+    Object.defineProperty(ref, 'nativeElement', {
+        set: (newVal) => {
+            if (ref.nativeElement !== newVal) {
+                ref$.next(newVal);
+                lastValue = ref.nativeElement;
+                ref.nativeElement = newVal;
+                // clone the cdRefs so we can mutate cdRefs in the loop
+                const cds = [...cdRefs];
+                for (let i = 0; i < cds.length; i++) {
+                    const cd = cds[i];
+                    // if a ChangeDetectorRef is destroyed, we stop tracking it and go to the next one
+                    if (cd.destroyed) {
+                        cdRefs.splice(i, 1);
+                        continue;
+                    }
+                    // during creation phase, 'context' on ViewRef will be null
+                    // we check the "context" to avoid running detectChanges during this phase.
+                    // becuase there's nothing to check
+                    if (cd['context']) {
+                        cd.detectChanges();
+                    }
+                }
+            }
+        },
+        get: () => ref$.value,
+    });
+    return Object.assign(ref, { subscribe, $, children$, useCDR: (cdr) => void cdRefs.push(cdr) });
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { NGT_CATALOGUE, NgtArgs, NgtCanvas, NgtCanvasContainer, NgtRepeat, extend };
+export { NGT_CATALOGUE, NgtArgs, NgtCanvas, NgtCanvasContainer, NgtRepeat, NgtRxStore, NgtStore, checkNeedsUpdate, checkUpdate, extend, getLocalState, injectNgtDestroy, injectNgtLoader, injectNgtRef, invalidateInstance, is, prepare, rootStateMap, startWithUndefined, updateCamera };
 //# sourceMappingURL=angular-three.mjs.map