angular-three-soba 2.0.0-beta.261 → 2.0.0-beta.263

package/controls/index.d.ts

@@ -1,2 +1,3 @@
 export * from './lib/camera-controls';
 export * from './lib/orbit-controls';
+export * from './lib/scroll-controls';

package/controls/lib/scroll-controls.d.ts

@@ -0,0 +1,78 @@
+import { NgtHTML } from 'angular-three';
+import * as i0 from "@angular/core";
+export interface NgtsScrollControlsOptions {
+    /** Precision, default 0.00001 */
+    eps: number;
+    /** Horizontal scroll, default false (vertical) */
+    horizontal: boolean;
+    /** Infinite scroll, default false (experimental!) */
+    infinite: boolean;
+    /** Defines the lenght of the scroll area, each page is height:100%, default 1 */
+    pages: number;
+    /** A factor that increases scroll bar travel,default: 1 */
+    distance: number;
+    /** Friction in seconds, default: 0.25 (1/4 second) */
+    damping: number;
+    /** maxSpeed optionally allows you to clamp the maximum speed. If damping is 0.2s and looks OK
+     *  going between, say, page 1 and 2, but not for pages far apart as it'll move very rapid,
+     *  then a maxSpeed of e.g. 3 which will clamp the speed to 3 units per second, it may now
+     *  take much longer than damping to reach the target if it is far away. Default: Infinity */
+    maxSpeed: number;
+    /** If true attaches the scroll container before the canvas */
+    prepend: boolean;
+    enabled: boolean;
+    style: Partial<CSSStyleDeclaration>;
+}
+export declare class NgtsScrollControls {
+    progress: import("@angular/core").ModelSignal<number>;
+    options: import("@angular/core").InputSignalWithTransform<NgtsScrollControlsOptions, "" | Partial<NgtsScrollControlsOptions>>;
+    private document;
+    private store;
+    private gl;
+    private events;
+    private invalidate;
+    private size;
+    private domElement;
+    private target;
+    private _el;
+    private _fill;
+    private _fixed;
+    private style;
+    private prepend;
+    private enabled;
+    private infinite;
+    private maxSpeed;
+    eps: import("@angular/core").Signal<number>;
+    horizontal: import("@angular/core").Signal<boolean>;
+    pages: import("@angular/core").Signal<number>;
+    distance: import("@angular/core").Signal<number>;
+    damping: import("@angular/core").Signal<number>;
+    scroll: number;
+    offset: number;
+    delta: number;
+    constructor();
+    get el(): HTMLDivElement;
+    get fill(): HTMLDivElement;
+    get fixed(): HTMLDivElement;
+    range(from: number, distance: number, margin?: number): number;
+    curve(from: number, distance: number, margin?: number): number;
+    visible(from: number, distance: number, margin?: number): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsScrollControls, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsScrollControls, "ngts-scroll-controls", never, { "progress": { "alias": "progress"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "progress": "progressChange"; }, never, ["*"], true, never>;
+}
+export declare class NgtsScrollCanvas {
+    private host;
+    private scrollControls;
+    private store;
+    private viewport;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsScrollCanvas, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsScrollCanvas, "ngt-group[ngts-scroll-canvas]", never, {}, {}, never, never, true, never>;
+}
+export declare class NgtsScrollHtml extends NgtHTML {
+    private scrollControls;
+    private size;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsScrollHtml, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsScrollHtml, "div[ngts-scroll-html]", never, {}, {}, never, never, true, never>;
+}

package/esm2022/controls/index.mjs

@@ -1,3 +1,4 @@
 export * from './lib/camera-controls';
 export * from './lib/orbit-controls';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvY29udHJvbHMvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL2NhbWVyYS1jb250cm9scyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9vcmJpdC1jb250cm9scyc7XG4iXX0=
+export * from './lib/scroll-controls';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvY29udHJvbHMvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9saWIvY2FtZXJhLWNvbnRyb2xzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL29yYml0LWNvbnRyb2xzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3Njcm9sbC1jb250cm9scyc7XG4iXX0=

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.1.0", ngImport: i0, type: NgtsScrollControls, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.1.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.1.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.1.0", ngImport: i0, type: NgtsScrollCanvas, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.0", type: NgtsScrollCanvas, isStandalone: true, selector: "ngt-group[ngts-scroll-canvas]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsScrollCanvas, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ngt-group[ngts-scroll-canvas]', 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.1.0", ngImport: i0, type: NgtsScrollHtml, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.0", type: NgtsScrollHtml, isStandalone: true, selector: "div[ngts-scroll-html]", 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.1.0", ngImport: i0, type: NgtsScrollHtml, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'div[ngts-scroll-html]',
+                    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: number = 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: number = 0): number {\n\t\treturn Math.sin(this.range(from, distance, margin) * Math.PI);\n\t}\n\n\tvisible(from: number, distance: number, margin: number = 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[ngts-scroll-canvas]', 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[ngts-scroll-html]',\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"]}