@prose-reader/core 1.58.0 → 1.60.0

package/dist/index.umd.cjs

@@ -1,7 +1,15 @@
 (function(global, factory) {
   typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("rxjs"), require("rxjs/operators"), require("@prose-reader/shared")) : typeof define === "function" && define.amd ? define(["exports", "rxjs", "rxjs/operators", "@prose-reader/shared"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.prose = {}, global.rxjs, global.operators, global.shared));
 })(this, function(exports2, rxjs, operators, shared) {
-  "use strict";
+  "use strict";var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+  var _context;
   const chromeEnhancer = (next) => (options) => {
     const reader = next(options);
     reader.context.state$.pipe(rxjs.takeUntil(reader.$.destroy$)).subscribe(({ containerElement }) => {
@@ -73,21 +81,98 @@
       reader.readAsDataURL(data);
     });
   };
+  function shallowMergeIfDefined(obj1, obj2) {
+    const result = { ...obj1 };
+    for (const key in obj2) {
+      if (Object.prototype.hasOwnProperty.call(obj2, key)) {
+        const value = obj2[key];
+        if (value !== void 0 || !(key in obj1)) {
+          result[key] = value;
+        }
+      }
+    }
+    return result;
+  }
+  class SettingsManagerOverload {
+    constructor(initialSettings, settingsManager) {
+      this.settingsManager = settingsManager;
+      this.inputSettings = shallowMergeIfDefined(this.getDefaultSettings(), initialSettings);
+      this.outputSettings = this.computeOutputSettings();
+      this.outputSettingsUpdateSubject = new rxjs.Subject();
+      this.settings$ = rxjs.combineLatest([
+        this.settingsManager.settings$,
+        this.outputSettingsUpdateSubject.pipe(operators.startWith(this.outputSettings))
+      ]).pipe(
+        operators.map(([parentSettings, settings]) => ({ ...parentSettings, ...settings })),
+        operators.shareReplay(1)
+      );
+      this.settings$.subscribe();
+    }
+    _prepareUpdate(settings) {
+      const parentInputSettings = this.getCleanedParentInputSettings(settings);
+      const parentManagerPreparedUpdate = this.settingsManager._prepareUpdate(parentInputSettings);
+      this.inputSettings = { ...this.inputSettings, ...settings };
+      const outputSettings = this.computeOutputSettings();
+      const hasChanged = this.hasSettingsChanged(outputSettings);
+      console.log({ outputSettings, hasChanged, parentManagerPreparedUpdate });
+      return {
+        hasChanged: hasChanged || parentManagerPreparedUpdate.hasChanged,
+        commit: () => {
+          this.outputSettings = outputSettings;
+          if (!parentManagerPreparedUpdate.hasChanged && hasChanged) {
+            this.outputSettingsUpdateSubject.next(outputSettings);
+          }
+          parentManagerPreparedUpdate.commit();
+        }
+      };
+    }
+    update(settings) {
+      const { commit } = this._prepareUpdate(settings);
+      commit();
+    }
+    get settings() {
+      return {
+        ...this.settingsManager.settings,
+        ...this.outputSettings
+      };
+    }
+    destroy() {
+      this.outputSettingsUpdateSubject.complete();
+    }
+  }
+  let SettingsManager$1 = class SettingsManager extends SettingsManagerOverload {
+    computeOutputSettings() {
+      return this.inputSettings;
+    }
+    hasSettingsChanged(newOutputSettings) {
+      return !isShallowEqual(this.outputSettings, newOutputSettings);
+    }
+    getCleanedParentInputSettings(settings) {
+      const { fontJustification, fontScale, fontWeight, lineHeight, ...rest } = settings;
+      return rest;
+    }
+    getDefaultSettings() {
+      return {
+        fontScale: 1,
+        fontWeight: "publisher",
+        lineHeight: "publisher",
+        fontJustification: "publisher"
+      };
+    }
+  };
   const fontsEnhancer = (next) => (options) => {
-    const {
-      fontScale = 1,
-      lineHeight = `publisher`,
-      fontWeight = `publisher`,
-      fontJustification = `publisher`
-    } = options;
+    const { fontScale, lineHeight, fontWeight, fontJustification } = options;
     const changes$ = new rxjs.Subject();
-    const settings$ = new rxjs.BehaviorSubject({
-      fontScale,
-      lineHeight,
-      fontWeight,
-      fontJustification
-    });
     const reader = next(options);
+    const settingsManager = new SettingsManager$1(
+      {
+        fontScale,
+        lineHeight,
+        fontWeight,
+        fontJustification
+      },
+      reader.settings
+    );
     const getStyle = () => `
     ${/*
           Ideally, we would like to use !important but it could break publisher specific
@@ -99,10 +184,10 @@
         */
     ``}
     body {
-      ${settings$.value.fontScale !== 1 ? `font-size: ${settings$.value.fontScale}em !important;` : ``}
-      ${settings$.value.lineHeight !== `publisher` ? `line-height: ${settings$.value.lineHeight} !important;` : ``}
-      ${settings$.value.fontWeight !== `publisher` ? `font-weight: ${settings$.value.fontWeight} !important;` : ``}
-      ${settings$.value.fontJustification !== `publisher` ? `text-align: ${settings$.value.fontJustification} !important;` : ``}
+      ${settingsManager.settings.fontScale !== 1 ? `font-size: ${settingsManager.settings.fontScale}em !important;` : ``}
+      ${settingsManager.settings.lineHeight !== `publisher` ? `line-height: ${settingsManager.settings.lineHeight} !important;` : ``}
+      ${settingsManager.settings.fontWeight !== `publisher` ? `font-weight: ${settingsManager.settings.fontWeight} !important;` : ``}
+      ${settingsManager.settings.fontJustification !== `publisher` ? `text-align: ${settingsManager.settings.fontJustification} !important;` : ``}
     }
   `;
     const applyChangeToSpineItem = (requireLayout) => {
@@ -132,42 +217,15 @@
         return false;
       })
     );
-    const newSettings$ = changes$.pipe(
-      operators.withLatestFrom(settings$),
-      rxjs.map(([changes, settings]) => ({
-        fontJustification: changes.fontJustification ?? settings.fontJustification,
-        fontWeight: changes.fontWeight ?? settings.fontWeight,
-        lineHeight: changes.lineHeight ?? settings.lineHeight,
-        fontScale: Math.max(0.01, changes.fontScale ?? settings.fontScale)
-      })),
-      operators.distinctUntilChanged(isShallowEqual),
-      operators.shareReplay(1)
-    );
-    newSettings$.subscribe(settings$);
-    settings$.pipe(shouldRequireLayout, operators.tap(applyChangeToSpineItem), rxjs.takeUntil(reader.$.destroy$)).subscribe();
-    const settingsMerge$ = rxjs.combineLatest([reader.settings.settings$, settings$]).pipe(
-      rxjs.map(([innerSettings, settings]) => ({
-        ...innerSettings,
-        ...settings
-      }))
-    );
-    const setSettings = (settings) => {
-      const { fontJustification: fontJustification2, fontScale: fontScale2, fontWeight: fontWeight2, lineHeight: lineHeight2, ...passthroughSettings } = settings;
-      changes$.next({ fontJustification: fontJustification2, fontScale: fontScale2, fontWeight: fontWeight2, lineHeight: lineHeight2 });
-      reader.settings.setSettings(passthroughSettings);
-    };
+    settingsManager.settings$.pipe(shouldRequireLayout, operators.tap(applyChangeToSpineItem), rxjs.takeUntil(reader.$.destroy$)).subscribe();
     return {
       ...reader,
       destroy: () => {
         changes$.complete();
-        settings$.complete();
+        settingsManager.destroy();
         reader.destroy();
       },
-      settings: {
-        ...reader.settings,
-        setSettings,
-        settings$: settingsMerge$
-      }
+      settings: settingsManager
     };
   };
   const hotkeysEnhancer = (next) => (options) => {
@@ -293,14 +351,37 @@
   function isDefined(arg) {
     return arg !== null && arg !== void 0;
   }
+  class SettingsManager extends SettingsManagerOverload {
+    computeOutputSettings() {
+      return this.inputSettings;
+    }
+    hasSettingsChanged(newOutputSettings) {
+      return !isShallowEqual(this.outputSettings, newOutputSettings);
+    }
+    getCleanedParentInputSettings(settings) {
+      const { layoutAutoResize, pageHorizontalMargin, pageVerticalMargin, ...rest } = settings;
+      return rest;
+    }
+    getDefaultSettings() {
+      return {
+        layoutAutoResize: "container",
+        pageHorizontalMargin: 24,
+        pageVerticalMargin: 24
+      };
+    }
+  }
   const SHOULD_NOT_LAYOUT = false;
   const layoutEnhancer = (next) => (options) => {
-    const { pageHorizontalMargin = 24, pageVerticalMargin = 24 } = options;
+    const { pageHorizontalMargin, pageVerticalMargin, layoutAutoResize } = options;
     const reader = next(options);
-    const settingsSubject$ = new rxjs.BehaviorSubject({
-      pageHorizontalMargin,
-      pageVerticalMargin
-    });
+    const settingsManager = new SettingsManager(
+      {
+        pageHorizontalMargin,
+        pageVerticalMargin,
+        layoutAutoResize
+      },
+      reader.settings
+    );
     reader.hookManager.register(`onViewportOffsetAdjust`, () => {
       let hasRedrawn = false;
       reader.spine.manipulateSpineItems(({ frame }) => {
@@ -313,7 +394,7 @@
     });
     reader.hookManager.register(`item.onLayoutBeforeMeasurement`, ({ frame, minimumWidth, item, isImageType }) => {
       var _a, _b;
-      const { pageHorizontalMargin: pageHorizontalMargin2 = 0, pageVerticalMargin: pageVerticalMargin2 = 0 } = settingsSubject$.value;
+      const { pageHorizontalMargin: pageHorizontalMargin2 = 0, pageVerticalMargin: pageVerticalMargin2 = 0 } = settingsManager.settings;
       const pageSize = reader.context.getPageSize();
       if (item.renditionLayout === `reflowable` && frame.getIsReady() && !isImageType() && !frame.getViewportDimensions()) {
         let columnWidth = pageSize.width - pageHorizontalMargin2 * 2;
@@ -367,7 +448,7 @@
     }
     const movingSafePan$ = createMovingSafePan$(reader);
     movingSafePan$.subscribe();
-    settingsSubject$.pipe(
+    settingsManager.settings$.pipe(
       mapKeysTo([`pageHorizontalMargin`, `pageVerticalMargin`]),
       operators.distinctUntilChanged(isShallowEqual),
       operators.skip(1),
@@ -376,32 +457,14 @@
       }),
       operators.takeUntil(reader.$.destroy$)
     ).subscribe();
-    const settings$ = rxjs.combineLatest([reader.settings.settings$, settingsSubject$.asObservable()]).pipe(
-      operators.map(([innerSettings, settings]) => ({
-        ...innerSettings,
-        ...settings
-      }))
-    );
-    const setSettings = ({ pageVerticalMargin: pageVerticalMargin2, pageHorizontalMargin: pageHorizontalMargin2, ...rest }) => {
-      if (pageHorizontalMargin2 !== void 0 || pageVerticalMargin2 !== void 0) {
-        settingsSubject$.next({
-          pageHorizontalMargin: pageHorizontalMargin2 ?? settingsSubject$.value.pageHorizontalMargin,
-          pageVerticalMargin: pageVerticalMargin2 ?? settingsSubject$.value.pageVerticalMargin
-        });
-      }
-      reader.settings.setSettings(rest);
-    };
     return {
       ...reader,
       destroy: () => {
+        settingsManager.destroy();
         reader.destroy();
         observer == null ? void 0 : observer.disconnect();
       },
-      settings: {
-        ...reader.settings,
-        setSettings,
-        settings$
-      }
+      settings: settingsManager
     };
   };
   const ROOT_NAMESPACE = `@prose-reader/core`;
@@ -5158,7 +5221,7 @@
       }),
       operators.switchMap(([, currentEvent]) => {
         if ((currentEvent == null ? void 0 : currentEvent.type) !== `manualAdjust`) return rxjs.EMPTY;
-        const animationDuration = currentEvent.animation === `snap` ? settings.settings.computedSnapAnimationDuration : settings.settings.computedPageTurnAnimationDuration;
+        const animationDuration = currentEvent.animation === `snap` ? settings.settings.snapAnimationDuration : settings.settings.computedPageTurnAnimationDuration;
         const pageTurnAnimation = currentEvent.animation === `snap` ? `slide` : settings.settings.computedPageTurnAnimation;
         return rxjs.of(currentEvent).pipe(
           /**
@@ -5506,96 +5569,111 @@
       generateFromRange
     };
   };
-  const getComputedSettings = (settings, context) => {
-    const manifest = context.manifest;
-    const hasVerticalWriting = context.state.hasVerticalWriting ?? false;
-    const computedSettings = {
-      computedPageTurnDirection: settings.pageTurnDirection,
-      computedPageTurnAnimation: settings.pageTurnAnimation,
-      computedPageTurnMode: `controlled`,
-      computedPageTurnAnimationDuration: 0,
-      computedSnapAnimationDuration: 0
-    };
-    if ((manifest == null ? void 0 : manifest.renditionFlow) === `scrolled-continuous`) {
-      computedSettings.computedPageTurnMode = `scrollable`;
-      computedSettings.computedPageTurnDirection = `vertical`;
-    } else if (manifest && settings.pageTurnMode === `scrollable` && (manifest.renditionLayout !== `pre-paginated` || !areAllItemsPrePaginated(manifest))) {
-      Report.warn(`pageTurnMode ${settings.pageTurnMode} incompatible with current book, switching back to default`);
-      computedSettings.computedPageTurnAnimation = `none`;
-      computedSettings.computedPageTurnMode = `controlled`;
-    } else if (settings.pageTurnMode === `scrollable`) {
-      computedSettings.computedPageTurnMode = `scrollable`;
-      computedSettings.computedPageTurnDirection = `vertical`;
-    }
-    if (hasVerticalWriting && computedSettings.computedPageTurnAnimation === `slide`) {
-      Report.warn(
-        `pageTurnAnimation ${computedSettings.computedPageTurnAnimation} incompatible with current book, switching back to default`
-      );
-      computedSettings.computedPageTurnAnimation = `none`;
-    }
-    if (computedSettings.computedPageTurnMode === `scrollable`) {
-      computedSettings.computedPageTurnAnimationDuration = 0;
-      computedSettings.computedPageTurnAnimation = `none`;
-    } else {
-      computedSettings.computedPageTurnAnimationDuration = settings.pageTurnAnimationDuration !== void 0 ? settings.pageTurnAnimationDuration : 300;
-    }
-    return computedSettings;
-  };
-  const defaultSettings = {
-    forceSinglePageMode: false,
-    pageTurnAnimation: `none`,
-    //   computedPageTurnAnimation: `none`,
-    pageTurnDirection: `horizontal`,
-    //   computedPageTurnDirection: `horizontal`,
-    pageTurnAnimationDuration: void 0,
-    //   computedPageTurnAnimationDuration: 0,
-    pageTurnMode: `controlled`,
-    //   computedPageTurnMode: `controlled`,
-    //   computedSnapAnimationDuration: 300,
-    navigationSnapThreshold: 0.3,
-    numberOfAdjacentSpineItemToPreLoad: 0
-  };
-  class SettingsManager {
+  class ReaderSettingsManager {
     constructor(initialSettings, context) {
-      this._context = context;
+      __privateAdd(this, _context);
+      __privateSet(this, _context, context);
       const settingsWithDefaults = {
-        ...defaultSettings,
+        ...this.getDefaultSettings(),
         ...initialSettings
       };
-      const computedSettings = getComputedSettings(settingsWithDefaults, context);
-      const settings = { ...settingsWithDefaults, ...computedSettings };
-      this._settingsSubject$ = new rxjs.BehaviorSubject(settings);
-      this.settings$ = this._settingsSubject$.asObservable().pipe(operators.distinctUntilChanged(isShallowEqual));
+      const outputSettings = this.getOutputSettings(settingsWithDefaults);
+      this.outputSettings = outputSettings;
+      this.outputSettingsUpdateSubject = new rxjs.Subject();
+      this.settings$ = this.outputSettingsUpdateSubject.asObservable().pipe(operators.startWith(this.settings), operators.shareReplay(1));
       const recomputeSettingsOnContextChange$ = rxjs.combineLatest([context.hasVerticalWriting$, context.manifest$]).pipe(
         operators.tap(() => {
-          this._updateSettings(this.settings);
+          this.update(this.settings);
         })
       );
-      const updateContextOnSettingsChanges$ = this._settingsSubject$.pipe(
+      const updateContextOnSettingsChanges$ = this.settings$.pipe(
         operators.tap(({ forceSinglePageMode }) => {
           context.update({ forceSinglePageMode });
         })
       );
       rxjs.merge(recomputeSettingsOnContextChange$, updateContextOnSettingsChanges$).pipe(operators.takeUntil(context.destroy$)).subscribe();
+      this.settings$.subscribe();
     }
-    // @see https://github.com/microsoft/TypeScript/issues/17293
-    _updateSettings(settings) {
-      const computed = getComputedSettings(settings, this._context);
-      const newMergedSettings = { ...settings, ...computed };
-      this._settingsSubject$.next(newMergedSettings);
+    getComputedSettings(settings) {
+      const manifest = __privateGet(this, _context).manifest;
+      const hasVerticalWriting = __privateGet(this, _context).state.hasVerticalWriting ?? false;
+      const computedSettings = {
+        computedPageTurnDirection: settings.pageTurnDirection,
+        computedPageTurnAnimation: settings.pageTurnAnimation,
+        computedPageTurnMode: `controlled`,
+        computedPageTurnAnimationDuration: 0
+      };
+      if ((manifest == null ? void 0 : manifest.renditionFlow) === `scrolled-continuous`) {
+        computedSettings.computedPageTurnMode = `scrollable`;
+        computedSettings.computedPageTurnDirection = `vertical`;
+      } else if (manifest && settings.pageTurnMode === `scrollable` && (manifest.renditionLayout !== `pre-paginated` || !areAllItemsPrePaginated(manifest))) {
+        Report.warn(`pageTurnMode ${settings.pageTurnMode} incompatible with current book, switching back to default`);
+        computedSettings.computedPageTurnAnimation = `none`;
+        computedSettings.computedPageTurnMode = `controlled`;
+      } else if (settings.pageTurnMode === `scrollable`) {
+        computedSettings.computedPageTurnMode = `scrollable`;
+        computedSettings.computedPageTurnDirection = `vertical`;
+      }
+      if (hasVerticalWriting && computedSettings.computedPageTurnAnimation === `slide`) {
+        Report.warn(
+          `pageTurnAnimation ${computedSettings.computedPageTurnAnimation} incompatible with current book, switching back to default`
+        );
+        computedSettings.computedPageTurnAnimation = `none`;
+      }
+      if (computedSettings.computedPageTurnMode === `scrollable`) {
+        computedSettings.computedPageTurnAnimationDuration = 0;
+        computedSettings.computedPageTurnAnimation = `none`;
+      } else {
+        computedSettings.computedPageTurnAnimationDuration = settings.pageTurnAnimationDuration !== void 0 ? settings.pageTurnAnimationDuration : 300;
+      }
+      return computedSettings;
+    }
+    _prepareUpdate(settings) {
+      const state = this.getOutputSettings(settings);
+      const hasChanged = !isShallowEqual(this.outputSettings, state);
+      return {
+        hasChanged,
+        state,
+        commit: () => {
+          this.outputSettings = state;
+          if (hasChanged) {
+            this.outputSettingsUpdateSubject.next(state);
+          }
+        }
+      };
+    }
+    getOutputSettings(inputSettings) {
+      const computedSettings = this.getComputedSettings({ ...this.outputSettings, ...inputSettings });
+      return { ...this.outputSettings, ...inputSettings, ...computedSettings };
+    }
+    getDefaultSettings() {
+      return {
+        forceSinglePageMode: false,
+        pageTurnAnimation: `none`,
+        //   computedPageTurnAnimation: `none`,
+        pageTurnDirection: `horizontal`,
+        //   computedPageTurnDirection: `horizontal`,
+        pageTurnAnimationDuration: void 0,
+        //   computedPageTurnAnimationDuration: 0,
+        pageTurnMode: `controlled`,
+        //   computedPageTurnMode: `controlled`,
+        snapAnimationDuration: 300,
+        navigationSnapThreshold: 0.3,
+        numberOfAdjacentSpineItemToPreLoad: 0
+      };
     }
-    setSettings(settings) {
-      if (Object.keys(settings).length === 0) return;
-      const newMergedSettings = { ...this._settingsSubject$.value, ...settings };
-      this._updateSettings(newMergedSettings);
+    update(settings) {
+      const { commit } = this._prepareUpdate(settings);
+      commit();
     }
     get settings() {
-      return this._settingsSubject$.getValue();
+      return this.outputSettings;
     }
     destroy() {
-      this._settingsSubject$.complete();
+      this.outputSettingsUpdateSubject.complete();
     }
   }
+  _context = new WeakMap();
   class HookManager {
     constructor() {
       this._hooks = [];
@@ -5678,7 +5756,7 @@
     const viewportStateSubject = new rxjs.BehaviorSubject(`free`);
     const hookManager = new HookManager();
     const context = new Context();
-    const settingsManager = new SettingsManager(inputSettings, context);
+    const settingsManager = new ReaderSettingsManager(inputSettings, context);
     const spineItemManager = createSpineItemManager({ context, settings: settingsManager });
     const pagination = createPagination({ context, spineItemManager });
     const elementSubject$ = new rxjs.BehaviorSubject(void 0);