@readium/shared 1.2.1 → 2.0.0

package/types/src/publication/accessibility/Accessibility.d.ts

@@ -0,0 +1,196 @@
+/**
+ * Holds the accessibility metadata of a Publication.
+ *
+ * https://www.w3.org/2021/a11y-discov-vocab/latest/
+ * https://readium.org/webpub-manifest/schema/a11y.schema.json
+ */
+export declare class Accessibility {
+    /**
+     * An established standard to which the described resource conforms.
+     */
+    conformsTo: AccessibilityProfile[];
+    /**
+     * Certification of accessible publications.
+     */
+    certification: Certification | null;
+    /**
+     * A human-readable summary of specific accessibility features or deficiencies.
+     */
+    summary: string | null;
+    /**
+     * The human sensory perceptual system through which a person may process or perceive information.
+     */
+    accessMode: AccessMode[];
+    /**
+     * A list of single or combined accessModes that are sufficient to understand all the intellectual content.
+     */
+    accessModeSufficient: PrimaryAccessMode[];
+    /**
+     * Content features of the resource.
+     */
+    feature: Feature[];
+    /**
+     * A characteristic of the described resource that is physiologically dangerous to some users.
+     */
+    hazard: Hazard[];
+    /**
+     * Justifications for non-conformance based on exemptions in a given jurisdiction.
+     */
+    exemption: Exemption[];
+    constructor(values?: {
+        conformsTo?: AccessibilityProfile[];
+        certification?: Certification | null;
+        summary?: string | null;
+        accessMode?: AccessMode[];
+        accessModeSufficient?: PrimaryAccessMode[];
+        feature?: Feature[];
+        hazard?: Hazard[];
+        exemption?: Exemption[];
+    });
+    /**
+     * Parses an [Accessibility] from its RWPM JSON representation.
+     */
+    static deserialize(json: Record<string, any> | string): Accessibility | undefined;
+    /**
+     * Serializes an [Accessibility] to its RWPM JSON representation.
+     */
+    serialize(): Record<string, any>;
+}
+export declare class AccessibilityProfile {
+    readonly uri: string;
+    constructor(uri: string);
+    static deserialize(json: any): AccessibilityProfile | undefined;
+    serialize(): any;
+    static readonly EPUB_A11Y_10_WCAG_20_A: AccessibilityProfile;
+    static readonly EPUB_A11Y_10_WCAG_20_AA: AccessibilityProfile;
+    static readonly EPUB_A11Y_10_WCAG_20_AAA: AccessibilityProfile;
+    static readonly EPUB_A11Y_11_WCAG_20_A: AccessibilityProfile;
+    static readonly EPUB_A11Y_11_WCAG_20_AA: AccessibilityProfile;
+    static readonly EPUB_A11Y_11_WCAG_20_AAA: AccessibilityProfile;
+    static readonly EPUB_A11Y_11_WCAG_21_A: AccessibilityProfile;
+    static readonly EPUB_A11Y_11_WCAG_21_AA: AccessibilityProfile;
+    static readonly EPUB_A11Y_11_WCAG_21_AAA: AccessibilityProfile;
+    static readonly EPUB_A11Y_11_WCAG_22_A: AccessibilityProfile;
+    static readonly EPUB_A11Y_11_WCAG_22_AA: AccessibilityProfile;
+    static readonly EPUB_A11Y_11_WCAG_22_AAA: AccessibilityProfile;
+    get isWCAGLevelA(): boolean;
+    get isWCAGLevelAA(): boolean;
+    get isWCAGLevelAAA(): boolean;
+}
+export declare class Certification {
+    readonly certifiedBy: string | null;
+    readonly credential: string | null;
+    readonly report: string | null;
+    constructor(certifiedBy?: string | null, credential?: string | null, report?: string | null);
+    static deserialize(json: any): Certification | undefined;
+    serialize(): Record<string, any>;
+}
+export declare class AccessMode {
+    readonly value: string;
+    constructor(value: string);
+    static deserialize(json: any): AccessMode | undefined;
+    serialize(): any;
+    static readonly AUDITORY: AccessMode;
+    static readonly CHART_ON_VISUAL: AccessMode;
+    static readonly CHEM_ON_VISUAL: AccessMode;
+    static readonly COLOR_DEPENDENT: AccessMode;
+    static readonly DIAGRAM_ON_VISUAL: AccessMode;
+    static readonly MATH_ON_VISUAL: AccessMode;
+    static readonly MUSIC_ON_VISUAL: AccessMode;
+    static readonly TACTILE: AccessMode;
+    static readonly TEXT_ON_VISUAL: AccessMode;
+    static readonly TEXTUAL: AccessMode;
+    static readonly VISUAL: AccessMode;
+}
+export declare class PrimaryAccessMode {
+    readonly value: string | string[];
+    private static readonly VALID_MODES;
+    constructor(value: string | string[]);
+    static deserialize(json: any): PrimaryAccessMode | undefined;
+    serialize(): string | string[];
+    static readonly AUDITORY: PrimaryAccessMode;
+    static readonly TACTILE: PrimaryAccessMode;
+    static readonly TEXTUAL: PrimaryAccessMode;
+    static readonly VISUAL: PrimaryAccessMode;
+}
+export declare class Feature {
+    readonly value: string;
+    constructor(value: string);
+    static deserialize(json: any): Feature | undefined;
+    serialize(): any;
+    static readonly NONE: Feature;
+    static readonly ANNOTATIONS: Feature;
+    static readonly ARIA: Feature;
+    static readonly INDEX: Feature;
+    static readonly PAGE_BREAK_MARKERS: Feature;
+    static readonly PAGE_NAVIGATION: Feature;
+    static readonly PRINT_PAGE_NUMBERS: Feature;
+    static readonly READING_ORDER: Feature;
+    static readonly STRUCTURAL_NAVIGATION: Feature;
+    static readonly TABLE_OF_CONTENTS: Feature;
+    static readonly TAGGED_PDF: Feature;
+    static readonly ALTERNATIVE_TEXT: Feature;
+    static readonly AUDIO_DESCRIPTION: Feature;
+    static readonly CAPTIONS: Feature;
+    static readonly CLOSED_CAPTIONS: Feature;
+    static readonly DESCRIBED_MATH: Feature;
+    static readonly LONG_DESCRIPTION: Feature;
+    static readonly OPEN_CAPTIONS: Feature;
+    static readonly SIGN_LANGUAGE: Feature;
+    static readonly TRANSCRIPT: Feature;
+    static readonly DISPLAY_TRANSFORMABILITY: Feature;
+    static readonly SYNCHRONIZED_AUDIO_TEXT: Feature;
+    static readonly TIMING_CONTROL: Feature;
+    static readonly UNLOCKED: Feature;
+    static readonly CHEM_ML: Feature;
+    static readonly LATEX: Feature;
+    static readonly LATEX_CHEMISTRY: Feature;
+    static readonly MATH_ML: Feature;
+    static readonly MATH_ML_CHEMISTRY: Feature;
+    static readonly TTS_MARKUP: Feature;
+    static readonly HIGH_CONTRAST_AUDIO: Feature;
+    static readonly HIGH_CONTRAST_DISPLAY: Feature;
+    static readonly LARGE_PRINT: Feature;
+    static readonly BRAILLE: Feature;
+    static readonly TACTILE_GRAPHIC: Feature;
+    static readonly TACTILE_OBJECT: Feature;
+    static readonly FULL_RUBY_ANNOTATIONS: Feature;
+    static readonly HORIZONTAL_WRITING: Feature;
+    static readonly RUBY_ANNOTATIONS: Feature;
+    static readonly VERTICAL_WRITING: Feature;
+    static readonly WITH_ADDITIONAL_WORD_SEGMENTATION: Feature;
+    static readonly WITHOUT_ADDITIONAL_WORD_SEGMENTATION: Feature;
+}
+export declare class Hazard {
+    readonly value: string;
+    constructor(value: string);
+    static deserialize(json: any): Hazard | undefined;
+    serialize(): any;
+    static readonly FLASHING: Hazard;
+    static readonly NO_FLASHING_HAZARD: Hazard;
+    static readonly UNKNOWN_FLASHING_HAZARD: Hazard;
+    static readonly MOTION_SIMULATION: Hazard;
+    static readonly NO_MOTION_SIMULATION_HAZARD: Hazard;
+    static readonly UNKNOWN_MOTION_SIMULATION_HAZARD: Hazard;
+    static readonly SOUND: Hazard;
+    static readonly NO_SOUND_HAZARD: Hazard;
+    static readonly UNKNOWN_SOUND_HAZARD: Hazard;
+    static readonly UNKNOWN: Hazard;
+    static readonly NONE: Hazard;
+}
+export declare class Exemption {
+    readonly value: string;
+    constructor(value: string);
+    static deserialize(json: any): Exemption | undefined;
+    serialize(): any;
+    static readonly NONE: Exemption;
+    static readonly DOCUMENTED: Exemption;
+    static readonly LEGAL: Exemption;
+    static readonly TEMPORARY: Exemption;
+    static readonly TECHNICAL: Exemption;
+    static readonly EAA_DISPROPORTIONATE_BURDEN: Exemption;
+    static readonly EAA_FUNDAMENTAL_ALTERATION: Exemption;
+    static readonly EAA_MICROENTERPRISE: Exemption;
+    static readonly EAA_TECHNICAL_IMPOSSIBILITY: Exemption;
+    static readonly EAA_TEMPORARY: Exemption;
+}

package/types/src/publication/accessibility/AccessibilityMetadataDisplayGuide.d.ts

@@ -0,0 +1,211 @@
+import { Publication } from '../Publication';
+import { AccessibilityProfile } from './Accessibility';
+/**
+ * Represents a single accessibility claim
+ */
+export interface AccessibilityDisplayStatement {
+    id: string;
+    compactString?: string;
+    descriptiveString?: string;
+}
+/**
+* Represents a collection of related accessibility claims which should be
+* displayed together in a section
+*/
+export interface AccessibilityDisplayField {
+    id: string;
+    title: string;
+    statements: AccessibilityDisplayStatement[];
+    shouldDisplay: boolean;
+}
+/**
+ * Represents the different ways visual adjustments can be made
+ */
+export declare enum VisualAdjustments {
+    Unknown = "unknown",
+    Modifiable = "modifiable",
+    Unmodifiable = "unmodifiable"
+}
+/**
+ * Represents the different types of non-visual reading
+ */
+export declare enum NonvisualReading {
+    NoMetadata = "noMetadata",
+    Readable = "readable",
+    NotFully = "notFully",
+    Unreadable = "unreadable"
+}
+/**
+ * Represents the different types of prerecorded audio
+ */
+export declare enum PrerecordedAudio {
+    NoMetadata = "noMetadata",
+    Synchronized = "synchronized",
+    AudioOnly = "audioOnly",
+    AudioComplementary = "audioComplementary"
+}
+/**
+ * The ways of reading display field is a banner heading that groups
+ * together the following information about how the content facilitates
+ * access.
+ */
+export declare class WaysOfReading implements AccessibilityDisplayField {
+    readonly id = "ways-of-reading.title";
+    readonly title: string;
+    readonly shouldDisplay: boolean;
+    readonly visualAdjustments: VisualAdjustments;
+    readonly nonvisualReading: NonvisualReading;
+    readonly nonvisualReadingAltText: boolean;
+    readonly prerecordedAudio: PrerecordedAudio;
+    readonly statements: AccessibilityDisplayStatement[];
+    private constructor();
+    static fromPublication(publication: Publication): WaysOfReading;
+}
+/**
+ * Navigation features of the content
+ */
+export declare class Navigation implements AccessibilityDisplayField {
+    readonly id = "navigation.title";
+    readonly title: string;
+    readonly shouldDisplay: boolean;
+    readonly noMetadata: boolean;
+    readonly tableOfContents: boolean;
+    readonly index: boolean;
+    readonly headings: boolean;
+    readonly page: boolean;
+    readonly statements: AccessibilityDisplayStatement[];
+    private constructor();
+    static fromPublication(publication: Publication): Navigation;
+}
+/**
+ * Represents the different types of rich content
+ */
+export declare enum RichContentType {
+    Math = "math",
+    Chemistry = "chemistry",
+    Music = "music",
+    Diagram = "diagram",
+    Chart = "chart",
+    Graph = "graph",
+    Table = "table",
+    Image = "image"
+}
+/**
+ * Rich content features of the content
+ */
+export declare class RichContent implements AccessibilityDisplayField {
+    readonly id = "rich-content.title";
+    readonly title: string;
+    readonly shouldDisplay: boolean;
+    readonly noMetadata: boolean;
+    readonly extendedAltTextDescriptions: boolean;
+    readonly mathFormula: boolean;
+    readonly mathFormulaAsMathML: boolean;
+    readonly mathFormulaAsLaTeX: boolean;
+    readonly chemicalFormulaAsMathML: boolean;
+    readonly chemicalFormulaAsLaTeX: boolean;
+    readonly closedCaptions: boolean;
+    readonly openCaptions: boolean;
+    readonly transcript: boolean;
+    readonly statements: AccessibilityDisplayStatement[];
+    private constructor();
+    static fromPublication(publication: Publication): RichContent;
+}
+/**
+ * Represents additional accessibility information
+ */
+export declare class AdditionalInformation implements AccessibilityDisplayField {
+    readonly id = "additional-accessibility-information.title";
+    readonly title: string;
+    readonly shouldDisplay: boolean;
+    readonly noMetadata: boolean;
+    readonly pageBreakMarkers: boolean;
+    readonly aria: boolean;
+    readonly audioDescriptions: boolean;
+    readonly braille: boolean;
+    readonly rubyAnnotations: boolean;
+    readonly fullRubyAnnotations: boolean;
+    readonly highAudioContrast: boolean;
+    readonly highDisplayContrast: boolean;
+    readonly largePrint: boolean;
+    readonly signLanguage: boolean;
+    readonly tactileGraphics: boolean;
+    readonly tactileObjects: boolean;
+    readonly textToSpeechHinting: boolean;
+    readonly statements: AccessibilityDisplayStatement[];
+    private constructor();
+    static fromPublication(publication: Publication): AdditionalInformation;
+}
+export declare enum HazardType {
+    yes = "yes",
+    no = "no",
+    unknown = "unknown",
+    noMetadata = "noMetadata"
+}
+/**
+ * Represents potential hazards in the content
+ */
+export declare class Hazards implements AccessibilityDisplayField {
+    readonly id = "hazards.title";
+    readonly title: string;
+    readonly shouldDisplay: boolean;
+    readonly noMetadata: boolean;
+    readonly noHazards: boolean;
+    readonly unknown: boolean;
+    readonly flashing: HazardType;
+    readonly motion: HazardType;
+    readonly sound: HazardType;
+    readonly statements: AccessibilityDisplayStatement[];
+    private constructor();
+    static fromPublication(publication: Publication): Hazards;
+}
+/**
+* Represents conformance to accessibility standards
+*/
+export declare class Conformance implements AccessibilityDisplayField {
+    readonly id = "conformance.title";
+    readonly title: string;
+    readonly shouldDisplay: boolean;
+    readonly profiles: AccessibilityProfile[];
+    readonly statements: AccessibilityDisplayStatement[];
+    private constructor();
+    static fromPublication(publication: Publication): Conformance;
+}
+/**
+ * Represents legal exemptions
+ */
+export declare class Legal implements AccessibilityDisplayField {
+    readonly id = "legal-considerations.title";
+    readonly title: string;
+    readonly shouldDisplay: boolean;
+    readonly exemption: boolean;
+    readonly statements: AccessibilityDisplayStatement[];
+    private constructor();
+    static fromPublication(publication: Publication): Legal;
+}
+/**
+* Represents the accessibility summary
+*/
+export declare class AccessibilitySummary implements AccessibilityDisplayField {
+    readonly id = "accessibility-summary.title";
+    readonly title: string;
+    readonly shouldDisplay: boolean;
+    readonly statements: AccessibilityDisplayStatement[];
+    private constructor();
+    static fromPublication(publication: Publication): AccessibilitySummary;
+}
+/**
+ * Main accessibility metadata display guide
+ */
+export declare class AccessibilityMetadataDisplayGuide {
+    readonly waysOfReading: WaysOfReading;
+    readonly navigation: Navigation;
+    readonly richContent: RichContent;
+    readonly additionalInformation: AdditionalInformation;
+    readonly hazards: Hazards;
+    readonly conformance: Conformance;
+    readonly legal: Legal;
+    readonly accessibilitySummary: AccessibilitySummary;
+    readonly fields: AccessibilityDisplayField[];
+    constructor(publication: Publication);
+}

package/types/src/publication/accessibility/Localization.d.ts

@@ -0,0 +1,37 @@
+export interface L10nString {
+    compact: string;
+    descriptive: string;
+}
+type LocaleData = Record<string, any>;
+declare class LocalizationImpl {
+    private static instance;
+    private currentLocaleCode;
+    private locale;
+    private availableLocales;
+    private constructor();
+    static getInstance(): LocalizationImpl;
+    /**
+     * Registers a new locale or updates an existing one
+     * @param localeCode BCP 47 language code (e.g., 'en', 'fr-FR')
+     * @param localeData The locale data to register
+     */
+    registerLocale(localeCode: string, localeData: LocaleData): void;
+    /**
+     * Sets the current locale by language code
+     * @param localeCode BCP 47 language code (e.g., 'en', 'fr-FR')
+     * @returns boolean indicating if the locale was set successfully
+     */
+    setLocale(localeCode: string): boolean;
+    /**
+     * Gets the current locale code (BCP 47)
+     */
+    getCurrentLocale(): string;
+    /**
+     * Gets a list of available locale codes
+     */
+    getAvailableLocales(): string[];
+    private getNestedValue;
+    getString(key: string): L10nString;
+}
+export declare const Localization: LocalizationImpl;
+export {};

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

@@ -0,0 +1,3 @@
+export * from './Accessibility';
+export * from './AccessibilityMetadataDisplayGuide';
+export * from './Localization';

package/types/src/publication/epub/MediaOverlay.d.ts

@@ -0,0 +1,19 @@
+export declare class MediaOverlay {
+    /** Author-defined CSS class name to apply to the currently-playing EPUB Content Document element. */
+    activeClass?: string;
+    /** Author-defined CSS class name to apply to the EPUB Content Document's document element when playback is active. */
+    playbackActiveClass?: string;
+    /** Creates a MediaOverlay object */
+    constructor(values: {
+        activeClass?: string;
+        playbackActiveClass?: string;
+    });
+    /**
+     * Parses a MediaOverlay from its RWPM JSON representation.
+     */
+    static deserialize(json: any): MediaOverlay | undefined;
+    /**
+     * Serializes a MediaOverlay to its RWPM JSON representation.
+     */
+    serialize(): any;
+}

package/types/src/publication/epub/Metadata.d.ts

@@ -0,0 +1,6 @@
+import { MediaOverlay } from "./MediaOverlay";
+declare module '../Metadata' {
+    interface Metadata {
+        getMediaOverlay(): MediaOverlay | undefined;
+    }
+}

package/types/src/publication/epub/Properties.d.ts

@@ -1,4 +1,3 @@
-import { EPUBLayout } from './EPUBLayout';
 declare module '../Properties' {
     interface Properties {
         /**
@@ -6,9 +5,6 @@ declare module '../Properties' {
          * media type.
          */
         getContains(): Set<string> | undefined;
-        /**
-         * Hints how the layout of the resource should be presented.
-         */
-        getLayout(): EPUBLayout | undefined;
     }
 }
+export {};

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

@@ -1,4 +1,4 @@
-export * from './EPUBLayout';
-export * from './Presentation';
+export * from './MediaOverlay';
+export * from './Metadata';
 export * from './Properties';
 export * from './Publication';

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

@@ -2,8 +2,8 @@ export * from './encryption';
 export * from './epub';
 export * from './html';
 export * from './opds';
-export * from './presentation';
 export * from './services';
+export * from './AltIdentifier';
 export * from './BelongsTo';
 export * from './Contributor';
 export * from './Link';
@@ -12,9 +12,12 @@ export * from './Locator';
 export * from './LocatorCollection';
 export * from './Manifest';
 export * from './Metadata';
+export * from './Profiles';
 export * from './Properties';
 export * from './Publication';
 export * from './PublicationCollection';
+export * from './Layout';
 export * from './ReadingProgression';
 export * from './Subject';
+export * from './TDM';
 export * from './GuidedNavigation';

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

@@ -7,5 +7,5 @@ export declare function datefromJSON(json: any): Date | undefined;
 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>;
+/** Converts a Set to an Array object */
+export declare function setToArray(obj: Set<any>): Array<any>;

package/LICENSE

@@ -1,28 +0,0 @@
-BSD 3-Clause License
-
-Copyright (c) 2022, Readium Foundation
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-   contributors may be used to endorse or promote products derived from
-   this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/src/publication/epub/EPUBLayout.ts

@@ -1,10 +0,0 @@
-/* Copyright 2021 Readium Foundation. All rights reserved.
- * Use of this source code is governed by a BSD-style license,
- * available in the LICENSE file present in the Github repository of the project.
- */
-
-/** Hint about the nature of the layout for the linked resources. */
-export enum EPUBLayout {
-  fixed = 'fixed',
-  reflowable = 'reflowable',
-}

package/src/publication/epub/Presentation.ts

@@ -1,16 +0,0 @@
-import { Link } from '../Link';
-import { Presentation } from '../presentation/Presentation';
-import { EPUBLayout } from './EPUBLayout';
-
-declare module '../presentation/Presentation' {
-  export interface Presentation {
-    layoutOf(link: Link): EPUBLayout;
-  }
-}
-
-/** Determines the layout of the given resource in this publication.
- *  Default layout is reflowable.
- */
-Presentation.prototype.layoutOf = function(link: Link): EPUBLayout {
-  return link.properties?.getLayout() || this.layout || EPUBLayout.reflowable;
-};

package/src/publication/presentation/Metadata.ts

@@ -1,19 +0,0 @@
-import { Metadata } from '../Metadata';
-import { Presentation } from './Presentation';
-
-// Presentation extensions for [Metadata]
-
-declare module '../Metadata' {
-  export interface Metadata {
-    getPresentation(): Presentation | undefined;
-  }
-}
-
-Metadata.prototype.getPresentation = function(): Presentation | undefined {
-  const presentation =
-    this.otherMetadata?.['presentation'] || this.otherMetadata?.['rendition'];
-
-  if (!presentation) return;
-
-  return Presentation.deserialize(presentation);
-};