@mnaoumov/obsidian-lib 10.11.0 → 11.0.0

package/dist/lib/esm/setting-components/multiple-text-component.mjs

@@ -75,12 +75,15 @@ class MultipleTextComponent extends ValueComponent {
     this.textAreaComponent.setValue("");
   }
   /**
-   * Gets the value of the component.
+   * Gets the value of the component: one entry per line of the text area.
+   *
+   * Blank and whitespace-only lines are skipped, so an empty text area reads as `[]` rather than `['']`. Every other
+   * line is kept exactly as typed.
    *
    * @returns The value of the component.
    */
   getValue() {
-    return this.textAreaComponent.getValue().split("\n");
+    return this.textAreaComponent.getValue().split("\n").filter((line) => line.trim() !== "");
   }
   /**
    * Checks if the component is empty.
@@ -166,4 +169,4 @@ class MultipleTextComponent extends ValueComponent {
 export {
   MultipleTextComponent
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/setting-components/multiple-text-component.ts"],"sourcesContent":["/**\n * @file\n *\n * Contains a component that displays and edits multiple text values.\n */\n\nimport type { ValidatorElement } from '@mnaoumov/typescript-lib/html-element';\n\nimport {\n  TextAreaComponent,\n  ValueComponent\n} from 'obsidian';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars -- We need to import `initPluginContext` to use it in the tsdocs.\nimport type { initPluginContext } from '../plugin/plugin-context.ts';\n// eslint-disable-next-line @typescript-eslint/no-unused-vars -- We need to import `SettingEx` to use it in the tsdocs.\nimport type { SettingEx } from '../setting-ex.ts';\nimport type { TextBasedComponent } from './text-based-component.ts';\nimport type { ValidatorComponent } from './validator-component.ts';\nimport type { ValueComponentWithChangeTracking } from './value-component-with-change-tracking.ts';\n\nimport { CssClass } from '../css-class.ts';\nimport { addPluginCssClasses } from '../plugin/plugin-context.ts';\n\n/**\n * A component that displays and edits multiple text values.\n *\n * You can add this component using {@link SettingEx.addMultipleText}.\n *\n * In order to add the styles for the component, use {@link initPluginContext} in your plugin's `onload()` function.\n *\n * Alternatively, you can copy styles from {@link https://unpkg.com/@mnaoumov/obsidian-lib/dist/styles.css}.\n */\nexport class MultipleTextComponent extends ValueComponent<readonly string[]> implements TextBasedComponent<readonly string[]>, ValidatorComponent, ValueComponentWithChangeTracking<readonly string[]> {\n  /**\n   * An input element of the component.\n   *\n   * @returns The input element of the component.\n   */\n  public get inputEl(): HTMLTextAreaElement {\n    return this.textAreaComponent.inputEl;\n  }\n\n  /**\n   * Gets the validator element of the component.\n   *\n   * @returns The validator element of the component.\n   */\n  public get validatorEl(): ValidatorElement {\n    return this.inputEl;\n  }\n\n  /**\n   * The inner text area component.\n   */\n  protected readonly textAreaComponent: TextAreaComponent;\n\n  private simulateChangeCallback?: () => void;\n\n  /**\n   * Creates a new multiple text component.\n   *\n   * @param containerEl - The container element of the component.\n   */\n  public constructor(containerEl: HTMLElement) {\n    super();\n    this.textAreaComponent = new TextAreaComponent(containerEl);\n    addPluginCssClasses(containerEl, CssClass.MultipleTextComponent);\n  }\n\n  /**\n   * Empties the component.\n   */\n  public empty(): void {\n    this.textAreaComponent.setValue('');\n  }\n\n  /**\n   * Gets the value of the component.\n   *\n   * @returns The value of the component.\n   */\n  public override getValue(): readonly string[] {\n    return this.textAreaComponent.getValue().split('\\n');\n  }\n\n  /**\n   * Checks if the component is empty.\n   *\n   * @returns `true` if the component is empty, `false` otherwise.\n   */\n  public isEmpty(): boolean {\n    return this.textAreaComponent.getValue() === '';\n  }\n\n  /**\n   * Adds a change listener to the component.\n   *\n   * @param callback - The callback to call when the value changes.\n   * @returns The component.\n   */\n  public onChange(callback: (newValue: readonly string[]) => void): this {\n    const changeHandler = (): void => {\n      callback(this.getValue());\n    };\n    this.simulateChangeCallback = changeHandler;\n    this.textAreaComponent.onChange(changeHandler);\n    return this;\n  }\n\n  /**\n   * Sets the disabled state of the component.\n   *\n   * @param isDisabled - The disabled state to set.\n   * @returns The component.\n   */\n  public override setDisabled(isDisabled: boolean): this {\n    super.setDisabled(isDisabled);\n    this.textAreaComponent.setDisabled(isDisabled);\n    return this;\n  }\n\n  /**\n   * Sets the placeholder of the component.\n   *\n   * @param placeholder - The placeholder to set.\n   * @returns The component.\n   */\n  public setPlaceholder(placeholder: string): this {\n    this.textAreaComponent.setPlaceholder(placeholder);\n    return this;\n  }\n\n  /**\n   * Sets the placeholder value of the component.\n   *\n   * @param placeholderValue - The placeholder value to set.\n   * @returns The component.\n   */\n  public setPlaceholderValue(placeholderValue: readonly string[]): this {\n    this.setPlaceholder(this.valueToString(placeholderValue));\n    return this;\n  }\n\n  /**\n   * Sets the value of the component.\n   *\n   * @param value - The value to set.\n   * @returns The component.\n   */\n  public override setValue(value: readonly string[]): this {\n    this.textAreaComponent.setValue(this.valueToString(value));\n    return this;\n  }\n\n  /**\n   * Simulate a change event.\n   *\n   * @deprecated Use only from tests to simulate a change event.\n   */\n  public simulateChange__(): void {\n    this.simulateChangeCallback?.();\n  }\n\n  /**\n   * Converts the value to the string shown in the text area. Subclasses can override to customize the serialization.\n   *\n   * @param value - The value to convert.\n   * @returns The string representation of the value.\n   */\n  protected valueToString(value: readonly string[]): string {\n    return value.join('\\n');\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAUP,SAAS,gBAAgB;AACzB,SAAS,2BAA2B;AAW7B,MAAM,8BAA8B,eAA4J;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMrM,IAAW,UAA+B;AACxC,WAAO,KAAK,kBAAkB;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAW,cAAgC;AACzC,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKmB;AAAA,EAEX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOD,YAAY,aAA0B;AAC3C,UAAM;AACN,SAAK,oBAAoB,IAAI,kBAAkB,WAAW;AAC1D,wBAAoB,aAAa,SAAS,qBAAqB;AAAA,EACjE;AAAA;AAAA;AAAA;AAAA,EAKO,QAAc;AACnB,SAAK,kBAAkB,SAAS,EAAE;AAAA,EACpC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOgB,WAA8B;AAC5C,WAAO,KAAK,kBAAkB,SAAS,EAAE,MAAM,IAAI;AAAA,EACrD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,UAAmB;AACxB,WAAO,KAAK,kBAAkB,SAAS,MAAM;AAAA,EAC/C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,SAAS,UAAuD;AACrE,UAAM,gBAAgB,MAAY;AAChC,eAAS,KAAK,SAAS,CAAC;AAAA,IAC1B;AACA,SAAK,yBAAyB;AAC9B,SAAK,kBAAkB,SAAS,aAAa;AAC7C,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQgB,YAAY,YAA2B;AACrD,UAAM,YAAY,UAAU;AAC5B,SAAK,kBAAkB,YAAY,UAAU;AAC7C,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,eAAe,aAA2B;AAC/C,SAAK,kBAAkB,eAAe,WAAW;AACjD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,oBAAoB,kBAA2C;AACpE,SAAK,eAAe,KAAK,cAAc,gBAAgB,CAAC;AACxD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQgB,SAAS,OAAgC;AACvD,SAAK,kBAAkB,SAAS,KAAK,cAAc,KAAK,CAAC;AACzD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,mBAAyB;AAC9B,SAAK,yBAAyB;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQU,cAAc,OAAkC;AACxD,WAAO,MAAM,KAAK,IAAI;AAAA,EACxB;AACF;","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/setting-components/multiple-text-component.ts"],"sourcesContent":["/**\n * @file\n *\n * Contains a component that displays and edits multiple text values.\n */\n\nimport type { ValidatorElement } from '@mnaoumov/typescript-lib/html-element';\n\nimport {\n  TextAreaComponent,\n  ValueComponent\n} from 'obsidian';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars -- We need to import `initPluginContext` to use it in the tsdocs.\nimport type { initPluginContext } from '../plugin/plugin-context.ts';\n// eslint-disable-next-line @typescript-eslint/no-unused-vars -- We need to import `SettingEx` to use it in the tsdocs.\nimport type { SettingEx } from '../setting-ex.ts';\nimport type { TextBasedComponent } from './text-based-component.ts';\nimport type { ValidatorComponent } from './validator-component.ts';\nimport type { ValueComponentWithChangeTracking } from './value-component-with-change-tracking.ts';\n\nimport { CssClass } from '../css-class.ts';\nimport { addPluginCssClasses } from '../plugin/plugin-context.ts';\n\n/**\n * A component that displays and edits multiple text values.\n *\n * You can add this component using {@link SettingEx.addMultipleText}.\n *\n * In order to add the styles for the component, use {@link initPluginContext} in your plugin's `onload()` function.\n *\n * Alternatively, you can copy styles from {@link https://unpkg.com/@mnaoumov/obsidian-lib/dist/styles.css}.\n */\nexport class MultipleTextComponent extends ValueComponent<readonly string[]> implements TextBasedComponent<readonly string[]>, ValidatorComponent, ValueComponentWithChangeTracking<readonly string[]> {\n  /**\n   * An input element of the component.\n   *\n   * @returns The input element of the component.\n   */\n  public get inputEl(): HTMLTextAreaElement {\n    return this.textAreaComponent.inputEl;\n  }\n\n  /**\n   * Gets the validator element of the component.\n   *\n   * @returns The validator element of the component.\n   */\n  public get validatorEl(): ValidatorElement {\n    return this.inputEl;\n  }\n\n  /**\n   * The inner text area component.\n   */\n  protected readonly textAreaComponent: TextAreaComponent;\n\n  private simulateChangeCallback?: () => void;\n\n  /**\n   * Creates a new multiple text component.\n   *\n   * @param containerEl - The container element of the component.\n   */\n  public constructor(containerEl: HTMLElement) {\n    super();\n    this.textAreaComponent = new TextAreaComponent(containerEl);\n    addPluginCssClasses(containerEl, CssClass.MultipleTextComponent);\n  }\n\n  /**\n   * Empties the component.\n   */\n  public empty(): void {\n    this.textAreaComponent.setValue('');\n  }\n\n  /**\n   * Gets the value of the component: one entry per line of the text area.\n   *\n   * Blank and whitespace-only lines are skipped, so an empty text area reads as `[]` rather than `['']`. Every other\n   * line is kept exactly as typed.\n   *\n   * @returns The value of the component.\n   */\n  public override getValue(): readonly string[] {\n    return this.textAreaComponent.getValue().split('\\n').filter((line) => line.trim() !== '');\n  }\n\n  /**\n   * Checks if the component is empty.\n   *\n   * @returns `true` if the component is empty, `false` otherwise.\n   */\n  public isEmpty(): boolean {\n    return this.textAreaComponent.getValue() === '';\n  }\n\n  /**\n   * Adds a change listener to the component.\n   *\n   * @param callback - The callback to call when the value changes.\n   * @returns The component.\n   */\n  public onChange(callback: (newValue: readonly string[]) => void): this {\n    const changeHandler = (): void => {\n      callback(this.getValue());\n    };\n    this.simulateChangeCallback = changeHandler;\n    this.textAreaComponent.onChange(changeHandler);\n    return this;\n  }\n\n  /**\n   * Sets the disabled state of the component.\n   *\n   * @param isDisabled - The disabled state to set.\n   * @returns The component.\n   */\n  public override setDisabled(isDisabled: boolean): this {\n    super.setDisabled(isDisabled);\n    this.textAreaComponent.setDisabled(isDisabled);\n    return this;\n  }\n\n  /**\n   * Sets the placeholder of the component.\n   *\n   * @param placeholder - The placeholder to set.\n   * @returns The component.\n   */\n  public setPlaceholder(placeholder: string): this {\n    this.textAreaComponent.setPlaceholder(placeholder);\n    return this;\n  }\n\n  /**\n   * Sets the placeholder value of the component.\n   *\n   * @param placeholderValue - The placeholder value to set.\n   * @returns The component.\n   */\n  public setPlaceholderValue(placeholderValue: readonly string[]): this {\n    this.setPlaceholder(this.valueToString(placeholderValue));\n    return this;\n  }\n\n  /**\n   * Sets the value of the component.\n   *\n   * @param value - The value to set.\n   * @returns The component.\n   */\n  public override setValue(value: readonly string[]): this {\n    this.textAreaComponent.setValue(this.valueToString(value));\n    return this;\n  }\n\n  /**\n   * Simulate a change event.\n   *\n   * @deprecated Use only from tests to simulate a change event.\n   */\n  public simulateChange__(): void {\n    this.simulateChangeCallback?.();\n  }\n\n  /**\n   * Converts the value to the string shown in the text area. Subclasses can override to customize the serialization.\n   *\n   * @param value - The value to convert.\n   * @returns The string representation of the value.\n   */\n  protected valueToString(value: readonly string[]): string {\n    return value.join('\\n');\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAUP,SAAS,gBAAgB;AACzB,SAAS,2BAA2B;AAW7B,MAAM,8BAA8B,eAA4J;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMrM,IAAW,UAA+B;AACxC,WAAO,KAAK,kBAAkB;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAW,cAAgC;AACzC,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKmB;AAAA,EAEX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOD,YAAY,aAA0B;AAC3C,UAAM;AACN,SAAK,oBAAoB,IAAI,kBAAkB,WAAW;AAC1D,wBAAoB,aAAa,SAAS,qBAAqB;AAAA,EACjE;AAAA;AAAA;AAAA;AAAA,EAKO,QAAc;AACnB,SAAK,kBAAkB,SAAS,EAAE;AAAA,EACpC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUgB,WAA8B;AAC5C,WAAO,KAAK,kBAAkB,SAAS,EAAE,MAAM,IAAI,EAAE,OAAO,CAAC,SAAS,KAAK,KAAK,MAAM,EAAE;AAAA,EAC1F;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,UAAmB;AACxB,WAAO,KAAK,kBAAkB,SAAS,MAAM;AAAA,EAC/C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,SAAS,UAAuD;AACrE,UAAM,gBAAgB,MAAY;AAChC,eAAS,KAAK,SAAS,CAAC;AAAA,IAC1B;AACA,SAAK,yBAAyB;AAC9B,SAAK,kBAAkB,SAAS,aAAa;AAC7C,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQgB,YAAY,YAA2B;AACrD,UAAM,YAAY,UAAU;AAC5B,SAAK,kBAAkB,YAAY,UAAU;AAC7C,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,eAAe,aAA2B;AAC/C,SAAK,kBAAkB,eAAe,WAAW;AACjD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,oBAAoB,kBAA2C;AACpE,SAAK,eAAe,KAAK,cAAc,gBAAgB,CAAC;AACxD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQgB,SAAS,OAAgC;AACvD,SAAK,kBAAkB,SAAS,KAAK,cAAc,KAAK,CAAC;AACzD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,mBAAyB;AAC9B,SAAK,yBAAyB;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQU,cAAc,OAAkC;AACxD,WAAO,MAAM,KAAK,IAAI;AAAA,EACxB;AACF;","names":[]}

package/dist/lib/esm/settings-recovery.d.mts

@@ -0,0 +1,178 @@
+/// <reference path="./library-references.d.mts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Device-local recovery copies of a plugin's `data.json`, kept BEFORE anything could lose what the file held.
+ *
+ * Two cases lose a user's settings for good without one. A `data.json` that does not parse (truncated by a sync tool,
+ * a crash mid-write, a hand edit) reads as missing, because Obsidian's `Vault.readJson` swallows the parse error
+ * (read from `1.15.1`); and a record that parses but holds values the plugin drops or rewrites (an unknown key from a
+ * newer plugin version, a legacy migration) is normalized and saved back over the file on the initial load. A copy of
+ * the raw text is kept first, in a {@link LocalDataStore}, so no sync tool carries it to other devices and nothing is
+ * added to the vault.
+ */
+import type { App } from 'obsidian';
+/**
+ * How many recovery copies a {@link LocalSettingsRecoveryStore} keeps per plugin by default. The oldest is dropped
+ * first.
+ */
+export declare const DEFAULT_MAX_SETTINGS_RECOVERY_COPIES = 5;
+/**
+ * The {@link LocalDataStore} store id the recovery copies live under. The `-v1` names the record shape below.
+ */
+export declare const SETTINGS_RECOVERY_STORE_ID = "settings-recovery-v1";
+/**
+ * Why a recovery copy was kept.
+ */
+export declare enum SettingsRecoveryReason {
+    /**
+     * The file did not parse as JSON, so it could not be loaded at all.
+     */
+    InvalidJson = "invalid-json",
+    /**
+     * The file parsed, but saving the normalized settings would have dropped or changed a stored value.
+     */
+    LossyRewrite = "lossy-rewrite"
+}
+/**
+ * Constructor parameters for {@link LocalSettingsRecoveryStore}.
+ */
+export interface LocalSettingsRecoveryStoreConstructorParams {
+    /**
+     * The Obsidian app; its device-local `appId` scopes the store to this vault.
+     */
+    readonly app: App;
+    /**
+     * IndexedDB implementation, injectable for tests.
+     */
+    readonly factory?: IDBFactory;
+    /**
+     * How many copies to keep. Defaults to {@link DEFAULT_MAX_SETTINGS_RECOVERY_COPIES}.
+     */
+    readonly maxCopies?: number;
+    /**
+     * The clock, injectable for tests. Defaults to {@link Date.now}.
+     */
+    readonly now?: () => number;
+    /**
+     * The `manifest.id` of the plugin.
+     */
+    readonly pluginId: string;
+}
+/**
+ * One kept copy of a plugin's `data.json`.
+ */
+export interface SettingsRecoveryCopy {
+    /**
+     * The copy's id, unique within the plugin's store.
+     */
+    readonly id: string;
+    /**
+     * When the copy was kept, in milliseconds since the Unix epoch.
+     */
+    readonly keptAt: number;
+    /**
+     * The vault-relative path of the file the copy was taken from.
+     */
+    readonly path: string;
+    /**
+     * The file's raw text, byte for byte as it was read.
+     */
+    readonly rawText: string;
+    /**
+     * Why the copy was kept.
+     */
+    readonly reason: SettingsRecoveryReason;
+}
+/**
+ * Where recovery copies of a plugin's `data.json` are kept.
+ */
+export interface SettingsRecoveryStore {
+    /**
+     * Keeps a copy. A copy whose raw text is already kept is not duplicated; the existing one is returned.
+     *
+     * @param params - What to keep.
+     * @returns The kept copy.
+     */
+    readonly keep: (params: SettingsRecoveryStoreKeepParams) => Promise<SettingsRecoveryCopy>;
+    /**
+     * Lists the kept copies.
+     *
+     * @returns The copies, newest first.
+     */
+    readonly list: () => Promise<SettingsRecoveryCopy[]>;
+    /**
+     * Removes a kept copy. Removing an id that is not kept does nothing.
+     *
+     * @param id - The copy's id.
+     * @returns A promise that resolves when the copy is removed.
+     */
+    readonly remove: (id: string) => Promise<void>;
+}
+/**
+ * Parameters for {@link SettingsRecoveryStore.keep}.
+ */
+export interface SettingsRecoveryStoreKeepParams {
+    /**
+     * The vault-relative path of the file the copy was taken from.
+     */
+    readonly path: string;
+    /**
+     * The file's raw text, byte for byte as it was read.
+     */
+    readonly rawText: string;
+    /**
+     * Why the copy is kept.
+     */
+    readonly reason: SettingsRecoveryReason;
+}
+/**
+ * A {@link SettingsRecoveryStore} in a device-local {@link LocalDataStore}, keeping the newest few copies.
+ *
+ * It opens its database per call and closes it again: copies are kept and read rarely (a load that found a damaged
+ * file, a lossy first save, the user asking for the list), so holding a connection for the plugin's lifetime would
+ * only add a resource to tie to an unload.
+ */
+export declare class LocalSettingsRecoveryStore implements SettingsRecoveryStore {
+    private readonly factory;
+    private readonly maxCopies;
+    private readonly now;
+    private readonly pluginId;
+    private readonly vaultId;
+    /**
+     * Creates a new store.
+     *
+     * @param params - The constructor parameters.
+     */
+    constructor(params: LocalSettingsRecoveryStoreConstructorParams);
+    /**
+     * Keeps a copy, dropping the oldest ones beyond the limit in the same transaction.
+     *
+     * @param params - What to keep.
+     * @returns The kept copy, or the already kept one with the same raw text.
+     */
+    keep(params: SettingsRecoveryStoreKeepParams): Promise<SettingsRecoveryCopy>;
+    /**
+     * Lists the kept copies.
+     *
+     * @returns The copies, newest first.
+     */
+    list(): Promise<SettingsRecoveryCopy[]>;
+    /**
+     * Removes a kept copy.
+     *
+     * @param id - The copy's id.
+     * @returns A promise that resolves when the copy is removed.
+     */
+    remove(id: string): Promise<void>;
+    private withStore;
+}
+/**
+ * Checks whether a value is a {@link SettingsRecoveryCopy}. A record of another shape (a later version's, or a damaged
+ * one) is ignored rather than trusted.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a recovery copy.
+ */
+export declare function isSettingsRecoveryCopy(value: unknown): value is SettingsRecoveryCopy;

package/dist/lib/esm/settings-recovery.mjs

@@ -0,0 +1,125 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { LocalDataStore } from "./data-stores/local-data-store.mjs";
+const DEFAULT_MAX_SETTINGS_RECOVERY_COPIES = 5;
+const SETTINGS_RECOVERY_STORE_ID = "settings-recovery-v1";
+var SettingsRecoveryReason = /* @__PURE__ */ ((SettingsRecoveryReason2) => {
+  SettingsRecoveryReason2["InvalidJson"] = "invalid-json";
+  SettingsRecoveryReason2["LossyRewrite"] = "lossy-rewrite";
+  return SettingsRecoveryReason2;
+})(SettingsRecoveryReason || {});
+class LocalSettingsRecoveryStore {
+  factory;
+  maxCopies;
+  now;
+  pluginId;
+  vaultId;
+  /**
+   * Creates a new store.
+   *
+   * @param params - The constructor parameters.
+   */
+  constructor(params) {
+    const maxCopies = params.maxCopies ?? DEFAULT_MAX_SETTINGS_RECOVERY_COPIES;
+    if (!Number.isSafeInteger(maxCopies) || maxCopies < 1) {
+      throw new RangeError(`maxCopies must be a positive integer, got ${String(maxCopies)}.`);
+    }
+    this.factory = params.factory;
+    this.maxCopies = maxCopies;
+    this.now = params.now ?? Date.now;
+    this.pluginId = params.pluginId;
+    this.vaultId = params.app.appId;
+  }
+  /**
+   * Keeps a copy, dropping the oldest ones beyond the limit in the same transaction.
+   *
+   * @param params - What to keep.
+   * @returns The kept copy, or the already kept one with the same raw text.
+   */
+  // eslint-disable-next-line typescript-dev-toolkit/params-options-name-match -- Implements SettingsRecoveryStore.keep, whose params type it shares.
+  async keep(params) {
+    return await this.withStore(async (store) => {
+      const copies = readCopies(await store.entries());
+      const duplicate = copies.find((copy2) => copy2.rawText === params.rawText);
+      if (duplicate) {
+        return duplicate;
+      }
+      const keptAt = this.now();
+      const copy = {
+        id: createCopyId(keptAt, copies),
+        keptAt,
+        path: params.path,
+        rawText: params.rawText,
+        reason: params.reason
+      };
+      const removedKeys = copies.slice(this.maxCopies - 1).map((oldCopy) => oldCopy.id);
+      await store.commit({ entries: [[copy.id, copy]], removedKeys });
+      return copy;
+    });
+  }
+  /**
+   * Lists the kept copies.
+   *
+   * @returns The copies, newest first.
+   */
+  async list() {
+    return await this.withStore(async (store) => readCopies(await store.entries()));
+  }
+  /**
+   * Removes a kept copy.
+   *
+   * @param id - The copy's id.
+   * @returns A promise that resolves when the copy is removed.
+   */
+  async remove(id) {
+    await this.withStore(async (store) => {
+      await store.delete(id);
+    });
+  }
+  async withStore(action) {
+    const store = await LocalDataStore.open({
+      ...this.factory && { factory: this.factory },
+      pluginId: this.pluginId,
+      storeId: SETTINGS_RECOVERY_STORE_ID,
+      vaultId: this.vaultId
+    });
+    try {
+      return await action(store);
+    } finally {
+      store.close();
+    }
+  }
+}
+function isSettingsRecoveryCopy(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const record = value;
+  return typeof record.id === "string" && typeof record.keptAt === "number" && typeof record.path === "string" && typeof record.rawText === "string" && (record.reason === "invalid-json" /* InvalidJson */ || record.reason === "lossy-rewrite" /* LossyRewrite */);
+}
+function compareNewestFirst(a, b) {
+  return b.keptAt - a.keptAt || b.id.localeCompare(a.id);
+}
+function createCopyId(keptAt, copies) {
+  const ids = new Set(copies.map((copy) => copy.id));
+  const base = new Date(keptAt).toISOString();
+  let id = base;
+  for (let suffix = 1; ids.has(id); suffix++) {
+    id = `${base}-${String(suffix)}`;
+  }
+  return id;
+}
+function readCopies(entries) {
+  return entries.map(([, value]) => value).filter(isSettingsRecoveryCopy).sort(compareNewestFirst);
+}
+export {
+  DEFAULT_MAX_SETTINGS_RECOVERY_COPIES,
+  LocalSettingsRecoveryStore,
+  SETTINGS_RECOVERY_STORE_ID,
+  SettingsRecoveryReason,
+  isSettingsRecoveryCopy
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/settings-recovery.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Device-local recovery copies of a plugin's `data.json`, kept BEFORE anything could lose what the file held.\n *\n * Two cases lose a user's settings for good without one. A `data.json` that does not parse (truncated by a sync tool,\n * a crash mid-write, a hand edit) reads as missing, because Obsidian's `Vault.readJson` swallows the parse error\n * (read from `1.15.1`); and a record that parses but holds values the plugin drops or rewrites (an unknown key from a\n * newer plugin version, a legacy migration) is normalized and saved back over the file on the initial load. A copy of\n * the raw text is kept first, in a {@link LocalDataStore}, so no sync tool carries it to other devices and nothing is\n * added to the vault.\n */\n\nimport type { App } from 'obsidian';\n\nimport { LocalDataStore } from './data-stores/local-data-store.ts';\n\n/**\n * How many recovery copies a {@link LocalSettingsRecoveryStore} keeps per plugin by default. The oldest is dropped\n * first.\n */\nexport const DEFAULT_MAX_SETTINGS_RECOVERY_COPIES = 5;\n\n/**\n * The {@link LocalDataStore} store id the recovery copies live under. The `-v1` names the record shape below.\n */\nexport const SETTINGS_RECOVERY_STORE_ID = 'settings-recovery-v1';\n\n/**\n * Why a recovery copy was kept.\n */\nexport enum SettingsRecoveryReason {\n  /**\n   * The file did not parse as JSON, so it could not be loaded at all.\n   */\n  InvalidJson = 'invalid-json',\n\n  /**\n   * The file parsed, but saving the normalized settings would have dropped or changed a stored value.\n   */\n  LossyRewrite = 'lossy-rewrite'\n}\n\n/**\n * Constructor parameters for {@link LocalSettingsRecoveryStore}.\n */\nexport interface LocalSettingsRecoveryStoreConstructorParams {\n  /**\n   * The Obsidian app; its device-local `appId` scopes the store to this vault.\n   */\n  readonly app: App;\n\n  /**\n   * IndexedDB implementation, injectable for tests.\n   */\n  readonly factory?: IDBFactory;\n\n  /**\n   * How many copies to keep. Defaults to {@link DEFAULT_MAX_SETTINGS_RECOVERY_COPIES}.\n   */\n  readonly maxCopies?: number;\n\n  /**\n   * The clock, injectable for tests. Defaults to {@link Date.now}.\n   */\n  readonly now?: () => number;\n\n  /**\n   * The `manifest.id` of the plugin.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * One kept copy of a plugin's `data.json`.\n */\nexport interface SettingsRecoveryCopy {\n  /**\n   * The copy's id, unique within the plugin's store.\n   */\n  readonly id: string;\n\n  /**\n   * When the copy was kept, in milliseconds since the Unix epoch.\n   */\n  readonly keptAt: number;\n\n  /**\n   * The vault-relative path of the file the copy was taken from.\n   */\n  readonly path: string;\n\n  /**\n   * The file's raw text, byte for byte as it was read.\n   */\n  readonly rawText: string;\n\n  /**\n   * Why the copy was kept.\n   */\n  readonly reason: SettingsRecoveryReason;\n}\n\n/**\n * Where recovery copies of a plugin's `data.json` are kept.\n */\nexport interface SettingsRecoveryStore {\n  /**\n   * Keeps a copy. A copy whose raw text is already kept is not duplicated; the existing one is returned.\n   *\n   * @param params - What to keep.\n   * @returns The kept copy.\n   */\n  readonly keep: (params: SettingsRecoveryStoreKeepParams) => Promise<SettingsRecoveryCopy>;\n\n  /**\n   * Lists the kept copies.\n   *\n   * @returns The copies, newest first.\n   */\n  readonly list: () => Promise<SettingsRecoveryCopy[]>;\n\n  /**\n   * Removes a kept copy. Removing an id that is not kept does nothing.\n   *\n   * @param id - The copy's id.\n   * @returns A promise that resolves when the copy is removed.\n   */\n  readonly remove: (id: string) => Promise<void>;\n}\n\n/**\n * Parameters for {@link SettingsRecoveryStore.keep}.\n */\nexport interface SettingsRecoveryStoreKeepParams {\n  /**\n   * The vault-relative path of the file the copy was taken from.\n   */\n  readonly path: string;\n\n  /**\n   * The file's raw text, byte for byte as it was read.\n   */\n  readonly rawText: string;\n\n  /**\n   * Why the copy is kept.\n   */\n  readonly reason: SettingsRecoveryReason;\n}\n\n/**\n * A {@link SettingsRecoveryStore} in a device-local {@link LocalDataStore}, keeping the newest few copies.\n *\n * It opens its database per call and closes it again: copies are kept and read rarely (a load that found a damaged\n * file, a lossy first save, the user asking for the list), so holding a connection for the plugin's lifetime would\n * only add a resource to tie to an unload.\n */\nexport class LocalSettingsRecoveryStore implements SettingsRecoveryStore {\n  private readonly factory: IDBFactory | undefined;\n  private readonly maxCopies: number;\n  private readonly now: () => number;\n  private readonly pluginId: string;\n  private readonly vaultId: string;\n\n  /**\n   * Creates a new store.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: LocalSettingsRecoveryStoreConstructorParams) {\n    const maxCopies = params.maxCopies ?? DEFAULT_MAX_SETTINGS_RECOVERY_COPIES;\n    if (!Number.isSafeInteger(maxCopies) || maxCopies < 1) {\n      throw new RangeError(`maxCopies must be a positive integer, got ${String(maxCopies)}.`);\n    }\n    this.factory = params.factory;\n    this.maxCopies = maxCopies;\n    this.now = params.now ?? Date.now;\n    this.pluginId = params.pluginId;\n    this.vaultId = params.app.appId;\n  }\n\n  /**\n   * Keeps a copy, dropping the oldest ones beyond the limit in the same transaction.\n   *\n   * @param params - What to keep.\n   * @returns The kept copy, or the already kept one with the same raw text.\n   */\n  // eslint-disable-next-line typescript-dev-toolkit/params-options-name-match -- Implements SettingsRecoveryStore.keep, whose params type it shares.\n  public async keep(params: SettingsRecoveryStoreKeepParams): Promise<SettingsRecoveryCopy> {\n    return await this.withStore(async (store) => {\n      const copies = readCopies(await store.entries());\n      const duplicate = copies.find((copy) => copy.rawText === params.rawText);\n      if (duplicate) {\n        return duplicate;\n      }\n\n      const keptAt = this.now();\n      const copy: SettingsRecoveryCopy = {\n        id: createCopyId(keptAt, copies),\n        keptAt,\n        path: params.path,\n        rawText: params.rawText,\n        reason: params.reason\n      };\n      const removedKeys = copies.slice(this.maxCopies - 1).map((oldCopy) => oldCopy.id);\n      await store.commit({ entries: [[copy.id, copy]], removedKeys });\n      return copy;\n    });\n  }\n\n  /**\n   * Lists the kept copies.\n   *\n   * @returns The copies, newest first.\n   */\n  public async list(): Promise<SettingsRecoveryCopy[]> {\n    return await this.withStore(async (store) => readCopies(await store.entries()));\n  }\n\n  /**\n   * Removes a kept copy.\n   *\n   * @param id - The copy's id.\n   * @returns A promise that resolves when the copy is removed.\n   */\n  public async remove(id: string): Promise<void> {\n    await this.withStore(async (store) => {\n      await store.delete(id);\n    });\n  }\n\n  private async withStore<T>(action: (store: LocalDataStore) => Promise<T>): Promise<T> {\n    const store = await LocalDataStore.open({\n      ...(this.factory && { factory: this.factory }),\n      pluginId: this.pluginId,\n      storeId: SETTINGS_RECOVERY_STORE_ID,\n      vaultId: this.vaultId\n    });\n    try {\n      return await action(store);\n    } finally {\n      store.close();\n    }\n  }\n}\n\n/**\n * Checks whether a value is a {@link SettingsRecoveryCopy}. A record of another shape (a later version's, or a damaged\n * one) is ignored rather than trusted.\n *\n * @param value - The value to check.\n * @returns Whether the value is a recovery copy.\n */\nexport function isSettingsRecoveryCopy(value: unknown): value is SettingsRecoveryCopy {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  const record = value as Partial<Record<keyof SettingsRecoveryCopy, unknown>>;\n  return typeof record.id === 'string'\n    && typeof record.keptAt === 'number'\n    && typeof record.path === 'string'\n    && typeof record.rawText === 'string'\n    && (record.reason === SettingsRecoveryReason.InvalidJson || record.reason === SettingsRecoveryReason.LossyRewrite);\n}\n\nfunction compareNewestFirst(a: SettingsRecoveryCopy, b: SettingsRecoveryCopy): number {\n  return b.keptAt - a.keptAt || b.id.localeCompare(a.id);\n}\n\nfunction createCopyId(keptAt: number, copies: readonly SettingsRecoveryCopy[]): string {\n  const ids = new Set(copies.map((copy) => copy.id));\n  const base = new Date(keptAt).toISOString();\n  let id = base;\n  for (let suffix = 1; ids.has(id); suffix++) {\n    id = `${base}-${String(suffix)}`;\n  }\n  return id;\n}\n\nfunction readCopies(entries: readonly (readonly [string, unknown])[]): SettingsRecoveryCopy[] {\n  return entries\n    .map(([, value]) => value)\n    .filter(isSettingsRecoveryCopy)\n    .sort(compareNewestFirst);\n}\n"],
  "mappings": ";;;;;AAeA,SAAS,sBAAsB;AAMxB,MAAM,uCAAuC;AAK7C,MAAM,6BAA6B;AAKnC,IAAK,yBAAL,kBAAKA,4BAAL;AAIL,EAAAA,wBAAA,iBAAc;AAKd,EAAAA,wBAAA,kBAAe;AATL,SAAAA;AAAA,GAAA;AA+HL,MAAM,2BAA4D;AAAA,EACtD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOV,YAAY,QAAqD;AACtE,UAAM,YAAY,OAAO,aAAa;AACtC,QAAI,CAAC,OAAO,cAAc,SAAS,KAAK,YAAY,GAAG;AACrD,YAAM,IAAI,WAAW,6CAA6C,OAAO,SAAS,CAAC,GAAG;AAAA,IACxF;AACA,SAAK,UAAU,OAAO;AACtB,SAAK,YAAY;AACjB,SAAK,MAAM,OAAO,OAAO,KAAK;AAC9B,SAAK,WAAW,OAAO;AACvB,SAAK,UAAU,OAAO,IAAI;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAa,KAAK,QAAwE;AACxF,WAAO,MAAM,KAAK,UAAU,OAAO,UAAU;AAC3C,YAAM,SAAS,WAAW,MAAM,MAAM,QAAQ,CAAC;AAC/C,YAAM,YAAY,OAAO,KAAK,CAACC,UAASA,MAAK,YAAY,OAAO,OAAO;AACvE,UAAI,WAAW;AACb,eAAO;AAAA,MACT;AAEA,YAAM,SAAS,KAAK,IAAI;AACxB,YAAM,OAA6B;AAAA,QACjC,IAAI,aAAa,QAAQ,MAAM;AAAA,QAC/B;AAAA,QACA,MAAM,OAAO;AAAA,QACb,SAAS,OAAO;AAAA,QAChB,QAAQ,OAAO;AAAA,MACjB;AACA,YAAM,cAAc,OAAO,MAAM,KAAK,YAAY,CAAC,EAAE,IAAI,CAAC,YAAY,QAAQ,EAAE;AAChF,YAAM,MAAM,OAAO,EAAE,SAAS,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,GAAG,YAAY,CAAC;AAC9D,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAa,OAAwC;AACnD,WAAO,MAAM,KAAK,UAAU,OAAO,UAAU,WAAW,MAAM,MAAM,QAAQ,CAAC,CAAC;AAAA,EAChF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAa,OAAO,IAA2B;AAC7C,UAAM,KAAK,UAAU,OAAO,UAAU;AACpC,YAAM,MAAM,OAAO,EAAE;AAAA,IACvB,CAAC;AAAA,EACH;AAAA,EAEA,MAAc,UAAa,QAA2D;AACpF,UAAM,QAAQ,MAAM,eAAe,KAAK;AAAA,MACtC,GAAI,KAAK,WAAW,EAAE,SAAS,KAAK,QAAQ;AAAA,MAC5C,UAAU,KAAK;AAAA,MACf,SAAS;AAAA,MACT,SAAS,KAAK;AAAA,IAChB,CAAC;AACD,QAAI;AACF,aAAO,MAAM,OAAO,KAAK;AAAA,IAC3B,UAAE;AACA,YAAM,MAAM;AAAA,IACd;AAAA,EACF;AACF;AASO,SAAS,uBAAuB,OAA+C;AACpF,MAAI,OAAO,UAAU,YAAY,UAAU,MAAM;AAC/C,WAAO;AAAA,EACT;AACA,QAAM,SAAS;AACf,SAAO,OAAO,OAAO,OAAO,YACvB,OAAO,OAAO,WAAW,YACzB,OAAO,OAAO,SAAS,YACvB,OAAO,OAAO,YAAY,aACzB,OAAO,WAAW,oCAAsC,OAAO,WAAW;AAClF;AAEA,SAAS,mBAAmB,GAAyB,GAAiC;AACpF,SAAO,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,cAAc,EAAE,EAAE;AACvD;AAEA,SAAS,aAAa,QAAgB,QAAiD;AACrF,QAAM,MAAM,IAAI,IAAI,OAAO,IAAI,CAAC,SAAS,KAAK,EAAE,CAAC;AACjD,QAAM,OAAO,IAAI,KAAK,MAAM,EAAE,YAAY;AAC1C,MAAI,KAAK;AACT,WAAS,SAAS,GAAG,IAAI,IAAI,EAAE,GAAG,UAAU;AAC1C,SAAK,GAAG,IAAI,IAAI,OAAO,MAAM,CAAC;AAAA,EAChC;AACA,SAAO;AACT;AAEA,SAAS,WAAW,SAA0E;AAC5F,SAAO,QACJ,IAAI,CAAC,CAAC,EAAE,KAAK,MAAM,KAAK,EACxB,OAAO,sBAAsB,EAC7B,KAAK,kBAAkB;AAC5B;",
  "names": ["SettingsRecoveryReason", "copy"]
}


package/dist/lib/esm/settings-tabs.mjs

@@ -128,7 +128,7 @@ class SettingsTabs {
     return this;
   }
   findEntry(tabId) {
-    return this.entries.find((entry) => entry.tab.id === tabId);
+    return this.entries.find((entry) => entry.tab.id === tabId) ?? null;
   }
   onKeyDown(event_) {
     const count = this.entries.length;
@@ -167,4 +167,4 @@ class SettingsTabs {
 export {
   SettingsTabs
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/settings-tabs.ts"],"sourcesContent":["/**\n * @file\n *\n * Tabbed sections inside a plugin's settings.\n */\n\nimport { setIcon } from 'obsidian';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars -- We need to import `initPluginContext` to use it in the tsdocs.\nimport type { initPluginContext } from './plugin/plugin-context.ts';\n\nimport { CssClass } from './css-class.ts';\nimport { addPluginCssClasses } from './plugin/plugin-context.ts';\n\n/**\n * A tab of {@link SettingsTabs}.\n */\nexport interface SettingsTab {\n  /**\n   * The name of an Obsidian icon shown before the name.\n   */\n  readonly icon?: string;\n\n  /**\n   * The id of the tab, unique among the tabs.\n   */\n  readonly id: string;\n\n  /**\n   * The name shown on the tab button.\n   */\n  readonly name: string;\n\n  /**\n   * Renders the tab's settings into the panel, which is empty each time the tab is selected.\n   *\n   * @param containerEl - The panel.\n   */\n  readonly render: (containerEl: HTMLElement) => void;\n}\n\ninterface SettingsTabEntry {\n  readonly buttonEl: HTMLButtonElement;\n  readonly tab: SettingsTab;\n}\n\n/**\n * Tabbed sections inside a plugin's settings: a row of tab buttons and one panel, which renders only the selected tab.\n * The arrow keys, Home and End move between tabs, as in the WAI-ARIA tabs pattern.\n *\n * ```ts\n * public override display(): void {\n *   this.containerEl.empty();\n *   new SettingsTabs(this.containerEl)\n *     .addTab({ id: 'general', name: 'General', render: (el) => this.renderGeneral(el) })\n *     .addTab({ id: 'advanced', name: 'Advanced', render: (el) => this.renderAdvanced(el) })\n *     .selectTab(this.lastTabId)\n *     .onTabChange((tabId) => {\n *       this.lastTabId = tabId;\n *     });\n * }\n * ```\n *\n * In order to add the styles for the component, use {@link initPluginContext} in your plugin's `onload()` function.\n *\n * Alternatively, you can copy styles from {@link https://unpkg.com/@mnaoumov/obsidian-lib/dist/styles.css}.\n */\nexport class SettingsTabs {\n  /**\n   * The panel the selected tab renders into.\n   */\n  public readonly panelEl: HTMLElement;\n\n  /**\n   * The row of tab buttons.\n   */\n  public readonly tabBarEl: HTMLElement;\n\n  private changeCallback?: (tabId: string) => void;\n  private readonly entries: SettingsTabEntry[] = [];\n  private selectedTabId: null | string = null;\n\n  /**\n   * Creates new settings tabs.\n   *\n   * @param containerEl - The container element.\n   */\n  public constructor(containerEl: HTMLElement) {\n    addPluginCssClasses(containerEl, CssClass.SettingsTabs);\n    this.tabBarEl = containerEl.createDiv({ attr: { role: 'tablist' }, cls: 'settings-tabs-bar' });\n    this.tabBarEl.addEventListener('keydown', this.onKeyDown.bind(this));\n    this.panelEl = containerEl.createDiv({ attr: { role: 'tabpanel' }, cls: 'settings-tabs-panel' });\n  }\n\n  /**\n   * Adds a tab. The first tab added is selected.\n   *\n   * @param tab - The tab.\n   * @returns The tabs.\n   * @throws If a tab with the same id was already added.\n   */\n  public addTab(tab: SettingsTab): this {\n    if (this.findEntry(tab.id)) {\n      throw new Error(`A settings tab with the id ${tab.id} was already added.`);\n    }\n    const buttonEl = this.tabBarEl.createEl('button', { attr: { 'aria-selected': 'false', 'role': 'tab', 'tabindex': '-1' }, cls: 'settings-tabs-button' });\n    if (tab.icon) {\n      setIcon(buttonEl.createSpan({ cls: 'settings-tabs-icon' }), tab.icon);\n    }\n    buttonEl.createSpan({ text: tab.name });\n    buttonEl.addEventListener('click', () => {\n      this.selectTab(tab.id);\n    });\n    this.entries.push({ buttonEl, tab });\n    if (this.selectedTabId === null) {\n      this.selectTab(tab.id);\n    }\n    return this;\n  }\n\n  /**\n   * Gets the id of the selected tab.\n   *\n   * @returns The id, or `null` before any tab is added.\n   */\n  public getSelectedTabId(): null | string {\n    return this.selectedTabId;\n  }\n\n  /**\n   * Sets the callback to be called when the user selects another tab.\n   *\n   * @param callback - The callback, given the id of the selected tab.\n   * @returns The tabs.\n   */\n  public onTabChange(callback: (tabId: string) => void): this {\n    this.changeCallback = callback;\n    return this;\n  }\n\n  /**\n   * Selects a tab and renders it into the panel. An unknown id, such as a stored id whose tab was since removed, leaves\n   * the selection as it is.\n   *\n   * @param tabId - The id of the tab.\n   * @returns The tabs.\n   */\n  public selectTab(tabId: null | string | undefined): this {\n    const entry = this.findEntry(tabId);\n    if (!entry) {\n      return this;\n    }\n    const { tab } = entry;\n    const isChange = this.selectedTabId !== null && this.selectedTabId !== tab.id;\n    this.selectedTabId = tab.id;\n    for (const { buttonEl, tab: candidate } of this.entries) {\n      const isSelected = candidate === tab;\n      buttonEl.toggleClass(CssClass.IsActive, isSelected);\n      buttonEl.setAttribute('aria-selected', String(isSelected));\n      buttonEl.setAttribute('tabindex', isSelected ? '0' : '-1');\n    }\n    this.panelEl.empty();\n    tab.render(this.panelEl);\n    if (isChange) {\n      this.changeCallback?.(tab.id);\n    }\n    return this;\n  }\n\n  private findEntry(tabId: null | string | undefined): SettingsTabEntry | undefined {\n    return this.entries.find((entry) => entry.tab.id === tabId);\n  }\n\n  private onKeyDown(event_: KeyboardEvent): void {\n    const count = this.entries.length;\n    const index = this.entries.findIndex((entry) => entry.tab.id === this.selectedTabId);\n    let nextIndex: number;\n    switch (event_.key) {\n      case 'ArrowLeft': {\n        nextIndex = (index - 1 + count) % count;\n        break;\n      }\n      case 'ArrowRight': {\n        nextIndex = (index + 1) % count;\n        break;\n      }\n      case 'End': {\n        nextIndex = count - 1;\n        break;\n      }\n      case 'Home': {\n        nextIndex = 0;\n        break;\n      }\n      default: {\n        return;\n      }\n    }\n    const nextEntry = this.entries[nextIndex];\n    if (!nextEntry) {\n      return;\n    }\n    event_.preventDefault();\n    this.selectTab(nextEntry.tab.id);\n    nextEntry.buttonEl.focus();\n  }\n}\n"],"mappings":"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","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/settings-tabs.ts"],"sourcesContent":["/**\n * @file\n *\n * Tabbed sections inside a plugin's settings.\n */\n\nimport { setIcon } from 'obsidian';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars -- We need to import `initPluginContext` to use it in the tsdocs.\nimport type { initPluginContext } from './plugin/plugin-context.ts';\n\nimport { CssClass } from './css-class.ts';\nimport { addPluginCssClasses } from './plugin/plugin-context.ts';\n\n/**\n * A tab of {@link SettingsTabs}.\n */\nexport interface SettingsTab {\n  /**\n   * The name of an Obsidian icon shown before the name.\n   */\n  readonly icon?: string;\n\n  /**\n   * The id of the tab, unique among the tabs.\n   */\n  readonly id: string;\n\n  /**\n   * The name shown on the tab button.\n   */\n  readonly name: string;\n\n  /**\n   * Renders the tab's settings into the panel, which is empty each time the tab is selected.\n   *\n   * @param containerEl - The panel.\n   */\n  readonly render: (containerEl: HTMLElement) => void;\n}\n\ninterface SettingsTabEntry {\n  readonly buttonEl: HTMLButtonElement;\n  readonly tab: SettingsTab;\n}\n\n/**\n * Tabbed sections inside a plugin's settings: a row of tab buttons and one panel, which renders only the selected tab.\n * The arrow keys, Home and End move between tabs, as in the WAI-ARIA tabs pattern.\n *\n * ```ts\n * public override display(): void {\n *   this.containerEl.empty();\n *   new SettingsTabs(this.containerEl)\n *     .addTab({ id: 'general', name: 'General', render: (el) => this.renderGeneral(el) })\n *     .addTab({ id: 'advanced', name: 'Advanced', render: (el) => this.renderAdvanced(el) })\n *     .selectTab(this.lastTabId)\n *     .onTabChange((tabId) => {\n *       this.lastTabId = tabId;\n *     });\n * }\n * ```\n *\n * In order to add the styles for the component, use {@link initPluginContext} in your plugin's `onload()` function.\n *\n * Alternatively, you can copy styles from {@link https://unpkg.com/@mnaoumov/obsidian-lib/dist/styles.css}.\n */\nexport class SettingsTabs {\n  /**\n   * The panel the selected tab renders into.\n   */\n  public readonly panelEl: HTMLElement;\n\n  /**\n   * The row of tab buttons.\n   */\n  public readonly tabBarEl: HTMLElement;\n\n  private changeCallback?: (tabId: string) => void;\n  private readonly entries: SettingsTabEntry[] = [];\n  private selectedTabId: null | string = null;\n\n  /**\n   * Creates new settings tabs.\n   *\n   * @param containerEl - The container element.\n   */\n  public constructor(containerEl: HTMLElement) {\n    addPluginCssClasses(containerEl, CssClass.SettingsTabs);\n    this.tabBarEl = containerEl.createDiv({ attr: { role: 'tablist' }, cls: 'settings-tabs-bar' });\n    this.tabBarEl.addEventListener('keydown', this.onKeyDown.bind(this));\n    this.panelEl = containerEl.createDiv({ attr: { role: 'tabpanel' }, cls: 'settings-tabs-panel' });\n  }\n\n  /**\n   * Adds a tab. The first tab added is selected.\n   *\n   * @param tab - The tab.\n   * @returns The tabs.\n   * @throws If a tab with the same id was already added.\n   */\n  public addTab(tab: SettingsTab): this {\n    if (this.findEntry(tab.id)) {\n      throw new Error(`A settings tab with the id ${tab.id} was already added.`);\n    }\n    const buttonEl = this.tabBarEl.createEl('button', { attr: { 'aria-selected': 'false', 'role': 'tab', 'tabindex': '-1' }, cls: 'settings-tabs-button' });\n    if (tab.icon) {\n      setIcon(buttonEl.createSpan({ cls: 'settings-tabs-icon' }), tab.icon);\n    }\n    buttonEl.createSpan({ text: tab.name });\n    buttonEl.addEventListener('click', () => {\n      this.selectTab(tab.id);\n    });\n    this.entries.push({ buttonEl, tab });\n    if (this.selectedTabId === null) {\n      this.selectTab(tab.id);\n    }\n    return this;\n  }\n\n  /**\n   * Gets the id of the selected tab.\n   *\n   * @returns The id, or `null` before any tab is added.\n   */\n  public getSelectedTabId(): null | string {\n    return this.selectedTabId;\n  }\n\n  /**\n   * Sets the callback to be called when the user selects another tab.\n   *\n   * @param callback - The callback, given the id of the selected tab.\n   * @returns The tabs.\n   */\n  public onTabChange(callback: (tabId: string) => void): this {\n    this.changeCallback = callback;\n    return this;\n  }\n\n  /**\n   * Selects a tab and renders it into the panel. An unknown id, such as a stored id whose tab was since removed, leaves\n   * the selection as it is.\n   *\n   * @param tabId - The id of the tab.\n   * @returns The tabs.\n   */\n  public selectTab(tabId: null | string | undefined): this {\n    const entry = this.findEntry(tabId);\n    if (!entry) {\n      return this;\n    }\n    const { tab } = entry;\n    const isChange = this.selectedTabId !== null && this.selectedTabId !== tab.id;\n    this.selectedTabId = tab.id;\n    for (const { buttonEl, tab: candidate } of this.entries) {\n      const isSelected = candidate === tab;\n      buttonEl.toggleClass(CssClass.IsActive, isSelected);\n      buttonEl.setAttribute('aria-selected', String(isSelected));\n      buttonEl.setAttribute('tabindex', isSelected ? '0' : '-1');\n    }\n    this.panelEl.empty();\n    tab.render(this.panelEl);\n    if (isChange) {\n      this.changeCallback?.(tab.id);\n    }\n    return this;\n  }\n\n  private findEntry(tabId: null | string | undefined): null | SettingsTabEntry {\n    return this.entries.find((entry) => entry.tab.id === tabId) ?? null;\n  }\n\n  private onKeyDown(event_: KeyboardEvent): void {\n    const count = this.entries.length;\n    const index = this.entries.findIndex((entry) => entry.tab.id === this.selectedTabId);\n    let nextIndex: number;\n    switch (event_.key) {\n      case 'ArrowLeft': {\n        nextIndex = (index - 1 + count) % count;\n        break;\n      }\n      case 'ArrowRight': {\n        nextIndex = (index + 1) % count;\n        break;\n      }\n      case 'End': {\n        nextIndex = count - 1;\n        break;\n      }\n      case 'Home': {\n        nextIndex = 0;\n        break;\n      }\n      default: {\n        return;\n      }\n    }\n    const nextEntry = this.entries[nextIndex];\n    if (!nextEntry) {\n      return;\n    }\n    event_.preventDefault();\n    this.selectTab(nextEntry.tab.id);\n    nextEntry.buttonEl.focus();\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/templater.d.mts

@@ -35,6 +35,7 @@
  */
 import type { App, TFile } from 'obsidian';
 import type { PathOrFile } from './file-system.mjs';
+import type { ThirdPartyPluginAdapter } from './plugin/third-party-plugin.mjs';
 import { AppActiveFileProvider } from './active-file-provider.mjs';
 /**
  * Parameters for {@link getTemplaterFunctions}.
@@ -282,3 +283,8 @@ export declare function requireTemplaterApi(app: App): TemplaterApi;
  * @returns The internal API, or `null` when `Templater` is not there to talk to.
  */
 export declare function resolveTemplaterApi(app: App): null | TemplaterApi;
+/**
+ * The {@link ThirdPartyPluginAdapter} of `Templater`, for `watchThirdPartyPluginApi`, the waits and
+ * `createThirdPartyPluginDependency`. It reads `plugin.templater` and verifies the members this module calls.
+ */
+export declare const TEMPLATER_PLUGIN_ADAPTER: ThirdPartyPluginAdapter<TemplaterApi>;

package/dist/lib/esm/templater.mjs

@@ -108,7 +108,15 @@ function requireTemplaterApi(app) {
 }
 function resolveTemplaterApi(app) {
   const plugin = app.plugins.getPlugin(TEMPLATER_PLUGIN_ID);
-  if (!plugin || !("templater" in plugin)) {
+  return plugin ? getTemplaterApiFromPlugin(plugin) : null;
+}
+const TEMPLATER_PLUGIN_ADAPTER = {
+  getApi: getTemplaterApiFromPlugin,
+  pluginId: TEMPLATER_PLUGIN_ID,
+  pluginName: "Templater"
+};
+function getTemplaterApiFromPlugin(plugin) {
+  if (!("templater" in plugin)) {
     return null;
   }
   const templater = plugin.templater;
@@ -123,6 +131,7 @@ function isTemplaterApi(value) {
   return typeof functionsGenerator === "object" && functionsGenerator !== null && "generate_object" in functionsGenerator && typeof functionsGenerator.generate_object === "function";
 }
 export {
+  TEMPLATER_PLUGIN_ADAPTER,
   TEMPLATER_PLUGIN_ID,
   TemplaterActiveFileProvider,
   TemplaterRunMode,
@@ -134,4 +143,4 @@ export {
   requireTemplaterApi,
   resolveTemplaterApi
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/templater.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The slice of `Templater`'s INTERNAL API this library talks to, and the runtime narrowing that gets hold\n * of it.\n *\n * **`Templater` publishes no API.** Rendering a template against a file and getting the resulting string\n * back is only reachable through undocumented internals hanging off\n * `app.plugins.getPlugin('templater-obsidian').templater` \u2014 `create_running_config`,\n * `functions_generator.generate_object`, `read_and_parse_template`, and a `RunMode` enum. Every plugin\n * that wants it re-derives the same reverse engineering, which is why it lives here instead.\n *\n * **This module is explicitly BEST-EFFORT.** Nothing it binds to is documented or covered by `Templater`'s\n * semantic versioning, so a `Templater` release may rename or reshape any of it without warning. The shapes\n * below were read from `Templater` `2.24.3`. Two deliberate consequences follow:\n *\n * - {@link resolveTemplaterApi} returns `null` \u2014 a `Templater` too old, too new or too broken to talk to\n *   reads as \"not there\" and the integration stays dormant.\n * - {@link requireTemplaterApi} throws a {@link TemplaterUnavailableError} that NAMES the plugin and the\n *   reason, rather than letting a `Cannot read properties of undefined` surface from somewhere inside\n *   `Templater`.\n *\n * The types are DECLARED HERE rather than imported, and narrowed to the members actually called: `Templater`\n * ships no npm types package, and depending on it would turn an optional integration into a build-time\n * dependency.\n *\n * The second thing this module supplies is an active-file answer. While a template renders,\n * `app.workspace.getActiveFile()` still points at whatever the user happens to have open \u2014 NOT at the file\n * the template is being rendered for \u2014 so a plugin's own helper called from inside a template resolves\n * links against the wrong note. {@link TemplaterActiveFileProvider} answers with the render target for the\n * duration of a {@link parseTemplate} call and falls back to the workspace otherwise. Note this is about\n * the CONSUMER's helpers: `Templater`'s own `tp.file.*` already resolves through the running config's\n * `target_file` and needs no help.\n */\n\nimport type {\n  App,\n  TFile\n} from 'obsidian';\n\nimport type { PathOrFile } from './file-system.ts';\n\nimport { AppActiveFileProvider } from './active-file-provider.ts';\nimport { getFile } from './file-system.ts';\n\n/**\n * Parameters for {@link getTemplaterFunctions}.\n */\nexport interface GetTemplaterFunctionsParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * Whether to return `Templater`'s `current_functions_object` when it already has one, instead of\n   * generating a fresh object. Reuse is cheaper and gives the object of the render currently in flight;\n   * pass `false` to force a new one built for `targetPathOrFile`.\n   *\n   * @default `true`\n   */\n  readonly shouldReuseCurrent?: boolean;\n\n  /**\n   * The file the generated functions should resolve against \u2014 what `tp.file.*` reports.\n   */\n  readonly targetPathOrFile: PathOrFile;\n}\n\n/**\n * Parameters for {@link parseTemplate}.\n */\nexport interface ParseTemplateParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The file the template is rendered FOR. It is what `tp.file.*` resolves to inside the template, and\n   * what {@link TemplaterActiveFileProvider} reports for the duration of the call.\n   */\n  readonly targetPathOrFile: PathOrFile;\n\n  /**\n   * The template file to render.\n   */\n  readonly templatePathOrFile: PathOrFile;\n}\n\n/**\n * `Templater`'s internal API object, narrowed to the members this library calls.\n *\n * Its members are `snake_case` because `Templater`'s are; they are transcribed rather than renamed so the\n * shape can be checked against `Templater`'s source at a glance.\n */\nexport interface TemplaterApi {\n  /**\n   * Builds the {@link TemplaterRunningConfig} that describes one render.\n   *\n   * @param templateFile - The template being rendered, or `undefined` when there is none (as when only\n   * the functions object is wanted).\n   * @param targetFile - The file the render is for.\n   * @param runMode - Which {@link TemplaterRunMode} the render is.\n   * @returns The running config.\n   */\n  readonly create_running_config: (templateFile: TFile | undefined, targetFile: TFile, runMode: TemplaterRunMode) => TemplaterRunningConfig;\n\n  /**\n   * The functions object (`tp`) of the render currently in flight, when there is one.\n   */\n  readonly current_functions_object?: object | undefined;\n\n  /**\n   * Builds the functions object (`tp`) a template is evaluated against.\n   */\n  readonly functions_generator: TemplaterFunctionsGenerator;\n\n  /**\n   * Reads the config's `template_file` and renders it, returning the resulting text.\n   *\n   * @param config - The {@link TemplaterRunningConfig} describing the render. `Templater` throws when its\n   * `template_file` is not a `TFile`.\n   * @returns A {@link Promise} resolving to the rendered text.\n   */\n  readonly read_and_parse_template: (config: TemplaterRunningConfig) => Promise<string>;\n}\n\n/**\n * The `functions_generator` half of {@link TemplaterApi}.\n */\nexport interface TemplaterFunctionsGenerator {\n  /**\n   * Builds the functions object (`tp`) for a running config.\n   *\n   * @param config - The {@link TemplaterRunningConfig} to build for.\n   * @returns A {@link Promise} resolving to the functions object.\n   */\n  readonly generate_object: (config: TemplaterRunningConfig) => Promise<object>;\n}\n\n/**\n * One `Templater` render, as `Templater`'s `create_running_config` describes it.\n *\n * Its members are `snake_case` because `Templater`'s are.\n */\nexport interface TemplaterRunningConfig {\n  /**\n   * The file `Templater` considers active. `Templater` fills this in itself from\n   * `workspace.activeEditor?.file ?? workspace.getActiveFile()`; it is optional here because a\n   * hand-built config may omit it.\n   */\n  readonly active_file?: null | TFile | undefined;\n\n  /**\n   * Which {@link TemplaterRunMode} the render is.\n   */\n  readonly run_mode: TemplaterRunMode;\n\n  /**\n   * The file the render is for \u2014 what `tp.file.*` resolves to.\n   */\n  readonly target_file: TFile;\n\n  /**\n   * The template being rendered, when there is one.\n   */\n  readonly template_file?: TFile | undefined;\n}\n\n/**\n * `Templater`'s plugin id, as its manifest declares it.\n */\nexport const TEMPLATER_PLUGIN_ID = 'templater-obsidian';\n\n/* eslint-disable no-magic-numbers -- These are `Templater`'s own `RunMode` values, transcribed. */\n/**\n * `Templater`'s `RunMode` enum, which says what kind of render a {@link TemplaterRunningConfig} describes.\n *\n * The numeric values ARE `Templater`'s, and the members are listed in its declaration order so the two can\n * be compared line for line. They are written out explicitly all the same, because they cross into\n * `Templater` as integers \u2014 never renumber them.\n */\nexport enum TemplaterRunMode {\n  /**\n   * Render the template into a newly created file.\n   */\n  CreateNewFromTemplate = 0,\n\n  /**\n   * Render the template and append the result to the active file.\n   */\n  AppendActiveFile = 1,\n\n  /**\n   * Render the template and overwrite a given file with the result.\n   */\n  OverwriteFile = 2,\n\n  /**\n   * Render the template and overwrite the active file with the result.\n   */\n  OverwriteActiveFile = 3,\n\n  /**\n   * Render the template on demand, for a caller that wants the resulting text rather than a file\n   * written. This is what {@link parseTemplate} uses.\n   */\n  DynamicProcessor = 4,\n\n  /**\n   * Render the template as a startup template. {@link getTemplaterFunctions} uses it for the throwaway\n   * config it builds, because that config renders nothing.\n   */\n  StartupTemplate = 5\n}\n/* eslint-enable no-magic-numbers -- These are `Templater`'s own `RunMode` values, transcribed. */\n\n/**\n * Why `Templater`'s internal API could not be handed over.\n */\nexport enum TemplaterUnavailabilityReason {\n  /**\n   * `Templater` is not installed, or is installed but disabled. Obsidian's `getPlugin` cannot tell the two\n   * apart \u2014 it returns nothing either way.\n   */\n  NotLoaded = 'notLoaded',\n\n  /**\n   * `Templater` is loaded, but does not expose the internals this library calls \u2014 it is too old, too new,\n   * or has been reshaped.\n   */\n  ShapeChanged = 'shapeChanged'\n}\n\n/**\n * Active-file provider that answers with the file a {@link parseTemplate} render is currently for,\n * falling back to the workspace's active file when no render is in flight.\n *\n * This is the piece that makes a consumer's own template helpers resolve against the right note: during a\n * render the workspace still has whatever the user was looking at open, which is rarely the target.\n */\nexport class TemplaterActiveFileProvider extends AppActiveFileProvider {\n  /**\n   * Gets the file the innermost in-flight {@link parseTemplate} render is for, or the workspace's active\n   * file when there is no render in flight.\n   *\n   * @returns The active file, or `null` if there is none.\n   */\n  public override getActiveFile(): null | TFile {\n    return getTemplaterRenderTargetFile() ?? super.getActiveFile();\n  }\n}\n\n/**\n * Thrown when `Templater`'s internal API cannot be handed over, carrying the\n * {@link TemplaterUnavailabilityReason} that says why.\n */\nexport class TemplaterUnavailableError extends Error {\n  /**\n   * Which of the two failures occurred.\n   */\n  public readonly reason: TemplaterUnavailabilityReason;\n\n  /**\n   * Creates a {@link TemplaterUnavailableError}.\n   *\n   * @param reason - Why the API is unavailable.\n   */\n  public constructor(reason: TemplaterUnavailabilityReason) {\n    super(`The internal API of the plugin \"${TEMPLATER_PLUGIN_ID}\" is unavailable: ${reason}.`);\n    this.name = 'TemplaterUnavailableError';\n    this.reason = reason;\n  }\n}\n\n/**\n * Gets `Templater`'s functions object \u2014 the `tp` a template is evaluated against \u2014 so a caller can invoke\n * `tp.date.now()`, `tp.file.title` and the rest outside a template.\n *\n * @param params - The {@link GetTemplaterFunctionsParams}.\n * @returns A {@link Promise} resolving to the functions object.\n * @throws A {@link TemplaterUnavailableError} when `Templater` is not loaded or its shape has changed.\n */\nexport async function getTemplaterFunctions(params: GetTemplaterFunctionsParams): Promise<object> {\n  const {\n    app,\n    shouldReuseCurrent = true,\n    targetPathOrFile\n  } = params;\n  const api = requireTemplaterApi(app);\n\n  if (shouldReuseCurrent && api.current_functions_object) {\n    return api.current_functions_object;\n  }\n\n  const targetFile = getFile({\n    app,\n    pathOrFile: targetPathOrFile\n  });\n  const config = api.create_running_config(undefined, targetFile, TemplaterRunMode.StartupTemplate);\n  return await api.functions_generator.generate_object(config);\n}\n\n/**\n * Gets the file the innermost in-flight {@link parseTemplate} render is for.\n *\n * Renders nest \u2014 a template may render another \u2014 so the calls form a stack and this reports the top of\n * it. Outside any render it is `null`.\n *\n * @returns The render target, or `null` when no render is in flight.\n */\nexport function getTemplaterRenderTargetFile(): null | TFile {\n  return renderTargetFiles.at(-1) ?? null;\n}\n\n/**\n * Renders a `Templater` template against a target file and returns the resulting text, without writing\n * anything.\n *\n * For the duration of the call {@link getTemplaterRenderTargetFile} and\n * {@link TemplaterActiveFileProvider} report `targetPathOrFile`, so a consumer's own helpers invoked from\n * inside the template resolve against it rather than against whatever the user has open.\n *\n * @param params - The {@link ParseTemplateParams}.\n * @returns A {@link Promise} resolving to the rendered text.\n * @throws A {@link TemplaterUnavailableError} when `Templater` is not loaded or its shape has changed.\n */\nexport async function parseTemplate(params: ParseTemplateParams): Promise<string> {\n  const {\n    app,\n    targetPathOrFile,\n    templatePathOrFile\n  } = params;\n  const templateFile = getFile({\n    app,\n    pathOrFile: templatePathOrFile\n  });\n  const targetFile = getFile({\n    app,\n    pathOrFile: targetPathOrFile\n  });\n  const api = requireTemplaterApi(app);\n\n  renderTargetFiles.push(targetFile);\n  try {\n    return await api.read_and_parse_template({\n      // eslint-disable-next-line camelcase -- `Templater` API.\n      run_mode: TemplaterRunMode.DynamicProcessor,\n      // eslint-disable-next-line camelcase -- `Templater` API.\n      target_file: targetFile,\n      // eslint-disable-next-line camelcase -- `Templater` API.\n      template_file: templateFile\n    });\n  } finally {\n    renderTargetFiles.pop();\n  }\n}\n\n/**\n * Gets `Templater`'s internal API, throwing when it cannot be had.\n *\n * Use this where the caller cannot carry on without `Templater` \u2014 the error names the plugin and says which\n * of the two failures occurred. Use {@link resolveTemplaterApi} instead where the integration is optional.\n *\n * @param app - The Obsidian app instance.\n * @returns `Templater`'s internal API.\n * @throws A {@link TemplaterUnavailableError} when `Templater` is not loaded or its shape has changed.\n */\nexport function requireTemplaterApi(app: App): TemplaterApi {\n  if (!app.plugins.getPlugin(TEMPLATER_PLUGIN_ID)) {\n    throw new TemplaterUnavailableError(TemplaterUnavailabilityReason.NotLoaded);\n  }\n\n  const api = resolveTemplaterApi(app);\n  if (!api) {\n    throw new TemplaterUnavailableError(TemplaterUnavailabilityReason.ShapeChanged);\n  }\n\n  return api;\n}\n\n/**\n * Gets `Templater`'s internal API, when `Templater` is installed, enabled and still the shape this library\n * expects.\n *\n * @param app - The Obsidian app instance.\n * @returns The internal API, or `null` when `Templater` is not there to talk to.\n */\nexport function resolveTemplaterApi(app: App): null | TemplaterApi {\n  const plugin = app.plugins.getPlugin(TEMPLATER_PLUGIN_ID);\n  if (!plugin || !('templater' in plugin)) {\n    return null;\n  }\n\n  const templater: unknown = plugin.templater;\n  return isTemplaterApi(templater) ? templater : null;\n}\n\n/*\n * The stack of files in-flight `parseTemplate` calls are rendering for, innermost last. A stack rather\n * than a single slot because a template may render another, and an array rather than a reassigned\n * variable because pushing and popping a `const` needs no write to an outer binding across an `await`.\n */\nconst renderTargetFiles: TFile[] = [];\n\n/**\n * Checks that a value is `Templater`'s internal API, by the members this library actually calls.\n *\n * A predicate rather than a cast on purpose: `templater` is not part of Obsidian's `Plugin` type, so the\n * value arrives as `unknown` and the only honest way to type it is to VERIFY it. A `Templater` that renames\n * one of these therefore reads as \"not there\", instead of throwing from inside a render.\n *\n * @param value - The candidate `templater` object.\n * @returns Whether it carries every member this library calls.\n */\nfunction isTemplaterApi(value: unknown): value is TemplaterApi {\n  if (typeof value !== 'object' || value === null || !('create_running_config' in value) || typeof value.create_running_config !== 'function' || !('read_and_parse_template' in value) || typeof value.read_and_parse_template !== 'function' || !('functions_generator' in value)) {\n    return false;\n  }\n\n  const functionsGenerator: unknown = value.functions_generator;\n  return typeof functionsGenerator === 'object' && functionsGenerator !== null && 'generate_object' in functionsGenerator && typeof functionsGenerator.generate_object === 'function';\n}\n"],
  "mappings": "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",
  "names": ["TemplaterRunMode", "TemplaterUnavailabilityReason"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/templater.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The slice of `Templater`'s INTERNAL API this library talks to, and the runtime narrowing that gets hold\n * of it.\n *\n * **`Templater` publishes no API.** Rendering a template against a file and getting the resulting string\n * back is only reachable through undocumented internals hanging off\n * `app.plugins.getPlugin('templater-obsidian').templater` \u2014 `create_running_config`,\n * `functions_generator.generate_object`, `read_and_parse_template`, and a `RunMode` enum. Every plugin\n * that wants it re-derives the same reverse engineering, which is why it lives here instead.\n *\n * **This module is explicitly BEST-EFFORT.** Nothing it binds to is documented or covered by `Templater`'s\n * semantic versioning, so a `Templater` release may rename or reshape any of it without warning. The shapes\n * below were read from `Templater` `2.24.3`. Two deliberate consequences follow:\n *\n * - {@link resolveTemplaterApi} returns `null` \u2014 a `Templater` too old, too new or too broken to talk to\n *   reads as \"not there\" and the integration stays dormant.\n * - {@link requireTemplaterApi} throws a {@link TemplaterUnavailableError} that NAMES the plugin and the\n *   reason, rather than letting a `Cannot read properties of undefined` surface from somewhere inside\n *   `Templater`.\n *\n * The types are DECLARED HERE rather than imported, and narrowed to the members actually called: `Templater`\n * ships no npm types package, and depending on it would turn an optional integration into a build-time\n * dependency.\n *\n * The second thing this module supplies is an active-file answer. While a template renders,\n * `app.workspace.getActiveFile()` still points at whatever the user happens to have open \u2014 NOT at the file\n * the template is being rendered for \u2014 so a plugin's own helper called from inside a template resolves\n * links against the wrong note. {@link TemplaterActiveFileProvider} answers with the render target for the\n * duration of a {@link parseTemplate} call and falls back to the workspace otherwise. Note this is about\n * the CONSUMER's helpers: `Templater`'s own `tp.file.*` already resolves through the running config's\n * `target_file` and needs no help.\n */\n\nimport type {\n  App,\n  Plugin,\n  TFile\n} from 'obsidian';\n\nimport type { PathOrFile } from './file-system.ts';\nimport type { ThirdPartyPluginAdapter } from './plugin/third-party-plugin.ts';\n\nimport { AppActiveFileProvider } from './active-file-provider.ts';\nimport { getFile } from './file-system.ts';\n\n/**\n * Parameters for {@link getTemplaterFunctions}.\n */\nexport interface GetTemplaterFunctionsParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * Whether to return `Templater`'s `current_functions_object` when it already has one, instead of\n   * generating a fresh object. Reuse is cheaper and gives the object of the render currently in flight;\n   * pass `false` to force a new one built for `targetPathOrFile`.\n   *\n   * @default `true`\n   */\n  readonly shouldReuseCurrent?: boolean;\n\n  /**\n   * The file the generated functions should resolve against \u2014 what `tp.file.*` reports.\n   */\n  readonly targetPathOrFile: PathOrFile;\n}\n\n/**\n * Parameters for {@link parseTemplate}.\n */\nexport interface ParseTemplateParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The file the template is rendered FOR. It is what `tp.file.*` resolves to inside the template, and\n   * what {@link TemplaterActiveFileProvider} reports for the duration of the call.\n   */\n  readonly targetPathOrFile: PathOrFile;\n\n  /**\n   * The template file to render.\n   */\n  readonly templatePathOrFile: PathOrFile;\n}\n\n/**\n * `Templater`'s internal API object, narrowed to the members this library calls.\n *\n * Its members are `snake_case` because `Templater`'s are; they are transcribed rather than renamed so the\n * shape can be checked against `Templater`'s source at a glance.\n */\nexport interface TemplaterApi {\n  /**\n   * Builds the {@link TemplaterRunningConfig} that describes one render.\n   *\n   * @param templateFile - The template being rendered, or `undefined` when there is none (as when only\n   * the functions object is wanted).\n   * @param targetFile - The file the render is for.\n   * @param runMode - Which {@link TemplaterRunMode} the render is.\n   * @returns The running config.\n   */\n  readonly create_running_config: (templateFile: TFile | undefined, targetFile: TFile, runMode: TemplaterRunMode) => TemplaterRunningConfig;\n\n  /**\n   * The functions object (`tp`) of the render currently in flight, when there is one.\n   */\n  readonly current_functions_object?: object | undefined;\n\n  /**\n   * Builds the functions object (`tp`) a template is evaluated against.\n   */\n  readonly functions_generator: TemplaterFunctionsGenerator;\n\n  /**\n   * Reads the config's `template_file` and renders it, returning the resulting text.\n   *\n   * @param config - The {@link TemplaterRunningConfig} describing the render. `Templater` throws when its\n   * `template_file` is not a `TFile`.\n   * @returns A {@link Promise} resolving to the rendered text.\n   */\n  readonly read_and_parse_template: (config: TemplaterRunningConfig) => Promise<string>;\n}\n\n/**\n * The `functions_generator` half of {@link TemplaterApi}.\n */\nexport interface TemplaterFunctionsGenerator {\n  /**\n   * Builds the functions object (`tp`) for a running config.\n   *\n   * @param config - The {@link TemplaterRunningConfig} to build for.\n   * @returns A {@link Promise} resolving to the functions object.\n   */\n  readonly generate_object: (config: TemplaterRunningConfig) => Promise<object>;\n}\n\n/**\n * One `Templater` render, as `Templater`'s `create_running_config` describes it.\n *\n * Its members are `snake_case` because `Templater`'s are.\n */\nexport interface TemplaterRunningConfig {\n  /**\n   * The file `Templater` considers active. `Templater` fills this in itself from\n   * `workspace.activeEditor?.file ?? workspace.getActiveFile()`; it is optional here because a\n   * hand-built config may omit it.\n   */\n  readonly active_file?: null | TFile | undefined;\n\n  /**\n   * Which {@link TemplaterRunMode} the render is.\n   */\n  readonly run_mode: TemplaterRunMode;\n\n  /**\n   * The file the render is for \u2014 what `tp.file.*` resolves to.\n   */\n  readonly target_file: TFile;\n\n  /**\n   * The template being rendered, when there is one.\n   */\n  readonly template_file?: TFile | undefined;\n}\n\n/**\n * `Templater`'s plugin id, as its manifest declares it.\n */\nexport const TEMPLATER_PLUGIN_ID = 'templater-obsidian';\n\n/* eslint-disable no-magic-numbers -- These are `Templater`'s own `RunMode` values, transcribed. */\n/**\n * `Templater`'s `RunMode` enum, which says what kind of render a {@link TemplaterRunningConfig} describes.\n *\n * The numeric values ARE `Templater`'s, and the members are listed in its declaration order so the two can\n * be compared line for line. They are written out explicitly all the same, because they cross into\n * `Templater` as integers \u2014 never renumber them.\n */\nexport enum TemplaterRunMode {\n  /**\n   * Render the template into a newly created file.\n   */\n  CreateNewFromTemplate = 0,\n\n  /**\n   * Render the template and append the result to the active file.\n   */\n  AppendActiveFile = 1,\n\n  /**\n   * Render the template and overwrite a given file with the result.\n   */\n  OverwriteFile = 2,\n\n  /**\n   * Render the template and overwrite the active file with the result.\n   */\n  OverwriteActiveFile = 3,\n\n  /**\n   * Render the template on demand, for a caller that wants the resulting text rather than a file\n   * written. This is what {@link parseTemplate} uses.\n   */\n  DynamicProcessor = 4,\n\n  /**\n   * Render the template as a startup template. {@link getTemplaterFunctions} uses it for the throwaway\n   * config it builds, because that config renders nothing.\n   */\n  StartupTemplate = 5\n}\n/* eslint-enable no-magic-numbers -- These are `Templater`'s own `RunMode` values, transcribed. */\n\n/**\n * Why `Templater`'s internal API could not be handed over.\n */\nexport enum TemplaterUnavailabilityReason {\n  /**\n   * `Templater` is not installed, or is installed but disabled. Obsidian's `getPlugin` cannot tell the two\n   * apart \u2014 it returns nothing either way.\n   */\n  NotLoaded = 'notLoaded',\n\n  /**\n   * `Templater` is loaded, but does not expose the internals this library calls \u2014 it is too old, too new,\n   * or has been reshaped.\n   */\n  ShapeChanged = 'shapeChanged'\n}\n\n/**\n * Active-file provider that answers with the file a {@link parseTemplate} render is currently for,\n * falling back to the workspace's active file when no render is in flight.\n *\n * This is the piece that makes a consumer's own template helpers resolve against the right note: during a\n * render the workspace still has whatever the user was looking at open, which is rarely the target.\n */\nexport class TemplaterActiveFileProvider extends AppActiveFileProvider {\n  /**\n   * Gets the file the innermost in-flight {@link parseTemplate} render is for, or the workspace's active\n   * file when there is no render in flight.\n   *\n   * @returns The active file, or `null` if there is none.\n   */\n  public override getActiveFile(): null | TFile {\n    return getTemplaterRenderTargetFile() ?? super.getActiveFile();\n  }\n}\n\n/**\n * Thrown when `Templater`'s internal API cannot be handed over, carrying the\n * {@link TemplaterUnavailabilityReason} that says why.\n */\nexport class TemplaterUnavailableError extends Error {\n  /**\n   * Which of the two failures occurred.\n   */\n  public readonly reason: TemplaterUnavailabilityReason;\n\n  /**\n   * Creates a {@link TemplaterUnavailableError}.\n   *\n   * @param reason - Why the API is unavailable.\n   */\n  public constructor(reason: TemplaterUnavailabilityReason) {\n    super(`The internal API of the plugin \"${TEMPLATER_PLUGIN_ID}\" is unavailable: ${reason}.`);\n    this.name = 'TemplaterUnavailableError';\n    this.reason = reason;\n  }\n}\n\n/**\n * Gets `Templater`'s functions object \u2014 the `tp` a template is evaluated against \u2014 so a caller can invoke\n * `tp.date.now()`, `tp.file.title` and the rest outside a template.\n *\n * @param params - The {@link GetTemplaterFunctionsParams}.\n * @returns A {@link Promise} resolving to the functions object.\n * @throws A {@link TemplaterUnavailableError} when `Templater` is not loaded or its shape has changed.\n */\nexport async function getTemplaterFunctions(params: GetTemplaterFunctionsParams): Promise<object> {\n  const {\n    app,\n    shouldReuseCurrent = true,\n    targetPathOrFile\n  } = params;\n  const api = requireTemplaterApi(app);\n\n  if (shouldReuseCurrent && api.current_functions_object) {\n    return api.current_functions_object;\n  }\n\n  const targetFile = getFile({\n    app,\n    pathOrFile: targetPathOrFile\n  });\n  const config = api.create_running_config(undefined, targetFile, TemplaterRunMode.StartupTemplate);\n  return await api.functions_generator.generate_object(config);\n}\n\n/**\n * Gets the file the innermost in-flight {@link parseTemplate} render is for.\n *\n * Renders nest \u2014 a template may render another \u2014 so the calls form a stack and this reports the top of\n * it. Outside any render it is `null`.\n *\n * @returns The render target, or `null` when no render is in flight.\n */\nexport function getTemplaterRenderTargetFile(): null | TFile {\n  return renderTargetFiles.at(-1) ?? null;\n}\n\n/**\n * Renders a `Templater` template against a target file and returns the resulting text, without writing\n * anything.\n *\n * For the duration of the call {@link getTemplaterRenderTargetFile} and\n * {@link TemplaterActiveFileProvider} report `targetPathOrFile`, so a consumer's own helpers invoked from\n * inside the template resolve against it rather than against whatever the user has open.\n *\n * @param params - The {@link ParseTemplateParams}.\n * @returns A {@link Promise} resolving to the rendered text.\n * @throws A {@link TemplaterUnavailableError} when `Templater` is not loaded or its shape has changed.\n */\nexport async function parseTemplate(params: ParseTemplateParams): Promise<string> {\n  const {\n    app,\n    targetPathOrFile,\n    templatePathOrFile\n  } = params;\n  const templateFile = getFile({\n    app,\n    pathOrFile: templatePathOrFile\n  });\n  const targetFile = getFile({\n    app,\n    pathOrFile: targetPathOrFile\n  });\n  const api = requireTemplaterApi(app);\n\n  renderTargetFiles.push(targetFile);\n  try {\n    return await api.read_and_parse_template({\n      // eslint-disable-next-line camelcase -- `Templater` API.\n      run_mode: TemplaterRunMode.DynamicProcessor,\n      // eslint-disable-next-line camelcase -- `Templater` API.\n      target_file: targetFile,\n      // eslint-disable-next-line camelcase -- `Templater` API.\n      template_file: templateFile\n    });\n  } finally {\n    renderTargetFiles.pop();\n  }\n}\n\n/**\n * Gets `Templater`'s internal API, throwing when it cannot be had.\n *\n * Use this where the caller cannot carry on without `Templater` \u2014 the error names the plugin and says which\n * of the two failures occurred. Use {@link resolveTemplaterApi} instead where the integration is optional.\n *\n * @param app - The Obsidian app instance.\n * @returns `Templater`'s internal API.\n * @throws A {@link TemplaterUnavailableError} when `Templater` is not loaded or its shape has changed.\n */\nexport function requireTemplaterApi(app: App): TemplaterApi {\n  if (!app.plugins.getPlugin(TEMPLATER_PLUGIN_ID)) {\n    throw new TemplaterUnavailableError(TemplaterUnavailabilityReason.NotLoaded);\n  }\n\n  const api = resolveTemplaterApi(app);\n  if (!api) {\n    throw new TemplaterUnavailableError(TemplaterUnavailabilityReason.ShapeChanged);\n  }\n\n  return api;\n}\n\n/**\n * Gets `Templater`'s internal API, when `Templater` is installed, enabled and still the shape this library\n * expects.\n *\n * @param app - The Obsidian app instance.\n * @returns The internal API, or `null` when `Templater` is not there to talk to.\n */\nexport function resolveTemplaterApi(app: App): null | TemplaterApi {\n  const plugin = app.plugins.getPlugin(TEMPLATER_PLUGIN_ID);\n  return plugin ? getTemplaterApiFromPlugin(plugin) : null;\n}\n\n/**\n * The {@link ThirdPartyPluginAdapter} of `Templater`, for `watchThirdPartyPluginApi`, the waits and\n * `createThirdPartyPluginDependency`. It reads `plugin.templater` and verifies the members this module calls.\n */\nexport const TEMPLATER_PLUGIN_ADAPTER: ThirdPartyPluginAdapter<TemplaterApi> = {\n  getApi: getTemplaterApiFromPlugin,\n  pluginId: TEMPLATER_PLUGIN_ID,\n  pluginName: 'Templater'\n};\n\nfunction getTemplaterApiFromPlugin(plugin: Plugin): null | TemplaterApi {\n  if (!('templater' in plugin)) {\n    return null;\n  }\n\n  const templater: unknown = plugin.templater;\n  return isTemplaterApi(templater) ? templater : null;\n}\n\n/*\n * The stack of files in-flight `parseTemplate` calls are rendering for, innermost last. A stack rather\n * than a single slot because a template may render another, and an array rather than a reassigned\n * variable because pushing and popping a `const` needs no write to an outer binding across an `await`.\n */\nconst renderTargetFiles: TFile[] = [];\n\n/**\n * Checks that a value is `Templater`'s internal API, by the members this library actually calls.\n *\n * A predicate rather than a cast on purpose: `templater` is not part of Obsidian's `Plugin` type, so the\n * value arrives as `unknown` and the only honest way to type it is to VERIFY it. A `Templater` that renames\n * one of these therefore reads as \"not there\", instead of throwing from inside a render.\n *\n * @param value - The candidate `templater` object.\n * @returns Whether it carries every member this library calls.\n */\nfunction isTemplaterApi(value: unknown): value is TemplaterApi {\n  if (typeof value !== 'object' || value === null || !('create_running_config' in value) || typeof value.create_running_config !== 'function' || !('read_and_parse_template' in value) || typeof value.read_and_parse_template !== 'function' || !('functions_generator' in value)) {\n    return false;\n  }\n\n  const functionsGenerator: unknown = value.functions_generator;\n  return typeof functionsGenerator === 'object' && functionsGenerator !== null && 'generate_object' in functionsGenerator && typeof functionsGenerator.generate_object === 'function';\n}\n"],
  "mappings": "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",
  "names": ["TemplaterRunMode", "TemplaterUnavailabilityReason"]
}
