@likecoin/epub-ts 0.4.3 → 0.4.4

package/dist/layout.d.ts

@@ -13,7 +13,7 @@ import { default as Section } from './section';
 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;
+    emit: (type: string, ...args: unknown[]) => void;
     settings: LayoutSettings;
     name: string;
     _spread: boolean;

package/dist/locations.d.ts

@@ -12,7 +12,7 @@ import { default as Section } from './section';
 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;
+    emit: (type: string, ...args: unknown[]) => void;
     spine: Spine | undefined;
     request: RequestFunction | undefined;
     pause: number | undefined;

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

@@ -18,7 +18,7 @@ declare class ContinuousViewManager extends DefaultViewManager {
     trimTimeout: ReturnType<typeof setTimeout>;
     constructor(options: ManagerOptions);
     display(section: Section, target?: string): Promise<any>;
-    fill(_full?: InstanceType<typeof defer>): Promise<any>;
+    fill(_full?: defer<void>): Promise<void>;
     moveTo(offset: {
         left: number;
         top: number;

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

@@ -9,7 +9,7 @@ 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;
+    optsSettings: ManagerOptions["settings"];
     View: new (section: Section, options?: ViewSettings) => IframeView;
     request: RequestFunction;
     renditionQueue: Queue;

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

@@ -75,8 +75,8 @@ declare class IframeView implements IEventEmitter {
     reframe(width: number, height: number): void;
     load(contents: string): Promise<Contents>;
     onLoad(event: Event, promise: {
-        resolve: (value?: any) => void;
-        reject: (reason?: any) => void;
+        resolve: (value: Contents | PromiseLike<Contents>) => void;
+        reject: (reason?: unknown) => void;
     }): void;
     setLayout(layout: Layout): void;
     setAxis(axis: string): void;

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

@@ -1,8 +1,14 @@
-import { IEventEmitter, ViewSettings } from '../../types';
+import { default as EpubCFI } from '../../epubcfi';
+import { default as Contents } from '../../contents';
+import { default as Section } from '../../section';
+import { default as Layout } from '../../layout';
+import { IEventEmitter, ViewSettings, RequestFunction, SizeObject, ReframeBounds } from '../../types';
 declare class InlineView implements IEventEmitter {
-    settings: any;
+    settings: ViewSettings & {
+        layout: Layout;
+    };
     id: string;
-    section: any;
+    section: Section;
     index: number;
     element: HTMLElement;
     added: boolean;
@@ -12,8 +18,8 @@ declare class InlineView implements IEventEmitter {
     height: number;
     fixedWidth: number;
     fixedHeight: number;
-    epubcfi: any;
-    layout: any;
+    epubcfi: EpubCFI;
+    layout: Layout;
     frame: HTMLDivElement | undefined;
     resizing: boolean;
     _width: number | undefined;
@@ -22,44 +28,44 @@ declare class InlineView implements IEventEmitter {
     _textHeight: number | undefined;
     _needsReframe: boolean;
     _expanding: boolean;
-    elementBounds: any;
-    prevBounds: any;
+    elementBounds: SizeObject | undefined;
+    prevBounds: SizeObject | undefined;
     lockedWidth: number;
     lockedHeight: number;
     document: Document;
     window: Window;
-    contents: any;
+    contents: Contents | undefined;
     rendering: boolean;
     stopExpanding: boolean;
     on: IEventEmitter["on"];
     off: IEventEmitter["off"];
     emit: IEventEmitter["emit"];
-    constructor(section: any, options?: ViewSettings);
+    constructor(section: Section, options?: ViewSettings);
     container(axis?: string): HTMLElement;
     create(): HTMLDivElement;
-    render(request: any, show?: boolean): Promise<any>;
+    render(request: RequestFunction, show?: boolean): Promise<void>;
     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;
+    resize(width: number | false, height: number | false): void;
+    load(contents: string): Promise<Contents>;
+    setLayout(layout: Layout): void;
     resizeListenters(): void;
     addListeners(): void;
-    removeListeners(_layoutFunc?: any): void;
-    display(request: any): Promise<any>;
+    removeListeners(): void;
+    display(request: RequestFunction): Promise<InlineView>;
     show(): void;
     hide(): void;
     position(): DOMRect;
-    locationOf(target: any): {
+    locationOf(target: string): {
         left: number;
         top: number;
     };
-    onDisplayed(_view: any): void;
-    onResize(_view: any, _e?: any): void;
-    bounds(): any;
+    onDisplayed(_view: InlineView): void;
+    onResize(_view: InlineView, _e?: ReframeBounds): void;
+    bounds(): SizeObject;
     destroy(): void;
 }
 export default InlineView;

package/dist/rendition.d.ts

@@ -46,7 +46,7 @@ interface RenditionHooks {
     show: Hook;
 }
 declare class Rendition implements IEventEmitter {
-    settings: RenditionOptions & Record<string, any>;
+    settings: RenditionOptions;
     book: Book | undefined;
     hooks: RenditionHooks;
     themes: Themes;
@@ -54,13 +54,13 @@ declare class Rendition implements IEventEmitter {
     epubcfi: EpubCFI;
     q: Queue;
     location: Location | undefined;
-    starting: defer;
+    starting: defer<void>;
     started: Promise<void>;
     manager: DefaultViewManager | undefined;
     ViewManager: typeof DefaultViewManager | typeof ContinuousViewManager | Function;
     View: typeof IframeView | Function;
     _layout: Layout | undefined;
-    displaying: defer | undefined;
+    displaying: defer<Section | undefined> | undefined;
     on: IEventEmitter["on"];
     off: IEventEmitter["off"];
     emit: IEventEmitter["emit"];
@@ -109,7 +109,7 @@ declare class Rendition implements IEventEmitter {
      * @param  {string} target Url or EpubCFI
      * @return {Promise}
      */
-    _display(target?: string | number): Promise<Section> | undefined;
+    _display(target?: string | number): Promise<Section | undefined> | undefined;
     /**
      * Report what section has been displayed
      * @private
@@ -168,7 +168,7 @@ declare class Rendition implements IEventEmitter {
      * @param  {object} metadata
      * @return {object} properties
      */
-    determineLayoutProperties(metadata: PackagingMetadataObject & Record<string, any>): GlobalLayout;
+    determineLayoutProperties(metadata: PackagingMetadataObject): GlobalLayout;
     /**
      * Adjust the flow of the rendition to paginated or scrolled
      * (scrolled-continuous vs scrolled-doc are handled by different view managers)

package/dist/spine.d.ts

@@ -1,7 +1,8 @@
 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';
+import { default as Packaging } from './packaging';
+import { PackagingManifestObject, SpineItem } from './types';
 /**
  * A collection of Spine Items
  */
@@ -27,7 +28,7 @@ declare class Spine {
      * @param  {method} resolver URL resolver
      * @param  {method} canonical Resolve canonical url
      */
-    unpack(_package: PackagingObject & {
+    unpack(_package: Packaging & {
         baseUrl?: string;
         basePath?: string;
     }, resolver: (href: string, absolute?: boolean) => string, canonical: (href: string) => string): void;

package/dist/store.d.ts

@@ -1,7 +1,7 @@
 import { IEventEmitter, RequestFunction } from './types';
 interface SimpleStorage {
-    getItem(key: string): Promise<any>;
-    setItem(key: string, value: any): Promise<any>;
+    getItem(key: string): Promise<Uint8Array | null>;
+    setItem(key: string, value: Uint8Array): Promise<Uint8Array>;
 }
 /**
  * Handles saving and requesting files from local storage
@@ -13,7 +13,7 @@ interface SimpleStorage {
 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;
+    emit: (type: string, ...args: unknown[]) => void;
     urlCache: Record<string, string>;
     storage: SimpleStorage;
     name: string;
@@ -52,7 +52,7 @@ declare class Store implements IEventEmitter {
         resources: Array<{
             href: string;
         }>;
-    }, force?: boolean): Promise<any[]>;
+    }, force?: boolean): Promise<(Uint8Array | null)[]>;
     /**
      * Put binary data from a url to storage
      * @param  {string} url  a url to request from storage
@@ -60,7 +60,7 @@ declare class Store implements IEventEmitter {
      * @param  {object} [headers]
      * @return {Promise<Blob>}
      */
-    put(url: string, withCredentials?: boolean, headers?: Record<string, string>): Promise<any>;
+    put(url: string, withCredentials?: boolean, headers?: Record<string, string>): Promise<Uint8Array | null>;
     /**
      * Request a url
      * @param  {string} url  a url to request from storage
@@ -69,22 +69,22 @@ declare class Store implements IEventEmitter {
      * @param  {object} [headers]
      * @return {Promise<Blob | string | JSON | Document | XMLDocument>}
      */
-    request(url: string, type?: string, withCredentials?: boolean, headers?: Record<string, string>): Promise<any>;
+    request(url: string, type?: string, withCredentials?: boolean, headers?: Record<string, string>): Promise<unknown>;
     /**
      * 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>;
+    retrieve(url: string, type?: string): Promise<unknown>;
     /**
      * Handle the response from request
      * @private
-     * @param  {any} response
+     * @param  {string | Blob} response
      * @param  {string} [type]
-     * @return {any} the parsed result
+     * @return {string | Document | Blob | object} the parsed result
      */
-    handleResponse(response: any, type?: string): any;
+    handleResponse(response: string | Blob, type?: string): string | Document | Blob | object;
     /**
      * Get a Blob from Storage by Url
      * @param  {string} url

package/dist/types.d.ts

@@ -1,14 +1,15 @@
 import { default as Section } from './section';
-export interface Deferred<T = any> {
+import { default as Queue } from './utils/queue';
+export interface Deferred<T = unknown> {
     id: string;
-    resolve: (value?: T | PromiseLike<T>) => void;
-    reject: (reason?: any) => void;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: unknown) => void;
     promise: Promise<T>;
 }
 export interface IEventEmitter {
-    on(type: string, fn: (...args: any[]) => void): any;
-    off(type: string, fn?: (...args: any[]) => void): any;
-    emit(type: string, ...args: any[]): void;
+    on(type: string, fn: (...args: any[]) => void): unknown;
+    off(type: string, fn?: (...args: any[]) => void): unknown;
+    emit(type: string, ...args: unknown[]): void;
     __listeners?: Record<string, Array<(...args: any[]) => void>>;
 }
 export interface PackagingMetadataObject {
@@ -28,6 +29,7 @@ export interface PackagingMetadataObject {
     media_active_class: string;
     spread: string;
     direction: string;
+    minSpreadWidth?: number;
 }
 export interface PackagingSpineItem {
     id?: string;
@@ -115,6 +117,10 @@ export interface RenditionOptions {
     defaultDirection?: string;
     allowScriptedContent?: boolean;
     allowPopups?: boolean;
+    globalLayoutProperties?: GlobalLayout;
+    direction?: string;
+    orientation?: string;
+    gap?: number;
 }
 export interface DisplayedLocation {
     index: number;
@@ -184,7 +190,7 @@ export interface EpubCFIComponent {
         assertion: string | null;
     };
 }
-export type RequestFunction = (url: string, type?: string, withCredentials?: boolean, headers?: Record<string, string>) => Promise<any>;
+export type RequestFunction = (url: string, type?: string, withCredentials?: boolean, headers?: Record<string, string>) => Promise<unknown>;
 export interface SizeObject {
     width: number;
     height: number;
@@ -229,10 +235,18 @@ export interface ManagerOptions extends ViewSettings {
     snap?: boolean | object;
     view?: string | Function | object;
     request?: RequestFunction;
-    [key: string]: any;
+    size?: SizeObject;
+    rtlScrollType?: string;
+    offset?: number;
+    afterScrolledTimeout?: number;
+    gap?: number;
+    offsetDelta?: number;
+    resizeOnOrientationChange?: boolean;
+    queue?: Queue;
+    settings?: RenditionOptions;
 }
 export interface HooksObject {
-    [key: string]: any;
+    [key: string]: unknown;
 }
 export interface StageOptions {
     width?: number | string;
@@ -265,3 +279,9 @@ export interface ParsedPath {
     ext: string;
     name: string;
 }
+declare global {
+    interface Window {
+        webkitURL?: typeof URL;
+        mozURL?: typeof URL;
+    }
+}

package/dist/utils/core.d.ts

@@ -52,14 +52,14 @@ export declare function prefixed(unprefixed: string): string;
  * @returns {object}
  * @memberof Core
  */
-export declare function defaults(obj: any, ...sources: any[]): any;
+export declare function defaults<T extends object>(obj: T, ...sources: object[]): T;
 /**
  * Extend properties of an object
  * @param {object} target
  * @returns {object}
  * @memberof Core
  */
-export declare function extend(target: any, ...sources: any[]): any;
+export declare function extend<T extends object>(target: T, ...sources: (object | null | undefined)[]): T;
 /**
  * Fast quicksort insert for sorted array -- based on:
  *  http://stackoverflow.com/questions/1344500/efficient-way-to-insert-a-number-into-a-sorted-array-of-numbers
@@ -69,7 +69,7 @@ export declare function extend(target: any, ...sources: any[]): any;
  * @returns {number} location (in array)
  * @memberof Core
  */
-export declare function insert(item: any, array: any[], compareFunction?: (a: any, b: any) => number): number;
+export declare function insert<T>(item: T, array: T[], compareFunction?: (a: T, b: T) => number): number;
 /**
  * Finds where something would fit into a sorted array
  * @param {any} item
@@ -80,7 +80,7 @@ export declare function insert(item: any, array: any[], compareFunction?: (a: an
  * @returns {number} location (in array)
  * @memberof Core
  */
-export declare function locationOf(item: any, array: any[], compareFunction?: (a: any, b: any) => number, _start?: number, _end?: number): number;
+export declare function locationOf<T>(item: T, array: T[], compareFunction?: (a: T, b: T) => number, _start?: number, _end?: number): number;
 /**
  * Finds index of something in a sorted array
  * Returns -1 if not found
@@ -92,7 +92,7 @@ export declare function locationOf(item: any, array: any[], compareFunction?: (a
  * @returns {number} index (in array) or -1
  * @memberof Core
  */
-export declare function indexOfSorted(item: any, array: any[], compareFunction?: (a: any, b: any) => number, _start?: number, _end?: number): number;
+export declare function indexOfSorted<T>(item: T, array: T[], compareFunction?: (a: T, b: T) => number, _start?: number, _end?: number): number;
 /**
  * Find the bounds of an element
  * taking padding and margin into account
@@ -217,7 +217,7 @@ export declare function parse(markup: string, mime: string): Document;
  * @returns {element} element
  * @memberof Core
  */
-export declare function qs(el: Document | Element, sel: string): Element | undefined;
+export declare function qs(el: Document | Element, sel: string): Element | null;
 /**
  * querySelectorAll wrapper
  * @param {element} el
@@ -267,11 +267,11 @@ export declare function blob2base64(blob: Blob): Promise<string | ArrayBuffer>;
  * Creates a new pending promise and provides methods to resolve or reject it.
  * From: https://developer.mozilla.org/en-US/docs/Mozilla/JavaScript_code_modules/Promise.jsm/Deferred#backwards_forwards_compatible
  */
-export declare class defer {
+export declare class defer<T = unknown> {
     id: string;
-    resolve: (value?: any) => void;
-    reject: (reason?: any) => void;
-    promise: Promise<any>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: unknown) => void;
+    promise: Promise<T>;
     constructor();
 }
 /**

package/dist/utils/event-emitter.d.ts

@@ -3,4 +3,4 @@
  * Drop-in replacement for the "event-emitter" npm package.
  * Supports on(type, fn), off(type, fn), emit(type, ...args).
  */
-export default function EventEmitter(target: any): any;
+export default function EventEmitter(target: object): object;

package/dist/utils/queue.d.ts

@@ -1,37 +1,45 @@
+import { defer } from './core';
+interface QueueItem {
+    task?: (...args: unknown[]) => unknown;
+    args: unknown[];
+    deferred?: defer<unknown>;
+    promise: Promise<unknown>;
+}
 /**
  * Queue for handling tasks one at a time
  * @class
  * @param {scope} context what this will resolve to in the tasks
  */
 declare class Queue {
-    _q: any[];
-    context: any;
-    tick: any;
-    running: any;
+    _q: QueueItem[];
+    context: object | undefined;
+    tick: ((cb: FrameRequestCallback) => number) | false;
+    running: boolean | Promise<void> | undefined;
     paused: boolean;
-    defered: any;
-    constructor(context: any);
+    defered: defer<void> | undefined;
+    constructor(context?: object);
     /**
      * Add an item to the queue
      * @return {Promise}
      */
-    enqueue(..._args: any[]): Promise<any>;
+    enqueue<R>(promise: Promise<R>): Promise<R>;
+    enqueue<A extends unknown[], R>(task: (...args: A) => R, ...args: A): Promise<Awaited<R>>;
     /**
      * Run one item
      * @return {Promise}
      */
-    dequeue(): any;
+    dequeue(): Promise<unknown> | undefined;
     dump(): void;
     /**
      * Run all tasks sequentially, at convince
      * @return {Promise}
      */
-    run(): Promise<any>;
+    run(): Promise<void>;
     /**
      * Flush all, as quickly as possible
      * @return {Promise}
      */
-    flush(): any;
+    flush(): Promise<void> | undefined;
     /**
      * Clear all items in wait
      */
@@ -60,7 +68,7 @@ declare class Queue {
  * @return {function} task
  */
 declare class Task {
-    constructor(task: Function, args: any[], context: any);
+    constructor(task: (...args: unknown[]) => void, args: unknown[], context?: object);
 }
 export default Queue;
 export { Task };

package/dist/utils/request.d.ts

@@ -1,2 +1,2 @@
-declare function request(url: string, type?: string, withCredentials?: boolean, headers?: Record<string, string>): Promise<any>;
+declare function request(url: string, type?: string, withCredentials?: boolean, headers?: Record<string, string>): Promise<unknown>;
 export default request;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@likecoin/epub-ts",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "TypeScript EPUB parser and renderer, forked from epubjs",
   "keywords": [
     "epub",