ng-mat-select-infinite-scroll 5.0.0-beta.2 → 6.0.0-next.0

package/README.md

@@ -1,93 +1,135 @@
+# Angular Material Select Infinite Scroll
 
-# Angular Material Select Infinite Scroll  
+Load options in pages as users scroll a standard Angular Material `mat-select`. Supports standalone imports and the existing NgModule API.
 
-Adds missing infinite scroll functionality for the [Angular Material Select component](https://material.angular.io/components/select).  
+## Version compatibility
 
-### Inputs  
+The 6.0 release candidate targets Angular/Material **15.2–22**. It is compiled with Angular 15.2 partial Ivy and checked as one npm tarball in independent applications for every major, including minimum-version fixtures. See [compatibility.json](compatibility.json) for exact test toolchains and [the execution status](REVIVAL_STATUS.md) for validation progress. A candidate is not a published stable release.
 
-| Property       | Description                                                                                                                                                                                                                  | Type      | Default    |  
-| -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------| ---------- |  
-| `complete`     | If `true`, the `infiniteScroll` output will no longer be triggered.                                                                                                                                                          | `boolean` | `false`    |  
-| `threshold`    | The threshold distance from the bottom of the options list to call the `infiniteScroll` output event when scrolled. The threshold value can be either in percent or pixels. For example, `10%` triggers the event 10% before the bottom. | `string`  | `'15%'`    |  
-| `debounceTime` | The threshold time (in milliseconds) before firing the `infiniteScroll` event.                                                                                                                                               | `number`  | `150`      |  
+| Your application | Package |
+| --- | --- |
+| Angular/Material 15.2–22 | Upcoming 6.x; use `@next` only after the candidate is published |
+| Angular/Material 15–16 | Existing `5.0.0-beta.3`; excludes the 6.x fixes |
+| Angular below 15 | Historical `4.0.0` declares peers `>=6 <15`; verify your exact versions |
 
-### Outputs  
+Angular and Material should use matching majors. The 6.x line uses RxJS 7.8+. Standard `MatSelect` is covered; `MatLegacySelect` is a separate integration. An older framework's compatibility entry does not extend its upstream security support.
 
-| Property         | Description                                                                             | Type                  |  
-| ----------------- | --------------------------------------------------------------------------------------- | --------------------- |  
-| `infiniteScroll`  | Emitted when the scroller inside the `mat-select` reaches the required distance.        | `EventEmitter<void>`  |  
-
-### Installation  
-
-```bash
-npm i ng-mat-select-infinite-scroll
+```sh
+# Once the candidate is published:
+npm install ng-mat-select-infinite-scroll@next
 ```
 
-### Usage  
+## Standalone usage
 
-[StackBlitz working example](https://stackblitz.com/edit/ng-mat-select-infinite-scroll)  
-
-Import `MatSelectInfiniteScrollModule` inside the `app.module.ts`:  
-```typescript
+```ts
+import { Component } from '@angular/core';
+import { CommonModule } from '@angular/common';
 import { MatFormFieldModule } from '@angular/material/form-field';
 import { MatSelectModule } from '@angular/material/select';
-import { MatSelectInfiniteScrollModule } from 'ng-mat-select-infinite-scroll';
-
-@NgModule({
-  declarations: [
-    AppComponent
-  ],
-  imports: [
-    BrowserModule,
-    BrowserAnimationsModule,
-    MatFormFieldModule,
-    MatSelectModule,
-    MatSelectInfiniteScrollModule
-  ],
-  providers: [],
-  bootstrap: [AppComponent]
+import { MatSelectInfiniteScrollDirective } from 'ng-mat-select-infinite-scroll';
+
+@Component({
+  standalone: true,
+  imports: [CommonModule, MatFormFieldModule, MatSelectModule, MatSelectInfiniteScrollDirective],
+  template: `
+    <mat-form-field>
+      <mat-label>Customer</mat-label>
+      <mat-select msInfiniteScroll [loading]="loading" [complete]="complete"
+                  (infiniteScroll)="loadNextPage()">
+        <mat-option *ngFor="let item of options" [value]="item.id">
+          {{ item.name }}
+        </mat-option>
+      </mat-select>
+    </mat-form-field>
+  `
 })
-export class AppModule {}
+export class CustomerSelect {
+  options: Array<{ id: number; name: string }> = [];
+  loading = false;
+  complete = false;
+  // Fetch the initial page before opening an empty select.
+  loadNextPage() { /* guarded server request; see below */ }
+}
 ```
 
-Then, place the `msInfiniteScroll` directive on the `mat-select` component:  
-```html
-<mat-form-field appearance="outline">
-  <mat-label>Select</mat-label>
-  <mat-select msInfiniteScroll (infiniteScroll)="getNextBatch()" [complete]="offset === data.length">
-    <mat-option *ngFor="let option of options$ | async" [value]="option">{{option}}</mat-option>
-  </mat-select>
-</mat-form-field>
+On Angular 22 use `@for (item of options; track item.id) { ... }` instead of the removed `*ngFor`. Configure animations according to your application's Angular/Material version.
+
+For NgModule applications, import `MatSelectInfiniteScrollModule` alongside `MatSelectModule` and `MatFormFieldModule`. Existing `msInfiniteScroll` templates continue to work.
+
+## API
+
+| Input | Default | Behavior |
+| --- | --- | --- |
+| `complete` | `false` | Suppresses output immediately, including changes while the panel is open. Reset for a new query. |
+| `loading` | `false` | Suppresses output while a page is in flight. Bind this to the application's request state. |
+| `threshold` | `'15%'` | Distance from the bottom: `0`–`100%`, a pixel string such as `'100px'`, or a numeric string such as `'100'`. |
+| `debounceTime` | `150` | Non-negative milliseconds to wait after a scroll event. |
+
+`(infiniteScroll)` emits `void` when more options are needed. Inputs remain live while open. Invalid thresholds and non-finite/negative debounce values throw `RangeError`.
+
+The directive checks the rendered panel on opening, after option changes, and when loading/completion inputs change. This allows a preselected last item or a short page to request more without another scroll. Automatic requests are bounded by changes to the rendered list; a failed or empty response does not cause an automatic retry loop. User scrolling can request again. Close/destroy cancels pending work.
+
+## Loading pages safely
+
+Fetch the first page in your component's initialization. Keep HTTP, offsets, cancellation, errors, and caching in the application:
+
+```ts
+loadNextPage() {
+  if (this.loading || this.complete) return;
+  this.loading = true;
+  this.error = null;
+  this.api.getCustomers({ query: this.query, offset: this.options.length, limit: 20 })
+    .pipe(finalize(() => { this.loading = false; }))
+    .subscribe({
+      next: page => {
+        this.options = [...this.options, ...page.items];
+        this.complete = this.options.length >= page.total || page.items.length === 0;
+      },
+      error: error => { this.error = error; }
+    });
+}
 ```
 
-> **Note:**  
-> Update the `complete` property when the loaded data reaches the total available data to avoid unnecessary scroll triggers.  
-> For older versions of Angular (<15), use version 4 of this library.
+Import `finalize` from RxJS. In a zoneless/OnPush component, use signals or mark the view for checking when asynchronous fields change. Cancel in-flight requests on destruction and query reset; a stale response must not append to a new query. Offer an explicit retry action after an error.
 
-### Compatibility  
+For server search, cancel the previous query (for example with `switchMap`), reset options/page/completion, and request the new first page. Search inputs can live outside `mat-select`; this directive does not implement filtering. For repeated selects in a FormArray, share a data-service cache keyed by query/filter/page and deduplicate in-flight requests there.
 
-This library supports Angular 15 and higher.  
-* `@angular/core`: `>=15.0.0 <16`  
-* `@angular/cdk`: `>=15.0.0 <16`  
-* `@angular/material`: `>=15.0.0 <16`  
-* `rxjs`: `^7.0.0`  
+## Selection and layout
 
-### Contributions  
+- Append options with stable IDs/identity. When clearing pages or filtering, retain the selected options separately or fetch them by ID; `compareWith` cannot recreate a removed option.
+- Keep the Material panel as the scrolling container. Arbitrary nested scrolling `div` elements are not supported. Standard options and optgroups are supported.
+- Appending pages preserves the panel's scroll position. **Material can still reset its active keyboard item to the selected option when the option list changes.** The compatibility browser checks record this upstream behavior; the library does not modify private Material key-manager fields. See [known limitations](docs/KNOWN_LIMITATIONS.md).
 
-Contributions are welcome! Feel free to open a Pull Request or create a new issue.  
+## Migration from 4.x / 5.x
 
-### Development Server  
+Keep the same selector, output, and NgModule import, or switch to the standalone directive. Add `[loading]` to prevent overlapping requests. Set/reset `[complete]` when your query finishes or changes. Review the stricter threshold validation and the new opening/short-list checks; requests can occur on opening without a new scroll event. Use the compatibility table instead of bypassing npm peers.
 
-Run `ng serve` for a dev server. Navigate to `http://localhost:4200/`. The app will automatically reload if you change any source files.  
+## Development
 
-### Build  
+```sh
+nvm use
+npm ci --ignore-scripts
+npm ci --prefix tools/build-library --ignore-scripts
+npm test
+npm run build
+npm run check:policy
+```
 
-Run `ng build` to build the project. The build artifacts will be stored in the `dist/` directory. Use the `--prod` flag for a production build.  
+The library builder intentionally uses Angular 15.2 and Node 18 in isolation. Browser orchestration and publication use Node 24.15. See [compatibility checks](compat/README.md) for per-version commands. Build output, tarballs, and browser receipts are ignored.
+
+The interactive demo uses its own Angular 22 toolchain. After building the library:
+
+```sh
+cd projects/example
+nvm use
+npm ci --ignore-scripts
+npm start
+```
 
-### Running Unit Tests  
+PR CI validates the actual tarball; the publishing workflow repeats the checks and uses npm trusted publishing. Stable publication requires the approved version, beta feedback, and the full matrix. See [request and selection recipes](docs/RECIPES.md) for shared caching and reset behavior.
 
-Run `ng test` to execute unit tests via [Karma](https://karma-runner.github.io).  
+Contributions are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md).
 
-### License  
+## License
 
-[MIT](LICENSE)  
+[MIT](LICENSE)

package/esm2020/lib/infinite-scroll.service.mjs

@@ -1,64 +1,73 @@
 import { Injectable } from '@angular/core';
-import { fromEvent, Subject } from 'rxjs';
-import { debounceTime, takeUntil, tap } from 'rxjs/operators';
+import { debounce, fromEvent, timer } from 'rxjs';
 import * as i0 from "@angular/core";
 export class InfiniteScrollService {
     constructor(ngZone) {
         this.ngZone = ngZone;
-        this.threshold = '15%';
-        this.debounceTime = 150;
-        this.thrPx = 0;
-        this.thrPc = 0;
-        this.destroyed$ = new Subject();
+        this.optionCount = 0;
     }
-    initialize(panel, selectItemHeightPx, config) {
-        this.threshold = config.threshold;
-        this.debounceTime = config.debounceTime;
-        this.complete = config.complete;
-        this.panel = panel;
-        this.selectItemHeightPx = selectItemHeightPx;
-        this.evaluateThreshold();
-    }
-    evaluateThreshold() {
-        if (this.threshold.lastIndexOf('%') > -1) {
-            this.thrPx = 0;
-            this.thrPc = (parseFloat(this.threshold) / 100);
-        }
-        else {
-            this.thrPx = parseFloat(this.threshold);
-            this.thrPc = 0;
+    validate(config) {
+        this.thresholdPixels(config.threshold, 1);
+        if (!Number.isFinite(config.debounceTime) || config.debounceTime < 0) {
+            throw new RangeError('debounceTime must be a finite, non-negative number');
         }
     }
-    registerScrollListener(infiniteScrollCallback) {
-        fromEvent(this.panel, 'scroll').pipe(takeUntil(this.destroyed$), debounceTime(this.debounceTime), tap((event) => {
-            this.handleScrollEvent(event, infiniteScrollCallback);
-        })).subscribe();
-    }
-    handleScrollEvent(event, infiniteScrollCallback) {
+    connect(panel, configuration, callback) {
+        this.disconnect();
+        this.validate(configuration());
+        this.panel = panel;
+        this.configuration = configuration;
+        this.callback = callback;
         this.ngZone.runOutsideAngular(() => {
-            if (this.complete) {
-                return;
-            }
-            const countOfRenderedOptions = Math.round(this.panel.scrollHeight / this.selectItemHeightPx);
-            const infiniteScrollDistance = this.selectItemHeightPx * countOfRenderedOptions;
-            const threshold = this.thrPc !== 0 ? (infiniteScrollDistance * this.thrPc) : this.thrPx;
-            const scrolledDistance = this.panel.clientHeight + event.target.scrollTop;
-            if ((scrolledDistance + threshold) >= infiniteScrollDistance) {
-                this.ngZone.run(infiniteScrollCallback);
-            }
+            this.subscription = fromEvent(panel, 'scroll').pipe(debounce(() => timer(configuration().debounceTime))).subscribe(() => this.check(this.optionCount, false));
         });
     }
-    destroy() {
-        this.destroyed$.next();
-        this.destroyed$.complete();
+    check(optionCount, automatic = true) {
+        this.optionCount = optionCount;
+        const panel = this.panel;
+        const config = this.configuration?.();
+        if (!panel || !config || config.complete || config.loading || panel.clientHeight <= 0)
+            return;
+        const threshold = this.thresholdPixels(config.threshold, panel.scrollHeight);
+        const remaining = panel.scrollHeight - panel.clientHeight - panel.scrollTop;
+        if (remaining > threshold + 0.5)
+            return;
+        // An automatic check can request again only after the rendered list changes.
+        // A failed/empty page must not cause an unbounded automatic request loop.
+        const key = `${panel.scrollHeight}:${panel.clientHeight}:${optionCount}`;
+        if (automatic && key === this.lastRequestKey)
+            return;
+        this.lastRequestKey = key;
+        if (this.callback)
+            this.ngZone.run(this.callback);
+    }
+    reset() {
+        this.lastRequestKey = undefined;
+    }
+    disconnect() {
+        // Unsubscribing discards pending debounce timers instead of flushing them.
+        this.subscription?.unsubscribe();
+        this.subscription = undefined;
+        this.panel = undefined;
+        this.configuration = undefined;
+        this.callback = undefined;
+        this.optionCount = 0;
+        this.reset();
+    }
+    thresholdPixels(value, height) {
+        const match = /^(\d+(?:\.\d+)?|\.\d+)(%|px)?$/.exec(String(value).trim());
+        if (!match || !Number.isFinite(Number(match[1]))) {
+            throw new RangeError('threshold must be a non-negative percentage or pixel distance');
+        }
+        const distance = Number(match[1]);
+        if (match[2] === '%' && distance > 100)
+            throw new RangeError('percentage threshold must not exceed 100%');
+        return match[2] === '%' ? height * distance / 100 : distance;
     }
 }
-InfiniteScrollService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: InfiniteScrollService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
-InfiniteScrollService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: InfiniteScrollService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: InfiniteScrollService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
+InfiniteScrollService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: InfiniteScrollService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+InfiniteScrollService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: InfiniteScrollService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: InfiniteScrollService, decorators: [{
+            type: Injectable
         }], ctorParameters: function () { return [{ type: i0.NgZone }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"infinite-scroll.service.js","sourceRoot":"","sources":["../../../../tools/build-library/.stage/src/lib/infinite-scroll.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\nimport { debounce, fromEvent, Subscription, timer } from 'rxjs';\n\nexport interface ScrollConfiguration {\n  threshold: string;\n  debounceTime: number;\n  complete: boolean;\n  loading: boolean;\n}\n\n@Injectable()\nexport class InfiniteScrollService {\n  private subscription?: Subscription;\n  private panel?: HTMLElement;\n  private configuration?: () => ScrollConfiguration;\n  private callback?: () => void;\n  private lastRequestKey?: string;\n  private optionCount = 0;\n\n  constructor(private readonly ngZone: NgZone) {}\n\n  validate(config: ScrollConfiguration): void {\n    this.thresholdPixels(config.threshold, 1);\n    if (!Number.isFinite(config.debounceTime) || config.debounceTime < 0) {\n      throw new RangeError('debounceTime must be a finite, non-negative number');\n    }\n  }\n\n  connect(panel: HTMLElement, configuration: () => ScrollConfiguration, callback: () => void): void {\n    this.disconnect();\n    this.validate(configuration());\n    this.panel = panel;\n    this.configuration = configuration;\n    this.callback = callback;\n    this.ngZone.runOutsideAngular(() => {\n      this.subscription = fromEvent(panel, 'scroll').pipe(\n        debounce(() => timer(configuration().debounceTime))\n      ).subscribe(() => this.check(this.optionCount, false));\n    });\n  }\n\n  check(optionCount: number, automatic = true): void {\n    this.optionCount = optionCount;\n    const panel = this.panel;\n    const config = this.configuration?.();\n    if (!panel || !config || config.complete || config.loading || panel.clientHeight <= 0) return;\n    const threshold = this.thresholdPixels(config.threshold, panel.scrollHeight);\n    const remaining = panel.scrollHeight - panel.clientHeight - panel.scrollTop;\n    if (remaining > threshold + 0.5) return;\n\n    // An automatic check can request again only after the rendered list changes.\n    // A failed/empty page must not cause an unbounded automatic request loop.\n    const key = `${panel.scrollHeight}:${panel.clientHeight}:${optionCount}`;\n    if (automatic && key === this.lastRequestKey) return;\n    this.lastRequestKey = key;\n    if (this.callback) this.ngZone.run(this.callback);\n  }\n\n  reset(): void {\n    this.lastRequestKey = undefined;\n  }\n\n  disconnect(): void {\n    // Unsubscribing discards pending debounce timers instead of flushing them.\n    this.subscription?.unsubscribe();\n    this.subscription = undefined;\n    this.panel = undefined;\n    this.configuration = undefined;\n    this.callback = undefined;\n    this.optionCount = 0;\n    this.reset();\n  }\n\n  private thresholdPixels(value: string, height: number): number {\n    const match = /^(\\d+(?:\\.\\d+)?|\\.\\d+)(%|px)?$/.exec(String(value).trim());\n    if (!match || !Number.isFinite(Number(match[1]))) {\n      throw new RangeError('threshold must be a non-negative percentage or pixel distance');\n    }\n    const distance = Number(match[1]);\n    if (match[2] === '%' && distance > 100) throw new RangeError('percentage threshold must not exceed 100%');\n    return match[2] === '%' ? height * distance / 100 : distance;\n  }\n}\n"]}

package/esm2020/lib/mat-select-infinite-scroll.directive.mjs

@@ -1,52 +1,112 @@
 import { Directive, EventEmitter, Input, Output } from '@angular/core';
-import { delay, takeUntil } from 'rxjs/operators';
-import { InfiniteScrollService } from "./infinite-scroll.service";
-import { Subject } from "rxjs";
+import { Subscription } from 'rxjs';
+import { InfiniteScrollService } from './infinite-scroll.service';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/material/select";
 import * as i2 from "./infinite-scroll.service";
-/** The height of the select items in `em` units. */
-const SELECT_ITEM_HEIGHT_EM = 3;
 export class MatSelectInfiniteScrollDirective {
-    constructor(matSelect, infiniteScrollService) {
+    constructor(matSelect, scroll) {
         this.matSelect = matSelect;
-        this.infiniteScrollService = infiniteScrollService;
+        this.scroll = scroll;
         this.threshold = '15%';
         this.debounceTime = 150;
+        this.complete = false;
+        this.loading = false;
         this.infiniteScroll = new EventEmitter();
-        this.destroyed$ = new Subject();
+        this.subscriptions = new Subscription();
+        this.connected = false;
+        this.destroyed = false;
+        this.optionCount = 0;
+    }
+    ngOnChanges(changes) {
+        this.scroll.validate(this.configuration());
+        if (changes['complete']?.previousValue === true && !this.complete)
+            this.scroll.reset();
+        this.scheduleCheck();
     }
     ngAfterViewInit() {
-        this.matSelect.openedChange.pipe(
-        //Wait for the panel to be rendered (https://github.com/angular/components/issues/30596)
-        delay(0), takeUntil(this.destroyed$)).subscribe((opened) => {
-            if (opened) {
-                const panel = this.matSelect.panel.nativeElement;
-                const selectItemHeightPx = this.getSelectItemHeightPx(panel);
-                this.infiniteScrollService.initialize(panel, selectItemHeightPx, {
-                    threshold: this.threshold,
-                    debounceTime: this.debounceTime,
-                    complete: this.complete
-                });
-                this.infiniteScrollService.registerScrollListener(() => this.infiniteScroll.emit());
+        this.subscriptions.add(this.matSelect.openedChange.subscribe(opened => {
+            if (!opened)
+                this.closePanel();
+            else if (!this.connected && this.openTimer === undefined)
+                this.openPanel();
+            else
+                this.scheduleCheck();
+        }));
+        this.subscriptions.add(this.matSelect.stateChanges.subscribe(() => {
+            if (!this.matSelect.panelOpen)
+                this.closePanel();
+            else if (!this.connected && this.openTimer === undefined)
+                this.openPanel();
+        }));
+        this.subscriptions.add(this.matSelect.options.changes.subscribe(() => {
+            const count = this.matSelect.options.length;
+            if (this.connected && this.optionCount > 0 && count > this.optionCount &&
+                this.matSelect.options.get(this.optionCount - 1) === this.lastOption) {
+                this.scrollAnchor = this.matSelect.panel?.nativeElement.scrollTop;
             }
+            this.optionCount = count;
+            this.lastOption = this.matSelect.options.last;
+            this.scheduleCheck();
+        }));
+        if (this.matSelect.panelOpen)
+            this.openPanel();
+    }
+    ngOnDestroy() {
+        this.destroyed = true;
+        this.closePanel();
+        this.subscriptions.unsubscribe();
+    }
+    openPanel() {
+        // Material versions differ in when the overlay panel becomes available.
+        this.openTimer = setTimeout(() => {
+            this.openTimer = undefined;
+            const panel = this.matSelect.panel?.nativeElement;
+            if (this.destroyed || !this.matSelect.panelOpen || !panel)
+                return;
+            this.scroll.connect(panel, () => this.configuration(), () => this.infiniteScroll.emit());
+            this.connected = true;
+            this.optionCount = this.matSelect.options.length;
+            this.lastOption = this.matSelect.options.last;
+            this.scheduleCheck();
         });
     }
-    getSelectItemHeightPx(panel) {
-        return parseFloat(getComputedStyle(panel).fontSize) * SELECT_ITEM_HEIGHT_EM;
+    closePanel() {
+        clearTimeout(this.openTimer);
+        clearTimeout(this.checkTimer);
+        this.openTimer = undefined;
+        this.checkTimer = undefined;
+        this.connected = false;
+        this.scrollAnchor = undefined;
+        this.lastOption = undefined;
+        this.scroll.disconnect();
     }
-    ngOnDestroy() {
-        this.destroyed$.next(true);
-        this.destroyed$.complete();
-        this.infiniteScrollService.destroy();
+    scheduleCheck() {
+        if (!this.connected || this.destroyed)
+            return;
+        clearTimeout(this.checkTimer);
+        this.checkTimer = setTimeout(() => {
+            this.checkTimer = undefined;
+            if (this.connected && this.matSelect.panelOpen) {
+                if (this.scrollAnchor !== undefined) {
+                    this.matSelect.panel.nativeElement.scrollTop = this.scrollAnchor;
+                    this.scrollAnchor = undefined;
+                }
+                this.scroll.check(this.matSelect.options.length);
+            }
+        });
+    }
+    configuration() {
+        return { threshold: this.threshold, debounceTime: this.debounceTime, complete: this.complete || !this.matSelect.panelOpen, loading: this.loading };
     }
 }
-MatSelectInfiniteScrollDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MatSelectInfiniteScrollDirective, deps: [{ token: i1.MatSelect }, { token: i2.InfiniteScrollService }], target: i0.ɵɵFactoryTarget.Directive });
-MatSelectInfiniteScrollDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.10", type: MatSelectInfiniteScrollDirective, selector: "[msInfiniteScroll]", inputs: { threshold: "threshold", debounceTime: "debounceTime", complete: "complete" }, outputs: { infiniteScroll: "infiniteScroll" }, providers: [InfiniteScrollService], ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MatSelectInfiniteScrollDirective, decorators: [{
+MatSelectInfiniteScrollDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: MatSelectInfiniteScrollDirective, deps: [{ token: i1.MatSelect }, { token: i2.InfiniteScrollService }], target: i0.ɵɵFactoryTarget.Directive });
+MatSelectInfiniteScrollDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.0", type: MatSelectInfiniteScrollDirective, isStandalone: true, selector: "[msInfiniteScroll]", inputs: { threshold: "threshold", debounceTime: "debounceTime", complete: "complete", loading: "loading" }, outputs: { infiniteScroll: "infiniteScroll" }, providers: [InfiniteScrollService], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: MatSelectInfiniteScrollDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[msInfiniteScroll]',
+                    standalone: true,
                     providers: [InfiniteScrollService]
                 }]
         }], ctorParameters: function () { return [{ type: i1.MatSelect }, { type: i2.InfiniteScrollService }]; }, propDecorators: { threshold: [{
@@ -55,7 +115,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                 type: Input
             }], complete: [{
                 type: Input
+            }], loading: [{
+                type: Input
             }], infiniteScroll: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mat-select-infinite-scroll.directive.js","sourceRoot":"","sources":["../../../../tools/build-library/.stage/src/lib/mat-select-infinite-scroll.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Directive, EventEmitter, Input, OnChanges, OnDestroy, Output, SimpleChanges } from '@angular/core';\nimport { MatSelect } from '@angular/material/select';\nimport { Subscription } from 'rxjs';\nimport { InfiniteScrollService, ScrollConfiguration } from './infinite-scroll.service';\n\n@Directive({\n  selector: '[msInfiniteScroll]',\n  standalone: true,\n  providers: [InfiniteScrollService]\n})\nexport class MatSelectInfiniteScrollDirective implements AfterViewInit, OnChanges, OnDestroy {\n  @Input() threshold = '15%';\n  @Input() debounceTime = 150;\n  @Input() complete = false;\n  @Input() loading = false;\n  @Output() infiniteScroll = new EventEmitter<void>();\n\n  private readonly subscriptions = new Subscription();\n  private openTimer?: ReturnType<typeof setTimeout>;\n  private checkTimer?: ReturnType<typeof setTimeout>;\n  private connected = false;\n  private destroyed = false;\n  private optionCount = 0;\n  private lastOption: unknown;\n  private scrollAnchor?: number;\n\n  constructor(protected readonly matSelect: MatSelect, private readonly scroll: InfiniteScrollService) {}\n\n  ngOnChanges(changes: SimpleChanges): void {\n    this.scroll.validate(this.configuration());\n    if (changes['complete']?.previousValue === true && !this.complete) this.scroll.reset();\n    this.scheduleCheck();\n  }\n\n  ngAfterViewInit(): void {\n    this.subscriptions.add(this.matSelect.openedChange.subscribe(opened => {\n      if (!opened) this.closePanel();\n      else if (!this.connected && this.openTimer === undefined) this.openPanel();\n      else this.scheduleCheck();\n    }));\n    this.subscriptions.add(this.matSelect.stateChanges.subscribe(() => {\n      if (!this.matSelect.panelOpen) this.closePanel();\n      else if (!this.connected && this.openTimer === undefined) this.openPanel();\n    }));\n    this.subscriptions.add(this.matSelect.options.changes.subscribe(() => {\n      const count = this.matSelect.options.length;\n      if (this.connected && this.optionCount > 0 && count > this.optionCount &&\n          this.matSelect.options.get(this.optionCount - 1) === this.lastOption) {\n        this.scrollAnchor = this.matSelect.panel?.nativeElement.scrollTop;\n      }\n      this.optionCount = count;\n      this.lastOption = this.matSelect.options.last;\n      this.scheduleCheck();\n    }));\n    if (this.matSelect.panelOpen) this.openPanel();\n  }\n\n  ngOnDestroy(): void {\n    this.destroyed = true;\n    this.closePanel();\n    this.subscriptions.unsubscribe();\n  }\n\n  private openPanel(): void {\n    // Material versions differ in when the overlay panel becomes available.\n    this.openTimer = setTimeout(() => {\n      this.openTimer = undefined;\n      const panel = this.matSelect.panel?.nativeElement as HTMLElement | undefined;\n      if (this.destroyed || !this.matSelect.panelOpen || !panel) return;\n      this.scroll.connect(panel, () => this.configuration(), () => this.infiniteScroll.emit());\n      this.connected = true;\n      this.optionCount = this.matSelect.options.length;\n      this.lastOption = this.matSelect.options.last;\n      this.scheduleCheck();\n    });\n  }\n\n  private closePanel(): void {\n    clearTimeout(this.openTimer);\n    clearTimeout(this.checkTimer);\n    this.openTimer = undefined;\n    this.checkTimer = undefined;\n    this.connected = false;\n    this.scrollAnchor = undefined;\n    this.lastOption = undefined;\n    this.scroll.disconnect();\n  }\n\n  private scheduleCheck(): void {\n    if (!this.connected || this.destroyed) return;\n    clearTimeout(this.checkTimer);\n    this.checkTimer = setTimeout(() => {\n      this.checkTimer = undefined;\n      if (this.connected && this.matSelect.panelOpen) {\n        if (this.scrollAnchor !== undefined) {\n          this.matSelect.panel.nativeElement.scrollTop = this.scrollAnchor;\n          this.scrollAnchor = undefined;\n        }\n        this.scroll.check(this.matSelect.options.length);\n      }\n    });\n  }\n\n  private configuration(): ScrollConfiguration {\n    return { threshold: this.threshold, debounceTime: this.debounceTime, complete: this.complete || !this.matSelect.panelOpen, loading: this.loading };\n  }\n}\n"]}

package/esm2020/lib/mat-select-infinite-scroll.module.mjs

@@ -4,17 +4,18 @@ import { MatSelectModule } from '@angular/material/select';
 import * as i0 from "@angular/core";
 export class MatSelectInfiniteScrollModule {
 }
-MatSelectInfiniteScrollModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MatSelectInfiniteScrollModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-MatSelectInfiniteScrollModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: MatSelectInfiniteScrollModule, declarations: [MatSelectInfiniteScrollDirective], imports: [MatSelectModule], exports: [MatSelectInfiniteScrollDirective] });
-MatSelectInfiniteScrollModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MatSelectInfiniteScrollModule, imports: [MatSelectModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MatSelectInfiniteScrollModule, decorators: [{
+MatSelectInfiniteScrollModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: MatSelectInfiniteScrollModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MatSelectInfiniteScrollModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.0", ngImport: i0, type: MatSelectInfiniteScrollModule, imports: [MatSelectModule,
+        MatSelectInfiniteScrollDirective], exports: [MatSelectInfiniteScrollDirective] });
+MatSelectInfiniteScrollModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: MatSelectInfiniteScrollModule, imports: [MatSelectModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: MatSelectInfiniteScrollModule, decorators: [{
             type: NgModule,
             args: [{
-                    declarations: [MatSelectInfiniteScrollDirective],
                     imports: [
                         MatSelectModule,
+                        MatSelectInfiniteScrollDirective,
                     ],
                     exports: [MatSelectInfiniteScrollDirective]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWF0LXNlbGVjdC1pbmZpbml0ZS1zY3JvbGwubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvbmctbWF0LXNlbGVjdC1pbmZpbml0ZS1zY3JvbGwvc3JjL2xpYi9tYXQtc2VsZWN0LWluZmluaXRlLXNjcm9sbC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUN2QyxPQUFPLEVBQUMsZ0NBQWdDLEVBQUMsTUFBTSx3Q0FBd0MsQ0FBQztBQUN4RixPQUFPLEVBQUMsZUFBZSxFQUFDLE1BQU0sMEJBQTBCLENBQUM7O0FBU3pELE1BQU0sT0FBTyw2QkFBNkI7OzJIQUE3Qiw2QkFBNkI7NEhBQTdCLDZCQUE2QixpQkFOdkIsZ0NBQWdDLGFBRTNDLGVBQWUsYUFFVCxnQ0FBZ0M7NEhBRWpDLDZCQUE2QixZQUpsQyxlQUFlOzRGQUlWLDZCQUE2QjtrQkFQekMsUUFBUTttQkFBQztvQkFDTixZQUFZLEVBQUUsQ0FBQyxnQ0FBZ0MsQ0FBQztvQkFDaEQsT0FBTyxFQUFFO3dCQUNMLGVBQWU7cUJBQ2xCO29CQUNELE9BQU8sRUFBRSxDQUFDLGdDQUFnQyxDQUFDO2lCQUM5QyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7TmdNb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtNYXRTZWxlY3RJbmZpbml0ZVNjcm9sbERpcmVjdGl2ZX0gZnJvbSAnLi9tYXQtc2VsZWN0LWluZmluaXRlLXNjcm9sbC5kaXJlY3RpdmUnO1xuaW1wb3J0IHtNYXRTZWxlY3RNb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL3NlbGVjdCc7XG5cbkBOZ01vZHVsZSh7XG4gICAgZGVjbGFyYXRpb25zOiBbTWF0U2VsZWN0SW5maW5pdGVTY3JvbGxEaXJlY3RpdmVdLFxuICAgIGltcG9ydHM6IFtcbiAgICAgICAgTWF0U2VsZWN0TW9kdWxlLFxuICAgIF0sXG4gICAgZXhwb3J0czogW01hdFNlbGVjdEluZmluaXRlU2Nyb2xsRGlyZWN0aXZlXVxufSlcbmV4cG9ydCBjbGFzcyBNYXRTZWxlY3RJbmZpbml0ZVNjcm9sbE1vZHVsZSB7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWF0LXNlbGVjdC1pbmZpbml0ZS1zY3JvbGwubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vdG9vbHMvYnVpbGQtbGlicmFyeS8uc3RhZ2Uvc3JjL2xpYi9tYXQtc2VsZWN0LWluZmluaXRlLXNjcm9sbC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUN2QyxPQUFPLEVBQUMsZ0NBQWdDLEVBQUMsTUFBTSx3Q0FBd0MsQ0FBQztBQUN4RixPQUFPLEVBQUMsZUFBZSxFQUFDLE1BQU0sMEJBQTBCLENBQUM7O0FBU3pELE1BQU0sT0FBTyw2QkFBNkI7OzBIQUE3Qiw2QkFBNkI7MkhBQTdCLDZCQUE2QixZQUxsQyxlQUFlO1FBQ2YsZ0NBQWdDLGFBRTFCLGdDQUFnQzsySEFFakMsNkJBQTZCLFlBTGxDLGVBQWU7MkZBS1YsNkJBQTZCO2tCQVB6QyxRQUFRO21CQUFDO29CQUNOLE9BQU8sRUFBRTt3QkFDTCxlQUFlO3dCQUNmLGdDQUFnQztxQkFDbkM7b0JBQ0QsT0FBTyxFQUFFLENBQUMsZ0NBQWdDLENBQUM7aUJBQzlDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtOZ01vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge01hdFNlbGVjdEluZmluaXRlU2Nyb2xsRGlyZWN0aXZlfSBmcm9tICcuL21hdC1zZWxlY3QtaW5maW5pdGUtc2Nyb2xsLmRpcmVjdGl2ZSc7XG5pbXBvcnQge01hdFNlbGVjdE1vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvc2VsZWN0JztcblxuQE5nTW9kdWxlKHtcbiAgICBpbXBvcnRzOiBbXG4gICAgICAgIE1hdFNlbGVjdE1vZHVsZSxcbiAgICAgICAgTWF0U2VsZWN0SW5maW5pdGVTY3JvbGxEaXJlY3RpdmUsXG4gICAgXSxcbiAgICBleHBvcnRzOiBbTWF0U2VsZWN0SW5maW5pdGVTY3JvbGxEaXJlY3RpdmVdXG59KVxuZXhwb3J0IGNsYXNzIE1hdFNlbGVjdEluZmluaXRlU2Nyb2xsTW9kdWxlIHtcbn1cbiJdfQ==

package/esm2020/ng-mat-select-infinite-scroll.mjs

@@ -2,4 +2,4 @@
  * Generated bundle index. Do not edit.
  */
 export * from './public-api';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctbWF0LXNlbGVjdC1pbmZpbml0ZS1zY3JvbGwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wcm9qZWN0cy9uZy1tYXQtc2VsZWN0LWluZmluaXRlLXNjcm9sbC9zcmMvbmctbWF0LXNlbGVjdC1pbmZpbml0ZS1zY3JvbGwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctbWF0LXNlbGVjdC1pbmZpbml0ZS1zY3JvbGwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90b29scy9idWlsZC1saWJyYXJ5Ly5zdGFnZS9zcmMvbmctbWF0LXNlbGVjdC1pbmZpbml0ZS1zY3JvbGwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2020/public-api.mjs

@@ -3,4 +3,4 @@
  */
 export * from './lib/mat-select-infinite-scroll.directive';
 export * from './lib/mat-select-infinite-scroll.module';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25nLW1hdC1zZWxlY3QtaW5maW5pdGUtc2Nyb2xsL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyw0Q0FBNEMsQ0FBQztBQUMzRCxjQUFjLHlDQUF5QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBuZy1tYXQtc2VsZWN0LWluZmluaXRlLXNjcm9sbFxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL21hdC1zZWxlY3QtaW5maW5pdGUtc2Nyb2xsLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9tYXQtc2VsZWN0LWluZmluaXRlLXNjcm9sbC5tb2R1bGUnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Rvb2xzL2J1aWxkLWxpYnJhcnkvLnN0YWdlL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyw0Q0FBNEMsQ0FBQztBQUMzRCxjQUFjLHlDQUF5QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBuZy1tYXQtc2VsZWN0LWluZmluaXRlLXNjcm9sbFxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL21hdC1zZWxlY3QtaW5maW5pdGUtc2Nyb2xsLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9tYXQtc2VsZWN0LWluZmluaXRlLXNjcm9sbC5tb2R1bGUnO1xuIl19