@likecoin/epub-ts 0.3.93

package/dist/epubcfi.d.ts

@@ -0,0 +1,116 @@
+import { EpubCFIStep, EpubCFIComponent } from './types';
+/**
+    * Parsing and creation of EpubCFIs: http://www.idpf.org/epub/linking/cfi/epub-cfi.html
+
+    * Implements:
+    * - Character Offset: epubcfi(/6/4[chap01ref]!/4[body01]/10[para05]/2/1:3)
+    * - Simple Ranges : epubcfi(/6/4[chap01ref]!/4[body01]/10[para05],/2/1:1,/3:4)
+
+    * Does Not Implement:
+    * - Temporal Offset (~)
+    * - Spatial Offset (@)
+    * - Temporal-Spatial Offset (~ + @)
+    * - Text Location Assertion ([)
+    * @class
+    @param {string | Range | Node } [cfiFrom]
+    @param {string | object} [base]
+    @param {string} [ignoreClass] class to ignore when parsing DOM
+*/
+declare class EpubCFI {
+    str: string;
+    base: EpubCFIComponent | any;
+    spinePos: number;
+    range: boolean;
+    path: EpubCFIComponent | any;
+    start: EpubCFIComponent | null;
+    end: EpubCFIComponent | null;
+    id: string | null;
+    constructor(cfiFrom?: string | Range | Node | EpubCFI, base?: string | EpubCFIComponent, ignoreClass?: string);
+    /**
+     * Check the type of constructor input
+     * @private
+     */
+    checkType(cfi: string | Range | Node | EpubCFI | undefined): string | false;
+    /**
+     * Parse a cfi string to a CFI object representation
+     * @param {string} cfiStr
+     * @returns {object} cfi
+     */
+    parse(cfiStr: string): any;
+    parseComponent(componentStr: string): EpubCFIComponent;
+    parseStep(stepStr: string): EpubCFIStep | undefined;
+    parseTerminal(termialStr: string): {
+        offset: number | null;
+        assertion: string | null;
+    };
+    getChapterComponent(cfiStr: string): string;
+    getPathComponent(cfiStr: string): string | undefined;
+    getRange(cfiStr: string): [string, string] | false;
+    getCharecterOffsetComponent(cfiStr: string): string;
+    joinSteps(steps: EpubCFIStep[]): string;
+    segmentString(segment: EpubCFIComponent): string;
+    /**
+     * Convert CFI to a epubcfi(...) string
+     * @returns {string} epubcfi
+     */
+    toString(): string;
+    /**
+     * Compare which of two CFIs is earlier in the text
+     * @returns {number} First is earlier = -1, Second is earlier = 1, They are equal = 0
+     */
+    compare(cfiOne: string | EpubCFI, cfiTwo: string | EpubCFI): number;
+    step(node: Node): EpubCFIStep;
+    filteredStep(node: Node, ignoreClass: string): EpubCFIStep | undefined;
+    pathTo(node: Node, offset: number | null, ignoreClass?: string): EpubCFIComponent;
+    equalStep(stepA: EpubCFIStep, stepB: EpubCFIStep): boolean;
+    /**
+     * Create a CFI object from a Range
+     * @param {Range} range
+     * @param {string | object} base
+     * @param {string} [ignoreClass]
+     * @returns {object} cfi
+     */
+    fromRange(range: Range, base: string | EpubCFIComponent, ignoreClass?: string): Partial<EpubCFI>;
+    /**
+     * Create a CFI object from a Node
+     * @param {Node} anchor
+     * @param {string | object} base
+     * @param {string} [ignoreClass]
+     * @returns {object} cfi
+     */
+    fromNode(anchor: Node, base: string | EpubCFIComponent, ignoreClass?: string): Partial<EpubCFI>;
+    filter(anchor: Node, ignoreClass: string): Node | false;
+    patchOffset(anchor: Node, offset: number, ignoreClass: string): number;
+    normalizedMap(children: NodeListOf<ChildNode>, nodeType: number, ignoreClass: string): Record<number, number>;
+    position(anchor: Node): number;
+    filteredPosition(anchor: Node, ignoreClass: string): number;
+    stepsToXpath(steps: EpubCFIStep[]): string;
+    stepsToQuerySelector(steps: EpubCFIStep[]): string;
+    textNodes(container: Node, ignoreClass?: string): Node[];
+    walkToNode(steps: EpubCFIStep[], _doc?: Document, ignoreClass?: string): Node | undefined;
+    findNode(steps: EpubCFIStep[], _doc?: Document, ignoreClass?: string): Node | undefined;
+    fixMiss(steps: EpubCFIStep[], offset: number, _doc?: Document, ignoreClass?: string): {
+        container: Node;
+        offset: number;
+    };
+    /**
+     * Creates a DOM range representing a CFI
+     * @param {document} _doc document referenced in the base
+     * @param {string} [ignoreClass]
+     * @return {Range}
+     */
+    toRange(_doc?: Document, ignoreClass?: string): Range | null;
+    /**
+     * Check if a string is wrapped with "epubcfi()"
+     * @param {string} str
+     * @returns {boolean}
+     */
+    isCfiString(str: unknown): boolean;
+    generateChapterComponent(_spineNodeIndex: number, _pos: number | string, id?: string): string;
+    /**
+     * Collapse a CFI Range to a single CFI Position
+     * @param {boolean} [toStart=false]
+     */
+    collapse(toStart?: boolean): void;
+}
+export default EpubCFI;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { default as Book } from './book';
+import { default as EpubCFI } from './epubcfi';
+import { default as Rendition } from './rendition';
+import { default as Contents } from './contents';
+import { default as Layout } from './layout';
+import { default as ePub } from './epub';
+export default ePub;
+export { Book, EpubCFI, Rendition, Contents, Layout };

package/dist/layout.d.ts

@@ -0,0 +1,77 @@
+import { LayoutSettings, LayoutProps, IEventEmitter } from './types';
+import { default as Contents } from './contents';
+import { default as Section } from './section';
+/**
+ * Figures out the CSS values to apply for a layout
+ * @class
+ * @param {object} settings
+ * @param {string} [settings.layout='reflowable']
+ * @param {string} [settings.spread]
+ * @param {number} [settings.minSpreadWidth=800]
+ * @param {boolean} [settings.evenSpreads=false]
+ */
+declare class Layout implements IEventEmitter {
+    on: (type: string, fn: (...args: any[]) => void) => this;
+    off: (type: string, fn?: (...args: any[]) => void) => this;
+    emit: (type: string, ...args: any[]) => void;
+    settings: LayoutSettings;
+    name: string;
+    _spread: boolean;
+    _minSpreadWidth: number;
+    _evenSpreads: boolean;
+    _flow: string;
+    width: number;
+    height: number;
+    spreadWidth: number;
+    delta: number;
+    columnWidth: number;
+    gap: number;
+    divisor: number;
+    pageWidth: number;
+    props: LayoutProps;
+    constructor(settings: LayoutSettings);
+    /**
+     * Switch the flow between paginated and scrolled
+     * @param  {string} flow paginated | scrolled
+     * @return {string} simplified flow
+     */
+    flow(flow?: string): string;
+    /**
+     * Switch between using spreads or not, and set the
+     * width at which they switch to single.
+     * @param  {string} spread "none" | "always" | "auto"
+     * @param  {number} min integer in pixels
+     * @return {boolean} spread true | false
+     */
+    spread(spread?: string, min?: number): boolean;
+    /**
+     * Calculate the dimensions of the pagination
+     * @param  {number} _width  width of the rendering
+     * @param  {number} _height height of the rendering
+     * @param  {number} _gap    width of the gap between columns
+     */
+    calculate(_width: number, _height: number, _gap?: number): void;
+    /**
+     * Apply Css to a Document
+     * @param  {Contents} contents
+     * @return {Promise}
+     */
+    format(contents: Contents, section?: Section, axis?: string): void;
+    /**
+     * Count number of pages
+     * @param  {number} totalLength
+     * @param  {number} pageLength
+     * @return {{spreads: Number, pages: Number}}
+     */
+    count(totalLength: number, pageLength?: number): {
+        spreads: number;
+        pages: number;
+    };
+    /**
+     * Update props that have changed
+     * @private
+     * @param  {object} props
+     */
+    update(props: Partial<LayoutProps>): void;
+}
+export default Layout;

package/dist/locations.d.ts

@@ -0,0 +1,117 @@
+import { default as Queue } from './utils/queue';
+import { default as EpubCFI } from './epubcfi';
+import { IEventEmitter, RequestFunction } from './types';
+import { default as Spine } from './spine';
+import { default as Section } from './section';
+/**
+ * Find Locations for a Book
+ * @param {Spine} spine
+ * @param {request} request
+ * @param {number} [pause=100]
+ */
+declare class Locations implements IEventEmitter {
+    on: (type: string, fn: (...args: any[]) => void) => this;
+    off: (type: string, fn?: (...args: any[]) => void) => this;
+    emit: (type: string, ...args: any[]) => void;
+    spine: Spine;
+    request: RequestFunction;
+    pause: number;
+    q: Queue;
+    epubcfi: EpubCFI;
+    _locations: string[];
+    _locationsWords: {
+        cfi: string;
+        wordCount: number;
+    }[];
+    total: number;
+    break: number;
+    _current: number;
+    _wordCounter: number;
+    _currentCfi: string;
+    processingTimeout: ReturnType<typeof setTimeout> | undefined;
+    constructor(spine: Spine, request: RequestFunction, pause?: number);
+    /**
+     * Load all of sections in the book to generate locations
+     * @param  {int} chars how many chars to split on
+     * @return {Promise<Array<string>>} locations
+     */
+    generate(chars?: number): Promise<string[]>;
+    createRange(): {
+        startContainer: Node | undefined;
+        startOffset: number | undefined;
+        endContainer: Node | undefined;
+        endOffset: number | undefined;
+    };
+    process(section: Section): Promise<string[]>;
+    parse(contents: Element, cfiBase: string, chars?: number): string[];
+    /**
+     * Load all of sections in the book to generate locations
+     * @param  {string} startCfi start position
+     * @param  {int} wordCount how many words to split on
+     * @param  {int} count result count
+     * @return {object} locations
+     */
+    generateFromWords(startCfi?: string, wordCount?: number, count?: number): Promise<any[]>;
+    processWords(section: Section, wordCount: number, startCfi?: EpubCFI, count?: number): Promise<any>;
+    countWords(s: string): number;
+    parseWords(contents: Element, section: Section, wordCount: number, startCfi?: EpubCFI): {
+        cfi: string;
+        wordCount: number;
+    }[];
+    /**
+     * Get a location from an EpubCFI
+     * @param {EpubCFI} cfi
+     * @return {number}
+     */
+    locationFromCfi(cfi: string | EpubCFI): number;
+    /**
+     * Get a percentage position in locations from an EpubCFI
+     * @param {EpubCFI} cfi
+     * @return {number}
+     */
+    percentageFromCfi(cfi: string | EpubCFI): number | null;
+    /**
+     * Get a percentage position from a location index
+     * @param {number} location
+     * @return {number}
+     */
+    percentageFromLocation(loc: number): number;
+    /**
+     * Get an EpubCFI from location index
+     * @param {number} loc
+     * @return {EpubCFI} cfi
+     */
+    cfiFromLocation(loc: string | number): string | number;
+    /**
+     * Get an EpubCFI from location percentage
+     * @param {number} percentage
+     * @return {EpubCFI} cfi
+     */
+    cfiFromPercentage(percentage: number): string | number;
+    /**
+     * Load locations from JSON
+     * @param {json} locations
+     */
+    load(locations: string | string[]): string[];
+    /**
+     * Save locations to JSON
+     * @return {json}
+     */
+    save(): string;
+    getCurrent(): number;
+    setCurrent(curr: string | number): void;
+    /**
+     * Get the current location
+     */
+    get currentLocation(): number;
+    /**
+     * Set the current location
+     */
+    set currentLocation(curr: string | number);
+    /**
+     * Locations length
+     */
+    length(): number;
+    destroy(): void;
+}
+export default Locations;

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

@@ -0,0 +1,46 @@
+import { defer, requestAnimationFrame } from '../../utils/core';
+import { default as DefaultViewManager } from '../default';
+import { default as Snap } from '../helpers/snap';
+import { default as Section } from '../../section';
+import { default as IframeView } from '../views/iframe';
+import { default as Stage } from '../helpers/stage';
+import { ManagerOptions, ReframeBounds } from '../../types';
+declare class ContinuousViewManager extends DefaultViewManager {
+    snapper: Snap;
+    tick: typeof requestAnimationFrame;
+    scrollDeltaVert: number;
+    scrollDeltaHorz: number;
+    _scrolled: (...args: any[]) => void;
+    didScroll: boolean;
+    prevScrollTop: number;
+    prevScrollLeft: number;
+    scrollTimeout: ReturnType<typeof setTimeout>;
+    trimTimeout: ReturnType<typeof setTimeout>;
+    constructor(options: ManagerOptions);
+    display(section: Section, target?: string): Promise<any>;
+    fill(_full?: InstanceType<typeof defer>): Promise<any>;
+    moveTo(offset: {
+        left: number;
+        top: number;
+    }): void;
+    afterResized(view: IframeView): void;
+    removeShownListeners(view: IframeView): void;
+    add(section: Section): Promise<any>;
+    append(section: Section): any;
+    prepend(section: Section): any;
+    counter(bounds: ReframeBounds): void;
+    update(_offset?: number): Promise<any>;
+    check(_offsetLeft?: number, _offsetTop?: number): Promise<any>;
+    trim(): Promise<any>;
+    erase(view: IframeView, above?: IframeView[]): void;
+    addEventListeners(_stage?: Stage): void;
+    addScrollListeners(): void;
+    removeEventListeners(): void;
+    onScroll(): void;
+    scrolled(): void;
+    next(): void;
+    prev(): void;
+    updateFlow(flow: string): void;
+    destroy(): void;
+}
+export default ContinuousViewManager;

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

@@ -0,0 +1,117 @@
+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 Layout } from '../../layout';
+import { default as Section } from '../../section';
+import { default as Contents } from '../../contents';
+import { default as IframeView } from '../views/iframe';
+import { IEventEmitter, ManagerOptions, ViewSettings, ViewLocation, RequestFunction, SizeObject, ReframeBounds, LayoutProps } from '../../types';
+declare class DefaultViewManager implements IEventEmitter {
+    name: string;
+    optsSettings: ManagerOptions;
+    View: new (section: Section, options?: ViewSettings) => IframeView;
+    request: RequestFunction;
+    renditionQueue: Queue;
+    q: Queue;
+    settings: ManagerOptions;
+    viewSettings: Omit<ViewSettings, "layout"> & {
+        layout?: Layout | LayoutProps;
+    };
+    rendered: boolean;
+    stage: Stage;
+    container: HTMLElement;
+    views: Views;
+    _bounds: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+        width: number;
+        height: number;
+    };
+    _stageSize: SizeObject;
+    overflow: string;
+    layout: Layout;
+    mapping: Mapping;
+    location: ViewLocation[];
+    isPaginated: boolean;
+    scrollLeft: number;
+    scrollTop: number;
+    ignore: boolean;
+    writingMode: string;
+    _hasScrolled: boolean;
+    _onScroll: (...args: any[]) => void;
+    orientationTimeout: ReturnType<typeof setTimeout>;
+    resizeTimeout: ReturnType<typeof setTimeout>;
+    afterScrolled: ReturnType<typeof setTimeout>;
+    winBounds: {
+        top: number;
+        left: number;
+        right: number;
+        bottom: number;
+        width: number;
+        height: number;
+    };
+    on: IEventEmitter["on"];
+    off: IEventEmitter["off"];
+    emit: IEventEmitter["emit"];
+    constructor(options: ManagerOptions);
+    render(element: HTMLElement, size: SizeObject): void;
+    addEventListeners(): void;
+    removeEventListeners(): void;
+    destroy(): void;
+    onOrientationChange(_e?: Event): void;
+    onResized(_e?: Event): void;
+    resize(width?: number, height?: number, epubcfi?: string): void;
+    createView(section: Section, forceRight?: boolean): IframeView;
+    handleNextPrePaginated(forceRight: boolean, section: Section, action: Function): any;
+    display(section: Section, target?: string): Promise<any>;
+    afterDisplayed(view: IframeView): void;
+    afterResized(view: IframeView): void;
+    moveTo(offset: {
+        left: number;
+        top: number;
+    }, width?: number): void;
+    add(section: Section, forceRight?: boolean): Promise<any>;
+    append(section: Section, forceRight?: boolean): Promise<any>;
+    prepend(section: Section, forceRight?: boolean): Promise<any>;
+    counter(bounds: ReframeBounds): void;
+    next(): any;
+    prev(): any;
+    current(): IframeView | null;
+    clear(): void;
+    currentLocation(): ViewLocation[];
+    scrolledLocation(): ViewLocation[];
+    paginatedLocation(): ViewLocation[];
+    isVisible(view: IframeView, offsetPrev: number, offsetNext: number, _container?: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+        width: number;
+        height: number;
+    }): boolean;
+    visible(): IframeView[];
+    scrollBy(x: number, y: number, silent?: boolean): void;
+    scrollTo(x: number, y: number, silent?: boolean): void;
+    onScroll(): void;
+    bounds(): {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+        width: number;
+        height: number;
+    };
+    applyLayout(layout: Layout): void;
+    updateLayout(): void;
+    setLayout(layout: Layout): void;
+    updateWritingMode(mode: string): void;
+    updateAxis(axis: string, forceUpdate?: boolean): void;
+    updateFlow(flow: string, defaultScrolledOverflow?: string): void;
+    getContents(): Contents[];
+    direction(dir?: string): void;
+    isRendered(): boolean;
+}
+export default DefaultViewManager;

package/dist/managers/helpers/snap.d.ts

@@ -0,0 +1,63 @@
+import { IEventEmitter } from '../../types';
+import { default as DefaultViewManager } from '../default/index';
+import { default as Contents } from '../../contents';
+import { default as Layout } from '../../layout';
+declare class Snap implements IEventEmitter {
+    settings: {
+        duration: number;
+        minVelocity: number;
+        minDistance: number;
+        easing: (pos: number) => number;
+        [key: string]: any;
+    };
+    manager: DefaultViewManager;
+    layout: Layout;
+    fullsize: boolean;
+    element: HTMLElement;
+    scroller: HTMLElement | Window;
+    isVertical: boolean;
+    touchCanceler: boolean;
+    resizeCanceler: boolean;
+    snapping: boolean;
+    scrollLeft: number;
+    scrollTop: number;
+    startTouchX: number;
+    startTouchY: number;
+    startTime: number;
+    endTouchX: number;
+    endTouchY: number;
+    endTime: number;
+    _onResize: (...args: any[]) => void;
+    _onScroll: (...args: any[]) => void;
+    _onTouchStart: (...args: any[]) => void;
+    _onTouchMove: (...args: any[]) => void;
+    _onTouchEnd: (...args: any[]) => void;
+    _afterDisplayed: (...args: any[]) => void;
+    on: IEventEmitter["on"];
+    off: IEventEmitter["off"];
+    emit: IEventEmitter["emit"];
+    constructor(manager: DefaultViewManager, options?: Record<string, any>);
+    setup(manager: DefaultViewManager): void;
+    supportsTouch(): boolean;
+    disableScroll(): void;
+    enableScroll(): void;
+    addListeners(): void;
+    removeListeners(): void;
+    afterDisplayed(view: {
+        contents: Contents;
+    }): void;
+    triggerViewEvent(e: TouchEvent, contents: Contents): void;
+    onScroll(_e?: Event): void;
+    onResize(_e?: Event): void;
+    onTouchStart(e: TouchEvent): void;
+    onTouchMove(e: TouchEvent): void;
+    onTouchEnd(_e?: TouchEvent): void;
+    wasSwiped(): number;
+    needsSnap(): boolean;
+    snap(howMany?: number): Promise<void>;
+    smoothScrollTo(destination: number): Promise<void>;
+    scrollTo(left?: number, top?: number): void;
+    now(): number;
+    destroy(): void;
+}
+export default Snap;

package/dist/managers/helpers/stage.d.ts

@@ -0,0 +1,41 @@
+import { StageOptions } from '../../types';
+declare class Stage {
+    settings: StageOptions;
+    id: string;
+    container: HTMLDivElement;
+    wrapper: HTMLDivElement;
+    element: HTMLElement;
+    resizeFunc: () => void;
+    orientationChangeFunc: (e: Event) => void;
+    containerStyles: CSSStyleDeclaration;
+    containerPadding: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+    sheet: CSSStyleSheet;
+    constructor(_options?: StageOptions);
+    create(options: StageOptions): HTMLDivElement;
+    wrap(container: HTMLElement): HTMLDivElement;
+    getElement(_element: HTMLElement | string): HTMLElement;
+    attachTo(what: HTMLElement | string): HTMLElement | void;
+    getContainer(): HTMLDivElement;
+    onResize(func: () => void): void;
+    onOrientationChange(func: (e: Event) => void): void;
+    size(width?: number | string | null, height?: number | string | null): {
+        width: number;
+        height: number;
+    };
+    bounds(): DOMRect | {
+        width: number;
+        height: number;
+    };
+    getSheet(): CSSStyleSheet;
+    addStyleRules(selector: string, rulesArray: Record<string, string>[]): void;
+    axis(axis: string): void;
+    direction(dir: string): void;
+    overflow(overflow: string): void;
+    destroy(): void;
+}
+export default Stage;

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

@@ -0,0 +1,27 @@
+import { default as IframeView } from '../views/iframe';
+import { default as Section } from '../../section';
+declare class Views {
+    container: HTMLElement;
+    _views: IframeView[];
+    length: number;
+    hidden: boolean;
+    constructor(container: HTMLElement);
+    all(): IframeView[];
+    first(): IframeView | undefined;
+    last(): IframeView | undefined;
+    indexOf(view: IframeView): number;
+    slice(...args: [start?: number, end?: number]): IframeView[];
+    get(i: number): IframeView;
+    append(view: IframeView): IframeView;
+    prepend(view: IframeView): IframeView;
+    insert(view: IframeView, index: number): IframeView;
+    remove(view: IframeView): void;
+    destroy(view: IframeView): void;
+    forEach(callbackfn: (value: IframeView, index: number, array: IframeView[]) => void): void;
+    clear(): void;
+    find(section: Section): IframeView | undefined;
+    displayed(): IframeView[];
+    show(): void;
+    hide(): void;
+}
+export default Views;