@caipira/vue-reader 0.0.1

package/dist/src/composables/useEpubReaderController.js

@@ -0,0 +1,23 @@
+import { computed, onBeforeUnmount, onMounted, toValue, watch } from 'vue';
+import { createEpubReaderController } from '../../src/core/controller';
+export const useEpubReaderController = (src, containerRef, options) => {
+    const sourceRef = computed(() => toValue(src));
+    const controller = createEpubReaderController(sourceRef, containerRef, options);
+    onMounted(async () => {
+        if (!sourceRef.value) {
+            controller.state.error.value = 'No source URL provided';
+            return;
+        }
+        await controller.actions.init();
+    });
+    onBeforeUnmount(() => {
+        controller.actions.destroy();
+    });
+    watch(() => sourceRef.value, async (next, prev) => {
+        if (!next || next === prev) {
+            return;
+        }
+        await controller.actions.reload();
+    });
+    return controller;
+};

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

@@ -0,0 +1,6 @@
+import type { ReturnTypeCreateController } from '../../src/composables/utils';
+export declare const useEpubReaderNavigation: (controller?: ReturnTypeCreateController) => {
+    goForward: () => void;
+    goBackward: () => void;
+    goToLink: (link: import("..").TocEntry["link"]) => void;
+};

package/dist/src/composables/useEpubReaderNavigation.js

@@ -0,0 +1,26 @@
+import { useEpubReaderControllerRef } from '../../src/composables/useEpubReaderState';
+export const useEpubReaderNavigation = (controller) => {
+    if (controller) {
+        const { goForward, goBackward, goToLink } = controller.actions;
+        return {
+            goForward,
+            goBackward,
+            goToLink,
+        };
+    }
+    const activeEpubReader = useEpubReaderControllerRef();
+    const goForward = () => {
+        activeEpubReader.value?.actions?.goForward?.();
+    };
+    const goBackward = () => {
+        activeEpubReader.value?.actions?.goBackward?.();
+    };
+    const goToLink = (...args) => {
+        activeEpubReader.value?.actions?.goToLink?.(...args);
+    };
+    return {
+        goForward,
+        goBackward,
+        goToLink,
+    };
+};

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

@@ -0,0 +1,15 @@
+import type { ReturnTypeCreateController } from '../../src/composables/utils';
+export declare const useEpubReaderSettings: (controller: ReturnTypeCreateController) => {
+    settings: {
+        backgroundColor: string | null;
+        columnCount: number | null;
+        fontFamily: string | null;
+        fontSize: number | null;
+        isFullscreen: boolean;
+        lineHeight: number | null;
+        scroll: boolean | null;
+        textAlign: import("@readium/navigator").TextAlignment | null;
+        textColor: string | null;
+    };
+    toggleFullscreen: () => void;
+};

package/dist/src/composables/useEpubReaderSettings.js

@@ -0,0 +1,8 @@
+export const useEpubReaderSettings = (controller) => {
+    const { settings } = controller.state;
+    const { toggleFullscreen } = controller.actions;
+    return {
+        settings,
+        toggleFullscreen,
+    };
+};

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

@@ -0,0 +1,22 @@
+import type { ShallowRef } from 'vue';
+import { computed } from 'vue';
+import type { ReturnTypeCreateController } from '../../src/composables/utils';
+type ControllerState = ReturnTypeCreateController['state'];
+type ActiveState = {
+    error: ReturnType<typeof computed<string | null | undefined>>;
+    loading: ReturnType<typeof computed<boolean | undefined>>;
+    tocLinks: ReturnType<typeof computed<ControllerState['tocLinks']['value'] | undefined>>;
+    navigator: ReturnType<typeof computed<ControllerState['navigator']['value'] | undefined>>;
+    publication: ReturnType<typeof computed<ControllerState['publication']['value'] | undefined>>;
+    containerRef: ReturnType<typeof computed<HTMLDivElement | null | undefined>>;
+    totalPositions: ReturnType<typeof computed<number | undefined>>;
+    currentPosition: ReturnType<typeof computed<number | undefined>>;
+    progressPercent: ReturnType<typeof computed<number | undefined>>;
+    currentChapterTitle: ReturnType<typeof computed<string | undefined>>;
+    settings: ReturnType<typeof computed<ControllerState['settings'] | undefined>>;
+};
+export declare const setEpubReaderController: (reader: ReturnTypeCreateController | null) => void;
+export declare const useEpubReaderControllerRef: () => ShallowRef<ReturnTypeCreateController | null>;
+export declare function useEpubReaderState(controller: ReturnTypeCreateController): ReturnTypeCreateController['state'];
+export declare function useEpubReaderState(controller?: undefined, container?: Readonly<ShallowRef<HTMLDivElement | null>>): ActiveState;
+export {};

package/dist/src/composables/useEpubReaderState.js

@@ -0,0 +1,29 @@
+import { computed, ref, shallowRef } from 'vue';
+const containerRef = ref();
+const epubReaderController = shallowRef(null);
+export const setEpubReaderController = (reader) => {
+    epubReaderController.value = reader;
+};
+export const useEpubReaderControllerRef = () => epubReaderController;
+export function useEpubReaderState(controller, 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),
+        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),
+    };
+}

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

@@ -0,0 +1,8 @@
+export type ReaderDictionaryWordStatus = 'known' | 'unknown';
+export type ReaderDictionaryApi = {
+    classifyWords: (language: string, lemmas: string[], contextKey: string) => Promise<Map<string, ReaderDictionaryWordStatus>>;
+    clear: () => void;
+};
+export declare const setReaderDictionary: (dictionary: ReaderDictionaryApi) => void;
+export declare const hasReaderDictionary: () => boolean;
+export declare const useReaderDictionary: () => ReaderDictionaryApi;

package/dist/src/composables/useReaderDictionary.js

@@ -0,0 +1,13 @@
+let readerDictionary = null;
+export const setReaderDictionary = (dictionary) => {
+    readerDictionary = dictionary;
+};
+export const hasReaderDictionary = () => {
+    return readerDictionary !== null;
+};
+export const useReaderDictionary = () => {
+    if (!readerDictionary) {
+        throw new Error('Reader dictionary is not configured. Call setReaderDictionary() before enabling word highlighting.');
+    }
+    return readerDictionary;
+};

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

@@ -0,0 +1,25 @@
+import type { ReturnTypeCreateController } from '../../src/composables/utils';
+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 declare const useReaderSettings: (controller: ReturnTypeCreateController) => {
+    settings: {
+        backgroundColor: string | null;
+        columnCount: number | null;
+        fontFamily: string | null;
+        fontSize: number | null;
+        isFullscreen: boolean;
+        lineHeight: number | null;
+        scroll: boolean | null;
+        textAlign: import("@readium/navigator").TextAlignment | null;
+        textColor: string | null;
+    };
+    toggleFullscreen: () => void;
+};
+export {};

package/dist/src/composables/useReaderSettings.js

@@ -0,0 +1,42 @@
+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;
+    }
+    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;
+        }
+    };
+};
+export const useReaderSettings = (controller) => {
+    return useEpubReaderSettings(controller);
+};

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

@@ -0,0 +1,2 @@
+import type { createEpubReaderController } from '../../src/core/controller';
+export type ReturnTypeCreateController = ReturnType<typeof createEpubReaderController>;

package/dist/src/composables/utils.js

@@ -0,0 +1 @@
+export {};