@likecoin/epub-ts 0.5.1 → 0.6.0

package/dist/managers/default/index.d.ts

@@ -2,6 +2,7 @@ import { default as Mapping } from '../../mapping';
 import { default as Queue } from '../../utils/queue';
 import { default as Stage } from '../helpers/stage';
 import { default as Views } from '../helpers/views';
+import { default as TextMeasurer } from '../../utils/text-measurer';
 import { default as Layout } from '../../layout';
 import { default as Section } from '../../section';
 import { default as Contents } from '../../contents';
@@ -52,6 +53,7 @@ declare class DefaultViewManager implements IEventEmitter<DefaultManagerEvents>
     overflow: string;
     layout: Layout;
     mapping: Mapping;
+    _measurer: TextMeasurer;
     location: ViewLocation[];
     isPaginated: boolean;
     scrollLeft: number;

package/dist/managers/views/iframe.d.ts

@@ -52,6 +52,7 @@ declare class IframeView implements IEventEmitter<IframeViewEvents> {
     _textHeight: number | undefined;
     _contentWidth: number | undefined;
     _contentHeight: number | undefined;
+    _contentDirty: boolean;
     _needsReframe: boolean;
     _expanding: boolean;
     elementBounds: {

package/dist/mapping.d.ts

@@ -1,6 +1,7 @@
 import { EpubCFIPair, RangePair, LayoutProps } from './types';
 import { default as IframeView } from './managers/views/iframe';
 import { default as Contents } from './contents';
+import { default as TextMeasurer } from './utils/text-measurer';
 /**
  * Map text locations to CFI ranges
  * @class
@@ -14,7 +15,8 @@ declare class Mapping {
     horizontal: boolean;
     direction: string;
     _dev: boolean;
-    constructor(layout: LayoutProps, direction?: string, axis?: string, dev?: boolean);
+    _measurer: TextMeasurer | null;
+    constructor(layout: LayoutProps, direction?: string, axis?: string, dev?: boolean, measurer?: TextMeasurer);
     /**
      * Find CFI pairs for entire section at once
      */
@@ -54,24 +56,39 @@ declare class Mapping {
      * @return {Range}
      */
     findEnd(root: Node, start: number, end: number): Range;
+    /**
+     * Try to prepare a text node's root for canvas-based measurement.
+     * Returns the PreparedNode for this text node, or null if not available.
+     * @private
+     */
+    private _canvasPrepare;
+    /**
+     * Canvas fast path: use binary search on pre-measured cumulative widths
+     * to find a Range at the target position, then verify with one getBoundingClientRect.
+     * Returns the Range if verification passes, or null to fall through to DOM loop.
+     * @private
+     */
+    private _canvasFindRange;
     /**
      * Find Text Start Range
      * @private
-     * @param {Node} root root node
+     * @param {Node} node text node
      * @param {number} start position to start at
      * @param {number} end position to end at
+     * @param {DOMRect} [nodePos] pre-computed node bounds from findStart (avoids redundant reflow)
      * @return {Range}
      */
-    findTextStartRange(node: Node, start: number, end: number): Range;
+    findTextStartRange(node: Node, start: number, end: number, nodePos?: DOMRect): Range;
     /**
      * Find Text End Range
      * @private
-     * @param {Node} root root node
+     * @param {Node} node text node
      * @param {number} start position to start at
      * @param {number} end position to end at
+     * @param {DOMRect} [nodePos] pre-computed node bounds from findEnd (avoids redundant reflow)
      * @return {Range}
      */
-    findTextEndRange(node: Node, start: number, end: number): Range;
+    findTextEndRange(node: Node, start: number, end: number, nodePos?: DOMRect): Range;
     /**
      * Split up a text node into ranges for each word
      * @private

package/dist/utils/text-measurer.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Canvas-based text measurement utility.
+ *
+ * Applies pretext's prepare/layout pattern: expensive measurement is done once
+ * via CanvasRenderingContext2D.measureText(), then layout queries (finding the
+ * character offset at a pixel position) are pure binary-search arithmetic with
+ * zero DOM reflow.
+ *
+ * Browser-only — not imported by the Node.js entry point.
+ */
+export interface TextSegment {
+    /** The text node this segment belongs to */
+    node: Text;
+    /** Character offset within the text node where this segment starts */
+    charOffset: number;
+    /** The segment text content */
+    text: string;
+    /** Measured width of this segment in pixels */
+    width: number;
+    /** Cumulative width from the start of this text node's segment list */
+    cumWidth: number;
+}
+export interface PreparedNode {
+    node: Text;
+    segments: TextSegment[];
+    totalWidth: number;
+    font: string;
+}
+declare class TextMeasurer {
+    private _canvas;
+    private _ctx;
+    /** font string → (text → width), bounded to MAX_WIDTH_CACHE_FONTS entries */
+    private _widthCache;
+    /** parent element → prepared nodes */
+    private _preparedCache;
+    /** text node → prepared node, for O(1) lookup in _canvasPrepare */
+    private _nodeIndex;
+    /** shared Intl.Segmenter instance (lazy) */
+    private _segmenter;
+    private getCanvas;
+    private getSegmenter;
+    /**
+     * Measure a text string with a given CSS font, returning its width in pixels.
+     * Results are cached per font+text pair.
+     */
+    measureText(text: string, font: string): number;
+    /**
+     * Segment text into word-level pieces suitable for measurement.
+     * Uses Intl.Segmenter when available, falls back to space-splitting
+     * (with per-character splitting for CJK).
+     */
+    segmentText(text: string): {
+        text: string;
+        index: number;
+    }[];
+    /**
+     * Prepare phase: measure all text nodes under a root element.
+     * Returns PreparedNode[] with cumulative widths for binary search.
+     *
+     * Text nodes whose parent has exotic CSS (letter-spacing, word-spacing,
+     * text-indent) are skipped — the caller should fall back to DOM Range
+     * measurement for those.
+     *
+     * @param root The container element (usually document.body)
+     * @param win The window object for getComputedStyle
+     * @returns PreparedNode[] with entries for measurable text nodes (may be empty)
+     */
+    prepare(root: Element, win: Window): PreparedNode[];
+    /**
+     * Layout phase: find the segment index at a given pixel position
+     * using binary search on cumulative widths.
+     *
+     * @param segments The TextSegment[] from a PreparedNode
+     * @param position Target position in pixels (relative to text node start)
+     * @returns Index into the segments array
+     */
+    findSegmentIndex(segments: TextSegment[], position: number): number;
+    /**
+     * Look up a previously prepared text node in O(1).
+     * Returns null if the node was not prepared (exotic CSS, not yet prepared, etc.).
+     */
+    getPreparedNode(node: Text): PreparedNode | null;
+    /**
+     * Check if a text node's parent has exotic CSS that prevents canvas measurement.
+     */
+    hasExoticCSS(node: Text, win: Window): boolean;
+    /**
+     * Invalidate cached preparation for a root element,
+     * including all per-node index entries under it.
+     */
+    invalidate(root: Element): void;
+    /**
+     * Destroy the measurer, releasing the canvas and all caches.
+     */
+    destroy(): void;
+}
+export default TextMeasurer;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likecoin/epub-ts",
-  "version": "0.5.1",
-  "description": "TypeScript EPUB parser and renderer, forked from epubjs",
+  "version": "0.6.0",
+  "description": "Drop-in epubjs replacement — fully typed, 1 dependency, actively maintained",
   "keywords": [
     "epub",
     "ebook",
@@ -76,6 +76,10 @@
       "optional": true
     }
   },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "dependencies": {
     "jszip": "^3.10.1"
   }