@readium/shared 1.2.0

package/types/src/publication/services/content/iterators/PublicationContentIterator.d.ts

@@ -0,0 +1,59 @@
+import { Resource } from "../../../../fetcher/Resource";
+import { Locator } from "../../../Locator";
+import { Publication } from "../../../Publication";
+import { Iterator } from "../Iterator";
+import { ContentElement } from "../element";
+export type ResourceContentIteratorFactory = (resource: Resource, locator: Locator) => Iterator | null;
+export declare class PublicationContentIterator extends Iterator {
+    /**
+     * The [Publication] which will be iterated through.
+     */
+    private publication;
+    /**
+     * Starting [Locator] in the publication.
+     */
+    private startLocator;
+    /**
+     * List of [ResourceContentIteratorFactory] which will be used to create the
+     * iterator for each resource. The factories are tried in order until there's a match.
+     */
+    private resourceContentIteratorFactories;
+    private _currentIterator;
+    private currentElement;
+    constructor(
+    /**
+     * The [Publication] which will be iterated through.
+     */
+    publication: Publication, 
+    /**
+     * Starting [Locator] in the publication.
+     */
+    startLocator: Locator | undefined, 
+    /**
+     * List of [ResourceContentIteratorFactory] which will be used to create the
+     * iterator for each resource. The factories are tried in order until there's a match.
+     */
+    resourceContentIteratorFactories: ResourceContentIteratorFactory[]);
+    hasPrevious(): Promise<boolean>;
+    previous(): ContentElement;
+    hasNext(): Promise<boolean>;
+    next(): ContentElement;
+    private nextIn;
+    /**
+     * Returns the [Iterator] for the current [Resource] in the reading order.
+     */
+    private get currentIterator();
+    /**
+     * Returns the first iterator starting at [startLocator] or the beginning of the publication.
+     */
+    private initialIterator;
+    /**
+     * Returns the next resource iterator in the given [direction], starting from [fromIndex].
+     */
+    private nextIteratorIn;
+    /**
+     * Loads the iterator at the given [index] in the reading order.
+     * The [location] will be used to compute the starting [Locator] for the iterator.
+     */
+    private loadIteratorAt;
+}

package/types/src/publication/services/content/iterators/helpers.d.ts

@@ -0,0 +1,10 @@
+import { LocatorText } from "../../../Locator";
+export declare function isInlineTag(n: Node): boolean;
+export declare function srcRelativeToHref(e: Element, base?: string | URL): string | null;
+export declare const isBlank: (s: string | null) => boolean;
+export declare const trimUnicodeSpace: (s: string) => string;
+export declare const trimUnicodeSpaceStart: (s: string) => string;
+export declare const trimUnicodeSpaceEnd: (s: string) => string;
+export declare const trimmingTextLocator: (text: string, before?: string) => LocatorText;
+export declare function elementLanguage(e: HTMLElement | null): string | null;
+export declare function appendNormalizedWhitespace(accum: string, text: string): string;

package/types/src/publication/services/content/iterators/index.d.ts

@@ -0,0 +1,3 @@
+export * from './PublicationContentIterator';
+export * from './PDFTextContentIterator';
+export * from './HTMLResourceContentIterator';

package/types/src/publication/services/index.d.ts

@@ -0,0 +1 @@
+export * from './content';

package/types/src/util/JSONParse.d.ts

@@ -0,0 +1,11 @@
+/** Parses the given array (or undefined it it's not an array) */
+export declare function arrayfromJSON(json: any): Array<any> | undefined;
+export declare function arrayfromJSONorString(json: any): Array<any> | undefined;
+/** Parses the given key and returns a Date (or undefined if it’s not a string) */
+export declare function datefromJSON(json: any): Date | undefined;
+/** Parses a numeric value, but returns undefined if it is not a positive number. */
+export declare function numberfromJSON(json: any): number | undefined;
+/** Parses a numeric value, but returns undefined if it is not a positive number. */
+export declare function positiveNumberfromJSON(json: any): number | undefined;
+/** Converts a Set of a string to a string Array object */
+export declare function setToArray(obj: Set<string>): Array<string>;

package/types/src/util/Language.d.ts

@@ -0,0 +1 @@
+export type Language = string;

package/types/src/util/URITemplate.d.ts

@@ -0,0 +1,24 @@
+/** A lightweight implementation of URI Template (RFC 6570).
+ *
+ *  Only handles simple cases, fitting Readium's use cases.
+ *  See https://tools.ietf.org/html/rfc6570
+ */
+export declare class URITemplate {
+    uri: string;
+    /**
+     * List of URI template parameter keys, if the [Link] is templated.
+     */
+    parameters: Set<string>;
+    constructor(uri: string);
+    /**
+     * List of URI template parameter keys, if the [Link] is templated.
+     */
+    private getParameters;
+    /** Expands the URI by replacing the template variables by the given parameters.
+     *  Any extra parameter is appended as query parameters.
+     *  See RFC 6570 on URI template: https://tools.ietf.org/html/rfc6570
+     */
+    expand(parameters: {
+        [param: string]: string;
+    }): string;
+}

package/types/src/util/index.d.ts

@@ -0,0 +1,5 @@
+export * from './mediatype';
+export * from './JSONParse';
+export * from './URITemplate';
+export * from './Language';
+export * from './tokenizer';

package/types/src/util/mediatype/MediaType.d.ts

@@ -0,0 +1,148 @@
+type ParametersMap = {
+    [param: string]: string;
+};
+/** Represents a string media type.
+ *  `MediaType` handles:
+ *  - components parsing – eg. type, subtype and parameters,
+ *  - media types comparison.
+ */
+export declare class MediaType {
+    /** The type component, e.g. `application` in `application/epub+zip`. */
+    type: string;
+    /** The subtype component, e.g. `epub+zip` in `application/epub+zip`. */
+    subtype: string;
+    /** The parameters in the media type, such as `charset=utf-8`. */
+    parameters: ParametersMap;
+    /** The string representation of this media type. */
+    string: string;
+    /** Encoding as declared in the `charset` parameter, if there's any. */
+    encoding?: string;
+    /** A human readable name identifying the media type, which may be presented to the user. */
+    name?: string;
+    /** The default file extension to use for this media type. */
+    fileExtension?: string;
+    /** Creates a MediaType object. */
+    constructor(values: {
+        mediaType: string;
+        name?: string;
+        fileExtension?: string;
+    });
+    static parse(values: {
+        mediaType: string;
+        name?: string;
+        fileExtension?: string;
+    }): MediaType;
+    /** Structured syntax suffix, e.g. `+zip` in `application/epub+zip`.
+     *  Gives a hint on the underlying structure of this media type.
+     *  See. https://tools.ietf.org/html/rfc6838#section-4.2.8
+     */
+    get structuredSyntaxSuffix(): string | undefined;
+    /** Parameter values might or might not be case-sensitive, depending on the semantics of
+     * the parameter name.
+     * https://tools.ietf.org/html/rfc2616#section-3.7
+     *
+     * The character set names may be up to 40 characters taken from the printable characters
+     * of US-ASCII.  However, no distinction is made between use of upper and lower case
+     * letters.
+     * https://www.iana.org/assignments/character-sets/character-sets.xhtml
+     */
+    get charset(): string | undefined;
+    /** Returns whether the given `other` media type is included in this media type.
+     *  For example, `text/html` contains `text/html;charset=utf-8`.
+     *  - `other` must match the parameters in the `parameters` property, but extra parameters
+     *  are ignored.
+     *  - Order of parameters is ignored.
+     *  - Wildcards are supported, meaning that `image/*` contains `image/png`
+     */
+    contains(other: MediaType | string): boolean;
+    /** Returns whether this media type and `other` are the same, ignoring parameters that
+     *  are not in both media types.
+     *  For example, `text/html` matches `text/html;charset=utf-8`, but `text/html;charset=ascii`
+     *  doesn't. This is basically like `contains`, but working in both direction.
+     */
+    matches(other: MediaType | string): boolean;
+    /**
+     * Returns whether this media type matches any of the [others] media types.
+     */
+    matchesAny(...others: MediaType[] | string[]): boolean;
+    /** Checks the MediaType equals another one (comparing their string) */
+    equals(other: MediaType): boolean;
+    /** Returns whether this media type is structured as a ZIP archive. */
+    get isZIP(): boolean;
+    /** Returns whether this media type is structured as a JSON file. */
+    get isJSON(): boolean;
+    /** Returns whether this media type is of an OPDS feed. */
+    get isOPDS(): boolean;
+    /** Returns whether this media type is of an HTML document. */
+    get isHTML(): boolean;
+    /** Returns whether this media type is of a bitmap image, so excluding vectorial formats. */
+    get isBitmap(): boolean;
+    /** Returns whether this media type is of an audio clip. */
+    get isAudio(): boolean;
+    /** Returns whether this media type is of a video clip. */
+    get isVideo(): boolean;
+    /** Returns whether this media type is of a Readium Web Publication Manifest. */
+    get isRWPM(): boolean;
+    /** Returns whether this media type is of a publication file. */
+    get isPublication(): boolean;
+    static get AAC(): MediaType;
+    static get ACSM(): MediaType;
+    static get AIFF(): MediaType;
+    static get AVI(): MediaType;
+    static get BINARY(): MediaType;
+    static get BMP(): MediaType;
+    static get CBZ(): MediaType;
+    static get CSS(): MediaType;
+    static get DIVINA(): MediaType;
+    static get DIVINA_MANIFEST(): MediaType;
+    static get EPUB(): MediaType;
+    static get GIF(): MediaType;
+    static get GZ(): MediaType;
+    static get HTML(): MediaType;
+    static get JAVASCRIPT(): MediaType;
+    static get JPEG(): MediaType;
+    static get JSON(): MediaType;
+    static get LCP_LICENSE_DOCUMENT(): MediaType;
+    static get LCP_PROTECTED_AUDIOBOOK(): MediaType;
+    static get LCP_PROTECTED_PDF(): MediaType;
+    static get LCP_STATUS_DOCUMENT(): MediaType;
+    static get LPF(): MediaType;
+    static get MP3(): MediaType;
+    static get MPEG(): MediaType;
+    static get NCX(): MediaType;
+    static get OGG(): MediaType;
+    static get OGV(): MediaType;
+    static get OPDS1(): MediaType;
+    static get OPDS1_ENTRY(): MediaType;
+    static get OPDS2(): MediaType;
+    static get OPDS2_PUBLICATION(): MediaType;
+    static get OPDS_AUTHENTICATION(): MediaType;
+    static get OPUS(): MediaType;
+    static get OTF(): MediaType;
+    static get PDF(): MediaType;
+    static get PNG(): MediaType;
+    static get READIUM_AUDIOBOOK(): MediaType;
+    static get READIUM_AUDIOBOOK_MANIFEST(): MediaType;
+    static get READIUM_CONTENT_DOCUMENT(): MediaType;
+    static get READIUM_GUIDED_NAVIGATION_DOCUMENT(): MediaType;
+    static get READIUM_POSITION_LIST(): MediaType;
+    static get READIUM_WEBPUB(): MediaType;
+    static get READIUM_WEBPUB_MANIFEST(): MediaType;
+    static get SMIL(): MediaType;
+    static get SVG(): MediaType;
+    static get TEXT(): MediaType;
+    static get TIFF(): MediaType;
+    static get TTF(): MediaType;
+    static get W3C_WPUB_MANIFEST(): MediaType;
+    static get WAV(): MediaType;
+    static get WEBM_AUDIO(): MediaType;
+    static get WEBM_VIDEO(): MediaType;
+    static get WEBP(): MediaType;
+    static get WOFF(): MediaType;
+    static get WOFF2(): MediaType;
+    static get XHTML(): MediaType;
+    static get XML(): MediaType;
+    static get ZAB(): MediaType;
+    static get ZIP(): MediaType;
+}
+export {};

package/types/src/util/mediatype/index.d.ts

@@ -0,0 +1 @@
+export * from './MediaType';

package/types/src/util/tokenizer/TextTokenizer.d.ts

@@ -0,0 +1,39 @@
+import { Language } from "../Language";
+import { Tokenizer } from "./Tokenizer";
+export type Range = [number, number];
+/**
+ * A tokenizer splitting a String into range tokens (e.g. words, sentences, etc.).
+ */
+export type TextTokenizer = Tokenizer<string, Range>;
+/**
+ * A text token unit which can be used with a [TextTokenizer].
+ */
+export declare enum TextUnit {
+    Word = "word",
+    Sentence = "sentence",
+    Paragraph = "paragraph"
+}
+export declare const DefaultTextContentTokenizer: (language: Language | null, unit: TextUnit) => TextTokenizer;
+/**
+ * A [TextTokenizer] using the Intl.Segmenter API.
+ * Very aware of language-specific rules since it uses ICU behind the scenes.
+ */
+export declare class IntlTextTokenizer implements TextTokenizer {
+    private unit;
+    private segmenter;
+    constructor(language: Language | null, unit: TextUnit);
+    tokenize(data: string): Range[];
+}
+/**
+ * A [TextTokenizer] using a naive approach to splitting text into tokens.
+ * This is a fallback for browsers that don't support Intl.Segmenter.
+ * It works mainly on English and similar languages. Don't use unless necessary.
+ */
+export declare class NaiveTextTokenizer {
+    private unit;
+    private tokenizer;
+    private isEnglish;
+    constructor(language: Language | null, unit: TextUnit);
+    tokenize(data: string): Range[];
+}
+export declare const speakableToken: (token: string) => string | null;

package/types/src/util/tokenizer/Tokenizer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A tokenizer splits a piece of data [D] into a list of [T] tokens.
+ */
+export interface Tokenizer<D, T> {
+    tokenize(data: D): T[];
+}

package/types/src/util/tokenizer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Tokenizer';
+export * from './TextTokenizer';