obsidian-dev-utils 88.2.0 → 88.4.0

package/dist/lib/esm/obsidian/popovers/field-popover.d.mts

@@ -0,0 +1,75 @@
+/// <reference path="../../library.d.mts" />
+/**
+ * @file
+ *
+ * Utility for editing a handful of named text fields in a popover anchored at a point.
+ *
+ * This is to {@link showPopover} what `modals/prompt.ts` is to `modals/modal.ts`: the common case
+ * spelled declaratively, so a caller that only needs a few text fields never writes any DOM wiring.
+ * Anything richer — a dropdown, a toggle, rendered markdown — goes through {@link showPopover}
+ * directly.
+ */
+import type { PopoverAnchor } from './popover-anchor.mjs';
+/**
+ * Parameters for {@link editFieldsInPopover}.
+ *
+ * @typeParam Key - The union of the field keys, inferred from {@link EditFieldsInPopoverParams.fields}.
+ */
+export interface EditFieldsInPopoverParams<Key extends string> {
+    /**
+     * Where to place the popover.
+     */
+    readonly anchor: PopoverAnchor;
+    /**
+     * A text for the "Cancel" button.
+     */
+    readonly cancelButtonText?: string;
+    /**
+     * Additional CSS classes to apply to the popover.
+     */
+    readonly cssClasses?: string[];
+    /**
+     * The fields to edit, rendered top to bottom in the given order.
+     */
+    readonly fields: readonly PopoverField<Key>[];
+    /**
+     * A text for the "OK" button.
+     */
+    readonly okButtonText?: string;
+}
+/**
+ * A single text field of a {@link editFieldsInPopover} popover.
+ *
+ * @typeParam Key - The key the field's value is returned under.
+ */
+export interface PopoverField<Key extends string> {
+    /**
+     * A value to pre-fill the field with.
+     *
+     * @default `''`
+     */
+    readonly defaultValue?: string;
+    /**
+     * The key the field's value is returned under.
+     */
+    readonly key: Key;
+    /**
+     * The label shown next to the field.
+     */
+    readonly name: string;
+    /**
+     * A placeholder text for the field.
+     *
+     * @default `''`
+     */
+    readonly placeholder?: string;
+}
+/**
+ * Displays a popover with a text field per entry in `fields` and resolves with their values keyed by
+ * {@link PopoverField.key}, or `null` if it was dismissed without confirming.
+ *
+ * @typeParam Key - The union of the field keys, inferred from the `fields` array.
+ * @param params - The parameters for the popover.
+ * @returns A {@link Promise} that resolves with the edited values, or `null` if dismissed.
+ */
+export declare function editFieldsInPopover<Key extends string>(params: EditFieldsInPopoverParams<Key>): Promise<null | Record<Key, string>>;

package/dist/lib/esm/obsidian/popovers/field-popover.mjs

@@ -0,0 +1,70 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import {
+  Setting,
+  TextComponent
+} from "obsidian";
+import { normalizeOptionalProperties } from "../../object-utils.mjs";
+import { CssClass } from "../css-class.mjs";
+import { showPopover } from "./popover.mjs";
+async function editFieldsInPopover(params) {
+  const {
+    anchor,
+    cancelButtonText,
+    cssClasses,
+    fields,
+    okButtonText
+  } = params;
+  return await showPopover(normalizeOptionalProperties({
+    anchor,
+    build({ contentEl }) {
+      const editors = fields.map((field) => ({
+        key: field.key,
+        textComponent: addField(contentEl, field)
+      }));
+      return () => {
+        const values = {};
+        for (const editor of editors) {
+          values[editor.key] = editor.textComponent.getValue();
+        }
+        return values;
+      };
+    },
+    cancelButtonText,
+    cssClasses,
+    okButtonText
+  }));
+}
+function addField(containerEl, field) {
+  const setting = new Setting(containerEl).setName(field.name);
+  const textComponent = new TextComponent(setting.controlEl);
+  textComponent.setValue(field.defaultValue ?? "");
+  textComponent.setPlaceholder(field.placeholder ?? "");
+  textComponent.inputEl.addClass(CssClass.TextBox);
+  return textComponent;
+}
+export {
+  editFieldsInPopover
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/popovers/index.d.mts

@@ -0,0 +1,4 @@
+/// <reference path="../../library.d.mts" />
+export * as 'field-popover' from './field-popover.mjs';
+export * as 'popover-anchor' from './popover-anchor.mjs';
+export * as 'popover' from './popover.mjs';

package/dist/lib/esm/obsidian/popovers/index.mjs

@@ -0,0 +1,32 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import * as field_popover from "./field-popover.mjs";
+import * as popover_anchor from "./popover-anchor.mjs";
+import * as popover from "./popover.mjs";
+export {
+  field_popover as "field-popover",
+  popover,
+  popover_anchor as "popover-anchor"
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL3BvcG92ZXJzL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKiBUSElTIElTIEEgR0VORVJBVEVEL0JVTkRMRUQgRklMRSBCWSBCVUlMRCBTQ1JJUFQgKi9cblxuZXhwb3J0ICogYXMgJ2ZpZWxkLXBvcG92ZXInIGZyb20gJy4vZmllbGQtcG9wb3Zlci50cyc7XG5leHBvcnQgKiBhcyAncG9wb3Zlci1hbmNob3InIGZyb20gJy4vcG9wb3Zlci1hbmNob3IudHMnO1xuZXhwb3J0ICogYXMgJ3BvcG92ZXInIGZyb20gJy4vcG9wb3Zlci50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUVBLFlBQVlBLG1CQUFxQjtBQUNqQyxZQUFZQyxvQkFBc0I7QUFDbEMsWUFBWSxhQUFlOyIsCiAgIm5hbWVzIjogWyJmaWVsZC1wb3BvdmVyIiwgInBvcG92ZXItYW5jaG9yIl0KfQo=

package/dist/lib/esm/obsidian/popovers/popover-anchor.d.mts

@@ -0,0 +1,67 @@
+/// <reference path="../../library.d.mts" />
+/**
+ * @file
+ *
+ * The resolved position a popover is placed at.
+ *
+ * A popover takes a resolved anchor rather than an element because callers know the position in
+ * different ways: a clicked element has a rect, a context menu has the pointer that opened it, and a
+ * keyboard-invoked command has the caret. Each way gets its own builder here, so the popover itself
+ * stays unaware of how the position was found.
+ *
+ * This lives apart from the popover shell so that anything producing an anchor — most notably
+ * `PointerPositionComponent` — depends only on the position, not on the panel that consumes it.
+ */
+/**
+ * Where a popover is placed: viewport coordinates plus the document they belong to.
+ *
+ * Carrying the document explicitly is what makes an anchor inside a pop-out window work — the popover
+ * is appended to, and clamped against, that window rather than the main one.
+ */
+export interface PopoverAnchor {
+    /**
+     * The viewport `y` coordinate the popover is placed below.
+     */
+    readonly bottom: number;
+    /**
+     * The document the coordinates belong to.
+     */
+    readonly doc: Document;
+    /**
+     * The viewport `x` coordinate the popover is aligned to.
+     */
+    readonly left: number;
+}
+/**
+ * Anchors a popover in the middle of the document, for the cases where nothing better is known.
+ *
+ * @param doc - The document to anchor in.
+ * @returns The anchor.
+ */
+export declare function createAnchorFromDocumentCenter(doc: Document): PopoverAnchor;
+/**
+ * Anchors a popover just below an element — used for a clicked element, whose rect is exactly where
+ * the user is looking.
+ *
+ * @param el - The element to anchor at.
+ * @returns The anchor.
+ */
+export declare function createAnchorFromElement(el: HTMLElement): PopoverAnchor;
+/**
+ * Anchors a popover at a pointer position — used for a context menu, which is raised by a right-click
+ * or a long-press whose coordinates are where the user is looking.
+ *
+ * @param x - The viewport `x` coordinate.
+ * @param y - The viewport `y` coordinate.
+ * @param doc - The document the coordinates belong to.
+ * @returns The anchor.
+ */
+export declare function createAnchorFromPoint(x: number, y: number, doc: Document): PopoverAnchor;
+/**
+ * Anchors a popover at the caret — used by a command invoked from the keyboard, with the cursor
+ * already at the place being edited.
+ *
+ * @param doc - The document holding the selection.
+ * @returns The anchor, or a centered one when there is no caret to read.
+ */
+export declare function createAnchorFromSelection(doc: Document): PopoverAnchor;

package/dist/lib/esm/obsidian/popovers/popover-anchor.mjs

@@ -0,0 +1,67 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import { getDocumentWindow } from "../../html-element.mjs";
+const CENTER_FRACTION = 0.5;
+function createAnchorFromDocumentCenter(doc) {
+  const win = getDocumentWindow(doc);
+  return {
+    bottom: win.innerHeight * CENTER_FRACTION,
+    doc,
+    left: win.innerWidth * CENTER_FRACTION
+  };
+}
+function createAnchorFromElement(el) {
+  const rect = el.getBoundingClientRect();
+  return {
+    bottom: rect.bottom,
+    doc: el.ownerDocument,
+    left: rect.left
+  };
+}
+function createAnchorFromPoint(x, y, doc) {
+  return {
+    bottom: y,
+    doc,
+    left: x
+  };
+}
+function createAnchorFromSelection(doc) {
+  const selection = doc.getSelection();
+  const rect = selection?.rangeCount ? selection.getRangeAt(0).getBoundingClientRect() : null;
+  if (!rect || rect.bottom === 0 && rect.left === 0) {
+    return createAnchorFromDocumentCenter(doc);
+  }
+  return {
+    bottom: rect.bottom,
+    doc,
+    left: rect.left
+  };
+}
+export {
+  createAnchorFromDocumentCenter,
+  createAnchorFromElement,
+  createAnchorFromPoint,
+  createAnchorFromSelection
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/popovers/popover.d.mts

@@ -0,0 +1,78 @@
+/// <reference path="../../library.d.mts" />
+/**
+ * @file
+ *
+ * A small floating panel anchored at a point, collecting a value and resolving a promise with it.
+ *
+ * This is the popover counterpart of `modals/modal.ts`: the same "ask the user for a value, resolve a
+ * promise" shape, for the cases a modal cannot serve. A modal dims the screen and is positioned by
+ * Obsidian, neither of which suits an editor that must appear *at* the thing it edits — a clicked
+ * link, the caret, or wherever a context menu was raised.
+ *
+ * The panel rides Obsidian's `.menu` class for its background, border and shadow, so only layout is
+ * styled by this library.
+ */
+import type { PopoverAnchor } from './popover-anchor.mjs';
+/**
+ * Reads the value the popover resolves with when it is confirmed.
+ *
+ * @typeParam Value - The type of the value resolved by the popover.
+ * @returns The current value.
+ */
+export type PopoverValueGetter<Value> = (this: void) => Value;
+/**
+ * The tools handed to {@link ShowPopoverParams.build} for populating a popover.
+ */
+export interface ShowPopoverBuildParams {
+    /**
+     * Dismisses the popover, resolving it with `null`, as the Cancel button does.
+     */
+    cancel(this: void): void;
+    /**
+     * Confirms the popover, resolving it with the built value, as the OK button does.
+     */
+    confirm(this: void): void;
+    /**
+     * The element to add the popover's content to. The OK and Cancel buttons are appended after it.
+     */
+    readonly contentEl: HTMLElement;
+}
+/**
+ * Parameters for {@link showPopover}.
+ *
+ * @typeParam Value - The type of the value resolved by the popover.
+ */
+export interface ShowPopoverParams<Value> {
+    /**
+     * Where to place the popover.
+     */
+    readonly anchor: PopoverAnchor;
+    /**
+     * Populates the popover's content.
+     *
+     * @param params - The tools for populating the popover.
+     * @returns A getter read when the popover is confirmed.
+     */
+    build(this: void, params: ShowPopoverBuildParams): PopoverValueGetter<Value>;
+    /**
+     * A text for the "Cancel" button.
+     */
+    readonly cancelButtonText?: string;
+    /**
+     * Additional CSS classes to apply to the popover.
+     */
+    readonly cssClasses?: string[];
+    /**
+     * A text for the "OK" button.
+     */
+    readonly okButtonText?: string;
+}
+/**
+ * Displays a popover at the given anchor and resolves with the built value, or `null` if it was
+ * dismissed without confirming.
+ *
+ * @typeParam Value - The type of the value resolved by the popover.
+ * @param params - The parameters for the popover.
+ * @returns A {@link Promise} that resolves with the built value, or `null` if dismissed.
+ */
+export declare function showPopover<Value>(params: ShowPopoverParams<Value>): Promise<null | Value>;

package/dist/lib/esm/obsidian/popovers/popover.mjs

@@ -0,0 +1,113 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import { Setting } from "obsidian";
+import { getDocumentWindow } from "../../html-element.mjs";
+import { CssClass } from "../css-class.mjs";
+import { t } from "../i18n/i18n.mjs";
+import { addPluginCssClasses } from "../plugin/plugin-context.mjs";
+const ANCHOR_GAP_IN_PIXELS = 4;
+const VIEWPORT_MARGIN_IN_PIXELS = 8;
+async function showPopover(params) {
+  const {
+    anchor,
+    build,
+    cancelButtonText,
+    cssClasses,
+    okButtonText
+  } = params;
+  const doc = anchor.doc;
+  const win = getDocumentWindow(doc);
+  const popoverEl = doc.body.createDiv({ cls: "menu" });
+  addPluginCssClasses(popoverEl, [CssClass.Popover, ...cssClasses ?? []]);
+  return await new Promise((resolve) => {
+    const state = { isClosed: false };
+    function close(result) {
+      if (state.isClosed) {
+        return;
+      }
+      state.isClosed = true;
+      doc.removeEventListener("pointerdown", handlePointerDown, true);
+      popoverEl.remove();
+      resolve(result);
+    }
+    function handleCancel() {
+      close(null);
+    }
+    function handleOk() {
+      close(getValue());
+    }
+    function handlePointerDown(evt) {
+      if (evt.composedPath().includes(popoverEl)) {
+        return;
+      }
+      close(null);
+    }
+    const getValue = build({
+      cancel: handleCancel,
+      confirm: handleOk,
+      contentEl: popoverEl
+    });
+    popoverEl.addEventListener("keydown", (evt) => {
+      if (evt.key === "Enter") {
+        evt.preventDefault();
+        handleOk();
+        return;
+      }
+      if (evt.key === "Escape") {
+        evt.preventDefault();
+        handleCancel();
+      }
+    });
+    const buttonsSetting = new Setting(popoverEl);
+    buttonsSetting.addButton((button) => {
+      button.setButtonText(okButtonText ?? t(($) => $.obsidianDevUtils.buttons.ok)).setCta().setClass(CssClass.OkButton).onClick(handleOk);
+    });
+    buttonsSetting.addButton((button) => {
+      button.setButtonText(cancelButtonText ?? t(($) => $.obsidianDevUtils.buttons.cancel)).setClass(CssClass.CancelButton).onClick(handleCancel);
+    });
+    doc.addEventListener("pointerdown", handlePointerDown, true);
+    positionAtAnchor(popoverEl, anchor, win);
+    focusFirstInput(popoverEl);
+  });
+}
+function focusFirstInput(popoverEl) {
+  const inputEl = popoverEl.querySelector("input");
+  if (!inputEl) {
+    return;
+  }
+  inputEl.focus();
+  inputEl.select();
+}
+function positionAtAnchor(popoverEl, anchor, win) {
+  const maxLeft = Math.max(VIEWPORT_MARGIN_IN_PIXELS, win.innerWidth - popoverEl.offsetWidth - VIEWPORT_MARGIN_IN_PIXELS);
+  const maxTop = Math.max(VIEWPORT_MARGIN_IN_PIXELS, win.innerHeight - popoverEl.offsetHeight - VIEWPORT_MARGIN_IN_PIXELS);
+  const left = Math.min(Math.max(anchor.left, VIEWPORT_MARGIN_IN_PIXELS), maxLeft);
+  const top = Math.min(Math.max(anchor.bottom + ANCHOR_GAP_IN_PIXELS, VIEWPORT_MARGIN_IN_PIXELS), maxTop);
+  popoverEl.style.left = `${String(Math.round(left + win.scrollX))}px`;
+  popoverEl.style.top = `${String(Math.round(top + win.scrollY))}px`;
+}
+export {
+  showPopover
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/popovers/popover.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * A small floating panel anchored at a point, collecting a value and resolving a promise with it.\n *\n * This is the popover counterpart of `modals/modal.ts`: the same \"ask the user for a value, resolve a\n * promise\" shape, for the cases a modal cannot serve. A modal dims the screen and is positioned by\n * Obsidian, neither of which suits an editor that must appear *at* the thing it edits \u2014 a clicked\n * link, the caret, or wherever a context menu was raised.\n *\n * The panel rides Obsidian's `.menu` class for its background, border and shadow, so only layout is\n * styled by this library.\n */\n\nimport { Setting } from 'obsidian';\n\nimport type { PopoverAnchor } from './popover-anchor.ts';\n\nimport { getDocumentWindow } from '../../html-element.ts';\nimport { CssClass } from '../css-class.ts';\nimport { t } from '../i18n/i18n.ts';\nimport { addPluginCssClasses } from '../plugin/plugin-context.ts';\n\n/**\n * The gap in pixels between the anchor and the popover.\n */\nconst ANCHOR_GAP_IN_PIXELS = 4;\n\n/**\n * The minimum gap in pixels the popover keeps from the edges of the window when it has to be clamped\n * back into view.\n */\nconst VIEWPORT_MARGIN_IN_PIXELS = 8;\n\n/**\n * Reads the value the popover resolves with when it is confirmed.\n *\n * @typeParam Value - The type of the value resolved by the popover.\n * @returns The current value.\n */\nexport type PopoverValueGetter<Value> = (this: void) => Value;\n\n/**\n * The tools handed to {@link ShowPopoverParams.build} for populating a popover.\n */\nexport interface ShowPopoverBuildParams {\n  /**\n   * Dismisses the popover, resolving it with `null`, as the Cancel button does.\n   */\n  cancel(this: void): void;\n\n  /**\n   * Confirms the popover, resolving it with the built value, as the OK button does.\n   */\n  confirm(this: void): void;\n\n  /**\n   * The element to add the popover's content to. The OK and Cancel buttons are appended after it.\n   */\n  readonly contentEl: HTMLElement;\n}\n\n/**\n * Parameters for {@link showPopover}.\n *\n * @typeParam Value - The type of the value resolved by the popover.\n */\nexport interface ShowPopoverParams<Value> {\n  /**\n   * Where to place the popover.\n   */\n  readonly anchor: PopoverAnchor;\n\n  /**\n   * Populates the popover's content.\n   *\n   * @param params - The tools for populating the popover.\n   * @returns A getter read when the popover is confirmed.\n   */\n  build(this: void, params: ShowPopoverBuildParams): PopoverValueGetter<Value>;\n\n  /**\n   * A text for the \"Cancel\" button.\n   */\n  readonly cancelButtonText?: string;\n\n  /**\n   * Additional CSS classes to apply to the popover.\n   */\n  readonly cssClasses?: string[];\n\n  /**\n   * A text for the \"OK\" button.\n   */\n  readonly okButtonText?: string;\n}\n\n/**\n * Displays a popover at the given anchor and resolves with the built value, or `null` if it was\n * dismissed without confirming.\n *\n * @typeParam Value - The type of the value resolved by the popover.\n * @param params - The parameters for the popover.\n * @returns A {@link Promise} that resolves with the built value, or `null` if dismissed.\n */\nexport async function showPopover<Value>(params: ShowPopoverParams<Value>): Promise<null | Value> {\n  const {\n    anchor,\n    build,\n    cancelButtonText,\n    cssClasses,\n    okButtonText\n  } = params;\n\n  const doc = anchor.doc;\n  const win = getDocumentWindow(doc);\n  const popoverEl = doc.body.createDiv({ cls: 'menu' });\n  addPluginCssClasses(popoverEl, [CssClass.Popover, ...cssClasses ?? []]);\n\n  return await new Promise<null | Value>((resolve) => {\n    const state = { isClosed: false };\n\n    function close(result: null | Value): void {\n      if (state.isClosed) {\n        return;\n      }\n      state.isClosed = true;\n      doc.removeEventListener('pointerdown', handlePointerDown, true);\n      popoverEl.remove();\n      resolve(result);\n    }\n\n    function handleCancel(): void {\n      close(null);\n    }\n\n    function handleOk(): void {\n      close(getValue());\n    }\n\n    /**\n     * Dismisses the popover when the next gesture starts outside it. Listening for `pointerdown`\n     * rather than `click` matters: a popover is typically opened from a `click` handler, and the very\n     * same click would otherwise reach this listener and close the popover the instant it appears.\n     *\n     * @param evt - The pointer event.\n     */\n    function handlePointerDown(evt: PointerEvent): void {\n      if (evt.composedPath().includes(popoverEl)) {\n        return;\n      }\n      close(null);\n    }\n\n    const getValue = build({\n      cancel: handleCancel,\n      confirm: handleOk,\n      contentEl: popoverEl\n    });\n\n    popoverEl.addEventListener('keydown', (evt: KeyboardEvent) => {\n      if (evt.key === 'Enter') {\n        evt.preventDefault();\n        handleOk();\n        return;\n      }\n\n      if (evt.key === 'Escape') {\n        evt.preventDefault();\n        handleCancel();\n      }\n    });\n\n    const buttonsSetting = new Setting(popoverEl);\n    buttonsSetting.addButton((button) => {\n      button\n        .setButtonText(okButtonText ?? t(($) => $.obsidianDevUtils.buttons.ok))\n        .setCta()\n        .setClass(CssClass.OkButton)\n        .onClick(handleOk);\n    });\n    buttonsSetting.addButton((button) => {\n      button\n        .setButtonText(cancelButtonText ?? t(($) => $.obsidianDevUtils.buttons.cancel))\n        .setClass(CssClass.CancelButton)\n        .onClick(handleCancel);\n    });\n\n    doc.addEventListener('pointerdown', handlePointerDown, true);\n    positionAtAnchor(popoverEl, anchor, win);\n    focusFirstInput(popoverEl);\n  });\n}\n\n/**\n * Focuses and selects the popover's first text input, so the user can type straight away.\n *\n * @param popoverEl - The popover to focus within.\n */\nfunction focusFirstInput(popoverEl: HTMLElement): void {\n  const inputEl = popoverEl.querySelector('input');\n  if (!inputEl) {\n    return;\n  }\n\n  inputEl.focus();\n  inputEl.select();\n}\n\n/**\n * Places the popover just below the anchor, pulling it back inside the window when it would otherwise\n * overflow \u2014 an anchor near the right or bottom edge is exactly where an unclamped popover would\n * render off-screen.\n *\n * @param popoverEl - The popover to position.\n * @param anchor - Where the popover belongs.\n * @param win - The window the anchor lives in (a pop-out window has its own).\n */\nfunction positionAtAnchor(popoverEl: HTMLElement, anchor: PopoverAnchor, win: Window): void {\n  const maxLeft = Math.max(VIEWPORT_MARGIN_IN_PIXELS, win.innerWidth - popoverEl.offsetWidth - VIEWPORT_MARGIN_IN_PIXELS);\n  const maxTop = Math.max(VIEWPORT_MARGIN_IN_PIXELS, win.innerHeight - popoverEl.offsetHeight - VIEWPORT_MARGIN_IN_PIXELS);\n\n  const left = Math.min(Math.max(anchor.left, VIEWPORT_MARGIN_IN_PIXELS), maxLeft);\n  const top = Math.min(Math.max(anchor.bottom + ANCHOR_GAP_IN_PIXELS, VIEWPORT_MARGIN_IN_PIXELS), maxTop);\n\n  popoverEl.style.left = `${String(Math.round(left + win.scrollX))}px`;\n  popoverEl.style.top = `${String(Math.round(top + win.scrollY))}px`;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/obsidian/resource-lock.d.mts

@@ -256,6 +256,21 @@ export declare class ResourceLockedError extends Error {
  * @returns `true` if the note has at least one active lock, `false` otherwise.
  */
 export declare function isResourceLockedForPath(app: App, pathOrFile: PathOrFile): boolean;
+/**
+ * Checks whether the note at the given path is currently locked directly OR is covered by a
+ * `subtree`-locked ancestor folder.
+ *
+ * Unlike {@link isResourceLockedForPath}, which only reports an exact-path lock, this also reports a
+ * path that lies under a folder locked in `subtree` mode. Use it to detect that a rename/move is
+ * happening inside a foreign plugin's in-flight locked transaction (which locks the affected folder
+ * subtree), so that a bystander (e.g. the rename/delete handler) can stay out of the way and let the
+ * transaction's owner keep its own links consistent.
+ *
+ * @param app - The Obsidian app instance.
+ * @param pathOrFile - The path or file of the note to check.
+ * @returns `true` if the path is itself locked or lies under a `subtree`-locked ancestor folder.
+ */
+export declare function isResourceLockedForPathByAncestor(app: App, pathOrFile: PathOrFile): boolean;
 /**
  * Locks the note at the given path, making it read-only in every current and future
  * {@link MarkdownView} until the lock is released, and showing a lock indicator in the tab header,