@readium/navigator 2.1.0 → 2.2.0

package/src/webpub/WebPubFramePoolManager.ts

@@ -0,0 +1,174 @@
+import { ModuleName } from "@readium/navigator-html-injectables";
+import { Locator, Publication } from "@readium/shared";
+import { WebPubBlobBuilder } from "./WebPubBlobBuilder";
+import { WebPubFrameManager } from "./WebPubFrameManager";
+
+export class WebPubFramePoolManager {
+    private readonly container: HTMLElement;
+    private _currentFrame: WebPubFrameManager | undefined;
+    private readonly pool: Map<string, WebPubFrameManager> = new Map();
+    private readonly blobs: Map<string, string> = new Map();
+    private readonly inprogress: Map<string, Promise<void>> = new Map();
+    private currentBaseURL: string | undefined;
+
+    constructor(container: HTMLElement) {
+        this.container = container;
+    }
+
+    async destroy() {
+        // Wait for all in-progress loads to complete
+        let iit = this.inprogress.values();
+        let inp = iit.next();
+        const inprogressPromises: Promise<void>[] = [];
+        while(inp.value) {
+            inprogressPromises.push(inp.value);
+            inp = iit.next();
+        }
+        if(inprogressPromises.length > 0) {
+            await Promise.allSettled(inprogressPromises);
+        }
+        this.inprogress.clear();
+
+        // Destroy all frames
+        let fit = this.pool.values();
+        let frm = fit.next();
+        while(frm.value) {
+            await (frm.value as WebPubFrameManager).destroy();
+            frm = fit.next();
+        }
+        this.pool.clear();
+
+        // Revoke all blobs
+        this.blobs.forEach(v => URL.revokeObjectURL(v));
+        this.blobs.clear();
+
+        // Empty container of elements
+        this.container.childNodes.forEach(v => {
+            if(v.nodeType === Node.ELEMENT_NODE || v.nodeType === Node.TEXT_NODE) v.remove();
+        })
+    }
+
+    async update(pub: Publication, locator: Locator, modules: ModuleName[]) {
+        const readingOrder = pub.readingOrder.items;
+        let i = readingOrder.findIndex(l => l.href === locator.href);
+        if(i < 0) throw Error(`Locator not found in reading order: ${locator.href}`);
+        const newHref = readingOrder[i].href;
+
+        if(this.inprogress.has(newHref))
+            await this.inprogress.get(newHref);
+
+        const progressPromise = new Promise<void>(async (resolve, reject) => {
+            const disposal: string[] = [];
+            const creation: string[] = [];
+            pub.readingOrder.items.forEach((l, j) => {
+                // Dispose everything except current, previous, and next
+                if(j !== i && j !== i - 1 && j !== i + 1) {
+                    if(!disposal.includes(l.href)) disposal.push(l.href);
+                }
+
+                // CURRENT FRAME: always create the frame we're navigating to
+                if(j === i) {
+                    if(!creation.includes(l.href)) creation.push(l.href);
+                }
+
+                // PREVIOUS/NEXT FRAMES: create adjacent chapters for smooth navigation
+                // if((j === i - 1 || j === i + 1) && j >= 0 && j < pub.readingOrder.items.length) {
+                //    if(!creation.includes(l.href)) creation.push(l.href);
+                // }
+            });
+            disposal.forEach(async href => {
+                if(creation.includes(href)) return;
+                if(!this.pool.has(href)) return;
+                await this.pool.get(href)?.destroy();
+                this.pool.delete(href);
+            });
+
+            if(this.currentBaseURL !== undefined && pub.baseURL !== this.currentBaseURL) {
+                this.blobs.forEach(v => URL.revokeObjectURL(v));
+                this.blobs.clear();
+            }
+            this.currentBaseURL = pub.baseURL;
+
+            const creator = async (href: string) => {
+                if(this.pool.has(href)) {
+                    const fm = this.pool.get(href)!;
+                    if(!this.blobs.has(href)) {
+                        await fm.destroy();
+                        this.pool.delete(href);
+                    } else {
+                        await fm.load(modules);
+                        return;
+                    }
+                }
+                const itm = pub.readingOrder.findWithHref(href);
+                if(!itm) return;
+                if(!this.blobs.has(href)) {
+                    const blobBuilder = new WebPubBlobBuilder(pub, this.currentBaseURL || "", itm);
+                    const blobURL = await blobBuilder.build();
+                    this.blobs.set(href, blobURL);
+                }
+
+                const fm = new WebPubFrameManager(this.blobs.get(href)!);
+                if(href !== newHref) await fm.hide();
+                this.container.appendChild(fm.iframe);
+                await fm.load(modules);
+                this.pool.set(href, fm);
+            }
+            try {
+                await Promise.all(creation.map(href => creator(href)));
+            } catch (error) {
+                reject(error);
+            }
+
+            const newFrame = this.pool.get(newHref)!;
+            if(newFrame?.source !== this._currentFrame?.source) {
+                await this._currentFrame?.hide();
+                if(newFrame)
+                    await newFrame.load(modules);
+
+                if(newFrame)
+                    await newFrame.show(locator.locations.progression);
+
+                this._currentFrame = newFrame;
+            }
+            resolve();
+        });
+
+        this.inprogress.set(newHref, progressPromise);
+        await progressPromise;
+        this.inprogress.delete(newHref);
+    }
+
+    get currentFrames(): (WebPubFrameManager | undefined)[] {
+        return [this._currentFrame];
+    }
+
+    get currentBounds(): DOMRect {
+        const ret = {
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0,
+            top: 0,
+            right: 0,
+            bottom: 0,
+            left: 0,
+            toJSON() {
+                return this;
+            },
+        };
+        this.currentFrames.forEach(f => {
+            if(!f) return;
+            const b = f.realSize;
+            ret.x = Math.min(ret.x, b.x);
+            ret.y = Math.min(ret.y, b.y);
+            ret.width += b.width;
+            ret.height = Math.max(ret.height, b.height);
+            ret.top = Math.min(ret.top, b.top);
+            ret.right = Math.min(ret.right, b.right);
+            ret.bottom = Math.min(ret.bottom, b.bottom);
+            ret.left = Math.min(ret.left, b.left);
+        });
+        return ret as DOMRect;
+    }
+}

package/src/webpub/WebPubNavigator.ts

@@ -0,0 +1,417 @@
+import { Link, Locator, Publication, ReadingProgression, LocatorLocations } from "@readium/shared";
+import { VisualNavigator, VisualNavigatorViewport, ProgressionRange } from "../Navigator";
+import { WebPubFramePoolManager } from "./WebPubFramePoolManager";
+import { BasicTextSelection, CommsEventKey, FrameClickEvent, ModuleLibrary, ModuleName, WebPubModules } from "@readium/navigator-html-injectables";
+import * as path from "path-browserify";
+import { ManagerEventKey } from "../epub/EpubNavigator";
+
+export interface WebPubNavigatorListeners {
+    frameLoaded: (wnd: Window) => void;
+    positionChanged: (locator: Locator) => void;
+    tap: (e: FrameClickEvent) => boolean;
+    click: (e: FrameClickEvent) => boolean;
+    zoom: (scale: number) => void;
+    scroll: (delta: number) => void;
+    customEvent: (key: string, data: unknown) => void;
+    handleLocator: (locator: Locator) => boolean;
+    textSelected: (selection: BasicTextSelection) => void;
+}
+
+const defaultListeners = (listeners: WebPubNavigatorListeners): WebPubNavigatorListeners => ({
+    frameLoaded: listeners.frameLoaded || (() => {}),
+    positionChanged: listeners.positionChanged || (() => {}),
+    tap: listeners.tap || (() => false),
+    click: listeners.click || (() => false),
+    zoom: listeners.zoom || (() => {}),
+    scroll: listeners.scroll || (() => {}),
+    customEvent: listeners.customEvent || (() => {}),
+    handleLocator: listeners.handleLocator || (() => false),
+    textSelected: listeners.textSelected || (() => {})
+});
+
+class WebPubNavigator extends VisualNavigator {
+    private readonly pub: Publication;
+    private readonly container: HTMLElement;
+    private readonly listeners: WebPubNavigatorListeners;
+    private framePool: WebPubFramePoolManager;
+    private currentIndex: number = 0;
+    private currentLocation: Locator;
+    private webViewport: VisualNavigatorViewport = {
+        readingOrder: [],
+        progressions: new Map(),
+        positions: null
+    };
+
+    constructor(container: HTMLElement, pub: Publication, listeners: WebPubNavigatorListeners, initialPosition: Locator | undefined = undefined) {
+        super();
+        this.pub = pub;
+        this.container = container;
+        this.listeners = defaultListeners(listeners);
+        this.framePool = new WebPubFramePoolManager(this.container);
+        if (initialPosition && typeof initialPosition.copyWithLocations === 'function') {
+            this.currentLocation = initialPosition;
+            // Update currentIndex to match the initial position
+            const index = this.pub.readingOrder.findIndexWithHref(initialPosition.href);
+            if (index >= 0) {
+                this.currentIndex = index;
+            }
+        } else {
+            this.currentLocation = this.createCurrentLocator();
+        }
+    }
+
+    async load(): Promise<void> {
+        await this.framePool.update(this.pub, this.currentLocation, this.determineModules());
+
+        this.attachListener();
+
+        // Notify listeners of initial position
+        this.listeners.positionChanged(this.currentLocation);
+    }
+
+    public eventListener(key: CommsEventKey | ManagerEventKey, data: unknown) {
+        switch (key) {
+            case "_pong":
+                this.listeners.frameLoaded(this.framePool.currentFrames[0]!.iframe.contentWindow!);
+                this.listeners.positionChanged(this.currentLocation);
+                break;
+            case "first_visible_locator":
+                const loc = Locator.deserialize(data as string);
+                if(!loc) break;
+                this.currentLocation = new Locator({
+                    href: this.currentLocation.href,
+                    type: this.currentLocation.type,
+                    title: this.currentLocation.title,
+                    locations: loc?.locations,
+                    text: loc?.text
+                });
+                this.listeners.positionChanged(this.currentLocation);
+                break;
+            case "text_selected":
+                this.listeners.textSelected(data as BasicTextSelection);
+                break;
+            case "click":
+            case "tap":
+                const edata = data as FrameClickEvent;
+                if (edata.interactiveElement) {
+                    const element = new DOMParser().parseFromString(
+                        edata.interactiveElement,
+                        "text/html"
+                    ).body.children[0];
+                    if (
+                        element.nodeType === element.ELEMENT_NODE &&
+                        element.nodeName === "A" &&
+                        element.hasAttribute("href")
+                    ) {
+                        const origHref = element.attributes.getNamedItem("href")?.value!;
+                        if (origHref.startsWith("#")) {
+                            this.go(this.currentLocation.copyWithLocations({
+                                fragments: [origHref.substring(1)]
+                            }), false, () => { });
+                        } else if(
+                            origHref.startsWith("mailto:") ||
+                            origHref.startsWith("tel:")
+                        ) {
+                            this.listeners.handleLocator(new Link({
+                                href: origHref,
+                            }).locator);
+                        } else {
+                            // Handle internal links that should navigate within the WebPub
+                            // This includes relative links and full URLs that might be in the readingOrder
+                            try {
+                                let hrefToCheck;
+
+                                // If origHref is already a full URL, use it directly
+                                if (origHref.startsWith("http://") || origHref.startsWith("https://")) {
+                                    hrefToCheck = origHref;
+                                } else {
+                                    // For relative URLs, use different strategies based on base URL format
+                                    if (this.currentLocation.href.startsWith("http://") || this.currentLocation.href.startsWith("https://")) {
+                                        // Base URL is absolute, use URL constructor
+                                        const currentUrl = new URL(this.currentLocation.href);
+                                        const resolvedUrl = new URL(origHref, currentUrl);
+                                        hrefToCheck = resolvedUrl.href;
+                                    } else {
+                                        // Base URL is relative, use path operations
+                                        hrefToCheck = path.join(path.dirname(this.currentLocation.href), origHref);
+                                    }
+                                }
+
+                                const link = this.pub.readingOrder.findWithHref(hrefToCheck);
+                                if (link) {
+                                    this.goLink(link, false, () => { });
+                                } else {
+                                    console.warn(`Internal link not found in readingOrder: ${hrefToCheck}`);
+                                    this.listeners.handleLocator(new Link({
+                                        href: origHref,
+                                    }).locator);
+                                }
+                            } catch (error) {
+                                console.warn(`Couldn't resolve internal link for ${origHref}: ${error}`);
+                                this.listeners.handleLocator(new Link({
+                                    href: origHref,
+                                }).locator);
+                            }
+                        }
+                    } else console.log("Clicked on", element);
+                } else {
+                    const handled = key === "click" ? this.listeners.click(edata) : this.listeners.tap(edata);
+                    if(handled) break;
+                }
+                break;
+            case "scroll":
+                this.listeners.scroll(data as number);
+                break;
+            case "zoom":
+                this.listeners.zoom(data as number);
+                break;
+            case "progress":
+                this.syncLocation(data as ProgressionRange);
+                break;
+            case "log":
+                console.log(this.framePool.currentFrames[0]?.source?.split("/")[3], ...(data as any[]));
+                break;
+            default:
+                this.listeners.customEvent(key, data);
+                break;
+        }
+    }
+
+    private determineModules(): ModuleName[] {
+        let modules = Array.from(ModuleLibrary.keys()) as ModuleName[];
+
+        // For WebPub, use the predefined WebPubModules array and filter
+        return modules.filter((m) => WebPubModules.includes(m));
+    }
+
+    private attachListener() {
+        if (this.framePool.currentFrames[0]?.msg) {
+            this.framePool.currentFrames[0].msg.listener = (key: CommsEventKey | ManagerEventKey, value: unknown) => {
+                this.eventListener(key, value);
+            };
+        }
+    }
+
+    private async apply() {
+        await this.framePool.update(this.pub, this.currentLocation, this.determineModules());
+
+        this.attachListener();
+
+        const idx = this.pub.readingOrder.findIndexWithHref(this.currentLocation.href);
+        if (idx < 0)
+            throw Error("Link for " + this.currentLocation.href + " not found!");
+    }
+
+    public async destroy() {
+        await this.framePool?.destroy();
+    }
+
+    private async changeResource(relative: number): Promise<boolean> {
+        if (relative === 0) return false;
+
+        const curr = this.pub.readingOrder.findIndexWithHref(this.currentLocation.href);
+        const i = Math.max(
+            0,
+            Math.min(this.pub.readingOrder.items.length - 1, curr + relative)
+        );
+        if (i === curr) {
+            return false;
+        }
+        this.currentIndex = i;
+        this.currentLocation = this.createCurrentLocator();
+        await this.apply();
+        return true;
+    }
+
+    private updateViewport(progression: ProgressionRange) {
+        this.webViewport.readingOrder = [];
+        this.webViewport.progressions.clear();
+        this.webViewport.positions = null;
+
+        // Use the current position's href
+        if (this.currentLocation) {
+            this.webViewport.readingOrder.push(this.currentLocation.href);
+            this.webViewport.progressions.set(this.currentLocation.href, progression);
+
+            if (this.currentLocation.locations?.position !== undefined) {
+                this.webViewport.positions = [this.currentLocation.locations.position];
+                // WebPub doesn't have lastLocationInView like EPUB, so no second position
+            }
+        }
+    }
+
+    private async syncLocation(iframeProgress: ProgressionRange): Promise<void> {
+        const progression = iframeProgress;
+        if (this.currentLocation) {
+            this.currentLocation = this.currentLocation.copyWithLocations({
+                progression: progression.start
+            });
+        }
+
+        this.updateViewport(progression);
+        this.listeners.positionChanged(this.currentLocation);
+        await this.framePool.update(this.pub, this.currentLocation, this.determineModules());
+    }
+
+    goBackward(_animated: boolean, cb: (ok: boolean) => void): void {
+        this.changeResource(-1).then((success) => {
+            cb(success);
+        });
+    }
+
+    goForward(_animated: boolean, cb: (ok: boolean) => void): void {
+        this.changeResource(1).then((success) => {
+            cb(success);
+        });
+    }
+
+    get currentLocator(): Locator {
+        return this.currentLocation;
+    }
+
+    get viewport(): VisualNavigatorViewport {
+        return this.webViewport;
+    }
+
+    get isScrollStart(): boolean {
+        const firstHref = this.viewport.readingOrder[0];
+        const progression = this.viewport.progressions.get(firstHref);
+        return progression?.start === 0;
+    }
+
+    get isScrollEnd(): boolean {
+        const lastHref = this.viewport.readingOrder[this.viewport.readingOrder.length - 1];
+        const progression = this.viewport.progressions.get(lastHref);
+        return progression?.end === 1;
+    }
+
+    get canGoBackward(): boolean {
+        const firstResource = this.pub.readingOrder.items[0]?.href;
+        return !(this.viewport.progressions.has(firstResource) && this.viewport.progressions.get(firstResource)?.start === 0);
+    }
+
+    get canGoForward(): boolean {
+        const lastResource = this.pub.readingOrder.items[this.pub.readingOrder.items.length - 1]?.href;
+        return !(this.viewport.progressions.has(lastResource) && this.viewport.progressions.get(lastResource)?.end === 1);
+    }
+
+    get readingProgression(): ReadingProgression {
+        return this.pub.metadata.effectiveReadingProgression;
+    }
+
+    get publication(): Publication {
+        return this.pub;
+    }
+
+    private async loadLocator(locator: Locator, cb: (ok: boolean) => void) {
+        let done = false;
+        let cssSelector = (typeof locator.locations.getCssSelector === 'function') && locator.locations.getCssSelector();
+        if(locator.text?.highlight) {
+            done = await new Promise<boolean>((res, _) => {
+                // Attempt to go to a highlighted piece of text in the resource
+                this.framePool.currentFrames[0]!.msg!.send(
+                    "go_text",
+                    cssSelector ? [
+                        locator.text?.serialize(),
+                        cssSelector // Include CSS selector if it exists
+                    ] : locator.text?.serialize(),
+                    (ok) => res(ok)
+                );
+            });
+        } else if(cssSelector) {
+            done = await new Promise<boolean>((res, _) => {
+                this.framePool.currentFrames[0]!.msg!.send(
+                    "go_text",
+                    [
+                        "", // No text!
+                        cssSelector // Just CSS selector
+                    ],
+                    (ok) => res(ok)
+                );
+            });
+        }
+        if(done) {
+            cb(done);
+            return;
+        }
+        // This sanity check has to be performed because we're still passing non-locator class
+        // locator objects to this function. This is not good and should eventually be forbidden
+        // or the locator should be deserialized sometime before this function.
+        const hid = (typeof locator.locations.htmlId === 'function') && locator.locations.htmlId();
+        if(hid)
+            done = await new Promise<boolean>((res, _) => {
+                // Attempt to go to an HTML ID in the resource
+                this.framePool.currentFrames[0]!.msg!.send("go_id", hid, (ok) => res(ok));
+            });
+        if(done) {
+            cb(done);
+            return;
+        }
+
+        const progression = locator?.locations?.progression;
+        const hasProgression = progression && progression > 0;
+        if(hasProgression)
+            done = await new Promise<boolean>((res, _) => {
+                // Attempt to go to a progression in the resource
+                this.framePool.currentFrames[0]!.msg!.send("go_progression", progression, (ok) => res(ok));
+            });
+        else done = true;
+        cb(done);
+    }
+
+    public go(locator: Locator, _: boolean, cb: (ok: boolean) => void): void {
+        const href = locator.href.split("#")[0];
+        let link = this.pub.readingOrder.findWithHref(href);
+        if(!link) {
+            return cb(this.listeners.handleLocator(locator));
+        }
+
+         // Update currentIndex to point to the found link
+        const index = this.pub.readingOrder.findIndexWithHref(href);
+        if (index >= 0) {
+            this.currentIndex = index;
+        }
+
+        this.currentLocation = this.createCurrentLocator();
+        this.apply().then(() => this.loadLocator(locator, (ok) => cb(ok))).then(() => {
+            // Now that we've gone to the right locator, we can attach the listeners.
+            // Doing this only at this stage reduces janky UI with multiple locator updates.
+            this.attachListener();
+        });
+    }
+
+    public goLink(link: Link, animated: boolean, cb: (ok: boolean) => void): void {
+        return this.go(link.locator, animated, cb);
+    }
+
+    // Specifics to WebPub
+    // Util method
+    private createCurrentLocator(): Locator {
+        const readingOrder = this.pub.readingOrder;
+        const currentLink = readingOrder.items[this.currentIndex];
+
+        if (!currentLink) {
+            throw new Error("No current resource available");
+        }
+
+        // Check if we're on the same resource
+        const isSameResource = this.currentLocation && this.currentLocation.href === currentLink.href;
+
+        // Preserve progression if staying on same resource, otherwise start from beginning
+        const progression = isSameResource && this.currentLocation.locations.progression
+            ? this.currentLocation.locations.progression
+            : 0;
+
+        return this.pub.manifest.locatorFromLink(currentLink) || new Locator({
+            href: currentLink.href,
+            type: currentLink.type || "text/html",
+            locations: new LocatorLocations({
+                fragments: [],
+                progression: progression,
+                position: this.currentIndex + 1
+            })
+        });
+    }
+}
+
+export const ExperimentalWebPubNavigator = WebPubNavigator;

package/src/webpub/index.ts

@@ -0,0 +1,4 @@
+export * from "./WebPubNavigator";
+export * from "./WebPubBlobBuilder";
+export * from "./WebPubFrameManager";
+export * from "./WebPubFramePoolManager";

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

@@ -1,4 +1,4 @@
-import { TextAlignment, Theme } from "../../preferences/Types";
+import { TextAlignment } from "../../preferences/Types";
 export type BodyHyphens = "auto" | "none";
 export type BoxSizing = "content-box" | "border-box";
 export type FontOpticalSizing = "auto" | "none";
@@ -22,7 +22,6 @@ declare abstract class Properties {
 export interface IUserProperties {
     advancedSettings?: boolean | null;
     a11yNormalize?: boolean | null;
-    appearance?: Theme | null;
     backgroundColor?: string | null;
     blendFilter?: boolean | null;
     bodyHyphens?: BodyHyphens | null;
@@ -57,7 +56,6 @@ export interface IUserProperties {
 }
 export declare class UserProperties extends Properties {
     a11yNormalize: boolean | null;
-    appearance: Theme | null;
     backgroundColor: string | null;
     blendFilter: boolean | null;
     bodyHyphens: BodyHyphens | null;

package/types/src/epub/preferences/EpubDefaults.d.ts

@@ -1,4 +1,4 @@
-import { TextAlignment, Theme } from "../../preferences/Types";
+import { TextAlignment } from "../../preferences/Types";
 export interface IEpubDefaults {
     backgroundColor?: string | null;
     blendFilter?: boolean | null;
@@ -36,7 +36,6 @@ export interface IEpubDefaults {
     textAlign?: TextAlignment | null;
     textColor?: string | null;
     textNormalization?: boolean | null;
-    theme?: Theme | null;
     visitedColor?: string | null;
     wordSpacing?: number | null;
 }
@@ -77,7 +76,6 @@ export declare class EpubDefaults {
     textAlign: TextAlignment | null;
     textColor: string | null;
     textNormalization: boolean | null;
-    theme: Theme | null;
     visitedColor: string | null;
     wordSpacing: number | null;
     constructor(defaults: IEpubDefaults);

package/types/src/epub/preferences/EpubPreferences.d.ts

@@ -1,5 +1,5 @@
 import { ConfigurablePreferences } from "../../preferences/Configurable";
-import { TextAlignment, Theme } from "../../preferences/Types";
+import { TextAlignment } from "../../preferences/Types";
 export interface IEpubPreferences {
     backgroundColor?: string | null;
     blendFilter?: boolean | null;
@@ -37,7 +37,6 @@ export interface IEpubPreferences {
     textAlign?: TextAlignment | null;
     textColor?: string | null;
     textNormalization?: boolean | null;
-    theme?: Theme | null;
     visitedColor?: string | null;
     wordSpacing?: number | null;
 }
@@ -78,7 +77,6 @@ export declare class EpubPreferences implements ConfigurablePreferences {
     textAlign?: TextAlignment | null;
     textColor?: string | null;
     textNormalization?: boolean | null;
-    theme?: Theme | null;
     visitedColor?: string | null;
     wordSpacing?: number | null;
     constructor(preferences?: IEpubPreferences);

package/types/src/epub/preferences/EpubPreferencesEditor.d.ts

@@ -3,7 +3,7 @@ import { IPreferencesEditor } from "../../preferences/PreferencesEditor";
 import { EpubPreferences } from "./EpubPreferences";
 import { EpubSettings } from "./EpubSettings";
 import { BooleanPreference, EnumPreference, Preference, RangePreference } from "../../preferences/Preference";
-import { TextAlignment, Theme } from "../../preferences/Types";
+import { TextAlignment } from "../../preferences/Types";
 export declare class EpubPreferencesEditor implements IPreferencesEditor {
     preferences: EpubPreferences;
     private settings;
@@ -48,7 +48,6 @@ export declare class EpubPreferencesEditor implements IPreferencesEditor {
     get textAlign(): EnumPreference<TextAlignment>;
     get textColor(): Preference<string>;
     get textNormalization(): BooleanPreference;
-    get theme(): EnumPreference<Theme>;
     get visitedColor(): Preference<string>;
     get wordSpacing(): RangePreference<number>;
 }