@embedpdf/plugin-scroll 1.0.0

package/dist/index.cjs

@@ -0,0 +1,737 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SCROLL_PLUGIN_ID: () => SCROLL_PLUGIN_ID,
+  ScrollPlugin: () => ScrollPlugin,
+  ScrollPluginPackage: () => ScrollPluginPackage,
+  ScrollStrategy: () => ScrollStrategy,
+  manifest: () => manifest
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lib/scroll-plugin.ts
+var import_core = require("@embedpdf/core");
+
+// ../models/dist/index.js
+var Rotation = /* @__PURE__ */ ((Rotation22) => {
+  Rotation22[Rotation22["Degree0"] = 0] = "Degree0";
+  Rotation22[Rotation22["Degree90"] = 1] = "Degree90";
+  Rotation22[Rotation22["Degree180"] = 2] = "Degree180";
+  Rotation22[Rotation22["Degree270"] = 3] = "Degree270";
+  return Rotation22;
+})(Rotation || {});
+function swap(size) {
+  const { width, height } = size;
+  return {
+    width: height,
+    height: width
+  };
+}
+function rotatePosition(containerSize, position, rotation) {
+  let x = position.x;
+  let y = position.y;
+  switch (rotation) {
+    case 0:
+      x = position.x;
+      y = position.y;
+      break;
+    case 1:
+      x = containerSize.height - position.y;
+      y = position.x;
+      break;
+    case 2:
+      x = containerSize.width - position.x;
+      y = containerSize.height - position.y;
+      break;
+    case 3:
+      x = position.y;
+      y = containerSize.width - position.x;
+      break;
+  }
+  return {
+    x,
+    y
+  };
+}
+function scalePosition(position, scaleFactor) {
+  return {
+    x: position.x * scaleFactor,
+    y: position.y * scaleFactor
+  };
+}
+function transformPosition(containerSize, position, rotation, scaleFactor) {
+  return scalePosition(rotatePosition(containerSize, position, rotation), scaleFactor);
+}
+function rotateRect(containerSize, rect, rotation) {
+  let x = rect.origin.x;
+  let y = rect.origin.y;
+  let size = rect.size;
+  switch (rotation) {
+    case 0:
+      break;
+    case 1:
+      x = containerSize.height - rect.origin.y - rect.size.height;
+      y = rect.origin.x;
+      size = swap(rect.size);
+      break;
+    case 2:
+      x = containerSize.width - rect.origin.x - rect.size.width;
+      y = containerSize.height - rect.origin.y - rect.size.height;
+      break;
+    case 3:
+      x = rect.origin.y;
+      y = containerSize.width - rect.origin.x - rect.size.width;
+      size = swap(rect.size);
+      break;
+  }
+  return {
+    origin: {
+      x,
+      y
+    },
+    size: {
+      width: size.width,
+      height: size.height
+    }
+  };
+}
+function scaleRect(rect, scaleFactor) {
+  return {
+    origin: {
+      x: rect.origin.x * scaleFactor,
+      y: rect.origin.y * scaleFactor
+    },
+    size: {
+      width: rect.size.width * scaleFactor,
+      height: rect.size.height * scaleFactor
+    }
+  };
+}
+function transformRect(containerSize, rect, rotation, scaleFactor) {
+  return scaleRect(rotateRect(containerSize, rect, rotation), scaleFactor);
+}
+
+// src/lib/types.ts
+var ScrollStrategy = /* @__PURE__ */ ((ScrollStrategy2) => {
+  ScrollStrategy2["Vertical"] = "vertical";
+  ScrollStrategy2["Horizontal"] = "horizontal";
+  return ScrollStrategy2;
+})(ScrollStrategy || {});
+
+// src/lib/strategies/base-strategy.ts
+var BaseScrollStrategy = class {
+  constructor(config) {
+    this.pageGap = config.pageGap ?? 20;
+    this.viewportGap = config.viewportGap ?? 20;
+    this.bufferSize = config.bufferSize ?? 2;
+  }
+  getVisibleRange(viewport, virtualItems, scale) {
+    const scrollOffset = this.getScrollOffset(viewport);
+    const clientSize = this.getClientSize(viewport);
+    const viewportStart = scrollOffset;
+    const viewportEnd = scrollOffset + clientSize;
+    let startIndex = 0;
+    while (startIndex < virtualItems.length && (virtualItems[startIndex].offset + virtualItems[startIndex].height) * scale <= viewportStart) {
+      startIndex++;
+    }
+    let endIndex = startIndex;
+    while (endIndex < virtualItems.length && virtualItems[endIndex].offset * scale <= viewportEnd) {
+      endIndex++;
+    }
+    return {
+      start: Math.max(0, startIndex - this.bufferSize),
+      end: Math.min(virtualItems.length - 1, endIndex + this.bufferSize - 1)
+    };
+  }
+  handleScroll(viewport, virtualItems, scale) {
+    const range = this.getVisibleRange(viewport, virtualItems, scale);
+    const visibleItems = virtualItems.slice(range.start, range.end + 1);
+    const pageVisibilityMetrics = this.calculatePageVisibility(visibleItems, viewport, scale);
+    const visiblePages = pageVisibilityMetrics.map((m) => m.pageNumber);
+    const renderedPageIndexes = virtualItems.slice(range.start, range.end + 1).flatMap((item) => item.index);
+    const currentPage = this.determineCurrentPage(pageVisibilityMetrics);
+    const first = virtualItems[range.start];
+    const last = virtualItems[range.end];
+    const startSpacing = first ? first.offset * scale : 0;
+    const endSpacing = last ? (virtualItems[virtualItems.length - 1].offset + // end of content
+    virtualItems[virtualItems.length - 1].height) * scale - // minus
+    (last.offset + last.height) * scale : 0;
+    return {
+      currentPage,
+      visiblePages,
+      pageVisibilityMetrics,
+      renderedPageIndexes,
+      scrollOffset: { x: viewport.scrollLeft, y: viewport.scrollTop },
+      startSpacing,
+      endSpacing
+    };
+  }
+  calculatePageVisibility(virtualItems, viewport, scale) {
+    const visibilityMetrics = [];
+    virtualItems.forEach((item) => {
+      item.pageLayouts.forEach((page) => {
+        const itemX = item.x * scale;
+        const itemY = item.y * scale;
+        const pageX = itemX + page.x * scale;
+        const pageY = itemY + page.y * scale;
+        const pageWidth = page.rotatedWidth * scale;
+        const pageHeight = page.rotatedHeight * scale;
+        const viewportLeft = viewport.scrollLeft;
+        const viewportTop = viewport.scrollTop;
+        const viewportRight = viewportLeft + viewport.clientWidth;
+        const viewportBottom = viewportTop + viewport.clientHeight;
+        const intersectionLeft = Math.max(pageX, viewportLeft);
+        const intersectionTop = Math.max(pageY, viewportTop);
+        const intersectionRight = Math.min(pageX + pageWidth, viewportRight);
+        const intersectionBottom = Math.min(pageY + pageHeight, viewportBottom);
+        if (intersectionLeft < intersectionRight && intersectionTop < intersectionBottom) {
+          const visibleWidth = intersectionRight - intersectionLeft;
+          const visibleHeight = intersectionBottom - intersectionTop;
+          const totalArea = pageWidth * pageHeight;
+          const visibleArea = visibleWidth * visibleHeight;
+          visibilityMetrics.push({
+            pageNumber: page.pageNumber,
+            viewportX: intersectionLeft - viewportLeft,
+            viewportY: intersectionTop - viewportTop,
+            visiblePercentage: visibleArea / totalArea * 100,
+            original: {
+              pageX: (intersectionLeft - pageX) / scale,
+              pageY: (intersectionTop - pageY) / scale,
+              visibleWidth: visibleWidth / scale,
+              visibleHeight: visibleHeight / scale,
+              scale: 1
+            },
+            scaled: {
+              pageX: intersectionLeft - pageX,
+              pageY: intersectionTop - pageY,
+              visibleWidth,
+              visibleHeight,
+              scale
+            }
+          });
+        }
+      });
+    });
+    return visibilityMetrics;
+  }
+  determineCurrentPage(visibilityMetrics) {
+    if (visibilityMetrics.length === 0) return 1;
+    const maxVisibility = Math.max(...visibilityMetrics.map((m) => m.visiblePercentage));
+    const mostVisiblePages = visibilityMetrics.filter((m) => m.visiblePercentage === maxVisibility);
+    return mostVisiblePages.length === 1 ? mostVisiblePages[0].pageNumber : mostVisiblePages.sort((a, b) => a.pageNumber - b.pageNumber)[0].pageNumber;
+  }
+  getRectLocationForPage(pageNumber, virtualItems) {
+    const item = virtualItems.find((item2) => item2.pageNumbers.includes(pageNumber));
+    if (!item) return null;
+    const pageLayout = item.pageLayouts.find((layout) => layout.pageNumber === pageNumber);
+    if (!pageLayout) return null;
+    return {
+      origin: {
+        x: item.x + pageLayout.x,
+        y: item.y + pageLayout.y
+      },
+      size: {
+        width: pageLayout.width,
+        height: pageLayout.height
+      }
+    };
+  }
+  getScrollPositionForPage(pageNumber, virtualItems, scale, rotation, pageCoordinates) {
+    const pageRect = this.getRectLocationForPage(pageNumber, virtualItems);
+    if (!pageRect) return null;
+    const scaledBasePosition = scalePosition(pageRect.origin, scale);
+    if (pageCoordinates) {
+      const rotatedSize = transformPosition(
+        {
+          width: pageRect.size.width,
+          height: pageRect.size.height
+        },
+        {
+          x: pageCoordinates.x,
+          y: pageCoordinates.y
+        },
+        rotation,
+        scale
+      );
+      return {
+        x: scaledBasePosition.x + rotatedSize.x + this.viewportGap,
+        y: scaledBasePosition.y + rotatedSize.y + this.viewportGap
+      };
+    }
+    return {
+      x: scaledBasePosition.x + this.viewportGap,
+      y: scaledBasePosition.y + this.viewportGap
+    };
+  }
+  getRectPositionForPage(pageNumber, virtualItems, scale, rotation, rect) {
+    const pageRect = this.getRectLocationForPage(pageNumber, virtualItems);
+    if (!pageRect) return null;
+    const scaledBasePosition = scalePosition(pageRect.origin, scale);
+    const rotatedSize = transformRect(
+      {
+        width: pageRect.size.width,
+        height: pageRect.size.height
+      },
+      rect,
+      rotation,
+      scale
+    );
+    return {
+      origin: {
+        x: scaledBasePosition.x + rotatedSize.origin.x,
+        y: scaledBasePosition.y + rotatedSize.origin.y
+      },
+      size: rotatedSize.size
+    };
+  }
+};
+
+// src/lib/strategies/vertical-strategy.ts
+var VerticalScrollStrategy = class extends BaseScrollStrategy {
+  constructor(config) {
+    super(config);
+  }
+  createVirtualItems(pdfPageObject) {
+    let yOffset = 0;
+    return pdfPageObject.map((pagesInSpread, index) => {
+      let pageX = 0;
+      const pageLayouts = pagesInSpread.map((page) => {
+        const layout = {
+          pageNumber: page.index + 1,
+          pageIndex: page.index,
+          x: pageX,
+          y: 0,
+          width: page.size.width,
+          height: page.size.height,
+          rotatedWidth: page.rotatedSize.width,
+          rotatedHeight: page.rotatedSize.height
+        };
+        pageX += page.rotatedSize.width + this.pageGap;
+        return layout;
+      });
+      const width = pagesInSpread.reduce(
+        (sum, page, i) => sum + page.rotatedSize.width + (i < pagesInSpread.length - 1 ? this.pageGap : 0),
+        0
+      );
+      const height = Math.max(...pagesInSpread.map((p) => p.rotatedSize.height));
+      const item = {
+        id: `item-${index}`,
+        x: 0,
+        y: yOffset,
+        offset: yOffset,
+        width,
+        height,
+        pageLayouts,
+        pageNumbers: pagesInSpread.map((p) => p.index + 1),
+        index
+      };
+      yOffset += height + this.pageGap;
+      return item;
+    });
+  }
+  getTotalContentSize(virtualItems) {
+    if (virtualItems.length === 0) return { width: 0, height: 0 };
+    const maxWidth = Math.max(...virtualItems.map((item) => item.width));
+    const totalHeight = virtualItems[virtualItems.length - 1].y + virtualItems[virtualItems.length - 1].height;
+    return {
+      width: maxWidth,
+      height: totalHeight
+    };
+  }
+  getScrollOffset(viewport) {
+    return viewport.scrollTop;
+  }
+  getClientSize(viewport) {
+    return viewport.clientHeight;
+  }
+};
+
+// src/lib/strategies/horizontal-strategy.ts
+var HorizontalScrollStrategy = class extends BaseScrollStrategy {
+  constructor(config) {
+    super(config);
+  }
+  createVirtualItems(pdfPageObject) {
+    let xOffset = 0;
+    return pdfPageObject.map((pagesInSpread, index) => {
+      let pageX = 0;
+      const pageLayouts = pagesInSpread.map((page) => {
+        const layout = {
+          pageNumber: page.index + 1,
+          pageIndex: page.index,
+          x: pageX,
+          y: 0,
+          width: page.size.width,
+          height: page.size.height,
+          rotatedWidth: page.rotatedSize.width,
+          rotatedHeight: page.rotatedSize.height
+        };
+        pageX += page.rotatedSize.width + this.pageGap;
+        return layout;
+      });
+      const width = pagesInSpread.reduce(
+        (sum, page, i) => sum + page.rotatedSize.width + (i < pagesInSpread.length - 1 ? this.pageGap : 0),
+        0
+      );
+      const height = Math.max(...pagesInSpread.map((p) => p.rotatedSize.height));
+      const item = {
+        id: `item-${index}`,
+        x: xOffset,
+        y: 0,
+        offset: xOffset,
+        width,
+        height,
+        pageLayouts,
+        pageNumbers: pagesInSpread.map((p) => p.index + 1),
+        index
+      };
+      xOffset += width + this.pageGap;
+      return item;
+    });
+  }
+  getTotalContentSize(virtualItems) {
+    if (virtualItems.length === 0) return { width: 0, height: 0 };
+    const totalWidth = virtualItems[virtualItems.length - 1].x + virtualItems[virtualItems.length - 1].width;
+    const maxHeight = Math.max(...virtualItems.map((item) => item.height));
+    return {
+      width: totalWidth,
+      height: maxHeight
+    };
+  }
+  getScrollOffset(viewport) {
+    return viewport.scrollLeft;
+  }
+  getClientSize(viewport) {
+    return viewport.clientWidth;
+  }
+};
+
+// src/lib/actions.ts
+var UPDATE_SCROLL_STATE = "UPDATE_SCROLL_STATE";
+var SET_DESIRED_SCROLL_POSITION = "SET_DESIRED_SCROLL_POSITION";
+function updateScrollState(payload) {
+  return { type: UPDATE_SCROLL_STATE, payload };
+}
+
+// src/lib/selectors.ts
+var getScrollerLayout = (state, scale) => {
+  return {
+    startSpacing: state.startSpacing,
+    endSpacing: state.endSpacing,
+    totalWidth: state.totalContentSize.width * scale,
+    totalHeight: state.totalContentSize.height * scale,
+    pageGap: state.pageGap * scale,
+    strategy: state.strategy,
+    items: state.renderedPageIndexes.map((idx) => {
+      return {
+        ...state.virtualItems[idx],
+        pageLayouts: state.virtualItems[idx].pageLayouts.map((layout) => {
+          return {
+            ...layout,
+            rotatedWidth: layout.rotatedWidth * scale,
+            rotatedHeight: layout.rotatedHeight * scale,
+            width: layout.width * scale,
+            height: layout.height * scale
+          };
+        })
+      };
+    })
+  };
+};
+
+// src/lib/scroll-plugin.ts
+var ScrollPlugin = class extends import_core.BasePlugin {
+  constructor(id, registry, config) {
+    super(id, registry);
+    this.id = id;
+    this.config = config;
+    this.currentScale = 1;
+    this.currentRotation = Rotation.Degree0;
+    this.currentPage = 1;
+    this.layout$ = (0, import_core.createBehaviorEmitter)();
+    this.scroll$ = (0, import_core.createBehaviorEmitter)();
+    this.state$ = (0, import_core.createBehaviorEmitter)();
+    this.scrollerLayout$ = (0, import_core.createBehaviorEmitter)();
+    this.pageChange$ = (0, import_core.createEmitter)();
+    this.viewport = this.registry.getPlugin("viewport").provides();
+    this.strategyConfig = {
+      pageGap: this.config?.pageGap ?? 10,
+      viewportGap: this.viewport.getViewportGap(),
+      bufferSize: this.config?.bufferSize ?? 2
+    };
+    this.strategy = this.config?.strategy === "horizontal" /* Horizontal */ ? new HorizontalScrollStrategy(this.strategyConfig) : new VerticalScrollStrategy(this.strategyConfig);
+    this.initialPage = this.config?.initialPage;
+    this.currentScale = this.coreState.core.scale;
+    this.currentRotation = this.coreState.core.rotation;
+    this.viewport.onViewportChange((vp) => this.commitMetrics(this.computeMetrics(vp)), {
+      mode: "throttle",
+      wait: 250
+    });
+    this.coreStore.onAction(
+      import_core.SET_DOCUMENT,
+      (_action, state) => this.refreshAll((0, import_core.getPagesWithRotatedSize)(state.core), this.viewport.getMetrics())
+    );
+    this.coreStore.onAction(
+      import_core.SET_ROTATION,
+      (_action, state) => this.refreshAll((0, import_core.getPagesWithRotatedSize)(state.core), this.viewport.getMetrics())
+    );
+    this.coreStore.onAction(
+      import_core.SET_PAGES,
+      (_action, state) => this.refreshAll((0, import_core.getPagesWithRotatedSize)(state.core), this.viewport.getMetrics())
+    );
+  }
+  /* ------------------------------------------------------------------ */
+  /*  ᴄᴏᴍᴘᴜᴛᴇʀs                                                       */
+  /* ------------------------------------------------------------------ */
+  computeLayout(pages) {
+    const virtualItems = this.strategy.createVirtualItems(pages);
+    const totalContentSize = this.strategy.getTotalContentSize(virtualItems);
+    return { virtualItems, totalContentSize };
+  }
+  computeMetrics(vp, items = this.state.virtualItems) {
+    return this.strategy.handleScroll(vp, items, this.currentScale);
+  }
+  /* ------------------------------------------------------------------ */
+  /*  ᴄᴏᴍᴍɪᴛ  (single source of truth)                                  */
+  /* ------------------------------------------------------------------ */
+  commit(stateDelta, emit) {
+    this.dispatch(updateScrollState(stateDelta));
+    if (emit?.layout) this.layout$.emit(emit.layout);
+    if (emit?.metrics) {
+      this.scroll$.emit(emit.metrics);
+      if (emit.metrics.currentPage !== this.currentPage) {
+        this.currentPage = emit.metrics.currentPage;
+        this.pageChange$.emit(this.currentPage);
+      }
+    }
+    this.scrollerLayout$.emit(this.getScrollerLayoutFromState());
+  }
+  /* convenience wrappers */
+  commitMetrics(metrics) {
+    this.commit(metrics, { metrics });
+  }
+  /* full re-compute after page-spread or initialisation */
+  refreshAll(pages, vp) {
+    const layout = this.computeLayout(pages);
+    const metrics = this.computeMetrics(vp, layout.virtualItems);
+    this.commit({ ...layout, ...metrics }, { layout, metrics });
+  }
+  getVirtualItemsFromState() {
+    return this.state.virtualItems || [];
+  }
+  getScrollerLayoutFromState() {
+    const scale = this.coreState.core.scale;
+    return getScrollerLayout(this.state, scale);
+  }
+  pushScrollLayout() {
+    this.scrollerLayout$.emit(this.getScrollerLayoutFromState());
+  }
+  onStoreUpdated(_prevState, _newState) {
+    this.pushScrollLayout();
+  }
+  onCoreStoreUpdated(prevState, newState) {
+    if (prevState.core.scale !== newState.core.scale) {
+      this.currentScale = newState.core.scale;
+      this.commitMetrics(this.computeMetrics(this.viewport.getMetrics()));
+    }
+    if (prevState.core.rotation !== newState.core.rotation) {
+      this.currentRotation = newState.core.rotation;
+    }
+  }
+  /**
+   * Change the scroll strategy at runtime (e.g., vertical <-> horizontal)
+   * @param newStrategy ScrollStrategy.Horizontal or ScrollStrategy.Vertical
+   */
+  setScrollStrategy(newStrategy) {
+    if (newStrategy === "horizontal" /* Horizontal */ && this.strategy instanceof HorizontalScrollStrategy || newStrategy === "vertical" /* Vertical */ && this.strategy instanceof VerticalScrollStrategy) {
+      return;
+    }
+    this.strategy = newStrategy === "horizontal" /* Horizontal */ ? new HorizontalScrollStrategy(this.strategyConfig) : new VerticalScrollStrategy(this.strategyConfig);
+    this.dispatch(
+      updateScrollState({
+        strategy: newStrategy
+      })
+    );
+    const pages = (0, import_core.getPagesWithRotatedSize)(this.coreState.core);
+    this.refreshAll(pages, this.viewport.getMetrics());
+  }
+  buildCapability() {
+    return {
+      onStateChange: this.state$.on,
+      onLayoutChange: this.layout$.on,
+      onScroll: this.scroll$.on,
+      onPageChange: this.pageChange$.on,
+      onScrollerData: this.scrollerLayout$.on,
+      scrollToPage: (options) => {
+        const { pageNumber, behavior = "smooth", pageCoordinates, center = false } = options;
+        const virtualItems = this.getVirtualItemsFromState();
+        const position = this.strategy.getScrollPositionForPage(
+          pageNumber,
+          virtualItems,
+          this.currentScale,
+          this.currentRotation,
+          pageCoordinates
+        );
+        if (position) {
+          this.viewport.scrollTo({ ...position, behavior, center });
+        }
+      },
+      scrollToNextPage: (behavior = "smooth") => {
+        const virtualItems = this.getVirtualItemsFromState();
+        const currentItemIndex = virtualItems.findIndex(
+          (item) => item.pageNumbers.includes(this.currentPage)
+        );
+        if (currentItemIndex >= 0 && currentItemIndex < virtualItems.length - 1) {
+          const nextItem = virtualItems[currentItemIndex + 1];
+          const position = this.strategy.getScrollPositionForPage(
+            nextItem.pageNumbers[0],
+            virtualItems,
+            this.currentScale,
+            this.currentRotation
+          );
+          if (position) {
+            this.viewport.scrollTo({ ...position, behavior });
+          }
+        }
+      },
+      scrollToPreviousPage: (behavior = "smooth") => {
+        const virtualItems = this.getVirtualItemsFromState();
+        const currentItemIndex = virtualItems.findIndex(
+          (item) => item.pageNumbers.includes(this.currentPage)
+        );
+        if (currentItemIndex > 0) {
+          const prevItem = virtualItems[currentItemIndex - 1];
+          const position = this.strategy.getScrollPositionForPage(
+            prevItem.pageNumbers[0],
+            virtualItems,
+            this.currentScale,
+            this.currentRotation
+          );
+          if (position) {
+            this.viewport.scrollTo({ ...position, behavior });
+          }
+        }
+      },
+      getMetrics: this.getMetrics.bind(this),
+      getLayout: this.getLayout.bind(this),
+      getRectPositionForPage: this.getRectPositionForPage.bind(this),
+      getPageGap: () => this.state.pageGap,
+      getScrollerLayout: () => this.getScrollerLayoutFromState(),
+      setScrollStrategy: (strategy) => this.setScrollStrategy(strategy)
+    };
+  }
+  getMetrics(viewport) {
+    const metrics = viewport || this.viewport.getMetrics();
+    const virtualItems = this.getVirtualItemsFromState();
+    return this.strategy.handleScroll(metrics, virtualItems, this.currentScale);
+  }
+  getLayout() {
+    return {
+      virtualItems: this.state.virtualItems,
+      totalContentSize: this.state.totalContentSize
+    };
+  }
+  getRectPositionForPage(pageIndex, rect, scale, rotation) {
+    return this.strategy.getRectPositionForPage(
+      pageIndex + 1,
+      this.state.virtualItems,
+      scale ?? this.currentScale,
+      rotation ?? this.currentRotation,
+      rect
+    );
+  }
+  async initialize() {
+  }
+  async destroy() {
+    this.layout$.clear();
+    this.scroll$.clear();
+    this.pageChange$.clear();
+    this.state$.clear();
+    super.destroy();
+  }
+};
+ScrollPlugin.id = "scroll";
+
+// src/lib/manifest.ts
+var SCROLL_PLUGIN_ID = "scroll";
+var manifest = {
+  id: SCROLL_PLUGIN_ID,
+  name: "Scroll Plugin",
+  version: "1.0.0",
+  provides: ["scroll"],
+  requires: ["viewport"],
+  optional: [],
+  defaultConfig: {
+    enabled: true,
+    pageGap: 10
+  }
+};
+
+// src/lib/reducer.ts
+var import_core2 = require("@embedpdf/core");
+var defaultScrollMetrics = {
+  currentPage: 1,
+  visiblePages: [],
+  pageVisibilityMetrics: [],
+  renderedPageIndexes: [],
+  scrollOffset: { x: 0, y: 0 },
+  startSpacing: 0,
+  endSpacing: 0
+};
+var initialState = (coreState, config) => ({
+  virtualItems: [],
+  totalContentSize: { width: 0, height: 0 },
+  desiredScrollPosition: { x: 0, y: 0 },
+  strategy: config.strategy ?? "vertical" /* Vertical */,
+  pageGap: config.pageGap ?? 10,
+  scale: coreState.scale,
+  ...defaultScrollMetrics
+});
+var scrollReducer = (state, action) => {
+  switch (action.type) {
+    case import_core2.SET_SCALE:
+      return { ...state, scale: action.payload };
+    case UPDATE_SCROLL_STATE:
+      return { ...state, ...action.payload };
+    case SET_DESIRED_SCROLL_POSITION:
+      return { ...state, desiredScrollPosition: action.payload };
+    default:
+      return state;
+  }
+};
+
+// src/lib/index.ts
+var ScrollPluginPackage = {
+  manifest,
+  create: (registry, _engine, config) => new ScrollPlugin(SCROLL_PLUGIN_ID, registry, config),
+  reducer: scrollReducer,
+  initialState: (coreState, config) => initialState(coreState, config)
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SCROLL_PLUGIN_ID,
+  ScrollPlugin,
+  ScrollPluginPackage,
+  ScrollStrategy,
+  manifest
+});
+//# sourceMappingURL=index.cjs.map