@embedpdf/plugin-interaction-manager 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 CloudPDF
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-EJ7FVBFM.js

@@ -0,0 +1,62 @@
+// src/shared/utils.ts
+function createPointerProvider(cap, scope, element, convertEventToPoint) {
+  let active = cap.getHandlersForScope(scope);
+  const stopMode = cap.onModeChange(() => {
+    if (scope.type === "global") {
+      const mode = cap.getActiveInteractionMode();
+      element.style.cursor = mode?.scope === "global" ? mode.cursor ?? "auto" : "auto";
+    }
+    active = cap.getHandlersForScope(scope);
+  });
+  const stopHandler = cap.onHandlerChange(() => {
+    active = cap.getHandlersForScope(scope);
+  });
+  const modeNow = cap.getActiveInteractionMode();
+  const cursorNow = cap.getCurrentCursor();
+  if (scope.type === "global") {
+    element.style.cursor = modeNow?.scope === "global" ? cursorNow : "auto";
+  } else {
+    element.style.cursor = cursorNow;
+  }
+  const stopCursor = cap.onCursorChange((c) => {
+    if (scope.type === "global") {
+      const isGlobalMode = cap.getActiveInteractionMode()?.scope === "global";
+      if (!isGlobalMode) return;
+    }
+    element.style.cursor = c;
+  });
+  const domEvent = {
+    onPointerDown: "pointerdown",
+    onPointerUp: "pointerup",
+    onPointerMove: "pointermove",
+    onPointerEnter: "pointerenter",
+    onPointerLeave: "pointerleave",
+    onPointerCancel: "pointercancel"
+  };
+  const listeners = {};
+  const toPos = (e, host) => {
+    if (convertEventToPoint) return convertEventToPoint(e, host);
+    const r = host.getBoundingClientRect();
+    return { x: e.clientX - r.left, y: e.clientY - r.top };
+  };
+  Object.keys(domEvent).forEach((k) => {
+    listeners[k] = (evt) => {
+      const pe = evt;
+      active?.[k]?.(toPos(pe, element), pe);
+    };
+    element.addEventListener(domEvent[k], listeners[k]);
+  });
+  return () => {
+    Object.keys(domEvent).forEach(
+      (k) => element.removeEventListener(domEvent[k], listeners[k])
+    );
+    stopMode();
+    stopCursor();
+    stopHandler();
+  };
+}
+
+export {
+  createPointerProvider
+};
+//# sourceMappingURL=chunk-EJ7FVBFM.js.map

package/dist/chunk-EJ7FVBFM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/utils.ts"],"sourcesContent":["import { Position } from '@embedpdf/models';\nimport type {\n  InteractionManagerCapability,\n  InteractionScope,\n  PointerEventHandlers,\n} from '@embedpdf/plugin-interaction-manager';\n\n/**\n * Hook one DOM element into the interaction-manager.\n *  – keeps handlers & cursor in-sync with the current mode\n *  – returns a teardown fn for React/Preact effects\n */\nexport function createPointerProvider(\n  cap: InteractionManagerCapability,\n  scope: InteractionScope,\n  element: HTMLElement,\n  convertEventToPoint?: (evt: PointerEvent, host: HTMLElement) => Position,\n) {\n  /* ------------------------------------------------------------------ */\n  /* active handler set – hot-swapped on every mode change              */\n  /* ------------------------------------------------------------------ */\n  let active: PointerEventHandlers | null = cap.getHandlersForScope(scope);\n\n  const stopMode = cap.onModeChange(() => {\n    if (scope.type === 'global') {\n      const mode = cap.getActiveInteractionMode();\n      element.style.cursor = mode?.scope === 'global' ? (mode.cursor ?? 'auto') : 'auto';\n    }\n    active = cap.getHandlersForScope(scope);\n  });\n\n  const stopHandler = cap.onHandlerChange(() => {\n    active = cap.getHandlersForScope(scope);\n  });\n\n  /* ------------------------------------------------------------------ */\n  /* cursor                                                             */\n  /* ------------------------------------------------------------------ */\n  const modeNow = cap.getActiveInteractionMode();\n  const cursorNow = cap.getCurrentCursor();\n\n  /** initial cursor -------------------------------------------------- */\n  if (scope.type === 'global') {\n    // global wrapper only shows the cursor while a *global* mode is active\n    element.style.cursor = modeNow?.scope === 'global' ? cursorNow : 'auto';\n  } else {\n    // page wrappers always mirror the latest cursor\n    element.style.cursor = cursorNow;\n  }\n\n  const stopCursor = cap.onCursorChange((c) => {\n    /**  ❖  Propagation rule\n     *      ─────────────────\n     *   • global provider updates its cursor *only* while the active\n     *     mode itself is ‘global’.\n     *   • page providers always sync (so they show the cursor during\n     *     a global mode as well). */\n    if (scope.type === 'global') {\n      const isGlobalMode = cap.getActiveInteractionMode()?.scope === 'global';\n      if (!isGlobalMode) return; // active mode is page-scoped → ignore\n    }\n    element.style.cursor = c;\n  });\n\n  /* ------------------------------------------------------------------ */\n  /* event wiring                                                       */\n  /* ------------------------------------------------------------------ */\n  type K = keyof PointerEventHandlers;\n  const domEvent: Record<K, keyof HTMLElementEventMap> = {\n    onPointerDown: 'pointerdown',\n    onPointerUp: 'pointerup',\n    onPointerMove: 'pointermove',\n    onPointerEnter: 'pointerenter',\n    onPointerLeave: 'pointerleave',\n    onPointerCancel: 'pointercancel',\n  };\n\n  /* one stable EventListener per key -> needed for removeEventListener */\n  const listeners: Partial<Record<K, EventListener>> = {};\n\n  const toPos = (e: PointerEvent, host: HTMLElement): Position => {\n    if (convertEventToPoint) return convertEventToPoint(e, host);\n    const r = host.getBoundingClientRect();\n    return { x: e.clientX - r.left, y: e.clientY - r.top };\n  };\n\n  (Object.keys(domEvent) as K[]).forEach((k) => {\n    listeners[k] = (evt: Event) => {\n      const pe = evt as PointerEvent; // safe – we only attach to pointer*\n      active?.[k]?.(toPos(pe, element), pe);\n      /* if you need to stop default behaviour when no handler is active:\n       * if (!active?.[k]) pe.preventDefault(); */\n    };\n    element.addEventListener(domEvent[k], listeners[k]!);\n  });\n\n  /* ------------------------------------------------------------------ */\n  /* teardown                                                           */\n  /* ------------------------------------------------------------------ */\n  return () => {\n    (Object.keys(domEvent) as K[]).forEach((k) =>\n      element.removeEventListener(domEvent[k], listeners[k]!),\n    );\n    stopMode();\n    stopCursor();\n    stopHandler();\n  };\n}\n"],"mappings":";AAYO,SAAS,sBACd,KACA,OACA,SACA,qBACA;AAIA,MAAI,SAAsC,IAAI,oBAAoB,KAAK;AAEvE,QAAM,WAAW,IAAI,aAAa,MAAM;AACtC,QAAI,MAAM,SAAS,UAAU;AAC3B,YAAM,OAAO,IAAI,yBAAyB;AAC1C,cAAQ,MAAM,SAAS,MAAM,UAAU,WAAY,KAAK,UAAU,SAAU;AAAA,IAC9E;AACA,aAAS,IAAI,oBAAoB,KAAK;AAAA,EACxC,CAAC;AAED,QAAM,cAAc,IAAI,gBAAgB,MAAM;AAC5C,aAAS,IAAI,oBAAoB,KAAK;AAAA,EACxC,CAAC;AAKD,QAAM,UAAU,IAAI,yBAAyB;AAC7C,QAAM,YAAY,IAAI,iBAAiB;AAGvC,MAAI,MAAM,SAAS,UAAU;AAE3B,YAAQ,MAAM,SAAS,SAAS,UAAU,WAAW,YAAY;AAAA,EACnE,OAAO;AAEL,YAAQ,MAAM,SAAS;AAAA,EACzB;AAEA,QAAM,aAAa,IAAI,eAAe,CAAC,MAAM;AAO3C,QAAI,MAAM,SAAS,UAAU;AAC3B,YAAM,eAAe,IAAI,yBAAyB,GAAG,UAAU;AAC/D,UAAI,CAAC,aAAc;AAAA,IACrB;AACA,YAAQ,MAAM,SAAS;AAAA,EACzB,CAAC;AAMD,QAAM,WAAiD;AAAA,IACrD,eAAe;AAAA,IACf,aAAa;AAAA,IACb,eAAe;AAAA,IACf,gBAAgB;AAAA,IAChB,gBAAgB;AAAA,IAChB,iBAAiB;AAAA,EACnB;AAGA,QAAM,YAA+C,CAAC;AAEtD,QAAM,QAAQ,CAAC,GAAiB,SAAgC;AAC9D,QAAI,oBAAqB,QAAO,oBAAoB,GAAG,IAAI;AAC3D,UAAM,IAAI,KAAK,sBAAsB;AACrC,WAAO,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,GAAG,EAAE,UAAU,EAAE,IAAI;AAAA,EACvD;AAEA,EAAC,OAAO,KAAK,QAAQ,EAAU,QAAQ,CAAC,MAAM;AAC5C,cAAU,CAAC,IAAI,CAAC,QAAe;AAC7B,YAAM,KAAK;AACX,eAAS,CAAC,IAAI,MAAM,IAAI,OAAO,GAAG,EAAE;AAAA,IAGtC;AACA,YAAQ,iBAAiB,SAAS,CAAC,GAAG,UAAU,CAAC,CAAE;AAAA,EACrD,CAAC;AAKD,SAAO,MAAM;AACX,IAAC,OAAO,KAAK,QAAQ,EAAU;AAAA,MAAQ,CAAC,MACtC,QAAQ,oBAAoB,SAAS,CAAC,GAAG,UAAU,CAAC,CAAE;AAAA,IACxD;AACA,aAAS;AACT,eAAW;AACX,gBAAY;AAAA,EACd;AACF;","names":[]}

package/dist/index.cjs

@@ -0,0 +1,260 @@
+"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, {
+  INTERACTION_MANAGER_PLUGIN_ID: () => INTERACTION_MANAGER_PLUGIN_ID,
+  InteractionManagerPlugin: () => InteractionManagerPlugin,
+  InteractionManagerPluginPackage: () => InteractionManagerPluginPackage,
+  manifest: () => manifest
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lib/interaction-manager-plugin.ts
+var import_core = require("@embedpdf/core");
+
+// src/lib/actions.ts
+var ACTIVATE_MODE = "INTERACTION/ACTIVATE_MODE";
+var activateMode = (mode) => ({
+  type: ACTIVATE_MODE,
+  payload: { mode }
+});
+var SET_CURSOR = "INTERACTION/SET_CURSOR";
+var setCursor = (cursor) => ({
+  type: SET_CURSOR,
+  payload: { cursor }
+});
+
+// src/lib/helper.ts
+function mergeHandlers(list) {
+  const keys = [
+    "onPointerDown",
+    "onPointerUp",
+    "onPointerMove",
+    "onPointerEnter",
+    "onPointerLeave",
+    "onPointerCancel"
+  ];
+  const out = {};
+  for (const k of keys) {
+    out[k] = (evt, nativeEvt) => {
+      for (const h of list) h[k]?.(evt, nativeEvt);
+    };
+  }
+  return out;
+}
+
+// src/lib/interaction-manager-plugin.ts
+var InteractionManagerPlugin = class extends import_core.BasePlugin {
+  constructor(id, registry) {
+    super(id, registry);
+    this.modes = /* @__PURE__ */ new Map();
+    this.cursorClaims = /* @__PURE__ */ new Map();
+    this.buckets = /* @__PURE__ */ new Map();
+    this.alwaysGlobal = /* @__PURE__ */ new Set();
+    this.alwaysPage = /* @__PURE__ */ new Map();
+    this.onModeChange$ = (0, import_core.createEmitter)();
+    this.onHandlerChange$ = (0, import_core.createEmitter)();
+    this.onCursorChange$ = (0, import_core.createEmitter)();
+    this.registerMode({
+      id: "default",
+      scope: "page",
+      exclusive: false,
+      cursor: "auto"
+    });
+  }
+  async initialize(_) {
+  }
+  buildCapability() {
+    return {
+      activate: (modeId) => this.activate(modeId),
+      onModeChange: this.onModeChange$.on,
+      onCursorChange: this.onCursorChange$.on,
+      onHandlerChange: this.onHandlerChange$.on,
+      getActiveMode: () => this.state.activeMode,
+      getActiveInteractionMode: () => this.getActiveInteractionMode(),
+      finish: () => this.activate("default"),
+      registerMode: (mode) => this.registerMode(mode),
+      registerHandlers: (options) => this.registerHandlers(options),
+      registerAlways: (options) => this.registerAlways(options),
+      setCursor: (token, cursor, priority = 0) => this.setCursor(token, cursor, priority),
+      removeCursor: (token) => this.removeCursor(token),
+      getCurrentCursor: () => this.state.cursor,
+      getHandlersForScope: (scope) => this.getHandlersForScope(scope),
+      activeModeIsExclusive: () => this.activeModeIsExclusive()
+    };
+  }
+  activate(mode) {
+    if (!this.modes.has(mode)) {
+      throw new Error(`[interaction] unknown mode '${mode}'`);
+    }
+    if (mode === this.state.activeMode) return;
+    this.cursorClaims.clear();
+    this.dispatch(activateMode(mode));
+    this.emitCursor();
+    this.onModeChange$.emit({ ...this.state, activeMode: mode });
+  }
+  registerMode(mode) {
+    this.modes.set(mode.id, mode);
+    if (!this.buckets.has(mode.id)) {
+      this.buckets.set(mode.id, { global: /* @__PURE__ */ new Set(), page: /* @__PURE__ */ new Map() });
+    }
+  }
+  /** ---------- pointer-handler handling ------------ */
+  registerHandlers({
+    modeId,
+    handlers,
+    pageIndex
+  }) {
+    const bucket = this.buckets.get(modeId);
+    if (!bucket) throw new Error(`unknown mode '${modeId}'`);
+    if (pageIndex == null) {
+      bucket.global.add(handlers);
+      this.onHandlerChange$.emit({ ...this.state });
+      return () => bucket.global.delete(handlers);
+    }
+    const set = bucket.page.get(pageIndex) ?? /* @__PURE__ */ new Set();
+    set.add(handlers);
+    bucket.page.set(pageIndex, set);
+    this.onHandlerChange$.emit({ ...this.state });
+    return () => {
+      set.delete(handlers);
+      this.onHandlerChange$.emit({ ...this.state });
+    };
+  }
+  registerAlways({ scope, handlers }) {
+    if (scope.type === "global") {
+      this.alwaysGlobal.add(handlers);
+      this.onHandlerChange$.emit({ ...this.state });
+      return () => this.alwaysGlobal.delete(handlers);
+    }
+    const set = this.alwaysPage.get(scope.pageIndex) ?? /* @__PURE__ */ new Set();
+    set.add(handlers);
+    this.alwaysPage.set(scope.pageIndex, set);
+    this.onHandlerChange$.emit({ ...this.state });
+    return () => {
+      set.delete(handlers);
+      this.onHandlerChange$.emit({ ...this.state });
+    };
+  }
+  /** Returns the *merged* handler set that should be active for the given
+   *  provider (`global` wrapper or a single page wrapper).
+   *  – `alwaysGlobal` / `alwaysPage` are **always** active.
+   *  – Handlers that belong to the current mode are added on top **iff**
+   *    the mode’s own scope matches the provider’s scope.            */
+  getHandlersForScope(scope) {
+    const mode = this.modes.get(this.state.activeMode);
+    if (!mode) return null;
+    const bucket = this.buckets.get(mode.id);
+    if (!bucket) return null;
+    const mergeSets = (a, b) => a.size || b.size ? mergeHandlers([...a, ...b]) : null;
+    if (scope.type === "global") {
+      const modeSpecific = mode.scope === "global" ? bucket.global : /* @__PURE__ */ new Set();
+      return mergeSets(this.alwaysGlobal, modeSpecific);
+    }
+    const alwaysPageSet = this.alwaysPage.get(scope.pageIndex) ?? /* @__PURE__ */ new Set();
+    const modePageSet = mode.scope === "page" ? bucket.page.get(scope.pageIndex) ?? /* @__PURE__ */ new Set() : /* @__PURE__ */ new Set();
+    return mergeSets(alwaysPageSet, modePageSet);
+  }
+  /** ---------- cursor handling --------------------- */
+  setCursor(token, cursor, priority = 0) {
+    this.cursorClaims.set(token, { cursor, priority });
+    this.emitCursor();
+  }
+  removeCursor(token) {
+    this.cursorClaims.delete(token);
+    this.emitCursor();
+  }
+  emitCursor() {
+    const top = [...this.cursorClaims.values()].sort((a, b) => b.priority - a.priority)[0] ?? {
+      cursor: this.modes.get(this.state.activeMode)?.cursor ?? "auto"
+    };
+    if (top.cursor !== this.state.cursor) {
+      this.dispatch(setCursor(top.cursor));
+      this.onCursorChange$.emit(top.cursor);
+    }
+  }
+  activeModeIsExclusive() {
+    const mode = this.modes.get(this.state.activeMode);
+    return !!mode?.exclusive;
+  }
+  getActiveInteractionMode() {
+    return this.modes.get(this.state.activeMode) ?? null;
+  }
+  // keep emitter clean
+  async destroy() {
+    this.onModeChange$.clear();
+    this.onCursorChange$.clear();
+    await super.destroy();
+  }
+};
+InteractionManagerPlugin.id = "interaction-manager";
+
+// src/lib/manifest.ts
+var INTERACTION_MANAGER_PLUGIN_ID = "interaction-manager";
+var manifest = {
+  id: INTERACTION_MANAGER_PLUGIN_ID,
+  name: "Interaction Manager Plugin",
+  version: "1.0.0",
+  provides: ["interaction-manager"],
+  requires: [],
+  optional: [],
+  defaultConfig: {
+    enabled: true
+  }
+};
+
+// src/lib/reducer.ts
+var initialState = {
+  activeMode: "default",
+  cursor: "auto"
+};
+var reducer = (state, action) => {
+  switch (action.type) {
+    case ACTIVATE_MODE:
+      return {
+        ...state,
+        activeMode: action.payload.mode
+      };
+    case SET_CURSOR:
+      return {
+        ...state,
+        cursor: action.payload.cursor
+      };
+    default:
+      return state;
+  }
+};
+
+// src/lib/index.ts
+var InteractionManagerPluginPackage = {
+  manifest,
+  create: (registry) => new InteractionManagerPlugin(INTERACTION_MANAGER_PLUGIN_ID, registry),
+  reducer,
+  initialState
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INTERACTION_MANAGER_PLUGIN_ID,
+  InteractionManagerPlugin,
+  InteractionManagerPluginPackage,
+  manifest
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/lib/interaction-manager-plugin.ts","../src/lib/actions.ts","../src/lib/helper.ts","../src/lib/manifest.ts","../src/lib/reducer.ts","../src/lib/index.ts"],"sourcesContent":["export * from './lib';\n","import { BasePlugin, createEmitter, PluginRegistry } from '@embedpdf/core';\n\nimport {\n  InteractionManagerCapability,\n  InteractionManagerPluginConfig,\n  InteractionManagerState,\n  InteractionMode,\n  InteractionScope,\n  PointerEventHandlers,\n  RegisterAlwaysOptions,\n  RegisterHandlersOptions,\n} from './types';\nimport { activateMode, setCursor } from './actions';\nimport { mergeHandlers } from './helper';\n\ninterface CursorClaim {\n  cursor: string;\n  priority: number;\n}\n\ntype HandlerSet = Set<PointerEventHandlers>;\ntype PageHandlerMap = Map<number /*pageIdx*/, HandlerSet>;\n\ninterface ModeBuckets {\n  /** handlers that listen on the global wrapper (only once per viewer) */\n  global: HandlerSet;\n  /** handlers that listen on a *specific* page wrapper */\n  page: PageHandlerMap;\n}\n\nexport class InteractionManagerPlugin extends BasePlugin<\n  InteractionManagerPluginConfig,\n  InteractionManagerCapability,\n  InteractionManagerState\n> {\n  static readonly id = 'interaction-manager' as const;\n\n  private modes = new Map<string, InteractionMode>();\n  private cursorClaims = new Map<string, CursorClaim>();\n  private buckets = new Map<string, ModeBuckets>();\n\n  private alwaysGlobal = new Set<PointerEventHandlers>();\n  private alwaysPage = new Map<number, Set<PointerEventHandlers>>();\n\n  private readonly onModeChange$ = createEmitter<InteractionManagerState>();\n  private readonly onHandlerChange$ = createEmitter<InteractionManagerState>();\n  private readonly onCursorChange$ = createEmitter<string>();\n\n  constructor(id: string, registry: PluginRegistry) {\n    super(id, registry);\n\n    this.registerMode({\n      id: 'default',\n      scope: 'page',\n      exclusive: false,\n      cursor: 'auto',\n    });\n  }\n\n  async initialize(_: InteractionManagerPluginConfig): Promise<void> {}\n\n  protected buildCapability(): InteractionManagerCapability {\n    return {\n      activate: (modeId: string) => this.activate(modeId),\n      onModeChange: this.onModeChange$.on,\n      onCursorChange: this.onCursorChange$.on,\n      onHandlerChange: this.onHandlerChange$.on,\n      getActiveMode: () => this.state.activeMode,\n      getActiveInteractionMode: () => this.getActiveInteractionMode(),\n      finish: () => this.activate('default'),\n      registerMode: (mode: InteractionMode) => this.registerMode(mode),\n      registerHandlers: (options: RegisterHandlersOptions) => this.registerHandlers(options),\n      registerAlways: (options: RegisterAlwaysOptions) => this.registerAlways(options),\n      setCursor: (token: string, cursor: string, priority = 0) =>\n        this.setCursor(token, cursor, priority),\n      removeCursor: (token: string) => this.removeCursor(token),\n      getCurrentCursor: () => this.state.cursor,\n      getHandlersForScope: (scope: InteractionScope) => this.getHandlersForScope(scope),\n      activeModeIsExclusive: () => this.activeModeIsExclusive(),\n    };\n  }\n\n  private activate(mode: string) {\n    if (!this.modes.has(mode)) {\n      throw new Error(`[interaction] unknown mode '${mode}'`);\n    }\n    if (mode === this.state.activeMode) return;\n\n    this.cursorClaims.clear(); // prevent cursor leaks\n\n    this.dispatch(activateMode(mode));\n    this.emitCursor();\n    this.onModeChange$.emit({ ...this.state, activeMode: mode });\n  }\n\n  private registerMode(mode: InteractionMode) {\n    this.modes.set(mode.id, mode);\n    if (!this.buckets.has(mode.id)) {\n      this.buckets.set(mode.id, { global: new Set(), page: new Map() });\n    }\n  }\n\n  /** ---------- pointer-handler handling ------------ */\n  private registerHandlers({\n    modeId,\n    handlers,\n    pageIndex,\n  }: {\n    modeId: string;\n    handlers: PointerEventHandlers;\n    pageIndex?: number;\n  }): () => void {\n    const bucket = this.buckets.get(modeId);\n    if (!bucket) throw new Error(`unknown mode '${modeId}'`);\n    if (pageIndex == null) {\n      bucket.global.add(handlers);\n      this.onHandlerChange$.emit({ ...this.state });\n      return () => bucket.global.delete(handlers);\n    }\n    const set = bucket.page.get(pageIndex) ?? new Set();\n    set.add(handlers);\n    bucket.page.set(pageIndex, set);\n    this.onHandlerChange$.emit({ ...this.state });\n    return () => {\n      set.delete(handlers);\n      this.onHandlerChange$.emit({ ...this.state });\n    };\n  }\n\n  public registerAlways({ scope, handlers }: RegisterAlwaysOptions): () => void {\n    if (scope.type === 'global') {\n      this.alwaysGlobal.add(handlers);\n      this.onHandlerChange$.emit({ ...this.state });\n      return () => this.alwaysGlobal.delete(handlers);\n    }\n    const set = this.alwaysPage.get(scope.pageIndex) ?? new Set();\n    set.add(handlers);\n    this.alwaysPage.set(scope.pageIndex, set);\n    this.onHandlerChange$.emit({ ...this.state });\n    return () => {\n      set.delete(handlers);\n      this.onHandlerChange$.emit({ ...this.state });\n    };\n  }\n\n  /** Returns the *merged* handler set that should be active for the given\n   *  provider (`global` wrapper or a single page wrapper).\n   *  – `alwaysGlobal` / `alwaysPage` are **always** active.\n   *  – Handlers that belong to the current mode are added on top **iff**\n   *    the mode’s own scope matches the provider’s scope.            */\n  private getHandlersForScope(scope: InteractionScope): PointerEventHandlers | null {\n    const mode = this.modes.get(this.state.activeMode);\n    if (!mode) return null;\n\n    const bucket = this.buckets.get(mode.id);\n    if (!bucket) return null;\n\n    /** helper – merge two handler sets into one object (or `null` if both are empty) */\n    const mergeSets = (a: HandlerSet, b: HandlerSet) =>\n      a.size || b.size ? mergeHandlers([...a, ...b]) : null;\n\n    /* ─────────────────────  GLOBAL PROVIDER  ─────────────────────── */\n    if (scope.type === 'global') {\n      const modeSpecific =\n        mode.scope === 'global' // only include mode handlers if the\n          ? bucket.global // mode itself is global-scoped\n          : new Set<PointerEventHandlers>();\n      return mergeSets(this.alwaysGlobal, modeSpecific);\n    }\n\n    /* ───────────────────────  PAGE PROVIDER  ──────────────────────── */\n    const alwaysPageSet = this.alwaysPage.get(scope.pageIndex) ?? new Set<PointerEventHandlers>();\n    const modePageSet =\n      mode.scope === 'page'\n        ? (bucket.page.get(scope.pageIndex) ?? new Set<PointerEventHandlers>())\n        : new Set<PointerEventHandlers>(); // global-scoped mode → ignore page buckets\n\n    return mergeSets(alwaysPageSet, modePageSet);\n  }\n\n  /** ---------- cursor handling --------------------- */\n  private setCursor(token: string, cursor: string, priority = 0) {\n    this.cursorClaims.set(token, { cursor, priority });\n    this.emitCursor();\n  }\n  private removeCursor(token: string) {\n    this.cursorClaims.delete(token);\n    this.emitCursor();\n  }\n\n  private emitCursor() {\n    /* pick highest priority claim, else mode baseline */\n    const top = [...this.cursorClaims.values()].sort((a, b) => b.priority - a.priority)[0] ?? {\n      cursor: this.modes.get(this.state.activeMode)?.cursor ?? 'auto',\n    };\n\n    if (top.cursor !== this.state.cursor) {\n      this.dispatch(setCursor(top.cursor));\n      this.onCursorChange$.emit(top.cursor);\n    }\n  }\n\n  private activeModeIsExclusive(): boolean {\n    const mode = this.modes.get(this.state.activeMode);\n    return !!mode?.exclusive;\n  }\n\n  private getActiveInteractionMode(): InteractionMode | null {\n    return this.modes.get(this.state.activeMode) ?? null;\n  }\n\n  // keep emitter clean\n  async destroy(): Promise<void> {\n    this.onModeChange$.clear();\n    this.onCursorChange$.clear();\n    await super.destroy();\n  }\n}\n","import { Action } from '@embedpdf/core';\nimport { InteractionScope } from './types';\n\nexport const ACTIVATE_MODE = 'INTERACTION/ACTIVATE_MODE';\n\nexport interface ActivateModeAction extends Action {\n  type: typeof ACTIVATE_MODE;\n  payload: { mode: string };\n}\n\nexport const activateMode = (mode: string): ActivateModeAction => ({\n  type: ACTIVATE_MODE,\n  payload: { mode },\n});\n\nexport const SET_CURSOR = 'INTERACTION/SET_CURSOR';\nexport interface SetCursorAction extends Action {\n  type: typeof SET_CURSOR;\n  payload: { cursor: string };\n}\nexport const setCursor = (cursor: string): SetCursorAction => ({\n  type: SET_CURSOR,\n  payload: { cursor },\n});\n\nexport type InteractionManagerAction = ActivateModeAction | SetCursorAction;\n","import { PointerEventHandlers } from './types';\n\nexport function mergeHandlers(list: PointerEventHandlers[]): PointerEventHandlers {\n  const keys: (keyof PointerEventHandlers)[] = [\n    'onPointerDown',\n    'onPointerUp',\n    'onPointerMove',\n    'onPointerEnter',\n    'onPointerLeave',\n    'onPointerCancel',\n  ];\n  const out: Partial<PointerEventHandlers> = {};\n  for (const k of keys) {\n    out[k] = (evt: any, nativeEvt: any) => {\n      for (const h of list) h[k]?.(evt, nativeEvt);\n    };\n  }\n  return out as PointerEventHandlers;\n}\n","import { PluginManifest } from '@embedpdf/core';\nimport { InteractionManagerPluginConfig } from './types';\n\nexport const INTERACTION_MANAGER_PLUGIN_ID = 'interaction-manager';\n\nexport const manifest: PluginManifest<InteractionManagerPluginConfig> = {\n  id: INTERACTION_MANAGER_PLUGIN_ID,\n  name: 'Interaction Manager Plugin',\n  version: '1.0.0',\n  provides: ['interaction-manager'],\n  requires: [],\n  optional: [],\n  defaultConfig: {\n    enabled: true,\n  },\n};\n","import { Reducer } from '@embedpdf/core';\nimport { ACTIVATE_MODE, InteractionManagerAction, SET_CURSOR } from './actions';\nimport { InteractionManagerState } from './types';\n\nexport const initialState: InteractionManagerState = {\n  activeMode: 'default',\n  cursor: 'auto',\n};\n\nexport const reducer: Reducer<InteractionManagerState, InteractionManagerAction> = (\n  state,\n  action,\n) => {\n  switch (action.type) {\n    case ACTIVATE_MODE:\n      return {\n        ...state,\n        activeMode: action.payload.mode,\n      };\n    case SET_CURSOR:\n      return {\n        ...state,\n        cursor: action.payload.cursor,\n      };\n    default:\n      return state;\n  }\n};\n","import { PluginPackage } from '@embedpdf/core';\n\nimport { InteractionManagerPlugin } from './interaction-manager-plugin';\nimport { manifest, INTERACTION_MANAGER_PLUGIN_ID } from './manifest';\nimport { InteractionManagerPluginConfig, InteractionManagerState } from './types';\nimport { reducer, initialState } from './reducer';\nimport { InteractionManagerAction } from './actions';\n\nexport const InteractionManagerPluginPackage: PluginPackage<\n  InteractionManagerPlugin,\n  InteractionManagerPluginConfig,\n  InteractionManagerState,\n  InteractionManagerAction\n> = {\n  manifest,\n  create: (registry) => new InteractionManagerPlugin(INTERACTION_MANAGER_PLUGIN_ID, registry),\n  reducer,\n  initialState,\n};\n\nexport * from './interaction-manager-plugin';\nexport * from './types';\nexport * from './manifest';\n"],"mappings":"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","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,148 @@
+import { BasePluginConfig, EventHook, BasePlugin, PluginRegistry, Action, PluginManifest, PluginPackage } from '@embedpdf/core';
+import { Position } from '@embedpdf/models';
+
+interface InteractionManagerPluginConfig extends BasePluginConfig {
+}
+interface InteractionManagerState {
+    /** Mode-id that is currently active (e.g. `"default"` or `"annotationCreation"`). */
+    activeMode: string;
+    /** Cursor that is currently active (e.g. `"auto"` or `"pointer"`). */
+    cursor: string;
+}
+interface InteractionMode {
+    /** unique id */
+    id: string;
+    /** where the handlers should listen for events */
+    scope: 'global' | 'page';
+    /** if true the page will receive events through a transparent overlay and no other page‑level
+     *  listener gets invoked until the mode finishes. */
+    exclusive: boolean;
+    /** baseline cursor while the mode is active (before any handler overrides it). */
+    cursor?: string;
+}
+interface EmbedPdfPointerEvent {
+    clientX: number;
+    clientY: number;
+    ctrlKey: boolean;
+    shiftKey: boolean;
+    altKey: boolean;
+    metaKey: boolean;
+}
+interface PointerEventHandlers<T = EmbedPdfPointerEvent> {
+    onPointerDown?(pos: Position, evt: T): void;
+    onPointerUp?(pos: Position, evt: T): void;
+    onPointerMove?(pos: Position, evt: T): void;
+    onPointerEnter?(pos: Position, evt: T): void;
+    onPointerLeave?(pos: Position, evt: T): void;
+    onPointerCancel?(pos: Position, evt: T): void;
+}
+interface GlobalInteractionScope {
+    type: 'global';
+}
+interface PageInteractionScope {
+    type: 'page';
+    pageIndex: number;
+}
+type InteractionScope = GlobalInteractionScope | PageInteractionScope;
+interface RegisterHandlersOptions {
+    /** the mode the handlers belong to                     */
+    modeId: string;
+    /** callbacks                                            */
+    handlers: PointerEventHandlers;
+    /** if omitted ⇒ handlers listen on the *global* layer   */
+    pageIndex?: number;
+}
+interface RegisterAlwaysOptions {
+    scope: InteractionScope;
+    handlers: PointerEventHandlers;
+}
+interface InteractionManagerCapability {
+    /** returns the active mode id */
+    getActiveMode(): string;
+    /** returns the active interaction mode */
+    getActiveInteractionMode(): InteractionMode | null;
+    /** programmatically switch to a mode */
+    activate(modeId: string): void;
+    /** finish current mode -> jumps back to `default` */
+    finish(): void;
+    /** register a mode (should be called at start‑up by each plugin/tool). */
+    registerMode(mode: InteractionMode): void;
+    /** register pointer handlers that run *only* while the given mode is active. */
+    registerHandlers(options: RegisterHandlersOptions): () => void;
+    /** register pointer handlers that run *always* (even if no mode is active). */
+    registerAlways(options: RegisterAlwaysOptions): () => void;
+    /** low‑level cursor API. Handlers can claim the cursor with a priority (larger wins). */
+    setCursor(token: string, cursor: string, priority?: number): void;
+    /** Returns the current cursor */
+    getCurrentCursor(): string;
+    /** remove a cursor */
+    removeCursor(token: string): void;
+    /** subscribe to mode changes (so framework layers can raise overlays, etc.) */
+    onModeChange: EventHook<InteractionManagerState>;
+    /** subscribe to cursor changes */
+    onCursorChange: EventHook<string>;
+    /** subscribe to handler changes */
+    onHandlerChange: EventHook<InteractionManagerState>;
+    /** framework helpers -------------------------------------------------------------- */
+    /** Returns the *merged* handler set for the current mode + given scope.
+     *  Used by the PointerInteractionProvider inside each page / at the root. */
+    getHandlersForScope(scope: InteractionScope): PointerEventHandlers | null;
+    /** Returns whether the current active mode demands an overlay */
+    activeModeIsExclusive(): boolean;
+}
+
+declare class InteractionManagerPlugin extends BasePlugin<InteractionManagerPluginConfig, InteractionManagerCapability, InteractionManagerState> {
+    static readonly id: "interaction-manager";
+    private modes;
+    private cursorClaims;
+    private buckets;
+    private alwaysGlobal;
+    private alwaysPage;
+    private readonly onModeChange$;
+    private readonly onHandlerChange$;
+    private readonly onCursorChange$;
+    constructor(id: string, registry: PluginRegistry);
+    initialize(_: InteractionManagerPluginConfig): Promise<void>;
+    protected buildCapability(): InteractionManagerCapability;
+    private activate;
+    private registerMode;
+    /** ---------- pointer-handler handling ------------ */
+    private registerHandlers;
+    registerAlways({ scope, handlers }: RegisterAlwaysOptions): () => void;
+    /** Returns the *merged* handler set that should be active for the given
+     *  provider (`global` wrapper or a single page wrapper).
+     *  – `alwaysGlobal` / `alwaysPage` are **always** active.
+     *  – Handlers that belong to the current mode are added on top **iff**
+     *    the mode’s own scope matches the provider’s scope.            */
+    private getHandlersForScope;
+    /** ---------- cursor handling --------------------- */
+    private setCursor;
+    private removeCursor;
+    private emitCursor;
+    private activeModeIsExclusive;
+    private getActiveInteractionMode;
+    destroy(): Promise<void>;
+}
+
+declare const ACTIVATE_MODE = "INTERACTION/ACTIVATE_MODE";
+interface ActivateModeAction extends Action {
+    type: typeof ACTIVATE_MODE;
+    payload: {
+        mode: string;
+    };
+}
+declare const SET_CURSOR = "INTERACTION/SET_CURSOR";
+interface SetCursorAction extends Action {
+    type: typeof SET_CURSOR;
+    payload: {
+        cursor: string;
+    };
+}
+type InteractionManagerAction = ActivateModeAction | SetCursorAction;
+
+declare const INTERACTION_MANAGER_PLUGIN_ID = "interaction-manager";
+declare const manifest: PluginManifest<InteractionManagerPluginConfig>;
+
+declare const InteractionManagerPluginPackage: PluginPackage<InteractionManagerPlugin, InteractionManagerPluginConfig, InteractionManagerState, InteractionManagerAction>;
+
+export { type EmbedPdfPointerEvent, INTERACTION_MANAGER_PLUGIN_ID, type InteractionManagerCapability, InteractionManagerPlugin, type InteractionManagerPluginConfig, InteractionManagerPluginPackage, type InteractionManagerState, type InteractionMode, type InteractionScope, type PointerEventHandlers, type RegisterAlwaysOptions, type RegisterHandlersOptions, manifest };