@likecoin/epub-ts 0.3.93

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

@@ -0,0 +1,114 @@
+import { default as EpubCFI } from '../../epubcfi';
+import { default as Contents } from '../../contents';
+import { Pane, Mark } from '../../marks-pane';
+import { IEventEmitter, ViewSettings, ReframeBounds, RequestFunction } from '../../types';
+import { default as Section } from '../../section';
+import { default as Layout } from '../../layout';
+declare class IframeView implements IEventEmitter {
+    settings: ViewSettings;
+    id: string;
+    section: Section;
+    index: number;
+    element: HTMLElement;
+    added: boolean;
+    displayed: boolean;
+    rendered: boolean;
+    fixedWidth: number;
+    fixedHeight: number;
+    epubcfi: EpubCFI;
+    layout: Layout;
+    pane: Pane | undefined;
+    highlights: Record<string, {
+        mark: Mark;
+        element: SVGElement | null;
+        listeners: (Function | undefined)[];
+    }>;
+    underlines: Record<string, {
+        mark: Mark;
+        element: SVGElement | null;
+        listeners: (Function | undefined)[];
+    }>;
+    marks: Record<string, {
+        element: HTMLAnchorElement;
+        range: Range;
+        listeners: (Function | undefined)[];
+    }>;
+    iframe: HTMLIFrameElement | undefined;
+    resizing: boolean;
+    _width: number;
+    _height: number;
+    _textWidth: number;
+    _textHeight: number;
+    _contentWidth: number;
+    _contentHeight: number;
+    _needsReframe: boolean;
+    _expanding: boolean;
+    elementBounds: {
+        width: number;
+        height: number;
+    };
+    supportsSrcdoc: boolean;
+    sectionRender: Promise<string>;
+    lockedWidth: number;
+    lockedHeight: number;
+    prevBounds: ReframeBounds | undefined;
+    blobUrl: string;
+    document: Document;
+    window: Window;
+    contents: Contents | undefined;
+    rendering: boolean;
+    writingMode: string;
+    stopExpanding: boolean;
+    axis: string;
+    on: IEventEmitter["on"];
+    off: IEventEmitter["off"];
+    emit: IEventEmitter["emit"];
+    constructor(section: Section, options?: ViewSettings);
+    container(axis?: string): HTMLElement;
+    create(): HTMLIFrameElement;
+    render(request: RequestFunction, _show?: boolean): Promise<void>;
+    reset(): void;
+    size(_width?: number, _height?: number): void;
+    lock(what: string, width: number, height: number): void;
+    expand(_force?: boolean): void;
+    reframe(width: number, height: number): void;
+    load(contents: string): Promise<Contents>;
+    onLoad(event: Event, promise: {
+        resolve: (value?: any) => void;
+        reject: (reason?: any) => void;
+    }): void;
+    setLayout(layout: Layout): void;
+    setAxis(axis: string): void;
+    setWritingMode(mode: string): void;
+    addListeners(): void;
+    removeListeners(_layoutFunc?: Function): void;
+    display(request: RequestFunction): Promise<IframeView>;
+    show(): void;
+    hide(): void;
+    offset(): {
+        top: number;
+        left: number;
+    };
+    width(): number;
+    height(): number;
+    position(): DOMRect;
+    locationOf(target: string): {
+        left: number;
+        top: number;
+    };
+    onDisplayed(_view: IframeView): void;
+    onResize(_view: IframeView, _e?: ReframeBounds): void;
+    bounds(force?: boolean): {
+        width: number;
+        height: number;
+    };
+    highlight(cfiRange: string, data?: Record<string, string>, cb?: Function, className?: string, styles?: Record<string, string>): Mark | undefined;
+    underline(cfiRange: string, data?: Record<string, string>, cb?: Function, className?: string, styles?: Record<string, string>): Mark | undefined;
+    mark(cfiRange: string, data?: Record<string, string>, cb?: Function): any;
+    placeMark(element: HTMLElement, range: Range): void;
+    unhighlight(cfiRange: string): void;
+    ununderline(cfiRange: string): void;
+    unmark(cfiRange: string): void;
+    destroy(): void;
+}
+export default IframeView;

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

@@ -0,0 +1,65 @@
+import { IEventEmitter, ViewSettings } from '../../types';
+declare class InlineView implements IEventEmitter {
+    settings: any;
+    id: string;
+    section: any;
+    index: number;
+    element: HTMLElement;
+    added: boolean;
+    displayed: boolean;
+    rendered: boolean;
+    width: number;
+    height: number;
+    fixedWidth: number;
+    fixedHeight: number;
+    epubcfi: any;
+    layout: any;
+    frame: HTMLDivElement;
+    resizing: boolean;
+    _width: number;
+    _height: number;
+    _textWidth: number;
+    _textHeight: number;
+    _needsReframe: boolean;
+    _expanding: boolean;
+    elementBounds: any;
+    prevBounds: any;
+    lockedWidth: number;
+    lockedHeight: number;
+    document: Document;
+    window: Window;
+    contents: any;
+    rendering: boolean;
+    stopExpanding: boolean;
+    on: IEventEmitter["on"];
+    off: IEventEmitter["off"];
+    emit: IEventEmitter["emit"];
+    constructor(section: any, options?: ViewSettings);
+    container(axis?: string): HTMLElement;
+    create(): HTMLDivElement;
+    render(request: any, show?: boolean): Promise<any>;
+    size(_width?: number, _height?: number): void;
+    lock(what: string, width: number, height: number): void;
+    expand(_force?: boolean): void;
+    contentWidth(_min?: number): number;
+    contentHeight(_min?: number): number;
+    resize(width: any, height: any): void;
+    load(contents: string): Promise<any>;
+    setLayout(layout: any): void;
+    resizeListenters(): void;
+    addListeners(): void;
+    removeListeners(_layoutFunc?: any): void;
+    display(request: any): Promise<any>;
+    show(): void;
+    hide(): void;
+    position(): DOMRect;
+    locationOf(target: any): {
+        left: number;
+        top: number;
+    };
+    onDisplayed(_view: any): void;
+    onResize(_view: any, _e?: any): void;
+    bounds(): any;
+    destroy(): void;
+}
+export default InlineView;

package/dist/mapping.d.ts

@@ -0,0 +1,97 @@
+import { EpubCFIPair, RangePair, LayoutProps } from './types';
+/**
+ * Map text locations to CFI ranges
+ * @class
+ * @param {Layout} layout Layout to apply
+ * @param {string} [direction="ltr"] Text direction
+ * @param {string} [axis="horizontal"] vertical or horizontal axis
+ * @param {boolean} [dev] toggle developer highlighting
+ */
+declare class Mapping {
+    layout: LayoutProps;
+    horizontal: boolean;
+    direction: string;
+    _dev: boolean;
+    constructor(layout: LayoutProps, direction?: string, axis?: string, dev?: boolean);
+    /**
+     * Find CFI pairs for entire section at once
+     */
+    section(view: any): EpubCFIPair[];
+    /**
+     * Find CFI pairs for a page
+     * @param {Contents} contents Contents from view
+     * @param {string} cfiBase string of the base for a cfi
+     * @param {number} start position to start at
+     * @param {number} end position to end at
+     */
+    page(contents: any, cfiBase: string, start: number, end: number): EpubCFIPair | undefined;
+    /**
+     * Walk a node, preforming a function on each node it finds
+     * @private
+     * @param {Node} root Node to walkToNode
+     * @param {function} func walk function
+     * @return {*} returns the result of the walk function
+     */
+    walk(root: Node, func: (node: Node) => Node | undefined): Node | undefined;
+    findRanges(view: any): any[];
+    /**
+     * Find Start Range
+     * @private
+     * @param {Node} root root node
+     * @param {number} start position to start at
+     * @param {number} end position to end at
+     * @return {Range}
+     */
+    findStart(root: Node, start: number, end: number): Range;
+    /**
+     * Find End Range
+     * @private
+     * @param {Node} root root node
+     * @param {number} start position to start at
+     * @param {number} end position to end at
+     * @return {Range}
+     */
+    findEnd(root: Node, start: number, end: number): Range;
+    /**
+     * Find Text Start Range
+     * @private
+     * @param {Node} root root node
+     * @param {number} start position to start at
+     * @param {number} end position to end at
+     * @return {Range}
+     */
+    findTextStartRange(node: Node, start: number, end: number): Range;
+    /**
+     * Find Text End Range
+     * @private
+     * @param {Node} root root node
+     * @param {number} start position to start at
+     * @param {number} end position to end at
+     * @return {Range}
+     */
+    findTextEndRange(node: Node, start: number, end: number): Range;
+    /**
+     * Split up a text node into ranges for each word
+     * @private
+     * @param {Node} root root node
+     * @param {string} [_splitter] what to split on
+     * @return {Range[]}
+     */
+    splitTextNodeIntoRanges(node: Node, _splitter?: string): Range[];
+    /**
+     * Turn a pair of ranges into a pair of CFIs
+     * @private
+     * @param {string} cfiBase base string for an EpubCFI
+     * @param {object} rangePair { start: Range, end: Range }
+     * @return {object} { start: "epubcfi(...)", end: "epubcfi(...)" }
+     */
+    rangePairToCfiPair(cfiBase: string, rangePair: RangePair): EpubCFIPair;
+    rangeListToCfiList(cfiBase: string, columns: RangePair[]): EpubCFIPair[];
+    /**
+     * Set the axis for mapping
+     * @param {string} axis horizontal | vertical
+     * @return {boolean} is it horizontal?
+     */
+    axis(axis?: string): boolean;
+}
+export default Mapping;

package/dist/marks-pane/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Inlined from marks-pane v1.0.9 (https://github.com/fchasen/marks)
+ * SVG-based text annotation marks (highlights, underlines) for iframes.
+ */
+export declare class Pane {
+    target: HTMLElement | HTMLIFrameElement;
+    element: SVGElement;
+    marks: Mark[];
+    container: HTMLElement;
+    constructor(target: HTMLElement | HTMLIFrameElement, container?: HTMLElement);
+    addMark(mark: Mark): Mark;
+    removeMark(mark: Mark): void;
+    render(): void;
+}
+export declare class Mark {
+    element: SVGElement | null;
+    container: HTMLElement;
+    range: Range;
+    constructor();
+    bind(element: SVGElement, container: HTMLElement): void;
+    unbind(): SVGElement | null;
+    render(): void;
+    dispatchEvent(e: Event): void;
+    getBoundingClientRect(): DOMRect;
+    getClientRects(): DOMRect[];
+    filteredRanges(): DOMRect[];
+}
+export declare class Highlight extends Mark {
+    range: Range;
+    className: string;
+    data: Record<string, string>;
+    attributes: Record<string, string>;
+    constructor(range: Range, className: string, data?: Record<string, string>, attributes?: Record<string, string>);
+    bind(element: SVGElement, container: HTMLElement): void;
+    render(): void;
+}
+export declare class Underline extends Highlight {
+    constructor(range: Range, className: string, data?: Record<string, string>, attributes?: Record<string, string>);
+    render(): void;
+}

package/dist/navigation.d.ts

@@ -0,0 +1,108 @@
+import { NavItem, LandmarkItem } from './types';
+/**
+ * Navigation Parser
+ * @param {document} xml navigation html / xhtml / ncx
+ */
+declare class Navigation {
+    toc: NavItem[];
+    tocByHref: Record<string, number>;
+    tocById: Record<string, number>;
+    landmarks: LandmarkItem[];
+    landmarksByType: Record<string, number>;
+    length: number;
+    constructor(xml?: Document | NavItem[]);
+    /**
+     * Parse out the navigation items
+     * @param {document} xml navigation html / xhtml / ncx
+     */
+    parse(xml: Document | NavItem[]): void;
+    /**
+     * Unpack navigation items
+     * @private
+     * @param  {array} toc
+     */
+    unpack(toc: NavItem[]): void;
+    /**
+     * Get an item from the navigation
+     * @param  {string} target
+     * @return {object} navItem
+     */
+    get(target?: string): NavItem | NavItem[] | undefined;
+    /**
+     * Get an item from navigation subitems recursively by index
+     * @param  {string} target
+     * @param  {number} index
+     * @param  {array} navItems
+     * @return {object} navItem
+     */
+    getByIndex(target: string, index: number | undefined, navItems: NavItem[]): NavItem | undefined;
+    /**
+     * Get a landmark by type
+     * List of types: https://idpf.github.io/epub-vocabs/structure/
+     * @param  {string} type
+     * @return {object} landmarkItem
+     */
+    landmark(type?: string): LandmarkItem | LandmarkItem[] | undefined;
+    /**
+     * Parse toc from a Epub > 3.0 Nav
+     * @private
+     * @param  {document} navHtml
+     * @return {array} navigation list
+     */
+    parseNav(navHtml: Document): NavItem[];
+    /**
+     * Parses lists in the toc
+     * @param  {document} navListHtml
+     * @param  {string} parent id
+     * @return {array} navigation list
+     */
+    parseNavList(navListHtml: Element, parent?: string): NavItem[];
+    /**
+     * Create a navItem
+     * @private
+     * @param  {element} item
+     * @return {object} navItem
+     */
+    navItem(item: Element, parent?: string): NavItem | undefined;
+    /**
+     * Parse landmarks from a Epub > 3.0 Nav
+     * @private
+     * @param  {document} navHtml
+     * @return {array} landmarks list
+     */
+    parseLandmarks(navHtml: Document): LandmarkItem[];
+    /**
+     * Create a landmarkItem
+     * @private
+     * @param  {element} item
+     * @return {object} landmarkItem
+     */
+    landmarkItem(item: Element): LandmarkItem | undefined;
+    /**
+     * Parse from a Epub > 3.0 NC
+     * @private
+     * @param  {document} navHtml
+     * @return {array} navigation list
+     */
+    parseNcx(tocXml: Document): NavItem[];
+    /**
+     * Create a ncxItem
+     * @private
+     * @param  {element} item
+     * @return {object} ncxItem
+     */
+    ncxItem(item: Element): NavItem;
+    /**
+     * Load Spine Items
+     * @param  {object} json the items to be loaded
+     * @return {Array} navItems
+     */
+    load(json: any[]): NavItem[];
+    /**
+     * forEach pass through
+     * @param  {Function} fn function to run on each item
+     * @return {method} forEach loop
+     */
+    forEach(fn: (item: NavItem, index: number, array: NavItem[]) => void): void;
+}
+export default Navigation;

package/dist/packaging.d.ts

@@ -0,0 +1,104 @@
+import { PackagingMetadataObject, PackagingSpineItem, PackagingManifestObject, PackagingObject, NavItem } from './types';
+/**
+ * Open Packaging Format Parser
+ * @class
+ * @param {document} packageDocument OPF XML
+ */
+declare class Packaging {
+    manifest: PackagingManifestObject;
+    navPath: string;
+    ncxPath: string;
+    coverPath: string;
+    spineNodeIndex: number;
+    spine: PackagingSpineItem[];
+    metadata: PackagingMetadataObject;
+    uniqueIdentifier: string;
+    toc: NavItem[];
+    constructor(packageDocument?: Document);
+    /**
+     * Parse OPF XML
+     * @param  {document} packageDocument OPF XML
+     * @return {object} parsed package parts
+     */
+    parse(packageDocument: Document): PackagingObject;
+    /**
+     * Parse Metadata
+     * @private
+     * @param  {node} xml
+     * @return {object} metadata
+     */
+    parseMetadata(xml: Element): PackagingMetadataObject;
+    /**
+     * Parse Manifest
+     * @private
+     * @param  {node} manifestXml
+     * @return {object} manifest
+     */
+    parseManifest(manifestXml: Element): PackagingManifestObject;
+    /**
+     * Parse Spine
+     * @private
+     * @param  {node} spineXml
+     * @param  {Packaging.manifest} manifest
+     * @return {object} spine
+     */
+    parseSpine(spineXml: Element, _manifest: PackagingManifestObject): PackagingSpineItem[];
+    /**
+     * Find Unique Identifier
+     * @private
+     * @param  {node} packageXml
+     * @return {string} Unique Identifier text
+     */
+    findUniqueIdentifier(packageXml: Document): string;
+    /**
+     * Find TOC NAV
+     * @private
+     * @param {element} manifestNode
+     * @return {string}
+     */
+    findNavPath(manifestNode: Element): string;
+    /**
+     * Find TOC NCX
+     * media-type="application/x-dtbncx+xml" href="toc.ncx"
+     * @private
+     * @param {element} manifestNode
+     * @param {element} spineNode
+     * @return {string}
+     */
+    findNcxPath(manifestNode: Element, spineNode: Element): string;
+    /**
+     * Find the Cover Path
+     * <item properties="cover-image" id="ci" href="cover.svg" media-type="image/svg+xml" />
+     * Fallback for Epub 2.0
+     * @private
+     * @param  {node} packageXml
+     * @return {string} href
+     */
+    findCoverPath(packageXml: Document): string;
+    /**
+     * Get text of a namespaced element
+     * @private
+     * @param  {node} xml
+     * @param  {string} tag
+     * @return {string} text
+     */
+    getElementText(xml: Element, tag: string): string;
+    /**
+     * Get text by property
+     * @private
+     * @param  {node} xml
+     * @param  {string} property
+     * @return {string} text
+     */
+    getPropertyText(xml: Element, property: string): string;
+    /**
+     * Load JSON Manifest
+     * @param  {document} packageDocument OPF XML
+     * @return {object} parsed package parts
+     */
+    load(json: Record<string, any>): PackagingObject & {
+        toc: NavItem[];
+    };
+    destroy(): void;
+}
+export default Packaging;

package/dist/pagelist.d.ts

@@ -0,0 +1,80 @@
+import { default as EpubCFI } from './epubcfi';
+import { PageListItem } from './types';
+/**
+ * Page List Parser
+ * @param {document} [xml]
+ */
+declare class PageList {
+    pages: number[];
+    locations: string[];
+    epubcfi: EpubCFI;
+    firstPage: number;
+    lastPage: number;
+    totalPages: number;
+    toc: Document | undefined;
+    ncx: Document | undefined;
+    pageList: PageListItem[];
+    constructor(xml?: Document);
+    /**
+     * Parse PageList Xml
+     * @param  {document} xml
+     */
+    parse(xml: Document): PageListItem[];
+    /**
+     * Parse a Nav PageList
+     * @private
+     * @param  {node} navHtml
+     * @return {PageList.item[]} list
+     */
+    parseNav(navHtml: Document): PageListItem[];
+    parseNcx(navXml: Document): PageListItem[];
+    ncxItem(item: Element): PageListItem;
+    /**
+     * Page List Item
+     * @private
+     * @param  {node} item
+     * @return {object} pageListItem
+     */
+    item(item: Element): PageListItem;
+    /**
+     * Process pageList items
+     * @private
+     * @param  {array} pageList
+     */
+    process(pageList: PageListItem[]): void;
+    /**
+     * Get a PageList result from a EpubCFI
+     * @param  {string} cfi EpubCFI String
+     * @return {number} page
+     */
+    pageFromCfi(cfi: string): number;
+    /**
+     * Get an EpubCFI from a Page List Item
+     * @param  {string | number} pg
+     * @return {string} cfi
+     */
+    cfiFromPage(pg: string | number): string | number;
+    /**
+     * Get a Page from Book percentage
+     * @param  {number} percent
+     * @return {number} page
+     */
+    pageFromPercentage(percent: number): number;
+    /**
+     * Returns a value between 0 - 1 corresponding to the location of a page
+     * @param  {number} pg the page
+     * @return {number} percentage
+     */
+    percentageFromPage(pg: number): number;
+    /**
+     * Returns a value between 0 - 1 corresponding to the location of a cfi
+     * @param  {string} cfi EpubCFI String
+     * @return {number} percentage
+     */
+    percentageFromCfi(cfi: string): number;
+    /**
+     * Destroy
+     */
+    destroy(): void;
+}
+export default PageList;