react-native-readium 4.0.1 → 5.0.0-rc.0

package/lib/web/utils/manifestNormalizer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Normalizes a Readium manifest object to ensure compatibility with the navigator.
+ * Handles various inconsistencies in manifest formats:
+ * - Converts string properties to arrays where required
+ * - Normalizes date formats to ISO 8601
+ * - Ensures required properties exist
+ */
+export declare function normalizeManifest(manifest: any): any;

package/lib/web/utils/manifestNormalizer.js

@@ -0,0 +1,70 @@
+/**
+ * Normalizes a Readium manifest object to ensure compatibility with the navigator.
+ * Handles various inconsistencies in manifest formats:
+ * - Converts string properties to arrays where required
+ * - Normalizes date formats to ISO 8601
+ * - Ensures required properties exist
+ */
+export function normalizeManifest(manifest) {
+    const responseObj = manifest;
+    const metadata = responseObj.metadata;
+    // Normalize root-level properties
+    if (typeof responseObj.conformsTo === 'string') {
+        responseObj.conformsTo = [responseObj.conformsTo];
+    }
+    if (typeof metadata?.conformsTo === 'string') {
+        metadata.conformsTo = [metadata.conformsTo];
+    }
+    if (typeof metadata?.accessMode === 'string') {
+        metadata.accessMode = [metadata.accessMode];
+    }
+    if (typeof metadata?.accessibilityFeature === 'string') {
+        metadata.accessibilityFeature = [metadata.accessibilityFeature];
+    }
+    if (typeof metadata?.accessibilityHazard === 'string') {
+        metadata.accessibilityHazard = [metadata.accessibilityHazard];
+    }
+    // Normalize nested accessibility properties
+    const accessibility = metadata?.accessibility;
+    if (accessibility) {
+        if (typeof accessibility.conformsTo === 'string') {
+            accessibility.conformsTo = [accessibility.conformsTo];
+        }
+        if (typeof accessibility.accessMode === 'string') {
+            accessibility.accessMode = [accessibility.accessMode];
+        }
+        if (typeof accessibility.feature === 'string') {
+            accessibility.feature = [accessibility.feature];
+        }
+        if (typeof accessibility.hazard === 'string') {
+            accessibility.hazard = [accessibility.hazard];
+        }
+    }
+    // Normalize date formats
+    // Some manifests use JavaScript Date.toString() format instead of ISO 8601
+    if (metadata?.modified && typeof metadata.modified === 'string') {
+        const date = new Date(metadata.modified);
+        if (!isNaN(date.getTime())) {
+            metadata.modified = date.toISOString();
+        }
+    }
+    if (metadata?.published && typeof metadata.published === 'string') {
+        const date = new Date(metadata.published);
+        if (!isNaN(date.getTime())) {
+            metadata.published = date.toISOString();
+        }
+    }
+    // Ensure links property exists (required by RWPM spec)
+    // Some manifests may have landmarks instead of links
+    if (!responseObj.links) {
+        // If landmarks exist, convert them to links
+        if (responseObj.landmarks && Array.isArray(responseObj.landmarks)) {
+            responseObj.links = responseObj.landmarks;
+        }
+        else {
+            // Otherwise create an empty links array
+            responseObj.links = [];
+        }
+    }
+    return responseObj;
+}

package/lib/web/utils/metadataNormalizer.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Normalizes metadata to ensure consistent structure per RWPM spec.
+ *
+ * This normalizer is library-agnostic and based on the stable RWPM specification,
+ * ensuring it works regardless of how the underlying Readium library serializes data.
+ *
+ * https://readium.org/webpub-manifest/
+ */
+/**
+ * Normalizes a localized string per RWPM spec.
+ *
+ * Per RWPM spec, a localized string can be:
+ * 1. Plain string: "Moby-Dick"
+ * 2. Language map: {"en": "Moby-Dick", "fr": "Moby Dick"}
+ *
+ * Priority for language selection:
+ * 1. "undefined" or "und" (default/undetermined language)
+ * 2. "en" (English fallback)
+ * 3. First available language
+ *
+ * https://readium.org/webpub-manifest/contexts/default/
+ */
+export declare function normalizeLocalizedString(value: any): string;
+/**
+ * Normalizes contributors per RWPM spec.
+ *
+ * Per RWPM spec, a contributor can be:
+ * 1. Plain string: "Herman Melville"
+ * 2. Object: {"name": "Herman Melville", "sortAs": "Melville, Herman"}
+ *
+ * The Web library uses a Contributors class with an "items" property.
+ *
+ * https://readium.org/webpub-manifest/schema/contributor-object.schema.json
+ */
+export declare function normalizeContributors(value: any): any[] | undefined;
+/**
+ * Normalizes subjects per RWPM spec.
+ *
+ * Subject names can be LocalizedStrings.
+ * The Web library uses a Subjects class with an "items" property.
+ *
+ * https://readium.org/webpub-manifest/schema/subject.schema.json
+ */
+export declare function normalizeSubjects(value: any): any[] | undefined;
+/**
+ * Normalizes the entire metadata object per RWPM spec.
+ *
+ * This function is library-agnostic and based on the stable RWPM specification,
+ * ensuring it works regardless of how the underlying Readium library serializes data.
+ *
+ * https://readium.org/webpub-manifest/
+ */
+export declare function normalizeMetadata(metadata: any): any;

package/lib/web/utils/metadataNormalizer.js

@@ -0,0 +1,220 @@
+/**
+ * Normalizes metadata to ensure consistent structure per RWPM spec.
+ *
+ * This normalizer is library-agnostic and based on the stable RWPM specification,
+ * ensuring it works regardless of how the underlying Readium library serializes data.
+ *
+ * https://readium.org/webpub-manifest/
+ */
+/**
+ * Normalizes a localized string per RWPM spec.
+ *
+ * Per RWPM spec, a localized string can be:
+ * 1. Plain string: "Moby-Dick"
+ * 2. Language map: {"en": "Moby-Dick", "fr": "Moby Dick"}
+ *
+ * Priority for language selection:
+ * 1. "undefined" or "und" (default/undetermined language)
+ * 2. "en" (English fallback)
+ * 3. First available language
+ *
+ * https://readium.org/webpub-manifest/contexts/default/
+ */
+export function normalizeLocalizedString(value) {
+    if (!value)
+        return '';
+    // Format 1: Plain string (spec-compliant shorthand)
+    if (typeof value === 'string')
+        return value;
+    // Format 2: Language map (spec-compliant full form)
+    if (typeof value === 'object') {
+        // Check if it's a LocalizedString instance with translations property
+        if (value.translations) {
+            const translations = value.translations;
+            return (translations['undefined'] ||
+                translations['und'] ||
+                translations['en'] ||
+                Object.values(translations)[0] ||
+                '');
+        }
+        // Check if it's already a plain language map object
+        return (value['undefined'] ||
+            value['und'] ||
+            value['en'] ||
+            Object.values(value)[0] ||
+            '');
+    }
+    return '';
+}
+/**
+ * Normalizes contributors per RWPM spec.
+ *
+ * Per RWPM spec, a contributor can be:
+ * 1. Plain string: "Herman Melville"
+ * 2. Object: {"name": "Herman Melville", "sortAs": "Melville, Herman"}
+ *
+ * The Web library uses a Contributors class with an "items" property.
+ *
+ * https://readium.org/webpub-manifest/schema/contributor-object.schema.json
+ */
+export function normalizeContributors(value) {
+    if (!value)
+        return undefined;
+    // Handle TypeScript library's Contributors class format (has .items property)
+    const items = value.items || value;
+    if (!Array.isArray(items))
+        return undefined;
+    return items
+        .map((contributor) => {
+        // Format 1: Plain string
+        if (typeof contributor === 'string') {
+            return { name: contributor };
+        }
+        // Format 2: Object with potentially localized fields
+        const normalized = {
+            name: normalizeLocalizedString(contributor.name),
+        };
+        if (contributor.sortAs) {
+            normalized.sortAs = normalizeLocalizedString(contributor.sortAs);
+        }
+        if (contributor.identifier) {
+            normalized.identifier = contributor.identifier;
+        }
+        if (contributor.role) {
+            normalized.role = contributor.role;
+        }
+        if (contributor.position !== undefined) {
+            normalized.position = contributor.position;
+        }
+        return normalized;
+    })
+        .filter((c) => c.name); // Remove contributors without names
+}
+/**
+ * Normalizes subjects per RWPM spec.
+ *
+ * Subject names can be LocalizedStrings.
+ * The Web library uses a Subjects class with an "items" property.
+ *
+ * https://readium.org/webpub-manifest/schema/subject.schema.json
+ */
+export function normalizeSubjects(value) {
+    if (!value)
+        return undefined;
+    // Handle Subjects class format (has .items property)
+    const items = value.items || value;
+    if (!Array.isArray(items))
+        return undefined;
+    return items
+        .map((subject) => {
+        // Format 1: Plain string
+        if (typeof subject === 'string') {
+            return { name: subject };
+        }
+        // Format 2: Object
+        const normalized = {
+            name: normalizeLocalizedString(subject.name),
+        };
+        if (subject.sortAs) {
+            normalized.sortAs = normalizeLocalizedString(subject.sortAs);
+        }
+        if (subject.code) {
+            normalized.code = subject.code;
+        }
+        if (subject.scheme) {
+            normalized.scheme = subject.scheme;
+        }
+        return normalized;
+    })
+        .filter((s) => s.name);
+}
+/**
+ * Normalizes the entire metadata object per RWPM spec.
+ *
+ * This function is library-agnostic and based on the stable RWPM specification,
+ * ensuring it works regardless of how the underlying Readium library serializes data.
+ *
+ * https://readium.org/webpub-manifest/
+ */
+export function normalizeMetadata(metadata) {
+    const normalized = {
+        // Title is required
+        title: normalizeLocalizedString(metadata.title),
+    };
+    // Optional localized string fields
+    if (metadata.subtitle) {
+        normalized.subtitle = normalizeLocalizedString(metadata.subtitle);
+    }
+    if (metadata.sortAs) {
+        normalized.sortAs = normalizeLocalizedString(metadata.sortAs);
+    }
+    // Direct copy fields
+    if (metadata.identifier)
+        normalized.identifier = metadata.identifier;
+    if (metadata.conformsTo)
+        normalized.conformsTo = metadata.conformsTo;
+    if (metadata.description)
+        normalized.description = metadata.description;
+    if (metadata.readingProgression)
+        normalized.readingProgression = metadata.readingProgression;
+    if (metadata.layout)
+        normalized.layout = metadata.layout;
+    if (metadata.duration)
+        normalized.duration = metadata.duration;
+    if (metadata.numberOfPages)
+        normalized.numberOfPages = metadata.numberOfPages;
+    // Date fields - convert to ISO strings
+    if (metadata.modified) {
+        normalized.modified =
+            metadata.modified instanceof Date
+                ? metadata.modified.toISOString()
+                : metadata.modified;
+    }
+    if (metadata.published) {
+        normalized.published =
+            metadata.published instanceof Date
+                ? metadata.published.toISOString()
+                : metadata.published;
+    }
+    // Languages (Web uses plural 'languages', our interface uses singular 'language')
+    if (metadata.languages) {
+        normalized.language = metadata.languages;
+    }
+    // Normalize all contributor types (Web uses plural names, our interface uses singular)
+    if (metadata.authors)
+        normalized.author = normalizeContributors(metadata.authors);
+    if (metadata.translators)
+        normalized.translator = normalizeContributors(metadata.translators);
+    if (metadata.editors)
+        normalized.editor = normalizeContributors(metadata.editors);
+    if (metadata.artists)
+        normalized.artist = normalizeContributors(metadata.artists);
+    if (metadata.illustrators)
+        normalized.illustrator = normalizeContributors(metadata.illustrators);
+    if (metadata.letterers)
+        normalized.letterer = normalizeContributors(metadata.letterers);
+    if (metadata.pencilers)
+        normalized.penciler = normalizeContributors(metadata.pencilers);
+    if (metadata.colorists)
+        normalized.colorist = normalizeContributors(metadata.colorists);
+    if (metadata.inkers)
+        normalized.inker = normalizeContributors(metadata.inkers);
+    if (metadata.narrators)
+        normalized.narrator = normalizeContributors(metadata.narrators);
+    if (metadata.contributors)
+        normalized.contributor = normalizeContributors(metadata.contributors);
+    if (metadata.publishers)
+        normalized.publisher = normalizeContributors(metadata.publishers);
+    if (metadata.imprints)
+        normalized.imprint = normalizeContributors(metadata.imprints);
+    // Normalize subjects
+    if (metadata.subjects) {
+        normalized.subject = normalizeSubjects(metadata.subjects);
+    }
+    // Copy complex objects as-is
+    if (metadata.belongsTo)
+        normalized.belongsTo = metadata.belongsTo;
+    if (metadata.accessibility)
+        normalized.accessibility = metadata.accessibility;
+    return normalized;
+}

package/lib/web/utils/navigatorListeners.d.ts

@@ -0,0 +1,6 @@
+import { EpubNavigatorListeners } from '@readium/navigator';
+import { Locator } from '@readium/shared';
+/**
+ * Creates navigator listeners for handling navigation events
+ */
+export declare function createNavigatorListeners(onLocationChangeWithTotalProgression: (locator: Locator) => void, onPositionChange?: (position: number | null) => void): EpubNavigatorListeners;

package/lib/web/utils/navigatorListeners.js

@@ -0,0 +1,50 @@
+/**
+ * Creates navigator listeners for handling navigation events
+ */
+export function createNavigatorListeners(onLocationChangeWithTotalProgression, onPositionChange) {
+    return {
+        frameLoaded: function (_wnd) {
+            // noop
+        },
+        positionChanged: function (_locator) {
+            onLocationChangeWithTotalProgression(_locator);
+            if (onPositionChange) {
+                onPositionChange(_locator.locations?.position || null);
+            }
+            window.focus();
+        },
+        tap: function (_e) {
+            return false;
+        },
+        click: function (_e) {
+            return false;
+        },
+        zoom: function (_scale) {
+            // noop
+        },
+        miscPointer: function (_amount) {
+            // noop
+        },
+        scroll: function (_amount) {
+            // noop
+        },
+        customEvent: function (_key, _data) { },
+        handleLocator: function (locator) {
+            const href = locator.href;
+            if (href.startsWith('http://') ||
+                href.startsWith('https://') ||
+                href.startsWith('mailto:') ||
+                href.startsWith('tel:')) {
+                if (confirm(`Open "${href}" ?`))
+                    window.open(href, '_blank');
+            }
+            else {
+                console.warn('Unhandled locator', locator);
+            }
+            return false;
+        },
+        textSelected: function (_selection) {
+            // noop
+        },
+    };
+}

package/lib/web/utils/publicationUtils.d.ts

@@ -0,0 +1,15 @@
+import { Locator, Manifest, Publication } from '@readium/shared';
+/**
+ * Normalizes a publication URL to ensure it ends with /
+ * If URL ends with manifest.json, extracts the base directory
+ */
+export declare function normalizePublicationURL(url: string): string;
+/**
+ * Creates positions array from publication reading order
+ * NOTE: The published npm packages (v2.2.5) require positions to be passed explicitly
+ */
+export declare function createPositions(publication: Publication): Locator[];
+/**
+ * Extracts table of contents items from manifest
+ */
+export declare function extractTableOfContents(manifest: Manifest): any[];

package/lib/web/utils/publicationUtils.js

@@ -0,0 +1,39 @@
+import { Locator, LocatorLocations, } from '@readium/shared';
+/**
+ * Normalizes a publication URL to ensure it ends with /
+ * If URL ends with manifest.json, extracts the base directory
+ */
+export function normalizePublicationURL(url) {
+    if (url.endsWith('manifest.json')) {
+        return url.substring(0, url.lastIndexOf('/') + 1);
+    }
+    return url.endsWith('/') ? url : `${url}/`;
+}
+/**
+ * Creates positions array from publication reading order
+ * NOTE: The published npm packages (v2.2.5) require positions to be passed explicitly
+ */
+export function createPositions(publication) {
+    return publication.readingOrder.items.map((link, idx) => {
+        const position = idx + 1;
+        return new Locator({
+            href: link.href,
+            type: link.type,
+            title: link.title,
+            locations: new LocatorLocations({
+                position: position,
+                progression: 0,
+                totalProgression: idx / publication.readingOrder.items.length,
+            }),
+        });
+    });
+}
+/**
+ * Extracts table of contents items from manifest
+ */
+export function extractTableOfContents(manifest) {
+    return Array.isArray(manifest.toc)
+        ? manifest.toc
+        : // @ts-ignore
+            manifest.toc.items || [];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-readium",
-  "version": "4.0.1",
+  "version": "5.0.0-rc.0",
   "description": "A react-native wrapper for https://readium.org/",
   "main": "lib/src/index",
   "types": "lib/src/index.d.ts",
@@ -21,6 +21,9 @@
     "!**/__fixtures__",
     "!**/__mocks__"
   ],
+  "workspaces": [
+    "apps/*"
+  ],
   "scripts": {
     "test": "jest",
     "typescript": "tsc --noEmit",
@@ -28,8 +31,9 @@
     "lint:fix": "eslint ./src  --fix",
     "prepare": "rimraf lib && tsc",
     "release": "release-it",
-    "example": "yarn --cwd example",
-    "pods": "cd example && pod-install --quiet",
+    "example": "yarn workspace example-native",
+    "example:nextjs": "yarn workspace example-nextjs",
+    "pods": "cd apps/example-native && pod-install --quiet",
     "bootstrap": "yarn example && yarn && yarn pods",
     "version": "yarn changelog && git add CHANGELOG.md",
     "postversion": "npm run publish:git && npm run publish:npm",
@@ -61,27 +65,27 @@
   "devDependencies": {
     "@commitlint/config-conventional": "^17.0.2",
     "@evilmartians/lefthook": "^1.5.0",
-    "@react-native/eslint-config": "^0.73.1",
+    "@react-native/eslint-config": "0.83.0",
     "@release-it/conventional-changelog": "^5.0.0",
-    "@types/jest": "^29.5.5",
-    "@types/react": "^18.2.44",
+    "@types/jest": "^29.5.13",
+    "@types/react": "^19.2.0",
     "commitlint": "^17.0.2",
     "conventional-changelog-cli": "^2.2.2",
     "del-cli": "^5.1.0",
-    "eslint": "^8.51.0",
+    "eslint": "^8.19.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-prettier": "^5.0.1",
     "husky": "^6.0.0",
-    "jest": "^29.7.0",
+    "jest": "^29.6.3",
     "pod-install": "^0.1.0",
-    "prettier": "^3.0.3",
-    "react": "18.2.0",
-    "react-native": "0.74.1",
+    "prettier": "2.8.8",
+    "react": "19.0.0",
+    "react-native": "0.83.1",
     "react-native-builder-bob": "^0.23.2",
     "release-it": "^15.0.0",
     "rimraf": "^5.0.7",
     "turbo": "^1.10.7",
-    "typescript": "^5.2.2"
+    "typescript": "^5.8.3"
   },
   "peerDependencies": {
     "react": "*",
@@ -122,6 +126,9 @@
       "@react-native",
       "prettier"
     ],
+    "plugins": [
+      "prettier"
+    ],
     "rules": {
       "prettier/prettier": [
         "error",
@@ -147,11 +154,14 @@
     "useTabs": false
   },
   "dependencies": {
-    "@d-i-t-a/reader": "^2.1.4",
+    "@readium/css": "^2.0.0-beta.24",
+    "@readium/navigator": "^2.2.5",
+    "@readium/navigator-html-injectables": "^2.2.2",
+    "@readium/shared": "^2.1.2",
     "use-deep-compare": "^1.1.0"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "packageManager": "yarn@3.6.4",
   "stableVersion": "1.2.1"

package/react-native-readium.podspec

@@ -18,10 +18,12 @@ Pod::Spec.new do |s|
 
   s.swift_version = "5.0"
 
+  s.dependency 'ReadiumShared',   '~> 3.5.0'
+  s.dependency 'ReadiumStreamer', '~> 3.5.0'
+  s.dependency 'ReadiumNavigator','~> 3.5.0'
+  s.dependency 'ReadiumAdapterGCDWebServer', '~> 3.5.0' 
+  s.dependency 'ReadiumInternal'
+
   s.dependency "React-Core"
-  s.dependency "R2Shared"
-  s.dependency "R2Streamer"
-  s.dependency "R2Navigator"
-  s.dependency "GCDWebServer"
-  s.dependency "ReadiumAdapterGCDWebServer"
+  
 end

package/src/ReadiumViewNativeComponent.ts

@@ -0,0 +1,35 @@
+import type { HostComponent, ViewProps } from 'react-native';
+import type { DirectEventHandler } from 'react-native/Libraries/Types/CodegenTypes';
+// eslint-disable-next-line @react-native/no-deep-imports
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+// eslint-disable-next-line @react-native/no-deep-imports
+import codegenNativeCommands from 'react-native/Libraries/Utilities/codegenNativeCommands';
+import type { File } from './interfaces/File';
+import type { Locator } from './interfaces/Locator';
+import type { PublicationReadyEvent } from './interfaces/PublicationReady';
+
+// Event types for native events
+type OnLocationChangeEvent = Readonly<Locator>;
+type OnPublicationReadyEvent = Readonly<PublicationReadyEvent>;
+
+// Native component props interface
+export interface NativeProps extends ViewProps {
+  file: File;
+  preferences?: string;
+  onLocationChange?: DirectEventHandler<OnLocationChangeEvent>;
+  onPublicationReady?: DirectEventHandler<OnPublicationReadyEvent>;
+}
+
+// Native commands interface
+export interface NativeCommands {
+  create: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+}
+
+// Generate the native component
+export const ReadiumViewNativeComponent =
+  codegenNativeComponent<NativeProps>('ReadiumView');
+
+// Generate the commands
+export const Commands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['create'],
+});

package/src/components/BaseReadiumView.tsx

@@ -1,11 +1,4 @@
-import { requireNativeComponent, UIManager } from 'react-native';
+import { ReadiumViewNativeComponent } from '../ReadiumViewNativeComponent';
 
-import type { BaseReadiumViewProps } from '../interfaces';
-import { COMPONENT_NAME, LINKING_ERROR } from '../utils';
-
-export const BaseReadiumView =
-  UIManager.getViewManagerConfig(COMPONENT_NAME) != null
-    ? requireNativeComponent<BaseReadiumViewProps>(COMPONENT_NAME)
-    : () => {
-        throw new Error(LINKING_ERROR);
-      };
+// Re-export the native component for backwards compatibility
+export const BaseReadiumView = ReadiumViewNativeComponent;