@ceriousdevtech/ngx-cerious-scroll 1.0.0 → 1.0.2

package/esm2022/lib/cerious-scroll.directive.mjs

@@ -35,7 +35,13 @@ export class CeriousScrollDirective {
         this.ceriousScrollReady = new EventEmitter();
         this.hostRef = null;
         this.viewportSub = null;
+        this.scheduledRenderFrame = null;
         this.viewByContainer = new Map();
+        // Pool of views detached because their container left the viewport. Reusing
+        // them on subsequent renders avoids destroying + recreating the entire row
+        // component tree on fast scrolls (where the engine's element pool wipes
+        // textContent on reused containers, so view rootNodes get orphaned).
+        this.freeViews = [];
     }
     ngAfterViewInit() {
         this.ensureInitialized();
@@ -45,10 +51,33 @@ export class CeriousScrollDirective {
             return;
         if (changes['ceriousScrollItems'] || changes['ceriousScrollTotalElements']) {
             const total = coerceTotalElements(this.ceriousScrollTotalElements, this.ceriousScrollItems?.length ?? null);
-            this.hostRef.scroller.totalElements = total;
-            this.hostRef.scroller.clearAllCaches();
-            if (this.ceriousScrollAutoRender)
+            const countChanged = this.hostRef.scroller.totalElements !== total;
+            if (countChanged) {
+                // The dataset size changed: the ViewportRenderer stores its own copy of
+                // totalElements (set by value at construction) so patching the engine's
+                // public property alone leaves the renderer's internal bound stale.  The
+                // renderer would then use the old count for its viewport-fill loop and
+                // bottom-boundary scan, producing phantom renders at out-of-bounds
+                // indices (undefined items → 0-height rows → the fill loop never
+                // satisfies its height condition → hundreds of renderer callbacks).
+                // Recreating the engine gives both the engine and the renderer a fresh,
+                // consistent count.  ensureInitialized() schedules the first render via
+                // queueMicrotask, which runs after the current CD cycle completes.
+                this.recreate();
+            }
+            else if (this.ceriousScrollAutoRender) {
+                // Same count, new data reference (e.g. an immutable edit or a sort that
+                // happens to keep the same length). The engine reuses the DOM element it
+                // already rendered for each overlapping index without re-invoking the
+                // renderer, so update the content of every currently-visible row IN
+                // PLACE before calling render().  This preserves each row's embedded
+                // view (so a focused textbox keeps focus/caret) and does NOT discard
+                // cached heights. If a row's height actually changes the engine's
+                // ResizeObserver keeps the cache correct on its own; for a wholesale
+                // height change across all rows, call recalculate() instead.
+                this.refreshRenderedContent();
                 this.render();
+            }
         }
         if (changes['ceriousScrollOptions'] && !changes['ceriousScrollOptions'].firstChange) {
             // Options are consumed primarily at construction time.
@@ -56,6 +85,10 @@ export class CeriousScrollDirective {
         }
     }
     ngOnDestroy() {
+        if (this.scheduledRenderFrame != null) {
+            cancelAnimationFrame(this.scheduledRenderFrame);
+            this.scheduledRenderFrame = null;
+        }
         this.viewportSub?.unsubscribe();
         this.viewportSub = null;
         this.destroyAllViews();
@@ -72,16 +105,122 @@ export class CeriousScrollDirective {
         const hostContainer = this.host.nativeElement;
         const height = hostContainer.clientHeight || hostContainer.offsetHeight;
         const contentContainer = this.hostRef.contentElement;
+        // Track whether the engine asked us to bind any row this pass. Pure scroll
+        // frames where the visible row set doesn't change still drive render() via
+        // the rAF coalescer — there's no point in walking the prune map or
+        // emitting the viewport range when nothing was touched.
+        let rendererInvocations = 0;
         const renderer = (index, elementContainer) => {
-            // Rendering must create Angular views inside the Angular zone.
-            this.ngZone.run(() => {
-                this.renderTemplateIntoContainer(template, index, elementContainer);
-            });
+            rendererInvocations++;
+            // Render each row's embedded view with LOCAL change detection
+            // (`view.detectChanges()` inside `renderTemplateIntoContainer`) so the
+            // engine can measure its height during this pass. Do NOT wrap each row in
+            // its own `ngZone.run` — that fires a full `ApplicationRef` tick *per row*
+            // (O(newRows × visibleRows) work, janky drags). The single coalesced tick
+            // for the whole pass is handled by the caller (`scheduleRender`).
+            this.renderTemplateIntoContainer(template, index, elementContainer);
         };
         const range = this.hostRef.scroller.renderViewport(height, contentContainer, renderer);
-        this.ngZone.run(() => this.ceriousScrollMeasuredViewport.emit(range));
+        if (rendererInvocations === 0) {
+            // Viewport didn't change — skip the prune walk and the (potentially
+            // zone-entering) emit.
+            return range;
+        }
+        // Destroy views whose container the engine no longer renders. Without this,
+        // every container the engine recycles into its element pool leaves its
+        // embedded view attached to ApplicationRef forever — so the attached-view
+        // list (and every O(n) `detachView`) grows without bound and scrolling gets
+        // progressively slower. Mirrors the React/Vue wrappers, which drop rows that
+        // fall out of `getRenderedIndices()`.
+        this.pruneDetachedViews();
+        // Only re-enter the zone (a global tick) if someone is actually listening.
+        if (this.ceriousScrollMeasuredViewport.observed) {
+            this.ngZone.run(() => this.ceriousScrollMeasuredViewport.emit(range));
+        }
         return range;
     }
+    /** Tear down embedded views whose container is no longer part of the viewport. */
+    pruneDetachedViews() {
+        if (!this.hostRef || this.viewByContainer.size === 0)
+            return;
+        const scroller = this.hostRef.scroller;
+        const active = new Set();
+        for (const index of scroller.getRenderedIndices()) {
+            const el = scroller.getRenderedElement(index);
+            if (el)
+                active.add(el);
+        }
+        for (const [container, view] of this.viewByContainer) {
+            if (!active.has(container)) {
+                // Detach DOM but keep the view alive in the pool for future reuse.
+                // Destroying + recreating views per scroll step dominates frame time.
+                for (const node of view.rootNodes) {
+                    if (node.parentNode)
+                        node.parentNode.removeChild(node);
+                }
+                this.viewByContainer.delete(container);
+                this.freeViews.push(view);
+            }
+        }
+    }
+    /** Auto-render coalesced to at most once per animation frame. */
+    scheduleRender() {
+        if (this.scheduledRenderFrame != null)
+            return;
+        this.scheduledRenderFrame = requestAnimationFrame(() => {
+            this.scheduledRenderFrame = null;
+            // Run render() OUTSIDE Angular's zone. A full ApplicationRef.tick() on
+            // every scroll frame is the primary FPS bottleneck: even when no rows
+            // change (pure translation), ngZone.run() causes Angular to walk the
+            // entire component tree. Instead we call view.detectChanges() locally
+            // inside renderTemplateIntoContainer for each affected row. Zone entry is
+            // only needed when creating a brand-new embedded view (to zone-patch its
+            // event listeners) — recycled and pooled views were already created inside
+            // zone and their listeners remain zone-aware.
+            this.render();
+        });
+    }
+    /**
+     * Discard all cached row heights and re-measure the viewport.
+     *
+     * Call this only when the heights of rows you've *already rendered* may have
+     * changed without their indices changing — e.g. a global font/density change,
+     * or swapping every row to a different layout. This forces a synchronous
+     * re-measure (one `offsetHeight` read per visible row), so do NOT call it on
+     * routine edits: a single cell edit keeps its row's size, and the engine's
+     * ResizeObserver picks up any incidental resize on its own.
+     */
+    recalculate() {
+        if (!this.hostRef)
+            return null;
+        // Discard the cached heights, then re-render. The engine re-measures and
+        // re-caches the rendered rows during the pass and refreshes the scroll
+        // percentage, so an in-place height change (e.g. expand/collapse) is
+        // reflected in the total content height and scrollbar immediately.
+        this.hostRef.scroller.clearAllCaches();
+        return this.render();
+    }
+    /** Jump directly to an element index, then render. */
+    jumpToElement(index) {
+        if (!this.hostRef)
+            return null;
+        this.hostRef.scroller.jumpToElement(index);
+        return this.render();
+    }
+    /** Scroll to a percentage (0..100), then render. */
+    scrollToPercentage(percentage) {
+        if (!this.hostRef)
+            return null;
+        this.hostRef.scroller.handleScrollPercentage(percentage);
+        return this.render();
+    }
+    /** Reset to the top, then render. */
+    reset() {
+        if (!this.hostRef)
+            return null;
+        this.hostRef.scroller.reset();
+        return this.render();
+    }
     recreate() {
         this.viewportSub?.unsubscribe();
         this.viewportSub = null;
@@ -96,11 +235,16 @@ export class CeriousScrollDirective {
         const container = this.host.nativeElement;
         const total = coerceTotalElements(this.ceriousScrollTotalElements, this.ceriousScrollItems?.length ?? null);
         this.hostRef = this.cerious.createHost(container, total, this.ceriousScrollOptions, this.ngZone, () => {
+            // Coalesce scroll-driven renders to one per frame (the native scrollbar
+            // can fire many scroll events between paints).
             if (this.ceriousScrollAutoRender)
-                this.render();
+                this.scheduleRender();
         });
         this.viewportSub = this.hostRef.viewportChanges$.subscribe((detail) => {
-            this.ngZone.run(() => this.ceriousScrollViewportChange.emit(detail));
+            // Skip the global tick when nobody is bound to the output.
+            if (this.ceriousScrollViewportChange.observed) {
+                this.ngZone.run(() => this.ceriousScrollViewportChange.emit(detail));
+            }
         });
         this.ceriousScrollReady.emit(this.hostRef.scroller);
         if (this.ceriousScrollAutoRender) {
@@ -119,27 +263,96 @@ export class CeriousScrollDirective {
     renderTemplateIntoContainer(template, index, elementContainer) {
         const previous = this.viewByContainer.get(elementContainer);
         if (previous) {
-            this.appRef.detachView(previous);
-            previous.destroy();
-            this.viewByContainer.delete(elementContainer);
+            // Recycle: update the bound context and run local CD instead of
+            // destroying the embedded view and rebuilding the entire row tree.
+            const item = this.getItemForIndex(index);
+            previous.context.$implicit = item;
+            previous.context.item = item;
+            previous.context.index = index;
+            // The core engine wipes elementContainer.textContent when reusing it from
+            // its pool, orphaning the view's root nodes. Re-append them defensively.
+            if (previous.rootNodes.length && previous.rootNodes[0].parentNode !== elementContainer) {
+                for (const node of previous.rootNodes) {
+                    elementContainer.appendChild(node);
+                }
+            }
+            previous.detectChanges();
+            return;
+        }
+        // Try to reuse a pooled view from a container that scrolled out of viewport.
+        const pooled = this.freeViews.pop();
+        if (pooled) {
+            const item = this.getItemForIndex(index);
+            pooled.context.$implicit = item;
+            pooled.context.item = item;
+            pooled.context.index = index;
+            elementContainer.textContent = '';
+            for (const node of pooled.rootNodes) {
+                elementContainer.appendChild(node);
+            }
+            pooled.detectChanges();
+            this.viewByContainer.set(elementContainer, pooled);
+            return;
         }
-        // Clear prior DOM (CeriousScroll may recycle containers).
+        // No prior view for this container: create one.
+        // Enter the Angular zone so the new view's template event listeners
+        // ((click), (input), etc.) are zone-patched. This path runs at most
+        // once per visible row (after that, the view is recycled from the pool).
         elementContainer.textContent = '';
         const item = this.getItemForIndex(index);
-        const view = template.createEmbeddedView({ $implicit: item, item, index });
-        this.appRef.attachView(view);
-        view.detectChanges();
+        const view = this.ngZone.run(() => {
+            const v = template.createEmbeddedView({ $implicit: item, item, index });
+            this.appRef.attachView(v);
+            v.detectChanges();
+            return v;
+        });
         for (const node of view.rootNodes) {
             elementContainer.appendChild(node);
         }
         this.viewByContainer.set(elementContainer, view);
     }
+    /**
+     * Update the bound item/index on every currently-rendered row's embedded view
+     * and run change detection, without recreating the views. Used when the data
+     * reference changes but the visible indices (and their heights) do not, so row
+     * state (focus, selection, open dropdowns) survives the update.
+     */
+    /**
+     * Re-bind each currently rendered row's context (from the current items/getter)
+     * and run change detection on its embedded view. Use this after mutating row
+     * state in place (e.g. selection flags) or column-level state read by the row
+     * template, when row identity and visible indices have not changed. Cheap
+     * relative to `render()` — does not invoke the engine's measurement pass.
+     */
+    refreshRenderedContent() {
+        if (!this.hostRef)
+            return;
+        const scroller = this.hostRef.scroller;
+        for (const index of scroller.getRenderedIndices()) {
+            const container = scroller.getRenderedElement(index);
+            if (!container)
+                continue;
+            const view = this.viewByContainer.get(container);
+            if (!view)
+                continue;
+            const item = this.getItemForIndex(index);
+            view.context.$implicit = item;
+            view.context.item = item;
+            view.context.index = index;
+            view.detectChanges();
+        }
+    }
     destroyAllViews() {
         for (const view of this.viewByContainer.values()) {
             this.appRef.detachView(view);
             view.destroy();
         }
         this.viewByContainer.clear();
+        for (const view of this.freeViews) {
+            this.appRef.detachView(view);
+            view.destroy();
+        }
+        this.freeViews.length = 0;
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CeriousScrollDirective, deps: [{ token: i0.ElementRef }, { token: i0.ApplicationRef }, { token: i0.NgZone }, { token: i1.CeriousScrollService }], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: CeriousScrollDirective, isStandalone: true, selector: "[ceriousScroll]", inputs: { ceriousScrollTotalElements: "ceriousScrollTotalElements", ceriousScrollItems: "ceriousScrollItems", ceriousScrollGetItem: "ceriousScrollGetItem", ceriousScrollItemTemplate: "ceriousScrollItemTemplate", ceriousScrollOptions: "ceriousScrollOptions", ceriousScrollAutoRender: "ceriousScrollAutoRender" }, outputs: { ceriousScrollViewportChange: "ceriousScrollViewportChange", ceriousScrollMeasuredViewport: "ceriousScrollMeasuredViewport", ceriousScrollReady: "ceriousScrollReady" }, usesOnChanges: true, ngImport: i0 }); }
@@ -169,4 +382,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
             }], ceriousScrollReady: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cerious-scroll.directive.js","sourceRoot":"","sources":["../../../../projects/ngx-cerious-scroll/src/lib/cerious-scroll.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ApplicationRef,\n  Directive,\n  ElementRef,\n  EmbeddedViewRef,\n  EventEmitter,\n  Input,\n  NgZone,\n  OnChanges,\n  OnDestroy,\n  Output,\n  SimpleChanges,\n  TemplateRef,\n} from '@angular/core';\n\nimport {\n  type CeriousScrollOptions,\n  type ElementRenderer,\n  type MeasuredViewportRange,\n} from '@ceriousdevtech/cerious-scroll';\nimport { Subscription } from 'rxjs';\n\nimport type { CeriousViewportChangeDetail } from './cerious-scroll.types';\nimport type { CeriousScrollItemTemplateContext } from './cerious-scroll-item-template.directive';\nimport { type CeriousScrollHostRef, CeriousScrollService } from './cerious-scroll.service';\n\nfunction coerceTotalElements(explicitTotal: number | null | undefined, itemsLen: number | null | undefined): number {\n  const candidate = typeof explicitTotal === 'number' ? explicitTotal : typeof itemsLen === 'number' ? itemsLen : undefined;\n  if (candidate === undefined || Number.isNaN(candidate)) {\n    throw new Error('CeriousScrollDirective: provide `ceriousScrollTotalElements` or `ceriousScrollItems`.');\n  }\n  // CeriousScroll currently requires >= 1\n  return Math.max(1, candidate);\n}\n\n@Directive({\n  selector: '[ceriousScroll]',\n  standalone: true,\n})\nexport class CeriousScrollDirective<TItem = unknown> implements AfterViewInit, OnChanges, OnDestroy {\n  /** Total number of items. If omitted, derived from `ceriousScrollItems.length`. */\n  @Input() ceriousScrollTotalElements: number | null = null;\n\n  /** Optional items array (enables `let-item`). */\n  @Input() ceriousScrollItems: readonly TItem[] | null = null;\n\n  /** Optional getter for large datasets (alternative to passing full `items`). */\n  @Input() ceriousScrollGetItem: ((index: number) => TItem) | null = null;\n\n  /** Template used to render each row. */\n  @Input() ceriousScrollItemTemplate: TemplateRef<CeriousScrollItemTemplateContext<TItem>> | null = null;\n\n  /** Options passed to `new CeriousScroll(...)`. */\n  @Input() ceriousScrollOptions: CeriousScrollOptions = {};\n\n  /** Automatically call render after each scroll event. Default: true */\n  @Input() ceriousScrollAutoRender = true;\n\n  /** Emits `cerious-viewport-change` detail. */\n  @Output() ceriousScrollViewportChange = new EventEmitter<CeriousViewportChangeDetail>();\n\n  /** Emits the last measured viewport after each render pass. */\n  @Output() ceriousScrollMeasuredViewport = new EventEmitter<MeasuredViewportRange>();\n\n  /** Emits once the underlying `CeriousScroll` instance is ready. */\n  @Output() ceriousScrollReady = new EventEmitter<CeriousScrollHostRef['scroller']>();\n\n  private hostRef: CeriousScrollHostRef | null = null;\n  private viewportSub: Subscription | null = null;\n\n  private readonly viewByContainer = new Map<HTMLElement, EmbeddedViewRef<CeriousScrollItemTemplateContext<TItem>>>();\n\n  constructor(\n    private readonly host: ElementRef<HTMLElement>,\n    private readonly appRef: ApplicationRef,\n    private readonly ngZone: NgZone,\n    private readonly cerious: CeriousScrollService\n  ) {}\n\n  ngAfterViewInit(): void {\n    this.ensureInitialized();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (!this.hostRef) return;\n\n    if (changes['ceriousScrollItems'] || changes['ceriousScrollTotalElements']) {\n      const total = coerceTotalElements(this.ceriousScrollTotalElements, this.ceriousScrollItems?.length ?? null);\n      this.hostRef.scroller.totalElements = total;\n      this.hostRef.scroller.clearAllCaches();\n      if (this.ceriousScrollAutoRender) this.render();\n    }\n\n    if (changes['ceriousScrollOptions'] && !changes['ceriousScrollOptions'].firstChange) {\n      // Options are consumed primarily at construction time.\n      this.recreate();\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.viewportSub?.unsubscribe();\n    this.viewportSub = null;\n\n    this.destroyAllViews();\n\n    this.hostRef?.destroy();\n    this.hostRef = null;\n  }\n\n  /** Imperatively trigger a render pass (uses `ceriousScrollItemTemplate`). */\n  render(): MeasuredViewportRange | null {\n    if (!this.hostRef) return null;\n    const template = this.ceriousScrollItemTemplate;\n    if (!template) return null;\n\n    const hostContainer = this.host.nativeElement;\n    const height = hostContainer.clientHeight || hostContainer.offsetHeight;\n    const contentContainer = this.hostRef.contentElement;\n\n    const renderer: ElementRenderer = (index, elementContainer) => {\n      // Rendering must create Angular views inside the Angular zone.\n      this.ngZone.run(() => {\n        this.renderTemplateIntoContainer(template, index, elementContainer);\n      });\n    };\n\n    const range = this.hostRef.scroller.renderViewport(height, contentContainer, renderer);\n    this.ngZone.run(() => this.ceriousScrollMeasuredViewport.emit(range));\n    return range;\n  }\n\n  private recreate(): void {\n    this.viewportSub?.unsubscribe();\n    this.viewportSub = null;\n\n    this.destroyAllViews();\n\n    this.hostRef?.destroy();\n    this.hostRef = null;\n\n    this.ensureInitialized();\n  }\n\n  private ensureInitialized(): void {\n    if (this.hostRef) return;\n\n    const container = this.host.nativeElement;\n    const total = coerceTotalElements(this.ceriousScrollTotalElements, this.ceriousScrollItems?.length ?? null);\n\n    this.hostRef = this.cerious.createHost(container, total, this.ceriousScrollOptions, this.ngZone, () => {\n      if (this.ceriousScrollAutoRender) this.render();\n    });\n\n    this.viewportSub = this.hostRef.viewportChanges$.subscribe((detail: CeriousViewportChangeDetail) => {\n      this.ngZone.run(() => this.ceriousScrollViewportChange.emit(detail));\n    });\n\n    this.ceriousScrollReady.emit(this.hostRef.scroller);\n\n    if (this.ceriousScrollAutoRender) {\n      queueMicrotask(() => this.render());\n    }\n  }\n\n  private getItemForIndex(index: number): TItem {\n    const getter = this.ceriousScrollGetItem;\n    if (getter) return getter(index);\n\n    const items = this.ceriousScrollItems;\n    if (!items) return undefined as TItem;\n\n    return items[index];\n  }\n\n  private renderTemplateIntoContainer(\n    template: TemplateRef<CeriousScrollItemTemplateContext<TItem>>,\n    index: number,\n    elementContainer: HTMLElement\n  ): void {\n    const previous = this.viewByContainer.get(elementContainer);\n    if (previous) {\n      this.appRef.detachView(previous);\n      previous.destroy();\n      this.viewByContainer.delete(elementContainer);\n    }\n\n    // Clear prior DOM (CeriousScroll may recycle containers).\n    elementContainer.textContent = '';\n\n    const item = this.getItemForIndex(index);\n    const view = template.createEmbeddedView({ $implicit: item, item, index });\n    this.appRef.attachView(view);\n    view.detectChanges();\n\n    for (const node of view.rootNodes) {\n      elementContainer.appendChild(node);\n    }\n\n    this.viewByContainer.set(elementContainer, view);\n  }\n\n  private destroyAllViews(): void {\n    for (const view of this.viewByContainer.values()) {\n      this.appRef.detachView(view);\n      view.destroy();\n    }\n    this.viewByContainer.clear();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cerious-scroll.directive.js","sourceRoot":"","sources":["../../../../projects/ngx-cerious-scroll/src/lib/cerious-scroll.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ApplicationRef,\n  Directive,\n  ElementRef,\n  EmbeddedViewRef,\n  EventEmitter,\n  Input,\n  NgZone,\n  OnChanges,\n  OnDestroy,\n  Output,\n  SimpleChanges,\n  TemplateRef,\n} from '@angular/core';\n\nimport {\n  type CeriousScrollOptions,\n  type ElementRenderer,\n  type MeasuredViewportRange,\n} from '@ceriousdevtech/cerious-scroll';\nimport { Subscription } from 'rxjs';\n\nimport type { CeriousViewportChangeDetail } from './cerious-scroll.types';\nimport type { CeriousScrollItemTemplateContext } from './cerious-scroll-item-template.directive';\nimport { type CeriousScrollHostRef, CeriousScrollService } from './cerious-scroll.service';\n\nfunction coerceTotalElements(explicitTotal: number | null | undefined, itemsLen: number | null | undefined): number {\n  const candidate = typeof explicitTotal === 'number' ? explicitTotal : typeof itemsLen === 'number' ? itemsLen : undefined;\n  if (candidate === undefined || Number.isNaN(candidate)) {\n    throw new Error('CeriousScrollDirective: provide `ceriousScrollTotalElements` or `ceriousScrollItems`.');\n  }\n  // CeriousScroll currently requires >= 1\n  return Math.max(1, candidate);\n}\n\n@Directive({\n  selector: '[ceriousScroll]',\n  standalone: true,\n})\nexport class CeriousScrollDirective<TItem = unknown> implements AfterViewInit, OnChanges, OnDestroy {\n  /** Total number of items. If omitted, derived from `ceriousScrollItems.length`. */\n  @Input() ceriousScrollTotalElements: number | null = null;\n\n  /** Optional items array (enables `let-item`). */\n  @Input() ceriousScrollItems: readonly TItem[] | null = null;\n\n  /** Optional getter for large datasets (alternative to passing full `items`). */\n  @Input() ceriousScrollGetItem: ((index: number) => TItem) | null = null;\n\n  /** Template used to render each row. */\n  @Input() ceriousScrollItemTemplate: TemplateRef<CeriousScrollItemTemplateContext<TItem>> | null = null;\n\n  /** Options passed to `new CeriousScroll(...)`. */\n  @Input() ceriousScrollOptions: CeriousScrollOptions = {};\n\n  /** Automatically call render after each scroll event. Default: true */\n  @Input() ceriousScrollAutoRender = true;\n\n  /** Emits `cerious-viewport-change` detail. */\n  @Output() ceriousScrollViewportChange = new EventEmitter<CeriousViewportChangeDetail>();\n\n  /** Emits the last measured viewport after each render pass. */\n  @Output() ceriousScrollMeasuredViewport = new EventEmitter<MeasuredViewportRange>();\n\n  /** Emits once the underlying `CeriousScroll` instance is ready. */\n  @Output() ceriousScrollReady = new EventEmitter<CeriousScrollHostRef['scroller']>();\n\n  private hostRef: CeriousScrollHostRef | null = null;\n  private viewportSub: Subscription | null = null;\n  private scheduledRenderFrame: number | null = null;\n\n  private readonly viewByContainer = new Map<HTMLElement, EmbeddedViewRef<CeriousScrollItemTemplateContext<TItem>>>();\n  // Pool of views detached because their container left the viewport. Reusing\n  // them on subsequent renders avoids destroying + recreating the entire row\n  // component tree on fast scrolls (where the engine's element pool wipes\n  // textContent on reused containers, so view rootNodes get orphaned).\n  private readonly freeViews: EmbeddedViewRef<CeriousScrollItemTemplateContext<TItem>>[] = [];\n\n  constructor(\n    private readonly host: ElementRef<HTMLElement>,\n    private readonly appRef: ApplicationRef,\n    private readonly ngZone: NgZone,\n    private readonly cerious: CeriousScrollService\n  ) {}\n\n  ngAfterViewInit(): void {\n    this.ensureInitialized();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (!this.hostRef) return;\n\n    if (changes['ceriousScrollItems'] || changes['ceriousScrollTotalElements']) {\n      const total = coerceTotalElements(this.ceriousScrollTotalElements, this.ceriousScrollItems?.length ?? null);\n      const countChanged = this.hostRef.scroller.totalElements !== total;\n\n      if (countChanged) {\n        // The dataset size changed: the ViewportRenderer stores its own copy of\n        // totalElements (set by value at construction) so patching the engine's\n        // public property alone leaves the renderer's internal bound stale.  The\n        // renderer would then use the old count for its viewport-fill loop and\n        // bottom-boundary scan, producing phantom renders at out-of-bounds\n        // indices (undefined items → 0-height rows → the fill loop never\n        // satisfies its height condition → hundreds of renderer callbacks).\n        // Recreating the engine gives both the engine and the renderer a fresh,\n        // consistent count.  ensureInitialized() schedules the first render via\n        // queueMicrotask, which runs after the current CD cycle completes.\n        this.recreate();\n      } else if (this.ceriousScrollAutoRender) {\n        // Same count, new data reference (e.g. an immutable edit or a sort that\n        // happens to keep the same length). The engine reuses the DOM element it\n        // already rendered for each overlapping index without re-invoking the\n        // renderer, so update the content of every currently-visible row IN\n        // PLACE before calling render().  This preserves each row's embedded\n        // view (so a focused textbox keeps focus/caret) and does NOT discard\n        // cached heights. If a row's height actually changes the engine's\n        // ResizeObserver keeps the cache correct on its own; for a wholesale\n        // height change across all rows, call recalculate() instead.\n        this.refreshRenderedContent();\n        this.render();\n      }\n    }\n\n    if (changes['ceriousScrollOptions'] && !changes['ceriousScrollOptions'].firstChange) {\n      // Options are consumed primarily at construction time.\n      this.recreate();\n    }\n  }\n\n  ngOnDestroy(): void {\n    if (this.scheduledRenderFrame != null) {\n      cancelAnimationFrame(this.scheduledRenderFrame);\n      this.scheduledRenderFrame = null;\n    }\n\n    this.viewportSub?.unsubscribe();\n    this.viewportSub = null;\n\n    this.destroyAllViews();\n\n    this.hostRef?.destroy();\n    this.hostRef = null;\n  }\n\n  /** Imperatively trigger a render pass (uses `ceriousScrollItemTemplate`). */\n  render(): MeasuredViewportRange | null {\n    if (!this.hostRef) return null;\n    const template = this.ceriousScrollItemTemplate;\n    if (!template) return null;\n\n    const hostContainer = this.host.nativeElement;\n    const height = hostContainer.clientHeight || hostContainer.offsetHeight;\n    const contentContainer = this.hostRef.contentElement;\n\n    // Track whether the engine asked us to bind any row this pass. Pure scroll\n    // frames where the visible row set doesn't change still drive render() via\n    // the rAF coalescer — there's no point in walking the prune map or\n    // emitting the viewport range when nothing was touched.\n    let rendererInvocations = 0;\n    const renderer: ElementRenderer = (index, elementContainer) => {\n      rendererInvocations++;\n      // Render each row's embedded view with LOCAL change detection\n      // (`view.detectChanges()` inside `renderTemplateIntoContainer`) so the\n      // engine can measure its height during this pass. Do NOT wrap each row in\n      // its own `ngZone.run` — that fires a full `ApplicationRef` tick *per row*\n      // (O(newRows × visibleRows) work, janky drags). The single coalesced tick\n      // for the whole pass is handled by the caller (`scheduleRender`).\n      this.renderTemplateIntoContainer(template, index, elementContainer);\n    };\n\n    const range = this.hostRef.scroller.renderViewport(height, contentContainer, renderer);\n\n    if (rendererInvocations === 0) {\n      // Viewport didn't change — skip the prune walk and the (potentially\n      // zone-entering) emit.\n      return range;\n    }\n\n    // Destroy views whose container the engine no longer renders. Without this,\n    // every container the engine recycles into its element pool leaves its\n    // embedded view attached to ApplicationRef forever — so the attached-view\n    // list (and every O(n) `detachView`) grows without bound and scrolling gets\n    // progressively slower. Mirrors the React/Vue wrappers, which drop rows that\n    // fall out of `getRenderedIndices()`.\n    this.pruneDetachedViews();\n\n    // Only re-enter the zone (a global tick) if someone is actually listening.\n    if (this.ceriousScrollMeasuredViewport.observed) {\n      this.ngZone.run(() => this.ceriousScrollMeasuredViewport.emit(range));\n    }\n    return range;\n  }\n\n  /** Tear down embedded views whose container is no longer part of the viewport. */\n  private pruneDetachedViews(): void {\n    if (!this.hostRef || this.viewByContainer.size === 0) return;\n    const scroller = this.hostRef.scroller;\n    const active = new Set<HTMLElement>();\n    for (const index of scroller.getRenderedIndices()) {\n      const el = scroller.getRenderedElement(index);\n      if (el) active.add(el);\n    }\n    for (const [container, view] of this.viewByContainer) {\n      if (!active.has(container)) {\n        // Detach DOM but keep the view alive in the pool for future reuse.\n        // Destroying + recreating views per scroll step dominates frame time.\n        for (const node of view.rootNodes) {\n          if (node.parentNode) node.parentNode.removeChild(node);\n        }\n        this.viewByContainer.delete(container);\n        this.freeViews.push(view);\n      }\n    }\n  }\n\n  /** Auto-render coalesced to at most once per animation frame. */\n  private scheduleRender(): void {\n    if (this.scheduledRenderFrame != null) return;\n    this.scheduledRenderFrame = requestAnimationFrame(() => {\n      this.scheduledRenderFrame = null;\n      // Run render() OUTSIDE Angular's zone. A full ApplicationRef.tick() on\n      // every scroll frame is the primary FPS bottleneck: even when no rows\n      // change (pure translation), ngZone.run() causes Angular to walk the\n      // entire component tree. Instead we call view.detectChanges() locally\n      // inside renderTemplateIntoContainer for each affected row. Zone entry is\n      // only needed when creating a brand-new embedded view (to zone-patch its\n      // event listeners) — recycled and pooled views were already created inside\n      // zone and their listeners remain zone-aware.\n      this.render();\n    });\n  }\n\n  /**\n   * Discard all cached row heights and re-measure the viewport.\n   *\n   * Call this only when the heights of rows you've *already rendered* may have\n   * changed without their indices changing — e.g. a global font/density change,\n   * or swapping every row to a different layout. This forces a synchronous\n   * re-measure (one `offsetHeight` read per visible row), so do NOT call it on\n   * routine edits: a single cell edit keeps its row's size, and the engine's\n   * ResizeObserver picks up any incidental resize on its own.\n   */\n  recalculate(): MeasuredViewportRange | null {\n    if (!this.hostRef) return null;\n    // Discard the cached heights, then re-render. The engine re-measures and\n    // re-caches the rendered rows during the pass and refreshes the scroll\n    // percentage, so an in-place height change (e.g. expand/collapse) is\n    // reflected in the total content height and scrollbar immediately.\n    this.hostRef.scroller.clearAllCaches();\n    return this.render();\n  }\n\n  /** Jump directly to an element index, then render. */\n  jumpToElement(index: number): MeasuredViewportRange | null {\n    if (!this.hostRef) return null;\n    this.hostRef.scroller.jumpToElement(index);\n    return this.render();\n  }\n\n  /** Scroll to a percentage (0..100), then render. */\n  scrollToPercentage(percentage: number): MeasuredViewportRange | null {\n    if (!this.hostRef) return null;\n    this.hostRef.scroller.handleScrollPercentage(percentage);\n    return this.render();\n  }\n\n  /** Reset to the top, then render. */\n  reset(): MeasuredViewportRange | null {\n    if (!this.hostRef) return null;\n    this.hostRef.scroller.reset();\n    return this.render();\n  }\n\n  private recreate(): void {\n    this.viewportSub?.unsubscribe();\n    this.viewportSub = null;\n\n    this.destroyAllViews();\n\n    this.hostRef?.destroy();\n    this.hostRef = null;\n\n    this.ensureInitialized();\n  }\n\n  private ensureInitialized(): void {\n    if (this.hostRef) return;\n\n    const container = this.host.nativeElement;\n    const total = coerceTotalElements(this.ceriousScrollTotalElements, this.ceriousScrollItems?.length ?? null);\n\n    this.hostRef = this.cerious.createHost(container, total, this.ceriousScrollOptions, this.ngZone, () => {\n      // Coalesce scroll-driven renders to one per frame (the native scrollbar\n      // can fire many scroll events between paints).\n      if (this.ceriousScrollAutoRender) this.scheduleRender();\n    });\n\n    this.viewportSub = this.hostRef.viewportChanges$.subscribe((detail: CeriousViewportChangeDetail) => {\n      // Skip the global tick when nobody is bound to the output.\n      if (this.ceriousScrollViewportChange.observed) {\n        this.ngZone.run(() => this.ceriousScrollViewportChange.emit(detail));\n      }\n    });\n\n    this.ceriousScrollReady.emit(this.hostRef.scroller);\n\n    if (this.ceriousScrollAutoRender) {\n      queueMicrotask(() => this.render());\n    }\n  }\n\n  private getItemForIndex(index: number): TItem {\n    const getter = this.ceriousScrollGetItem;\n    if (getter) return getter(index);\n\n    const items = this.ceriousScrollItems;\n    if (!items) return undefined as TItem;\n\n    return items[index];\n  }\n\n  private renderTemplateIntoContainer(\n    template: TemplateRef<CeriousScrollItemTemplateContext<TItem>>,\n    index: number,\n    elementContainer: HTMLElement\n  ): void {\n    const previous = this.viewByContainer.get(elementContainer);\n    if (previous) {\n      // Recycle: update the bound context and run local CD instead of\n      // destroying the embedded view and rebuilding the entire row tree.\n      const item = this.getItemForIndex(index);\n      previous.context.$implicit = item;\n      previous.context.item = item;\n      previous.context.index = index;\n      // The core engine wipes elementContainer.textContent when reusing it from\n      // its pool, orphaning the view's root nodes. Re-append them defensively.\n      if (previous.rootNodes.length && previous.rootNodes[0].parentNode !== elementContainer) {\n        for (const node of previous.rootNodes) {\n          elementContainer.appendChild(node);\n        }\n      }\n      previous.detectChanges();\n      return;\n    }\n\n    // Try to reuse a pooled view from a container that scrolled out of viewport.\n    const pooled = this.freeViews.pop();\n    if (pooled) {\n      const item = this.getItemForIndex(index);\n      pooled.context.$implicit = item;\n      pooled.context.item = item;\n      pooled.context.index = index;\n      elementContainer.textContent = '';\n      for (const node of pooled.rootNodes) {\n        elementContainer.appendChild(node);\n      }\n      pooled.detectChanges();\n      this.viewByContainer.set(elementContainer, pooled);\n      return;\n    }\n\n    // No prior view for this container: create one.\n    // Enter the Angular zone so the new view's template event listeners\n    // ((click), (input), etc.) are zone-patched. This path runs at most\n    // once per visible row (after that, the view is recycled from the pool).\n    elementContainer.textContent = '';\n\n    const item = this.getItemForIndex(index);\n    const view = this.ngZone.run(() => {\n      const v = template.createEmbeddedView({ $implicit: item, item, index });\n      this.appRef.attachView(v);\n      v.detectChanges();\n      return v;\n    });\n\n    for (const node of view.rootNodes) {\n      elementContainer.appendChild(node);\n    }\n\n    this.viewByContainer.set(elementContainer, view);\n  }\n\n  /**\n   * Update the bound item/index on every currently-rendered row's embedded view\n   * and run change detection, without recreating the views. Used when the data\n   * reference changes but the visible indices (and their heights) do not, so row\n   * state (focus, selection, open dropdowns) survives the update.\n   */\n  /**\n   * Re-bind each currently rendered row's context (from the current items/getter)\n   * and run change detection on its embedded view. Use this after mutating row\n   * state in place (e.g. selection flags) or column-level state read by the row\n   * template, when row identity and visible indices have not changed. Cheap\n   * relative to `render()` — does not invoke the engine's measurement pass.\n   */\n  refreshRenderedContent(): void {\n    if (!this.hostRef) return;\n    const scroller = this.hostRef.scroller;\n\n    for (const index of scroller.getRenderedIndices()) {\n      const container = scroller.getRenderedElement(index);\n      if (!container) continue;\n\n      const view = this.viewByContainer.get(container);\n      if (!view) continue;\n\n      const item = this.getItemForIndex(index);\n      view.context.$implicit = item;\n      view.context.item = item;\n      view.context.index = index;\n      view.detectChanges();\n    }\n  }\n\n  private destroyAllViews(): void {\n    for (const view of this.viewByContainer.values()) {\n      this.appRef.detachView(view);\n      view.destroy();\n    }\n    this.viewByContainer.clear();\n    for (const view of this.freeViews) {\n      this.appRef.detachView(view);\n      view.destroy();\n    }\n    this.freeViews.length = 0;\n  }\n}\n"]}