@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/esm/components/registry-component.mjs

@@ -0,0 +1,90 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+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;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import { ComponentEx } from "./component-ex.mjs";
+class RegistryComponent extends ComponentEx {
+  /**
+   * Get the single child of the given type.
+   *
+   * @typeParam TComponent - The type of component to get.
+   * @param componentClass - The class of the component to get.
+   * @returns The single registered child of the given type.
+   */
+  getChild(componentClass) {
+    const child = this.getChildOrNull(componentClass);
+    if (child) {
+      return child;
+    }
+    throw new Error(`No instance of ${componentClass.name} registered`);
+  }
+  /**
+   * Get the single child of the given type.
+   *
+   * @typeParam TComponent - The type of component to get.
+   * @param componentClass - The class of the component to get.
+   * @returns The single registered child of the given type, or `null` if none are registered.
+   */
+  getChildOrNull(componentClass) {
+    const children = this.getChildren(componentClass);
+    if (children.length === 0) {
+      return null;
+    }
+    if (children.length === 1) {
+      return ensureNonNullable(children[0]);
+    }
+    throw new Error(`Multiple instances of ${componentClass.name} registered`);
+  }
+  /**
+   * Get all children of the given type.
+   *
+   * @typeParam TComponent - The type of component to get.
+   * @param componentClass - The class of the component to get.
+   * @returns All registered children of the given type.
+   */
+  getChildren(componentClass) {
+    return this._children.filter((child) => child instanceof componentClass);
+  }
+}
+export {
+  RegistryComponent
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/components/release-notes-component.d.mts

@@ -0,0 +1,129 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Component that shows a plugin's release notes once, when the workspace layout is ready.
+ *
+ * Several plugins hand-rolled this popup, and every copy had the same defect: it was titled only
+ * `Release notes`, over headings that are bare version numbers, so nothing in it named the plugin. A user
+ * with dozens of plugins installed could not tell whose popup it was. This component always names the
+ * plugin in the title.
+ *
+ * It also owns the wait every copy needed. The notes already shown are stored in the host's settings, and
+ * the host's settings component is a SIBLING whose own async load is still in flight when the plugin is
+ * enabled after the layout is ready. Reading the list then sees the default empty one and shows every note
+ * again, on every start. See {@link PluginSettingsComponentBase.whenLoadedFromFile}.
+ */
+import type { App } from 'obsidian';
+import type { Promisable } from 'type-fest';
+import type { PluginSettingsComponentBase } from './plugin-settings-component.mjs';
+import { ComponentEx } from './component-ex.mjs';
+/**
+ * Release notes, keyed by the semantic version that introduced each one.
+ */
+export type ReleaseNotes = Readonly<Record<string, DocumentFragment>>;
+/**
+ * Parameters for the {@link ReleaseNotesComponent} constructor.
+ */
+export interface ReleaseNotesComponentConstructorParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * Returns the versions whose notes the user has already seen.
+     *
+     * Storage belongs to the host plugin, typically as one of its settings, because this component has no
+     * `data.json` of its own and the list has to outlive a reload.
+     *
+     * Only ever called once {@link pluginSettingsComponent} reports its settings loaded, so an implementation
+     * that reads a setting reads the stored value rather than its default.
+     *
+     * @returns The versions already shown.
+     */
+    readonly getShownReleaseNoteVersions: () => readonly string[];
+    /**
+     * The display name of the plugin, shown in the popup title.
+     */
+    readonly pluginName: string;
+    /**
+     * The settings component holding whatever {@link getShownReleaseNoteVersions} reads.
+     *
+     * Taken as a whole component rather than as a bare "ready" flag, so the host cannot forget to wire the
+     * wait.
+     */
+    readonly pluginSettingsComponent: PluginSettingsComponentBase<object>;
+    /**
+     * Builds the release notes.
+     *
+     * Called at layout ready rather than at construction, so the fragments are built only when they may be
+     * shown, and a localized string is read after the host's translations are set up.
+     *
+     * Every key must be a valid semantic version. The notes are shown in ascending version order, whatever
+     * order the keys were written in.
+     *
+     * @returns The release notes.
+     */
+    readonly releaseNotesProvider: () => ReleaseNotes;
+    /**
+     * Records the versions whose notes the user has now seen.
+     *
+     * Called before the popup is shown, with the full list: the versions already shown followed by the ones
+     * about to be.
+     *
+     * @param versions - The versions shown.
+     * @returns A {@link Promise} that resolves once the list is persisted.
+     */
+    readonly setShownReleaseNoteVersions: (versions: readonly string[]) => Promisable<void>;
+    /**
+     * Decides whether the release notes may be shown now.
+     *
+     * When it returns `false`, nothing is shown and nothing is recorded, so the notes are shown at a later
+     * start once it returns `true`. Use it when the notes only make sense while some feature is on.
+     *
+     * @returns `true` when the notes may be shown.
+     * @default Always `true`.
+     */
+    readonly shouldShowReleaseNotes?: () => Promisable<boolean>;
+}
+/**
+ * Shows a plugin's release notes that the user has not seen yet, once the workspace layout is ready.
+ */
+export declare class ReleaseNotesComponent extends ComponentEx {
+    /**
+     * The Obsidian app instance.
+     */
+    protected readonly app: App;
+    /**
+     * The display name of the plugin, shown in the popup title.
+     */
+    protected readonly pluginName: string;
+    /**
+     * The settings component whose load is awaited before the shown versions are read.
+     */
+    protected readonly pluginSettingsComponent: PluginSettingsComponentBase<object>;
+    private readonly getShownReleaseNoteVersions;
+    private readonly releaseNotesProvider;
+    private readonly setShownReleaseNoteVersions;
+    private readonly shouldShowReleaseNotes;
+    /**
+     * Creates an instance of {@link ReleaseNotesComponent}.
+     *
+     * @param params - The constructor parameters.
+     */
+    constructor(params: ReleaseNotesComponentConstructorParams);
+    /**
+     * Loads the component, showing the unseen release notes once the layout is ready AND the host's settings
+     * have been read from disk.
+     */
+    onload(): void;
+    /**
+     * Shows the release notes the user has not seen yet, and records them as seen.
+     *
+     * Does nothing when {@link ReleaseNotesComponentConstructorParams.shouldShowReleaseNotes} declines, or when
+     * every note has been shown already.
+     *
+     * @returns A {@link Promise} that resolves once the popup is closed, or at once when nothing is shown.
+     */
+    protected showUnseenReleaseNotes(): Promise<void>;
+}

package/dist/lib/esm/components/release-notes-component.mjs

@@ -0,0 +1,128 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+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;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { compareVersions } from "compare-versions";
+import { t } from "../i18n/i18n.mjs";
+import { alert } from "../modals/alert.mjs";
+import { ComponentEx } from "./component-ex.mjs";
+import { CallbackLayoutReadyComponent } from "./layout-ready-component.mjs";
+class ReleaseNotesComponent extends ComponentEx {
+  /**
+   * The Obsidian app instance.
+   */
+  app;
+  /**
+   * The display name of the plugin, shown in the popup title.
+   */
+  pluginName;
+  /**
+   * The settings component whose load is awaited before the shown versions are read.
+   */
+  pluginSettingsComponent;
+  getShownReleaseNoteVersions;
+  releaseNotesProvider;
+  setShownReleaseNoteVersions;
+  shouldShowReleaseNotes;
+  /**
+   * Creates an instance of {@link ReleaseNotesComponent}.
+   *
+   * @param params - The constructor parameters.
+   */
+  constructor(params) {
+    super();
+    this.app = params.app;
+    this.getShownReleaseNoteVersions = params.getShownReleaseNoteVersions;
+    this.pluginName = params.pluginName;
+    this.pluginSettingsComponent = params.pluginSettingsComponent;
+    this.releaseNotesProvider = params.releaseNotesProvider;
+    this.setShownReleaseNoteVersions = params.setShownReleaseNoteVersions;
+    this.shouldShowReleaseNotes = params.shouldShowReleaseNotes ?? (() => true);
+  }
+  /**
+   * Loads the component, showing the unseen release notes once the layout is ready AND the host's settings
+   * have been read from disk.
+   */
+  onload() {
+    this.addChild(
+      new CallbackLayoutReadyComponent(this.app, async () => {
+        await this.pluginSettingsComponent.whenLoadedFromFile();
+        if (this.isUnloaded()) {
+          return;
+        }
+        await this.showUnseenReleaseNotes();
+      })
+    );
+  }
+  /**
+   * Shows the release notes the user has not seen yet, and records them as seen.
+   *
+   * Does nothing when {@link ReleaseNotesComponentConstructorParams.shouldShowReleaseNotes} declines, or when
+   * every note has been shown already.
+   *
+   * @returns A {@link Promise} that resolves once the popup is closed, or at once when nothing is shown.
+   */
+  async showUnseenReleaseNotes() {
+    if (!await this.shouldShowReleaseNotes()) {
+      return;
+    }
+    const shownVersions = this.getShownReleaseNoteVersions();
+    const shownVersionSet = new Set(shownVersions);
+    const unseenReleaseNotes = Object.entries(this.releaseNotesProvider()).filter(([version]) => !shownVersionSet.has(version)).sort(([version1], [version2]) => compareVersions(version1, version2));
+    if (unseenReleaseNotes.length === 0) {
+      return;
+    }
+    const message = createFragment();
+    for (const [version, releaseNote] of unseenReleaseNotes) {
+      message.createEl("h3", { text: version });
+      message.append(releaseNote);
+    }
+    await this.setShownReleaseNoteVersions([...shownVersions, ...unseenReleaseNotes.map(([version]) => version)]);
+    await alert({
+      app: this.app,
+      message,
+      title: t(($) => $.obsidianDevUtils.releaseNotes.title, { pluginName: this.pluginName })
+    });
+  }
+}
+export {
+  ReleaseNotesComponent
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/components/release-notes-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Component that shows a plugin's release notes once, when the workspace layout is ready.\n *\n * Several plugins hand-rolled this popup, and every copy had the same defect: it was titled only\n * `Release notes`, over headings that are bare version numbers, so nothing in it named the plugin. A user\n * with dozens of plugins installed could not tell whose popup it was. This component always names the\n * plugin in the title.\n *\n * It also owns the wait every copy needed. The notes already shown are stored in the host's settings, and\n * the host's settings component is a SIBLING whose own async load is still in flight when the plugin is\n * enabled after the layout is ready. Reading the list then sees the default empty one and shows every note\n * again, on every start. See {@link PluginSettingsComponentBase.whenLoadedFromFile}.\n */\n\nimport type { App } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { compareVersions } from 'compare-versions';\n\nimport type { PluginSettingsComponentBase } from './plugin-settings-component.ts';\n\nimport { t } from '../i18n/i18n.ts';\nimport { alert } from '../modals/alert.ts';\nimport { ComponentEx } from './component-ex.ts';\nimport { CallbackLayoutReadyComponent } from './layout-ready-component.ts';\n\n/**\n * Release notes, keyed by the semantic version that introduced each one.\n */\nexport type ReleaseNotes = Readonly<Record<string, DocumentFragment>>;\n\n/**\n * Parameters for the {@link ReleaseNotesComponent} constructor.\n */\nexport interface ReleaseNotesComponentConstructorParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * Returns the versions whose notes the user has already seen.\n   *\n   * Storage belongs to the host plugin, typically as one of its settings, because this component has no\n   * `data.json` of its own and the list has to outlive a reload.\n   *\n   * Only ever called once {@link pluginSettingsComponent} reports its settings loaded, so an implementation\n   * that reads a setting reads the stored value rather than its default.\n   *\n   * @returns The versions already shown.\n   */\n  readonly getShownReleaseNoteVersions: () => readonly string[];\n\n  /**\n   * The display name of the plugin, shown in the popup title.\n   */\n  readonly pluginName: string;\n\n  /**\n   * The settings component holding whatever {@link getShownReleaseNoteVersions} reads.\n   *\n   * Taken as a whole component rather than as a bare \"ready\" flag, so the host cannot forget to wire the\n   * wait.\n   */\n  readonly pluginSettingsComponent: PluginSettingsComponentBase<object>;\n\n  /**\n   * Builds the release notes.\n   *\n   * Called at layout ready rather than at construction, so the fragments are built only when they may be\n   * shown, and a localized string is read after the host's translations are set up.\n   *\n   * Every key must be a valid semantic version. The notes are shown in ascending version order, whatever\n   * order the keys were written in.\n   *\n   * @returns The release notes.\n   */\n  readonly releaseNotesProvider: () => ReleaseNotes;\n\n  /**\n   * Records the versions whose notes the user has now seen.\n   *\n   * Called before the popup is shown, with the full list: the versions already shown followed by the ones\n   * about to be.\n   *\n   * @param versions - The versions shown.\n   * @returns A {@link Promise} that resolves once the list is persisted.\n   */\n  readonly setShownReleaseNoteVersions: (versions: readonly string[]) => Promisable<void>;\n\n  /**\n   * Decides whether the release notes may be shown now.\n   *\n   * When it returns `false`, nothing is shown and nothing is recorded, so the notes are shown at a later\n   * start once it returns `true`. Use it when the notes only make sense while some feature is on.\n   *\n   * @returns `true` when the notes may be shown.\n   * @default Always `true`.\n   */\n  readonly shouldShowReleaseNotes?: () => Promisable<boolean>;\n}\n\n/**\n * Shows a plugin's release notes that the user has not seen yet, once the workspace layout is ready.\n */\nexport class ReleaseNotesComponent extends ComponentEx {\n  /**\n   * The Obsidian app instance.\n   */\n  protected readonly app: App;\n\n  /**\n   * The display name of the plugin, shown in the popup title.\n   */\n  protected readonly pluginName: string;\n\n  /**\n   * The settings component whose load is awaited before the shown versions are read.\n   */\n  protected readonly pluginSettingsComponent: PluginSettingsComponentBase<object>;\n\n  private readonly getShownReleaseNoteVersions: () => readonly string[];\n  private readonly releaseNotesProvider: () => ReleaseNotes;\n  private readonly setShownReleaseNoteVersions: (versions: readonly string[]) => Promisable<void>;\n  private readonly shouldShowReleaseNotes: () => Promisable<boolean>;\n\n  /**\n   * Creates an instance of {@link ReleaseNotesComponent}.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: ReleaseNotesComponentConstructorParams) {\n    super();\n    this.app = params.app;\n    this.getShownReleaseNoteVersions = params.getShownReleaseNoteVersions;\n    this.pluginName = params.pluginName;\n    this.pluginSettingsComponent = params.pluginSettingsComponent;\n    this.releaseNotesProvider = params.releaseNotesProvider;\n    this.setShownReleaseNoteVersions = params.setShownReleaseNoteVersions;\n    this.shouldShowReleaseNotes = params.shouldShowReleaseNotes ?? ((): boolean => true);\n  }\n\n  /**\n   * Loads the component, showing the unseen release notes once the layout is ready AND the host's settings\n   * have been read from disk.\n   */\n  public override onload(): void {\n    this.addChild(\n      new CallbackLayoutReadyComponent(this.app, async () => {\n        await this.pluginSettingsComponent.whenLoadedFromFile();\n        if (this.isUnloaded()) {\n          return;\n        }\n\n        await this.showUnseenReleaseNotes();\n      })\n    );\n  }\n\n  /**\n   * Shows the release notes the user has not seen yet, and records them as seen.\n   *\n   * Does nothing when {@link ReleaseNotesComponentConstructorParams.shouldShowReleaseNotes} declines, or when\n   * every note has been shown already.\n   *\n   * @returns A {@link Promise} that resolves once the popup is closed, or at once when nothing is shown.\n   */\n  protected async showUnseenReleaseNotes(): Promise<void> {\n    if (!await this.shouldShowReleaseNotes()) {\n      return;\n    }\n\n    const shownVersions = this.getShownReleaseNoteVersions();\n    const shownVersionSet = new Set(shownVersions);\n    const unseenReleaseNotes = Object.entries(this.releaseNotesProvider())\n      .filter(([version]) => !shownVersionSet.has(version))\n      .sort(([version1], [version2]) => compareVersions(version1, version2));\n\n    if (unseenReleaseNotes.length === 0) {\n      return;\n    }\n\n    const message = createFragment();\n    for (const [version, releaseNote] of unseenReleaseNotes) {\n      message.createEl('h3', { text: version });\n      message.append(releaseNote);\n    }\n\n    // Recorded before the popup is shown, so a user who reloads without closing it is not shown it again.\n    await this.setShownReleaseNoteVersions([...shownVersions, ...unseenReleaseNotes.map(([version]) => version)]);\n\n    await alert({\n      app: this.app,\n      message,\n      title: t(($) => $.obsidianDevUtils.releaseNotes.title, { pluginName: this.pluginName })\n    });\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmBA,SAAS,uBAAuB;AAIhC,SAAS,SAAS;AAClB,SAAS,aAAa;AACtB,SAAS,mBAAmB;AAC5B,SAAS,oCAAoC;AAiFtC,MAAM,8BAA8B,YAAY;AAAA;AAAA;AAAA;AAAA,EAIlC;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA,EAEF;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOV,YAAY,QAAgD;AACjE,UAAM;AACN,SAAK,MAAM,OAAO;AAClB,SAAK,8BAA8B,OAAO;AAC1C,SAAK,aAAa,OAAO;AACzB,SAAK,0BAA0B,OAAO;AACtC,SAAK,uBAAuB,OAAO;AACnC,SAAK,8BAA8B,OAAO;AAC1C,SAAK,yBAAyB,OAAO,2BAA2B,MAAe;AAAA,EACjF;AAAA;AAAA;AAAA;AAAA;AAAA,EAMgB,SAAe;AAC7B,SAAK;AAAA,MACH,IAAI,6BAA6B,KAAK,KAAK,YAAY;AACrD,cAAM,KAAK,wBAAwB,mBAAmB;AACtD,YAAI,KAAK,WAAW,GAAG;AACrB;AAAA,QACF;AAEA,cAAM,KAAK,uBAAuB;AAAA,MACpC,CAAC;AAAA,IACH;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,MAAgB,yBAAwC;AACtD,QAAI,CAAC,MAAM,KAAK,uBAAuB,GAAG;AACxC;AAAA,IACF;AAEA,UAAM,gBAAgB,KAAK,4BAA4B;AACvD,UAAM,kBAAkB,IAAI,IAAI,aAAa;AAC7C,UAAM,qBAAqB,OAAO,QAAQ,KAAK,qBAAqB,CAAC,EAClE,OAAO,CAAC,CAAC,OAAO,MAAM,CAAC,gBAAgB,IAAI,OAAO,CAAC,EACnD,KAAK,CAAC,CAAC,QAAQ,GAAG,CAAC,QAAQ,MAAM,gBAAgB,UAAU,QAAQ,CAAC;AAEvE,QAAI,mBAAmB,WAAW,GAAG;AACnC;AAAA,IACF;AAEA,UAAM,UAAU,eAAe;AAC/B,eAAW,CAAC,SAAS,WAAW,KAAK,oBAAoB;AACvD,cAAQ,SAAS,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,cAAQ,OAAO,WAAW;AAAA,IAC5B;AAGA,UAAM,KAAK,4BAA4B,CAAC,GAAG,eAAe,GAAG,mBAAmB,IAAI,CAAC,CAAC,OAAO,MAAM,OAAO,CAAC,CAAC;AAE5G,UAAM,MAAM;AAAA,MACV,KAAK,KAAK;AAAA,MACV;AAAA,MACA,OAAO,EAAE,CAAC,MAAM,EAAE,iBAAiB,aAAa,OAAO,EAAE,YAAY,KAAK,WAAW,CAAC;AAAA,IACxF,CAAC;AAAA,EACH;AACF;",
  "names": []
}


package/dist/lib/esm/components/rename-delete-handler-component.d.mts

@@ -0,0 +1,165 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Contains utility functions for handling rename and delete events in Obsidian.
+ */
+import type { App } from 'obsidian';
+import type { LinkUpdateProgressReporter } from '../link-update-progress.mjs';
+import type { ResourceLockComponent } from '../resource-lock.mjs';
+import type { AbortSignalComponent } from './abort-signal-component.mjs';
+import type { PluginNoticeComponent } from './plugin-notice-component.mjs';
+import { EmptyFolderBehavior } from '../vault.mjs';
+import { ComponentEx } from './component-ex.mjs';
+/**
+ * Parameters for {@link RenameDeleteHandlerSettings.getRescuePath}.
+ */
+export interface GetRescuePathParams {
+    /**
+     * The path of the attachment that is about to be stranded.
+     */
+    readonly attachmentPath: string;
+    /**
+     * The paths of the notes that still reference the attachment once the deletion is done. Never empty.
+     */
+    readonly survivingNotePaths: readonly string[];
+}
+/**
+ * Settings for the rename/delete handler.
+ */
+export interface RenameDeleteHandlerSettings {
+    /**
+     * A behavior of the rename/delete handler when deleting empty folders.
+     */
+    emptyFolderBehavior: EmptyFolderBehavior;
+    /**
+     * Where to move an attachment that a deletion would otherwise strand — one that survives because another
+     * note still references it, but is left sitting in a folder whose owning note is gone.
+     *
+     * Deciding the destination is the plugin's attachment-path policy, which is why the handler asks rather
+     * than guesses. Returning `null` — or not implementing this at all — keeps the attachment where it is,
+     * which is the behavior every consumer had before this member existed.
+     */
+    getRescuePath?: (params: GetRescuePathParams) => Promise<null | string>;
+    /**
+     * Whether the path is a note.
+     */
+    isNote: (path: string) => boolean;
+    /**
+     * Whether to ignore the path.
+     */
+    isPathIgnored: (path: string) => boolean;
+    /**
+     * Whether to delete conflicting attachments.
+     */
+    shouldDeleteConflictingAttachments: boolean;
+    /**
+     * Whether to handle deletions.
+     */
+    shouldHandleDeletions: boolean;
+    /**
+     * Whether to handle renames.
+     */
+    shouldHandleRenames: boolean;
+    /**
+     * Whether to rename attachment files when a note is renamed.
+     */
+    shouldRenameAttachmentFiles: boolean;
+    /**
+     * Whether to rename attachment folder when a note is renamed.
+     */
+    shouldRenameAttachmentFolder: boolean;
+    /**
+     * Whether to update file name aliases when a note is renamed.
+     */
+    shouldUpdateFileNameAliases: boolean;
+}
+interface RenameDeleteHandlerComponentConstructorParams {
+    readonly abortSignalComponent: AbortSignalComponent;
+    readonly app: App;
+    readonly linkUpdateProgressReporter?: LinkUpdateProgressReporter;
+    readonly pluginNoticeComponent: PluginNoticeComponent;
+    readonly resourceLockComponent: null | ResourceLockComponent;
+    readonly settingsBuilder: () => Partial<RenameDeleteHandlerSettings>;
+}
+/**
+ * Resolves the settings the handler runs with.
+ *
+ * There is exactly one contributor: the component's own `settingsBuilder`. Earlier versions aggregated a
+ * registry of contributors and OR-merged their answers, because several plugins could each register a
+ * handler against the one shared vault. They no longer do, so there is no longer any question of whose
+ * setting wins.
+ *
+ * What remains is defaulting: the builder returns a `Partial`, so the two predicates and the empty-folder
+ * behavior need a value when it does not supply one.
+ */
+declare class SettingsManager {
+    private readonly settingsBuilder;
+    constructor(settingsBuilder: () => Partial<RenameDeleteHandlerSettings>);
+    getSettings(): Partial<RenameDeleteHandlerSettings>;
+    isNoteEx(path: string): boolean;
+}
+/**
+ * Component that handles rename and delete events in Obsidian.
+ * It listens to rename and delete events and updates links accordingly.
+ * It also handles edge cases such as case-only renames and collisions with existing files.
+ */
+export declare class RenameDeleteHandlerComponent extends ComponentEx {
+    /**
+     * The abort signal component whose signal cancels in-flight rename operations.
+     */
+    protected readonly abortSignalComponent: AbortSignalComponent;
+    /**
+     * The Obsidian app instance.
+     */
+    protected readonly app: App;
+    /**
+     * An optional reporter invoked once per backlink file whose links are updated during a rename/move,
+     * with the running count of processed files and the total. When `null`, no progress is reported.
+     */
+    protected readonly linkUpdateProgressReporter: LinkUpdateProgressReporter | null;
+    /**
+     * The notice component used to report updated links to the user.
+     */
+    protected readonly pluginNoticeComponent: PluginNoticeComponent;
+    /**
+     * The resource lock component used to guard link updates, or `null` if none is used.
+     */
+    protected readonly resourceLockComponent: null | ResourceLockComponent;
+    /**
+     * Builds this plugin's rename/delete handler settings.
+     */
+    protected readonly settingsBuilder: () => Partial<RenameDeleteHandlerSettings>;
+    /**
+     * The manager that aggregates rename/delete handler settings across registered plugins.
+     */
+    protected readonly settingsManager: SettingsManager;
+    private readonly deletedMetadataCacheMap;
+    private readonly handledRenames;
+    private readonly interruptedRenamesMap;
+    /**
+     * Creates an instance of RenameDeleteHandlerComponent.
+     *
+     * @param params - The parameters for the RenameDeleteHandlerComponent.
+     */
+    constructor(params: RenameDeleteHandlerComponentConstructorParams);
+    /**
+     * Loads the component
+     */
+    onload(): void;
+    private handleDelete;
+    private handleMetadataDeleted;
+    private handleRename;
+    /**
+     * With link rewriting off, the handler's only remaining jobs are moving a NOTE's attachments and pruning
+     * the folder a moved file vacated. A non-note rename needs neither when empty folders are kept, so there
+     * is nothing to queue.
+     *
+     * @param settings - The aggregated rename/delete handler settings.
+     * @param oldPath - The path the file was renamed from.
+     * @param newPath - The path the file was renamed to.
+     * @returns `true` when the handler would do no work for this rename.
+     */
+    private isNoOpRename;
+}
+export { EmptyFolderBehavior } from '../vault.mjs';