react-native-readium 4.0.2 → 5.0.0-rc.1

package/web/utils/locationNormalizer.ts

@@ -0,0 +1,58 @@
+import type { Locator } from '@readium/shared';
+import type { Link, Locator as LocalLocator } from '../../src/interfaces';
+
+/**
+ * Normalizes an href by removing leading slashes for consistency across platforms.
+ *
+ * The Readium toolkit expects hrefs in relative format (e.g., "OPS/main3.xml")
+ * rather than absolute format (e.g., "/OPS/main3.xml").
+ *
+ * @param href - The href to normalize
+ * @returns The normalized href without leading slash
+ */
+export function normalizeHref(href: string): string {
+  if (href.startsWith('/')) {
+    return href.substring(1);
+  }
+  return href;
+}
+
+/**
+ * Normalizes a location object (Link or Locator) by normalizing its href.
+ *
+ * @param location - The Link or Locator to normalize
+ * @returns A new location object with normalized href
+ */
+export function normalizeLocation<T extends { href: string }>(location: T): T {
+  return {
+    ...location,
+    href: normalizeHref(location.href),
+  };
+}
+
+/**
+ * Converts a Link or Locator to a Readium Locator format suitable for navigation.
+ *
+ * @param location - The Link or Locator from the file.initialLocation
+ * @returns A Locator object ready for the Readium navigator, or undefined if invalid
+ */
+export function convertToNavigatorLocator(
+  location: Link | LocalLocator
+): Locator | undefined {
+  // First, normalize the href
+  const normalized = normalizeLocation(location);
+
+  // Check if this is already a Locator (has locations property)
+  if ('locations' in normalized) {
+    // It's already a Locator, return it
+    return normalized as unknown as Locator;
+  }
+
+  // It's a Link - convert to basic Locator format
+  // The Readium navigator will handle finding the exact position
+  return {
+    href: normalized.href,
+    type: normalized.type || 'application/xhtml+xml',
+    title: normalized.title,
+  } as Locator;
+}

package/web/utils/manifestFetcher.ts

@@ -0,0 +1,38 @@
+import { Fetcher, HttpFetcher, Link, Manifest } from '@readium/shared';
+import { normalizeManifest } from './manifestNormalizer';
+
+/**
+ * Fetches and deserializes the publication manifest
+ */
+export async function fetchManifest(publicationURL: string): Promise<{
+  manifest: Manifest;
+  fetcher: Fetcher;
+}> {
+  const manifestLink = new Link({ href: 'manifest.json' });
+  const fetcher: Fetcher = new HttpFetcher(undefined, publicationURL);
+  const fetched = fetcher.get(manifestLink);
+  const selfLink = (await fetched.link()).toURL(publicationURL)!;
+
+  const response = await fetched.readAsJSON();
+  const responseObj = normalizeManifest(response as any);
+
+  let manifest;
+  try {
+    manifest = Manifest.deserialize(responseObj as string);
+  } catch (error) {
+    console.error('Error during manifest deserialization:', error);
+    console.error('Manifest that failed:', responseObj);
+    throw error;
+  }
+
+  if (!manifest) {
+    console.error(
+      'Failed to deserialize manifest (returned null/undefined):',
+      responseObj
+    );
+    throw new Error('Manifest deserialization returned null/undefined');
+  }
+
+  manifest.setSelfLink(selfLink);
+  return { manifest, fetcher };
+}

package/web/utils/manifestNormalizer.ts

@@ -0,0 +1,74 @@
+/**
+ * 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: any): any {
+  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/web/utils/metadataNormalizer.ts

@@ -0,0 +1,238 @@
+/**
+ * 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: any): string {
+  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] as string) ||
+        ''
+      );
+    }
+
+    // Check if it's already a plain language map object
+    return (
+      value['undefined'] ||
+      value['und'] ||
+      value['en'] ||
+      (Object.values(value)[0] as string) ||
+      ''
+    );
+  }
+
+  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: any): any[] | undefined {
+  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: any) => {
+      // Format 1: Plain string
+      if (typeof contributor === 'string') {
+        return { name: contributor };
+      }
+
+      // Format 2: Object with potentially localized fields
+      const normalized: any = {
+        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: any): any[] | undefined {
+  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: any) => {
+      // Format 1: Plain string
+      if (typeof subject === 'string') {
+        return { name: subject };
+      }
+
+      // Format 2: Object
+      const normalized: any = {
+        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: any): any {
+  const normalized: any = {
+    // 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/web/utils/navigatorListeners.ts

@@ -0,0 +1,60 @@
+import {
+  BasicTextSelection,
+  FrameClickEvent,
+} from '@readium/navigator-html-injectables';
+import { EpubNavigatorListeners } from '@readium/navigator';
+import { Locator } from '@readium/shared';
+
+/**
+ * Creates navigator listeners for handling navigation events
+ */
+export function createNavigatorListeners(
+  onLocationChangeWithTotalProgression: (locator: Locator) => void,
+  onPositionChange?: (position: number | null) => void
+): EpubNavigatorListeners {
+  return {
+    frameLoaded: function (_wnd: Window): void {
+      // noop
+    },
+    positionChanged: function (_locator: Locator): void {
+      onLocationChangeWithTotalProgression(_locator);
+      if (onPositionChange) {
+        onPositionChange(_locator.locations?.position || null);
+      }
+      window.focus();
+    },
+    tap: function (_e: FrameClickEvent): boolean {
+      return false;
+    },
+    click: function (_e: FrameClickEvent): boolean {
+      return false;
+    },
+    zoom: function (_scale: number): void {
+      // noop
+    },
+    miscPointer: function (_amount: number): void {
+      // noop
+    },
+    scroll: function (_amount: number): void {
+      // noop
+    },
+    customEvent: function (_key: string, _data: unknown): void {},
+    handleLocator: function (locator: Locator): boolean {
+      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: BasicTextSelection): void {
+      // noop
+    },
+  };
+}

package/web/utils/publicationUtils.ts

@@ -0,0 +1,47 @@
+import {
+  Locator,
+  LocatorLocations,
+  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 function normalizePublicationURL(url: string): string {
+  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: Publication): Locator[] {
+  return publication.readingOrder.items.map((link: any, idx: number) => {
+    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: Manifest): any[] {
+  return Array.isArray(manifest.toc)
+    ? manifest.toc
+    : // @ts-ignore
+      manifest.toc.items || [];
+}

package/android/src/main/java/com/reactnativereadium/ReadiumView.kt

@@ -1,109 +0,0 @@
-package com.reactnativereadium
-
-import android.view.Choreographer
-import android.widget.FrameLayout
-import androidx.fragment.app.FragmentActivity
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.uimanager.ThemedReactContext
-import com.facebook.react.uimanager.events.RCTEventEmitter
-import com.reactnativereadium.reader.BaseReaderFragment
-import com.reactnativereadium.reader.EpubReaderFragment
-import com.reactnativereadium.reader.ReaderViewModel
-import com.reactnativereadium.reader.VisualReaderFragment
-import com.reactnativereadium.utils.Dimensions
-import com.reactnativereadium.utils.File
-import com.reactnativereadium.utils.LinkOrLocator
-import org.readium.r2.navigator.epub.EpubNavigatorFragment
-import org.readium.r2.navigator.epub.EpubPreferences
-import org.readium.r2.shared.extensions.toMap
-
-class ReadiumView(
-  val reactContext: ThemedReactContext
-) : FrameLayout(reactContext) {
-  var dimensions: Dimensions = Dimensions(0,0)
-  var file: File? = null
-  var fragment: BaseReaderFragment? = null
-  var isViewInitialized: Boolean = false
-  var lateInitSerializedUserPreferences: String? = null
-
-  fun updateLocation(location: LinkOrLocator) : Boolean {
-    if (fragment == null) {
-      return false
-    } else {
-      return this.fragment!!.go(location, true)
-    }
-  }
-
-  fun updatePreferencesFromJsonString(preferences: String?) {
-    lateInitSerializedUserPreferences = preferences
-    if (preferences == null || fragment == null) {
-      return
-    }
-
-    if (fragment is EpubReaderFragment) {
-      (fragment as EpubReaderFragment).updatePreferencesFromJsonString(preferences)
-    }
-  }
-
-  fun addFragment(frag: BaseReaderFragment) {
-    fragment = frag
-    setupLayout()
-    lateInitSerializedUserPreferences?.let { updatePreferencesFromJsonString(it)}
-    val activity: FragmentActivity? = reactContext.currentActivity as FragmentActivity?
-    activity!!.supportFragmentManager
-      .beginTransaction()
-      .replace(this.id, frag, this.id.toString())
-      .commit()
-
-    val module = reactContext.getJSModule(RCTEventEmitter::class.java)
-    // subscribe to reader events
-    frag.channel.receive(frag) { event ->
-      when (event) {
-        is ReaderViewModel.Event.LocatorUpdate -> {
-          val json = event.locator.toJSON()
-          val payload = Arguments.makeNativeMap(json.toMap())
-          module.receiveEvent(
-            this.id.toInt(),
-            ReadiumViewManager.ON_LOCATION_CHANGE,
-            payload
-          )
-        }
-        is ReaderViewModel.Event.TableOfContentsLoaded -> {
-          val map = event.toc.map { it.toJSON().toMap() }
-          val payload = Arguments.makeNativeMap(mapOf("toc" to map))
-          module.receiveEvent(
-            this.id.toInt(),
-            ReadiumViewManager.ON_TABLE_OF_CONTENTS,
-            payload
-          )
-        }
-        else -> {
-          // do nothing
-        }
-      }
-    }
-  }
-
-  private fun setupLayout() {
-    Choreographer.getInstance().postFrameCallback(object : Choreographer.FrameCallback {
-      override fun doFrame(frameTimeNanos: Long) {
-        manuallyLayoutChildren()
-        this@ReadiumView.viewTreeObserver.dispatchOnGlobalLayout()
-        Choreographer.getInstance().postFrameCallback(this)
-      }
-    })
-  }
-
-  /**
-   * Layout all children properly
-   */
-  private fun manuallyLayoutChildren() {
-    // propWidth and propHeight coming from react-native props
-    val width = dimensions.width
-    val height = dimensions.height
-    this.measure(
-      MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
-      MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY))
-    this.layout(0, 0, width, height)
-  }
-}