angular-three 0.0.2 → 0.0.3

package/esm2020/lib/services/resize.mjs

@@ -0,0 +1,127 @@
+import { DOCUMENT } from '@angular/common';
+import { ElementRef, inject, Injectable, NgZone } from '@angular/core';
+import { debounceTime, fromEvent, Observable, pipe, ReplaySubject, share, Subject, takeUntil, } from 'rxjs';
+import { injectResizeObserverSupport, injectResizeOptions } from '../di/resize';
+import { injectWindow } from '../di/window';
+import * as i0 from "@angular/core";
+export class NgtResize extends Observable {
+    constructor() {
+        const { nativeElement } = inject(ElementRef);
+        const zone = inject(NgZone);
+        const document = inject(DOCUMENT);
+        const window = injectWindow();
+        const isSupport = injectResizeObserverSupport();
+        const { box, offsetSize, scroll, debounce } = injectResizeOptions();
+        let observer;
+        let lastBounds;
+        let lastEntries = [];
+        const torndown$ = new Subject();
+        const scrollContainers = findScrollContainers(nativeElement, document.body);
+        // set actual debounce values early, so effects know if they should react accordingly
+        const scrollDebounce = debounce ? (typeof debounce === 'number' ? debounce : debounce.scroll) : null;
+        const resizeDebounce = debounce ? (typeof debounce === 'number' ? debounce : debounce.resize) : null;
+        const debounceAndDestroy = (debounce) => {
+            return pipe(debounceTime(debounce ?? 0), takeUntil(torndown$));
+        };
+        super((subscriber) => {
+            if (!isSupport) {
+                subscriber.error('ResizeObserver is not supported in your browser. Please use a polyfill');
+                return;
+            }
+            zone.runOutsideAngular(() => {
+                const callback = (entries) => {
+                    lastEntries = entries;
+                    const { left, top, width, height, bottom, right, x, y } = nativeElement.getBoundingClientRect();
+                    const size = {
+                        left,
+                        top,
+                        width,
+                        height,
+                        bottom,
+                        right,
+                        x,
+                        y,
+                    };
+                    if (nativeElement instanceof HTMLElement && offsetSize) {
+                        size.height = nativeElement.offsetHeight;
+                        size.width = nativeElement.offsetWidth;
+                    }
+                    Object.freeze(size);
+                    subscriber.next({
+                        entries,
+                        dpr: window.devicePixelRatio,
+                        ...size,
+                    });
+                    if (!areBoundsEqual(lastBounds || {}, size)) {
+                        lastBounds = size;
+                    }
+                };
+                const boundEntriesCallback = () => {
+                    callback(lastEntries);
+                };
+                observer = new ResizeObserver(callback);
+                observer.observe(nativeElement, { box });
+                if (scroll) {
+                    if (scrollContainers) {
+                        scrollContainers.forEach((scrollContainer) => {
+                            fromEvent(scrollContainer, 'scroll', {
+                                capture: true,
+                                passive: true,
+                            })
+                                .pipe(debounceAndDestroy(scrollDebounce))
+                                .subscribe(boundEntriesCallback);
+                        });
+                    }
+                    fromEvent(window, 'scroll', {
+                        capture: true,
+                        passive: true,
+                    })
+                        .pipe(debounceAndDestroy(scrollDebounce))
+                        .subscribe(boundEntriesCallback);
+                }
+                fromEvent(window, 'resize').pipe(debounceAndDestroy(resizeDebounce)).subscribe(boundEntriesCallback);
+            });
+            return () => {
+                if (observer) {
+                    observer.unobserve(nativeElement);
+                    observer.disconnect();
+                }
+                torndown$.next();
+                torndown$.complete();
+            };
+        });
+        return this.pipe(debounceTime(scrollDebounce || 0), share({
+            connector: () => new ReplaySubject(1),
+            resetOnRefCountZero: true,
+            resetOnComplete: true,
+        }));
+    }
+}
+NgtResize.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtResize, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+NgtResize.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtResize });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtResize, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+// Returns a list of scroll offsets
+function findScrollContainers(element, documentBody) {
+    const result = [];
+    if (!element || element === documentBody)
+        return result;
+    const { overflow, overflowX, overflowY } = window.getComputedStyle(element);
+    if ([overflow, overflowX, overflowY].some((prop) => prop === 'auto' || prop === 'scroll'))
+        result.push(element);
+    return [...result, ...findScrollContainers(element.parentElement, documentBody)];
+}
+// Checks if element boundaries are equal
+const keys = [
+    'x',
+    'y',
+    'top',
+    'bottom',
+    'left',
+    'right',
+    'width',
+    'height',
+];
+const areBoundsEqual = (a, b) => keys.every((key) => a[key] === b[key]);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resize.js","sourceRoot":"","sources":["../../../../../../packages/angular-three/src/lib/services/resize.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport { ElementRef, inject, Injectable, NgZone } from '@angular/core';\nimport {\n    debounceTime,\n    fromEvent,\n    MonoTypeOperatorFunction,\n    Observable,\n    pipe,\n    ReplaySubject,\n    share,\n    Subject,\n    takeUntil,\n} from 'rxjs';\nimport { injectResizeObserverSupport, injectResizeOptions } from '../di/resize';\nimport { injectWindow } from '../di/window';\n\nexport interface NgtResizeResult {\n    readonly entries: ReadonlyArray<ResizeObserverEntry>;\n    readonly x: number;\n    readonly y: number;\n    readonly width: number;\n    readonly height: number;\n    readonly top: number;\n    readonly right: number;\n    readonly bottom: number;\n    readonly left: number;\n    readonly dpr: number;\n}\n\n@Injectable()\nexport class NgtResize extends Observable<NgtResizeResult> {\n    constructor() {\n        const { nativeElement } = inject(ElementRef) as ElementRef<HTMLElement>;\n        const zone = inject(NgZone);\n        const document = inject(DOCUMENT);\n        const window = injectWindow();\n        const isSupport = injectResizeObserverSupport();\n        const { box, offsetSize, scroll, debounce } = injectResizeOptions();\n\n        let observer: ResizeObserver;\n        let lastBounds: Omit<NgtResizeResult, 'entries' | 'dpr'>;\n        let lastEntries: ResizeObserverEntry[] = [];\n\n        const torndown$ = new Subject<void>();\n        const scrollContainers: HTMLOrSVGElement[] | null = findScrollContainers(nativeElement, document.body);\n\n        // set actual debounce values early, so effects know if they should react accordingly\n        const scrollDebounce = debounce ? (typeof debounce === 'number' ? debounce : debounce.scroll) : null;\n\n        const resizeDebounce = debounce ? (typeof debounce === 'number' ? debounce : debounce.resize) : null;\n\n        const debounceAndDestroy = <T>(debounce: number | null): MonoTypeOperatorFunction<T> => {\n            return pipe(debounceTime(debounce ?? 0), takeUntil(torndown$));\n        };\n\n        super((subscriber) => {\n            if (!isSupport) {\n                subscriber.error('ResizeObserver is not supported in your browser. Please use a polyfill');\n                return;\n            }\n\n            zone.runOutsideAngular(() => {\n                const callback = (entries: ResizeObserverEntry[]) => {\n                    lastEntries = entries;\n                    const { left, top, width, height, bottom, right, x, y } = nativeElement.getBoundingClientRect();\n\n                    const size = {\n                        left,\n                        top,\n                        width,\n                        height,\n                        bottom,\n                        right,\n                        x,\n                        y,\n                    };\n\n                    if (nativeElement instanceof HTMLElement && offsetSize) {\n                        size.height = nativeElement.offsetHeight;\n                        size.width = nativeElement.offsetWidth;\n                    }\n\n                    Object.freeze(size);\n                    subscriber.next({\n                        entries,\n                        dpr: window.devicePixelRatio,\n                        ...size,\n                    });\n                    if (!areBoundsEqual(lastBounds || {}, size)) {\n                        lastBounds = size;\n                    }\n                };\n\n                const boundEntriesCallback = () => {\n                    callback(lastEntries);\n                };\n\n                observer = new ResizeObserver(callback);\n                observer.observe(nativeElement, { box });\n                if (scroll) {\n                    if (scrollContainers) {\n                        scrollContainers.forEach((scrollContainer) => {\n                            fromEvent(scrollContainer as HTMLElement, 'scroll', {\n                                capture: true,\n                                passive: true,\n                            })\n                                .pipe(debounceAndDestroy(scrollDebounce))\n                                .subscribe(boundEntriesCallback);\n                        });\n                    }\n\n                    fromEvent(window, 'scroll', {\n                        capture: true,\n                        passive: true,\n                    })\n                        .pipe(debounceAndDestroy(scrollDebounce))\n                        .subscribe(boundEntriesCallback);\n                }\n\n                fromEvent(window, 'resize').pipe(debounceAndDestroy(resizeDebounce)).subscribe(boundEntriesCallback);\n            });\n\n            return () => {\n                if (observer) {\n                    observer.unobserve(nativeElement);\n                    observer.disconnect();\n                }\n                torndown$.next();\n                torndown$.complete();\n            };\n        });\n\n        return this.pipe(\n            debounceTime(scrollDebounce || 0),\n            share({\n                connector: () => new ReplaySubject(1),\n                resetOnRefCountZero: true,\n                resetOnComplete: true,\n            })\n        );\n    }\n}\n\n// Returns a list of scroll offsets\nfunction findScrollContainers(element: HTMLOrSVGElement | null, documentBody: HTMLElement): HTMLOrSVGElement[] {\n    const result: HTMLOrSVGElement[] = [];\n    if (!element || element === documentBody) return result;\n    const { overflow, overflowX, overflowY } = window.getComputedStyle(element as HTMLElement);\n    if ([overflow, overflowX, overflowY].some((prop) => prop === 'auto' || prop === 'scroll')) result.push(element);\n    return [...result, ...findScrollContainers((element as HTMLElement).parentElement, documentBody)];\n}\n\n// Checks if element boundaries are equal\nconst keys: (keyof Omit<NgtResizeResult, 'entries' | 'dpr'>)[] = [\n    'x',\n    'y',\n    'top',\n    'bottom',\n    'left',\n    'right',\n    'width',\n    'height',\n];\nconst areBoundsEqual = (a: Omit<NgtResizeResult, 'entries' | 'dpr'>, b: Omit<NgtResizeResult, 'entries' | 'dpr'>) =>\n    keys.every((key) => a[key] === b[key]);\n"]}

package/esm2020/lib/stores/component-store.mjs

@@ -0,0 +1,137 @@
+import { Injectable } from '@angular/core';
+import { ComponentStore } from '@ngrx/component-store';
+import { combineLatest, filter, isObservable, noop, tap, } from 'rxjs';
+import { is } from '../utils/is';
+import * as i0 from "@angular/core";
+/**
+ * a default Selector that consumers can quickly use for their selectors projector
+ */
+export const defaultProjector = () => ({});
+/**
+ * A custom operator that skips the first undefined value but allows subsequent undefined values.
+ * NgRxComponentStore#select always emits the first value regardless of undefined or not after initialize
+ */
+export const skipFirstUndefined = () => filter((value, index) => index > 0 || value !== undefined);
+/**
+ * An extended `tap` operator that accepts an `effectFn` which:
+ * - runs on every `next` notification from `source$`
+ * - can optionally return a `cleanUp` function that
+ * invokes from the 2nd `next` notification onward and on `unsubscribe` (destroyed)
+ *
+ *
+ * @example
+ * ```typescript
+ * source$.pipe(
+ *  tapEffect((sourceValue) = {
+ *    const cb = () => {
+ *      doStuff(sourceValue);
+ *    };
+ *    addListener('event', cb);
+ *
+ *    return () => {
+ *      removeListener('event', cb);
+ *    }
+ *  })
+ * )
+ * ```
+ */
+export function tapEffect(effectFn) {
+    let cleanupFn = noop;
+    let firstRun = false;
+    let prev = undefined;
+    const teardown = (error) => {
+        return () => {
+            if (cleanupFn) {
+                cleanupFn({ prev, complete: true, error });
+            }
+        };
+    };
+    return tap({
+        next: (value) => {
+            if (cleanupFn && firstRun) {
+                cleanupFn({ prev, complete: false, error: false });
+            }
+            const cleanUpOrVoid = effectFn(value);
+            if (cleanUpOrVoid) {
+                cleanupFn = cleanUpOrVoid;
+            }
+            prev = value;
+            if (!firstRun) {
+                firstRun = true;
+            }
+        },
+        complete: teardown(false),
+        unsubscribe: teardown(false),
+        error: teardown(true),
+    });
+}
+export class NgtComponentStore extends ComponentStore {
+    constructor() {
+        super({});
+        // exposing get since THREE is imperative at its core
+        // we need to imperatively get state sometimes for usages in Animation Loop
+        // we also bind "this" instance, so we don't have to bind it later
+        this.read = this.get.bind(this);
+        this.initialize();
+    }
+    /**
+     * A custom patchState that allows for:
+     * - Partial state updates and Observable of partial state updates like patchState
+     * - Pass a Record<string, ObservableInput> to update a specific key with an Observable.
+     * This is similar to `RxState.connect()` API
+     */
+    write(partialStateOrFactory) {
+        if (typeof partialStateOrFactory === 'function') {
+            return this.write(partialStateOrFactory(this.read()));
+        }
+        const partialState = partialStateOrFactory;
+        if (Object.keys(partialState).length === 0) {
+            return;
+        }
+        if (isObservable(partialState)) {
+            return this.patchState(partialState);
+        }
+        const entries = Object.entries(partialState);
+        const hasObservable = entries.some(([_, value]) => isObservable(value) && !is.ref(value));
+        if (!hasObservable) {
+            return this.patchState(partialState);
+        }
+        const [rawValues, observableValues] = entries.reduce((result, [key, value]) => {
+            if (isObservable(value)) {
+                result[1][key] = value;
+            }
+            else {
+                result[0][key] = value;
+            }
+            return result;
+        }, [{}, {}]);
+        if (Object.keys(rawValues).length > 0) {
+            this.patchState(rawValues);
+        }
+        if (Object.keys(observableValues).length > 0) {
+            this.patchState(combineLatest(observableValues));
+        }
+    }
+    initialize() {
+        return;
+    }
+    /**
+     * A utility class method to select a state on the template as Observable
+     * - This method always debounce the Observable
+     */
+    selectKey(key, skipFirst = false) {
+        return this.select((s) => s[key], { debounce: true }).pipe(skipFirst ? skipFirstUndefined() : (s) => s);
+    }
+    /**
+     * A utility class method to get a state on the template as imperative Value
+     */
+    readKey(key) {
+        return this.read((s) => s[key]);
+    }
+}
+NgtComponentStore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtComponentStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+NgtComponentStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtComponentStore });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtComponentStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component-store.js","sourceRoot":"","sources":["../../../../../../packages/angular-three/src/lib/stores/component-store.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ComponentStore } from '@ngrx/component-store';\nimport {\n    combineLatest,\n    filter,\n    isObservable,\n    MonoTypeOperatorFunction,\n    noop,\n    Observable,\n    ObservableInput,\n    tap,\n} from 'rxjs';\nimport type { NgtAnyRecord } from '../types';\nimport { is } from '../utils/is';\n\n/**\n * a default Selector that consumers can quickly use for their selectors projector\n */\nexport const defaultProjector = () => ({});\n\n/**\n * A custom operator that skips the first undefined value but allows subsequent undefined values.\n * NgRxComponentStore#select always emits the first value regardless of undefined or not after initialize\n */\nexport const skipFirstUndefined = <T>(): MonoTypeOperatorFunction<T> =>\n    filter<T>((value, index) => index > 0 || value !== undefined);\n\ntype EffectFn<TValue> = (\n    value: TValue\n) => void | undefined | ((cleanUpParams: { prev: TValue | undefined; complete: boolean; error: boolean }) => void);\n\n/**\n * An extended `tap` operator that accepts an `effectFn` which:\n * - runs on every `next` notification from `source$`\n * - can optionally return a `cleanUp` function that\n * invokes from the 2nd `next` notification onward and on `unsubscribe` (destroyed)\n *\n *\n * @example\n * ```typescript\n * source$.pipe(\n *  tapEffect((sourceValue) = {\n *    const cb = () => {\n *      doStuff(sourceValue);\n *    };\n *    addListener('event', cb);\n *\n *    return () => {\n *      removeListener('event', cb);\n *    }\n *  })\n * )\n * ```\n */\nexport function tapEffect<TValue>(effectFn: EffectFn<TValue>): MonoTypeOperatorFunction<TValue> {\n    let cleanupFn: (cleanUpParams: { prev: TValue | undefined; complete: boolean; error: boolean }) => void = noop;\n    let firstRun = false;\n    let prev: TValue | undefined = undefined;\n\n    const teardown = (error: boolean) => {\n        return () => {\n            if (cleanupFn) {\n                cleanupFn({ prev, complete: true, error });\n            }\n        };\n    };\n\n    return tap<TValue>({\n        next: (value: TValue) => {\n            if (cleanupFn && firstRun) {\n                cleanupFn({ prev, complete: false, error: false });\n            }\n\n            const cleanUpOrVoid = effectFn(value);\n            if (cleanUpOrVoid) {\n                cleanupFn = cleanUpOrVoid;\n            }\n\n            prev = value;\n\n            if (!firstRun) {\n                firstRun = true;\n            }\n        },\n        complete: teardown(false),\n        unsubscribe: teardown(false),\n        error: teardown(true),\n    });\n}\n\n@Injectable()\nexport class NgtComponentStore<\n    TState extends object = any,\n    TInternalState extends object = TState & NgtAnyRecord\n> extends ComponentStore<TInternalState> {\n    constructor() {\n        super({} as TInternalState);\n        this.initialize();\n    }\n\n    // exposing get since THREE is imperative at its core\n    // we need to imperatively get state sometimes for usages in Animation Loop\n    // we also bind \"this\" instance, so we don't have to bind it later\n    readonly read = this.get.bind(this);\n\n    /**\n     * A custom patchState that allows for:\n     * - Partial state updates and Observable of partial state updates like patchState\n     * - Pass a Record<string, ObservableInput> to update a specific key with an Observable.\n     * This is similar to `RxState.connect()` API\n     */\n    write(\n        partialStateOrFactory:\n            | ((state: TInternalState) => Record<string, any>)\n            | ((state: TInternalState) => Observable<Partial<TInternalState>>)\n            | Observable<Partial<TInternalState>>\n            | Record<string, any>\n    ): void {\n        if (typeof partialStateOrFactory === 'function') {\n            return this.write(partialStateOrFactory(this.read()));\n        }\n\n        const partialState = partialStateOrFactory;\n        if (Object.keys(partialState).length === 0) {\n            return;\n        }\n\n        if (isObservable(partialState)) {\n            return this.patchState(partialState as Observable<Partial<TInternalState>>);\n        }\n\n        const entries = Object.entries(partialState);\n        const hasObservable = entries.some(([_, value]) => isObservable(value) && !is.ref(value));\n\n        if (!hasObservable) {\n            return this.patchState(partialState as Partial<TInternalState>);\n        }\n\n        const [rawValues, observableValues] = entries.reduce(\n            (result, [key, value]) => {\n                if (isObservable(value)) {\n                    result[1][key as keyof TInternalState] = value;\n                } else {\n                    result[0][key as keyof TInternalState] = value as TInternalState[keyof TInternalState];\n                }\n                return result;\n            },\n            [{}, {}] as [Partial<TInternalState>, Record<keyof TInternalState, ObservableInput<any>>]\n        );\n\n        if (Object.keys(rawValues).length > 0) {\n            this.patchState(rawValues);\n        }\n\n        if (Object.keys(observableValues).length > 0) {\n            this.patchState(combineLatest(observableValues));\n        }\n    }\n\n    protected initialize() {\n        return;\n    }\n\n    /**\n     * A utility class method to select a state on the template as Observable\n     * - This method always debounce the Observable\n     */\n    selectKey<TKey extends keyof TInternalState & string>(\n        key: TKey,\n        skipFirst = false\n    ): Observable<TInternalState[TKey]> {\n        return this.select((s) => s[key], { debounce: true }).pipe(skipFirst ? skipFirstUndefined() : (s) => s);\n    }\n\n    /**\n     * A utility class method to get a state on the template as imperative Value\n     */\n    readKey<TKey extends keyof TInternalState & string>(key: TKey): TInternalState[TKey] {\n        return this.read((s) => s[key]);\n    }\n}\n"]}