@uniprank/ngx-scrollspy 1.0.9 → 2.0.1

package/README.md

@@ -1,8 +1,8 @@
-[![travis build](https://img.shields.io/travis/uniprank/ngx-scrollspy?label=Travis%3Abuild&style=flat-square)](https://travis-ci.org/uniprank/ngx-scrollspy)
+[![CI](https://github.com/uniprank/ngx-scrollspy/actions/workflows/ci.yml/badge.svg)](https://github.com/uniprank/ngx-scrollspy/actions/workflows/ci.yml)
 
 You can use this angular service to spy scroll events from `window` or any other scrollable element.
 
-This library implements an service to collect observables from scroll spy directives. It can be used to create you own components or if you prefer use one of the following directives.
+This library implements a service to collect observables from scroll spy directives. It can be used to create your own components or if you prefer use one of the following directives.
 
 See Examples here [Example](https://uniprank.github.io/ngx-scrollspy/test-cases)
 
@@ -14,116 +14,137 @@ First you need to install the npm module:
 npm install @uniprank/ngx-scrollspy --save
 ```
 
-If you use SystemJS to load your files, you might have to update your config with this if you don't use `defaultJSExtensions: true`:
+## Setup (Standalone API)
 
-```js
-System.config({
-  packages: {
-    '@uniprank/ngx-scrollspy': { defaultExtension: 'js' }
-  }
-});
+Use `provideScrollSpy()` in your application config to set up the service:
+
+```typescript
+// app.config.ts
+import { ApplicationConfig } from '@angular/core';
+import { provideScrollSpy } from '@uniprank/ngx-scrollspy';
+
+export const appConfig: ApplicationConfig = {
+  providers: [
+    provideScrollSpy({ lookAhead: true })
+  ]
+};
 ```
 
-Finally, you can use ngx-scrollspy in your Angular project (NOT AngularJS).
-It is recommended to instantiate `ScrollSpyService` in the bootstrap of your application and to never add it to the "providers" property of your components, this way you will keep it as a singleton.
-If you add it to the "providers" property of a component it will instantiate a new instance of the service that won't be initialized.
+```typescript
+// main.ts
+import { bootstrapApplication } from '@angular/platform-browser';
+import { AppComponent } from './app/app.component';
+import { appConfig } from './app/app.config';
 
-```js
-import { NgModule } from '@angular/core';
-import { BrowserModule } from '@angular/platform-browser';
+bootstrapApplication(AppComponent, appConfig);
+```
+
+Then import the standalone directives directly in your components:
 
-import { ScrollSpyModule } from '@uniprank/ngx-scrollspy';
+```typescript
+import { Component } from '@angular/core';
+import { ScrollSpyDirective, ScrollItemDirective } from '@uniprank/ngx-scrollspy';
 
-@NgModule({
-  imports: [BrowserModule, ScrollSpyModule.forRoot()],
-  declarations: [AppComponent],
-  bootstrap: [AppComponent]
+@Component({
+  selector: 'app-example',
+  standalone: true,
+  imports: [ScrollSpyDirective, ScrollItemDirective],
+  template: `
+    <li uniScrollItem="section1">Section 1</li>
+    <section uniScrollSpy="section1">Content</section>
+  `
 })
-export class AppModule {}
+export class ExampleComponent {}
 ```
 
+### Available Directives
+
+| Directive | Selector | Description |
+|-----------|----------|-------------|
+| `ScrollSpyDirective` | `[uniScrollSpy]` | Marks a content section to be tracked by the scroll spy |
+| `ScrollItemDirective` | `[uniScrollItem]` | Marks a navigation item that mirrors the active state |
+| `ScrollElementDirective` | `[uniScrollElement]` | Wraps a custom scrollable container (non-window) |
+
 ## Using
 
 #### Spy window scroll
 
-Use `ScrollSpyDirective` to spy on window as default or set also element to spy on a other scroll able element.
+Use `ScrollSpyDirective` to spy on window as default or set `scrollElement` to spy on another scrollable element.
 
-```js
-import { NgModule, Component, Injectable, AfterViewInit } from '@angular/core';
-import { BrowserModule } from '@angular/platform-browser';
+```typescript
+import { Component } from '@angular/core';
+import { ScrollSpyDirective, ScrollItemDirective, ScrollSpyService } from '@uniprank/ngx-scrollspy';
 
-import { ScrollSpyModule, ScrollSpyService, ScrollObjectInterface } from '@uniprank/ngx-scrollspy';
-
-@Injectable()
 @Component({
-	selector: 'app',
-	template: `<div uniScrollSpy="section-abc"></div>`
+  selector: 'app-example',
+  standalone: true,
+  imports: [ScrollSpyDirective, ScrollItemDirective],
+  template: `<div uniScrollSpy="section-abc"></div>`
 })
-export class AppComponent implements AfterViewInit {
-	constructor(private _scrollSpyService: ScrollSpyService) {}
-
-	ngAfterViewInit() {
-		this._scrollSpyService.getObservable('window').subscribe((element: ScrollObjectInterface) => {
-			console.log('ScrollSpy::window: ', element);
-		});
-	}
-}
+export class ExampleComponent implements AfterViewInit {
+  constructor(private _scrollSpyService: ScrollSpyService) {}
 
-@NgModule({
-  imports: [
-  	BrowserModule,
-  	ScrollSpyModule.forRoot()
-  ],
-  declarations: [
-  	AppComponent
-  ],
-  bootstrap: [ AppComponent ]
-})
+  ngAfterViewInit() {
+    this._scrollSpyService.observe('window').subscribe((element) => {
+      console.log('ScrollSpy::window: ', element);
+    });
+  }
+}
 ```
 
 #### Spy any element scroll
 
-Use `ScrollSpyElementDirective` to spy on any element. You must give an unique id to each instance.
-This unique id is called elementID and you need this elementID to connect your `ScrollSpyItemDirective` or your `ScrollSpyDirective`.
+Use `ScrollElementDirective` to spy on any element. You must give a unique id to each instance.
+This unique id is called elementID and you need this elementID to connect your `ScrollItemDirective` or your `ScrollSpyDirective`.
 
-```js
-import { NgModule, Component, Injectable, AfterViewInit } from '@angular/core';
-import { ScrollSpyModule, ScrollSpyService, ScrollObjectInterface } from '@uniprank/ngx-scrollspy';
+```typescript
+import { Component, AfterViewInit } from '@angular/core';
+import {
+  ScrollSpyDirective,
+  ScrollItemDirective,
+  ScrollElementDirective,
+  ScrollSpyService,
+  ScrollObjectInterface
+} from '@uniprank/ngx-scrollspy';
 
-@Injectable()
 @Component({
-	selector: 'yourComponent',
+  selector: 'app-example',
+  standalone: true,
+  imports: [ScrollSpyDirective, ScrollItemDirective, ScrollElementDirective],
   template: `
-  <div uniScrollSpyItem="part2" scrollElement="test">Get class active if part2 is in focus.</div>
-	<div uniScrollSpyElement="test" style="max-height: 100px; overflow: auto;">
-		<div uniScrollSpy="part1" style="height: 500px;"></div>
-		<div uniScrollSpy="part2" style="height: 500px;"></div>
-	</div>`
+    <div uniScrollItem="part2" scrollElement="test">Get class active if part2 is in focus.</div>
+    <div uniScrollElement="test" style="max-height: 100px; overflow: auto;">
+      <div uniScrollSpy="part1" style="height: 500px;"></div>
+      <div uniScrollSpy="part2" style="height: 500px;"></div>
+    </div>
+  `
 })
-export class YourComponent implements AfterViewInit {
-
-	constructor(private _scrollSpyService: ScrollSpyService) {}
+export class ExampleComponent implements AfterViewInit {
+  constructor(private _scrollSpyService: ScrollSpyService) {}
 
-	ngAfterViewInit() {
-		this._scrollSpyService.getObservable('test').subscribe((element: ScrollObjectInterface) => {
-			console.log('ScrollSpy::test: ', element);
-		});
-	}
+  ngAfterViewInit() {
+    this._scrollSpyService.observe('test').subscribe((element: ScrollObjectInterface) => {
+      console.log('ScrollSpy::test: ', element);
+    });
+  }
 }
-
-@NgModule({
-  imports: [
-		ScrollSpyModule
-  ],
-  declarations: [
-  	AppComponent
-  ],
-  providers: [ ]
-})
-export class YourModule { }
 ```
 
-Because `ScrollSpyService` is a singleton, you can get any ScrollSpy observable from anywhere withing your application.
+Because `ScrollSpyService` is a singleton, you can get any ScrollSpy observable from anywhere within your application.
+
+## Parameters
+
+You can pass optional parameters to `provideScrollSpy()`:
+
+| Parameter | Value | Description |
+|-----------|-------|-------------|
+| `lookAhead` | boolean | Set the first item active even if it's not already in the viewport |
+| `activateOnlySetItems` | boolean | Only activate items when fully within the viewport |
+| `attributeType` | `'id'` \| `'data-id'` | Which HTML attribute to set on spy elements (default: `'id'`) |
+
+```typescript
+provideScrollSpy({ lookAhead: true })
+```
 
 # TODO:
 

package/fesm2022/uniprank-ngx-scrollspy.mjs

@@ -0,0 +1,389 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, ElementRef, Injectable, input, signal, DestroyRef, Directive, contentChildren, output, makeEnvironmentProviders, NgModule } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { Subject, fromEvent, BehaviorSubject } from 'rxjs';
+import { auditTime, takeUntil } from 'rxjs/operators';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+
+var ScrollDirectionEnum;
+(function (ScrollDirectionEnum) {
+    ScrollDirectionEnum["vertical"] = "vertical";
+    ScrollDirectionEnum["horizontal"] = "horizontal";
+})(ScrollDirectionEnum || (ScrollDirectionEnum = {}));
+
+const defaultElementId = 'window';
+const SPY_CONFIG = new InjectionToken('SPY_CONFIG');
+class ScrollSpyService {
+    constructor() {
+        this._doc = inject(DOCUMENT);
+        this._config = inject(SPY_CONFIG, { optional: true });
+        this._scrollItems = {};
+        this._scrollElements = {};
+        this._$scrollElementListener = {};
+        this._scrollElementListener = {};
+        this._onStopListening = new Subject();
+        this._window = this._doc.defaultView;
+        this._initScrollElementListener(defaultElementId, this._generateScrollElement(defaultElementId, new ElementRef(this._doc.documentElement || this._doc.body), ScrollDirectionEnum.vertical));
+        if (this._window) {
+            fromEvent(this._window, 'resize')
+                .pipe(auditTime(300), takeUntil(this._onStopListening))
+                .subscribe(() => this._windowScroll());
+            fromEvent(this._window, 'scroll')
+                .pipe(auditTime(10), takeUntil(this._onStopListening))
+                .subscribe(() => this._windowScroll());
+        }
+        this._windowScroll();
+        if (this._config != null) {
+            this._lookAhead = this._config.lookAhead ?? false;
+            this._activateOnlySetItems = this._config.activateOnlySetItems ?? false;
+            this.attributeType = this._config.attributeType ?? 'id';
+        }
+        else {
+            this._lookAhead = false;
+            this._activateOnlySetItems = false;
+            this.attributeType = 'id';
+        }
+    }
+    _initScrollElementListener(scrollElementId, scrollElement) {
+        this._scrollElements[scrollElementId] = scrollElement;
+        this._scrollElementListener[scrollElementId] = null;
+        this._$scrollElementListener[scrollElementId] = new BehaviorSubject(null);
+    }
+    _windowScroll() {
+        this.updateScrollElement(defaultElementId);
+    }
+    _generateScrollElement(scrollElementId, elementRef, direction, offset = 0) {
+        return {
+            id: scrollElementId,
+            elementRef,
+            direction,
+            offset
+        };
+    }
+    setOffset(scrollElementId, offset) {
+        this._checkScrollElementExists(scrollElementId);
+        this._scrollElements[scrollElementId].offset = offset;
+    }
+    setScrollElement(scrollElementId, elementRef, direction, offset = 0) {
+        const existing = this._scrollElements[scrollElementId];
+        if (existing != null && existing.elementRef.nativeElement.isConnected) {
+            throw new Error(`ScrollSpyService: The scroll element with the id [${scrollElementId}] already exists in the DOM.`);
+        }
+        this._initScrollElementListener(scrollElementId, this._generateScrollElement(scrollElementId, elementRef, direction, offset));
+    }
+    setItem(itemId, elementRef, scrollElementId = defaultElementId) {
+        const existing = this._scrollItems[itemId];
+        if (existing != null && existing.nativeElement.isConnected) {
+            throw new Error(`ScrollSpyService: The scroll item with the id [${itemId}] already exists in the DOM.`);
+        }
+        this._scrollItems[itemId] = this._generateScrollObject(itemId, elementRef, scrollElementId);
+        this._setDefaultItem(itemId, scrollElementId);
+    }
+    _generateScrollObject(id, elementRef, scrollElementId) {
+        return {
+            id,
+            scrollElementId,
+            elementRef,
+            nativeElement: elementRef.nativeElement
+        };
+    }
+    _setDefaultItem(itemId, scrollElementId) {
+        if (this._lookAhead) {
+            return;
+        }
+        const _value = this._scrollElementListener[scrollElementId];
+        if (_value == null) {
+            this._setScrollElementListener(scrollElementId, this._scrollItems[itemId]);
+        }
+    }
+    _setScrollElementListener(scrollElementId, scrollObject) {
+        this._scrollElementListener[scrollElementId] = scrollObject;
+        setTimeout(() => this._$scrollElementListener[scrollElementId].next(scrollObject));
+    }
+    changeScrollElement(itemId, oldElementId, newElementId, override = false) {
+        this._checkScrollElementExists(oldElementId);
+        this._checkScrollElementExists(newElementId);
+        this._checkItemExists(itemId);
+        const _scrollItem = this._scrollItems[itemId];
+        if ((_scrollItem.scrollElementId !== defaultElementId && override) || _scrollItem.scrollElementId === defaultElementId) {
+            this._scrollItems[itemId].scrollElementId = newElementId;
+        }
+        this._setDefaultItem(itemId, newElementId);
+        const _oldElements = this._getElementItems(oldElementId);
+        if (_oldElements.length > 0) {
+            this._setDefaultItem(_oldElements[0].id, oldElementId);
+        }
+    }
+    _getElementItems(scrollElementId) {
+        const _items = [];
+        for (const key in this._scrollItems) {
+            if (Object.prototype.hasOwnProperty.call(this._scrollItems, key)) {
+                const value = this._scrollItems[key];
+                if (value.scrollElementId === scrollElementId) {
+                    _items.push(value);
+                }
+            }
+        }
+        return _items;
+    }
+    _checkItemExists(itemId) {
+        if (this._scrollItems[itemId] == null) {
+            throw new Error(`ScrollSpyService: The scroll item with the id [${itemId}] doesn't exist.`);
+        }
+    }
+    observe(scrollElementId = defaultElementId) {
+        this._checkScrollElementExists(scrollElementId);
+        return this._$scrollElementListener[scrollElementId].asObservable();
+    }
+    _checkScrollElementExists(scrollElementId) {
+        if (this._scrollElements[scrollElementId] == null) {
+            throw new Error(`ScrollSpyService: The scroll element with the id [${scrollElementId}] doesn't exist.`);
+        }
+    }
+    updateScrollElement(scrollElementId) {
+        this._checkScrollElementExists(scrollElementId);
+        const _element = this._scrollElements[scrollElementId];
+        const _elementItems = this._getElementItems(scrollElementId);
+        const _nextActiveItem = this._getActiveItem(_element, _elementItems);
+        const _currentActiveItem = this._scrollElementListener[scrollElementId];
+        if (_currentActiveItem == null) {
+            if (_nextActiveItem != null) {
+                this._setScrollElementListener(scrollElementId, _nextActiveItem);
+            }
+        }
+        else if (_nextActiveItem != null) {
+            if (_currentActiveItem.id !== _nextActiveItem.id) {
+                this._setScrollElementListener(scrollElementId, _nextActiveItem);
+            }
+        }
+        else if (_nextActiveItem == null && this._lookAhead) {
+            this._setScrollElementListener(scrollElementId, null);
+        }
+    }
+    _getActiveItem(scrollElement, listOfElements) {
+        const _direction = scrollElement.direction;
+        let _scrollObject = null;
+        const nativeElement = scrollElement.elementRef.nativeElement;
+        listOfElements.forEach((_element) => {
+            let _active = false;
+            switch (_direction) {
+                case ScrollDirectionEnum.horizontal: {
+                    const _scrollLeft = scrollElement.id.toLowerCase() === 'window' ? (this._window?.pageXOffset ?? 0) : nativeElement.scrollLeft;
+                    _active = _element.nativeElement.offsetLeft <= _scrollLeft + scrollElement.offset;
+                    break;
+                }
+                default: {
+                    const _scrollTop = scrollElement.id.toLowerCase() === 'window' ? (this._window?.scrollY ?? 0) : nativeElement.scrollTop;
+                    if (this._activateOnlySetItems) {
+                        _active =
+                            _element.nativeElement.offsetTop < _scrollTop + scrollElement.offset &&
+                                _element.nativeElement.offsetTop + _element.nativeElement.offsetHeight > _scrollTop + scrollElement.offset;
+                    }
+                    else {
+                        _active = _element.nativeElement.offsetTop <= _scrollTop + scrollElement.offset;
+                    }
+                }
+            }
+            if (_active) {
+                _scrollObject = _element;
+            }
+        });
+        return _scrollObject;
+    }
+    deleteScrollElement(scrollElementId) {
+        if (scrollElementId === 'window') {
+            this._setScrollElementListener(scrollElementId, null);
+        }
+        else {
+            this._checkScrollElementExists(scrollElementId);
+            delete this._scrollElements[scrollElementId];
+            delete this._$scrollElementListener[scrollElementId];
+            delete this._scrollElementListener[scrollElementId];
+        }
+    }
+    deleteItem(itemId) {
+        if (this._scrollItems[itemId] != null) {
+            delete this._scrollItems[itemId];
+        }
+    }
+    destroy() {
+        this._onStopListening.next();
+        this._onStopListening.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.19", ngImport: i0, type: ScrollSpyService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.19", ngImport: i0, type: ScrollSpyService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.19", ngImport: i0, type: ScrollSpyService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+class ScrollSpyDirective {
+    constructor() {
+        this.itemId = input.required({ alias: 'uniScrollSpy' });
+        this.scrollElement = input('window');
+        this.classActive = signal(false);
+        this._el = inject(ElementRef);
+        this._scrollSpyService = inject(ScrollSpyService);
+        this._destroyRef = inject(DestroyRef);
+    }
+    ngOnDestroy() {
+        this._scrollSpyService.deleteItem(this.itemId());
+    }
+    ngAfterViewInit() {
+        this._scrollSpyService
+            .observe(this.scrollElement())
+            .pipe(takeUntilDestroyed(this._destroyRef))
+            .subscribe((element) => {
+            if (element != null) {
+                this.classActive.set(element.id === this.itemId());
+            }
+        });
+        this._scrollSpyService.setItem(this.itemId(), this._el, this.scrollElement());
+        const keyType = this._scrollSpyService.attributeType === 'data-id' ? 'data-id' : 'id';
+        this._el.nativeElement.setAttribute(keyType, this.itemId());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.19", ngImport: i0, type: ScrollSpyDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.2.19", type: ScrollSpyDirective, isStandalone: true, selector: "[uniScrollSpy]", inputs: { itemId: { classPropertyName: "itemId", publicName: "uniScrollSpy", isSignal: true, isRequired: true, transformFunction: null }, scrollElement: { classPropertyName: "scrollElement", publicName: "scrollElement", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "class.active": "classActive()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.19", ngImport: i0, type: ScrollSpyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[uniScrollSpy]',
+                    standalone: true,
+                    host: {
+                        '[class.active]': 'classActive()'
+                    }
+                }]
+        }] });
+
+class ScrollElementDirective {
+    constructor() {
+        this.elementId = input.required({ alias: 'uniScrollElement' });
+        this.direction = input(ScrollDirectionEnum.vertical);
+        this.scrollSpyElements = contentChildren(ScrollSpyDirective, { descendants: true });
+        this._el = inject(ElementRef);
+        this._scrollSpyService = inject(ScrollSpyService);
+    }
+    onScroll() {
+        this._scrollSpyService.updateScrollElement(this.elementId());
+    }
+    ngOnInit() {
+        this._scrollSpyService.setScrollElement(this.elementId(), this._el, this.direction());
+        if (this._scrollSpyService.attributeType === 'id') {
+            this._el.nativeElement.setAttribute('id', this.elementId());
+        }
+        else {
+            this._el.nativeElement.setAttribute('data-id', this.elementId());
+        }
+    }
+    ngAfterViewInit() {
+        const elements = this.scrollSpyElements();
+        elements.forEach((element) => {
+            this._scrollSpyService.changeScrollElement(element.itemId(), element.scrollElement(), this.elementId());
+        });
+    }
+    ngOnDestroy() {
+        this._scrollSpyService.deleteScrollElement(this.elementId());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.19", ngImport: i0, type: ScrollElementDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "19.2.19", type: ScrollElementDirective, isStandalone: true, selector: "[uniScrollElement]", inputs: { elementId: { classPropertyName: "elementId", publicName: "uniScrollElement", isSignal: true, isRequired: true, transformFunction: null }, direction: { classPropertyName: "direction", publicName: "direction", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "scroll": "onScroll()" } }, queries: [{ propertyName: "scrollSpyElements", predicate: ScrollSpyDirective, descendants: true, isSignal: true }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.19", ngImport: i0, type: ScrollElementDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[uniScrollElement]',
+                    standalone: true,
+                    host: {
+                        '(scroll)': 'onScroll()'
+                    }
+                }]
+        }] });
+
+class ScrollItemDirective {
+    constructor() {
+        this.itemId = input.required({ alias: 'uniScrollItem' });
+        this.scrollElement = input('window');
+        this.activeEvent = output();
+        this.classActive = signal(false);
+        this._scrollSpyService = inject(ScrollSpyService);
+        this._destroyRef = inject(DestroyRef);
+    }
+    ngAfterViewInit() {
+        this._scrollSpyService
+            .observe(this.scrollElement())
+            .pipe(takeUntilDestroyed(this._destroyRef))
+            .subscribe((element) => {
+            let _active;
+            if (element != null) {
+                _active = element.id === this.itemId();
+                this.activeEvent.emit(_active);
+            }
+            else {
+                _active = false;
+            }
+            this.classActive.set(_active);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.19", ngImport: i0, type: ScrollItemDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.2.19", type: ScrollItemDirective, isStandalone: true, selector: "[uniScrollItem]", inputs: { itemId: { classPropertyName: "itemId", publicName: "uniScrollItem", isSignal: true, isRequired: true, transformFunction: null }, scrollElement: { classPropertyName: "scrollElement", publicName: "scrollElement", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { activeEvent: "activeEvent" }, host: { properties: { "class.active": "classActive()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.19", ngImport: i0, type: ScrollItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[uniScrollItem]',
+                    standalone: true,
+                    host: {
+                        '[class.active]': 'classActive()'
+                    }
+                }]
+        }] });
+
+const directives = [ScrollSpyDirective, ScrollItemDirective, ScrollElementDirective];
+/**
+ * Provide ScrollSpy configuration for standalone applications.
+ *
+ * @example
+ * ```typescript
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideScrollSpy({ lookAhead: true })]
+ * });
+ * ```
+ */
+function provideScrollSpy(config = { lookAhead: false }) {
+    return makeEnvironmentProviders([{ provide: SPY_CONFIG, useValue: config }]);
+}
+/**
+ * @deprecated Use standalone directives (ScrollSpyDirective, ScrollItemDirective, ScrollElementDirective)
+ * and provideScrollSpy() instead.
+ */
+class NgxScrollspyModule {
+    static forRoot(parameters = { lookAhead: false }) {
+        return {
+            ngModule: NgxScrollspyModule,
+            providers: [{ provide: SPY_CONFIG, useValue: parameters }]
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.19", ngImport: i0, type: NgxScrollspyModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.19", ngImport: i0, type: NgxScrollspyModule, imports: [ScrollSpyDirective, ScrollItemDirective, ScrollElementDirective], exports: [ScrollSpyDirective, ScrollItemDirective, ScrollElementDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.19", ngImport: i0, type: NgxScrollspyModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.19", ngImport: i0, type: NgxScrollspyModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [...directives],
+                    exports: [...directives]
+                }]
+        }] });
+
+/*
+ * Public API Surface of ngx-scrollspy
+ */
+// enums
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { NgxScrollspyModule, SPY_CONFIG, ScrollDirectionEnum, ScrollElementDirective, ScrollItemDirective, ScrollSpyDirective, ScrollSpyService, provideScrollSpy };
+//# sourceMappingURL=uniprank-ngx-scrollspy.mjs.map