@ceriousdevtech/ngx-cerious-scroll 1.0.7 → 1.1.0

package/README.md

@@ -233,6 +233,7 @@ Both the component and directive expose:
 |--------|-------------|
 | `render()` | Trigger a manual render pass. |
 | `recalculate()` | Discard all cached row heights and re-measure the viewport. |
+| `jumpToItem(index, screenOffset?)` | Jump to a card in Masonry mode. |
 
 **When to call `recalculate()`:** only when the heights of rows you've *already
 rendered* change without their indices changing — e.g. a global font/density
@@ -267,6 +268,26 @@ Usage in templates:
 </ng-template>
 ```
 
+## Masonry Layout
+
+Use `layout: 'masonry'` with the normal Angular item template. The directive
+supplies the core engine's DOM renderer internally:
+
+```ts
+readonly options: CeriousScrollOptions = {
+  layout: 'masonry',
+  masonry: {
+    getItemHeight: (_index, width) => width * 0.75 + 48,
+    targetColumnWidth: 280,
+    gap: 16,
+  },
+};
+```
+
+Supplying `getItemHeight` gives canonical, reproducible placement. Omit it for
+dynamic DOM-measured cards. Use `jumpToItem()` rather than `jumpToElement()` for
+card navigation.
+
 ## Table Layout
 
 Pass `[ceriousScrollOptions]="{ layout: 'table' }"` to render **real `<table>` / `<tr>` / `<td>` rows** with a frozen header and native column alignment — while keeping O(1) virtualization. The row template returns the row's `<td>` cells; `[ceriousScrollHeaderTemplate]` provides the `<thead>` row (it updates via change detection):

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

@@ -7,6 +7,17 @@ export class CeriousScrollComponent {
     constructor(ceriousScroll) {
         this.ceriousScroll = ceriousScroll;
     }
+    get scroller() { return this.ceriousScroll.scroller; }
+    render() { return this.ceriousScroll.render(); }
+    jumpToElement(index) { return this.ceriousScroll.jumpToElement(index); }
+    jumpToItem(index, screenOffset = 0) {
+        return this.ceriousScroll.jumpToItem(index, screenOffset);
+    }
+    scrollToPercentage(percentage) {
+        return this.ceriousScroll.scrollToPercentage(percentage);
+    }
+    reset() { return this.ceriousScroll.reset(); }
+    recalculate() { return this.ceriousScroll.recalculate(); }
     ngAfterContentInit() {
         if (this.ceriousScroll.ceriousScrollItemTemplate)
             return;
@@ -46,4 +57,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 type: ContentChild,
                 args: [CeriousScrollItemTemplateDirective]
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -10,6 +10,10 @@ function coerceTotalElements(explicitTotal, itemsLen) {
     return Math.max(1, candidate);
 }
 export class CeriousScrollDirective {
+    /** Underlying core engine instance, or null before initialization. */
+    get scroller() {
+        return this.hostRef?.scroller ?? null;
+    }
     constructor(host, appRef, ngZone, cerious) {
         this.host = host;
         this.appRef = appRef;
@@ -42,6 +46,10 @@ export class CeriousScrollDirective {
         this.hostRef = null;
         this.viewportSub = null;
         this.scheduledRenderFrame = null;
+        // Incremented by the core-owned Masonry renderer whenever it mounts a probe
+        // or visible card. Unlike row mode, those calls do not flow through the
+        // ElementRenderer passed to renderViewport().
+        this.masonryRendererEpoch = 0;
         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
@@ -60,19 +68,36 @@ export class CeriousScrollDirective {
             return;
         if (changes['ceriousScrollItems'] || changes['ceriousScrollTotalElements']) {
             const total = coerceTotalElements(this.ceriousScrollTotalElements, this.ceriousScrollItems?.length ?? null);
-            const countChanged = this.hostRef.scroller.totalElements !== total;
+            const masonryMode = this.ceriousScrollOptions.layout === 'masonry';
+            const currentCount = masonryMode
+                ? this.hostRef.scroller.itemCount
+                : this.hostRef.scroller.totalElements;
+            const countChanged = currentCount !== 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();
+                if (masonryMode) {
+                    // Masonry's renderer owns card-count-derived segment state. Recreate
+                    // it when the dataset size changes rather than updating segment count
+                    // through the row-oriented updateTotalElements API.
+                    this.recreate();
+                    return;
+                }
+                // Grow/shrink the dataset IN PLACE — no recreate. updateTotalElements
+                // propagates the new count to every subsystem, INCLUDING the
+                // ViewportRenderer's own copy of totalElements (it used to go stale,
+                // which is exactly why this recreated: the renderer kept the old count
+                // for its viewport-fill loop and bottom scan, producing phantom
+                // out-of-bounds renders). In place keeps the scroll position and an
+                // in-progress scrollbar drag alive, and a growing dataset keeps a stable
+                // bottom index (no bouncing tail). The track lengthens, so re-sync the
+                // thumb afterwards.
+                this.hostRef.scroller.updateTotalElements(total);
+                // A shrink can leave the position past the new end — clamp it.
+                if (this.hostRef.scroller.currentElement > total - 1) {
+                    this.hostRef.scroller.jumpToElement(total - 1);
+                }
+                if (this.ceriousScrollAutoRender)
+                    this.render();
+                this.hostRef.scroller.syncScrollbar();
             }
             else if (this.ceriousScrollAutoRender) {
                 // Same count, new data reference (e.g. an immutable edit or a sort that
@@ -131,8 +156,11 @@ export class CeriousScrollDirective {
             // for the whole pass is handled by the caller (`scheduleRender`).
             this.renderTemplateIntoContainer(template, index, elementContainer);
         };
+        const masonryMode = this.ceriousScrollOptions.layout === 'masonry';
+        const masonryEpochBefore = this.masonryRendererEpoch;
         const range = this.hostRef.scroller.renderViewport(height, contentContainer, renderer);
-        if (rendererInvocations === 0) {
+        const masonryInvocations = this.masonryRendererEpoch - masonryEpochBefore;
+        if (rendererInvocations === 0 && (!masonryMode || masonryInvocations === 0)) {
             // Viewport didn't change — skip the prune walk and the (potentially
             // zone-entering) emit.
             return range;
@@ -155,11 +183,19 @@ export class CeriousScrollDirective {
         if (!this.hostRef || this.viewByContainer.size === 0)
             return;
         const scroller = this.hostRef.scroller;
+        const masonryMode = this.ceriousScrollOptions.layout === 'masonry';
         const active = new Set();
-        for (const index of scroller.getRenderedIndices()) {
-            const el = scroller.getRenderedElement(index);
-            if (el)
-                active.add(el);
+        if (masonryMode) {
+            this.host.nativeElement
+                .querySelectorAll('[data-element-index]')
+                .forEach((el) => active.add(el));
+        }
+        else {
+            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)) {
@@ -224,6 +260,13 @@ export class CeriousScrollDirective {
         this.hostRef.scroller.jumpToElement(index);
         return this.render();
     }
+    /** Masonry mode only: jump directly to a card index, then render. */
+    jumpToItem(index, screenOffset = 0) {
+        if (!this.hostRef)
+            return null;
+        this.hostRef.scroller.jumpToItem(index, screenOffset);
+        return this.render();
+    }
     /** Scroll to a percentage (0..100), then render. */
     scrollToPercentage(percentage) {
         if (!this.hostRef)
@@ -253,7 +296,33 @@ export class CeriousScrollDirective {
         const total = coerceTotalElements(this.ceriousScrollTotalElements, this.ceriousScrollItems?.length ?? null);
         // Table mode: capture the engine-created <thead> so we can render the
         // declarative header template into it (and still run any user header hook).
-        let options = this.ceriousScrollOptions;
+        let options;
+        if (this.ceriousScrollOptions.layout === 'masonry') {
+            if (!this.ceriousScrollOptions.masonry) {
+                throw new Error("CeriousScrollDirective: layout 'masonry' requires `ceriousScrollOptions.masonry`.");
+            }
+            options = {
+                ...this.ceriousScrollOptions,
+                masonry: {
+                    ...this.ceriousScrollOptions.masonry,
+                    renderItem: (index, element) => {
+                        this.masonryRendererEpoch++;
+                        const template = this.ceriousScrollItemTemplate;
+                        if (!template)
+                            return;
+                        if (element.dataset['ceriousMasonry'] === 'probe') {
+                            this.renderProbe(template, index, element);
+                        }
+                        else {
+                            this.renderTemplateIntoContainer(template, index, element);
+                        }
+                    },
+                },
+            };
+        }
+        else {
+            options = this.ceriousScrollOptions;
+        }
         if (options.layout === 'table' && this.ceriousScrollHeaderTemplate) {
             const userHeader = options.table?.header;
             options = {
@@ -312,6 +381,25 @@ export class CeriousScrollDirective {
             return undefined;
         return items[index];
     }
+    renderProbe(template, index, container) {
+        const item = this.getItemForIndex(index);
+        const view = this.ngZone.runOutsideAngular(() => {
+            const v = template.createEmbeddedView({ $implicit: item, item, index });
+            v.detectChanges();
+            return v;
+        });
+        for (const node of view.rootNodes)
+            container.appendChild(node);
+        // Measurement probes are deliberately NOT attached to ApplicationRef:
+        // they are disposable, non-interactive markup and local detectChanges() is
+        // enough to populate their DOM synchronously. Attaching each probe inside
+        // Angular's zone turns dynamic scrolling into repeated application-wide
+        // change-detection work. The core reads offsetHeight immediately after this
+        // callback and clears the probe, so destroy the isolated view afterwards.
+        queueMicrotask(() => {
+            view.destroy();
+        });
+    }
     renderTemplateIntoContainer(template, index, elementContainer) {
         const previous = this.viewByContainer.get(elementContainer);
         if (previous) {
@@ -436,4 +524,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  /**\n   * Table mode only: template rendered into the engine's `<thead>` (a `<tr>` of\n   * `<th>`s). It lives in the same `<table>` as the rows, so columns align\n   * natively. Updates via change detection like the rows.\n   */\n  @Input() ceriousScrollHeaderTemplate: TemplateRef<unknown> | 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  // Table mode: the embedded view of the declarative header, rendered into the\n  // engine's <thead>.\n  private headerView: EmbeddedViewRef<unknown> | null = null;\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    this.headerView?.destroy();\n    this.headerView = null;\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    const template = this.ceriousScrollItemTemplate;\n    if (template) {\n      // Re-invoke the renderer for every currently-rendered row so pending\n      // Angular bindings flush into the DOM and the engine re-measures each\n      // row's new height into its cache. Without this, the engine's render\n      // pass skips the renderer for already-rendered indices and falls\n      // through to reading stale offsetHeight.\n      this.hostRef.scroller.refreshVisible((index, elementContainer) => {\n        this.renderTemplateIntoContainer(template, index, elementContainer);\n      });\n    }\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    // Table mode: capture the engine-created <thead> so we can render the\n    // declarative header template into it (and still run any user header hook).\n    let options = this.ceriousScrollOptions;\n    if (options.layout === 'table' && this.ceriousScrollHeaderTemplate) {\n      const userHeader = options.table?.header;\n      options = {\n        ...options,\n        table: {\n          ...options.table,\n          header: (thead: HTMLTableSectionElement) => {\n            userHeader?.(thead);\n            this.mountHeader(thead);\n          },\n        },\n      };\n    }\n\n    this.hostRef = this.cerious.createHost(container, total, options, 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  /**\n   * Render the declarative header template into the engine's <thead>. One\n   * embedded view, created inside the zone (so the header's event bindings are\n   * zone-patched), its root nodes appended directly into the <thead>.\n   */\n  private mountHeader(thead: HTMLElement): void {\n    if (!this.ceriousScrollHeaderTemplate) return;\n    this.headerView?.destroy();\n    const view = this.ngZone.run(() => {\n      const v = this.ceriousScrollHeaderTemplate!.createEmbeddedView({});\n      this.appRef.attachView(v);\n      v.detectChanges();\n      return v;\n    });\n    for (const node of view.rootNodes) thead.appendChild(node);\n    this.headerView = view;\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"]}
+//# 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 as CoreCeriousScrollOptions,\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 { CeriousScrollOptions } 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  /**\n   * Table mode only: template rendered into the engine's `<thead>` (a `<tr>` of\n   * `<th>`s). It lives in the same `<table>` as the rows, so columns align\n   * natively. Updates via change detection like the rows.\n   */\n  @Input() ceriousScrollHeaderTemplate: TemplateRef<unknown> | 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  // Incremented by the core-owned Masonry renderer whenever it mounts a probe\n  // or visible card. Unlike row mode, those calls do not flow through the\n  // ElementRenderer passed to renderViewport().\n  private masonryRendererEpoch = 0;\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  // Table mode: the embedded view of the declarative header, rendered into the\n  // engine's <thead>.\n  private headerView: EmbeddedViewRef<unknown> | null = null;\n\n  /** Underlying core engine instance, or null before initialization. */\n  get scroller(): CeriousScrollHostRef['scroller'] | null {\n    return this.hostRef?.scroller ?? null;\n  }\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 masonryMode = this.ceriousScrollOptions.layout === 'masonry';\n      const currentCount = masonryMode\n        ? this.hostRef.scroller.itemCount\n        : this.hostRef.scroller.totalElements;\n      const countChanged = currentCount !== total;\n\n      if (countChanged) {\n        if (masonryMode) {\n          // Masonry's renderer owns card-count-derived segment state. Recreate\n          // it when the dataset size changes rather than updating segment count\n          // through the row-oriented updateTotalElements API.\n          this.recreate();\n          return;\n        }\n        // Grow/shrink the dataset IN PLACE — no recreate. updateTotalElements\n        // propagates the new count to every subsystem, INCLUDING the\n        // ViewportRenderer's own copy of totalElements (it used to go stale,\n        // which is exactly why this recreated: the renderer kept the old count\n        // for its viewport-fill loop and bottom scan, producing phantom\n        // out-of-bounds renders). In place keeps the scroll position and an\n        // in-progress scrollbar drag alive, and a growing dataset keeps a stable\n        // bottom index (no bouncing tail). The track lengthens, so re-sync the\n        // thumb afterwards.\n        this.hostRef.scroller.updateTotalElements(total);\n        // A shrink can leave the position past the new end — clamp it.\n        if (this.hostRef.scroller.currentElement > total - 1) {\n          this.hostRef.scroller.jumpToElement(total - 1);\n        }\n        if (this.ceriousScrollAutoRender) this.render();\n        this.hostRef.scroller.syncScrollbar();\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    this.headerView?.destroy();\n    this.headerView = null;\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 masonryMode = this.ceriousScrollOptions.layout === 'masonry';\n    const masonryEpochBefore = this.masonryRendererEpoch;\n    const range = this.hostRef.scroller.renderViewport(height, contentContainer, renderer);\n    const masonryInvocations = this.masonryRendererEpoch - masonryEpochBefore;\n\n    if (rendererInvocations === 0 && (!masonryMode || masonryInvocations === 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 masonryMode = this.ceriousScrollOptions.layout === 'masonry';\n    const active = new Set<HTMLElement>();\n    if (masonryMode) {\n      this.host.nativeElement\n        .querySelectorAll<HTMLElement>('[data-element-index]')\n        .forEach((el) => active.add(el));\n    } else {\n      for (const index of scroller.getRenderedIndices()) {\n        const el = scroller.getRenderedElement(index);\n        if (el) active.add(el);\n      }\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    const template = this.ceriousScrollItemTemplate;\n    if (template) {\n      // Re-invoke the renderer for every currently-rendered row so pending\n      // Angular bindings flush into the DOM and the engine re-measures each\n      // row's new height into its cache. Without this, the engine's render\n      // pass skips the renderer for already-rendered indices and falls\n      // through to reading stale offsetHeight.\n      this.hostRef.scroller.refreshVisible((index, elementContainer) => {\n        this.renderTemplateIntoContainer(template, index, elementContainer);\n      });\n    }\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  /** Masonry mode only: jump directly to a card index, then render. */\n  jumpToItem(index: number, screenOffset = 0): MeasuredViewportRange | null {\n    if (!this.hostRef) return null;\n    this.hostRef.scroller.jumpToItem(index, screenOffset);\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    // Table mode: capture the engine-created <thead> so we can render the\n    // declarative header template into it (and still run any user header hook).\n    let options: CoreCeriousScrollOptions;\n    if (this.ceriousScrollOptions.layout === 'masonry') {\n      if (!this.ceriousScrollOptions.masonry) {\n        throw new Error(\"CeriousScrollDirective: layout 'masonry' requires `ceriousScrollOptions.masonry`.\");\n      }\n      options = {\n        ...this.ceriousScrollOptions,\n        masonry: {\n          ...this.ceriousScrollOptions.masonry,\n          renderItem: (index, element) => {\n            this.masonryRendererEpoch++;\n            const template = this.ceriousScrollItemTemplate;\n            if (!template) return;\n            if (element.dataset['ceriousMasonry'] === 'probe') {\n              this.renderProbe(template, index, element);\n            } else {\n              this.renderTemplateIntoContainer(template, index, element);\n            }\n          },\n        },\n      };\n    } else {\n      options = this.ceriousScrollOptions as CoreCeriousScrollOptions;\n    }\n    if (options.layout === 'table' && this.ceriousScrollHeaderTemplate) {\n      const userHeader = options.table?.header;\n      options = {\n        ...options,\n        table: {\n          ...options.table,\n          header: (thead: HTMLTableSectionElement) => {\n            userHeader?.(thead);\n            this.mountHeader(thead);\n          },\n        },\n      };\n    }\n\n    this.hostRef = this.cerious.createHost(container, total, options, 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  /**\n   * Render the declarative header template into the engine's <thead>. One\n   * embedded view, created inside the zone (so the header's event bindings are\n   * zone-patched), its root nodes appended directly into the <thead>.\n   */\n  private mountHeader(thead: HTMLElement): void {\n    if (!this.ceriousScrollHeaderTemplate) return;\n    this.headerView?.destroy();\n    const view = this.ngZone.run(() => {\n      const v = this.ceriousScrollHeaderTemplate!.createEmbeddedView({});\n      this.appRef.attachView(v);\n      v.detectChanges();\n      return v;\n    });\n    for (const node of view.rootNodes) thead.appendChild(node);\n    this.headerView = view;\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 renderProbe(\n    template: TemplateRef<CeriousScrollItemTemplateContext<TItem>>,\n    index: number,\n    container: HTMLElement\n  ): void {\n    const item = this.getItemForIndex(index);\n    const view = this.ngZone.runOutsideAngular(() => {\n      const v = template.createEmbeddedView({ $implicit: item, item, index });\n      v.detectChanges();\n      return v;\n    });\n    for (const node of view.rootNodes) container.appendChild(node);\n\n    // Measurement probes are deliberately NOT attached to ApplicationRef:\n    // they are disposable, non-interactive markup and local detectChanges() is\n    // enough to populate their DOM synchronously. Attaching each probe inside\n    // Angular's zone turns dynamic scrolling into repeated application-wide\n    // change-detection work. The core reads offsetHeight immediately after this\n    // callback and clears the probe, so destroy the isolated view afterwards.\n    queueMicrotask(() => {\n      view.destroy();\n    });\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"]}

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

@@ -27,7 +27,9 @@ function ensureContentElement(container) {
 }
 export class CeriousScrollService {
     createHost(container, totalElements, options, ngZone, onScrollHook) {
-        const contentElement = ensureContentElement(container);
+        const contentElement = options.layout === 'masonry'
+            ? container
+            : ensureContentElement(container);
         let scroller;
         ngZone.runOutsideAngular(() => {
             const userOnScroll = options?.onScroll;
@@ -46,10 +48,10 @@ export class CeriousScrollService {
             contentElement,
             viewportChanges$,
             destroy: () => {
-                // Remove rendered rows content first; keep container stable.
-                contentElement.textContent = '';
                 scroller.detachScrollbar(container);
                 scroller.dispose();
+                // Remove rendered content after the engine has detached its own DOM.
+                contentElement.textContent = '';
             },
         };
     }
@@ -62,4 +64,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     providedIn: 'root'
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2VyaW91cy1zY3JvbGwudHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtY2VyaW91cy1zY3JvbGwvc3JjL2xpYi9jZXJpb3VzLXNjcm9sbC50eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBTY3JvbGxSZXN1bHQgfSBmcm9tICdAY2VyaW91c2RldnRlY2gvY2VyaW91cy1zY3JvbGwnO1xuXG4vKipcbiAqIERldGFpbCBwYXlsb2FkIGZvciB0aGUgYGNlcmlvdXMtdmlld3BvcnQtY2hhbmdlYCBDdXN0b21FdmVudCBkaXNwYXRjaGVkIGJ5IGBAY2VyaW91c2RldnRlY2gvY2VyaW91cy1zY3JvbGxgLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIENlcmlvdXNWaWV3cG9ydENoYW5nZURldGFpbCB7XG4gIC8qKiBTY3JvbGwgcGVyY2VudGFnZSBmcm9tIDAuLjEwMCAqL1xuICBwZXJjZW50YWdlOiBudW1iZXI7XG5cbiAgLyoqIEN1cnJlbnQgdG9wLW1vc3QgZWxlbWVudCBpbmRleCAoYXMgdHJhY2tlZCBieSBDZXJpb3VzU2Nyb2xsKSAqL1xuICBjdXJyZW50RWxlbWVudDogbnVtYmVyO1xuXG4gIC8qKiBQaXhlbCBvZmZzZXQgd2l0aGluIGBjdXJyZW50RWxlbWVudGAgKi9cbiAgc2Nyb2xsT2Zmc2V0OiBudW1iZXI7XG5cbiAgLyoqIFNjcm9sbCBvcGVyYXRpb24gcmVzdWx0IChlbGVtZW50ICsgb2Zmc2V0KSAqL1xuICByZXN1bHQ6IFNjcm9sbFJlc3VsdDtcbn1cblxuZXhwb3J0IHR5cGUgQ2VyaW91c1ZpZXdwb3J0Q2hhbmdlRXZlbnQgPSBDdXN0b21FdmVudDxDZXJpb3VzVmlld3BvcnRDaGFuZ2VEZXRhaWw+O1xuXG4vKipcbiAqIFBheWxvYWQgdXNlZCBieSBDZXJpb3VzU2Nyb2xsJ3MgbmF0aXZlIHNjcm9sbGJhciBpbnRlZ3JhdGlvbi5cbiAqIChEaXNwYXRjaGVkIGFzIGB2aWV3cG9ydC1jaGFuZ2VgIGluIHRoZSB1cHN0cmVhbSBwYWNrYWdlLilcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBDZXJpb3VzTmF0aXZlU2Nyb2xsYmFyVmlld3BvcnRDaGFuZ2VEZXRhaWwge1xuICBwZXJjZW50YWdlOiBudW1iZXI7XG4gIGVsZW1lbnQ6IG51bWJlcjtcbiAgc2Nyb2xsT2Zmc2V0OiBudW1iZXI7XG59XG5cbmV4cG9ydCB0eXBlIENlcmlvdXNOYXRpdmVTY3JvbGxiYXJWaWV3cG9ydENoYW5nZUV2ZW50ID0gQ3VzdG9tRXZlbnQ8Q2VyaW91c05hdGl2ZVNjcm9sbGJhclZpZXdwb3J0Q2hhbmdlRGV0YWlsPjtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/public-api.mjs

@@ -9,4 +9,4 @@ export * from './lib/cerious-scroll.component';
 export * from './lib/cerious-scroll.service';
 // Re-export upstream types/classes for convenience
 export * from '@ceriousdevtech/cerious-scroll';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25neC1jZXJpb3VzLXNjcm9sbC9zcmMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLDhDQUE4QyxDQUFDO0FBQzdELGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLDhCQUE4QixDQUFDO0FBRTdDLG1EQUFtRDtBQUNuRCxjQUFjLGdDQUFnQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBuZ3gtY2VyaW91cy1zY3JvbGxcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jZXJpb3VzLXNjcm9sbC50eXBlcyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jZXJpb3VzLXNjcm9sbC5vYnNlcnZhYmxlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NlcmlvdXMtc2Nyb2xsLWl0ZW0tdGVtcGxhdGUuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NlcmlvdXMtc2Nyb2xsLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jZXJpb3VzLXNjcm9sbC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY2VyaW91cy1zY3JvbGwuc2VydmljZSc7XG5cbi8vIFJlLWV4cG9ydCB1cHN0cmVhbSB0eXBlcy9jbGFzc2VzIGZvciBjb252ZW5pZW5jZVxuZXhwb3J0ICogZnJvbSAnQGNlcmlvdXNkZXZ0ZWNoL2NlcmlvdXMtc2Nyb2xsJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25neC1jZXJpb3VzLXNjcm9sbC9zcmMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsNEJBQTRCLENBQUM7QUFFM0MsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLDhDQUE4QyxDQUFDO0FBQzdELGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLDhCQUE4QixDQUFDO0FBRTdDLG1EQUFtRDtBQUNuRCxjQUFjLGdDQUFnQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBuZ3gtY2VyaW91cy1zY3JvbGxcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jZXJpb3VzLXNjcm9sbC50eXBlcyc7XG5leHBvcnQgdHlwZSB7IENlcmlvdXNTY3JvbGxPcHRpb25zIH0gZnJvbSAnLi9saWIvY2VyaW91cy1zY3JvbGwudHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY2VyaW91cy1zY3JvbGwub2JzZXJ2YWJsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jZXJpb3VzLXNjcm9sbC1pdGVtLXRlbXBsYXRlLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jZXJpb3VzLXNjcm9sbC5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY2VyaW91cy1zY3JvbGwuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NlcmlvdXMtc2Nyb2xsLnNlcnZpY2UnO1xuXG4vLyBSZS1leHBvcnQgdXBzdHJlYW0gdHlwZXMvY2xhc3NlcyBmb3IgY29udmVuaWVuY2VcbmV4cG9ydCAqIGZyb20gJ0BjZXJpb3VzZGV2dGVjaC9jZXJpb3VzLXNjcm9sbCc7XG4iXX0=

package/fesm2022/ceriousdevtech-ngx-cerious-scroll.mjs

@@ -77,7 +77,9 @@ function ensureContentElement(container) {
 }
 class CeriousScrollService {
     createHost(container, totalElements, options, ngZone, onScrollHook) {
-        const contentElement = ensureContentElement(container);
+        const contentElement = options.layout === 'masonry'
+            ? container
+            : ensureContentElement(container);
         let scroller;
         ngZone.runOutsideAngular(() => {
             const userOnScroll = options?.onScroll;
@@ -96,10 +98,10 @@ class CeriousScrollService {
             contentElement,
             viewportChanges$,
             destroy: () => {
-                // Remove rendered rows content first; keep container stable.
-                contentElement.textContent = '';
                 scroller.detachScrollbar(container);
                 scroller.dispose();
+                // Remove rendered content after the engine has detached its own DOM.
+                contentElement.textContent = '';
             },
         };
     }
@@ -122,6 +124,10 @@ function coerceTotalElements(explicitTotal, itemsLen) {
     return Math.max(1, candidate);
 }
 class CeriousScrollDirective {
+    /** Underlying core engine instance, or null before initialization. */
+    get scroller() {
+        return this.hostRef?.scroller ?? null;
+    }
     constructor(host, appRef, ngZone, cerious) {
         this.host = host;
         this.appRef = appRef;
@@ -154,6 +160,10 @@ class CeriousScrollDirective {
         this.hostRef = null;
         this.viewportSub = null;
         this.scheduledRenderFrame = null;
+        // Incremented by the core-owned Masonry renderer whenever it mounts a probe
+        // or visible card. Unlike row mode, those calls do not flow through the
+        // ElementRenderer passed to renderViewport().
+        this.masonryRendererEpoch = 0;
         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
@@ -172,19 +182,36 @@ class CeriousScrollDirective {
             return;
         if (changes['ceriousScrollItems'] || changes['ceriousScrollTotalElements']) {
             const total = coerceTotalElements(this.ceriousScrollTotalElements, this.ceriousScrollItems?.length ?? null);
-            const countChanged = this.hostRef.scroller.totalElements !== total;
+            const masonryMode = this.ceriousScrollOptions.layout === 'masonry';
+            const currentCount = masonryMode
+                ? this.hostRef.scroller.itemCount
+                : this.hostRef.scroller.totalElements;
+            const countChanged = currentCount !== 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();
+                if (masonryMode) {
+                    // Masonry's renderer owns card-count-derived segment state. Recreate
+                    // it when the dataset size changes rather than updating segment count
+                    // through the row-oriented updateTotalElements API.
+                    this.recreate();
+                    return;
+                }
+                // Grow/shrink the dataset IN PLACE — no recreate. updateTotalElements
+                // propagates the new count to every subsystem, INCLUDING the
+                // ViewportRenderer's own copy of totalElements (it used to go stale,
+                // which is exactly why this recreated: the renderer kept the old count
+                // for its viewport-fill loop and bottom scan, producing phantom
+                // out-of-bounds renders). In place keeps the scroll position and an
+                // in-progress scrollbar drag alive, and a growing dataset keeps a stable
+                // bottom index (no bouncing tail). The track lengthens, so re-sync the
+                // thumb afterwards.
+                this.hostRef.scroller.updateTotalElements(total);
+                // A shrink can leave the position past the new end — clamp it.
+                if (this.hostRef.scroller.currentElement > total - 1) {
+                    this.hostRef.scroller.jumpToElement(total - 1);
+                }
+                if (this.ceriousScrollAutoRender)
+                    this.render();
+                this.hostRef.scroller.syncScrollbar();
             }
             else if (this.ceriousScrollAutoRender) {
                 // Same count, new data reference (e.g. an immutable edit or a sort that
@@ -243,8 +270,11 @@ class CeriousScrollDirective {
             // for the whole pass is handled by the caller (`scheduleRender`).
             this.renderTemplateIntoContainer(template, index, elementContainer);
         };
+        const masonryMode = this.ceriousScrollOptions.layout === 'masonry';
+        const masonryEpochBefore = this.masonryRendererEpoch;
         const range = this.hostRef.scroller.renderViewport(height, contentContainer, renderer);
-        if (rendererInvocations === 0) {
+        const masonryInvocations = this.masonryRendererEpoch - masonryEpochBefore;
+        if (rendererInvocations === 0 && (!masonryMode || masonryInvocations === 0)) {
             // Viewport didn't change — skip the prune walk and the (potentially
             // zone-entering) emit.
             return range;
@@ -267,11 +297,19 @@ class CeriousScrollDirective {
         if (!this.hostRef || this.viewByContainer.size === 0)
             return;
         const scroller = this.hostRef.scroller;
+        const masonryMode = this.ceriousScrollOptions.layout === 'masonry';
         const active = new Set();
-        for (const index of scroller.getRenderedIndices()) {
-            const el = scroller.getRenderedElement(index);
-            if (el)
-                active.add(el);
+        if (masonryMode) {
+            this.host.nativeElement
+                .querySelectorAll('[data-element-index]')
+                .forEach((el) => active.add(el));
+        }
+        else {
+            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)) {
@@ -336,6 +374,13 @@ class CeriousScrollDirective {
         this.hostRef.scroller.jumpToElement(index);
         return this.render();
     }
+    /** Masonry mode only: jump directly to a card index, then render. */
+    jumpToItem(index, screenOffset = 0) {
+        if (!this.hostRef)
+            return null;
+        this.hostRef.scroller.jumpToItem(index, screenOffset);
+        return this.render();
+    }
     /** Scroll to a percentage (0..100), then render. */
     scrollToPercentage(percentage) {
         if (!this.hostRef)
@@ -365,7 +410,33 @@ class CeriousScrollDirective {
         const total = coerceTotalElements(this.ceriousScrollTotalElements, this.ceriousScrollItems?.length ?? null);
         // Table mode: capture the engine-created <thead> so we can render the
         // declarative header template into it (and still run any user header hook).
-        let options = this.ceriousScrollOptions;
+        let options;
+        if (this.ceriousScrollOptions.layout === 'masonry') {
+            if (!this.ceriousScrollOptions.masonry) {
+                throw new Error("CeriousScrollDirective: layout 'masonry' requires `ceriousScrollOptions.masonry`.");
+            }
+            options = {
+                ...this.ceriousScrollOptions,
+                masonry: {
+                    ...this.ceriousScrollOptions.masonry,
+                    renderItem: (index, element) => {
+                        this.masonryRendererEpoch++;
+                        const template = this.ceriousScrollItemTemplate;
+                        if (!template)
+                            return;
+                        if (element.dataset['ceriousMasonry'] === 'probe') {
+                            this.renderProbe(template, index, element);
+                        }
+                        else {
+                            this.renderTemplateIntoContainer(template, index, element);
+                        }
+                    },
+                },
+            };
+        }
+        else {
+            options = this.ceriousScrollOptions;
+        }
         if (options.layout === 'table' && this.ceriousScrollHeaderTemplate) {
             const userHeader = options.table?.header;
             options = {
@@ -424,6 +495,25 @@ class CeriousScrollDirective {
             return undefined;
         return items[index];
     }
+    renderProbe(template, index, container) {
+        const item = this.getItemForIndex(index);
+        const view = this.ngZone.runOutsideAngular(() => {
+            const v = template.createEmbeddedView({ $implicit: item, item, index });
+            v.detectChanges();
+            return v;
+        });
+        for (const node of view.rootNodes)
+            container.appendChild(node);
+        // Measurement probes are deliberately NOT attached to ApplicationRef:
+        // they are disposable, non-interactive markup and local detectChanges() is
+        // enough to populate their DOM synchronously. Attaching each probe inside
+        // Angular's zone turns dynamic scrolling into repeated application-wide
+        // change-detection work. The core reads offsetHeight immediately after this
+        // callback and clears the probe, so destroy the isolated view afterwards.
+        queueMicrotask(() => {
+            view.destroy();
+        });
+    }
     renderTemplateIntoContainer(template, index, elementContainer) {
         const previous = this.viewByContainer.get(elementContainer);
         if (previous) {
@@ -553,6 +643,17 @@ class CeriousScrollComponent {
     constructor(ceriousScroll) {
         this.ceriousScroll = ceriousScroll;
     }
+    get scroller() { return this.ceriousScroll.scroller; }
+    render() { return this.ceriousScroll.render(); }
+    jumpToElement(index) { return this.ceriousScroll.jumpToElement(index); }
+    jumpToItem(index, screenOffset = 0) {
+        return this.ceriousScroll.jumpToItem(index, screenOffset);
+    }
+    scrollToPercentage(percentage) {
+        return this.ceriousScroll.scrollToPercentage(percentage);
+    }
+    reset() { return this.ceriousScroll.reset(); }
+    recalculate() { return this.ceriousScroll.recalculate(); }
     ngAfterContentInit() {
         if (this.ceriousScroll.ceriousScrollItemTemplate)
             return;

package/fesm2022/ceriousdevtech-ngx-cerious-scroll.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ceriousdevtech-ngx-cerious-scroll.mjs","sources":["../../../projects/ngx-cerious-scroll/src/lib/cerious-scroll.observable.ts","../../../projects/ngx-cerious-scroll/src/lib/cerious-scroll-item-template.directive.ts","../../../projects/ngx-cerious-scroll/src/lib/cerious-scroll.service.ts","../../../projects/ngx-cerious-scroll/src/lib/cerious-scroll.directive.ts","../../../projects/ngx-cerious-scroll/src/lib/cerious-scroll.component.ts","../../../projects/ngx-cerious-scroll/src/public-api.ts","../../../projects/ngx-cerious-scroll/src/ceriousdevtech-ngx-cerious-scroll.ts"],"sourcesContent":["import { fromEvent, map, merge, Observable, share } from 'rxjs';\n\nimport type { ScrollResult } from '@ceriousdevtech/cerious-scroll';\n\nimport {\n  CeriousNativeScrollbarViewportChangeEvent,\n  CeriousViewportChangeDetail,\n  CeriousViewportChangeEvent,\n} from './cerious-scroll.types';\n\n/**\n * Observable wrapper around the `cerious-viewport-change` CustomEvent emitted by `@ceriousdevtech/cerious-scroll`.\n *\n * Note: this event is emitted when wheel/touch/keyboard handlers are enabled (defaults are enabled).\n */\nexport function ceriousViewportChange$(container: HTMLElement): Observable<CeriousViewportChangeDetail> {\n  const fromCerious = fromEvent<CeriousViewportChangeEvent>(container, 'cerious-viewport-change').pipe(\n    map((evt) => evt.detail)\n  );\n\n  // Native scrollbar integration in the upstream package dispatches `viewport-change`.\n  // Normalize it into the same shape as `cerious-viewport-change`.\n  const fromScrollbar = fromEvent<CeriousNativeScrollbarViewportChangeEvent>(container, 'viewport-change').pipe(\n    map((evt) => {\n      const result: ScrollResult = { element: evt.detail.element, offset: evt.detail.scrollOffset };\n      return {\n        percentage: evt.detail.percentage,\n        currentElement: evt.detail.element,\n        scrollOffset: evt.detail.scrollOffset,\n        result,\n      } satisfies CeriousViewportChangeDetail;\n    })\n  );\n\n  return merge(fromCerious, fromScrollbar).pipe(share());\n}\n","import { Directive, TemplateRef } from '@angular/core';\n\nexport interface CeriousScrollItemTemplateContext<TItem = unknown> {\n  /** The item for this row (also available as `$implicit`). */\n  $implicit: TItem;\n  /** Row index. */\n  index: number;\n  /** Same as `$implicit` for named access. */\n  item: TItem;\n}\n\n/**\n * Marks an `ng-template` as the row template for `CeriousScrollComponent`.\n *\n * Usage:\n * ```html\n * <cerious-scroll [items]=\"items\">\n *   <ng-template ceriousScrollItem let-item let-index=\"index\">\n *     {{ index }} - {{ item.name }}\n *   </ng-template>\n * </cerious-scroll>\n * ```\n */\n@Directive({\n  selector: 'ng-template[ceriousScrollItem]',\n  standalone: true,\n})\nexport class CeriousScrollItemTemplateDirective<TItem = unknown> {\n  constructor(public readonly templateRef: TemplateRef<CeriousScrollItemTemplateContext<TItem>>) {}\n}\n","import { Injectable, NgZone } from '@angular/core';\n\nimport { CeriousScroll, type CeriousScrollOptions } from '@ceriousdevtech/cerious-scroll';\nimport { Observable } from 'rxjs';\n\nimport { ceriousViewportChange$ } from './cerious-scroll.observable';\nimport type { CeriousViewportChangeDetail } from './cerious-scroll.types';\n\nconst CONTENT_ATTR = 'data-cerious-scroll-content';\n\nfunction ensureContentElement(container: HTMLElement): HTMLElement {\n  const existing = container.querySelector<HTMLElement>(`[${CONTENT_ATTR}]`);\n  if (existing) return existing;\n\n  const el = document.createElement('div');\n  el.setAttribute(CONTENT_ATTR, '');\n  el.style.position = 'relative';\n  el.style.width = '100%';\n  el.style.height = '100%';\n  // overflow-y: clip + overflow-x: auto: clip vertical row overflow (engine\n  // owns vertical) and let the inner element own the native horizontal\n  // scrollbar when consumer content (e.g. wide spreadsheet) overflows.\n  // Horizontal scroll must NOT move to the outer container or the cerious\n  // sibling-driver vertical scrollbar (`position: absolute; right: 0` inside\n  // the outer) would translate with the content. The engine reads its\n  // viewport height from this element so the bottom row stays clear of the\n  // h-scrollbar gutter when it appears.\n  el.style.overflowY = 'clip';\n  el.style.overflowX = 'auto';\n  container.appendChild(el);\n  return el;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class CeriousScrollService {\n  createHost(\n    container: HTMLElement,\n    totalElements: number,\n    options: CeriousScrollOptions,\n    ngZone: NgZone,\n    onScrollHook?: () => void\n  ): CeriousScrollHostRef {\n    const contentElement = ensureContentElement(container);\n    let scroller!: CeriousScroll;\n\n    ngZone.runOutsideAngular(() => {\n      const userOnScroll = options?.onScroll;\n      const mergedOptions: CeriousScrollOptions = {\n        ...options,\n        onScroll: () => {\n          userOnScroll?.();\n          onScrollHook?.();\n        },\n      };\n\n      scroller = new CeriousScroll(container, totalElements, mergedOptions);\n    });\n\n    const viewportChanges$ = ceriousViewportChange$(container);\n\n    return {\n      scroller,\n      contentElement,\n      viewportChanges$,\n      destroy: () => {\n        // Remove rendered rows content first; keep container stable.\n        contentElement.textContent = '';\n        scroller.detachScrollbar(container);\n        scroller.dispose();\n      },\n    };\n  }\n}\n\nexport interface CeriousScrollHostRef {\n  readonly scroller: CeriousScroll;\n  /** Dedicated element used for row rendering (prevents scrollbar DOM from being cleared). */\n  readonly contentElement: HTMLElement;\n  readonly viewportChanges$: Observable<CeriousViewportChangeDetail>;\n  destroy(): void;\n}\n","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  /**\n   * Table mode only: template rendered into the engine's `<thead>` (a `<tr>` of\n   * `<th>`s). It lives in the same `<table>` as the rows, so columns align\n   * natively. Updates via change detection like the rows.\n   */\n  @Input() ceriousScrollHeaderTemplate: TemplateRef<unknown> | 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  // Table mode: the embedded view of the declarative header, rendered into the\n  // engine's <thead>.\n  private headerView: EmbeddedViewRef<unknown> | null = null;\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    this.headerView?.destroy();\n    this.headerView = null;\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    const template = this.ceriousScrollItemTemplate;\n    if (template) {\n      // Re-invoke the renderer for every currently-rendered row so pending\n      // Angular bindings flush into the DOM and the engine re-measures each\n      // row's new height into its cache. Without this, the engine's render\n      // pass skips the renderer for already-rendered indices and falls\n      // through to reading stale offsetHeight.\n      this.hostRef.scroller.refreshVisible((index, elementContainer) => {\n        this.renderTemplateIntoContainer(template, index, elementContainer);\n      });\n    }\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    // Table mode: capture the engine-created <thead> so we can render the\n    // declarative header template into it (and still run any user header hook).\n    let options = this.ceriousScrollOptions;\n    if (options.layout === 'table' && this.ceriousScrollHeaderTemplate) {\n      const userHeader = options.table?.header;\n      options = {\n        ...options,\n        table: {\n          ...options.table,\n          header: (thead: HTMLTableSectionElement) => {\n            userHeader?.(thead);\n            this.mountHeader(thead);\n          },\n        },\n      };\n    }\n\n    this.hostRef = this.cerious.createHost(container, total, options, 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  /**\n   * Render the declarative header template into the engine's <thead>. One\n   * embedded view, created inside the zone (so the header's event bindings are\n   * zone-patched), its root nodes appended directly into the <thead>.\n   */\n  private mountHeader(thead: HTMLElement): void {\n    if (!this.ceriousScrollHeaderTemplate) return;\n    this.headerView?.destroy();\n    const view = this.ngZone.run(() => {\n      const v = this.ceriousScrollHeaderTemplate!.createEmbeddedView({});\n      this.appRef.attachView(v);\n      v.detectChanges();\n      return v;\n    });\n    for (const node of view.rootNodes) thead.appendChild(node);\n    this.headerView = view;\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","import {\n  AfterContentInit,\n  ChangeDetectionStrategy,\n  Component,\n  ContentChild,\n  TemplateRef,\n} from '@angular/core';\n\nimport { CeriousScrollDirective } from './cerious-scroll.directive';\nimport {\n  CeriousScrollItemTemplateDirective,\n  type CeriousScrollItemTemplateContext,\n} from './cerious-scroll-item-template.directive';\n\n@Component({\n  selector: 'cerious-scroll',\n  standalone: true,\n  imports: [],\n  hostDirectives: [\n    {\n      directive: CeriousScrollDirective,\n      inputs: [\n        'ceriousScrollTotalElements: totalElements',\n        'ceriousScrollItems: items',\n        'ceriousScrollGetItem: getItem',\n        'ceriousScrollItemTemplate: itemTemplate',\n        'ceriousScrollHeaderTemplate: headerTemplate',\n        'ceriousScrollOptions: options',\n        'ceriousScrollAutoRender: autoRender',\n      ],\n      outputs: [\n        'ceriousScrollViewportChange: viewportChange',\n        'ceriousScrollMeasuredViewport: measuredViewport',\n        'ceriousScrollReady: scrollerReady',\n      ],\n    },\n  ],\n  template: `<ng-content />`,\n  styles: `\n    :host {\n      display: block;\n    }\n  `,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class CeriousScrollComponent<TItem = unknown> implements AfterContentInit {\n  /** Optional convenience template marker: <ng-template ceriousScrollItem let-item let-index=\"index\">...</ng-template> */\n  @ContentChild(CeriousScrollItemTemplateDirective)\n  private readonly projectedItemTemplate?: CeriousScrollItemTemplateDirective<TItem>;\n\n  constructor(private readonly ceriousScroll: CeriousScrollDirective<TItem>) {}\n\n  ngAfterContentInit(): void {\n    if (this.ceriousScroll.ceriousScrollItemTemplate) return;\n    if (!this.projectedItemTemplate) return;\n\n    this.ceriousScroll.ceriousScrollItemTemplate =\n      this.projectedItemTemplate.templateRef as TemplateRef<CeriousScrollItemTemplateContext<TItem>>;\n\n    if (this.ceriousScroll.ceriousScrollAutoRender) {\n      queueMicrotask(() => this.ceriousScroll.render());\n    }\n  }\n}\n","/*\n * Public API Surface of ngx-cerious-scroll\n */\n\nexport * from './lib/cerious-scroll.types';\nexport * from './lib/cerious-scroll.observable';\nexport * from './lib/cerious-scroll-item-template.directive';\nexport * from './lib/cerious-scroll.directive';\nexport * from './lib/cerious-scroll.component';\nexport * from './lib/cerious-scroll.service';\n\n// Re-export upstream types/classes for convenience\nexport * from '@ceriousdevtech/cerious-scroll';\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":["i1.CeriousScrollService","i1.CeriousScrollDirective"],"mappings":"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"}
+{"version":3,"file":"ceriousdevtech-ngx-cerious-scroll.mjs","sources":["../../../projects/ngx-cerious-scroll/src/lib/cerious-scroll.observable.ts","../../../projects/ngx-cerious-scroll/src/lib/cerious-scroll-item-template.directive.ts","../../../projects/ngx-cerious-scroll/src/lib/cerious-scroll.service.ts","../../../projects/ngx-cerious-scroll/src/lib/cerious-scroll.directive.ts","../../../projects/ngx-cerious-scroll/src/lib/cerious-scroll.component.ts","../../../projects/ngx-cerious-scroll/src/public-api.ts","../../../projects/ngx-cerious-scroll/src/ceriousdevtech-ngx-cerious-scroll.ts"],"sourcesContent":["import { fromEvent, map, merge, Observable, share } from 'rxjs';\n\nimport type { ScrollResult } from '@ceriousdevtech/cerious-scroll';\n\nimport {\n  CeriousNativeScrollbarViewportChangeEvent,\n  CeriousViewportChangeDetail,\n  CeriousViewportChangeEvent,\n} from './cerious-scroll.types';\n\n/**\n * Observable wrapper around the `cerious-viewport-change` CustomEvent emitted by `@ceriousdevtech/cerious-scroll`.\n *\n * Note: this event is emitted when wheel/touch/keyboard handlers are enabled (defaults are enabled).\n */\nexport function ceriousViewportChange$(container: HTMLElement): Observable<CeriousViewportChangeDetail> {\n  const fromCerious = fromEvent<CeriousViewportChangeEvent>(container, 'cerious-viewport-change').pipe(\n    map((evt) => evt.detail)\n  );\n\n  // Native scrollbar integration in the upstream package dispatches `viewport-change`.\n  // Normalize it into the same shape as `cerious-viewport-change`.\n  const fromScrollbar = fromEvent<CeriousNativeScrollbarViewportChangeEvent>(container, 'viewport-change').pipe(\n    map((evt) => {\n      const result: ScrollResult = { element: evt.detail.element, offset: evt.detail.scrollOffset };\n      return {\n        percentage: evt.detail.percentage,\n        currentElement: evt.detail.element,\n        scrollOffset: evt.detail.scrollOffset,\n        result,\n      } satisfies CeriousViewportChangeDetail;\n    })\n  );\n\n  return merge(fromCerious, fromScrollbar).pipe(share());\n}\n","import { Directive, TemplateRef } from '@angular/core';\n\nexport interface CeriousScrollItemTemplateContext<TItem = unknown> {\n  /** The item for this row (also available as `$implicit`). */\n  $implicit: TItem;\n  /** Row index. */\n  index: number;\n  /** Same as `$implicit` for named access. */\n  item: TItem;\n}\n\n/**\n * Marks an `ng-template` as the row template for `CeriousScrollComponent`.\n *\n * Usage:\n * ```html\n * <cerious-scroll [items]=\"items\">\n *   <ng-template ceriousScrollItem let-item let-index=\"index\">\n *     {{ index }} - {{ item.name }}\n *   </ng-template>\n * </cerious-scroll>\n * ```\n */\n@Directive({\n  selector: 'ng-template[ceriousScrollItem]',\n  standalone: true,\n})\nexport class CeriousScrollItemTemplateDirective<TItem = unknown> {\n  constructor(public readonly templateRef: TemplateRef<CeriousScrollItemTemplateContext<TItem>>) {}\n}\n","import { Injectable, NgZone } from '@angular/core';\n\nimport { CeriousScroll, type CeriousScrollOptions } from '@ceriousdevtech/cerious-scroll';\nimport { Observable } from 'rxjs';\n\nimport { ceriousViewportChange$ } from './cerious-scroll.observable';\nimport type { CeriousViewportChangeDetail } from './cerious-scroll.types';\n\nconst CONTENT_ATTR = 'data-cerious-scroll-content';\n\nfunction ensureContentElement(container: HTMLElement): HTMLElement {\n  const existing = container.querySelector<HTMLElement>(`[${CONTENT_ATTR}]`);\n  if (existing) return existing;\n\n  const el = document.createElement('div');\n  el.setAttribute(CONTENT_ATTR, '');\n  el.style.position = 'relative';\n  el.style.width = '100%';\n  el.style.height = '100%';\n  // overflow-y: clip + overflow-x: auto: clip vertical row overflow (engine\n  // owns vertical) and let the inner element own the native horizontal\n  // scrollbar when consumer content (e.g. wide spreadsheet) overflows.\n  // Horizontal scroll must NOT move to the outer container or the cerious\n  // sibling-driver vertical scrollbar (`position: absolute; right: 0` inside\n  // the outer) would translate with the content. The engine reads its\n  // viewport height from this element so the bottom row stays clear of the\n  // h-scrollbar gutter when it appears.\n  el.style.overflowY = 'clip';\n  el.style.overflowX = 'auto';\n  container.appendChild(el);\n  return el;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class CeriousScrollService {\n  createHost(\n    container: HTMLElement,\n    totalElements: number,\n    options: CeriousScrollOptions,\n    ngZone: NgZone,\n    onScrollHook?: () => void\n  ): CeriousScrollHostRef {\n    const contentElement = options.layout === 'masonry'\n      ? container\n      : ensureContentElement(container);\n    let scroller!: CeriousScroll;\n\n    ngZone.runOutsideAngular(() => {\n      const userOnScroll = options?.onScroll;\n      const mergedOptions: CeriousScrollOptions = {\n        ...options,\n        onScroll: () => {\n          userOnScroll?.();\n          onScrollHook?.();\n        },\n      };\n\n      scroller = new CeriousScroll(container, totalElements, mergedOptions);\n    });\n\n    const viewportChanges$ = ceriousViewportChange$(container);\n\n    return {\n      scroller,\n      contentElement,\n      viewportChanges$,\n      destroy: () => {\n        scroller.detachScrollbar(container);\n        scroller.dispose();\n        // Remove rendered content after the engine has detached its own DOM.\n        contentElement.textContent = '';\n      },\n    };\n  }\n}\n\nexport interface CeriousScrollHostRef {\n  readonly scroller: CeriousScroll;\n  /** Dedicated element used for row rendering (prevents scrollbar DOM from being cleared). */\n  readonly contentElement: HTMLElement;\n  readonly viewportChanges$: Observable<CeriousViewportChangeDetail>;\n  destroy(): void;\n}\n","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 as CoreCeriousScrollOptions,\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 { CeriousScrollOptions } 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  /**\n   * Table mode only: template rendered into the engine's `<thead>` (a `<tr>` of\n   * `<th>`s). It lives in the same `<table>` as the rows, so columns align\n   * natively. Updates via change detection like the rows.\n   */\n  @Input() ceriousScrollHeaderTemplate: TemplateRef<unknown> | 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  // Incremented by the core-owned Masonry renderer whenever it mounts a probe\n  // or visible card. Unlike row mode, those calls do not flow through the\n  // ElementRenderer passed to renderViewport().\n  private masonryRendererEpoch = 0;\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  // Table mode: the embedded view of the declarative header, rendered into the\n  // engine's <thead>.\n  private headerView: EmbeddedViewRef<unknown> | null = null;\n\n  /** Underlying core engine instance, or null before initialization. */\n  get scroller(): CeriousScrollHostRef['scroller'] | null {\n    return this.hostRef?.scroller ?? null;\n  }\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 masonryMode = this.ceriousScrollOptions.layout === 'masonry';\n      const currentCount = masonryMode\n        ? this.hostRef.scroller.itemCount\n        : this.hostRef.scroller.totalElements;\n      const countChanged = currentCount !== total;\n\n      if (countChanged) {\n        if (masonryMode) {\n          // Masonry's renderer owns card-count-derived segment state. Recreate\n          // it when the dataset size changes rather than updating segment count\n          // through the row-oriented updateTotalElements API.\n          this.recreate();\n          return;\n        }\n        // Grow/shrink the dataset IN PLACE — no recreate. updateTotalElements\n        // propagates the new count to every subsystem, INCLUDING the\n        // ViewportRenderer's own copy of totalElements (it used to go stale,\n        // which is exactly why this recreated: the renderer kept the old count\n        // for its viewport-fill loop and bottom scan, producing phantom\n        // out-of-bounds renders). In place keeps the scroll position and an\n        // in-progress scrollbar drag alive, and a growing dataset keeps a stable\n        // bottom index (no bouncing tail). The track lengthens, so re-sync the\n        // thumb afterwards.\n        this.hostRef.scroller.updateTotalElements(total);\n        // A shrink can leave the position past the new end — clamp it.\n        if (this.hostRef.scroller.currentElement > total - 1) {\n          this.hostRef.scroller.jumpToElement(total - 1);\n        }\n        if (this.ceriousScrollAutoRender) this.render();\n        this.hostRef.scroller.syncScrollbar();\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    this.headerView?.destroy();\n    this.headerView = null;\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 masonryMode = this.ceriousScrollOptions.layout === 'masonry';\n    const masonryEpochBefore = this.masonryRendererEpoch;\n    const range = this.hostRef.scroller.renderViewport(height, contentContainer, renderer);\n    const masonryInvocations = this.masonryRendererEpoch - masonryEpochBefore;\n\n    if (rendererInvocations === 0 && (!masonryMode || masonryInvocations === 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 masonryMode = this.ceriousScrollOptions.layout === 'masonry';\n    const active = new Set<HTMLElement>();\n    if (masonryMode) {\n      this.host.nativeElement\n        .querySelectorAll<HTMLElement>('[data-element-index]')\n        .forEach((el) => active.add(el));\n    } else {\n      for (const index of scroller.getRenderedIndices()) {\n        const el = scroller.getRenderedElement(index);\n        if (el) active.add(el);\n      }\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    const template = this.ceriousScrollItemTemplate;\n    if (template) {\n      // Re-invoke the renderer for every currently-rendered row so pending\n      // Angular bindings flush into the DOM and the engine re-measures each\n      // row's new height into its cache. Without this, the engine's render\n      // pass skips the renderer for already-rendered indices and falls\n      // through to reading stale offsetHeight.\n      this.hostRef.scroller.refreshVisible((index, elementContainer) => {\n        this.renderTemplateIntoContainer(template, index, elementContainer);\n      });\n    }\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  /** Masonry mode only: jump directly to a card index, then render. */\n  jumpToItem(index: number, screenOffset = 0): MeasuredViewportRange | null {\n    if (!this.hostRef) return null;\n    this.hostRef.scroller.jumpToItem(index, screenOffset);\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    // Table mode: capture the engine-created <thead> so we can render the\n    // declarative header template into it (and still run any user header hook).\n    let options: CoreCeriousScrollOptions;\n    if (this.ceriousScrollOptions.layout === 'masonry') {\n      if (!this.ceriousScrollOptions.masonry) {\n        throw new Error(\"CeriousScrollDirective: layout 'masonry' requires `ceriousScrollOptions.masonry`.\");\n      }\n      options = {\n        ...this.ceriousScrollOptions,\n        masonry: {\n          ...this.ceriousScrollOptions.masonry,\n          renderItem: (index, element) => {\n            this.masonryRendererEpoch++;\n            const template = this.ceriousScrollItemTemplate;\n            if (!template) return;\n            if (element.dataset['ceriousMasonry'] === 'probe') {\n              this.renderProbe(template, index, element);\n            } else {\n              this.renderTemplateIntoContainer(template, index, element);\n            }\n          },\n        },\n      };\n    } else {\n      options = this.ceriousScrollOptions as CoreCeriousScrollOptions;\n    }\n    if (options.layout === 'table' && this.ceriousScrollHeaderTemplate) {\n      const userHeader = options.table?.header;\n      options = {\n        ...options,\n        table: {\n          ...options.table,\n          header: (thead: HTMLTableSectionElement) => {\n            userHeader?.(thead);\n            this.mountHeader(thead);\n          },\n        },\n      };\n    }\n\n    this.hostRef = this.cerious.createHost(container, total, options, 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  /**\n   * Render the declarative header template into the engine's <thead>. One\n   * embedded view, created inside the zone (so the header's event bindings are\n   * zone-patched), its root nodes appended directly into the <thead>.\n   */\n  private mountHeader(thead: HTMLElement): void {\n    if (!this.ceriousScrollHeaderTemplate) return;\n    this.headerView?.destroy();\n    const view = this.ngZone.run(() => {\n      const v = this.ceriousScrollHeaderTemplate!.createEmbeddedView({});\n      this.appRef.attachView(v);\n      v.detectChanges();\n      return v;\n    });\n    for (const node of view.rootNodes) thead.appendChild(node);\n    this.headerView = view;\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 renderProbe(\n    template: TemplateRef<CeriousScrollItemTemplateContext<TItem>>,\n    index: number,\n    container: HTMLElement\n  ): void {\n    const item = this.getItemForIndex(index);\n    const view = this.ngZone.runOutsideAngular(() => {\n      const v = template.createEmbeddedView({ $implicit: item, item, index });\n      v.detectChanges();\n      return v;\n    });\n    for (const node of view.rootNodes) container.appendChild(node);\n\n    // Measurement probes are deliberately NOT attached to ApplicationRef:\n    // they are disposable, non-interactive markup and local detectChanges() is\n    // enough to populate their DOM synchronously. Attaching each probe inside\n    // Angular's zone turns dynamic scrolling into repeated application-wide\n    // change-detection work. The core reads offsetHeight immediately after this\n    // callback and clears the probe, so destroy the isolated view afterwards.\n    queueMicrotask(() => {\n      view.destroy();\n    });\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","import {\n  AfterContentInit,\n  ChangeDetectionStrategy,\n  Component,\n  ContentChild,\n  TemplateRef,\n} from '@angular/core';\n\nimport { CeriousScrollDirective } from './cerious-scroll.directive';\nimport {\n  CeriousScrollItemTemplateDirective,\n  type CeriousScrollItemTemplateContext,\n} from './cerious-scroll-item-template.directive';\n\n@Component({\n  selector: 'cerious-scroll',\n  standalone: true,\n  imports: [],\n  hostDirectives: [\n    {\n      directive: CeriousScrollDirective,\n      inputs: [\n        'ceriousScrollTotalElements: totalElements',\n        'ceriousScrollItems: items',\n        'ceriousScrollGetItem: getItem',\n        'ceriousScrollItemTemplate: itemTemplate',\n        'ceriousScrollHeaderTemplate: headerTemplate',\n        'ceriousScrollOptions: options',\n        'ceriousScrollAutoRender: autoRender',\n      ],\n      outputs: [\n        'ceriousScrollViewportChange: viewportChange',\n        'ceriousScrollMeasuredViewport: measuredViewport',\n        'ceriousScrollReady: scrollerReady',\n      ],\n    },\n  ],\n  template: `<ng-content />`,\n  styles: `\n    :host {\n      display: block;\n    }\n  `,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class CeriousScrollComponent<TItem = unknown> implements AfterContentInit {\n  /** Optional convenience template marker: <ng-template ceriousScrollItem let-item let-index=\"index\">...</ng-template> */\n  @ContentChild(CeriousScrollItemTemplateDirective)\n  private readonly projectedItemTemplate?: CeriousScrollItemTemplateDirective<TItem>;\n\n  constructor(private readonly ceriousScroll: CeriousScrollDirective<TItem>) {}\n\n  get scroller() { return this.ceriousScroll.scroller; }\n  render() { return this.ceriousScroll.render(); }\n  jumpToElement(index: number) { return this.ceriousScroll.jumpToElement(index); }\n  jumpToItem(index: number, screenOffset = 0) {\n    return this.ceriousScroll.jumpToItem(index, screenOffset);\n  }\n  scrollToPercentage(percentage: number) {\n    return this.ceriousScroll.scrollToPercentage(percentage);\n  }\n  reset() { return this.ceriousScroll.reset(); }\n  recalculate() { return this.ceriousScroll.recalculate(); }\n\n  ngAfterContentInit(): void {\n    if (this.ceriousScroll.ceriousScrollItemTemplate) return;\n    if (!this.projectedItemTemplate) return;\n\n    this.ceriousScroll.ceriousScrollItemTemplate =\n      this.projectedItemTemplate.templateRef as TemplateRef<CeriousScrollItemTemplateContext<TItem>>;\n\n    if (this.ceriousScroll.ceriousScrollAutoRender) {\n      queueMicrotask(() => this.ceriousScroll.render());\n    }\n  }\n}\n","/*\n * Public API Surface of ngx-cerious-scroll\n */\n\nexport * from './lib/cerious-scroll.types';\nexport type { CeriousScrollOptions } from './lib/cerious-scroll.types';\nexport * from './lib/cerious-scroll.observable';\nexport * from './lib/cerious-scroll-item-template.directive';\nexport * from './lib/cerious-scroll.directive';\nexport * from './lib/cerious-scroll.component';\nexport * from './lib/cerious-scroll.service';\n\n// Re-export upstream types/classes for convenience\nexport * from '@ceriousdevtech/cerious-scroll';\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":["i1.CeriousScrollService","i1.CeriousScrollDirective"],"mappings":"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"}

package/lib/cerious-scroll.component.d.ts

@@ -7,6 +7,13 @@ export declare class CeriousScrollComponent<TItem = unknown> implements AfterCon
     /** Optional convenience template marker: <ng-template ceriousScrollItem let-item let-index="index">...</ng-template> */
     private readonly projectedItemTemplate?;
     constructor(ceriousScroll: CeriousScrollDirective<TItem>);
+    get scroller(): import("@ceriousdevtech/cerious-scroll").CeriousScroll | null;
+    render(): import("@ceriousdevtech/cerious-scroll").MeasuredViewportRange | null;
+    jumpToElement(index: number): import("@ceriousdevtech/cerious-scroll").MeasuredViewportRange | null;
+    jumpToItem(index: number, screenOffset?: number): import("@ceriousdevtech/cerious-scroll").MeasuredViewportRange | null;
+    scrollToPercentage(percentage: number): import("@ceriousdevtech/cerious-scroll").MeasuredViewportRange | null;
+    reset(): import("@ceriousdevtech/cerious-scroll").MeasuredViewportRange | null;
+    recalculate(): import("@ceriousdevtech/cerious-scroll").MeasuredViewportRange | null;
     ngAfterContentInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CeriousScrollComponent<any>, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<CeriousScrollComponent<any>, "cerious-scroll", never, {}, {}, ["projectedItemTemplate"], ["*"], true, [{ directive: typeof i1.CeriousScrollDirective; inputs: { "ceriousScrollTotalElements": "totalElements"; "ceriousScrollItems": "items"; "ceriousScrollGetItem": "getItem"; "ceriousScrollItemTemplate": "itemTemplate"; "ceriousScrollHeaderTemplate": "headerTemplate"; "ceriousScrollOptions": "options"; "ceriousScrollAutoRender": "autoRender"; }; outputs: { "ceriousScrollViewportChange": "viewportChange"; "ceriousScrollMeasuredViewport": "measuredViewport"; "ceriousScrollReady": "scrollerReady"; }; }]>;

package/lib/cerious-scroll.directive.d.ts

@@ -1,8 +1,9 @@
 import { AfterViewInit, ApplicationRef, ElementRef, EventEmitter, NgZone, OnChanges, OnDestroy, SimpleChanges, TemplateRef } from '@angular/core';
-import { type CeriousScrollOptions, type MeasuredViewportRange } from '@ceriousdevtech/cerious-scroll';
+import { type MeasuredViewportRange } from '@ceriousdevtech/cerious-scroll';
 import type { CeriousViewportChangeDetail } from './cerious-scroll.types';
+import type { CeriousScrollOptions } from './cerious-scroll.types';
 import type { CeriousScrollItemTemplateContext } from './cerious-scroll-item-template.directive';
-import { CeriousScrollService } from './cerious-scroll.service';
+import { type CeriousScrollHostRef, CeriousScrollService } from './cerious-scroll.service';
 import * as i0 from "@angular/core";
 export declare class CeriousScrollDirective<TItem = unknown> implements AfterViewInit, OnChanges, OnDestroy {
     private readonly host;
@@ -36,9 +37,12 @@ export declare class CeriousScrollDirective<TItem = unknown> implements AfterVie
     private hostRef;
     private viewportSub;
     private scheduledRenderFrame;
+    private masonryRendererEpoch;
     private readonly viewByContainer;
     private readonly freeViews;
     private headerView;
+    /** Underlying core engine instance, or null before initialization. */
+    get scroller(): CeriousScrollHostRef['scroller'] | null;
     constructor(host: ElementRef<HTMLElement>, appRef: ApplicationRef, ngZone: NgZone, cerious: CeriousScrollService);
     ngAfterViewInit(): void;
     ngOnChanges(changes: SimpleChanges): void;
@@ -62,6 +66,8 @@ export declare class CeriousScrollDirective<TItem = unknown> implements AfterVie
     recalculate(): MeasuredViewportRange | null;
     /** Jump directly to an element index, then render. */
     jumpToElement(index: number): MeasuredViewportRange | null;
+    /** Masonry mode only: jump directly to a card index, then render. */
+    jumpToItem(index: number, screenOffset?: number): MeasuredViewportRange | null;
     /** Scroll to a percentage (0..100), then render. */
     scrollToPercentage(percentage: number): MeasuredViewportRange | null;
     /** Reset to the top, then render. */
@@ -75,6 +81,7 @@ export declare class CeriousScrollDirective<TItem = unknown> implements AfterVie
      */
     private mountHeader;
     private getItemForIndex;
+    private renderProbe;
     private renderTemplateIntoContainer;
     /**
      * Update the bound item/index on every currently-rendered row's embedded view

package/lib/cerious-scroll.types.d.ts

@@ -1,4 +1,11 @@
-import type { ScrollResult } from '@ceriousdevtech/cerious-scroll';
+import type { CeriousScrollOptions as CoreCeriousScrollOptions, MasonryOptions, ScrollResult } from '@ceriousdevtech/cerious-scroll';
+/** Engine options adapted for Angular-owned Masonry rendering. */
+export type CeriousScrollOptions = Omit<CoreCeriousScrollOptions, 'masonry'> & {
+    masonry?: Omit<MasonryOptions, 'renderItem'> & {
+        /** Accepted for backward compatibility; Angular supplies the active renderer. */
+        renderItem?: MasonryOptions['renderItem'];
+    };
+};
 /**
  * Detail payload for the `cerious-viewport-change` CustomEvent dispatched by `@ceriousdevtech/cerious-scroll`.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ceriousdevtech/ngx-cerious-scroll",
-  "version": "1.0.7",
+  "version": "1.1.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -11,7 +11,7 @@
     "@angular/core": ">=16.0.0"
   },
   "dependencies": {
-    "@ceriousdevtech/cerious-scroll": "^1.0.7",
+    "@ceriousdevtech/cerious-scroll": "^1.1.0",
     "tslib": "^2.3.0"
   },
   "sideEffects": false,

package/public-api.d.ts

@@ -1,4 +1,5 @@
 export * from './lib/cerious-scroll.types';
+export type { CeriousScrollOptions } from './lib/cerious-scroll.types';
 export * from './lib/cerious-scroll.observable';
 export * from './lib/cerious-scroll-item-template.directive';
 export * from './lib/cerious-scroll.directive';