angular-three-soba 2.0.0-beta.9 → 2.1.0

package/esm2022/controls/lib/scroll-controls.mjs

@@ -0,0 +1,268 @@
+import { DOCUMENT } from '@angular/common';
+import { afterNextRender, ChangeDetectionStrategy, Component, Directive, ElementRef, inject, input, model, untracked, } from '@angular/core';
+import { injectBeforeRender, injectStore, NgtHTML, pick, provideHTMLDomElement } from 'angular-three';
+import { easing } from 'maath';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import * as i0 from "@angular/core";
+const defaultOptions = {
+    eps: 0.00001,
+    horizontal: false,
+    infinite: false,
+    pages: 1,
+    distance: 1,
+    damping: 0.25,
+    maxSpeed: Infinity,
+    prepend: false,
+    enabled: true,
+    style: {},
+};
+export class NgtsScrollControls {
+    constructor() {
+        this.progress = model(0);
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.document = inject(DOCUMENT);
+        this.store = injectStore();
+        this.gl = this.store.select('gl');
+        this.events = this.store.select('events');
+        this.invalidate = this.store.select('invalidate');
+        this.size = this.store.select('size');
+        this.domElement = pick(this.gl, 'domElement');
+        this.target = pick(this.domElement, 'parentNode');
+        this._el = this.document.createElement('div');
+        this._fill = this.document.createElement('div');
+        this._fixed = this.document.createElement('div');
+        this.style = pick(this.options, 'style');
+        this.prepend = pick(this.options, 'prepend');
+        this.enabled = pick(this.options, 'enabled');
+        this.infinite = pick(this.options, 'infinite');
+        this.maxSpeed = pick(this.options, 'maxSpeed');
+        this.eps = pick(this.options, 'eps');
+        this.horizontal = pick(this.options, 'horizontal');
+        this.pages = pick(this.options, 'pages');
+        this.distance = pick(this.options, 'distance');
+        this.damping = pick(this.options, 'damping');
+        this.scroll = 0;
+        this.offset = 0;
+        this.delta = 0;
+        const autoEffect = injectAutoEffect();
+        afterNextRender(() => {
+            autoEffect(() => {
+                const target = this.target();
+                if (!target)
+                    return;
+                const parent = target;
+                const [pages, distance, horizontal, el, fill, fixed, style, prepend, domElement, events] = [
+                    this.pages(),
+                    this.distance(),
+                    this.horizontal(),
+                    this.el,
+                    this.fill,
+                    this.fixed,
+                    untracked(this.style),
+                    untracked(this.prepend),
+                    untracked(this.domElement),
+                    untracked(this.events),
+                ];
+                el.style.position = 'absolute';
+                el.style.width = '100%';
+                el.style.height = '100%';
+                el.style[horizontal ? 'overflowX' : 'overflowY'] = 'auto';
+                el.style[horizontal ? 'overflowY' : 'overflowX'] = 'hidden';
+                el.style.top = '0px';
+                el.style.left = '0px';
+                for (const key in style) {
+                    el.style[key] = style[key];
+                }
+                fixed.style.position = 'sticky';
+                fixed.style.top = '0px';
+                fixed.style.left = '0px';
+                fixed.style.width = '100%';
+                fixed.style.height = '100%';
+                fixed.style.overflow = 'hidden';
+                el.appendChild(fixed);
+                fill.style.height = horizontal ? '100%' : `${pages * distance * 100}%`;
+                fill.style.width = horizontal ? `${pages * distance * 100}%` : '100%';
+                fill.style.pointerEvents = 'none';
+                el.appendChild(fill);
+                if (prepend)
+                    parent.prepend(el);
+                else
+                    parent.appendChild(el);
+                // Init scroll one pixel in to allow upward/leftward scroll
+                el[horizontal ? 'scrollLeft' : 'scrollTop'] = 1;
+                const oldTarget = (events.connected || domElement);
+                requestAnimationFrame(() => events.connect?.(el));
+                const oldCompute = events.compute?.bind(events);
+                this.store.snapshot.setEvents({
+                    compute(event, store) {
+                        const state = store.snapshot;
+                        // we are using boundingClientRect because we could not rely on target.offsetTop as canvas could be positioned anywhere in dom
+                        const { left, top } = parent.getBoundingClientRect();
+                        const offsetX = event.clientX - left;
+                        const offsetY = event.clientY - top;
+                        state.pointer.set((offsetX / state.size.width) * 2 - 1, -(offsetY / state.size.height) * 2 + 1);
+                        state.raycaster.setFromCamera(state.pointer, state.camera);
+                    },
+                });
+                return () => {
+                    parent.removeChild(el);
+                    this.store.snapshot.setEvents({ compute: oldCompute });
+                    events.connect?.(oldTarget);
+                };
+            });
+            autoEffect(() => {
+                const [el, events, size, infinite, invalidate, horizontal, enabled] = [
+                    this.el,
+                    this.events(),
+                    this.size(),
+                    this.infinite(),
+                    this.invalidate(),
+                    this.horizontal(),
+                    this.enabled(),
+                ];
+                if (events.connected !== el)
+                    return;
+                const containerLength = size[horizontal ? 'width' : 'height'];
+                const scrollLength = el[horizontal ? 'scrollWidth' : 'scrollHeight'];
+                const scrollThreshold = scrollLength - containerLength;
+                let current = 0;
+                let disableScroll = true;
+                let firstRun = true;
+                const onScroll = () => {
+                    // Prevent first scroll because it is indirectly caused by the one pixel offset
+                    if (!enabled || firstRun)
+                        return;
+                    invalidate();
+                    current = el[horizontal ? 'scrollLeft' : 'scrollTop'];
+                    this.scroll = current / scrollThreshold;
+                    if (infinite) {
+                        if (!disableScroll) {
+                            if (current >= scrollThreshold) {
+                                const damp = 1 - this.offset;
+                                el[horizontal ? 'scrollLeft' : 'scrollTop'] = 1;
+                                this.scroll = this.offset = -damp;
+                                disableScroll = true;
+                            }
+                            else if (current <= 0) {
+                                const damp = 1 + this.offset;
+                                el[horizontal ? 'scrollLeft' : 'scrollTop'] = scrollLength;
+                                this.scroll = this.offset = damp;
+                                disableScroll = true;
+                            }
+                        }
+                        if (disableScroll)
+                            setTimeout(() => (disableScroll = false), 40);
+                    }
+                    untracked(() => {
+                        this.progress.set(this.scroll);
+                    });
+                };
+                el.addEventListener('scroll', onScroll, { passive: true });
+                requestAnimationFrame(() => (firstRun = false));
+                const onWheel = (e) => (el[horizontal ? 'scrollLeft' : 'scrollTop'] += e.deltaY / 2);
+                if (horizontal)
+                    el.addEventListener('wheel', onWheel, { passive: true });
+                return () => {
+                    el.removeEventListener('scroll', onScroll);
+                    if (horizontal)
+                        el.removeEventListener('wheel', onWheel);
+                };
+            });
+        });
+        let last = 0;
+        injectBeforeRender(({ delta }) => {
+            last = this.offset;
+            easing.damp(this, 'offset', this.scroll, this.damping(), delta, this.maxSpeed(), undefined, this.eps());
+            easing.damp(this, 'delta', Math.abs(last - this.offset), this.damping(), delta, this.maxSpeed(), undefined, this.eps());
+            if (this.delta > this.eps())
+                this.invalidate()();
+        });
+    }
+    get el() {
+        return this._el;
+    }
+    get fill() {
+        return this._fill;
+    }
+    get fixed() {
+        return this._fixed;
+    }
+    range(from, distance, margin = 0) {
+        const start = from - margin;
+        const end = start + distance + margin * 2;
+        return this.offset < start ? 0 : this.offset > end ? 1 : (this.offset - start) / (end - start);
+    }
+    curve(from, distance, margin = 0) {
+        return Math.sin(this.range(from, distance, margin) * Math.PI);
+    }
+    visible(from, distance, margin = 0) {
+        const start = from - margin;
+        const end = start + distance + margin * 2;
+        return this.offset >= start && this.offset <= end;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsScrollControls, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.0", type: NgtsScrollControls, isStandalone: true, selector: "ngts-scroll-controls", inputs: { progress: { classPropertyName: "progress", publicName: "progress", isSignal: true, isRequired: false, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { progress: "progressChange" }, ngImport: i0, template: `
+		<ng-content />
+	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsScrollControls, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-scroll-controls',
+                    standalone: true,
+                    template: `
+		<ng-content />
+	`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+export class NgtsScrollCanvas {
+    constructor() {
+        this.host = inject(ElementRef);
+        this.scrollControls = inject(NgtsScrollControls);
+        this.store = injectStore();
+        this.viewport = this.store.select('viewport');
+        injectBeforeRender(() => {
+            const group = this.host.nativeElement;
+            group.position.x = this.scrollControls.horizontal()
+                ? -this.viewport().width * (this.scrollControls.pages() - 1) * this.scrollControls.offset
+                : 0;
+            group.position.y = this.scrollControls.horizontal()
+                ? 0
+                : this.viewport().height * (this.scrollControls.pages() - 1) * this.scrollControls.offset;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsScrollCanvas, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.0", type: NgtsScrollCanvas, isStandalone: true, selector: "ngt-group[ngtsScrollCanvas]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsScrollCanvas, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ngt-group[ngtsScrollCanvas]', standalone: true }]
+        }], ctorParameters: () => [] });
+export class NgtsScrollHtml extends NgtHTML {
+    constructor() {
+        super();
+        this.scrollControls = inject(NgtsScrollControls);
+        this.size = this.store.select('size');
+        injectBeforeRender(() => {
+            if (this.scrollControls.delta > this.scrollControls.eps()) {
+                this.host.nativeElement.style.transform = `translate3d(${this.scrollControls.horizontal()
+                    ? -this.size().width * (this.scrollControls.pages() - 1) * this.scrollControls.offset
+                    : 0}px,${this.scrollControls.horizontal() ? 0 : this.size().height * (this.scrollControls.pages() - 1) * -this.scrollControls.offset}px,0)`;
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsScrollHtml, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.0", type: NgtsScrollHtml, isStandalone: true, selector: "div[ngtsScrollHTML]", host: { styleAttribute: "position: absolute; top: 0; left: 0; will-change: transform;" }, providers: [provideHTMLDomElement([NgtsScrollControls], (scrollControls) => scrollControls.fixed)], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsScrollHtml, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'div[ngtsScrollHTML]',
+                    standalone: true,
+                    host: { style: 'position: absolute; top: 0; left: 0; will-change: transform;' },
+                    providers: [provideHTMLDomElement([NgtsScrollControls], (scrollControls) => scrollControls.fixed)],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scroll-controls.js","sourceRoot":"","sources":["../../../../../../libs/soba/controls/src/lib/scroll-controls.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport {\n\tafterNextRender,\n\tChangeDetectionStrategy,\n\tComponent,\n\tDirective,\n\tElementRef,\n\tinject,\n\tinput,\n\tmodel,\n\tuntracked,\n} from '@angular/core';\nimport { injectBeforeRender, injectStore, NgtHTML, pick, provideHTMLDomElement } from 'angular-three';\nimport { easing } from 'maath';\nimport { injectAutoEffect } from 'ngxtension/auto-effect';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { Group } from 'three';\n\nexport interface NgtsScrollControlsOptions {\n\t/** Precision, default 0.00001 */\n\teps: number;\n\t/** Horizontal scroll, default false (vertical) */\n\thorizontal: boolean;\n\t/** Infinite scroll, default false (experimental!) */\n\tinfinite: boolean;\n\t/** Defines the lenght of the scroll area, each page is height:100%, default 1 */\n\tpages: number;\n\t/** A factor that increases scroll bar travel,default: 1 */\n\tdistance: number;\n\t/** Friction in seconds, default: 0.25 (1/4 second) */\n\tdamping: number;\n\t/** maxSpeed optionally allows you to clamp the maximum speed. If damping is 0.2s and looks OK\n\t *  going between, say, page 1 and 2, but not for pages far apart as it'll move very rapid,\n\t *  then a maxSpeed of e.g. 3 which will clamp the speed to 3 units per second, it may now\n\t *  take much longer than damping to reach the target if it is far away. Default: Infinity */\n\tmaxSpeed: number;\n\t/** If true attaches the scroll container before the canvas */\n\tprepend: boolean;\n\tenabled: boolean;\n\tstyle: Partial<CSSStyleDeclaration>;\n}\n\nconst defaultOptions: NgtsScrollControlsOptions = {\n\teps: 0.00001,\n\thorizontal: false,\n\tinfinite: false,\n\tpages: 1,\n\tdistance: 1,\n\tdamping: 0.25,\n\tmaxSpeed: Infinity,\n\tprepend: false,\n\tenabled: true,\n\tstyle: {},\n};\n\n@Component({\n\tselector: 'ngts-scroll-controls',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ng-content />\n\t`,\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsScrollControls {\n\tprogress = model(0);\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\n\tprivate document = inject(DOCUMENT);\n\tprivate store = injectStore();\n\tprivate gl = this.store.select('gl');\n\tprivate events = this.store.select('events');\n\tprivate invalidate = this.store.select('invalidate');\n\tprivate size = this.store.select('size');\n\n\tprivate domElement = pick(this.gl, 'domElement');\n\tprivate target = pick(this.domElement, 'parentNode');\n\n\tprivate _el = this.document.createElement('div');\n\tprivate _fill = this.document.createElement('div');\n\tprivate _fixed = this.document.createElement('div');\n\n\tprivate style = pick(this.options, 'style');\n\tprivate prepend = pick(this.options, 'prepend');\n\tprivate enabled = pick(this.options, 'enabled');\n\tprivate infinite = pick(this.options, 'infinite');\n\tprivate maxSpeed = pick(this.options, 'maxSpeed');\n\teps = pick(this.options, 'eps');\n\thorizontal = pick(this.options, 'horizontal');\n\tpages = pick(this.options, 'pages');\n\tdistance = pick(this.options, 'distance');\n\tdamping = pick(this.options, 'damping');\n\tscroll = 0;\n\toffset = 0;\n\tdelta = 0;\n\n\tconstructor() {\n\t\tconst autoEffect = injectAutoEffect();\n\n\t\tafterNextRender(() => {\n\t\t\tautoEffect(() => {\n\t\t\t\tconst target = this.target();\n\t\t\t\tif (!target) return;\n\n\t\t\t\tconst parent = target as HTMLElement;\n\t\t\t\tconst [pages, distance, horizontal, el, fill, fixed, style, prepend, domElement, events] = [\n\t\t\t\t\tthis.pages(),\n\t\t\t\t\tthis.distance(),\n\t\t\t\t\tthis.horizontal(),\n\t\t\t\t\tthis.el,\n\t\t\t\t\tthis.fill,\n\t\t\t\t\tthis.fixed,\n\t\t\t\t\tuntracked(this.style),\n\t\t\t\t\tuntracked(this.prepend),\n\t\t\t\t\tuntracked(this.domElement),\n\t\t\t\t\tuntracked(this.events),\n\t\t\t\t];\n\n\t\t\t\tel.style.position = 'absolute';\n\t\t\t\tel.style.width = '100%';\n\t\t\t\tel.style.height = '100%';\n\t\t\t\tel.style[horizontal ? 'overflowX' : 'overflowY'] = 'auto';\n\t\t\t\tel.style[horizontal ? 'overflowY' : 'overflowX'] = 'hidden';\n\t\t\t\tel.style.top = '0px';\n\t\t\t\tel.style.left = '0px';\n\n\t\t\t\tfor (const key in style) {\n\t\t\t\t\tel.style[key] = (style as CSSStyleDeclaration)[key];\n\t\t\t\t}\n\n\t\t\t\tfixed.style.position = 'sticky';\n\t\t\t\tfixed.style.top = '0px';\n\t\t\t\tfixed.style.left = '0px';\n\t\t\t\tfixed.style.width = '100%';\n\t\t\t\tfixed.style.height = '100%';\n\t\t\t\tfixed.style.overflow = 'hidden';\n\t\t\t\tel.appendChild(fixed);\n\n\t\t\t\tfill.style.height = horizontal ? '100%' : `${pages * distance * 100}%`;\n\t\t\t\tfill.style.width = horizontal ? `${pages * distance * 100}%` : '100%';\n\t\t\t\tfill.style.pointerEvents = 'none';\n\t\t\t\tel.appendChild(fill);\n\n\t\t\t\tif (prepend) parent.prepend(el);\n\t\t\t\telse parent.appendChild(el);\n\n\t\t\t\t// Init scroll one pixel in to allow upward/leftward scroll\n\t\t\t\tel[horizontal ? 'scrollLeft' : 'scrollTop'] = 1;\n\n\t\t\t\tconst oldTarget = (events.connected || domElement) as HTMLElement;\n\t\t\t\trequestAnimationFrame(() => events.connect?.(el));\n\t\t\t\tconst oldCompute = events.compute?.bind(events);\n\n\t\t\t\tthis.store.snapshot.setEvents({\n\t\t\t\t\tcompute(event, store) {\n\t\t\t\t\t\tconst state = store.snapshot;\n\t\t\t\t\t\t// we are using boundingClientRect because we could not rely on target.offsetTop as canvas could be positioned anywhere in dom\n\t\t\t\t\t\tconst { left, top } = parent.getBoundingClientRect();\n\t\t\t\t\t\tconst offsetX = event.clientX - left;\n\t\t\t\t\t\tconst offsetY = event.clientY - top;\n\t\t\t\t\t\tstate.pointer.set((offsetX / state.size.width) * 2 - 1, -(offsetY / state.size.height) * 2 + 1);\n\t\t\t\t\t\tstate.raycaster.setFromCamera(state.pointer, state.camera);\n\t\t\t\t\t},\n\t\t\t\t});\n\n\t\t\t\treturn () => {\n\t\t\t\t\tparent.removeChild(el);\n\t\t\t\t\tthis.store.snapshot.setEvents({ compute: oldCompute });\n\t\t\t\t\tevents.connect?.(oldTarget);\n\t\t\t\t};\n\t\t\t});\n\n\t\t\tautoEffect(() => {\n\t\t\t\tconst [el, events, size, infinite, invalidate, horizontal, enabled] = [\n\t\t\t\t\tthis.el,\n\t\t\t\t\tthis.events(),\n\t\t\t\t\tthis.size(),\n\t\t\t\t\tthis.infinite(),\n\t\t\t\t\tthis.invalidate(),\n\t\t\t\t\tthis.horizontal(),\n\t\t\t\t\tthis.enabled(),\n\t\t\t\t];\n\n\t\t\t\tif (events.connected !== el) return;\n\n\t\t\t\tconst containerLength = size[horizontal ? 'width' : 'height'];\n\t\t\t\tconst scrollLength = el[horizontal ? 'scrollWidth' : 'scrollHeight'];\n\t\t\t\tconst scrollThreshold = scrollLength - containerLength;\n\n\t\t\t\tlet current = 0;\n\t\t\t\tlet disableScroll = true;\n\t\t\t\tlet firstRun = true;\n\n\t\t\t\tconst onScroll = () => {\n\t\t\t\t\t// Prevent first scroll because it is indirectly caused by the one pixel offset\n\t\t\t\t\tif (!enabled || firstRun) return;\n\t\t\t\t\tinvalidate();\n\t\t\t\t\tcurrent = el[horizontal ? 'scrollLeft' : 'scrollTop'];\n\t\t\t\t\tthis.scroll = current / scrollThreshold;\n\n\t\t\t\t\tif (infinite) {\n\t\t\t\t\t\tif (!disableScroll) {\n\t\t\t\t\t\t\tif (current >= scrollThreshold) {\n\t\t\t\t\t\t\t\tconst damp = 1 - this.offset;\n\t\t\t\t\t\t\t\tel[horizontal ? 'scrollLeft' : 'scrollTop'] = 1;\n\t\t\t\t\t\t\t\tthis.scroll = this.offset = -damp;\n\t\t\t\t\t\t\t\tdisableScroll = true;\n\t\t\t\t\t\t\t} else if (current <= 0) {\n\t\t\t\t\t\t\t\tconst damp = 1 + this.offset;\n\t\t\t\t\t\t\t\tel[horizontal ? 'scrollLeft' : 'scrollTop'] = scrollLength;\n\t\t\t\t\t\t\t\tthis.scroll = this.offset = damp;\n\t\t\t\t\t\t\t\tdisableScroll = true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (disableScroll) setTimeout(() => (disableScroll = false), 40);\n\t\t\t\t\t}\n\n\t\t\t\t\tuntracked(() => {\n\t\t\t\t\t\tthis.progress.set(this.scroll);\n\t\t\t\t\t});\n\t\t\t\t};\n\n\t\t\t\tel.addEventListener('scroll', onScroll, { passive: true });\n\t\t\t\trequestAnimationFrame(() => (firstRun = false));\n\n\t\t\t\tconst onWheel = (e: WheelEvent) => (el[horizontal ? 'scrollLeft' : 'scrollTop'] += e.deltaY / 2);\n\t\t\t\tif (horizontal) el.addEventListener('wheel', onWheel, { passive: true });\n\n\t\t\t\treturn () => {\n\t\t\t\t\tel.removeEventListener('scroll', onScroll);\n\t\t\t\t\tif (horizontal) el.removeEventListener('wheel', onWheel);\n\t\t\t\t};\n\t\t\t});\n\t\t});\n\n\t\tlet last = 0;\n\t\tinjectBeforeRender(({ delta }) => {\n\t\t\tlast = this.offset;\n\t\t\teasing.damp(this, 'offset', this.scroll, this.damping(), delta, this.maxSpeed(), undefined, this.eps());\n\t\t\teasing.damp(\n\t\t\t\tthis,\n\t\t\t\t'delta',\n\t\t\t\tMath.abs(last - this.offset),\n\t\t\t\tthis.damping(),\n\t\t\t\tdelta,\n\t\t\t\tthis.maxSpeed(),\n\t\t\t\tundefined,\n\t\t\t\tthis.eps(),\n\t\t\t);\n\t\t\tif (this.delta > this.eps()) this.invalidate()();\n\t\t});\n\t}\n\n\tget el() {\n\t\treturn this._el;\n\t}\n\n\tget fill() {\n\t\treturn this._fill;\n\t}\n\n\tget fixed() {\n\t\treturn this._fixed;\n\t}\n\n\trange(from: number, distance: number, margin = 0): number {\n\t\tconst start = from - margin;\n\t\tconst end = start + distance + margin * 2;\n\t\treturn this.offset < start ? 0 : this.offset > end ? 1 : (this.offset - start) / (end - start);\n\t}\n\n\tcurve(from: number, distance: number, margin = 0): number {\n\t\treturn Math.sin(this.range(from, distance, margin) * Math.PI);\n\t}\n\n\tvisible(from: number, distance: number, margin = 0): boolean {\n\t\tconst start = from - margin;\n\t\tconst end = start + distance + margin * 2;\n\t\treturn this.offset >= start && this.offset <= end;\n\t}\n}\n\n@Directive({ selector: 'ngt-group[ngtsScrollCanvas]', standalone: true })\nexport class NgtsScrollCanvas {\n\tprivate host = inject<ElementRef<Group>>(ElementRef);\n\tprivate scrollControls = inject(NgtsScrollControls);\n\tprivate store = injectStore();\n\tprivate viewport = this.store.select('viewport');\n\n\tconstructor() {\n\t\tinjectBeforeRender(() => {\n\t\t\tconst group = this.host.nativeElement;\n\n\t\t\tgroup.position.x = this.scrollControls.horizontal()\n\t\t\t\t? -this.viewport().width * (this.scrollControls.pages() - 1) * this.scrollControls.offset\n\t\t\t\t: 0;\n\t\t\tgroup.position.y = this.scrollControls.horizontal()\n\t\t\t\t? 0\n\t\t\t\t: this.viewport().height * (this.scrollControls.pages() - 1) * this.scrollControls.offset;\n\t\t});\n\t}\n}\n\n@Directive({\n\tselector: 'div[ngtsScrollHTML]',\n\tstandalone: true,\n\thost: { style: 'position: absolute; top: 0; left: 0; will-change: transform;' },\n\tproviders: [provideHTMLDomElement([NgtsScrollControls], (scrollControls) => scrollControls.fixed)],\n})\nexport class NgtsScrollHtml extends NgtHTML {\n\tprivate scrollControls = inject(NgtsScrollControls);\n\tprivate size = this.store.select('size');\n\n\tconstructor() {\n\t\tsuper();\n\t\tinjectBeforeRender(() => {\n\t\t\tif (this.scrollControls.delta > this.scrollControls.eps()) {\n\t\t\t\tthis.host.nativeElement.style.transform = `translate3d(${\n\t\t\t\t\tthis.scrollControls.horizontal()\n\t\t\t\t\t\t? -this.size().width * (this.scrollControls.pages() - 1) * this.scrollControls.offset\n\t\t\t\t\t\t: 0\n\t\t\t\t}px,${this.scrollControls.horizontal() ? 0 : this.size().height * (this.scrollControls.pages() - 1) * -this.scrollControls.offset}px,0)`;\n\t\t\t}\n\t\t});\n\t}\n}\n"]}

package/esm2022/loaders/index.mjs

@@ -1,5 +1,6 @@
-export * from './gltf-loader/gltf-loader';
-export * from './loader/loader';
-export * from './progress/progress';
-export * from './texture-loader/texture-loader';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvbG9hZGVycy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxpQ0FBaUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZ2x0Zi1sb2FkZXIvZ2x0Zi1sb2FkZXInO1xuZXhwb3J0ICogZnJvbSAnLi9sb2FkZXIvbG9hZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvZ3Jlc3MvcHJvZ3Jlc3MnO1xuZXhwb3J0ICogZnJvbSAnLi90ZXh0dXJlLWxvYWRlci90ZXh0dXJlLWxvYWRlcic7XG4iXX0=
+export * from './lib/font-loader';
+export * from './lib/gltf-loader';
+export * from './lib/loader';
+export * from './lib/progress';
+export * from './lib/texture-loader';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvbG9hZGVycy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL2ZvbnQtbG9hZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2dsdGYtbG9hZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2xvYWRlcic7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9wcm9ncmVzcyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi90ZXh0dXJlLWxvYWRlcic7XG4iXX0=

package/esm2022/loaders/lib/font-loader.mjs

@@ -0,0 +1,49 @@
+import { effect, signal, untracked } from '@angular/core';
+import { assertInjector } from 'ngxtension/assert-injector';
+import { FontLoader } from 'three-stdlib';
+let fontLoader = null;
+async function loadFontData(font) {
+    return typeof font === 'string' ? await (await fetch(font)).json() : font;
+}
+function parseFontData(fontData) {
+    if (!fontLoader) {
+        fontLoader = new FontLoader();
+    }
+    return fontLoader.parse(fontData);
+}
+const cache = new Map();
+export function injectFont(input, { injector } = {}) {
+    return assertInjector(injectFont, injector, () => {
+        const font = signal(null);
+        effect(() => {
+            const fontInput = input();
+            if (cache.has(fontInput)) {
+                untracked(() => {
+                    font.set(cache.get(fontInput));
+                });
+                return;
+            }
+            loadFontData(input()).then((data) => {
+                const parsed = parseFontData(data);
+                cache.set(fontInput, parsed);
+                font.set(parsed);
+            });
+        });
+        return font.asReadonly();
+    });
+}
+injectFont.preload = (input) => {
+    loadFontData(input()).then((data) => {
+        const parsed = parseFontData(data);
+        cache.set(input(), parsed);
+    });
+};
+injectFont.clear = (input) => {
+    if (input) {
+        cache.delete(input());
+    }
+    else {
+        cache.clear();
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/loaders/lib/gltf-loader.mjs

@@ -0,0 +1,51 @@
+import { computed } from '@angular/core';
+import { injectLoader } from 'angular-three';
+import { assertInjector } from 'ngxtension/assert-injector';
+import { DRACOLoader, GLTFLoader, MeshoptDecoder } from 'three-stdlib';
+let dracoLoader = null;
+let decoderPath = 'https://www.gstatic.com/draco/versioned/decoders/1.5.5/';
+function _extensions(useDraco, useMeshOpt, extensions) {
+    return (loader) => {
+        if (extensions) {
+            extensions(loader);
+        }
+        if (useDraco) {
+            if (!dracoLoader) {
+                dracoLoader = new DRACOLoader();
+            }
+            dracoLoader.setDecoderPath(typeof useDraco === 'string' ? useDraco : decoderPath);
+            loader.setDRACOLoader(dracoLoader);
+        }
+        if (useMeshOpt) {
+            loader.setMeshoptDecoder(typeof MeshoptDecoder === 'function' ? MeshoptDecoder() : MeshoptDecoder);
+        }
+    };
+}
+function _injectGLTF(path, { useDraco = true, useMeshOpt = true, injector, extensions, onLoad, } = {}) {
+    return assertInjector(_injectGLTF, injector, () => {
+        const result = injectLoader(() => GLTFLoader, path, {
+            extensions: _extensions(useDraco, useMeshOpt, extensions),
+            // @ts-expect-error - we know the type of the data
+            onLoad,
+        });
+        Object.defineProperty(result, 'scene', {
+            value: computed(() => {
+                const gltf = result();
+                if (!gltf)
+                    return null;
+                return gltf.scene;
+            }),
+        });
+        return result;
+    });
+}
+_injectGLTF.preload = (path, { useDraco = true, useMeshOpt = true, extensions, onLoad, } = {}) => {
+    injectLoader.preload(() => GLTFLoader, path, _extensions(useDraco, useMeshOpt, extensions), 
+    // @ts-expect-error - we know the type of the data
+    onLoad);
+};
+_injectGLTF.setDecoderPath = (path) => {
+    decoderPath = path;
+};
+export const injectGLTF = _injectGLTF;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/loaders/lib/loader.mjs

@@ -0,0 +1,109 @@
+import { ChangeDetectionStrategy, Component, computed, effect, input, signal, untracked, viewChild, } from '@angular/core';
+import { pick } from 'angular-three';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { injectProgress } from './progress';
+import * as i0 from "@angular/core";
+const defaultDataInterpolation = (p) => `Loading ${p.toFixed(2)}%`;
+const defaultOptions = {
+    containerClass: '',
+    innerClass: '',
+    barClass: '',
+    dataClass: '',
+    dataInterpolation: defaultDataInterpolation,
+    initialState: (value) => value,
+};
+export class NgtsLoader {
+    constructor() {
+        this.progressState = injectProgress();
+        this.active = computed(() => this.progressState().active);
+        this.progress = computed(() => this.progressState().progress);
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.containerClass = pick(this.options, 'containerClass');
+        this.innerClass = pick(this.options, 'innerClass');
+        this.barClass = pick(this.options, 'barClass');
+        this.dataClass = pick(this.options, 'dataClass');
+        this.initialState = pick(this.options, 'initialState');
+        this.dataInterpolation = pick(this.options, 'dataInterpolation');
+        this.progressSpanRef = viewChild('progressSpanRef');
+        this.shown = signal(this.initialState()(this.active()));
+        this.setShown();
+        this.updateProgress();
+    }
+    setShown() {
+        effect((onCleanup) => {
+            const [active, lastShown] = [this.active(), untracked(this.shown)];
+            if (lastShown !== active) {
+                const timeoutId = setTimeout(() => {
+                    this.shown.set(active);
+                }, 300);
+                onCleanup(() => clearTimeout(timeoutId));
+            }
+        });
+    }
+    updateProgress() {
+        let progressRef = 0;
+        let rafId;
+        effect((onCleanup) => {
+            const [dataInterpolation, progress] = [this.dataInterpolation(), this.progress()];
+            const updateProgress = () => {
+                const progressSpan = this.progressSpanRef()?.nativeElement;
+                if (!progressSpan)
+                    return;
+                progressRef += (progress - progressRef) / 2;
+                if (progressRef > 0.95 * progress || progress === 100)
+                    progressRef = progress;
+                progressSpan.innerText = dataInterpolation(progressRef);
+                if (progressRef < progress) {
+                    rafId = requestAnimationFrame(updateProgress);
+                }
+            };
+            updateProgress();
+            onCleanup(() => cancelAnimationFrame(rafId));
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsLoader, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.0", type: NgtsLoader, isStandalone: true, selector: "ngts-loader", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "progressSpanRef", first: true, predicate: ["progressSpanRef"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		@if (shown()) {
+			<div
+				class="ngts-loader-container"
+				[class]="containerClass() || ''"
+				[style.--ngts-loader-container-opacity]="active() ? 1 : 0"
+			>
+				<div>
+					<div class="ngts-loader-inner" [class]="innerClass() || ''">
+						<div
+							class="ngts-loader-bar"
+							[class]="barClass() || ''"
+							[style.--ngts-loader-bar-scale]="progress() / 100"
+						></div>
+						<span #progressSpanRef class="ngts-loader-data" [class]="dataClass() || ''"></span>
+					</div>
+				</div>
+			</div>
+		}
+	`, isInline: true, styles: [".ngts-loader-container{--ngts-loader-container-opacity: 0;position:absolute;top:0;left:0;width:100%;height:100%;background:#171717;display:flex;align-items:center;justify-content:center;transition:opacity .3s ease;z-index:1000;opacity:var(--ngts-loader-container-opacity)}.ngts-loader-inner{width:100px;height:3px;background:#272727;text-align:center}.ngts-loader-bar{--ngts-loader-bar-scale: 0;height:3px;width:100px;background:#fff;transition:transform .2s;transform-origin:left center;transform:scaleX(var(--ngts-loader-bar-scale))}.ngts-loader-data{display:inline-block;position:relative;font-variant-numeric:tabular-nums;margin-top:.8em;color:#f0f0f0;font-size:.6em;font-family:-apple-system,BlinkMacSystemFont,Inter,Segoe UI,Helvetica Neue,Helvetica,Arial,Roboto,Ubuntu,sans-serif,\"Apple Color Emoji\",\"Segoe UI Emoji\",Segoe UI Symbol;white-space:nowrap}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsLoader, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngts-loader', standalone: true, template: `
+		@if (shown()) {
+			<div
+				class="ngts-loader-container"
+				[class]="containerClass() || ''"
+				[style.--ngts-loader-container-opacity]="active() ? 1 : 0"
+			>
+				<div>
+					<div class="ngts-loader-inner" [class]="innerClass() || ''">
+						<div
+							class="ngts-loader-bar"
+							[class]="barClass() || ''"
+							[style.--ngts-loader-bar-scale]="progress() / 100"
+						></div>
+						<span #progressSpanRef class="ngts-loader-data" [class]="dataClass() || ''"></span>
+					</div>
+				</div>
+			</div>
+		}
+	`, changeDetection: ChangeDetectionStrategy.OnPush, styles: [".ngts-loader-container{--ngts-loader-container-opacity: 0;position:absolute;top:0;left:0;width:100%;height:100%;background:#171717;display:flex;align-items:center;justify-content:center;transition:opacity .3s ease;z-index:1000;opacity:var(--ngts-loader-container-opacity)}.ngts-loader-inner{width:100px;height:3px;background:#272727;text-align:center}.ngts-loader-bar{--ngts-loader-bar-scale: 0;height:3px;width:100px;background:#fff;transition:transform .2s;transform-origin:left center;transform:scaleX(var(--ngts-loader-bar-scale))}.ngts-loader-data{display:inline-block;position:relative;font-variant-numeric:tabular-nums;margin-top:.8em;color:#f0f0f0;font-size:.6em;font-family:-apple-system,BlinkMacSystemFont,Inter,Segoe UI,Helvetica Neue,Helvetica,Arial,Roboto,Ubuntu,sans-serif,\"Apple Color Emoji\",\"Segoe UI Emoji\",Segoe UI Symbol;white-space:nowrap}\n"] }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loader.js","sourceRoot":"","sources":["../../../../../../libs/soba/loaders/src/lib/loader.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tChangeDetectionStrategy,\n\tComponent,\n\tElementRef,\n\tcomputed,\n\teffect,\n\tinput,\n\tsignal,\n\tuntracked,\n\tviewChild,\n} from '@angular/core';\nimport { pick } from 'angular-three';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { injectProgress } from './progress';\n\nconst defaultDataInterpolation = (p: number) => `Loading ${p.toFixed(2)}%`;\n\nexport interface NgtsLoaderOptions {\n\tcontainerClass?: string;\n\tinnerClass?: string;\n\tbarClass?: string;\n\tdataClass?: string;\n\tdataInterpolation: (value: number) => string;\n\tinitialState: (value: boolean) => boolean;\n}\n\nconst defaultOptions: NgtsLoaderOptions = {\n\tcontainerClass: '',\n\tinnerClass: '',\n\tbarClass: '',\n\tdataClass: '',\n\tdataInterpolation: defaultDataInterpolation,\n\tinitialState: (value) => value,\n};\n\n@Component({\n\tselector: 'ngts-loader',\n\tstandalone: true,\n\ttemplate: `\n\t\t@if (shown()) {\n\t\t\t<div\n\t\t\t\tclass=\"ngts-loader-container\"\n\t\t\t\t[class]=\"containerClass() || ''\"\n\t\t\t\t[style.--ngts-loader-container-opacity]=\"active() ? 1 : 0\"\n\t\t\t>\n\t\t\t\t<div>\n\t\t\t\t\t<div class=\"ngts-loader-inner\" [class]=\"innerClass() || ''\">\n\t\t\t\t\t\t<div\n\t\t\t\t\t\t\tclass=\"ngts-loader-bar\"\n\t\t\t\t\t\t\t[class]=\"barClass() || ''\"\n\t\t\t\t\t\t\t[style.--ngts-loader-bar-scale]=\"progress() / 100\"\n\t\t\t\t\t\t></div>\n\t\t\t\t\t\t<span #progressSpanRef class=\"ngts-loader-data\" [class]=\"dataClass() || ''\"></span>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t}\n\t`,\n\tstyleUrls: ['./loader.css'],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsLoader {\n\tprivate progressState = injectProgress();\n\n\tactive = computed(() => this.progressState().active);\n\tprogress = computed(() => this.progressState().progress);\n\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\n\tcontainerClass = pick(this.options, 'containerClass');\n\tinnerClass = pick(this.options, 'innerClass');\n\tbarClass = pick(this.options, 'barClass');\n\tdataClass = pick(this.options, 'dataClass');\n\tinitialState = pick(this.options, 'initialState');\n\tdataInterpolation = pick(this.options, 'dataInterpolation');\n\n\tprogressSpanRef = viewChild<ElementRef<HTMLSpanElement>>('progressSpanRef');\n\n\tshown = signal(this.initialState()(this.active()));\n\n\tconstructor() {\n\t\tthis.setShown();\n\t\tthis.updateProgress();\n\t}\n\n\tprivate setShown() {\n\t\teffect((onCleanup) => {\n\t\t\tconst [active, lastShown] = [this.active(), untracked(this.shown)];\n\t\t\tif (lastShown !== active) {\n\t\t\t\tconst timeoutId = setTimeout(() => {\n\t\t\t\t\tthis.shown.set(active);\n\t\t\t\t}, 300);\n\t\t\t\tonCleanup(() => clearTimeout(timeoutId));\n\t\t\t}\n\t\t});\n\t}\n\n\tprivate updateProgress() {\n\t\tlet progressRef = 0;\n\t\tlet rafId: ReturnType<typeof requestAnimationFrame>;\n\n\t\teffect((onCleanup) => {\n\t\t\tconst [dataInterpolation, progress] = [this.dataInterpolation(), this.progress()];\n\t\t\tconst updateProgress = () => {\n\t\t\t\tconst progressSpan = this.progressSpanRef()?.nativeElement;\n\t\t\t\tif (!progressSpan) return;\n\t\t\t\tprogressRef += (progress - progressRef) / 2;\n\t\t\t\tif (progressRef > 0.95 * progress || progress === 100) progressRef = progress;\n\t\t\t\tprogressSpan.innerText = dataInterpolation(progressRef);\n\t\t\t\tif (progressRef < progress) {\n\t\t\t\t\trafId = requestAnimationFrame(updateProgress);\n\t\t\t\t}\n\t\t\t};\n\t\t\tupdateProgress();\n\t\t\tonCleanup(() => cancelAnimationFrame(rafId));\n\t\t});\n\t}\n}\n"]}