@mnaoumov/obsidian-lib 10.11.0 → 10.12.0

package/dist/lib/cjs/components/workspace-layout-state-component.d.cts

@@ -0,0 +1,239 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * Keeps a plugin's layout-scoped state in the workspace layout itself, so each saved workspace remembers its own value
+ * and switching workspaces restores it, instead of one global value in `data.json`.
+ *
+ * Read from Obsidian `1.15.1`: `Workspace.getLayout()` builds a fresh object (`main`, `left`, `right`, `left-ribbon`,
+ * `floating`, `active`) and `Workspace.setLayout()` ignores every other top-level key. `deserializeLayout` keeps each
+ * item's `id`, popout leaves included. The Workspaces core plugin saves through `getLayout()` and loads through
+ * `changeLayout()`, which calls `setLayout()`. Startup goes through `loadLayout()`, `readWorkspaceFile()` and
+ * `setLayout()`, after the plugins enabled at startup have loaded. So two patches on the `app.workspace` instance carry
+ * the whole thing: `getLayout` writes the records under {@link WORKSPACE_LAYOUT_STATE_LAYOUT_KEY}, and `setLayout`
+ * replaces them from the layout it is handed before any view is restored. Per-leaf state is keyed by leaf id at the
+ * layout level, so no `WorkspaceItem.serialize` or `deserializeLayout` patch is needed.
+ *
+ * A view the plugin owns needs none of this: `View.getState` / `setState` already ride in each leaf's state. This
+ * component is for the scope those methods cannot represent: the whole layout, and leaves of views the plugin does not
+ * own.
+ *
+ * Every plugin bundles its own copy of this library, so the records, the subscriptions and ONE installation of the
+ * patches live in the shared-state bag under a versioned key, owned by one subscriber. When the owner unloads while
+ * others remain, the next subscriber installs again from its own copy. What crosses that boundary is a wire format
+ * between copies of different versions: plain objects and plain functions only, fields only ever added, and a change of
+ * meaning moves to a new key. The layout record is a wire format too, persisted in `workspace.json` and in every saved
+ * workspace.
+ */
+import type { App, WorkspaceLeaf } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { JsonValue } from 'type-fest' with { 'resolution-mode': 'import' };
+import { ComponentEx } from './component-ex.cjs';
+/**
+ * The top-level key of a serialized layout that holds the records.
+ */
+export declare const WORKSPACE_LAYOUT_STATE_LAYOUT_KEY = "obsidianLibLayoutStateV1";
+/**
+ * A change of one key's value, in one scope.
+ *
+ * @typeParam T - The value type.
+ */
+export interface WorkspaceLayoutStateChange<T> {
+    /**
+     * The leaf whose value changed, or `null` for the workspace scope or a leaf no longer in the layout.
+     */
+    readonly leaf: null | WorkspaceLeaf;
+    /**
+     * The id of the leaf whose value changed, or `null` for the workspace scope.
+     */
+    readonly leafId: null | string;
+    /**
+     * The value before the change, as {@link WorkspaceLayoutStateKey.get} read it.
+     */
+    readonly oldValue: T;
+    /**
+     * The value after the change, as {@link WorkspaceLayoutStateKey.get} reads it.
+     */
+    readonly value: T;
+}
+/**
+ * Parameters for {@link WorkspaceLayoutStateComponent}.
+ */
+export interface WorkspaceLayoutStateComponentConstructorParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The id of the plugin the values belong to. Every value is namespaced by it.
+     */
+    readonly pluginId: string;
+}
+/**
+ * A typed handle to one layout-scoped key.
+ *
+ * Every method takes an optional leaf. Without one, the value belongs to the whole layout (the workspace scope).
+ *
+ * @typeParam T - The value type.
+ */
+export interface WorkspaceLayoutStateKey<T> {
+    /**
+     * Reads the value: a clone of the stored one, or of the default when nothing is stored or the stored value fails the
+     * key's guard.
+     *
+     * @param leaf - The leaf, or nothing for the workspace scope.
+     * @returns The value.
+     */
+    readonly get: (leaf?: WorkspaceLeaf) => T;
+    /**
+     * Checks whether a value is stored, valid or not.
+     *
+     * @param leaf - The leaf, or nothing for the workspace scope.
+     * @returns Whether a value is stored.
+     */
+    readonly has: (leaf?: WorkspaceLeaf) => boolean;
+    /**
+     * The key name, unique within the plugin.
+     */
+    readonly key: string;
+    /**
+     * Subscribes to changes of this key made through `set` or `unset`, in any scope and from any copy of the library. A
+     * layout load is reported through {@link WorkspaceLayoutStateComponent.onLayoutLoad} instead.
+     *
+     * @param callback - Called after each change.
+     * @returns A function that unsubscribes. Unloading the component unsubscribes too.
+     */
+    readonly onChange: (callback: (change: WorkspaceLayoutStateChange<T>) => void) => () => void;
+    /**
+     * Stores a clone of the value and requests a layout save. Storing a value equal to the stored one does nothing.
+     *
+     * @param value - The value. It must be JSON-safe; `null` is stored as `null`.
+     * @param leaf - The leaf, or nothing for the workspace scope.
+     * @throws A `TypeError` if the value is not JSON-safe.
+     */
+    readonly set: (value: T, leaf?: WorkspaceLeaf) => void;
+    /**
+     * Removes the stored value, so `get` reads the default again, and requests a layout save.
+     *
+     * @param leaf - The leaf, or nothing for the workspace scope.
+     */
+    readonly unset: (leaf?: WorkspaceLeaf) => void;
+}
+/**
+ * Defines a layout-scoped key.
+ *
+ * @typeParam T - The value type.
+ */
+export interface WorkspaceLayoutStateKeyDefinition<T> {
+    /**
+     * The value read when nothing valid is stored.
+     */
+    readonly defaultValue: T;
+    /**
+     * Checks a stored value. A value that fails reads as the default and stays stored until it is replaced or unset.
+     *
+     * @default Accepts every JSON value.
+     */
+    readonly isValid?: (value: unknown) => value is T;
+    /**
+     * The key name, unique within the plugin.
+     */
+    readonly key: string;
+}
+/**
+ * One plugin's records. Fields a newer copy adds are preserved.
+ */
+export interface WorkspaceLayoutStatePluginRecord {
+    /**
+     * The values by leaf id, then by key.
+     */
+    readonly leaves: Record<string, JsonRecord>;
+    /**
+     * Fields a newer copy of the library added.
+     */
+    readonly [field: string]: unknown;
+    /**
+     * The workspace-scope values by key.
+     */
+    readonly workspace: JsonRecord;
+}
+/**
+ * The record persisted under {@link WORKSPACE_LAYOUT_STATE_LAYOUT_KEY}. Fields a newer copy adds are preserved.
+ */
+export interface WorkspaceLayoutStateRecord {
+    /**
+     * The records by plugin id.
+     */
+    readonly plugins: Record<string, WorkspaceLayoutStatePluginRecord>;
+    /**
+     * Fields a newer copy of the library added.
+     */
+    readonly [field: string]: unknown;
+}
+type JsonRecord = Record<string, JsonValue>;
+/**
+ * Keeps a plugin's layout-scoped values in the workspace layout, so saved workspaces each restore their own.
+ *
+ * Any number of these, in any number of plugins, share one installation per {@link App}. Values are restored when a
+ * layout loads, which REPLACES every value: write them after {@link Workspace.onLayoutReady}, and re-read them in
+ * {@link onLayoutLoad}.
+ */
+export declare class WorkspaceLayoutStateComponent extends ComponentEx {
+    /**
+     * The Obsidian app instance.
+     */
+    protected readonly app: App;
+    /**
+     * The id of the plugin the values belong to.
+     */
+    protected readonly pluginId: string;
+    private readonly layoutLoadListeners;
+    private readonly recordChangeListeners;
+    /**
+     * Creates a new workspace layout state component.
+     *
+     * @param params - The parameters.
+     * @throws A `TypeError` if the plugin id is empty.
+     */
+    constructor(params: WorkspaceLayoutStateComponentConstructorParams);
+    /**
+     * Defines a typed key.
+     *
+     * @typeParam T - The value type.
+     * @param definition - The key definition.
+     * @returns The key handle.
+     * @throws A `TypeError` if the key is empty or the default value is not JSON-safe.
+     */
+    defineKey<T>(definition: WorkspaceLayoutStateKeyDefinition<T>): WorkspaceLayoutStateKey<T>;
+    /**
+     * Subscribes to layout loads: a saved workspace loaded, the layout restored at startup, or the saved layout read when
+     * the component is first loaded after layout-ready. Every value may have changed.
+     *
+     * @param callback - Called after the layout is loaded, once its leaves exist.
+     * @returns A function that unsubscribes. Unloading the component unsubscribes too.
+     */
+    onLayoutLoad(callback: () => void): () => void;
+    /**
+     * Subscribes to the shared installation, installing it when nobody has yet.
+     */
+    onload(): void;
+    private subscribeToRecordChanges;
+}
+/**
+ * Parses a persisted record. A part that is malformed is dropped one level at a time: a malformed record reads as
+ * empty, a malformed plugin record drops only that plugin, and a malformed leaf bucket drops only that leaf. Fields this
+ * copy does not know are kept.
+ *
+ * @param value - The value found under {@link WORKSPACE_LAYOUT_STATE_LAYOUT_KEY}.
+ * @returns The parsed record, sharing nothing with the input.
+ */
+export declare function parseWorkspaceLayoutStateRecord(value: unknown): WorkspaceLayoutStateRecord;
+/**
+ * Builds the record to persist into a serialized layout: leaf buckets for leaves absent from the layout are left out,
+ * and so are plugins with nothing left.
+ *
+ * @param record - The current record.
+ * @param layout - The serialized layout.
+ * @returns The record to persist, or `null` when there is nothing to persist.
+ */
+export declare function serializeWorkspaceLayoutStateRecord(record: WorkspaceLayoutStateRecord, layout: unknown): null | WorkspaceLayoutStateRecord;
+export {};

package/dist/lib/cjs/css-class.cjs

@@ -92,6 +92,8 @@ __export(css_class_exports, {
 module.exports = __toCommonJS(css_class_exports);
 var CssClass = /* @__PURE__ */ ((CssClass2) => {
   CssClass2["AlertModal"] = "alert-modal";
+  CssClass2["BugReportPreview"] = "bug-report-preview";
+  CssClass2["BugReportReviewModal"] = "bug-report-review-modal";
   CssClass2["CancelButton"] = "cancel-button";
   CssClass2["CheckboxComponent"] = "checkbox-component";
   CssClass2["ClickableIcon"] = "clickable-icon";
@@ -103,6 +105,8 @@ var CssClass = /* @__PURE__ */ ((CssClass2) => {
   CssClass2["CodeBlockBuilderPreview"] = "code-block-builder-preview";
   CssClass2["CodeHighlighterComponent"] = "code-highlighter-component";
   CssClass2["ConfirmModal"] = "confirm-modal";
+  CssClass2["CopyTextManuallyModal"] = "copy-text-manually-modal";
+  CssClass2["CopyTextManuallyText"] = "copy-text-manually-text";
   CssClass2["DateComponent"] = "date-component";
   CssClass2["DateTimeComponent"] = "datetime-component";
   CssClass2["EmailComponent"] = "email-component";
@@ -174,4 +178,4 @@ var CssClass = /* @__PURE__ */ ((CssClass2) => {
 0 && (module.exports = {
   CssClass
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/css-class.ts"],"sourcesContent":["/**\n * @file\n *\n * CSS classes used by the `@mnaoumov/obsidian-lib` library.\n */\n\n/**\n * CSS classes used by the `@mnaoumov/obsidian-lib` library.\n */\nexport enum CssClass {\n  /**\n   * A CSS class for the alert modal.\n   */\n  AlertModal = 'alert-modal',\n\n  /**\n   * A CSS class for the cancel button.\n   */\n  CancelButton = 'cancel-button',\n\n  /**\n   * A CSS class for the checkbox component.\n   */\n  CheckboxComponent = 'checkbox-component',\n\n  /**\n   * Obsidian's class for a clickable icon button, giving it the hover background and icon-color treatment.\n   */\n  ClickableIcon = 'clickable-icon',\n\n  /**\n   * Obsidian's class for an inline code element (used by `appendCodeBlock`).\n   */\n  Code = 'code',\n\n  /**\n   * A CSS class for a collapsible field group of the code block builder modal.\n   */\n  CodeBlockBuilderGroup = 'code-block-builder-group',\n\n  /**\n   * A CSS class for the field container of a collapsible group of the code block builder modal.\n   */\n  CodeBlockBuilderGroupBody = 'code-block-builder-group-body',\n\n  /**\n   * A CSS class for the code block builder modal.\n   */\n  CodeBlockBuilderModal = 'code-block-builder-modal',\n\n  /**\n   * A CSS class for the output row of the code block builder modal.\n   */\n  CodeBlockBuilderOutput = 'code-block-builder-output',\n\n  /**\n   * A CSS class for the live preview container of the code block builder modal.\n   */\n  CodeBlockBuilderPreview = 'code-block-builder-preview',\n\n  /**\n   * A CSS class for the code highlighter component.\n   */\n  CodeHighlighterComponent = 'code-highlighter-component',\n\n  /**\n   * A CSS class for the confirm modal.\n   */\n  ConfirmModal = 'confirm-modal',\n\n  /**\n   * A CSS class for the date component.\n   */\n  DateComponent = 'date-component',\n\n  /**\n   * A CSS class for the date and time component.\n   */\n  DateTimeComponent = 'datetime-component',\n\n  /**\n   * A CSS class for the email component.\n   */\n  EmailComponent = 'email-component',\n\n  /**\n   * A CSS class for the file component.\n   */\n  FileComponent = 'file-component',\n\n  /**\n   * A CSS class for rendered markdown whose headings and lists `registerFoldHandlers` made foldable.\n   */\n  FoldableMarkdown = 'foldable-markdown',\n\n  /**\n   * A CSS class for the folder list component.\n   */\n  FolderListComponent = 'folder-list-component',\n  /**\n   * A CSS class for the hotkey component.\n   */\n  HotkeyComponent = 'hotkey-component',\n\n  /**\n   * A CSS class for the element an inline token renders into, in Reading view and in Live Preview.\n   */\n  InlineToken = 'inline-token',\n\n  /**\n   * Obsidian's class for a control that is currently ON, reused so a pressed command button matches the\n   * app's own toggled controls.\n   */\n  IsActive = 'is-active',\n\n  /**\n   * Obsidian's class for a collapsed element, reused for a collapsed group of the code block builder modal.\n   */\n  IsCollapsed = 'is-collapsed',\n\n  /**\n   * A CSS class for the placeholder.\n   */\n  IsPlaceholder = 'is-placeholder',\n\n  /**\n   * A CSS class for the library name, set on every element the library builds.\n   */\n  LibraryName = 'obsidian-lib',\n\n  /**\n   * A CSS class for the reorderable list component.\n   */\n  ListComponent = 'list-component',\n  /**\n   * Obsidian's class marking rendered-markdown content (used by `appendCodeBlock`).\n   */\n  MarkdownRendered = 'markdown-rendered',\n\n  /**\n   * A CSS class for the minimizable modal.\n   */\n  MinimizableModal = 'minimizable-modal',\n\n  /**\n   * A CSS class for the minimize button of the minimizable modal.\n   */\n  MinimizeButton = 'minimize-button',\n\n  /**\n   * A CSS class for the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBar = 'minimized-modal-bar',\n\n  /**\n   * A CSS class for the one-shot attention flash of the minimized bar, played when the user attempts a\n   * blocked action (a keystroke, right-click, or opening another modal) while the modal is minimized.\n   */\n  MinimizedModalBarAttention = 'minimized-modal-bar-attention',\n\n  /**\n   * A CSS class for the title of the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBarTitle = 'minimized-modal-bar-title',\n\n  /**\n   * A CSS class for one button in a modal's command strip.\n   */\n  ModalCommand = 'modal-command',\n\n  /**\n   * A CSS class for a control injected into an instruction's purpose text — a checkbox, a dropdown.\n   * Obsidian's own instruction bar never contains one, so nothing upstream separates it from the label\n   * it belongs to.\n   */\n  ModalCommandControl = 'modal-command-control',\n\n  /**\n   * A CSS class for the hotkey hint inside a modal command button.\n   */\n  ModalCommandHotkey = 'modal-command-hotkey',\n\n  /**\n   * A CSS class for the strip of commands a modal renders along its bottom edge.\n   */\n  ModalCommands = 'modal-commands',\n\n  /**\n   * Obsidian's class for a modal header button (e.g. the modal close button), reused to match the\n   * native modal close button's box and hover.\n   */\n  ModalHeaderButton = 'modal-header-button',\n\n  /**\n   * A CSS class for the month component.\n   */\n  MonthComponent = 'month-component',\n\n  /**\n   * A CSS class for the multiple dropdown component.\n   */\n  MultipleDropdownComponent = 'multiple-dropdown-component',\n\n  /**\n   * A CSS class for the multiple email component.\n   */\n  MultipleEmailComponent = 'multiple-email-component',\n\n  /**\n   * A CSS class for the multiple file component.\n   */\n  MultipleFileComponent = 'multiple-file-component',\n\n  /**\n   * A CSS class for the multiple text component.\n   */\n  MultipleTextComponent = 'multiple-text-component',\n\n  /**\n   * A CSS class for the number component.\n   */\n  NumberComponent = 'number-component',\n\n  /**\n   * A CSS class for the ok button.\n   */\n  OkButton = 'ok-button',\n\n  /**\n   * A CSS class for the overlay validator.\n   */\n  OverlayValidator = 'overlay-validator',\n\n  /**\n   * A CSS class for the password component.\n   */\n  PasswordComponent = 'password-component',\n\n  /**\n   * A CSS class for the banner naming a plugin this one refuses, or warns about, running beside.\n   */\n  PluginConflictBanner = 'plugin-conflict-banner',\n\n  /**\n   * A CSS class for the banner a blocked plugin renders in place of its settings, naming the mandatory\n   * dependency it is waiting for.\n   */\n  PluginDependencyBanner = 'plugin-dependency-banner',\n\n  /**\n   * A CSS class for the close button of a notice that requires close confirmation.\n   */\n  PluginNoticeCloseButton = 'plugin-notice-close-button',\n\n  /**\n   * A CSS class for the container wrapping a notice's content, used to keep the notice open when an\n   * interactive element inside it is clicked.\n   */\n  PluginNoticeContent = 'plugin-notice-content',\n\n  /**\n   * A CSS class for the plugin name shown as the prefix of a notice.\n   */\n  PluginNoticeName = 'plugin-notice-name',\n\n  /**\n   * A CSS class applied to the notice element of a notice that requires an explicit close, used to make\n   * its whole area non-dismissible.\n   */\n  PluginNoticeRequiresExplicitClose = 'plugin-notice-requires-explicit-close',\n\n  /**\n   * A CSS class for the plugin settings tab.\n   */\n  PluginSettingsTab = 'plugin-settings-tab',\n\n  /**\n   * A CSS class for the banner a plugin-suggestion renders into a settings tab.\n   */\n  PluginSuggestionBanner = 'plugin-suggestion-banner',\n\n  /**\n   * A CSS class for the row of buttons in a plugin-suggestion notice, which spaces the action button apart from\n   * the decline button.\n   */\n  PluginSuggestionNoticeButtons = 'plugin-suggestion-notice-buttons',\n\n  /**\n   * A CSS class for the popover.\n   */\n  Popover = 'popover',\n\n  /**\n   * Obsidian's class for one row of its modal instruction bar, reused so a self-created bar inherits the\n   * app's own instruction styling.\n   */\n  PromptInstruction = 'prompt-instruction',\n\n  /**\n   * Obsidian's class for the key-hint half of one instruction row. It is the only thing carrying that\n   * hint's bold weight and the `margin-inline-end` that separates it from the purpose text, so a\n   * self-created bar that omits it renders `alt 1Keep the old title` welded together. Reused rather\n   * than re-implemented: the app's rule for it is unscoped, so it reaches a plain `Modal` too, and\n   * sharing the class keeps the self-created bar and `setInstructions` from ever drifting apart.\n   */\n  PromptInstructionCommand = 'prompt-instruction-command',\n\n  /**\n   * Obsidian's class for its modal instruction bar, reused so a self-created bar inherits the app's own\n   * instruction styling.\n   */\n  PromptInstructions = 'prompt-instructions',\n\n  /**\n   * A CSS class for the prompt modal.\n   */\n  PromptModal = 'prompt-modal',\n\n  /**\n   * A CSS class for the restore button of the minimized modal bar.\n   */\n  RestoreButton = 'restore-button',\n\n  /**\n   * A CSS class for the select item modal.\n   */\n  SelectItemModal = 'select-item-modal',\n\n  /**\n   * A CSS class for the select option modal.\n   */\n  SelectOptionModal = 'select-option-modal',\n\n  /**\n   * A CSS class for the setting component wrapper.\n   */\n  SettingComponentWrapper = 'setting-component-wrapper',\n\n  /**\n   * A CSS class for the settings tabs.\n   */\n  SettingsTabs = 'settings-tabs',\n  /**\n   * A CSS class for the tag list component.\n   */\n  TagListComponent = 'tag-list-component',\n  /**\n   * A CSS class for the telephone component.\n   */\n  TelephoneComponent = 'telephone-component',\n\n  /**\n   * A CSS class for the text box.\n   */\n  TextBox = 'text-box',\n\n  /**\n   * A CSS class for the time component.\n   */\n  TimeComponent = 'time-component',\n\n  /**\n   * A CSS class for the tooltip.\n   */\n  Tooltip = 'tooltip',\n\n  /**\n   * A CSS class for the tooltip arrow.\n   */\n  TooltipArrow = 'tooltip-arrow',\n\n  /**\n   * A CSS class for the tooltip validator.\n   */\n  TooltipValidator = 'tooltip-validator',\n\n  /**\n   * A CSS class for the tri-state checkbox component.\n   */\n  TriStateCheckboxComponent = 'tri-state-checkbox-component',\n\n  /**\n   * A CSS class for the typed dropdown component.\n   */\n  TypedDropdownComponent = 'typed-dropdown-component',\n\n  /**\n   * A CSS class for the typed multiple dropdown component.\n   */\n  TypedMultipleDropdownComponent = 'typed-multiple-dropdown-component',\n\n  /**\n   * A CSS class for an input the user has not interacted with yet, used to defer the invalid styling until\n   * the input is touched.\n   */\n  Untouched = 'untouched',\n\n  /**\n   * A CSS class for the url component.\n   */\n  UrlComponent = 'url-component',\n\n  /**\n   * A CSS class for the week component.\n   */\n  WeekComponent = 'week-component'\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AASO,IAAK,WAAL,kBAAKA,cAAL;AAIL,EAAAA,UAAA,gBAAa;AAKb,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,UAAO;AAKP,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,6BAA0B;AAK1B,EAAAA,UAAA,8BAA2B;AAK3B,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,yBAAsB;AAItB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,iBAAc;AAMd,EAAAA,UAAA,cAAW;AAKX,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,mBAAgB;AAIhB,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,uBAAoB;AAMpB,EAAAA,UAAA,gCAA6B;AAK7B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,kBAAe;AAOf,EAAAA,UAAA,yBAAsB;AAKtB,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,mBAAgB;AAMhB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,cAAW;AAKX,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,0BAAuB;AAMvB,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,6BAA0B;AAM1B,EAAAA,UAAA,yBAAsB;AAKtB,EAAAA,UAAA,sBAAmB;AAMnB,EAAAA,UAAA,uCAAoC;AAKpC,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,4BAAyB;AAMzB,EAAAA,UAAA,mCAAgC;AAKhC,EAAAA,UAAA,aAAU;AAMV,EAAAA,UAAA,uBAAoB;AASpB,EAAAA,UAAA,8BAA2B;AAM3B,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,6BAA0B;AAK1B,EAAAA,UAAA,kBAAe;AAIf,EAAAA,UAAA,sBAAmB;AAInB,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,aAAU;AAKV,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,aAAU;AAKV,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,oCAAiC;AAMjC,EAAAA,UAAA,eAAY;AAKZ,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AA5YN,SAAAA;AAAA,GAAA;","names":["CssClass"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/css-class.ts"],"sourcesContent":["/**\n * @file\n *\n * CSS classes used by the `@mnaoumov/obsidian-lib` library.\n */\n\n/**\n * CSS classes used by the `@mnaoumov/obsidian-lib` library.\n */\nexport enum CssClass {\n  /**\n   * A CSS class for the alert modal.\n   */\n  AlertModal = 'alert-modal',\n\n  /**\n   * A CSS class for the preview of the bug-report diagnostics review modal.\n   */\n  BugReportPreview = 'bug-report-preview',\n\n  /**\n   * A CSS class for the bug-report diagnostics review modal.\n   */\n  BugReportReviewModal = 'bug-report-review-modal',\n\n  /**\n   * A CSS class for the cancel button.\n   */\n  CancelButton = 'cancel-button',\n\n  /**\n   * A CSS class for the checkbox component.\n   */\n  CheckboxComponent = 'checkbox-component',\n\n  /**\n   * Obsidian's class for a clickable icon button, giving it the hover background and icon-color treatment.\n   */\n  ClickableIcon = 'clickable-icon',\n\n  /**\n   * Obsidian's class for an inline code element (used by `appendCodeBlock`).\n   */\n  Code = 'code',\n\n  /**\n   * A CSS class for a collapsible field group of the code block builder modal.\n   */\n  CodeBlockBuilderGroup = 'code-block-builder-group',\n\n  /**\n   * A CSS class for the field container of a collapsible group of the code block builder modal.\n   */\n  CodeBlockBuilderGroupBody = 'code-block-builder-group-body',\n\n  /**\n   * A CSS class for the code block builder modal.\n   */\n  CodeBlockBuilderModal = 'code-block-builder-modal',\n\n  /**\n   * A CSS class for the output row of the code block builder modal.\n   */\n  CodeBlockBuilderOutput = 'code-block-builder-output',\n\n  /**\n   * A CSS class for the live preview container of the code block builder modal.\n   */\n  CodeBlockBuilderPreview = 'code-block-builder-preview',\n\n  /**\n   * A CSS class for the code highlighter component.\n   */\n  CodeHighlighterComponent = 'code-highlighter-component',\n\n  /**\n   * A CSS class for the confirm modal.\n   */\n  ConfirmModal = 'confirm-modal',\n\n  /**\n   * A CSS class for the copy-text-manually modal.\n   */\n  CopyTextManuallyModal = 'copy-text-manually-modal',\n\n  /**\n   * A CSS class for the text area of the copy-text-manually modal.\n   */\n  CopyTextManuallyText = 'copy-text-manually-text',\n\n  /**\n   * A CSS class for the date component.\n   */\n  DateComponent = 'date-component',\n\n  /**\n   * A CSS class for the date and time component.\n   */\n  DateTimeComponent = 'datetime-component',\n\n  /**\n   * A CSS class for the email component.\n   */\n  EmailComponent = 'email-component',\n\n  /**\n   * A CSS class for the file component.\n   */\n  FileComponent = 'file-component',\n\n  /**\n   * A CSS class for rendered markdown whose headings and lists `registerFoldHandlers` made foldable.\n   */\n  FoldableMarkdown = 'foldable-markdown',\n\n  /**\n   * A CSS class for the folder list component.\n   */\n  FolderListComponent = 'folder-list-component',\n  /**\n   * A CSS class for the hotkey component.\n   */\n  HotkeyComponent = 'hotkey-component',\n\n  /**\n   * A CSS class for the element an inline token renders into, in Reading view and in Live Preview.\n   */\n  InlineToken = 'inline-token',\n\n  /**\n   * Obsidian's class for a control that is currently ON, reused so a pressed command button matches the\n   * app's own toggled controls.\n   */\n  IsActive = 'is-active',\n\n  /**\n   * Obsidian's class for a collapsed element, reused for a collapsed group of the code block builder modal.\n   */\n  IsCollapsed = 'is-collapsed',\n\n  /**\n   * A CSS class for the placeholder.\n   */\n  IsPlaceholder = 'is-placeholder',\n\n  /**\n   * A CSS class for the library name, set on every element the library builds.\n   */\n  LibraryName = 'obsidian-lib',\n\n  /**\n   * A CSS class for the reorderable list component.\n   */\n  ListComponent = 'list-component',\n  /**\n   * Obsidian's class marking rendered-markdown content (used by `appendCodeBlock`).\n   */\n  MarkdownRendered = 'markdown-rendered',\n\n  /**\n   * A CSS class for the minimizable modal.\n   */\n  MinimizableModal = 'minimizable-modal',\n\n  /**\n   * A CSS class for the minimize button of the minimizable modal.\n   */\n  MinimizeButton = 'minimize-button',\n\n  /**\n   * A CSS class for the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBar = 'minimized-modal-bar',\n\n  /**\n   * A CSS class for the one-shot attention flash of the minimized bar, played when the user attempts a\n   * blocked action (a keystroke, right-click, or opening another modal) while the modal is minimized.\n   */\n  MinimizedModalBarAttention = 'minimized-modal-bar-attention',\n\n  /**\n   * A CSS class for the title of the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBarTitle = 'minimized-modal-bar-title',\n\n  /**\n   * A CSS class for one button in a modal's command strip.\n   */\n  ModalCommand = 'modal-command',\n\n  /**\n   * A CSS class for a control injected into an instruction's purpose text — a checkbox, a dropdown.\n   * Obsidian's own instruction bar never contains one, so nothing upstream separates it from the label\n   * it belongs to.\n   */\n  ModalCommandControl = 'modal-command-control',\n\n  /**\n   * A CSS class for the hotkey hint inside a modal command button.\n   */\n  ModalCommandHotkey = 'modal-command-hotkey',\n\n  /**\n   * A CSS class for the strip of commands a modal renders along its bottom edge.\n   */\n  ModalCommands = 'modal-commands',\n\n  /**\n   * Obsidian's class for a modal header button (e.g. the modal close button), reused to match the\n   * native modal close button's box and hover.\n   */\n  ModalHeaderButton = 'modal-header-button',\n\n  /**\n   * A CSS class for the month component.\n   */\n  MonthComponent = 'month-component',\n\n  /**\n   * A CSS class for the multiple dropdown component.\n   */\n  MultipleDropdownComponent = 'multiple-dropdown-component',\n\n  /**\n   * A CSS class for the multiple email component.\n   */\n  MultipleEmailComponent = 'multiple-email-component',\n\n  /**\n   * A CSS class for the multiple file component.\n   */\n  MultipleFileComponent = 'multiple-file-component',\n\n  /**\n   * A CSS class for the multiple text component.\n   */\n  MultipleTextComponent = 'multiple-text-component',\n\n  /**\n   * A CSS class for the number component.\n   */\n  NumberComponent = 'number-component',\n\n  /**\n   * A CSS class for the ok button.\n   */\n  OkButton = 'ok-button',\n\n  /**\n   * A CSS class for the overlay validator.\n   */\n  OverlayValidator = 'overlay-validator',\n\n  /**\n   * A CSS class for the password component.\n   */\n  PasswordComponent = 'password-component',\n\n  /**\n   * A CSS class for the banner naming a plugin this one refuses, or warns about, running beside.\n   */\n  PluginConflictBanner = 'plugin-conflict-banner',\n\n  /**\n   * A CSS class for the banner a blocked plugin renders in place of its settings, naming the mandatory\n   * dependency it is waiting for.\n   */\n  PluginDependencyBanner = 'plugin-dependency-banner',\n\n  /**\n   * A CSS class for the close button of a notice that requires close confirmation.\n   */\n  PluginNoticeCloseButton = 'plugin-notice-close-button',\n\n  /**\n   * A CSS class for the container wrapping a notice's content, used to keep the notice open when an\n   * interactive element inside it is clicked.\n   */\n  PluginNoticeContent = 'plugin-notice-content',\n\n  /**\n   * A CSS class for the plugin name shown as the prefix of a notice.\n   */\n  PluginNoticeName = 'plugin-notice-name',\n\n  /**\n   * A CSS class applied to the notice element of a notice that requires an explicit close, used to make\n   * its whole area non-dismissible.\n   */\n  PluginNoticeRequiresExplicitClose = 'plugin-notice-requires-explicit-close',\n\n  /**\n   * A CSS class for the plugin settings tab.\n   */\n  PluginSettingsTab = 'plugin-settings-tab',\n\n  /**\n   * A CSS class for the banner a plugin-suggestion renders into a settings tab.\n   */\n  PluginSuggestionBanner = 'plugin-suggestion-banner',\n\n  /**\n   * A CSS class for the row of buttons in a plugin-suggestion notice, which spaces the action button apart from\n   * the decline button.\n   */\n  PluginSuggestionNoticeButtons = 'plugin-suggestion-notice-buttons',\n\n  /**\n   * A CSS class for the popover.\n   */\n  Popover = 'popover',\n\n  /**\n   * Obsidian's class for one row of its modal instruction bar, reused so a self-created bar inherits the\n   * app's own instruction styling.\n   */\n  PromptInstruction = 'prompt-instruction',\n\n  /**\n   * Obsidian's class for the key-hint half of one instruction row. It is the only thing carrying that\n   * hint's bold weight and the `margin-inline-end` that separates it from the purpose text, so a\n   * self-created bar that omits it renders `alt 1Keep the old title` welded together. Reused rather\n   * than re-implemented: the app's rule for it is unscoped, so it reaches a plain `Modal` too, and\n   * sharing the class keeps the self-created bar and `setInstructions` from ever drifting apart.\n   */\n  PromptInstructionCommand = 'prompt-instruction-command',\n\n  /**\n   * Obsidian's class for its modal instruction bar, reused so a self-created bar inherits the app's own\n   * instruction styling.\n   */\n  PromptInstructions = 'prompt-instructions',\n\n  /**\n   * A CSS class for the prompt modal.\n   */\n  PromptModal = 'prompt-modal',\n\n  /**\n   * A CSS class for the restore button of the minimized modal bar.\n   */\n  RestoreButton = 'restore-button',\n\n  /**\n   * A CSS class for the select item modal.\n   */\n  SelectItemModal = 'select-item-modal',\n\n  /**\n   * A CSS class for the select option modal.\n   */\n  SelectOptionModal = 'select-option-modal',\n\n  /**\n   * A CSS class for the setting component wrapper.\n   */\n  SettingComponentWrapper = 'setting-component-wrapper',\n\n  /**\n   * A CSS class for the settings tabs.\n   */\n  SettingsTabs = 'settings-tabs',\n  /**\n   * A CSS class for the tag list component.\n   */\n  TagListComponent = 'tag-list-component',\n  /**\n   * A CSS class for the telephone component.\n   */\n  TelephoneComponent = 'telephone-component',\n\n  /**\n   * A CSS class for the text box.\n   */\n  TextBox = 'text-box',\n\n  /**\n   * A CSS class for the time component.\n   */\n  TimeComponent = 'time-component',\n\n  /**\n   * A CSS class for the tooltip.\n   */\n  Tooltip = 'tooltip',\n\n  /**\n   * A CSS class for the tooltip arrow.\n   */\n  TooltipArrow = 'tooltip-arrow',\n\n  /**\n   * A CSS class for the tooltip validator.\n   */\n  TooltipValidator = 'tooltip-validator',\n\n  /**\n   * A CSS class for the tri-state checkbox component.\n   */\n  TriStateCheckboxComponent = 'tri-state-checkbox-component',\n\n  /**\n   * A CSS class for the typed dropdown component.\n   */\n  TypedDropdownComponent = 'typed-dropdown-component',\n\n  /**\n   * A CSS class for the typed multiple dropdown component.\n   */\n  TypedMultipleDropdownComponent = 'typed-multiple-dropdown-component',\n\n  /**\n   * A CSS class for an input the user has not interacted with yet, used to defer the invalid styling until\n   * the input is touched.\n   */\n  Untouched = 'untouched',\n\n  /**\n   * A CSS class for the url component.\n   */\n  UrlComponent = 'url-component',\n\n  /**\n   * A CSS class for the week component.\n   */\n  WeekComponent = 'week-component'\n}\n"],"mappings":"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","names":["CssClass"]}

package/dist/lib/cjs/css-class.d.cts

@@ -12,6 +12,14 @@ export declare enum CssClass {
      * A CSS class for the alert modal.
      */
     AlertModal = "alert-modal",
+    /**
+     * A CSS class for the preview of the bug-report diagnostics review modal.
+     */
+    BugReportPreview = "bug-report-preview",
+    /**
+     * A CSS class for the bug-report diagnostics review modal.
+     */
+    BugReportReviewModal = "bug-report-review-modal",
     /**
      * A CSS class for the cancel button.
      */
@@ -56,6 +64,14 @@ export declare enum CssClass {
      * A CSS class for the confirm modal.
      */
     ConfirmModal = "confirm-modal",
+    /**
+     * A CSS class for the copy-text-manually modal.
+     */
+    CopyTextManuallyModal = "copy-text-manually-modal",
+    /**
+     * A CSS class for the text area of the copy-text-manually modal.
+     */
+    CopyTextManuallyText = "copy-text-manually-text",
     /**
      * A CSS class for the date component.
      */

package/dist/lib/cjs/data-handler.cjs

@@ -2,6 +2,33 @@
 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();
+})();
 (function patchObsidianRequire() {
   const originalRequire = require;
   if (!originalRequire || originalRequire.__isPatched) {
@@ -87,39 +114,163 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var data_handler_exports = {};
 __export(data_handler_exports, {
-  PluginDataHandler: () => PluginDataHandler
+  DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES: () => DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES,
+  PluginDataHandler: () => PluginDataHandler,
+  PluginDataOperation: () => PluginDataOperation,
+  PluginDataSizeLimitExceededError: () => PluginDataSizeLimitExceededError
 });
 module.exports = __toCommonJS(data_handler_exports);
+var import_obsidian = require('obsidian');
+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;
   }
   plugin;
+  /**
+   * 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.
+   *
    * @returns The loaded data.
+   * @throws {@link PluginDataSizeLimitExceededError} If the existing file is larger than the limit.
    */
   async loadData() {
+    const sizeInBytes = await this.getExistingFileSize();
+    if (sizeInBytes !== null && sizeInBytes > this.maxSizeInBytes) {
+      throw this.createError("load" /* Load */, sizeInBytes);
+    }
     return this.plugin.loadData();
   }
   /**
    * 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 ? (0, import_obsidian.normalizePath)(`${directory}/data.json`) : null;
+  }
+  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;
+    }
+  }
+}
+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;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  PluginDataHandler
+  DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES,
+  PluginDataHandler,
+  PluginDataOperation,
+  PluginDataSizeLimitExceededError
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# 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\nimport type { Plugin } from 'obsidian';\n\nimport { normalizePath } from 'obsidian';\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   * 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/**\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   * 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  }\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.\n   *\n   * @returns The loaded data.\n   * @throws {@link PluginDataSizeLimitExceededError} If the existing file is larger than the limit.\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    return this.plugin.loadData();\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  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\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"]}