@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/cjs/components/rename-delete-handler-component.d.cts

@@ -0,0 +1,165 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @file
+ *
+ * Contains utility functions for handling rename and delete events in Obsidian.
+ */
+import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { LinkUpdateProgressReporter } from '../link-update-progress.cjs';
+import type { ResourceLockComponent } from '../resource-lock.cjs';
+import type { AbortSignalComponent } from './abort-signal-component.cjs';
+import type { PluginNoticeComponent } from './plugin-notice-component.cjs';
+import { EmptyFolderBehavior } from '../vault.cjs';
+import { ComponentEx } from './component-ex.cjs';
+/**
+ * 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.cjs';

package/dist/lib/cjs/components/rmdir-guard-component.cjs

@@ -0,0 +1,190 @@
+/*
+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 keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord["__name"] ??= keepName;
+  globalThisRecord["__extractDefault"] ??= extractDefault;
+  ensureBrowserProcess();
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    if (globalThis.app.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rmdir_guard_component_exports = {};
+__export(rmdir_guard_component_exports, {
+  NOT_EMPTY_DIRECTORY_ERROR_CODE: () => NOT_EMPTY_DIRECTORY_ERROR_CODE,
+  RmdirGuardComponent: () => RmdirGuardComponent
+});
+module.exports = __toCommonJS(rmdir_guard_component_exports);
+var import_vault = require('../vault.cjs');
+var import_monkey_around_component = require('./monkey-around-component.cjs');
+const NOT_EMPTY_DIRECTORY_ERROR_CODE = "ENOTEMPTY";
+class RmdirGuardComponent extends import_monkey_around_component.MonkeyAroundComponent {
+  /**
+   * Creates a new instance of the {@link RmdirGuardComponent} class.
+   *
+   * @param app - The Obsidian app instance whose vault adapter to guard.
+   */
+  constructor(app) {
+    super();
+    this.app = app;
+  }
+  app;
+  /**
+   * Installs the `rmdir` guard. The patch is uninstalled when this component unloads.
+   */
+  onload() {
+    this.registerMethodPatch({
+      $object: this.app.vault.adapter,
+      methodName: "rmdir",
+      patchHandler: async ({
+        fallback,
+        originalArguments: [normalizedPath, recursive],
+        originalMethodBound
+      }) => {
+        if (recursive) {
+          await fallback();
+          return;
+        }
+        const stats = await this.app.vault.adapter.stat(normalizedPath);
+        if (stats?.type !== "folder") {
+          await fallback();
+          return;
+        }
+        if (!await (0, import_vault.isEmptyFolder)(this.app, normalizedPath)) {
+          throw Object.assign(new Error(`Directory ${normalizedPath} is not empty`), {
+            code: NOT_EMPTY_DIRECTORY_ERROR_CODE,
+            path: normalizedPath
+          });
+        }
+        await originalMethodBound(normalizedPath, true);
+      }
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NOT_EMPTY_DIRECTORY_ERROR_CODE,
+  RmdirGuardComponent
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/components/rmdir-guard-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains class {@link RmdirGuardComponent} that makes the `recursive` flag of\n * {@link https://docs.obsidian.md/Reference/TypeScript+API/DataAdapter/rmdir | DataAdapter.rmdir} mean what it says.\n */\n\nimport type { App } from 'obsidian';\n\nimport { isEmptyFolder } from '../vault.ts';\nimport { MonkeyAroundComponent } from './monkey-around-component.ts';\n\n/**\n * The `code` carried by the error thrown when a non-recursive `rmdir` is refused because the folder has children.\n *\n * Matches the POSIX/Node error code a correct non-recursive directory removal produces, so a caller already\n * branching on `error.code` keeps working. Check the `code`, never `instanceof` \u2014 every plugin bundles its own\n * copy of this library, so the error may cross a copy boundary.\n */\nexport const NOT_EMPTY_DIRECTORY_ERROR_CODE = 'ENOTEMPTY';\n\n/**\n * Makes `app.vault.adapter.rmdir(path, false)` behave as its name promises: a non-recursive call on a folder\n * that still has children throws instead of deleting them.\n *\n * @remarks\n * Obsidian's adapters do not honor `recursive: false`, and they get it wrong in opposite directions:\n *\n * - `CapacitorAdapter` (mobile) does not accept the argument at all \u2014 it always removes recursively, so a\n *   non-recursive call silently deletes the folder and everything under it. This is the data-loss footgun.\n * - `FileSystemAdapter` (desktop) forwards it to `fs.promises.rm(path, { recursive })`, which throws\n *   `ERR_FS_EISDIR` for *any* directory when `recursive` is `false` \u2014 so the non-recursive call never\n *   succeeds, not even on an empty folder.\n *\n * While loaded, this component gives both platforms the same, correct behavior: a non-empty folder is\n * refused with an {@link NOT_EMPTY_DIRECTORY_ERROR_CODE} error and nothing is deleted; an empty folder is\n * removed. Emptiness is decided from the adapter (via {@link isEmptyFolder}), not from the vault index \u2014 the\n * index omits dot-prefixed and otherwise hidden entries, so a folder holding only hidden files reads as empty\n * there and the guard would wave through exactly the deletion it exists to prevent.\n *\n * A folder proven empty is removed by forwarding to the original method with `recursive: true`. That is not\n * merely defensive: it is what makes the empty-folder case succeed on desktop, where the non-recursive call\n * would otherwise throw.\n *\n * Calls that already pass `recursive: true`, and calls whose target is not a folder (a file, a missing path),\n * are passed through untouched and keep their native behavior.\n *\n * Loading the guard more than once is safe, and it deliberately carries **no patch token**. Every plugin\n * bundles its own copy of this library and they all patch the one shared adapter, so several guards do stack\n * \u2014 but the operation is idempotent (prove empty, then delete), so stacking changes nothing: the outermost\n * guard either throws or forwards with `recursive: true`, which every guard beneath passes straight through.\n * They can also be unloaded in any order and the method stays guarded until the last one goes, because\n * `monkey-around` neutralizes an unloaded wrapper in place rather than splicing it out. A token would only\n * move the decision to the innermost guard \u2014 an equally arbitrary choice \u2014 while adding a path on which a\n * guard declines to guard. For a data-loss guard that trade is not worth making. Contrast\n * `RenameDeleteHandlerComponent`, which does need one: suppressing `runAsyncLinkUpdate` is not idempotent,\n * so two of those would conflict.\n *\n * This component is deliberately **opt-in**: `app.vault.adapter` is shared by the whole app, so a library that\n * installed this patch on its own would change `rmdir` semantics for every other plugin, including the ones\n * that never asked for it. A plugin that deletes folders opts in for itself:\n *\n * @example\n * ```ts\n * this.addChild(new RmdirGuardComponent(this.app));\n * ```\n */\nexport class RmdirGuardComponent extends MonkeyAroundComponent {\n  /**\n   * Creates a new instance of the {@link RmdirGuardComponent} class.\n   *\n   * @param app - The Obsidian app instance whose vault adapter to guard.\n   */\n  public constructor(protected readonly app: App) {\n    super();\n  }\n\n  /**\n   * Installs the `rmdir` guard. The patch is uninstalled when this component unloads.\n   */\n  public override onload(): void {\n    this.registerMethodPatch({\n      $object: this.app.vault.adapter,\n      methodName: 'rmdir',\n      patchHandler: async ({\n        fallback,\n        originalArguments: [normalizedPath, recursive],\n        originalMethodBound\n      }) => {\n        if (recursive) {\n          await fallback();\n          return;\n        }\n\n        const stats = await this.app.vault.adapter.stat(normalizedPath);\n        if (stats?.type !== 'folder') {\n          await fallback();\n          return;\n        }\n\n        if (!await isEmptyFolder(this.app, normalizedPath)) {\n          throw Object.assign(new Error(`Directory ${normalizedPath} is not empty`), {\n            code: NOT_EMPTY_DIRECTORY_ERROR_CODE,\n            path: normalizedPath\n          });\n        }\n\n        // The folder is proven empty, so a recursive removal is equivalent -- and, unlike the non-recursive\n        // one, it actually works on the desktop adapter.\n        await originalMethodBound(normalizedPath, true);\n      }\n    });\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AASA,mBAA8B;AAC9B,qCAAsC;AAS/B,MAAM,iCAAiC;AAgDvC,MAAM,4BAA4B,qDAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMtD,YAA+B,KAAU;AAC9C,UAAM;AAD8B;AAAA,EAEtC;AAAA,EAFsC;AAAA;AAAA;AAAA;AAAA,EAOtB,SAAe;AAC7B,SAAK,oBAAoB;AAAA,MACvB,SAAS,KAAK,IAAI,MAAM;AAAA,MACxB,YAAY;AAAA,MACZ,cAAc,OAAO;AAAA,QACnB;AAAA,QACA,mBAAmB,CAAC,gBAAgB,SAAS;AAAA,QAC7C;AAAA,MACF,MAAM;AACJ,YAAI,WAAW;AACb,gBAAM,SAAS;AACf;AAAA,QACF;AAEA,cAAM,QAAQ,MAAM,KAAK,IAAI,MAAM,QAAQ,KAAK,cAAc;AAC9D,YAAI,OAAO,SAAS,UAAU;AAC5B,gBAAM,SAAS;AACf;AAAA,QACF;AAEA,YAAI,CAAC,UAAM,4BAAc,KAAK,KAAK,cAAc,GAAG;AAClD,gBAAM,OAAO,OAAO,IAAI,MAAM,aAAa,cAAc,eAAe,GAAG;AAAA,YACzE,MAAM;AAAA,YACN,MAAM;AAAA,UACR,CAAC;AAAA,QACH;AAIA,cAAM,oBAAoB,gBAAgB,IAAI;AAAA,MAChD;AAAA,IACF,CAAC;AAAA,EACH;AACF;",
  "names": []
}


package/dist/lib/cjs/components/rmdir-guard-component.d.cts

@@ -0,0 +1,76 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @file
+ *
+ * Contains class {@link RmdirGuardComponent} that makes the `recursive` flag of
+ * {@link https://docs.obsidian.md/Reference/TypeScript+API/DataAdapter/rmdir | DataAdapter.rmdir} mean what it says.
+ */
+import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
+import { MonkeyAroundComponent } from './monkey-around-component.cjs';
+/**
+ * The `code` carried by the error thrown when a non-recursive `rmdir` is refused because the folder has children.
+ *
+ * Matches the POSIX/Node error code a correct non-recursive directory removal produces, so a caller already
+ * branching on `error.code` keeps working. Check the `code`, never `instanceof` — every plugin bundles its own
+ * copy of this library, so the error may cross a copy boundary.
+ */
+export declare const NOT_EMPTY_DIRECTORY_ERROR_CODE = "ENOTEMPTY";
+/**
+ * Makes `app.vault.adapter.rmdir(path, false)` behave as its name promises: a non-recursive call on a folder
+ * that still has children throws instead of deleting them.
+ *
+ * @remarks
+ * Obsidian's adapters do not honor `recursive: false`, and they get it wrong in opposite directions:
+ *
+ * - `CapacitorAdapter` (mobile) does not accept the argument at all — it always removes recursively, so a
+ *   non-recursive call silently deletes the folder and everything under it. This is the data-loss footgun.
+ * - `FileSystemAdapter` (desktop) forwards it to `fs.promises.rm(path, { recursive })`, which throws
+ *   `ERR_FS_EISDIR` for *any* directory when `recursive` is `false` — so the non-recursive call never
+ *   succeeds, not even on an empty folder.
+ *
+ * While loaded, this component gives both platforms the same, correct behavior: a non-empty folder is
+ * refused with an {@link NOT_EMPTY_DIRECTORY_ERROR_CODE} error and nothing is deleted; an empty folder is
+ * removed. Emptiness is decided from the adapter (via {@link isEmptyFolder}), not from the vault index — the
+ * index omits dot-prefixed and otherwise hidden entries, so a folder holding only hidden files reads as empty
+ * there and the guard would wave through exactly the deletion it exists to prevent.
+ *
+ * A folder proven empty is removed by forwarding to the original method with `recursive: true`. That is not
+ * merely defensive: it is what makes the empty-folder case succeed on desktop, where the non-recursive call
+ * would otherwise throw.
+ *
+ * Calls that already pass `recursive: true`, and calls whose target is not a folder (a file, a missing path),
+ * are passed through untouched and keep their native behavior.
+ *
+ * Loading the guard more than once is safe, and it deliberately carries **no patch token**. Every plugin
+ * bundles its own copy of this library and they all patch the one shared adapter, so several guards do stack
+ * — but the operation is idempotent (prove empty, then delete), so stacking changes nothing: the outermost
+ * guard either throws or forwards with `recursive: true`, which every guard beneath passes straight through.
+ * They can also be unloaded in any order and the method stays guarded until the last one goes, because
+ * `monkey-around` neutralizes an unloaded wrapper in place rather than splicing it out. A token would only
+ * move the decision to the innermost guard — an equally arbitrary choice — while adding a path on which a
+ * guard declines to guard. For a data-loss guard that trade is not worth making. Contrast
+ * `RenameDeleteHandlerComponent`, which does need one: suppressing `runAsyncLinkUpdate` is not idempotent,
+ * so two of those would conflict.
+ *
+ * This component is deliberately **opt-in**: `app.vault.adapter` is shared by the whole app, so a library that
+ * installed this patch on its own would change `rmdir` semantics for every other plugin, including the ones
+ * that never asked for it. A plugin that deletes folders opts in for itself:
+ *
+ * @example
+ * ```ts
+ * this.addChild(new RmdirGuardComponent(this.app));
+ * ```
+ */
+export declare class RmdirGuardComponent extends MonkeyAroundComponent {
+    protected readonly app: App;
+    /**
+     * Creates a new instance of the {@link RmdirGuardComponent} class.
+     *
+     * @param app - The Obsidian app instance whose vault adapter to guard.
+     */
+    constructor(app: App);
+    /**
+     * Installs the `rmdir` guard. The patch is uninstalled when this component unloads.
+     */
+    onload(): void;
+}