@caipira/vue-reader 0.0.2 → 0.0.3

package/dist/src/composables/useEpubReaderState.js

@@ -1,29 +1,39 @@
-import { computed, ref, shallowRef } from 'vue';
+import { computed, ref } from 'vue';
+export var LOG_MODES;
+(function (LOG_MODES) {
+    LOG_MODES["ALL"] = "all";
+    LOG_MODES["WARNING"] = "warning";
+    LOG_MODES["ERROR"] = "error";
+    LOG_MODES["NONE"] = "none";
+})(LOG_MODES || (LOG_MODES = {}));
+const error = ref(null);
+const logMode = ref(LOG_MODES.ALL);
+const loading = ref(false);
+const tocLinks = ref([]);
+const settings = ref(null);
+const navigator = ref(null);
+const publication = ref(null);
 const containerRef = ref();
-const epubReaderController = shallowRef(null);
-export const setEpubReaderController = (reader) => {
-    epubReaderController.value = reader;
-};
-export const useEpubReaderControllerRef = () => epubReaderController;
-export function useEpubReaderState(controller, container) {
+const totalPositions = ref(0);
+const currentPosition = ref(0);
+const progressPercent = computed(() => Math.min(100, Math.max(0, currentPosition.value)));
+const currentChapterTitle = ref('');
+export function useEpubReaderState(container) {
     if (container) {
         containerRef.value = container;
     }
-    if (controller) {
-        return controller.state;
-    }
-    const activeState = computed(() => epubReaderController.value?.state);
     return {
-        error: computed(() => activeState.value?.error?.value),
-        loading: computed(() => activeState.value?.loading?.value),
-        tocLinks: computed(() => activeState.value?.tocLinks?.value),
-        navigator: computed(() => activeState.value?.navigator?.value),
-        publication: computed(() => activeState.value?.publication?.value),
+        error,
+        loading,
+        logMode,
+        tocLinks,
+        settings,
+        navigator,
+        publication,
         containerRef: computed(() => containerRef.value?.value),
-        totalPositions: computed(() => activeState.value?.totalPositions?.value),
-        currentPosition: computed(() => activeState.value?.currentPosition?.value),
-        progressPercent: computed(() => activeState.value?.progressPercent?.value),
-        currentChapterTitle: computed(() => activeState.value?.currentChapterTitle?.value),
-        settings: computed(() => activeState.value?.settings),
+        totalPositions,
+        currentPosition,
+        progressPercent,
+        currentChapterTitle,
     };
 }

package/dist/{composables → src/composables}/useEpubReaderStrategy.d.ts

@@ -1,4 +1,4 @@
-import type { ChapterBoundary } from '../types/common';
+import type { ChapterBoundary } from '../../src/types/common';
 export type ReaderProgress = {
     progress: number;
     resourceProgression: number;

package/dist/src/composables/useEpubReaderWasm.d.ts

@@ -0,0 +1,2 @@
+import type { ReaderSourceStrategy } from '../../src/composables/useEpubReaderStrategy';
+export declare function useEpubReaderWasm(): ReaderSourceStrategy;

package/dist/{composables → src/composables}/useEpubReaderWasm.js

@@ -1,8 +1,8 @@
-import { resolveHref } from '../services/browser/url';
-import { computePublicationChaptersSize } from '../services/common/progression';
-import { loadPublication, createPublication, unloadPublication, } from '../services/wasm/wasm-streamer';
-import { buildWeightsFromResolver } from '../services/common/progression';
-import { installFrameDocumentBridge } from '../services/wasm/frame-document-bridge';
+import { resolveHref } from '../../src/services/browser/url';
+import { computePublicationChaptersSize } from '../../src/services/common/progression';
+import { loadPublication, createPublication, unloadPublication, } from '../../src/services/wasm/wasm-streamer';
+import { buildWeightsFromResolver } from '../../src/services/common/progression';
+import { installFrameDocumentBridge } from '../../src/services/wasm/frame-document-bridge';
 const isExternalRef = (value) => {
     const ref = value.trim().toLowerCase();
     return (ref === '' ||

package/dist/src/composables/useEpubReaderZipFetcher.d.ts

@@ -0,0 +1,2 @@
+import type { ReaderSourceStrategy } from '../../src/composables/useEpubReaderStrategy';
+export declare function useEpubReaderZipFetcher(): ReaderSourceStrategy;

package/dist/{composables → src/composables}/useEpubReaderZipFetcher.js

@@ -1,8 +1,8 @@
-import ZipFetcher from '../services/browser/zip-fetcher';
-import { buildManifest } from '../services/browser/manifest';
-import { clearBlobUrlCache } from '../services/browser/url-rewrite';
-import { fetchEpub, unzipEpub } from '../services/browser/epub';
-import { buildWeightsFromZip, computeChapterProgressions, } from '../services/common/progression';
+import ZipFetcher from '../../src/services/browser/zip-fetcher';
+import { buildManifest } from '../../src/services/browser/manifest';
+import { clearBlobUrlCache } from '../../src/services/browser/url-rewrite';
+import { fetchEpub, unzipEpub } from '../../src/services/browser/epub';
+import { buildWeightsFromZip, computeChapterProgressions, } from '../../src/services/common/progression';
 export function useEpubReaderZipFetcher() {
     const load = async (url) => {
         const zip = await unzipEpub(await fetchEpub(url));

package/dist/src/composables/useReaderColors.d.ts

@@ -0,0 +1,10 @@
+export type ReaderColors = {
+    text: string | null;
+    background: string | null;
+    highlight: string | null;
+};
+type ReaderColorsListener = (colors: Readonly<ReaderColors>) => void;
+export declare const setReaderColors: (colors: Partial<ReaderColors>) => void;
+export declare const getReaderColors: () => ReaderColors;
+export declare const onReaderColorsChange: (handler: ReaderColorsListener) => () => void;
+export {};

package/dist/src/composables/useReaderColors.js

@@ -0,0 +1,38 @@
+const readerColors = {
+    text: null,
+    background: null,
+    highlight: null,
+};
+let readerColorsListener = null;
+const notifyReaderColorsListeners = () => {
+    const snapshot = {
+        text: readerColors.text,
+        background: readerColors.background,
+        highlight: readerColors.highlight,
+    };
+    readerColorsListener?.(snapshot);
+};
+export const setReaderColors = (colors) => {
+    if (colors.text !== undefined) {
+        readerColors.text = colors.text;
+    }
+    if (colors.background !== undefined) {
+        readerColors.background = colors.background;
+    }
+    if (colors.highlight !== undefined) {
+        readerColors.highlight = colors.highlight;
+    }
+    notifyReaderColorsListeners();
+};
+export const getReaderColors = () => {
+    return readerColors;
+};
+export const onReaderColorsChange = (handler) => {
+    readerColorsListener = handler;
+    handler(getReaderColors());
+    return () => {
+        if (readerColorsListener === handler) {
+            readerColorsListener = null;
+        }
+    };
+};

package/dist/src/composables/useReaderSettings.d.ts

@@ -1,14 +1,29 @@
-import type { ReturnTypeCreateController } from '../../src/composables/utils';
-export type ReaderColors = {
-    text: string | null;
-    background: string | null;
-    highlight: string | null;
+import type { ReaderPreferencesAdapter, ReaderSettings } from '../../src/types/common';
+import { TextAlignment } from '@readium/navigator';
+export declare const EPUB_FONT_SIZE_OPTIONS: {
+    value: number;
+    label: string;
+}[];
+export declare const PX_FONT_SIZE_OPTIONS: {
+    value: number;
+    label: string;
+}[];
+export declare const COLUMN_OPTIONS: {
+    value: number;
+    label: string;
+}[];
+export declare const ALIGN_OPTIONS: ({
+    key: null;
+    label: string;
+} | {
+    key: TextAlignment;
+    label: string;
+})[];
+type UseReaderSettingsOptions = {
+    initialSettings?: Partial<ReaderSettings>;
+    preferences?: ReaderPreferencesAdapter;
 };
-type ReaderColorsListener = (colors: Readonly<ReaderColors>) => void;
-export declare const setReaderColors: (colors: Partial<ReaderColors>) => void;
-export declare const getReaderColors: () => ReaderColors;
-export declare const onReaderColorsChange: (handler: ReaderColorsListener) => () => void;
-export declare const useReaderSettings: (controller: ReturnTypeCreateController) => {
+export declare const useReaderSettings: (options?: UseReaderSettingsOptions) => {
     settings: {
         backgroundColor: string | null;
         columnCount: number | null;
@@ -17,9 +32,11 @@ export declare const useReaderSettings: (controller: ReturnTypeCreateController)
         isFullscreen: boolean;
         lineHeight: number | null;
         scroll: boolean | null;
-        textAlign: import("@readium/navigator").TextAlignment | null;
+        textAlign: TextAlignment | null;
         textColor: string | null;
     };
+    hydrate: () => Promise<void>;
+    onSettingsChange: (handler: (next: Readonly<ReaderSettings>) => void) => () => boolean;
     toggleFullscreen: () => void;
 };
 export {};

package/dist/src/composables/useReaderSettings.js

@@ -1,42 +1,116 @@
-import { useEpubReaderSettings } from '../../src/composables/useEpubReaderSettings';
-const readerColors = {
-    text: null,
-    background: null,
-    highlight: null,
-};
-let readerColorsListener = null;
-const notifyReaderColorsListeners = () => {
-    const snapshot = {
-        text: readerColors.text,
-        background: readerColors.background,
-        highlight: readerColors.highlight,
-    };
-    readerColorsListener?.(snapshot);
-};
-export const setReaderColors = (colors) => {
-    if (colors.text !== undefined) {
-        readerColors.text = colors.text;
+import { TextAlignment } from '@readium/navigator';
+import { reactive, watch } from 'vue';
+import { getReaderColors } from '../../src/composables/useReaderColors';
+import { useEpubReaderState } from '../../src/composables/useEpubReaderState';
+export const EPUB_FONT_SIZE_OPTIONS = [
+    { value: 0.8, label: '80%' },
+    { value: 1, label: '100% (Default)' },
+    { value: 1.2, label: '120%' },
+    { value: 1.4, label: '140%' },
+    { value: 1.6, label: '160%' },
+];
+export const PX_FONT_SIZE_OPTIONS = [
+    { value: 16, label: '16 (Default)' },
+    { value: 20, label: '20' },
+    { value: 24, label: '24' },
+    { value: 28, label: '28' },
+    { value: 32, label: '32' },
+];
+export const COLUMN_OPTIONS = [
+    { value: 0, label: 'Auto' },
+    { value: 1, label: '1' },
+    { value: 2, label: '2' },
+];
+export const ALIGN_OPTIONS = [
+    { key: null, label: 'Auto' },
+    { key: TextAlignment.start, label: 'Start' },
+    { key: TextAlignment.left, label: 'Left' },
+    { key: TextAlignment.right, label: 'Right' },
+    { key: TextAlignment.justify, label: 'Justify' },
+];
+const colors = getReaderColors();
+const settings = reactive({
+    backgroundColor: colors.background,
+    textColor: colors.text,
+    fontFamily: 'DEFAULT',
+    fontSize: 1,
+    lineHeight: null,
+    textAlign: null,
+    columnCount: null,
+    scroll: null,
+    isFullscreen: false,
+});
+const listeners = new Set();
+let activePreferences;
+let hydrated = false;
+let watchInitialized = false;
+const initWatcher = () => {
+    if (watchInitialized) {
+        return;
     }
-    if (colors.background !== undefined) {
-        readerColors.background = colors.background;
+    watchInitialized = true;
+    watch(() => [
+        settings.fontFamily,
+        settings.fontSize,
+        settings.lineHeight,
+        settings.textAlign,
+        settings.columnCount,
+        settings.scroll,
+        settings.backgroundColor,
+        settings.textColor,
+        settings.isFullscreen,
+    ], () => {
+        listeners.forEach((handler) => handler(settings));
+        void activePreferences?.save?.(settings);
+    });
+};
+export const useReaderSettings = (options) => {
+    initWatcher();
+    if (options?.preferences && options.preferences !== activePreferences) {
+        activePreferences = options.preferences;
+        hydrated = false;
     }
-    if (colors.highlight !== undefined) {
-        readerColors.highlight = colors.highlight;
+    if (options?.initialSettings) {
+        Object.assign(settings, options.initialSettings);
     }
-    notifyReaderColorsListeners();
-};
-export const getReaderColors = () => {
-    return readerColors;
-};
-export const onReaderColorsChange = (handler) => {
-    readerColorsListener = handler;
-    handler(getReaderColors());
-    return () => {
-        if (readerColorsListener === handler) {
-            readerColorsListener = null;
+    const { containerRef } = useEpubReaderState();
+    const hydrate = async () => {
+        if (hydrated || !activePreferences?.load) {
+            hydrated = true;
+            return;
         }
+        const loaded = await activePreferences.load();
+        Object.assign(settings, loaded ?? {});
+        hydrated = true;
+    };
+    const onSettingsChange = (handler) => {
+        listeners.add(handler);
+        return () => listeners.delete(handler);
+    };
+    const toggleFullscreen = () => {
+        const el = containerRef.value?.parentElement;
+        if (!el) {
+            return;
+        }
+        if (!document.fullscreenElement) {
+            el.requestFullscreen()
+                .then(() => {
+                settings.isFullscreen = true;
+            })
+                .catch(() => { });
+            return;
+        }
+        document
+            .exitFullscreen()
+            .then(() => {
+            settings.isFullscreen = false;
+        })
+            .catch(() => { });
+    };
+    return {
+        settings,
+        hydrate,
+        onSettingsChange,
+        toggleFullscreen,
     };
-};
-export const useReaderSettings = (controller) => {
-    return useEpubReaderSettings(controller);
 };

package/dist/src/index.d.ts

@@ -1,13 +1,10 @@
-export type { TocEntry, ReaderSettings, ReaderAssetConfig, EpubReaderStrategy, ReaderStorageAdapter, ReaderPreferencesAdapter, EpubReaderControllerOptions, } from '../src/types';
-export { createEpubReaderController } from '../src/core/controller';
-export { createSessionStorageAdapter } from '../src/core/storage';
+export type { TocEntry, ReaderSettings, ReaderAssetConfig, EpubReaderStrategy, ReaderStorageAdapter, ReaderPreferencesAdapter, EpubReaderOptions, } from '../src/types/common';
+export { createSessionStorageAdapter } from '../src/services/common/storage';
 export { useEpubReader } from '../src/composables/useEpubReader';
-export { useEpubReaderSettings } from '../src/composables/useEpubReaderSettings';
-export { useEpubReaderController } from '../src/composables/useEpubReaderController';
+export { useEpubReaderState } from '../src/composables/useEpubReaderState';
 export { useEpubReaderNavigation } from '../src/composables/useEpubReaderNavigation';
-export { useEpubReaderState, setEpubReaderController, useEpubReaderControllerRef, } from '../src/composables/useEpubReaderState';
-export { setReaderColors, getReaderColors, useReaderSettings, } from '../src/composables/useReaderSettings';
+export { useReaderSettings, ALIGN_OPTIONS, COLUMN_OPTIONS, PX_FONT_SIZE_OPTIONS, EPUB_FONT_SIZE_OPTIONS, } from '../src/composables/useReaderSettings';
+export { setReaderColors, getReaderColors } from '../src/composables/useReaderColors';
 export { setReaderDictionary, hasReaderDictionary, useReaderDictionary, } from '../src/composables/useReaderDictionary';
 export type { ReaderDictionaryApi, ReaderDictionaryWordStatus, } from '../src/composables/useReaderDictionary';
-export { ALIGN_OPTIONS, COLUMN_OPTIONS, PX_FONT_SIZE_OPTIONS, EPUB_FONT_SIZE_OPTIONS, } from '../src/settings/options';
-export { setWasmStreamerConfig, ensureSW as ensureEpubServiceWorker, } from '../services/wasm/wasm-streamer';
+export { setWasmStreamerConfig, ensureSW as ensureEpubServiceWorker, } from '../src/services/wasm/wasm-streamer';

package/dist/src/index.js

@@ -1,11 +1,8 @@
-export { createEpubReaderController } from '../src/core/controller';
-export { createSessionStorageAdapter } from '../src/core/storage';
+export { createSessionStorageAdapter } from '../src/services/common/storage';
 export { useEpubReader } from '../src/composables/useEpubReader';
-export { useEpubReaderSettings } from '../src/composables/useEpubReaderSettings';
-export { useEpubReaderController } from '../src/composables/useEpubReaderController';
+export { useEpubReaderState } from '../src/composables/useEpubReaderState';
 export { useEpubReaderNavigation } from '../src/composables/useEpubReaderNavigation';
-export { useEpubReaderState, setEpubReaderController, useEpubReaderControllerRef, } from '../src/composables/useEpubReaderState';
-export { setReaderColors, getReaderColors, useReaderSettings, } from '../src/composables/useReaderSettings';
+export { useReaderSettings, ALIGN_OPTIONS, COLUMN_OPTIONS, PX_FONT_SIZE_OPTIONS, EPUB_FONT_SIZE_OPTIONS, } from '../src/composables/useReaderSettings';
+export { setReaderColors, getReaderColors } from '../src/composables/useReaderColors';
 export { setReaderDictionary, hasReaderDictionary, useReaderDictionary, } from '../src/composables/useReaderDictionary';
-export { ALIGN_OPTIONS, COLUMN_OPTIONS, PX_FONT_SIZE_OPTIONS, EPUB_FONT_SIZE_OPTIONS, } from '../src/settings/options';
-export { setWasmStreamerConfig, ensureSW as ensureEpubServiceWorker, } from '../services/wasm/wasm-streamer';
+export { setWasmStreamerConfig, ensureSW as ensureEpubServiceWorker, } from '../src/services/wasm/wasm-streamer';

package/dist/{services → src/services}/browser/epub.d.ts

@@ -1,4 +1,4 @@
-import type { ZipData } from '../../types/browser';
+import type { ZipData } from '../../../src/types/browser';
 declare const fetchEpub: (url: string) => Promise<ArrayBuffer>;
 declare const unzipEpub: (buf: ArrayBuffer) => Promise<ZipData>;
 export { fetchEpub, unzipEpub };

package/dist/{services → src/services}/browser/manifest.d.ts

@@ -1,4 +1,4 @@
-import type { ZipData } from '../../types/browser';
+import type { ZipData } from '../../../src/types/browser';
 import { Manifest } from '@readium/shared';
 /**
  * Build a RWPM Manifest from the OPF file and related resources in the zip.

package/dist/{services → src/services}/browser/manifest.js

@@ -1,5 +1,5 @@
 import { Link, Links, Metadata, Manifest, Contributor, Contributors, LocalizedString, ReadingProgression, } from '@readium/shared';
-import { guessMediaType, getExt, resolveHref } from '../../services/browser/url';
+import { guessMediaType, getExt, resolveHref } from '../../../src/services/browser/url';
 const parseNavDoc = (html, baseDir) => {
     const doc = new DOMParser().parseFromString(html, 'text/html');
     const nav = doc.querySelector('nav[epub\\:type="toc"]') ??

package/dist/{services → src/services}/browser/url-rewrite.d.ts

@@ -1,4 +1,4 @@
-import type { ZipData } from '../../types/browser';
+import type { ZipData } from '../../../src/types/browser';
 declare const clearBlobUrlCache: () => void;
 declare const rewriteXhtmlUrls: (doc: Document, resourceHref: string, zip: ZipData) => void;
 declare const rewriteCssUrls: (css: string, resourceHref: string, zip: ZipData) => string;

package/dist/{services → src/services}/browser/url-rewrite.js

@@ -1,4 +1,4 @@
-import { getExt, resolveHref, parseSrcset, guessMediaType, } from '../../services/browser/url';
+import { getExt, resolveHref, parseSrcset, guessMediaType, } from '../../../src/services/browser/url';
 const blobUrlCache = new Map();
 const getBlobUrl = (zip, path) => {
     const existing = blobUrlCache.get(path);

package/dist/{services → src/services}/browser/zip-fetcher.d.ts

@@ -1,5 +1,5 @@
 import type { Fetcher } from '@readium/shared';
-import type { ZipData } from '../../types/browser';
+import type { ZipData } from '../../../src/types/browser';
 import { Link } from '@readium/shared';
 import { Resource } from '@readium/shared';
 declare class ZipFetcher implements Fetcher {

package/dist/{services → src/services}/browser/zip-fetcher.js

@@ -1,7 +1,7 @@
 import { Link } from '@readium/shared';
 import { Resource } from '@readium/shared';
-import { guessMediaType, getExt } from '../../services/browser/url';
-import { rewriteCssUrls, rewriteXhtmlUrls, clearBlobUrlCache, } from '../../services/browser/url-rewrite';
+import { guessMediaType, getExt } from '../../../src/services/browser/url';
+import { rewriteCssUrls, rewriteXhtmlUrls, clearBlobUrlCache, } from '../../../src/services/browser/url-rewrite';
 const isHtmlType = (path) => {
     const ext = getExt(path);
     return ext === 'xhtml' || ext === 'html' || ext === 'htm' || ext === 'svg';

package/dist/{services → src/services}/common/progression.d.ts

@@ -1,5 +1,5 @@
-import type { ZipData } from '../../types/browser';
-import type { ChapterBoundary } from '../../types/common';
+import type { ZipData } from '../../../src/types/browser';
+import type { ChapterBoundary } from '../../../src/types/common';
 import { Link, Locator, Publication } from '@readium/shared';
 /**
  * Scan the content files referenced by TOC entries and compute
@@ -20,13 +20,5 @@ declare const buildWeightsFromResolver: (pub: Publication, resolveSize: (href: s
     progress: number;
     resourceProgression: number;
 });
-/**
- * Save the current position (spine index and progression) for the given URL in sessionStorage.
- */
-declare const savePosition: (url: string, persisted: Locator) => void;
-/**
- * Restore the saved position for the given URL from sessionStorage.
- */
-declare const restorePosition: (url: string, publication: Publication) => Locator | undefined;
 declare const computePublicationChaptersSize: (publication: Publication) => Promise<Map<string, number>>;
-export { savePosition, restorePosition, generatePositions, buildWeightsFromZip, buildWeightsFromResolver, computeChapterProgressions, computePublicationChaptersSize, };
+export { generatePositions, buildWeightsFromZip, buildWeightsFromResolver, computeChapterProgressions, computePublicationChaptersSize, };

package/dist/{services → src/services}/common/progression.js

@@ -121,37 +121,6 @@ const buildWeightsFromResolver = (pub, resolveSize) => {
     }));
     return buildWeightedProgressCalculator(resourceWeights);
 };
-/**
- * Save the current position (spine index and progression) for the given URL in sessionStorage.
- */
-const savePosition = (url, persisted) => {
-    sessionStorage.setItem(`epub-locator:${url}`, JSON.stringify(persisted.serialize()));
-};
-/**
- * Restore the saved position for the given URL from sessionStorage.
- */
-const restorePosition = (url, publication) => {
-    const saved = sessionStorage.getItem(`epub-locator:${url}`);
-    if (saved) {
-        const raw = JSON.parse(saved);
-        const parsed = Locator.deserialize(raw);
-        if (parsed) {
-            const href = parsed.href;
-            const idx = publication.readingOrder.findIndexWithHref(href) ?? -1;
-            if (idx >= 0) {
-                const prog = parsed.locations?.progression !== undefined &&
-                    parsed.locations.progression >= 0 &&
-                    parsed.locations.progression <= 1
-                    ? parsed.locations.progression
-                    : 0;
-                return parsed.copyWithLocations({
-                    position: idx + 1,
-                    progression: prog,
-                });
-            }
-        }
-    }
-};
 const computePublicationChaptersSize = async (publication) => {
     const resourceSizes = new Map();
     await Promise.all(publication.readingOrder.items.map(async (item) => {
@@ -166,4 +135,4 @@ const computePublicationChaptersSize = async (publication) => {
     }));
     return resourceSizes;
 };
-export { savePosition, restorePosition, generatePositions, buildWeightsFromZip, buildWeightsFromResolver, computeChapterProgressions, computePublicationChaptersSize, };
+export { generatePositions, buildWeightsFromZip, buildWeightsFromResolver, computeChapterProgressions, computePublicationChaptersSize, };

package/dist/src/{core → services/common}/storage.d.ts

@@ -1,2 +1,2 @@
-import type { ReaderStorageAdapter } from '../../src/types';
+import type { ReaderStorageAdapter } from '../../../src/types/common';
 export declare const createSessionStorageAdapter: () => ReaderStorageAdapter;

package/dist/src/{core → services/common}/storage.js

@@ -14,8 +14,7 @@ export const createSessionStorageAdapter = () => {
                 if (!parsed) {
                     return undefined;
                 }
-                const idx = publication.readingOrder.findIndexWithHref(parsed.href) ??
-                    -1;
+                const idx = publication.readingOrder.findIndexWithHref(parsed.href) ?? -1;
                 if (idx < 0) {
                     return undefined;
                 }

package/dist/{services → src/services}/common/title.d.ts

@@ -1,5 +1,5 @@
 import type { Locator } from '@readium/shared';
-import type { TocEntry, ChapterBoundary } from '../../types/common';
+import type { TocEntry, ChapterBoundary } from '../../../src/types/common';
 /**
  * Determine chapter title:
  *     1. Progression-based lookup (single-file multi-chapter books)

package/dist/{services → src/services}/common/word-decorations.d.ts

@@ -1,4 +1,4 @@
 import type { Ref } from 'vue';
 import type { EpubNavigator } from '@readium/navigator';
-import type { ReadiumWordDecorationsController } from '../../types/common';
+import type { ReadiumWordDecorationsController } from '../../../src/types/common';
 export declare const createReadiumWordDecorationsController: (navigatorRef: Ref<EpubNavigator | null>, languageRef: () => string | undefined) => ReadiumWordDecorationsController;

package/dist/{services → src/services}/common/word-decorations.js

@@ -1,7 +1,7 @@
 import { toRaw } from 'vue';
 import { debounce } from 'lodash';
-import { getReaderColors } from '../../src/composables/useReaderSettings';
-import { useReaderDictionary } from '../../src/composables/useReaderDictionary';
+import { getReaderColors } from '../../../src/composables/useReaderColors';
+import { useReaderDictionary } from '../../../src/composables/useReaderDictionary';
 const GROUP_KNOWN = 'known-words-known';
 const GROUP_UNKNOWN = 'known-words-unknown';
 const MAX_VISIBLE_WORDS = 2000;

package/dist/{services → src/services}/common/word-lookup.js

@@ -1,4 +1,4 @@
-import { useReaderDictionary } from '../../src/composables/useReaderDictionary';
+import { useReaderDictionary } from '../../../src/composables/useReaderDictionary';
 const EPUB_WORD_REGEX = /[a-zA-Z0-9\u00C0-\u00FF]+(?:[’']?[a-zA-Z\u00C0-\u00FF]+)?/g;
 const normalizeLookupText = (text) => {
     return text.replace(/\s+/g, ' ').trim();

package/dist/{types → src/types}/common.d.ts

@@ -1,4 +1,5 @@
-import type { Link } from '@readium/shared';
+import type { TextAlignment } from '@readium/navigator';
+import type { Link, Locator, Publication } from '@readium/shared';
 export type ChapterBoundary = {
     title: string;
     /** Normalised progression (0–1) where this chapter starts in the file. */
@@ -52,4 +53,38 @@ export type ReadiumWordDecorationsController = {
     refresh: () => Promise<void>;
     destroy: () => void;
 };
+export type EpubReaderStrategy = 'wasm' | 'zip-fetcher';
+export type ReaderSettings = {
+    backgroundColor: string | null;
+    columnCount: number | null;
+    fontFamily: string | null;
+    fontSize: number | null;
+    isFullscreen: boolean;
+    lineHeight: number | null;
+    scroll: boolean | null;
+    textAlign: TextAlignment | null;
+    textColor: string | null;
+};
+export type ReaderStorageAdapter = {
+    savePosition: (key: string, locator: Locator) => void;
+    restorePosition: (key: string, publication: Publication) => Locator | undefined;
+};
+export type ReaderPreferencesAdapter = {
+    load: () => Partial<ReaderSettings> | Promise<Partial<ReaderSettings>>;
+    save?: (settings: Readonly<ReaderSettings>) => void | Promise<void>;
+};
+export type ReaderAssetConfig = {
+    swUrl?: string;
+    swScope?: string;
+    wasmUrl?: string;
+    fontBaseUrl?: string;
+};
+export type EpubReaderOptions = {
+    strategy?: EpubReaderStrategy;
+    settings?: Partial<ReaderSettings>;
+    storage?: ReaderStorageAdapter;
+    preferences?: ReaderPreferencesAdapter;
+    assets?: ReaderAssetConfig;
+    logNamespace?: string;
+};
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@caipira/vue-reader",
-    "version": "0.0.2",
+    "version": "0.0.3",
     "private": false,
     "description": "Headless e-book reader toolkit for vue",
     "author": {