@mnaoumov/obsidian-lib 10.11.0 → 11.0.0

package/dist/lib/esm/data-handler.d.mts

@@ -3,8 +3,43 @@
  * @file
  *
  * A module for handling data loading and saving to the plugin's data file.
+ *
+ * {@link PluginDataHandler} bounds the plugin's `data.json` in bytes, in both directions, because Obsidian does
+ * not. Read from Obsidian `1.15.1`: `Plugin.loadData` reads the whole file and `JSON.parse`s it with no limit, so an
+ * oversized file is fully read and parsed into memory on every startup, and `Plugin.saveData` writes
+ * `JSON.stringify(data, undefined, 2)` with no limit either. Obsidian also swallows a failed read or write: its
+ * `readJson` logs a parse failure and resolves `undefined`, and its `writeJson` catches every error. So the guard
+ * has to decide BEFORE handing the call to Obsidian, which is the only point where refusing still changes the
+ * outcome.
+ *
+ * The same `readJson` makes a `data.json` that EXISTS but does not parse indistinguishable from no file at all: both
+ * resolve `undefined`. A settings component reading that as "nothing stored" saves its defaults over the file, and
+ * the user's settings are gone. So when Obsidian answers `undefined` or `null`, {@link PluginDataHandler.loadData}
+ * reads the file raw and parses it itself; a file that does not parse is copied into the device-local
+ * {@link SettingsRecoveryStore} and reported as a {@link PluginDataParseError}, never as missing.
  */
 import type { Plugin } from 'obsidian';
+import type { SettingsRecoveryCopy, SettingsRecoveryStore } from './settings-recovery.mjs';
+/**
+ * The default maximum size of a plugin's `data.json`, in bytes: 16 MiB.
+ *
+ * This is a protective budget against startup exhaustion, not a sync quota. Obsidian Sync's own per-file limit
+ * depends on the plan and is a separate constraint a plugin may want to stay well under.
+ */
+export declare const DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES = 16777216;
+/**
+ * The operation a {@link PluginDataSizeLimitExceededError} refused.
+ */
+export declare enum PluginDataOperation {
+    /**
+     * Loading the existing `data.json`.
+     */
+    Load = "load",
+    /**
+     * Saving a new `data.json`.
+     */
+    Save = "save"
+}
 /**
  * A handler for loading and saving data to the plugin's data file.
  */
@@ -15,6 +50,12 @@ export interface DataHandler {
      * @returns The loaded data.
      */
     readonly loadData: () => Promise<unknown>;
+    /**
+     * Where a copy of the data file is kept before anything could lose what it held, or `null` (or absent) when the
+     * handler keeps none. A settings component keeps a copy here before a first save that would drop or change a
+     * stored value, and skips that save when the copy cannot be kept.
+     */
+    readonly recoveryStore?: null | SettingsRecoveryStore;
     /**
      * A function to save data to the plugin's data file.
      *
@@ -23,27 +64,203 @@ export interface DataHandler {
     readonly saveData: (data: unknown) => Promise<void>;
 }
 /**
- * A handler for loading and saving data to the plugin's data file.
+ * Options for {@link PluginDataHandler}.
+ */
+export interface PluginDataHandlerConstructorOptions {
+    /**
+     * The maximum size of `data.json`, in UTF-8 bytes as written to disk. Defaults to
+     * {@link DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES}. Pass `Infinity` to disable the guard.
+     */
+    readonly maxSizeInBytes?: number;
+    /**
+     * Where recovery copies of `data.json` are kept. Defaults to a device-local {@link LocalSettingsRecoveryStore}
+     * for the plugin. Pass `null` to keep none: an unparseable file is then still reported and never overwritten, so a
+     * settings component built on this handler fails its load rather than run on defaults, and a first save that drops
+     * or changes a stored value is written with no copy kept, as before recovery copies existed.
+     */
+    readonly recoveryStore?: null | SettingsRecoveryStore;
+}
+/**
+ * Parameters for {@link PluginDataParseError}.
+ */
+export interface PluginDataParseErrorConstructorParams {
+    /**
+     * The error `JSON.parse` threw.
+     */
+    readonly cause: unknown;
+    /**
+     * The path of the plugin's `data.json`.
+     */
+    readonly path: string;
+    /**
+     * The `manifest.id` of the plugin.
+     */
+    readonly pluginId: string;
+    /**
+     * The `manifest.name` of the plugin.
+     */
+    readonly pluginName: string;
+    /**
+     * The recovery copy kept of the file, or `null` when none could be kept.
+     */
+    readonly recoveryCopy: null | SettingsRecoveryCopy;
+}
+/**
+ * Parameters for {@link PluginDataSizeLimitExceededError}.
+ */
+export interface PluginDataSizeLimitExceededErrorConstructorParams {
+    /**
+     * The size limit, in bytes.
+     */
+    readonly maxSizeInBytes: number;
+    /**
+     * The refused operation.
+     */
+    readonly operation: PluginDataOperation;
+    /**
+     * The path of the plugin's `data.json`.
+     */
+    readonly path: string;
+    /**
+     * The `manifest.id` of the plugin.
+     */
+    readonly pluginId: string;
+    /**
+     * The `manifest.name` of the plugin.
+     */
+    readonly pluginName: string;
+    /**
+     * The size of the existing file (load) or of the serialized data (save), in bytes.
+     */
+    readonly sizeInBytes: number;
+}
+/**
+ * A handler for loading and saving data to the plugin's data file, refusing a `data.json` larger than a byte limit.
  */
 export declare class PluginDataHandler implements DataHandler {
     protected readonly plugin: Plugin;
+    /**
+     * Where recovery copies of `data.json` are kept, or `null` when none are.
+     */
+    readonly recoveryStore: null | SettingsRecoveryStore;
+    /**
+     * The maximum size of `data.json`, in bytes.
+     */
+    protected readonly maxSizeInBytes: number;
     /**
      * Creates a new plugin data handler.
      *
      * @param plugin - The plugin instance.
+     * @param options - The options.
      */
-    constructor(plugin: Plugin);
+    constructor(plugin: Plugin, options?: PluginDataHandlerConstructorOptions);
     /**
      * Loads data from the plugin's data file.
      *
+     * The file's size is read through the adapter BEFORE Obsidian reads and parses it, so an oversized file is never
+     * loaded into memory. When Obsidian answers `undefined` or `null`, the file is read raw and parsed here, because
+     * Obsidian answers `undefined` for a file that exists but does not parse too.
+     *
      * @returns The loaded data.
+     * @throws {@link PluginDataSizeLimitExceededError} If the existing file is larger than the limit.
+     * @throws {@link PluginDataParseError} If the existing file is not valid JSON. The file is left untouched, and a
+     * recovery copy of it is kept first when the handler has a recovery store.
      */
     loadData(): Promise<unknown>;
     /**
      * Saves data to the plugin's data file.
      *
+     * The data is serialized exactly as Obsidian writes it, and its UTF-8 byte length is checked before anything is
+     * written.
+     *
      * @param data - The data to save.
      * @returns A promise that resolves when the data is saved.
+     * @throws {@link PluginDataSizeLimitExceededError} If the serialized data is larger than the limit.
      */
     saveData(data: unknown): Promise<void>;
+    /**
+     * Gets the path of the plugin's `data.json`, as Obsidian's `Plugin.loadData` reads it.
+     *
+     * @returns The path, or `null` when the manifest has no folder.
+     */
+    protected getDataFilePath(): null | string;
+    /**
+     * Tells the user that `data.json` could not be parsed: a notice naming the plugin and the path, and the error in the
+     * console.
+     *
+     * @param error - The parse error.
+     */
+    protected reportParseError(error: PluginDataParseError): void;
+    private createError;
+    private getExistingFileSize;
+    private keepRecoveryCopy;
+    private readRawFile;
+}
+/**
+ * Thrown when a plugin's `data.json` exists but is not valid JSON.
+ *
+ * The file is never touched when this is thrown. When {@link recoveryCopy} is not `null`, a copy of the file's raw text
+ * was kept on this device first, so even a later save over the file loses nothing.
+ */
+export declare class PluginDataParseError extends Error {
+    /**
+     * The path of the plugin's `data.json`.
+     */
+    readonly path: string;
+    /**
+     * The `manifest.id` of the plugin.
+     */
+    readonly pluginId: string;
+    /**
+     * The `manifest.name` of the plugin.
+     */
+    readonly pluginName: string;
+    /**
+     * The recovery copy kept of the file, or `null` when none could be kept.
+     */
+    readonly recoveryCopy: null | SettingsRecoveryCopy;
+    /**
+     * Creates a {@link PluginDataParseError}.
+     *
+     * @param params - The parameters for the error.
+     */
+    constructor(params: PluginDataParseErrorConstructorParams);
+}
+/**
+ * Thrown when a plugin's `data.json` is, or would become, larger than the configured limit.
+ *
+ * The file on disk is never touched when this is thrown: an oversized existing file is left intact for the user to
+ * inspect or trim, and an oversized save is refused before anything is written, so the last good file remains.
+ */
+export declare class PluginDataSizeLimitExceededError extends Error {
+    /**
+     * The size limit, in bytes.
+     */
+    readonly maxSizeInBytes: number;
+    /**
+     * The refused operation.
+     */
+    readonly operation: PluginDataOperation;
+    /**
+     * The path of the plugin's `data.json`.
+     */
+    readonly path: string;
+    /**
+     * The `manifest.id` of the plugin.
+     */
+    readonly pluginId: string;
+    /**
+     * The `manifest.name` of the plugin.
+     */
+    readonly pluginName: string;
+    /**
+     * The size of the existing file (load) or of the serialized data (save), in bytes.
+     */
+    readonly sizeInBytes: number;
+    /**
+     * Creates a {@link PluginDataSizeLimitExceededError}.
+     *
+     * @param params - The parameters for the error.
+     */
+    constructor(params: PluginDataSizeLimitExceededErrorConstructorParams);
 }

package/dist/lib/esm/data-handler.mjs

@@ -2,36 +2,293 @@
 THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
 if you want to view the source, please visit the github repository of this plugin
 */
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
 
+ensureBrowserProcess();
+})();
+
+import { normalizePath } from "obsidian";
+import { PluginNoticeComponent } from "./components/plugin-notice-component.mjs";
+import { t } from "./i18n/i18n.mjs";
+import {
+  LocalSettingsRecoveryStore,
+  SettingsRecoveryReason
+} from "./settings-recovery.mjs";
+const OBSIDIAN_JSON_INDENT = 2;
+const DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES = 16777216;
+var PluginDataOperation = /* @__PURE__ */ ((PluginDataOperation2) => {
+  PluginDataOperation2["Load"] = "load";
+  PluginDataOperation2["Save"] = "save";
+  return PluginDataOperation2;
+})(PluginDataOperation || {});
 class PluginDataHandler {
   /**
    * Creates a new plugin data handler.
    *
    * @param plugin - The plugin instance.
+   * @param options - The options.
    */
-  constructor(plugin) {
+  constructor(plugin, options = {}) {
     this.plugin = plugin;
+    const maxSizeInBytes = options.maxSizeInBytes ?? DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES;
+    if (Number.isNaN(maxSizeInBytes) || maxSizeInBytes < 0) {
+      throw new RangeError(`maxSizeInBytes must be a non-negative number, got ${String(maxSizeInBytes)}.`);
+    }
+    this.maxSizeInBytes = maxSizeInBytes;
+    this.recoveryStore = options.recoveryStore === void 0 ? new LocalSettingsRecoveryStore({ app: plugin.app, pluginId: plugin.manifest.id }) : options.recoveryStore;
   }
   plugin;
+  /**
+   * Where recovery copies of `data.json` are kept, or `null` when none are.
+   */
+  recoveryStore;
+  /**
+   * The maximum size of `data.json`, in bytes.
+   */
+  maxSizeInBytes;
   /**
    * Loads data from the plugin's data file.
    *
+   * The file's size is read through the adapter BEFORE Obsidian reads and parses it, so an oversized file is never
+   * loaded into memory. When Obsidian answers `undefined` or `null`, the file is read raw and parsed here, because
+   * Obsidian answers `undefined` for a file that exists but does not parse too.
+   *
    * @returns The loaded data.
+   * @throws {@link PluginDataSizeLimitExceededError} If the existing file is larger than the limit.
+   * @throws {@link PluginDataParseError} If the existing file is not valid JSON. The file is left untouched, and a
+   * recovery copy of it is kept first when the handler has a recovery store.
    */
   async loadData() {
-    return this.plugin.loadData();
+    const sizeInBytes = await this.getExistingFileSize();
+    if (sizeInBytes !== null && sizeInBytes > this.maxSizeInBytes) {
+      throw this.createError("load" /* Load */, sizeInBytes);
+    }
+    const data = await this.plugin.loadData();
+    if (data !== void 0 && data !== null) {
+      return data;
+    }
+    const path = this.getDataFilePath();
+    if (path === null) {
+      return data;
+    }
+    const rawText = await this.readRawFile(path);
+    if (rawText === null) {
+      return data;
+    }
+    try {
+      const parsed = JSON.parse(rawText);
+      return parsed;
+    } catch (parseError) {
+      const error = new PluginDataParseError({
+        cause: parseError,
+        path,
+        pluginId: this.plugin.manifest.id,
+        pluginName: this.plugin.manifest.name,
+        recoveryCopy: await this.keepRecoveryCopy(path, rawText)
+      });
+      this.reportParseError(error);
+      throw error;
+    }
   }
   /**
    * Saves data to the plugin's data file.
    *
+   * The data is serialized exactly as Obsidian writes it, and its UTF-8 byte length is checked before anything is
+   * written.
+   *
    * @param data - The data to save.
    * @returns A promise that resolves when the data is saved.
+   * @throws {@link PluginDataSizeLimitExceededError} If the serialized data is larger than the limit.
    */
   async saveData(data) {
-    return this.plugin.saveData(data);
+    if (this.maxSizeInBytes !== Infinity) {
+      const serialized = JSON.stringify(data, void 0, OBSIDIAN_JSON_INDENT);
+      if (serialized !== void 0) {
+        const sizeInBytes = new TextEncoder().encode(serialized).byteLength;
+        if (sizeInBytes > this.maxSizeInBytes) {
+          throw this.createError("save" /* Save */, sizeInBytes);
+        }
+      }
+    }
+    await this.plugin.saveData(data);
+  }
+  /**
+   * Gets the path of the plugin's `data.json`, as Obsidian's `Plugin.loadData` reads it.
+   *
+   * @returns The path, or `null` when the manifest has no folder.
+   */
+  getDataFilePath() {
+    const directory = this.plugin.manifest.dir;
+    return directory ? normalizePath(`${directory}/data.json`) : null;
+  }
+  /**
+   * Tells the user that `data.json` could not be parsed: a notice naming the plugin and the path, and the error in the
+   * console.
+   *
+   * @param error - The parse error.
+   */
+  reportParseError(error) {
+    console.error(error);
+    new PluginNoticeComponent({
+      app: this.plugin.app,
+      pluginName: this.plugin.manifest.name
+    }).showNotice(
+      error.recoveryCopy === null ? t(($) => $.obsidianLib.notices.dataFileUnparseable, { path: error.path }) : t(($) => $.obsidianLib.notices.dataFileUnparseableCopyKept, { path: error.path })
+    );
+  }
+  createError(operation, sizeInBytes) {
+    return new PluginDataSizeLimitExceededError({
+      maxSizeInBytes: this.maxSizeInBytes,
+      operation,
+      path: this.getDataFilePath() ?? "data.json",
+      pluginId: this.plugin.manifest.id,
+      pluginName: this.plugin.manifest.name,
+      sizeInBytes
+    });
+  }
+  async getExistingFileSize() {
+    if (this.maxSizeInBytes === Infinity) {
+      return null;
+    }
+    const path = this.getDataFilePath();
+    if (path === null) {
+      return null;
+    }
+    try {
+      const stat = await this.plugin.app.vault.adapter.stat(path);
+      return stat?.size ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async keepRecoveryCopy(path, rawText) {
+    if (this.recoveryStore === null) {
+      return null;
+    }
+    try {
+      return await this.recoveryStore.keep({ path, rawText, reason: SettingsRecoveryReason.InvalidJson });
+    } catch (error) {
+      console.error(new Error(`Could not keep a recovery copy of "${path}"`, { cause: error }));
+      return null;
+    }
+  }
+  async readRawFile(path) {
+    const adapter = this.plugin.app.vault.adapter;
+    try {
+      return await adapter.exists(path) ? await adapter.read(path) : null;
+    } catch {
+      return null;
+    }
+  }
+}
+class PluginDataParseError extends Error {
+  /**
+   * The path of the plugin's `data.json`.
+   */
+  path;
+  /**
+   * The `manifest.id` of the plugin.
+   */
+  pluginId;
+  /**
+   * The `manifest.name` of the plugin.
+   */
+  pluginName;
+  /**
+   * The recovery copy kept of the file, or `null` when none could be kept.
+   */
+  recoveryCopy;
+  /**
+   * Creates a {@link PluginDataParseError}.
+   *
+   * @param params - The parameters for the error.
+   */
+  constructor(params) {
+    const copy = params.recoveryCopy === null ? "No recovery copy could be kept." : `A recovery copy was kept on this device as "${params.recoveryCopy.id}".`;
+    super(
+      `Plugin "${params.pluginName}" (${params.pluginId}): "${params.path}" is not valid JSON, so it could not be loaded. The file was left untouched. ${copy}`,
+      { cause: params.cause }
+    );
+    this.name = "PluginDataParseError";
+    this.path = params.path;
+    this.pluginId = params.pluginId;
+    this.pluginName = params.pluginName;
+    this.recoveryCopy = params.recoveryCopy;
+  }
+}
+class PluginDataSizeLimitExceededError extends Error {
+  /**
+   * The size limit, in bytes.
+   */
+  maxSizeInBytes;
+  /**
+   * The refused operation.
+   */
+  operation;
+  /**
+   * The path of the plugin's `data.json`.
+   */
+  path;
+  /**
+   * The `manifest.id` of the plugin.
+   */
+  pluginId;
+  /**
+   * The `manifest.name` of the plugin.
+   */
+  pluginName;
+  /**
+   * The size of the existing file (load) or of the serialized data (save), in bytes.
+   */
+  sizeInBytes;
+  /**
+   * Creates a {@link PluginDataSizeLimitExceededError}.
+   *
+   * @param params - The parameters for the error.
+   */
+  constructor(params) {
+    const what = params.operation === "load" /* Load */ ? `Refusing to load "${params.path}": the file is ${String(params.sizeInBytes)} bytes` : `Refusing to save "${params.path}": the data would be ${String(params.sizeInBytes)} bytes`;
+    const consequence = params.operation === "load" /* Load */ ? "The file was left untouched." : "Nothing was written, so the last saved file remains.";
+    super(
+      `Plugin "${params.pluginName}" (${params.pluginId}): ${what}, over the ${String(params.maxSizeInBytes)}-byte limit. ${consequence} Keep data.json for small settings, and move large or growing state to LocalDataStore or SharedDataStore.`
+    );
+    this.name = "PluginDataSizeLimitExceededError";
+    this.maxSizeInBytes = params.maxSizeInBytes;
+    this.operation = params.operation;
+    this.path = params.path;
+    this.pluginId = params.pluginId;
+    this.pluginName = params.pluginName;
+    this.sizeInBytes = params.sizeInBytes;
   }
 }
 export {
-  PluginDataHandler
+  DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES,
+  PluginDataHandler,
+  PluginDataOperation,
+  PluginDataParseError,
+  PluginDataSizeLimitExceededError
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2RhdGEtaGFuZGxlci50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEEgbW9kdWxlIGZvciBoYW5kbGluZyBkYXRhIGxvYWRpbmcgYW5kIHNhdmluZyB0byB0aGUgcGx1Z2luJ3MgZGF0YSBmaWxlLlxuICovXG5cbmltcG9ydCB0eXBlIHsgUGx1Z2luIH0gZnJvbSAnb2JzaWRpYW4nO1xuXG4vKipcbiAqIEEgaGFuZGxlciBmb3IgbG9hZGluZyBhbmQgc2F2aW5nIGRhdGEgdG8gdGhlIHBsdWdpbidzIGRhdGEgZmlsZS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBEYXRhSGFuZGxlciB7XG4gIC8qKlxuICAgKiBBIGZ1bmN0aW9uIHRvIGxvYWQgZGF0YSBmcm9tIHRoZSBwbHVnaW4ncyBkYXRhIGZpbGUuXG4gICAqXG4gICAqIEByZXR1cm5zIFRoZSBsb2FkZWQgZGF0YS5cbiAgICovXG4gIHJlYWRvbmx5IGxvYWREYXRhOiAoKSA9PiBQcm9taXNlPHVua25vd24+O1xuXG4gIC8qKlxuICAgKiBBIGZ1bmN0aW9uIHRvIHNhdmUgZGF0YSB0byB0aGUgcGx1Z2luJ3MgZGF0YSBmaWxlLlxuICAgKlxuICAgKiBAcGFyYW0gZGF0YSAtIFRoZSBkYXRhIHRvIHNhdmUuXG4gICAqL1xuICByZWFkb25seSBzYXZlRGF0YTogKGRhdGE6IHVua25vd24pID0+IFByb21pc2U8dm9pZD47XG59XG5cbi8qKlxuICogQSBoYW5kbGVyIGZvciBsb2FkaW5nIGFuZCBzYXZpbmcgZGF0YSB0byB0aGUgcGx1Z2luJ3MgZGF0YSBmaWxlLlxuICovXG5leHBvcnQgY2xhc3MgUGx1Z2luRGF0YUhhbmRsZXIgaW1wbGVtZW50cyBEYXRhSGFuZGxlciB7XG4gIC8qKlxuICAgKiBDcmVhdGVzIGEgbmV3IHBsdWdpbiBkYXRhIGhhbmRsZXIuXG4gICAqXG4gICAqIEBwYXJhbSBwbHVnaW4gLSBUaGUgcGx1Z2luIGluc3RhbmNlLlxuICAgKi9cbiAgcHVibGljIGNvbnN0cnVjdG9yKHByb3RlY3RlZCByZWFkb25seSBwbHVnaW46IFBsdWdpbikge31cblxuICAvKipcbiAgICogTG9hZHMgZGF0YSBmcm9tIHRoZSBwbHVnaW4ncyBkYXRhIGZpbGUuXG4gICAqXG4gICAqIEByZXR1cm5zIFRoZSBsb2FkZWQgZGF0YS5cbiAgICovXG4gIHB1YmxpYyBhc3luYyBsb2FkRGF0YSgpOiBQcm9taXNlPHVua25vd24+IHtcbiAgICByZXR1cm4gdGhpcy5wbHVnaW4ubG9hZERhdGEoKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBTYXZlcyBkYXRhIHRvIHRoZSBwbHVnaW4ncyBkYXRhIGZpbGUuXG4gICAqXG4gICAqIEBwYXJhbSBkYXRhIC0gVGhlIGRhdGEgdG8gc2F2ZS5cbiAgICogQHJldHVybnMgQSBwcm9taXNlIHRoYXQgcmVzb2x2ZXMgd2hlbiB0aGUgZGF0YSBpcyBzYXZlZC5cbiAgICovXG4gIHB1YmxpYyBhc3luYyBzYXZlRGF0YShkYXRhOiB1bmtub3duKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgcmV0dXJuIHRoaXMucGx1Z2luLnNhdmVEYXRhKGRhdGEpO1xuICB9XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7OztBQThCTyxNQUFNLGtCQUF5QztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQU03QyxZQUErQixRQUFnQjtBQUFoQjtBQUFBLEVBQWlCO0FBQUEsRUFBakI7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFPdEMsTUFBYSxXQUE2QjtBQUN4QyxXQUFPLEtBQUssT0FBTyxTQUFTO0FBQUEsRUFDOUI7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQVFBLE1BQWEsU0FBUyxNQUE4QjtBQUNsRCxXQUFPLEtBQUssT0FBTyxTQUFTLElBQUk7QUFBQSxFQUNsQztBQUNGOyIsCiAgIm5hbWVzIjogW10KfQo=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/data-handler.ts"],"sourcesContent":["/**\n * @file\n *\n * A module for handling data loading and saving to the plugin's data file.\n *\n * {@link PluginDataHandler} bounds the plugin's `data.json` in bytes, in both directions, because Obsidian does\n * not. Read from Obsidian `1.15.1`: `Plugin.loadData` reads the whole file and `JSON.parse`s it with no limit, so an\n * oversized file is fully read and parsed into memory on every startup, and `Plugin.saveData` writes\n * `JSON.stringify(data, undefined, 2)` with no limit either. Obsidian also swallows a failed read or write: its\n * `readJson` logs a parse failure and resolves `undefined`, and its `writeJson` catches every error. So the guard\n * has to decide BEFORE handing the call to Obsidian, which is the only point where refusing still changes the\n * outcome.\n *\n * The same `readJson` makes a `data.json` that EXISTS but does not parse indistinguishable from no file at all: both\n * resolve `undefined`. A settings component reading that as \"nothing stored\" saves its defaults over the file, and\n * the user's settings are gone. So when Obsidian answers `undefined` or `null`, {@link PluginDataHandler.loadData}\n * reads the file raw and parses it itself; a file that does not parse is copied into the device-local\n * {@link SettingsRecoveryStore} and reported as a {@link PluginDataParseError}, never as missing.\n */\n\nimport type { Plugin } from 'obsidian';\n\nimport { normalizePath } from 'obsidian';\n\nimport type {\n  SettingsRecoveryCopy,\n  SettingsRecoveryStore\n} from './settings-recovery.ts';\n\nimport { PluginNoticeComponent } from './components/plugin-notice-component.ts';\nimport { t } from './i18n/i18n.ts';\nimport {\n  LocalSettingsRecoveryStore,\n  SettingsRecoveryReason\n} from './settings-recovery.ts';\n\n/**\n * The indentation Obsidian's `Vault.writeJson` passes to `JSON.stringify` for `data.json` (read from `1.15.1`).\n */\nconst OBSIDIAN_JSON_INDENT = 2;\n\n/**\n * The default maximum size of a plugin's `data.json`, in bytes: 16 MiB.\n *\n * This is a protective budget against startup exhaustion, not a sync quota. Obsidian Sync's own per-file limit\n * depends on the plan and is a separate constraint a plugin may want to stay well under.\n */\nexport const DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES = 16_777_216;\n\n/**\n * The operation a {@link PluginDataSizeLimitExceededError} refused.\n */\nexport enum PluginDataOperation {\n  /**\n   * Loading the existing `data.json`.\n   */\n  Load = 'load',\n\n  /**\n   * Saving a new `data.json`.\n   */\n  Save = 'save'\n}\n\n/**\n * A handler for loading and saving data to the plugin's data file.\n */\nexport interface DataHandler {\n  /**\n   * A function to load data from the plugin's data file.\n   *\n   * @returns The loaded data.\n   */\n  readonly loadData: () => Promise<unknown>;\n\n  /**\n   * Where a copy of the data file is kept before anything could lose what it held, or `null` (or absent) when the\n   * handler keeps none. A settings component keeps a copy here before a first save that would drop or change a\n   * stored value, and skips that save when the copy cannot be kept.\n   */\n  readonly recoveryStore?: null | SettingsRecoveryStore;\n\n  /**\n   * A function to save data to the plugin's data file.\n   *\n   * @param data - The data to save.\n   */\n  readonly saveData: (data: unknown) => Promise<void>;\n}\n\n/**\n * Options for {@link PluginDataHandler}.\n */\nexport interface PluginDataHandlerConstructorOptions {\n  /**\n   * The maximum size of `data.json`, in UTF-8 bytes as written to disk. Defaults to\n   * {@link DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES}. Pass `Infinity` to disable the guard.\n   */\n  readonly maxSizeInBytes?: number;\n\n  /**\n   * Where recovery copies of `data.json` are kept. Defaults to a device-local {@link LocalSettingsRecoveryStore}\n   * for the plugin. Pass `null` to keep none: an unparseable file is then still reported and never overwritten, so a\n   * settings component built on this handler fails its load rather than run on defaults, and a first save that drops\n   * or changes a stored value is written with no copy kept, as before recovery copies existed.\n   */\n  readonly recoveryStore?: null | SettingsRecoveryStore;\n}\n\n/**\n * Parameters for {@link PluginDataParseError}.\n */\nexport interface PluginDataParseErrorConstructorParams {\n  /**\n   * The error `JSON.parse` threw.\n   */\n  readonly cause: unknown;\n\n  /**\n   * The path of the plugin's `data.json`.\n   */\n  readonly path: string;\n\n  /**\n   * The `manifest.id` of the plugin.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The `manifest.name` of the plugin.\n   */\n  readonly pluginName: string;\n\n  /**\n   * The recovery copy kept of the file, or `null` when none could be kept.\n   */\n  readonly recoveryCopy: null | SettingsRecoveryCopy;\n}\n\n/**\n * Parameters for {@link PluginDataSizeLimitExceededError}.\n */\nexport interface PluginDataSizeLimitExceededErrorConstructorParams {\n  /**\n   * The size limit, in bytes.\n   */\n  readonly maxSizeInBytes: number;\n\n  /**\n   * The refused operation.\n   */\n  readonly operation: PluginDataOperation;\n\n  /**\n   * The path of the plugin's `data.json`.\n   */\n  readonly path: string;\n\n  /**\n   * The `manifest.id` of the plugin.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The `manifest.name` of the plugin.\n   */\n  readonly pluginName: string;\n\n  /**\n   * The size of the existing file (load) or of the serialized data (save), in bytes.\n   */\n  readonly sizeInBytes: number;\n}\n\n/**\n * A handler for loading and saving data to the plugin's data file, refusing a `data.json` larger than a byte limit.\n */\nexport class PluginDataHandler implements DataHandler {\n  /**\n   * Where recovery copies of `data.json` are kept, or `null` when none are.\n   */\n  public readonly recoveryStore: null | SettingsRecoveryStore;\n\n  /**\n   * The maximum size of `data.json`, in bytes.\n   */\n  protected readonly maxSizeInBytes: number;\n\n  /**\n   * Creates a new plugin data handler.\n   *\n   * @param plugin - The plugin instance.\n   * @param options - The options.\n   */\n  public constructor(protected readonly plugin: Plugin, options: PluginDataHandlerConstructorOptions = {}) {\n    const maxSizeInBytes = options.maxSizeInBytes ?? DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES;\n    if (Number.isNaN(maxSizeInBytes) || maxSizeInBytes < 0) {\n      throw new RangeError(`maxSizeInBytes must be a non-negative number, got ${String(maxSizeInBytes)}.`);\n    }\n    this.maxSizeInBytes = maxSizeInBytes;\n    this.recoveryStore = options.recoveryStore === undefined\n      ? new LocalSettingsRecoveryStore({ app: plugin.app, pluginId: plugin.manifest.id })\n      : options.recoveryStore;\n  }\n\n  /**\n   * Loads data from the plugin's data file.\n   *\n   * The file's size is read through the adapter BEFORE Obsidian reads and parses it, so an oversized file is never\n   * loaded into memory. When Obsidian answers `undefined` or `null`, the file is read raw and parsed here, because\n   * Obsidian answers `undefined` for a file that exists but does not parse too.\n   *\n   * @returns The loaded data.\n   * @throws {@link PluginDataSizeLimitExceededError} If the existing file is larger than the limit.\n   * @throws {@link PluginDataParseError} If the existing file is not valid JSON. The file is left untouched, and a\n   * recovery copy of it is kept first when the handler has a recovery store.\n   */\n  public async loadData(): Promise<unknown> {\n    const sizeInBytes = await this.getExistingFileSize();\n    if (sizeInBytes !== null && sizeInBytes > this.maxSizeInBytes) {\n      throw this.createError(PluginDataOperation.Load, sizeInBytes);\n    }\n    const data: unknown = await this.plugin.loadData();\n    if (data !== undefined && data !== null) {\n      return data;\n    }\n\n    const path = this.getDataFilePath();\n    if (path === null) {\n      return data;\n    }\n    const rawText = await this.readRawFile(path);\n    if (rawText === null) {\n      return data;\n    }\n\n    try {\n      const parsed: unknown = JSON.parse(rawText);\n      return parsed;\n    } catch (parseError) {\n      const error = new PluginDataParseError({\n        cause: parseError,\n        path,\n        pluginId: this.plugin.manifest.id,\n        pluginName: this.plugin.manifest.name,\n        recoveryCopy: await this.keepRecoveryCopy(path, rawText)\n      });\n      this.reportParseError(error);\n      throw error;\n    }\n  }\n\n  /**\n   * Saves data to the plugin's data file.\n   *\n   * The data is serialized exactly as Obsidian writes it, and its UTF-8 byte length is checked before anything is\n   * written.\n   *\n   * @param data - The data to save.\n   * @returns A promise that resolves when the data is saved.\n   * @throws {@link PluginDataSizeLimitExceededError} If the serialized data is larger than the limit.\n   */\n  public async saveData(data: unknown): Promise<void> {\n    if (this.maxSizeInBytes !== Infinity) {\n      // Obsidian's `writeJson` would swallow a serialization failure and write nothing; throwing here instead keeps\n      // the disk unchanged too, and tells the caller.\n      const serialized = JSON.stringify(data, undefined, OBSIDIAN_JSON_INDENT);\n      if (serialized !== undefined) {\n        const sizeInBytes = new TextEncoder().encode(serialized).byteLength;\n        if (sizeInBytes > this.maxSizeInBytes) {\n          throw this.createError(PluginDataOperation.Save, sizeInBytes);\n        }\n      }\n    }\n    await this.plugin.saveData(data);\n  }\n\n  /**\n   * Gets the path of the plugin's `data.json`, as Obsidian's `Plugin.loadData` reads it.\n   *\n   * @returns The path, or `null` when the manifest has no folder.\n   */\n  protected getDataFilePath(): null | string {\n    const directory = this.plugin.manifest.dir;\n    return directory ? normalizePath(`${directory}/data.json`) : null;\n  }\n\n  /**\n   * Tells the user that `data.json` could not be parsed: a notice naming the plugin and the path, and the error in the\n   * console.\n   *\n   * @param error - The parse error.\n   */\n  protected reportParseError(error: PluginDataParseError): void {\n    console.error(error);\n    new PluginNoticeComponent({\n      app: this.plugin.app,\n      pluginName: this.plugin.manifest.name\n    }).showNotice(\n      error.recoveryCopy === null\n        ? t(($) => $.obsidianLib.notices.dataFileUnparseable, { path: error.path })\n        : t(($) => $.obsidianLib.notices.dataFileUnparseableCopyKept, { path: error.path })\n    );\n  }\n\n  private createError(operation: PluginDataOperation, sizeInBytes: number): PluginDataSizeLimitExceededError {\n    return new PluginDataSizeLimitExceededError({\n      maxSizeInBytes: this.maxSizeInBytes,\n      operation,\n      path: this.getDataFilePath() ?? 'data.json',\n      pluginId: this.plugin.manifest.id,\n      pluginName: this.plugin.manifest.name,\n      sizeInBytes\n    });\n  }\n\n  private async getExistingFileSize(): Promise<null | number> {\n    if (this.maxSizeInBytes === Infinity) {\n      return null;\n    }\n    const path = this.getDataFilePath();\n    if (path === null) {\n      return null;\n    }\n    try {\n      const stat = await this.plugin.app.vault.adapter.stat(path);\n      return stat?.size ?? null;\n    } catch {\n      // The size is unknown, not oversized: Obsidian's own read decides what happens next, as before this guard.\n      return null;\n    }\n  }\n\n  private async keepRecoveryCopy(path: string, rawText: string): Promise<null | SettingsRecoveryCopy> {\n    if (this.recoveryStore === null) {\n      return null;\n    }\n    try {\n      return await this.recoveryStore.keep({ path, rawText, reason: SettingsRecoveryReason.InvalidJson });\n    } catch (error) {\n      console.error(new Error(`Could not keep a recovery copy of \"${path}\"`, { cause: error }));\n      return null;\n    }\n  }\n\n  private async readRawFile(path: string): Promise<null | string> {\n    const adapter = this.plugin.app.vault.adapter;\n    try {\n      return await adapter.exists(path) ? await adapter.read(path) : null;\n    } catch {\n      // Unreadable is not unparseable: Obsidian's own answer stands, as before this check.\n      return null;\n    }\n  }\n}\n\n/**\n * Thrown when a plugin's `data.json` exists but is not valid JSON.\n *\n * The file is never touched when this is thrown. When {@link recoveryCopy} is not `null`, a copy of the file's raw text\n * was kept on this device first, so even a later save over the file loses nothing.\n */\nexport class PluginDataParseError extends Error {\n  /**\n   * The path of the plugin's `data.json`.\n   */\n  public readonly path: string;\n\n  /**\n   * The `manifest.id` of the plugin.\n   */\n  public readonly pluginId: string;\n\n  /**\n   * The `manifest.name` of the plugin.\n   */\n  public readonly pluginName: string;\n\n  /**\n   * The recovery copy kept of the file, or `null` when none could be kept.\n   */\n  public readonly recoveryCopy: null | SettingsRecoveryCopy;\n\n  /**\n   * Creates a {@link PluginDataParseError}.\n   *\n   * @param params - The parameters for the error.\n   */\n  public constructor(params: PluginDataParseErrorConstructorParams) {\n    const copy = params.recoveryCopy === null\n      ? 'No recovery copy could be kept.'\n      : `A recovery copy was kept on this device as \"${params.recoveryCopy.id}\".`;\n    super(\n      `Plugin \"${params.pluginName}\" (${params.pluginId}): \"${params.path}\" is not valid JSON, so it could not be loaded. The file was left untouched. ${copy}`,\n      { cause: params.cause }\n    );\n    this.name = 'PluginDataParseError';\n    this.path = params.path;\n    this.pluginId = params.pluginId;\n    this.pluginName = params.pluginName;\n    this.recoveryCopy = params.recoveryCopy;\n  }\n}\n\n/**\n * Thrown when a plugin's `data.json` is, or would become, larger than the configured limit.\n *\n * The file on disk is never touched when this is thrown: an oversized existing file is left intact for the user to\n * inspect or trim, and an oversized save is refused before anything is written, so the last good file remains.\n */\nexport class PluginDataSizeLimitExceededError extends Error {\n  /**\n   * The size limit, in bytes.\n   */\n  public readonly maxSizeInBytes: number;\n\n  /**\n   * The refused operation.\n   */\n  public readonly operation: PluginDataOperation;\n\n  /**\n   * The path of the plugin's `data.json`.\n   */\n  public readonly path: string;\n\n  /**\n   * The `manifest.id` of the plugin.\n   */\n  public readonly pluginId: string;\n\n  /**\n   * The `manifest.name` of the plugin.\n   */\n  public readonly pluginName: string;\n\n  /**\n   * The size of the existing file (load) or of the serialized data (save), in bytes.\n   */\n  public readonly sizeInBytes: number;\n\n  /**\n   * Creates a {@link PluginDataSizeLimitExceededError}.\n   *\n   * @param params - The parameters for the error.\n   */\n  public constructor(params: PluginDataSizeLimitExceededErrorConstructorParams) {\n    const what = params.operation === PluginDataOperation.Load\n      ? `Refusing to load \"${params.path}\": the file is ${String(params.sizeInBytes)} bytes`\n      : `Refusing to save \"${params.path}\": the data would be ${String(params.sizeInBytes)} bytes`;\n    const consequence = params.operation === PluginDataOperation.Load\n      ? 'The file was left untouched.'\n      : 'Nothing was written, so the last saved file remains.';\n    super(\n      `Plugin \"${params.pluginName}\" (${params.pluginId}): ${what}, over the ${String(params.maxSizeInBytes)}-byte limit. ${consequence} `\n        + 'Keep data.json for small settings, and move large or growing state to LocalDataStore or SharedDataStore.'\n    );\n    this.name = 'PluginDataSizeLimitExceededError';\n    this.maxSizeInBytes = params.maxSizeInBytes;\n    this.operation = params.operation;\n    this.path = params.path;\n    this.pluginId = params.pluginId;\n    this.pluginName = params.pluginName;\n    this.sizeInBytes = params.sizeInBytes;\n  }\n}\n"],"mappings":"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","names":["PluginDataOperation"]}

package/dist/lib/esm/data-stores/data-store-locations.d.mts

@@ -55,6 +55,21 @@ export declare class DataStoreLocations {
      * @returns A promise that resolves when the new writer is ready.
      */
     relocate(location: DataStoreLocation): Promise<void>;
+    private buildChain;
     private createTransport;
+    /**
+     * Maps the records of an anchor folder that was moved (or sits under a moved folder) onto the folder the store is open
+     * at, because records name absolute folders.
+     *
+     * A transition that names its `anchor` is remapped from that folder exactly, so several successive moves resolve too.
+     * A transition written before that field existed names no anchor, and a moved anchor then looks the same as a chain whose
+     * first record has not arrived yet. So the former folder is inferred only when nothing starts at the initial identity,
+     * exactly one candidate folder (one the legacy records start from, in the initial format) yields a complete chain, and
+     * that folder no longer holds this store. Anything else is left for `buildChain` to reject.
+     *
+     * @param transitions - The transitions recorded at the anchor.
+     * @returns The transitions to build the chain from.
+     */
+    private resolveMovedAnchor;
     private validateLocation;
 }