obsidian-dev-utils 80.1.0 → 82.0.0-beta.0

package/dist/lib/esm/obsidian/dataview-link.d.mts

@@ -6,16 +6,33 @@
  */
 import type { DataviewInlineApi, Link } from './dataview.mjs';
 import type { PathOrFile } from './file-system.mjs';
+/**
+ * Parameters for {@link fixTitle}.
+ */
+export interface FixTitleParams {
+    /**
+     * The DataviewInlineApi instance used to create the file link.
+     */
+    readonly dv: DataviewInlineApi;
+    /**
+     * A boolean indicating whether the file is a folder note.
+     * If `true`, the title is derived from the folder name.
+     *
+     * @default `false`
+     */
+    readonly isFolderNote?: boolean;
+    /**
+     * The file path for which the title is to be fixed.
+     */
+    readonly pathOrFile: PathOrFile;
+}
 /**
  * Fixes the title of a file or folder note by generating a {@link Link} object with a proper title.
  *
- * @param dv - The DataviewInlineApi instance used to create the file link.
- * @param pathOrFile - The file path for which the title is to be fixed.
- * @param isFolderNote - A boolean indicating whether the file is a folder note. Defaults to `false`.
- * If `true`, the title is derived from the folder name. Defaults to `false`.
+ * @param params - The parameters for fixing the title.
  * @returns A Link object with the corrected title.
  */
-export declare function fixTitle(dv: DataviewInlineApi, pathOrFile: PathOrFile, isFolderNote?: boolean): Link;
+export declare function fixTitle(params: FixTitleParams): Link;
 /**
  * Generates a string representation of a {@link Link} object that includes both the link text and the file path.
  *

package/dist/lib/esm/obsidian/dataview-link.mjs

@@ -27,7 +27,12 @@ import {
   extname
 } from "../path.mjs";
 import { getPath } from "./file-system.mjs";
-function fixTitle(dv, pathOrFile, isFolderNote) {
+function fixTitle(params) {
+  const {
+    dv,
+    isFolderNote,
+    pathOrFile
+  } = params;
   const path = getPath(dv.app, pathOrFile);
   const ext = extname(path);
   const title = isFolderNote ? basename(dirname(path)) : basename(path, ext);
@@ -40,4 +45,4 @@ export {
   fixTitle,
   makeLinkWithPath
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL2RhdGF2aWV3LWxpbmsudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBUaGlzIG1vZHVsZSBwcm92aWRlcyB1dGlsaXR5IGZ1bmN0aW9ucyBmb3Igd29ya2luZyB3aXRoIERhdGF2aWV3IGxpbmtzIGluIE9ic2lkaWFuXG4gKi9cblxuaW1wb3J0IHR5cGUge1xuICBEYXRhdmlld0lubGluZUFwaSxcbiAgTGlua1xufSBmcm9tICcuL2RhdGF2aWV3LnRzJztcbmltcG9ydCB0eXBlIHsgUGF0aE9yRmlsZSB9IGZyb20gJy4vZmlsZS1zeXN0ZW0udHMnO1xuXG5pbXBvcnQge1xuICBiYXNlbmFtZSxcbiAgZGlybmFtZSxcbiAgZXh0bmFtZVxufSBmcm9tICcuLi9wYXRoLnRzJztcbmltcG9ydCB7IGdldFBhdGggfSBmcm9tICcuL2ZpbGUtc3lzdGVtLnRzJztcblxuLyoqXG4gKiBGaXhlcyB0aGUgdGl0bGUgb2YgYSBmaWxlIG9yIGZvbGRlciBub3RlIGJ5IGdlbmVyYXRpbmcgYSB7QGxpbmsgTGlua30gb2JqZWN0IHdpdGggYSBwcm9wZXIgdGl0bGUuXG4gKlxuICogQHBhcmFtIGR2IC0gVGhlIERhdGF2aWV3SW5saW5lQXBpIGluc3RhbmNlIHVzZWQgdG8gY3JlYXRlIHRoZSBmaWxlIGxpbmsuXG4gKiBAcGFyYW0gcGF0aE9yRmlsZSAtIFRoZSBmaWxlIHBhdGggZm9yIHdoaWNoIHRoZSB0aXRsZSBpcyB0byBiZSBmaXhlZC5cbiAqIEBwYXJhbSBpc0ZvbGRlck5vdGUgLSBBIGJvb2xlYW4gaW5kaWNhdGluZyB3aGV0aGVyIHRoZSBmaWxlIGlzIGEgZm9sZGVyIG5vdGUuIERlZmF1bHRzIHRvIGBmYWxzZWAuXG4gKiBJZiBgdHJ1ZWAsIHRoZSB0aXRsZSBpcyBkZXJpdmVkIGZyb20gdGhlIGZvbGRlciBuYW1lLiBEZWZhdWx0cyB0byBgZmFsc2VgLlxuICogQHJldHVybnMgQSBMaW5rIG9iamVjdCB3aXRoIHRoZSBjb3JyZWN0ZWQgdGl0bGUuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBmaXhUaXRsZShkdjogRGF0YXZpZXdJbmxpbmVBcGksIHBhdGhPckZpbGU6IFBhdGhPckZpbGUsIGlzRm9sZGVyTm90ZT86IGJvb2xlYW4pOiBMaW5rIHtcbiAgY29uc3QgcGF0aCA9IGdldFBhdGgoZHYuYXBwLCBwYXRoT3JGaWxlKTtcbiAgY29uc3QgZXh0ID0gZXh0bmFtZShwYXRoKTtcbiAgY29uc3QgdGl0bGUgPSBpc0ZvbGRlck5vdGUgPyBiYXNlbmFtZShkaXJuYW1lKHBhdGgpKSA6IGJhc2VuYW1lKHBhdGgsIGV4dCk7XG4gIHJldHVybiBkdi5maWxlTGluayhwYXRoLCBmYWxzZSwgdGl0bGUpO1xufVxuXG4vKipcbiAqIEdlbmVyYXRlcyBhIHN0cmluZyByZXByZXNlbnRhdGlvbiBvZiBhIHtAbGluayBMaW5rfSBvYmplY3QgdGhhdCBpbmNsdWRlcyBib3RoIHRoZSBsaW5rIHRleHQgYW5kIHRoZSBmaWxlIHBhdGguXG4gKlxuICogQHBhcmFtIGxpbmsgLSBUaGUgTGluayBvYmplY3QgdG8gYmUgY29udmVydGVkIHRvIGEgc3RyaW5nIHdpdGggaXRzIHBhdGguXG4gKiBAcmV0dXJucyBBIHN0cmluZyByZXByZXNlbnRpbmcgdGhlIGxpbmsgaW4gdGhlIGZvcm1hdDogXCJsaW5rVGV4dCAobGlua1BhdGgpXCIuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBtYWtlTGlua1dpdGhQYXRoKGxpbms6IExpbmspOiBzdHJpbmcge1xuICByZXR1cm4gYCR7U3RyaW5nKGxpbmspfSAoJHtsaW5rLnBhdGh9KWA7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQVlBO0FBQUEsRUFDRTtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQUEsT0FDSztBQUNQLFNBQVMsZUFBZTtBQVdqQixTQUFTLFNBQVMsSUFBdUIsWUFBd0IsY0FBOEI7QUFDcEcsUUFBTSxPQUFPLFFBQVEsR0FBRyxLQUFLLFVBQVU7QUFDdkMsUUFBTSxNQUFNLFFBQVEsSUFBSTtBQUN4QixRQUFNLFFBQVEsZUFBZSxTQUFTLFFBQVEsSUFBSSxDQUFDLElBQUksU0FBUyxNQUFNLEdBQUc7QUFDekUsU0FBTyxHQUFHLFNBQVMsTUFBTSxPQUFPLEtBQUs7QUFDdkM7QUFRTyxTQUFTLGlCQUFpQixNQUFvQjtBQUNuRCxTQUFPLEdBQUcsT0FBTyxJQUFJLENBQUMsS0FBSyxLQUFLLElBQUk7QUFDdEM7IiwKICAibmFtZXMiOiBbXQp9Cg==
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/dataview.d.mts

@@ -89,6 +89,23 @@ export declare function reloadCurrentFileCache(dv: DataviewInlineApi): Promise<v
  * @typeParam T - The type of the elements.
  */
 export type ArrayOrDataArray<T> = DataArray<T> | T[];
+/**
+ * Parameters for {@link insertCodeBlock}.
+ */
+export interface InsertCodeBlockParams {
+    /**
+     * The code content to be inserted into the code block.
+     */
+    readonly code: string;
+    /**
+     * The DataviewInlineApi instance to insert the code block into.
+     */
+    readonly dv: DataviewInlineApi;
+    /**
+     * The language identifier for the code block.
+     */
+    readonly language: string;
+}
 /**
  * Options for {@link renderIframe}.
  */
@@ -99,6 +116,8 @@ export interface RenderIframeParams {
     readonly dv: DataviewInlineApi;
     /**
      * A height of the iframe.
+     *
+     * @default `'600px'`
      */
     readonly height?: string;
     /**
@@ -107,6 +126,8 @@ export interface RenderIframeParams {
     readonly relativePathOrFile: PathOrFile;
     /**
      * A width of the iframe.
+     *
+     * @default `'100%'`
      */
     readonly width?: string;
 }
@@ -121,7 +142,9 @@ export interface RenderPaginatedListParams<T> {
      */
     readonly dv: DataviewInlineApi;
     /**
-     * Options for items per page. Defaults to `[10, 20, 50, 100]`.
+     * Options for items per page.
+     *
+     * @default `[10, 20, 50, 100]`
      */
     readonly itemsPerPageOptions?: number[];
     /**
@@ -141,6 +164,8 @@ export interface RenderPaginatedParams<T> {
     readonly dv: DataviewInlineApi;
     /**
      * Options for items per page.
+     *
+     * @default `[10, 20, 50, 100]`
      */
     readonly itemsPerPageOptions?: number[];
     /**
@@ -170,7 +195,9 @@ export interface RenderPaginatedTableParams<T> {
      */
     readonly headers: string[];
     /**
-     * Options for items per page. Defaults to `[10, 20, 50, 100]`.
+     * Options for items per page.
+     *
+     * @default `[10, 20, 50, 100]`
      */
     readonly itemsPerPageOptions?: number[];
     /**
@@ -191,11 +218,9 @@ export declare function getRenderedContainer(dv: DataviewInlineApi, renderer: ()
 /**
  * Inserts a code block into the specified Dataview instance using the provided language and code.
  *
- * @param dv - The DataviewInlineApi instance to insert the code block into.
- * @param language - The language identifier for the code block.
- * @param code - The code content to be inserted into the code block.
+ * @param params - The parameters for inserting the code block.
  */
-export declare function insertCodeBlock(dv: DataviewInlineApi, language: string, code: string): void;
+export declare function insertCodeBlock(params: InsertCodeBlockParams): void;
 /**
  * Renders an iframe in the Dataview container with the specified relative path, width, and height.
  *

package/dist/lib/esm/obsidian/dataview.mjs

@@ -31,7 +31,10 @@ import {
 import { t } from "./i18n/i18n.mjs";
 import { relativePathToResourceUrl } from "./resource-url.mjs";
 async function reloadCurrentFileCache(dv) {
-  await activeWindow.DataviewAPI?.index.reload(getFile(dv.app, dv.current().file.path));
+  await activeWindow.DataviewAPI?.index.reload(getFile({
+    app: dv.app,
+    pathOrFile: dv.current().file.path
+  }));
 }
 const paginationCss = `
 .pagination .page-link.disabled {
@@ -74,7 +77,12 @@ async function getRenderedContainer(dv, renderer) {
   }
   return tempContainer;
 }
-function insertCodeBlock(dv, language, code) {
+function insertCodeBlock(params) {
+  const {
+    code,
+    dv,
+    language
+  } = params;
   const MIN_FENCE_LENGTH = 3;
   const fenceRegExp = new RegExp(`^\`{${String(MIN_FENCE_LENGTH)},}`, "gm");
   const fenceMatches = code.matchAll(fenceRegExp);
@@ -96,7 +104,11 @@ function renderIframe(params) {
   dv.el("iframe", "", {
     attr: {
       height,
-      src: relativePathToResourceUrl(dv.app, getPath(dv.app, relativePathOrFile), dv.current().file.path),
+      src: relativePathToResourceUrl({
+        app: dv.app,
+        notePath: dv.current().file.path,
+        relativePath: getPath(dv.app, relativePathOrFile)
+      }),
       width
     }
   });
@@ -154,13 +166,13 @@ async function renderPaginated(params) {
   function createPaginationControls(pageNumber) {
     const paginationDiv = container.createDiv({ cls: "pagination" });
     const paginationRow1Div = paginationDiv.createDiv();
-    createPageLink("First", 1, pageNumber === 1);
-    createPageLink("Prev", pageNumber - 1, pageNumber === 1);
+    createPageLink({ currentPageNumber: 1, disabled: pageNumber === 1, text: "First" });
+    createPageLink({ currentPageNumber: pageNumber - 1, disabled: pageNumber === 1, text: "Prev" });
     if (pageNumber > MORE_PAGE_NUMBER) {
       paginationRow1Div.createSpan({ text: "..." });
     }
     for (let i = Math.max(1, pageNumber - SECOND_PAGE_NUMBER); i <= Math.min(totalPages, pageNumber + SECOND_PAGE_NUMBER); i++) {
-      const pageLink = createPageLink(String(i), i, i === pageNumber);
+      const pageLink = createPageLink({ currentPageNumber: i, disabled: i === pageNumber, text: String(i) });
       if (i === pageNumber) {
         pageLink.addClass("current");
       }
@@ -168,8 +180,8 @@ async function renderPaginated(params) {
     if (pageNumber < totalPages - SECOND_PAGE_NUMBER) {
       paginationRow1Div.createSpan({ text: "..." });
     }
-    createPageLink("Next", pageNumber + 1, pageNumber === totalPages);
-    createPageLink("Last", totalPages, pageNumber === totalPages);
+    createPageLink({ currentPageNumber: pageNumber + 1, disabled: pageNumber === totalPages, text: "Next" });
+    createPageLink({ currentPageNumber: totalPages, disabled: pageNumber === totalPages, text: "Last" });
     const paginationRow2Div = paginationDiv.createDiv();
     paginationRow2Div.createSpan({ text: ` ${t(($) => $.obsidianDevUtils.dataview.itemsPerPage)} ` });
     const itemsPerPageSelect = paginationRow2Div.createEl("select");
@@ -199,7 +211,12 @@ async function renderPaginated(params) {
       })
     );
     paginationRow2Div.createSpan({ text: t(($) => $.obsidianDevUtils.dataview.pageHeader, { pageNumber, totalItems: rows.length, totalPages }) });
-    function createPageLink(text, currentPageNumber, disabled = false) {
+    function createPageLink(params2) {
+      const {
+        currentPageNumber,
+        disabled = false,
+        text
+      } = params2;
       const link = paginationRow1Div.createEl("a", { cls: "page-link", href: `#${String(currentPageNumber)}`, text });
       if (disabled) {
         link.addClass("disabled");
@@ -244,4 +261,4 @@ export {
   renderPaginatedList,
   renderPaginatedTable
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/dataview.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides utility functions for working with Dataview in Obsidian.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport type { DataviewInlineApi as DataviewInlineApiOriginal } from './@types/dataview/api/inline-api.d.ts';\nimport type {\n  DataArray,\n  DataviewApi,\n  SMarkdownPage\n} from './@types/dataview/index.d.ts';\nimport type { PathOrFile } from './file-system.ts';\nimport type { CombinedFrontmatter } from './frontmatter.ts';\n\nimport { convertAsyncToSync } from '../async.ts';\nimport { errorToString } from '../error.ts';\nimport { ensureNonNullable } from '../type-guards.ts';\nimport {\n  getFile,\n  getPath\n} from './file-system.ts';\nimport { t } from './i18n/i18n.ts';\nimport { relativePathToResourceUrl } from './resource-url.ts';\n\n/**\n * Export DateTime and Link types from the Dataview API.\n */\nexport type {\n  DateTime,\n  Link\n} from './@types/dataview/index.d.ts';\n\ndeclare global {\n  /**\n   * A {@link DataviewApi} object represents the API for interacting with Dataview in Obsidian.\n   */\n  // eslint-disable-next-line vars-on-top -- It is a `var` in module declaration. ESLint mistakenly confuses it with `var` as a variable declaration.\n  var DataviewAPI: DataviewApi | undefined;\n}\n\n/**\n * A combined page type, which includes the front matter and the SMarkdownPage.\n *\n * @typeParam CustomFrontmatter - The type of the custom front matter.\n */\nexport type CombinedPage<CustomFrontmatter = unknown> = CombinedFrontmatter<CustomFrontmatter> & SMarkdownPage;\n\n/**\n * Extended interface for the Dataview Inline API, providing additional methods for custom page types and array handling.\n */\nexport interface DataviewInlineApi extends DataviewInlineApiOriginal {\n  /**\n   * Wraps an array of items into a {@link DataArray} object.\n   *\n   * @typeParam T - The type of the items in the array.\n   * @param arr - The array of items to wrap.\n   * @returns A {@link DataArray} containing the items.\n   */\n  array<T>(arr: T[]): DataArray<T>;\n\n  /**\n   * Retrieves the current page, with an optional custom page type.\n   *\n   * @typeParam CustomPage - The type of the custom page. Defaults to `SMarkdownPage`.\n   * @returns The current page.\n   */\n  current<CustomFrontmatter = unknown>(): CombinedPage<CustomFrontmatter>;\n\n  /**\n   * Retrieves pages based on an optional query, with an optional custom page type.\n   *\n   * @typeParam CustomPage - The type of the custom page. Defaults to `SMarkdownPage`.\n   * @param query - An optional string query to filter the pages.\n   * @returns A {@link DataArray} of pages matching the query.\n   */\n  pages<CustomFrontmatter = unknown>(query?: string): DataArray<CombinedPage<CustomFrontmatter>>;\n\n  /**\n   * Creates a paragraph HTML element with the provided text and optional DOM element options.\n   *\n   * @param text - The content of the paragraph.\n   * @param options - Optional DOM element options, including an optional container.\n   * @returns The created HTML paragraph element.\n   */\n  paragraph(\n    text: unknown,\n    options?: DomElementInfoWithContainer\n  ): HTMLParagraphElement;\n}\n\n/**\n * DomElementInfo with an optional container.\n */\nexport type DomElementInfoWithContainer = ContainerInfo & DomElementInfo;\n\n/**\n * A combined file type, which includes the front matter and the SMarkdownFile.\n */\nexport type PageFile = SMarkdownPage['file'];\n\n/**\n * List of page files.\n */\nexport type PageFiles = ArrayOrDataArray<PageFile>;\n\ninterface ContainerInfo {\n  container?: HTMLElement;\n}\n\n/**\n * Reloads the current file cache using the Dataview API.\n *\n * @param dv - The DataviewInlineApi instance.\n * @returns A {@link Promise} that resolves when the cache is reloaded.\n */\nexport async function reloadCurrentFileCache(dv: DataviewInlineApi): Promise<void> {\n  await activeWindow.DataviewAPI?.index.reload(getFile(dv.app, dv.current().file.path));\n}\n\nconst paginationCss = `\n.pagination .page-link.disabled {\n  pointer-events: none;\n  color: gray;\n}\n\n.pagination .page-link {\n  margin: 0 5px;\n  cursor: pointer;\n  text-decoration: none;\n  color: blue;\n}\n\n.pagination .page-link:hover:not(.disabled) {\n  text-decoration: underline;\n}\n.pagination .page-link.current {\n  font-weight: bold;\n  text-decoration: underline;\n}\n\n.pagination select,\n.pagination input {\n  margin: 0 5px;\n}\n`;\n\n/**\n * Array or DataArray type.\n *\n * @typeParam T - The type of the elements.\n */\nexport type ArrayOrDataArray<T> = DataArray<T> | T[];\n\n/**\n * Options for {@link renderIframe}.\n */\nexport interface RenderIframeParams {\n  /**\n   * A {@link DataviewInlineApi} instance.\n   */\n  readonly dv: DataviewInlineApi;\n\n  /**\n   * A height of the iframe.\n   */\n  readonly height?: string;\n\n  /**\n   * A relative path to the resource to be displayed in the iframe.\n   */\n  readonly relativePathOrFile: PathOrFile;\n\n  /**\n   * A width of the iframe.\n   */\n  readonly width?: string;\n}\n\n/**\n * Options for {@link renderPaginatedList}.\n *\n * @typeParam T - The type of the list items.\n */\nexport interface RenderPaginatedListParams<T> {\n  /**\n   * A {@link DataviewInlineApi} instance.\n   */\n  readonly dv: DataviewInlineApi;\n\n  /**\n   * Options for items per page. Defaults to `[10, 20, 50, 100]`.\n   */\n  readonly itemsPerPageOptions?: number[];\n\n  /**\n   * A list of items to paginate.\n   */\n  readonly rows: ArrayOrDataArray<T>;\n}\n\n/**\n * Options for {@link renderPaginated}.\n *\n * @typeParam T - The type of the items to paginate.\n */\nexport interface RenderPaginatedParams<T> {\n  /**\n   * A {@link DataviewInlineApi} instance.\n   */\n  readonly dv: DataviewInlineApi;\n\n  /**\n   * Options for items per page.\n   */\n  readonly itemsPerPageOptions?: number[];\n\n  /**\n   * Display the paginated content.\n   *\n   * @param rowsForOnePage - The rows to render.\n   * @returns A {@link Promise} that resolves when the content is rendered.\n   */\n  renderer(rowsForOnePage: ArrayOrDataArray<T>): Promisable<void>;\n\n  /**\n   * Rows to paginate.\n   */\n  readonly rows: ArrayOrDataArray<T>;\n}\n\n/**\n * Options for {@link renderPaginatedTable}.\n *\n * @typeParam T - The type of the table row data.\n */\nexport interface RenderPaginatedTableParams<T> {\n  /**\n   * A {@link DataviewInlineApi} instance.\n   */\n  readonly dv: DataviewInlineApi;\n\n  /**\n   * A headers of the table.\n   */\n  readonly headers: string[];\n\n  /**\n   * Options for items per page. Defaults to `[10, 20, 50, 100]`.\n   */\n  readonly itemsPerPageOptions?: number[];\n\n  /**\n   * Rows of the table to paginate.\n   */\n  readonly rows: ArrayOrDataArray<T>;\n}\n\n/**\n * Renders the content using the provided renderer function in a temporary container,\n * and then returns the container.\n *\n * @param dv - The DataviewInlineApi instance.\n * @param renderer - The function responsible for rendering the content.\n * @returns A {@link Promise} that resolves to the HTML paragraph element\n * that was used as the temporary container.\n */\nexport async function getRenderedContainer(dv: DataviewInlineApi, renderer: () => Promisable<void>): Promise<HTMLParagraphElement> {\n  const oldContainer = dv.container;\n  const tempContainer = dv.paragraph('');\n  dv.container = tempContainer;\n  dv.container.empty();\n\n  try {\n    await renderer();\n  } catch (e) {\n    dv.paragraph(`\u274C${errorToString(e)}`);\n  } finally {\n    // eslint-disable-next-line require-atomic-updates -- Yes, it is a potential race condition, but I don't an elegant way to fix it.\n    dv.container = oldContainer;\n    tempContainer.remove();\n  }\n\n  return tempContainer;\n}\n\n/**\n * Inserts a code block into the specified Dataview instance using the provided language and code.\n *\n * @param dv - The DataviewInlineApi instance to insert the code block into.\n * @param language - The language identifier for the code block.\n * @param code - The code content to be inserted into the code block.\n */\nexport function insertCodeBlock(dv: DataviewInlineApi, language: string, code: string): void {\n  const MIN_FENCE_LENGTH = 3;\n  const fenceRegExp = new RegExp(`^\\`{${String(MIN_FENCE_LENGTH)},}`, 'gm');\n  const fenceMatches = code.matchAll(fenceRegExp);\n  const fenceLengths = Array.from(fenceMatches).map((fenceMatch) => fenceMatch[0].length);\n  const maxFenceLength = Math.max(0, ...fenceLengths);\n  const resultFenceLength = Math.max(MIN_FENCE_LENGTH, maxFenceLength + 1);\n  const resultFence = '`'.repeat(resultFenceLength);\n\n  dv.paragraph(`${resultFence}${language}\n${code}\n${resultFence}`);\n}\n\n/**\n * Renders an iframe in the Dataview container with the specified relative path, width, and height.\n *\n * @param params - The parameters for rendering the iframe.\n */\nexport function renderIframe(params: RenderIframeParams): void {\n  const {\n    dv,\n    height = '600px',\n    relativePathOrFile,\n    width = '100%'\n  } = params;\n  dv.el('iframe', '', {\n    attr: {\n      height,\n      src: relativePathToResourceUrl(dv.app, getPath(dv.app, relativePathOrFile), dv.current().file.path),\n      width\n    }\n  });\n}\n\n/**\n * Renders a paginated list using the provided DataviewInlineApi instance.\n *\n * @typeParam T - The type of items in the list.\n *\n * @param params - The parameters for rendering the paginated list.\n *\n * @returns A {@link Promise} that resolves when the list is rendered.\n */\nexport async function renderPaginatedList<T>(params: RenderPaginatedListParams<T>): Promise<void> {\n  const {\n    dv,\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    itemsPerPageOptions = [10, 20, 50, 100],\n    rows\n  } = params;\n  await renderPaginated({\n    dv,\n    itemsPerPageOptions,\n    renderer: async (rowsForOnePage: ArrayOrDataArray<T>): Promise<void> => {\n      await dv.list(rowsForOnePage);\n    },\n    rows\n  });\n}\n\n/**\n * Renders a paginated table using the provided DataviewInlineApi instance.\n *\n * @typeParam T - The type of items in the table rows.\n *\n * @param params - The parameters for rendering the paginated table.\n *\n * @returns A {@link Promise} that resolves when the table is rendered.\n */\nexport async function renderPaginatedTable<T extends unknown[]>(params: RenderPaginatedTableParams<T>): Promise<void> {\n  const {\n    dv,\n    headers,\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    itemsPerPageOptions = [10, 20, 50, 100],\n    rows\n  } = params;\n  await renderPaginated({\n    dv,\n    itemsPerPageOptions,\n    renderer: async (rowsForOnePage: ArrayOrDataArray<T>): Promise<void> => {\n      await dv.table(headers, rowsForOnePage);\n    },\n    rows\n  });\n}\n\n/**\n * Helper function to render paginated content using the specified renderer.\n *\n * @typeParam T - The type of items to paginate.\n *\n * @param params - The parameters for rendering the paginated content.\n *\n * @returns A {@link Promise} that resolves when the content is rendered.\n */\nasync function renderPaginated<T>(params: RenderPaginatedParams<T>): Promise<void> {\n  const SECOND_PAGE_NUMBER = 2;\n  const MORE_PAGE_NUMBER = 3;\n  const {\n    dv,\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    itemsPerPageOptions = [10, 20, 50, 100],\n    rows\n  } = params;\n  if (rows.length === 0) {\n    dv.paragraph('No items found');\n    return;\n  }\n  const container = dv.container;\n  let itemsPerPage = ensureNonNullable(itemsPerPageOptions[0], 'Items per page options are empty');\n  let totalPages = Math.ceil(rows.length / itemsPerPage);\n  await renderPage(1);\n\n  function createPaginationControls(pageNumber: number): void {\n    const paginationDiv = container.createDiv({ cls: 'pagination' });\n    const paginationRow1Div = paginationDiv.createDiv();\n\n    createPageLink('First', 1, pageNumber === 1);\n    createPageLink('Prev', pageNumber - 1, pageNumber === 1);\n\n    if (pageNumber > MORE_PAGE_NUMBER) {\n      paginationRow1Div.createSpan({ text: '...' });\n    }\n\n    for (let i = Math.max(1, pageNumber - SECOND_PAGE_NUMBER); i <= Math.min(totalPages, pageNumber + SECOND_PAGE_NUMBER); i++) {\n      const pageLink = createPageLink(String(i), i, i === pageNumber);\n      if (i === pageNumber) {\n        pageLink.addClass('current');\n      }\n    }\n\n    if (pageNumber < totalPages - SECOND_PAGE_NUMBER) {\n      paginationRow1Div.createSpan({ text: '...' });\n    }\n\n    createPageLink('Next', pageNumber + 1, pageNumber === totalPages);\n    createPageLink('Last', totalPages, pageNumber === totalPages);\n\n    const paginationRow2Div = paginationDiv.createDiv();\n\n    paginationRow2Div.createSpan({ text: ` ${t(($) => $.obsidianDevUtils.dataview.itemsPerPage)} ` });\n\n    const itemsPerPageSelect = paginationRow2Div.createEl('select');\n    itemsPerPageOptions.forEach((option: number): void => {\n      itemsPerPageSelect.createEl('option', { text: String(option), value: String(option) });\n    });\n    itemsPerPageSelect.value = String(itemsPerPage);\n    itemsPerPageSelect.addEventListener(\n      'change',\n      convertAsyncToSync(async (): Promise<void> => {\n        itemsPerPage = parseInt(itemsPerPageSelect.value, 10);\n        totalPages = Math.ceil(rows.length / itemsPerPage);\n        await renderPage(1);\n      })\n    );\n\n    paginationRow2Div.createSpan({ text: ` ${t(($) => $.obsidianDevUtils.dataview.jumpToPage)} ` });\n\n    const jumpToPageInput = paginationRow2Div.createEl('input', { attr: { max: totalPages, min: 1 }, type: 'number' });\n    jumpToPageInput.addEventListener(\n      'keydown',\n      convertAsyncToSync(async (event: KeyboardEvent): Promise<void> => {\n        if (event.key === 'Enter') {\n          const page = parseInt(jumpToPageInput.value, 10);\n          if (page >= 1 && page <= totalPages) {\n            await renderPage(page);\n          }\n        }\n      })\n    );\n\n    paginationRow2Div.createSpan({ text: t(($) => $.obsidianDevUtils.dataview.pageHeader, { pageNumber, totalItems: rows.length, totalPages }) });\n\n    function createPageLink(text: string, currentPageNumber: number, disabled = false): HTMLAnchorElement {\n      const link = paginationRow1Div.createEl('a', { cls: 'page-link', href: `#${String(currentPageNumber)}`, text });\n      if (disabled) {\n        link.addClass('disabled');\n        link.onclick = (event: MouseEvent): void => {\n          event.preventDefault();\n        };\n      } else {\n        link.addEventListener(\n          'click',\n          convertAsyncToSync(async (event: MouseEvent): Promise<void> => {\n            event.preventDefault();\n            await renderPage(currentPageNumber);\n          })\n        );\n      }\n      return link;\n    }\n  }\n\n  async function renderPage(pageNumber: number): Promise<void> {\n    container.empty();\n    // eslint-disable-next-line obsidianmd/no-forbidden-elements -- We need to create a style element to apply the pagination CSS.\n    container.createEl('style', { text: paginationCss });\n\n    const startIndex = (pageNumber - 1) * itemsPerPage;\n    const endIndex = startIndex + itemsPerPage;\n    const rowsForCurrentPage = rows.slice(startIndex, endIndex);\n\n    const oldContainer = dv.container;\n\n    dv.container = container;\n    try {\n      await params.renderer(rowsForCurrentPage);\n    } catch (e) {\n      dv.paragraph(`\u274C${errorToString(e)}`);\n    } finally {\n      // eslint-disable-next-line require-atomic-updates -- Yes, it is a potential race condition, but I don't an elegant way to fix it.\n      dv.container = oldContainer;\n    }\n\n    createPaginationControls(pageNumber);\n  }\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/dataview.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides utility functions for working with Dataview in Obsidian.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport type { DataviewInlineApi as DataviewInlineApiOriginal } from './@types/dataview/api/inline-api.d.ts';\nimport type {\n  DataArray,\n  DataviewApi,\n  SMarkdownPage\n} from './@types/dataview/index.d.ts';\nimport type { PathOrFile } from './file-system.ts';\nimport type { CombinedFrontmatter } from './frontmatter.ts';\n\nimport { convertAsyncToSync } from '../async.ts';\nimport { errorToString } from '../error.ts';\nimport { ensureNonNullable } from '../type-guards.ts';\nimport {\n  getFile,\n  getPath\n} from './file-system.ts';\nimport { t } from './i18n/i18n.ts';\nimport { relativePathToResourceUrl } from './resource-url.ts';\n\n/**\n * Export DateTime and Link types from the Dataview API.\n */\nexport type {\n  DateTime,\n  Link\n} from './@types/dataview/index.d.ts';\n\ndeclare global {\n  /**\n   * A {@link DataviewApi} object represents the API for interacting with Dataview in Obsidian.\n   */\n  // eslint-disable-next-line vars-on-top -- It is a `var` in module declaration. ESLint mistakenly confuses it with `var` as a variable declaration.\n  var DataviewAPI: DataviewApi | undefined;\n}\n\n/**\n * A combined page type, which includes the front matter and the SMarkdownPage.\n *\n * @typeParam CustomFrontmatter - The type of the custom front matter.\n */\nexport type CombinedPage<CustomFrontmatter = unknown> = CombinedFrontmatter<CustomFrontmatter> & SMarkdownPage;\n\n/**\n * Extended interface for the Dataview Inline API, providing additional methods for custom page types and array handling.\n */\nexport interface DataviewInlineApi extends DataviewInlineApiOriginal {\n  /**\n   * Wraps an array of items into a {@link DataArray} object.\n   *\n   * @typeParam T - The type of the items in the array.\n   * @param arr - The array of items to wrap.\n   * @returns A {@link DataArray} containing the items.\n   */\n  array<T>(arr: T[]): DataArray<T>;\n\n  /**\n   * Retrieves the current page, with an optional custom page type.\n   *\n   * @typeParam CustomPage - The type of the custom page. Defaults to `SMarkdownPage`.\n   * @returns The current page.\n   */\n  current<CustomFrontmatter = unknown>(): CombinedPage<CustomFrontmatter>;\n\n  /**\n   * Retrieves pages based on an optional query, with an optional custom page type.\n   *\n   * @typeParam CustomPage - The type of the custom page. Defaults to `SMarkdownPage`.\n   * @param query - An optional string query to filter the pages.\n   * @returns A {@link DataArray} of pages matching the query.\n   */\n  pages<CustomFrontmatter = unknown>(query?: string): DataArray<CombinedPage<CustomFrontmatter>>;\n\n  /**\n   * Creates a paragraph HTML element with the provided text and optional DOM element options.\n   *\n   * @param text - The content of the paragraph.\n   * @param options - Optional DOM element options, including an optional container.\n   * @returns The created HTML paragraph element.\n   */\n  paragraph(\n    text: unknown,\n    options?: DomElementInfoWithContainer\n  ): HTMLParagraphElement;\n}\n\n/**\n * DomElementInfo with an optional container.\n */\nexport type DomElementInfoWithContainer = ContainerInfo & DomElementInfo;\n\n/**\n * A combined file type, which includes the front matter and the SMarkdownFile.\n */\nexport type PageFile = SMarkdownPage['file'];\n\n/**\n * List of page files.\n */\nexport type PageFiles = ArrayOrDataArray<PageFile>;\n\ninterface ContainerInfo {\n  container?: HTMLElement;\n}\n\n/**\n * Reloads the current file cache using the Dataview API.\n *\n * @param dv - The DataviewInlineApi instance.\n * @returns A {@link Promise} that resolves when the cache is reloaded.\n */\nexport async function reloadCurrentFileCache(dv: DataviewInlineApi): Promise<void> {\n  await activeWindow.DataviewAPI?.index.reload(getFile({\n    app: dv.app,\n    pathOrFile: dv.current().file.path\n  }));\n}\n\nconst paginationCss = `\n.pagination .page-link.disabled {\n  pointer-events: none;\n  color: gray;\n}\n\n.pagination .page-link {\n  margin: 0 5px;\n  cursor: pointer;\n  text-decoration: none;\n  color: blue;\n}\n\n.pagination .page-link:hover:not(.disabled) {\n  text-decoration: underline;\n}\n.pagination .page-link.current {\n  font-weight: bold;\n  text-decoration: underline;\n}\n\n.pagination select,\n.pagination input {\n  margin: 0 5px;\n}\n`;\n\n/**\n * Array or DataArray type.\n *\n * @typeParam T - The type of the elements.\n */\nexport type ArrayOrDataArray<T> = DataArray<T> | T[];\n\n/**\n * Parameters for {@link insertCodeBlock}.\n */\nexport interface InsertCodeBlockParams {\n  /**\n   * The code content to be inserted into the code block.\n   */\n  readonly code: string;\n\n  /**\n   * The DataviewInlineApi instance to insert the code block into.\n   */\n  readonly dv: DataviewInlineApi;\n\n  /**\n   * The language identifier for the code block.\n   */\n  readonly language: string;\n}\n\n/**\n * Options for {@link renderIframe}.\n */\nexport interface RenderIframeParams {\n  /**\n   * A {@link DataviewInlineApi} instance.\n   */\n  readonly dv: DataviewInlineApi;\n\n  /**\n   * A height of the iframe.\n   *\n   * @default `'600px'`\n   */\n  readonly height?: string;\n\n  /**\n   * A relative path to the resource to be displayed in the iframe.\n   */\n  readonly relativePathOrFile: PathOrFile;\n\n  /**\n   * A width of the iframe.\n   *\n   * @default `'100%'`\n   */\n  readonly width?: string;\n}\n\n/**\n * Options for {@link renderPaginatedList}.\n *\n * @typeParam T - The type of the list items.\n */\nexport interface RenderPaginatedListParams<T> {\n  /**\n   * A {@link DataviewInlineApi} instance.\n   */\n  readonly dv: DataviewInlineApi;\n\n  /**\n   * Options for items per page.\n   *\n   * @default `[10, 20, 50, 100]`\n   */\n  readonly itemsPerPageOptions?: number[];\n\n  /**\n   * A list of items to paginate.\n   */\n  readonly rows: ArrayOrDataArray<T>;\n}\n\n/**\n * Options for {@link renderPaginated}.\n *\n * @typeParam T - The type of the items to paginate.\n */\nexport interface RenderPaginatedParams<T> {\n  /**\n   * A {@link DataviewInlineApi} instance.\n   */\n  readonly dv: DataviewInlineApi;\n\n  /**\n   * Options for items per page.\n   *\n   * @default `[10, 20, 50, 100]`\n   */\n  readonly itemsPerPageOptions?: number[];\n\n  /**\n   * Display the paginated content.\n   *\n   * @param rowsForOnePage - The rows to render.\n   * @returns A {@link Promise} that resolves when the content is rendered.\n   */\n  renderer(rowsForOnePage: ArrayOrDataArray<T>): Promisable<void>;\n\n  /**\n   * Rows to paginate.\n   */\n  readonly rows: ArrayOrDataArray<T>;\n}\n\n/**\n * Options for {@link renderPaginatedTable}.\n *\n * @typeParam T - The type of the table row data.\n */\nexport interface RenderPaginatedTableParams<T> {\n  /**\n   * A {@link DataviewInlineApi} instance.\n   */\n  readonly dv: DataviewInlineApi;\n\n  /**\n   * A headers of the table.\n   */\n  readonly headers: string[];\n\n  /**\n   * Options for items per page.\n   *\n   * @default `[10, 20, 50, 100]`\n   */\n  readonly itemsPerPageOptions?: number[];\n\n  /**\n   * Rows of the table to paginate.\n   */\n  readonly rows: ArrayOrDataArray<T>;\n}\n\n/**\n * Parameters for {@link createPageLink}.\n */\ninterface CreatePageLinkParams {\n  /**\n   * The page number the link points to.\n   */\n  readonly currentPageNumber: number;\n\n  /**\n   * Whether the link is disabled.\n   */\n  readonly disabled?: boolean;\n\n  /**\n   * The text to display for the link.\n   */\n  readonly text: string;\n}\n\n/**\n * Renders the content using the provided renderer function in a temporary container,\n * and then returns the container.\n *\n * @param dv - The DataviewInlineApi instance.\n * @param renderer - The function responsible for rendering the content.\n * @returns A {@link Promise} that resolves to the HTML paragraph element\n * that was used as the temporary container.\n */\nexport async function getRenderedContainer(dv: DataviewInlineApi, renderer: () => Promisable<void>): Promise<HTMLParagraphElement> {\n  const oldContainer = dv.container;\n  const tempContainer = dv.paragraph('');\n  dv.container = tempContainer;\n  dv.container.empty();\n\n  try {\n    await renderer();\n  } catch (e) {\n    dv.paragraph(`\u274C${errorToString(e)}`);\n  } finally {\n    // eslint-disable-next-line require-atomic-updates -- Yes, it is a potential race condition, but I don't an elegant way to fix it.\n    dv.container = oldContainer;\n    tempContainer.remove();\n  }\n\n  return tempContainer;\n}\n\n/**\n * Inserts a code block into the specified Dataview instance using the provided language and code.\n *\n * @param params - The parameters for inserting the code block.\n */\nexport function insertCodeBlock(params: InsertCodeBlockParams): void {\n  const {\n    code,\n    dv,\n    language\n  } = params;\n  const MIN_FENCE_LENGTH = 3;\n  const fenceRegExp = new RegExp(`^\\`{${String(MIN_FENCE_LENGTH)},}`, 'gm');\n  const fenceMatches = code.matchAll(fenceRegExp);\n  const fenceLengths = Array.from(fenceMatches).map((fenceMatch) => fenceMatch[0].length);\n  const maxFenceLength = Math.max(0, ...fenceLengths);\n  const resultFenceLength = Math.max(MIN_FENCE_LENGTH, maxFenceLength + 1);\n  const resultFence = '`'.repeat(resultFenceLength);\n\n  dv.paragraph(`${resultFence}${language}\n${code}\n${resultFence}`);\n}\n\n/**\n * Renders an iframe in the Dataview container with the specified relative path, width, and height.\n *\n * @param params - The parameters for rendering the iframe.\n */\nexport function renderIframe(params: RenderIframeParams): void {\n  const {\n    dv,\n    height = '600px',\n    relativePathOrFile,\n    width = '100%'\n  } = params;\n  dv.el('iframe', '', {\n    attr: {\n      height,\n      src: relativePathToResourceUrl({\n        app: dv.app,\n        notePath: dv.current().file.path,\n        relativePath: getPath(dv.app, relativePathOrFile)\n      }),\n      width\n    }\n  });\n}\n\n/**\n * Renders a paginated list using the provided DataviewInlineApi instance.\n *\n * @typeParam T - The type of items in the list.\n *\n * @param params - The parameters for rendering the paginated list.\n *\n * @returns A {@link Promise} that resolves when the list is rendered.\n */\nexport async function renderPaginatedList<T>(params: RenderPaginatedListParams<T>): Promise<void> {\n  const {\n    dv,\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    itemsPerPageOptions = [10, 20, 50, 100],\n    rows\n  } = params;\n  await renderPaginated({\n    dv,\n    itemsPerPageOptions,\n    renderer: async (rowsForOnePage: ArrayOrDataArray<T>): Promise<void> => {\n      await dv.list(rowsForOnePage);\n    },\n    rows\n  });\n}\n\n/**\n * Renders a paginated table using the provided DataviewInlineApi instance.\n *\n * @typeParam T - The type of items in the table rows.\n *\n * @param params - The parameters for rendering the paginated table.\n *\n * @returns A {@link Promise} that resolves when the table is rendered.\n */\nexport async function renderPaginatedTable<T extends unknown[]>(params: RenderPaginatedTableParams<T>): Promise<void> {\n  const {\n    dv,\n    headers,\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    itemsPerPageOptions = [10, 20, 50, 100],\n    rows\n  } = params;\n  await renderPaginated({\n    dv,\n    itemsPerPageOptions,\n    renderer: async (rowsForOnePage: ArrayOrDataArray<T>): Promise<void> => {\n      await dv.table(headers, rowsForOnePage);\n    },\n    rows\n  });\n}\n\n/**\n * Helper function to render paginated content using the specified renderer.\n *\n * @typeParam T - The type of items to paginate.\n *\n * @param params - The parameters for rendering the paginated content.\n *\n * @returns A {@link Promise} that resolves when the content is rendered.\n */\nasync function renderPaginated<T>(params: RenderPaginatedParams<T>): Promise<void> {\n  const SECOND_PAGE_NUMBER = 2;\n  const MORE_PAGE_NUMBER = 3;\n  const {\n    dv,\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    itemsPerPageOptions = [10, 20, 50, 100],\n    rows\n  } = params;\n  if (rows.length === 0) {\n    dv.paragraph('No items found');\n    return;\n  }\n  const container = dv.container;\n  let itemsPerPage = ensureNonNullable(itemsPerPageOptions[0], 'Items per page options are empty');\n  let totalPages = Math.ceil(rows.length / itemsPerPage);\n  await renderPage(1);\n\n  function createPaginationControls(pageNumber: number): void {\n    const paginationDiv = container.createDiv({ cls: 'pagination' });\n    const paginationRow1Div = paginationDiv.createDiv();\n\n    createPageLink({ currentPageNumber: 1, disabled: pageNumber === 1, text: 'First' });\n    createPageLink({ currentPageNumber: pageNumber - 1, disabled: pageNumber === 1, text: 'Prev' });\n\n    if (pageNumber > MORE_PAGE_NUMBER) {\n      paginationRow1Div.createSpan({ text: '...' });\n    }\n\n    for (let i = Math.max(1, pageNumber - SECOND_PAGE_NUMBER); i <= Math.min(totalPages, pageNumber + SECOND_PAGE_NUMBER); i++) {\n      const pageLink = createPageLink({ currentPageNumber: i, disabled: i === pageNumber, text: String(i) });\n      if (i === pageNumber) {\n        pageLink.addClass('current');\n      }\n    }\n\n    if (pageNumber < totalPages - SECOND_PAGE_NUMBER) {\n      paginationRow1Div.createSpan({ text: '...' });\n    }\n\n    createPageLink({ currentPageNumber: pageNumber + 1, disabled: pageNumber === totalPages, text: 'Next' });\n    createPageLink({ currentPageNumber: totalPages, disabled: pageNumber === totalPages, text: 'Last' });\n\n    const paginationRow2Div = paginationDiv.createDiv();\n\n    paginationRow2Div.createSpan({ text: ` ${t(($) => $.obsidianDevUtils.dataview.itemsPerPage)} ` });\n\n    const itemsPerPageSelect = paginationRow2Div.createEl('select');\n    itemsPerPageOptions.forEach((option: number): void => {\n      itemsPerPageSelect.createEl('option', { text: String(option), value: String(option) });\n    });\n    itemsPerPageSelect.value = String(itemsPerPage);\n    itemsPerPageSelect.addEventListener(\n      'change',\n      convertAsyncToSync(async (): Promise<void> => {\n        itemsPerPage = parseInt(itemsPerPageSelect.value, 10);\n        totalPages = Math.ceil(rows.length / itemsPerPage);\n        await renderPage(1);\n      })\n    );\n\n    paginationRow2Div.createSpan({ text: ` ${t(($) => $.obsidianDevUtils.dataview.jumpToPage)} ` });\n\n    const jumpToPageInput = paginationRow2Div.createEl('input', { attr: { max: totalPages, min: 1 }, type: 'number' });\n    jumpToPageInput.addEventListener(\n      'keydown',\n      convertAsyncToSync(async (event: KeyboardEvent): Promise<void> => {\n        if (event.key === 'Enter') {\n          const page = parseInt(jumpToPageInput.value, 10);\n          if (page >= 1 && page <= totalPages) {\n            await renderPage(page);\n          }\n        }\n      })\n    );\n\n    paginationRow2Div.createSpan({ text: t(($) => $.obsidianDevUtils.dataview.pageHeader, { pageNumber, totalItems: rows.length, totalPages }) });\n\n    function createPageLink(params2: CreatePageLinkParams): HTMLAnchorElement {\n      const {\n        currentPageNumber,\n        disabled = false,\n        text\n      } = params2;\n      const link = paginationRow1Div.createEl('a', { cls: 'page-link', href: `#${String(currentPageNumber)}`, text });\n      if (disabled) {\n        link.addClass('disabled');\n        link.onclick = (event: MouseEvent): void => {\n          event.preventDefault();\n        };\n      } else {\n        link.addEventListener(\n          'click',\n          convertAsyncToSync(async (event: MouseEvent): Promise<void> => {\n            event.preventDefault();\n            await renderPage(currentPageNumber);\n          })\n        );\n      }\n      return link;\n    }\n  }\n\n  async function renderPage(pageNumber: number): Promise<void> {\n    container.empty();\n    // eslint-disable-next-line obsidianmd/no-forbidden-elements -- We need to create a style element to apply the pagination CSS.\n    container.createEl('style', { text: paginationCss });\n\n    const startIndex = (pageNumber - 1) * itemsPerPage;\n    const endIndex = startIndex + itemsPerPage;\n    const rowsForCurrentPage = rows.slice(startIndex, endIndex);\n\n    const oldContainer = dv.container;\n\n    dv.container = container;\n    try {\n      await params.renderer(rowsForCurrentPage);\n    } catch (e) {\n      dv.paragraph(`\u274C${errorToString(e)}`);\n    } finally {\n      // eslint-disable-next-line require-atomic-updates -- Yes, it is a potential race condition, but I don't an elegant way to fix it.\n      dv.container = oldContainer;\n    }\n\n    createPaginationControls(pageNumber);\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAiBA,SAAS,0BAA0B;AACnC,SAAS,qBAAqB;AAC9B,SAAS,yBAAyB;AAClC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,SAAS;AAClB,SAAS,iCAAiC;AA6F1C,eAAsB,uBAAuB,IAAsC;AACjF,QAAM,aAAa,aAAa,MAAM,OAAO,QAAQ;AAAA,IACnD,KAAK,GAAG;AAAA,IACR,YAAY,GAAG,QAAQ,EAAE,KAAK;AAAA,EAChC,CAAC,CAAC;AACJ;AAEA,MAAM,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAqMtB,eAAsB,qBAAqB,IAAuB,UAAiE;AACjI,QAAM,eAAe,GAAG;AACxB,QAAM,gBAAgB,GAAG,UAAU,EAAE;AACrC,KAAG,YAAY;AACf,KAAG,UAAU,MAAM;AAEnB,MAAI;AACF,UAAM,SAAS;AAAA,EACjB,SAAS,GAAG;AACV,OAAG,UAAU,SAAI,cAAc,CAAC,CAAC,EAAE;AAAA,EACrC,UAAE;AAEA,OAAG,YAAY;AACf,kBAAc,OAAO;AAAA,EACvB;AAEA,SAAO;AACT;AAOO,SAAS,gBAAgB,QAAqC;AACnE,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AACJ,QAAM,mBAAmB;AACzB,QAAM,cAAc,IAAI,OAAO,OAAO,OAAO,gBAAgB,CAAC,MAAM,IAAI;AACxE,QAAM,eAAe,KAAK,SAAS,WAAW;AAC9C,QAAM,eAAe,MAAM,KAAK,YAAY,EAAE,IAAI,CAAC,eAAe,WAAW,CAAC,EAAE,MAAM;AACtF,QAAM,iBAAiB,KAAK,IAAI,GAAG,GAAG,YAAY;AAClD,QAAM,oBAAoB,KAAK,IAAI,kBAAkB,iBAAiB,CAAC;AACvE,QAAM,cAAc,IAAI,OAAO,iBAAiB;AAEhD,KAAG,UAAU,GAAG,WAAW,GAAG,QAAQ;AAAA,EACtC,IAAI;AAAA,EACJ,WAAW,EAAE;AACf;AAOO,SAAS,aAAa,QAAkC;AAC7D,QAAM;AAAA,IACJ;AAAA,IACA,SAAS;AAAA,IACT;AAAA,IACA,QAAQ;AAAA,EACV,IAAI;AACJ,KAAG,GAAG,UAAU,IAAI;AAAA,IAClB,MAAM;AAAA,MACJ;AAAA,MACA,KAAK,0BAA0B;AAAA,QAC7B,KAAK,GAAG;AAAA,QACR,UAAU,GAAG,QAAQ,EAAE,KAAK;AAAA,QAC5B,cAAc,QAAQ,GAAG,KAAK,kBAAkB;AAAA,MAClD,CAAC;AAAA,MACD;AAAA,IACF;AAAA,EACF,CAAC;AACH;AAWA,eAAsB,oBAAuB,QAAqD;AAChG,QAAM;AAAA,IACJ;AAAA;AAAA,IAEA,sBAAsB,CAAC,IAAI,IAAI,IAAI,GAAG;AAAA,IACtC;AAAA,EACF,IAAI;AACJ,QAAM,gBAAgB;AAAA,IACpB;AAAA,IACA;AAAA,IACA,UAAU,OAAO,mBAAuD;AACtE,YAAM,GAAG,KAAK,cAAc;AAAA,IAC9B;AAAA,IACA;AAAA,EACF,CAAC;AACH;AAWA,eAAsB,qBAA0C,QAAsD;AACpH,QAAM;AAAA,IACJ;AAAA,IACA;AAAA;AAAA,IAEA,sBAAsB,CAAC,IAAI,IAAI,IAAI,GAAG;AAAA,IACtC;AAAA,EACF,IAAI;AACJ,QAAM,gBAAgB;AAAA,IACpB;AAAA,IACA;AAAA,IACA,UAAU,OAAO,mBAAuD;AACtE,YAAM,GAAG,MAAM,SAAS,cAAc;AAAA,IACxC;AAAA,IACA;AAAA,EACF,CAAC;AACH;AAWA,eAAe,gBAAmB,QAAiD;AACjF,QAAM,qBAAqB;AAC3B,QAAM,mBAAmB;AACzB,QAAM;AAAA,IACJ;AAAA;AAAA,IAEA,sBAAsB,CAAC,IAAI,IAAI,IAAI,GAAG;AAAA,IACtC;AAAA,EACF,IAAI;AACJ,MAAI,KAAK,WAAW,GAAG;AACrB,OAAG,UAAU,gBAAgB;AAC7B;AAAA,EACF;AACA,QAAM,YAAY,GAAG;AACrB,MAAI,eAAe,kBAAkB,oBAAoB,CAAC,GAAG,kCAAkC;AAC/F,MAAI,aAAa,KAAK,KAAK,KAAK,SAAS,YAAY;AACrD,QAAM,WAAW,CAAC;AAElB,WAAS,yBAAyB,YAA0B;AAC1D,UAAM,gBAAgB,UAAU,UAAU,EAAE,KAAK,aAAa,CAAC;AAC/D,UAAM,oBAAoB,cAAc,UAAU;AAElD,mBAAe,EAAE,mBAAmB,GAAG,UAAU,eAAe,GAAG,MAAM,QAAQ,CAAC;AAClF,mBAAe,EAAE,mBAAmB,aAAa,GAAG,UAAU,eAAe,GAAG,MAAM,OAAO,CAAC;AAE9F,QAAI,aAAa,kBAAkB;AACjC,wBAAkB,WAAW,EAAE,MAAM,MAAM,CAAC;AAAA,IAC9C;AAEA,aAAS,IAAI,KAAK,IAAI,GAAG,aAAa,kBAAkB,GAAG,KAAK,KAAK,IAAI,YAAY,aAAa,kBAAkB,GAAG,KAAK;AAC1H,YAAM,WAAW,eAAe,EAAE,mBAAmB,GAAG,UAAU,MAAM,YAAY,MAAM,OAAO,CAAC,EAAE,CAAC;AACrG,UAAI,MAAM,YAAY;AACpB,iBAAS,SAAS,SAAS;AAAA,MAC7B;AAAA,IACF;AAEA,QAAI,aAAa,aAAa,oBAAoB;AAChD,wBAAkB,WAAW,EAAE,MAAM,MAAM,CAAC;AAAA,IAC9C;AAEA,mBAAe,EAAE,mBAAmB,aAAa,GAAG,UAAU,eAAe,YAAY,MAAM,OAAO,CAAC;AACvG,mBAAe,EAAE,mBAAmB,YAAY,UAAU,eAAe,YAAY,MAAM,OAAO,CAAC;AAEnG,UAAM,oBAAoB,cAAc,UAAU;AAElD,sBAAkB,WAAW,EAAE,MAAM,IAAI,EAAE,CAAC,MAAM,EAAE,iBAAiB,SAAS,YAAY,CAAC,IAAI,CAAC;AAEhG,UAAM,qBAAqB,kBAAkB,SAAS,QAAQ;AAC9D,wBAAoB,QAAQ,CAAC,WAAyB;AACpD,yBAAmB,SAAS,UAAU,EAAE,MAAM,OAAO,MAAM,GAAG,OAAO,OAAO,MAAM,EAAE,CAAC;AAAA,IACvF,CAAC;AACD,uBAAmB,QAAQ,OAAO,YAAY;AAC9C,uBAAmB;AAAA,MACjB;AAAA,MACA,mBAAmB,YAA2B;AAC5C,uBAAe,SAAS,mBAAmB,OAAO,EAAE;AACpD,qBAAa,KAAK,KAAK,KAAK,SAAS,YAAY;AACjD,cAAM,WAAW,CAAC;AAAA,MACpB,CAAC;AAAA,IACH;AAEA,sBAAkB,WAAW,EAAE,MAAM,IAAI,EAAE,CAAC,MAAM,EAAE,iBAAiB,SAAS,UAAU,CAAC,IAAI,CAAC;AAE9F,UAAM,kBAAkB,kBAAkB,SAAS,SAAS,EAAE,MAAM,EAAE,KAAK,YAAY,KAAK,EAAE,GAAG,MAAM,SAAS,CAAC;AACjH,oBAAgB;AAAA,MACd;AAAA,MACA,mBAAmB,OAAO,UAAwC;AAChE,YAAI,MAAM,QAAQ,SAAS;AACzB,gBAAM,OAAO,SAAS,gBAAgB,OAAO,EAAE;AAC/C,cAAI,QAAQ,KAAK,QAAQ,YAAY;AACnC,kBAAM,WAAW,IAAI;AAAA,UACvB;AAAA,QACF;AAAA,MACF,CAAC;AAAA,IACH;AAEA,sBAAkB,WAAW,EAAE,MAAM,EAAE,CAAC,MAAM,EAAE,iBAAiB,SAAS,YAAY,EAAE,YAAY,YAAY,KAAK,QAAQ,WAAW,CAAC,EAAE,CAAC;AAE5I,aAAS,eAAe,SAAkD;AACxE,YAAM;AAAA,QACJ;AAAA,QACA,WAAW;AAAA,QACX;AAAA,MACF,IAAI;AACJ,YAAM,OAAO,kBAAkB,SAAS,KAAK,EAAE,KAAK,aAAa,MAAM,IAAI,OAAO,iBAAiB,CAAC,IAAI,KAAK,CAAC;AAC9G,UAAI,UAAU;AACZ,aAAK,SAAS,UAAU;AACxB,aAAK,UAAU,CAAC,UAA4B;AAC1C,gBAAM,eAAe;AAAA,QACvB;AAAA,MACF,OAAO;AACL,aAAK;AAAA,UACH;AAAA,UACA,mBAAmB,OAAO,UAAqC;AAC7D,kBAAM,eAAe;AACrB,kBAAM,WAAW,iBAAiB;AAAA,UACpC,CAAC;AAAA,QACH;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAAA,EACF;AAEA,iBAAe,WAAW,YAAmC;AAC3D,cAAU,MAAM;AAEhB,cAAU,SAAS,SAAS,EAAE,MAAM,cAAc,CAAC;AAEnD,UAAM,cAAc,aAAa,KAAK;AACtC,UAAM,WAAW,aAAa;AAC9B,UAAM,qBAAqB,KAAK,MAAM,YAAY,QAAQ;AAE1D,UAAM,eAAe,GAAG;AAExB,OAAG,YAAY;AACf,QAAI;AACF,YAAM,OAAO,SAAS,kBAAkB;AAAA,IAC1C,SAAS,GAAG;AACV,SAAG,UAAU,SAAI,cAAc,CAAC,CAAC,EAAE;AAAA,IACrC,UAAE;AAEA,SAAG,YAAY;AAAA,IACjB;AAEA,6BAAyB,UAAU;AAAA,EACrC;AACF;",
  "names": []
}


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

@@ -0,0 +1,57 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Note-scoped, reference-counted editor locking.
+ *
+ * Where {@link lockEditor} / {@link unlockEditor} from `./editor.ts` toggle the read-only state of a
+ * single {@link Editor} instance, the helpers here lock a note by its **path**: while a path is
+ * locked, every current and future {@link MarkdownView} of that note (in any window, including
+ * popouts) is made read-only and shows a lock icon. Locks are reference-counted, so nested or
+ * concurrent operations on the same note are safe — the note is unlocked only when the last lock is
+ * released.
+ *
+ * The acquirers return a {@link Disposable}, so the preferred call style is a `using` declaration
+ * that releases automatically at scope exit (including on throw):
+ *
+ * ```ts
+ * using _lock = lockEditorForPath(app, path);
+ * // ... long-running work (process, processFrontMatter, merge/split) ...
+ * // auto-unlocked at scope exit
+ * ```
+ *
+ * The explicit {@link unlockEditorForPath} pair remains available for non-`using` call sites.
+ */
+import type { App } from 'obsidian';
+import type { PathOrFile } from './file-system.mjs';
+/**
+ * Checks whether the note at the given path is currently locked.
+ *
+ * @param app - The Obsidian app instance.
+ * @param pathOrFile - The path or file of the note to check.
+ * @returns `true` if the note has at least one active lock, `false` otherwise.
+ */
+export declare function isEditorLockedForPath(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.
+ *
+ * The lock is reference-counted: each call must be balanced by exactly one release (either disposing
+ * the returned {@link Disposable} — ideally via a `using` declaration — or a matching
+ * {@link unlockEditorForPath} call).
+ *
+ * @param app - The Obsidian app instance.
+ * @param pathOrFile - The path or file of the note to lock.
+ * @returns A {@link Disposable} that releases this lock when disposed. Disposing more than once is a no-op.
+ */
+export declare function lockEditorForPath(app: App, pathOrFile: PathOrFile): Disposable;
+/**
+ * Releases one lock previously acquired for the note at the given path via {@link lockEditorForPath}.
+ *
+ * When the last lock is released the note becomes fully editable again and its lock icon is removed.
+ * Calling this when the note is not locked is a no-op.
+ *
+ * @param app - The Obsidian app instance.
+ * @param pathOrFile - The path or file of the note to unlock.
+ */
+export declare function unlockEditorForPath(app: App, pathOrFile: PathOrFile): void;

package/dist/lib/esm/obsidian/editor-lock.mjs

@@ -0,0 +1,141 @@
+/*
+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 { ViewType } from "@obsidian-typings/obsidian-public-latest/implementations";
+import { MarkdownView } from "obsidian";
+import {
+  CallbackDisposable,
+  MultipleDisposeBehavior
+} from "../disposable.mjs";
+import { noop } from "../function.mjs";
+import { getObsidianDevUtilsState } from "../obsidian-dev-utils-state.mjs";
+import {
+  lockEditor,
+  unlockEditor
+} from "./editor.mjs";
+import { getPath } from "./file-system.mjs";
+import { t } from "./i18n/i18n.mjs";
+const EDITOR_LOCK_STATE_KEY = "editorLock";
+const LOCK_ICON_ID = "lock";
+class EditorPathLockManager {
+  eventRefs = [];
+  lockCountByPath = /* @__PURE__ */ new Map();
+  lockedIconElByView = /* @__PURE__ */ new Map();
+  isLocked(app, pathOrFile) {
+    return (this.lockCountByPath.get(getPath(app, pathOrFile)) ?? 0) > 0;
+  }
+  lock(app, pathOrFile) {
+    const path = getPath(app, pathOrFile);
+    this.lockCountByPath.set(path, (this.lockCountByPath.get(path) ?? 0) + 1);
+    this.ensureEventsRegistered(app);
+    this.reconcile(app);
+    return new CallbackDisposable({
+      callback: () => {
+        this.unlockPath(app, path);
+      },
+      multipleDisposeBehavior: MultipleDisposeBehavior.Ignore
+    });
+  }
+  unlock(app, pathOrFile) {
+    this.unlockPath(app, getPath(app, pathOrFile));
+  }
+  ensureEventsRegistered(app) {
+    if (this.eventRefs.length > 0) {
+      return;
+    }
+    const reconcile = () => {
+      this.reconcile(app);
+    };
+    this.eventRefs.push(
+      app.workspace.on("active-leaf-change", reconcile),
+      app.workspace.on("layout-change", reconcile)
+    );
+  }
+  reconcile(app) {
+    const viewsToLock = /* @__PURE__ */ new Set();
+    for (const leaf of app.workspace.getLeavesOfType(ViewType.Markdown)) {
+      const view = leaf.view;
+      if (!(view instanceof MarkdownView)) {
+        continue;
+      }
+      const path = view.file?.path;
+      if (path === void 0) {
+        continue;
+      }
+      if ((this.lockCountByPath.get(path) ?? 0) > 0) {
+        viewsToLock.add(view);
+        if (!this.lockedIconElByView.has(view)) {
+          lockEditor(view.editor);
+          const iconEl = view.addAction(LOCK_ICON_ID, t(($) => $.obsidianDevUtils.editorLock.lockedNoteTooltip), noop);
+          this.lockedIconElByView.set(view, iconEl);
+        }
+      }
+    }
+    for (const [view, iconEl] of this.lockedIconElByView) {
+      if (!viewsToLock.has(view)) {
+        unlockEditor(view.editor);
+        iconEl.remove();
+        this.lockedIconElByView.delete(view);
+      }
+    }
+  }
+  unlockPath(app, path) {
+    const count = this.lockCountByPath.get(path) ?? 0;
+    if (count <= 0) {
+      return;
+    }
+    if (count === 1) {
+      this.lockCountByPath.delete(path);
+    } else {
+      this.lockCountByPath.set(path, count - 1);
+    }
+    this.reconcile(app);
+    if (this.lockCountByPath.size === 0) {
+      this.unregisterEvents(app);
+    }
+  }
+  unregisterEvents(app) {
+    for (const eventRef of this.eventRefs) {
+      app.workspace.offref(eventRef);
+    }
+    this.eventRefs = [];
+  }
+}
+function isEditorLockedForPath(app, pathOrFile) {
+  return getManager().isLocked(app, pathOrFile);
+}
+function lockEditorForPath(app, pathOrFile) {
+  return getManager().lock(app, pathOrFile);
+}
+function unlockEditorForPath(app, pathOrFile) {
+  getManager().unlock(app, pathOrFile);
+}
+function getManager() {
+  return getObsidianDevUtilsState(EDITOR_LOCK_STATE_KEY, new EditorPathLockManager()).value;
+}
+export {
+  isEditorLockedForPath,
+  lockEditorForPath,
+  unlockEditorForPath
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/editor-lock.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Note-scoped, reference-counted editor locking.\n *\n * Where {@link lockEditor} / {@link unlockEditor} from `./editor.ts` toggle the read-only state of a\n * single {@link Editor} instance, the helpers here lock a note by its **path**: while a path is\n * locked, every current and future {@link MarkdownView} of that note (in any window, including\n * popouts) is made read-only and shows a lock icon. Locks are reference-counted, so nested or\n * concurrent operations on the same note are safe \u2014 the note is unlocked only when the last lock is\n * released.\n *\n * The acquirers return a {@link Disposable}, so the preferred call style is a `using` declaration\n * that releases automatically at scope exit (including on throw):\n *\n * ```ts\n * using _lock = lockEditorForPath(app, path);\n * // ... long-running work (process, processFrontMatter, merge/split) ...\n * // auto-unlocked at scope exit\n * ```\n *\n * The explicit {@link unlockEditorForPath} pair remains available for non-`using` call sites.\n */\n\nimport type {\n  App,\n  EventRef\n} from 'obsidian';\n\nimport { ViewType } from '@obsidian-typings/obsidian-public-latest/implementations';\nimport { MarkdownView } from 'obsidian';\n\nimport type { PathOrFile } from './file-system.ts';\n\nimport {\n  CallbackDisposable,\n  MultipleDisposeBehavior\n} from '../disposable.ts';\nimport { noop } from '../function.ts';\nimport { getObsidianDevUtilsState } from '../obsidian-dev-utils-state.ts';\nimport {\n  lockEditor,\n  unlockEditor\n} from './editor.ts';\nimport { getPath } from './file-system.ts';\nimport { t } from './i18n/i18n.ts';\n\nconst EDITOR_LOCK_STATE_KEY = 'editorLock';\nconst LOCK_ICON_ID = 'lock';\n\n/**\n * Tracks reference-counted, path-scoped editor locks and keeps every open {@link MarkdownView} in\n * sync with the locked-path set. A single instance lives on the shared `obsidian-dev-utils` state.\n */\nclass EditorPathLockManager {\n  private eventRefs: EventRef[] = [];\n  private readonly lockCountByPath = new Map<string, number>();\n  private readonly lockedIconElByView = new Map<MarkdownView, HTMLElement>();\n\n  public isLocked(app: App, pathOrFile: PathOrFile): boolean {\n    return (this.lockCountByPath.get(getPath(app, pathOrFile)) ?? 0) > 0;\n  }\n\n  public lock(app: App, pathOrFile: PathOrFile): Disposable {\n    const path = getPath(app, pathOrFile);\n    this.lockCountByPath.set(path, (this.lockCountByPath.get(path) ?? 0) + 1);\n    this.ensureEventsRegistered(app);\n    this.reconcile(app);\n\n    return new CallbackDisposable({\n      callback: (): void => {\n        this.unlockPath(app, path);\n      },\n      multipleDisposeBehavior: MultipleDisposeBehavior.Ignore\n    });\n  }\n\n  public unlock(app: App, pathOrFile: PathOrFile): void {\n    this.unlockPath(app, getPath(app, pathOrFile));\n  }\n\n  private ensureEventsRegistered(app: App): void {\n    if (this.eventRefs.length > 0) {\n      return;\n    }\n\n    const reconcile = (): void => {\n      this.reconcile(app);\n    };\n    this.eventRefs.push(\n      app.workspace.on('active-leaf-change', reconcile),\n      app.workspace.on('layout-change', reconcile)\n    );\n  }\n\n  private reconcile(app: App): void {\n    const viewsToLock = new Set<MarkdownView>();\n    for (const leaf of app.workspace.getLeavesOfType(ViewType.Markdown)) {\n      const view = leaf.view;\n      if (!(view instanceof MarkdownView)) {\n        continue;\n      }\n\n      const path = view.file?.path;\n      if (path === undefined) {\n        continue;\n      }\n\n      if ((this.lockCountByPath.get(path) ?? 0) > 0) {\n        viewsToLock.add(view);\n        if (!this.lockedIconElByView.has(view)) {\n          lockEditor(view.editor);\n          const iconEl = view.addAction(LOCK_ICON_ID, t(($) => $.obsidianDevUtils.editorLock.lockedNoteTooltip), noop);\n          this.lockedIconElByView.set(view, iconEl);\n        }\n      }\n    }\n\n    for (const [view, iconEl] of this.lockedIconElByView) {\n      if (!viewsToLock.has(view)) {\n        unlockEditor(view.editor);\n        iconEl.remove();\n        this.lockedIconElByView.delete(view);\n      }\n    }\n  }\n\n  private unlockPath(app: App, path: string): void {\n    const count = this.lockCountByPath.get(path) ?? 0;\n    if (count <= 0) {\n      return;\n    }\n\n    if (count === 1) {\n      this.lockCountByPath.delete(path);\n    } else {\n      this.lockCountByPath.set(path, count - 1);\n    }\n\n    this.reconcile(app);\n\n    if (this.lockCountByPath.size === 0) {\n      this.unregisterEvents(app);\n    }\n  }\n\n  private unregisterEvents(app: App): void {\n    for (const eventRef of this.eventRefs) {\n      app.workspace.offref(eventRef);\n    }\n    this.eventRefs = [];\n  }\n}\n\n/**\n * Checks whether the note at the given path is currently locked.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file of the note to check.\n * @returns `true` if the note has at least one active lock, `false` otherwise.\n */\nexport function isEditorLockedForPath(app: App, pathOrFile: PathOrFile): boolean {\n  return getManager().isLocked(app, pathOrFile);\n}\n\n/**\n * Locks the note at the given path, making it read-only in every current and future\n * {@link MarkdownView} until the lock is released.\n *\n * The lock is reference-counted: each call must be balanced by exactly one release (either disposing\n * the returned {@link Disposable} \u2014 ideally via a `using` declaration \u2014 or a matching\n * {@link unlockEditorForPath} call).\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file of the note to lock.\n * @returns A {@link Disposable} that releases this lock when disposed. Disposing more than once is a no-op.\n */\nexport function lockEditorForPath(app: App, pathOrFile: PathOrFile): Disposable {\n  return getManager().lock(app, pathOrFile);\n}\n\n/**\n * Releases one lock previously acquired for the note at the given path via {@link lockEditorForPath}.\n *\n * When the last lock is released the note becomes fully editable again and its lock icon is removed.\n * Calling this when the note is not locked is a no-op.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file of the note to unlock.\n */\nexport function unlockEditorForPath(app: App, pathOrFile: PathOrFile): void {\n  getManager().unlock(app, pathOrFile);\n}\n\nfunction getManager(): EditorPathLockManager {\n  return getObsidianDevUtilsState<EditorPathLockManager>(EDITOR_LOCK_STATE_KEY, new EditorPathLockManager()).value;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/obsidian/editor.d.mts

@@ -9,8 +9,9 @@ import type { Editor } from 'obsidian';
  * Locks the editor.
  *
  * @param editor - The editor to lock.
+ * @returns A {@link Disposable} that unlocks the editor when disposed, for use with `using`.
  */
-export declare function lockEditor(editor: Editor): void;
+export declare function lockEditor(editor: Editor): Disposable;
 /**
  * Unlocks the editor.
  *

package/dist/lib/esm/obsidian/editor.mjs

@@ -26,6 +26,7 @@ import {
   EditorState
 } from "@codemirror/state";
 import { EditorView } from "@codemirror/view";
+import { CallbackDisposable } from "../disposable.mjs";
 const editorCompartmentMap = /* @__PURE__ */ new WeakMap();
 function lockEditor(editor) {
   const compartment = ensureCompartment(editor);
@@ -35,6 +36,11 @@ function lockEditor(editor) {
       EditorView.editable.of(false)
     ])
   });
+  return new CallbackDisposable({
+    callback: () => {
+      unlockEditor(editor);
+    }
+  });
 }
 function unlockEditor(editor) {
   const compartment = ensureCompartment(editor);
@@ -57,4 +63,4 @@ export {
   lockEditor,
   unlockEditor
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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