@likecoin/epub-ts 0.3.93

package/dist/rendition.d.ts

@@ -0,0 +1,293 @@
+import { defer } from './utils/core';
+import { default as Hook } from './utils/hook';
+import { default as EpubCFI } from './epubcfi';
+import { default as Queue } from './utils/queue';
+import { default as Layout } from './layout';
+import { default as Themes } from './themes';
+import { default as Contents } from './contents';
+import { default as Annotations } from './annotations';
+import { IEventEmitter, RenditionOptions, Location, GlobalLayout, ViewLocation, SizeObject, PackagingMetadataObject } from './types';
+import { default as Book } from './book';
+import { default as Section } from './section';
+import { default as IframeView } from './managers/views/iframe';
+import { default as DefaultViewManager } from './managers/default/index';
+import { default as ContinuousViewManager } from './managers/continuous/index';
+/**
+ * Displays an Epub as a series of Views for each Section.
+ * Requires Manager and View class to handle specifics of rendering
+ * the section content.
+ * @class
+ * @param {Book} book
+ * @param {object} [options]
+ * @param {number} [options.width]
+ * @param {number} [options.height]
+ * @param {string} [options.ignoreClass] class for the cfi parser to ignore
+ * @param {string | function | object} [options.manager='default']
+ * @param {string | function} [options.view='iframe']
+ * @param {string} [options.layout] layout to force
+ * @param {string} [options.spread] force spread value
+ * @param {number} [options.minSpreadWidth] overridden by spread: none (never) / both (always)
+ * @param {string} [options.stylesheet] url of stylesheet to be injected
+ * @param {boolean} [options.resizeOnOrientationChange] false to disable orientation events
+ * @param {string} [options.script] url of script to be injected
+ * @param {boolean | object} [options.snap=false] use snap scrolling
+ * @param {string} [options.defaultDirection='ltr'] default text direction
+ * @param {boolean} [options.allowScriptedContent=false] enable running scripts in content
+ * @param {boolean} [options.allowPopups=false] enable opening popup in content
+ */
+interface RenditionHooks {
+    display: Hook;
+    serialize: Hook;
+    content: Hook;
+    unloaded: Hook;
+    layout: Hook;
+    render: Hook;
+    show: Hook;
+}
+declare class Rendition implements IEventEmitter {
+    settings: RenditionOptions & Record<string, any>;
+    book: Book | undefined;
+    hooks: RenditionHooks;
+    themes: Themes;
+    annotations: Annotations;
+    epubcfi: EpubCFI;
+    q: Queue;
+    location: Location | undefined;
+    starting: defer;
+    started: Promise<void>;
+    manager: DefaultViewManager | undefined;
+    ViewManager: typeof DefaultViewManager | typeof ContinuousViewManager | Function;
+    View: typeof IframeView | Function;
+    _layout: Layout | undefined;
+    displaying: defer | undefined;
+    on: IEventEmitter["on"];
+    off: IEventEmitter["off"];
+    emit: IEventEmitter["emit"];
+    constructor(book: Book, options?: RenditionOptions);
+    /**
+     * Set the manager function
+     * @param {function} manager
+     */
+    setManager(manager: DefaultViewManager): void;
+    /**
+     * Require the manager from passed string, or as a class function
+     * @param  {string|object} manager [description]
+     * @return {method}
+     */
+    requireManager(manager: string | Function | object): typeof DefaultViewManager | typeof ContinuousViewManager | Function;
+    /**
+     * Require the view from passed string, or as a class function
+     * @param  {string|object} view
+     * @return {view}
+     */
+    requireView(view: string | Function | object): typeof IframeView | Function;
+    /**
+     * Start the rendering
+     * @return {Promise} rendering has started
+     */
+    start(): void;
+    /**
+     * Call to attach the container to an element in the dom
+     * Container must be attached before rendering can begin
+     * @param  {element} element to attach to
+     * @return {Promise}
+     */
+    attachTo(element: HTMLElement | string): Promise<void>;
+    /**
+     * Display a point in the book
+     * The request will be added to the rendering Queue,
+     * so it will wait until book is opened, rendering started
+     * and all other rendering tasks have finished to be called.
+     * @param  {string} target Url or EpubCFI
+     * @return {Promise}
+     */
+    display(target?: string | number): Promise<Section>;
+    /**
+     * Tells the manager what to display immediately
+     * @private
+     * @param  {string} target Url or EpubCFI
+     * @return {Promise}
+     */
+    _display(target?: string | number): Promise<Section> | undefined;
+    /**
+     * Report what section has been displayed
+     * @private
+     * @param  {*} view
+     */
+    afterDisplayed(view: any): void;
+    /**
+     * Report what has been removed
+     * @private
+     * @param  {*} view
+     */
+    afterRemoved(view: any): void;
+    /**
+     * Report resize events and display the last seen location
+     * @private
+     */
+    onResized(size: SizeObject, epubcfi?: string): void;
+    /**
+     * Report orientation events and display the last seen location
+     * @private
+     */
+    onOrientationChange(orientation: string): void;
+    /**
+     * Move the Rendition to a specific offset
+     * Usually you would be better off calling display()
+     * @param {object} offset
+     */
+    moveTo(offset: {
+        left: number;
+        top: number;
+    }): void;
+    /**
+     * Trigger a resize of the views
+     * @param {number} [width]
+     * @param {number} [height]
+     * @param {string} [epubcfi] (optional)
+     */
+    resize(width?: number, height?: number, epubcfi?: string): void;
+    /**
+     * Clear all rendered views
+     */
+    clear(): void;
+    /**
+     * Go to the next "page" in the rendition
+     * @return {Promise}
+     */
+    next(): Promise<any>;
+    /**
+     * Go to the previous "page" in the rendition
+     * @return {Promise}
+     */
+    prev(): Promise<any>;
+    /**
+     * Determine the Layout properties from metadata and settings
+     * @private
+     * @param  {object} metadata
+     * @return {object} properties
+     */
+    determineLayoutProperties(metadata: PackagingMetadataObject & Record<string, any>): GlobalLayout;
+    /**
+     * Adjust the flow of the rendition to paginated or scrolled
+     * (scrolled-continuous vs scrolled-doc are handled by different view managers)
+     * @param  {string} flow
+     */
+    flow(flow: string): void;
+    /**
+     * Adjust the layout of the rendition to reflowable or pre-paginated
+     * @param  {object} settings
+     */
+    layout(settings?: GlobalLayout): Layout | undefined;
+    /**
+     * Adjust if the rendition uses spreads
+     * @param  {string} spread none | auto (TODO: implement landscape, portrait, both)
+     * @param  {int} [min] min width to use spreads at
+     */
+    spread(spread: string, min?: number): void;
+    /**
+     * Adjust the direction of the rendition
+     * @param  {string} dir
+     */
+    direction(dir?: string): void;
+    /**
+     * Report the current location
+     * @fires relocated
+     * @fires locationChanged
+     */
+    reportLocation(): Promise<void>;
+    /**
+     * Get the Current Location object
+     * @return {displayedLocation | promise} location (may be a promise)
+     */
+    currentLocation(): Location | undefined;
+    /**
+     * Creates a Rendition#locationRange from location
+     * passed by the Manager
+     * @returns {displayedLocation}
+     * @private
+     */
+    located(location: ViewLocation[]): Location | undefined;
+    /**
+     * Remove and Clean Up the Rendition
+     */
+    destroy(): void;
+    /**
+     * Pass the events from a view's Contents
+     * @private
+     * @param  {Contents} view contents
+     */
+    passEvents(contents: Contents): void;
+    /**
+     * Emit events passed by a view
+     * @private
+     * @param  {event} e
+     */
+    triggerViewEvent(e: Event, contents: Contents): void;
+    /**
+     * Emit a selection event's CFI Range passed from a a view
+     * @private
+     * @param  {string} cfirange
+     */
+    triggerSelectedEvent(cfirange: string, contents: Contents): void;
+    /**
+     * Emit a markClicked event with the cfiRange and data from a mark
+     * @private
+     * @param  {EpubCFI} cfirange
+     */
+    triggerMarkEvent(cfiRange: string, data: object, contents: Contents): void;
+    /**
+     * Get a Range from a Visible CFI
+     * @param  {string} cfi EpubCfi String
+     * @param  {string} ignoreClass
+     * @return {range}
+     */
+    getRange(cfi: string, ignoreClass?: string): Range | undefined;
+    /**
+     * Hook to adjust images to fit in columns
+     * @param  {Contents} contents
+     * @private
+     */
+    adjustImages(contents: Contents): Promise<void>;
+    /**
+     * Get the Contents object of each rendered view
+     * @returns {Contents[]}
+     */
+    getContents(): Contents[];
+    /**
+     * Get the views member from the manager
+     * @returns {Views}
+     */
+    views(): any;
+    /**
+     * Hook to handle link clicks in rendered content
+     * @param  {Contents} contents
+     * @private
+     */
+    handleLinks(contents: Contents): void;
+    /**
+     * Hook to handle injecting stylesheet before
+     * a Section is serialized
+     * @param  {document} doc
+     * @param  {Section} section
+     * @private
+     */
+    injectStylesheet(doc: Document, _section: Section): void;
+    /**
+     * Hook to handle injecting scripts before
+     * a Section is serialized
+     * @param  {document} doc
+     * @param  {Section} section
+     * @private
+     */
+    injectScript(doc: Document, _section: Section): void;
+    /**
+     * Hook to handle the document identifier before
+     * a Section is serialized
+     * @param  {document} doc
+     * @param  {Section} section
+     * @private
+     */
+    injectIdentifier(doc: Document, _section: Section): void;
+}
+export default Rendition;

package/dist/resources.d.ts

@@ -0,0 +1,97 @@
+import { PackagingManifestObject, PackagingManifestItem, RequestFunction } from './types';
+import { default as Archive } from './archive';
+/**
+ * Handle Package Resources
+ * @class
+ * @param {Manifest} manifest
+ * @param {object} [options]
+ * @param {string} [options.replacements="base64"]
+ * @param {Archive} [options.archive]
+ * @param {method} [options.resolver]
+ */
+declare class Resources {
+    settings: {
+        replacements: string;
+        archive: Archive;
+        resolver: (href: string, absolute?: boolean) => string;
+        request: RequestFunction;
+    };
+    manifest: PackagingManifestObject;
+    resources: PackagingManifestItem[];
+    replacementUrls: string[];
+    html: PackagingManifestItem[];
+    assets: PackagingManifestItem[];
+    css: PackagingManifestItem[];
+    urls: string[];
+    cssUrls: string[];
+    constructor(manifest: PackagingManifestObject, options?: {
+        replacements?: string;
+        archive?: Archive;
+        resolver?: (href: string, absolute?: boolean) => string;
+        request?: RequestFunction;
+    });
+    /**
+     * Process resources
+     * @param {Manifest} manifest
+     */
+    process(manifest: PackagingManifestObject): void;
+    /**
+     * Split resources by type
+     * @private
+     */
+    split(): void;
+    /**
+     * Convert split resources into Urls
+     * @private
+     */
+    splitUrls(): void;
+    /**
+     * Create a url to a resource
+     * @param {string} url
+     * @return {Promise<string>} Promise resolves with url string
+     */
+    createUrl(url: string): Promise<string>;
+    /**
+     * Create blob urls for all the assets
+     * @return {Promise}         returns replacement urls
+     */
+    replacements(): Promise<string[]>;
+    /**
+     * Replace URLs in CSS resources
+     * @private
+     * @param  {Archive} [archive]
+     * @param  {method} [resolver]
+     * @return {Promise}
+     */
+    replaceCss(archive?: Archive, resolver?: (href: string, absolute?: boolean) => string): Promise<(string | void)[]>;
+    /**
+     * Create a new CSS file with the replaced URLs
+     * @private
+     * @param  {string} href the original css file
+     * @return {Promise}  returns a BlobUrl to the new CSS file or a data url
+     */
+    createCssFile(href: string): Promise<string | void>;
+    /**
+     * Resolve all resources URLs relative to an absolute URL
+     * @param  {string} absolute to be resolved to
+     * @param  {resolver} [resolver]
+     * @return {string[]} array with relative Urls
+     */
+    relativeTo(absolute: string, resolver?: (href: string, absolute?: boolean) => string): string[];
+    /**
+     * Get a URL for a resource
+     * @param  {string} path
+     * @return {string} url
+     */
+    get(path: string): Promise<string> | undefined;
+    /**
+     * Substitute urls in content, with replacements,
+     * relative to a url if provided
+     * @param  {string} content
+     * @param  {string} [url]   url to resolve to
+     * @return {string}         content with urls substituted
+     */
+    substitute(content: string, url?: string): string;
+    destroy(): void;
+}
+export default Resources;

package/dist/section.d.ts

@@ -0,0 +1,88 @@
+import { default as Hook } from './utils/hook';
+import { SpineItem, GlobalLayout, SearchResult, RequestFunction } from './types';
+/**
+ * Represents a Section of the Book
+ *
+ * In most books this is equivalent to a Chapter
+ * @param {object} item  The spine item representing the section
+ * @param {object} hooks hooks for serialize and content
+ */
+declare class Section {
+    idref: string;
+    linear: boolean;
+    properties: string[];
+    index: number;
+    href: string;
+    url: string;
+    canonical: string;
+    next: () => SpineItem | undefined;
+    prev: () => SpineItem | undefined;
+    cfiBase: string;
+    hooks: {
+        serialize: Hook;
+        content: Hook;
+    };
+    document: Document | undefined;
+    contents: Element | undefined;
+    output: string | undefined;
+    request: RequestFunction;
+    constructor(item: SpineItem, hooks?: {
+        serialize: Hook;
+        content: Hook;
+    });
+    /**
+     * Load the section from its url
+     * @param  {method} [_request] a request method to use for loading
+     * @return {document} a promise with the xml document
+     */
+    load(_request?: RequestFunction): Promise<Element>;
+    /**
+     * Adds a base tag for resolving urls in the section
+     * @private
+     */
+    base(): void;
+    /**
+     * Render the contents of a section
+     * @param  {method} [_request] a request method to use for loading
+     * @return {string} output a serialized XML Document
+     */
+    render(_request?: RequestFunction): Promise<string>;
+    /**
+     * Find a string in a section
+     * @param  {string} _query The query string to find
+     * @return {object[]} A list of matches, with form {cfi, excerpt}
+     */
+    find(_query: string): SearchResult[];
+    /**
+     * Search a string in multiple sequential Element of the section. If the document.createTreeWalker api is missed(eg: IE8), use `find` as a fallback.
+     * @param  {string} _query The query string to search
+     * @param  {int} maxSeqEle The maximum number of Element that are combined for search, default value is 5.
+     * @return {object[]} A list of matches, with form {cfi, excerpt}
+     */
+    search(_query: string, maxSeqEle?: number): SearchResult[];
+    /**
+    * Reconciles the current chapters layout properties with
+    * the global layout properties.
+    * @param {object} globalLayout  The global layout settings object, chapter properties string
+    * @return {object} layoutProperties Object with layout properties
+    */
+    reconcileLayoutSettings(globalLayout: GlobalLayout): Record<string, string>;
+    /**
+     * Get a CFI from a Range in the Section
+     * @param  {range} _range
+     * @return {string} cfi an EpubCFI string
+     */
+    cfiFromRange(_range: Range): string;
+    /**
+     * Get a CFI from an Element in the Section
+     * @param  {element} el
+     * @return {string} cfi an EpubCFI string
+     */
+    cfiFromElement(el: Element): string;
+    /**
+     * Unload the section document
+     */
+    unload(): void;
+    destroy(): void;
+}
+export default Section;

package/dist/spine.d.ts

@@ -0,0 +1,79 @@
+import { default as EpubCFI } from './epubcfi';
+import { default as Hook } from './utils/hook';
+import { default as Section } from './section';
+import { PackagingManifestObject, PackagingObject, SpineItem } from './types';
+/**
+ * A collection of Spine Items
+ */
+declare class Spine {
+    spineItems: Section[];
+    spineByHref: Record<string, number>;
+    spineById: Record<string, number>;
+    hooks: {
+        serialize: Hook;
+        content: Hook;
+    };
+    epubcfi: EpubCFI;
+    loaded: boolean;
+    items: SpineItem[];
+    manifest: PackagingManifestObject;
+    spineNodeIndex: number;
+    baseUrl: string;
+    length: number;
+    constructor();
+    /**
+     * Unpack items from a opf into spine items
+     * @param  {Packaging} _package
+     * @param  {method} resolver URL resolver
+     * @param  {method} canonical Resolve canonical url
+     */
+    unpack(_package: PackagingObject & {
+        baseUrl?: string;
+        basePath?: string;
+    }, resolver: (href: string, absolute?: boolean) => string, canonical: (href: string) => string): void;
+    /**
+     * Get an item from the spine
+     * @param  {string|number} [target]
+     * @return {Section} section
+     * @example spine.get();
+     * @example spine.get(1);
+     * @example spine.get("chap1.html");
+     * @example spine.get("#id1234");
+     */
+    get(target?: string | number): Section | null;
+    /**
+     * Append a Section to the Spine
+     * @private
+     * @param  {Section} section
+     */
+    append(section: Section): number;
+    /**
+     * Prepend a Section to the Spine
+     * @private
+     * @param  {Section} section
+     */
+    prepend(section: Section): number;
+    /**
+     * Remove a Section from the Spine
+     * @private
+     * @param  {Section} section
+     */
+    remove(section: Section): Section[] | undefined;
+    /**
+     * Loop over the Sections in the Spine
+     * @return {method} forEach
+     */
+    each(...args: any[]): void;
+    /**
+     * Find the first Section in the Spine
+     * @return {Section} first section
+     */
+    first(): Section | undefined;
+    /**
+     * Find the last Section in the Spine
+     * @return {Section} last section
+     */
+    last(): Section | undefined;
+    destroy(): void;
+}
+export default Spine;

package/dist/store.d.ts

@@ -0,0 +1,122 @@
+import { IEventEmitter, RequestFunction } from './types';
+/**
+ * Handles saving and requesting files from local storage
+ * @class
+ * @param {string} name This should be the name of the application for modals
+ * @param {function} [requester]
+ * @param {function} [resolver]
+ */
+declare class Store implements IEventEmitter {
+    on: (type: string, fn: (...args: any[]) => void) => this;
+    off: (type: string, fn?: (...args: any[]) => void) => this;
+    emit: (type: string, ...args: any[]) => void;
+    urlCache: Record<string, string>;
+    storage: any;
+    name: string;
+    requester: RequestFunction;
+    resolver: (href: string) => string;
+    online: boolean;
+    _status: ((event: Event) => void) | undefined;
+    constructor(name: string, requester?: RequestFunction, resolver?: (href: string) => string);
+    /**
+     * Checks to see if localForage exists in global namspace,
+     * Requires localForage if it isn't there
+     * @private
+     */
+    checkRequirements(): void;
+    /**
+     * Add online and offline event listeners
+     * @private
+     */
+    addListeners(): void;
+    /**
+     * Remove online and offline event listeners
+     * @private
+     */
+    removeListeners(): void;
+    /**
+     * Update the online / offline status
+     * @private
+     */
+    status(_event: Event): void;
+    /**
+     * Add all of a book resources to the store
+     * @param  {Resources} resources  book resources
+     * @param  {boolean} [force] force resaving resources
+     * @return {Promise<object>} store objects
+     */
+    add(resources: {
+        resources: Array<{
+            href: string;
+        }>;
+    }, force?: boolean): Promise<any[]>;
+    /**
+     * Put binary data from a url to storage
+     * @param  {string} url  a url to request from storage
+     * @param  {boolean} [withCredentials]
+     * @param  {object} [headers]
+     * @return {Promise<Blob>}
+     */
+    put(url: string, withCredentials?: boolean, headers?: Record<string, string>): Promise<any>;
+    /**
+     * Request a url
+     * @param  {string} url  a url to request from storage
+     * @param  {string} [type] specify the type of the returned result
+     * @param  {boolean} [withCredentials]
+     * @param  {object} [headers]
+     * @return {Promise<Blob | string | JSON | Document | XMLDocument>}
+     */
+    request(url: string, type?: string, withCredentials?: boolean, headers?: Record<string, string>): Promise<any>;
+    /**
+     * Request a url from storage
+     * @param  {string} url  a url to request from storage
+     * @param  {string} [type] specify the type of the returned result
+     * @return {Promise<Blob | string | JSON | Document | XMLDocument>}
+     */
+    retrieve(url: string, type?: string): Promise<any>;
+    /**
+     * Handle the response from request
+     * @private
+     * @param  {any} response
+     * @param  {string} [type]
+     * @return {any} the parsed result
+     */
+    handleResponse(response: any, type?: string): any;
+    /**
+     * Get a Blob from Storage by Url
+     * @param  {string} url
+     * @param  {string} [mimeType]
+     * @return {Blob}
+     */
+    getBlob(url: string, mimeType?: string): Promise<Blob | undefined>;
+    /**
+     * Get Text from Storage by Url
+     * @param  {string} url
+     * @param  {string} [mimeType]
+     * @return {string}
+     */
+    getText(url: string, mimeType?: string): Promise<any>;
+    /**
+     * Get a base64 encoded result from Storage by Url
+     * @param  {string} url
+     * @param  {string} [mimeType]
+     * @return {string} base64 encoded
+     */
+    getBase64(url: string, mimeType?: string): Promise<any>;
+    /**
+     * Create a Url from a stored item
+     * @param  {string} url
+     * @param  {object} [options.base64] use base64 encoding or blob url
+     * @return {Promise} url promise with Url string
+     */
+    createUrl(url: string, options?: {
+        base64?: boolean;
+    }): Promise<string>;
+    /**
+     * Revoke Temp Url for a archive item
+     * @param  {string} url url of the item in the store
+     */
+    revokeUrl(url: string): void;
+    destroy(): void;
+}
+export default Store;