@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

package/dist/lib/esm/dataview.mjs

@@ -0,0 +1,288 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { convertAsyncToSync } from "@mnaoumov/typescript-lib/async";
+import { errorToString } from "@mnaoumov/typescript-lib/error";
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import {
+  getFile,
+  getPath
+} from "./file-system.mjs";
+import { t } from "./i18n/i18n.mjs";
+import { relativePathToResourceUrl } from "./resource-url.mjs";
+async function reloadCurrentFileCache(dv) {
+  await activeWindow.DataviewAPI?.index.reload(getFile({
+    app: dv.app,
+    pathOrFile: dv.current().file.path
+  }));
+}
+const paginationCss = `
+.pagination .page-link.disabled {
+  pointer-events: none;
+  color: gray;
+}
+
+.pagination .page-link {
+  margin: 0 5px;
+  cursor: pointer;
+  text-decoration: none;
+  color: blue;
+}
+
+.pagination .page-link:hover:not(.disabled) {
+  text-decoration: underline;
+}
+.pagination .page-link.current {
+  font-weight: bold;
+  text-decoration: underline;
+}
+
+.pagination select,
+.pagination input {
+  margin: 0 5px;
+}
+`;
+async function getRenderedContainer(dv, renderer) {
+  const oldContainer = dv.container;
+  const temporaryContainer = dv.paragraph("");
+  dv.container = temporaryContainer;
+  dv.container.empty();
+  try {
+    await renderer();
+  } catch (error) {
+    dv.paragraph(`\u274C${errorToString(error)}`);
+  } finally {
+    dv.container = oldContainer;
+    temporaryContainer.remove();
+  }
+  return temporaryContainer;
+}
+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);
+  const fenceLengths = [...fenceMatches].map((fenceMatch) => fenceMatch[0].length);
+  const maxFenceLength = Math.max(0, ...fenceLengths);
+  const resultFenceLength = Math.max(MIN_FENCE_LENGTH, maxFenceLength + 1);
+  const resultFence = "`".repeat(resultFenceLength);
+  dv.paragraph(`${resultFence}${language}
+${code}
+${resultFence}`);
+}
+function renderIframe(params) {
+  const {
+    dv,
+    height = "600px",
+    relativePathOrFile,
+    width = "100%"
+  } = params;
+  dv.el("iframe", "", {
+    attr: {
+      height,
+      src: relativePathToResourceUrl({
+        app: dv.app,
+        notePath: dv.current().file.path,
+        relativePath: getPath(dv.app, relativePathOrFile)
+      }),
+      width
+    }
+  });
+}
+async function renderPaginatedList(params) {
+  const {
+    dv,
+    // 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.
+    itemsPerPageOptions = [10, 20, 50, 100],
+    rows
+  } = params;
+  await renderPaginated({
+    dv,
+    itemsPerPageOptions,
+    renderer: async (rowsForOnePage) => {
+      await dv.list(rowsForOnePage);
+    },
+    rows
+  });
+}
+async function renderPaginatedTable(params) {
+  const {
+    dv,
+    headers,
+    // 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.
+    itemsPerPageOptions = [10, 20, 50, 100],
+    rows
+  } = params;
+  await renderPaginated({
+    dv,
+    itemsPerPageOptions,
+    renderer: async (rowsForOnePage) => {
+      await dv.table(headers, rowsForOnePage);
+    },
+    rows
+  });
+}
+async function renderPaginated(params) {
+  const SECOND_PAGE_NUMBER = 2;
+  const MORE_PAGE_NUMBER = 3;
+  const {
+    dv,
+    // 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.
+    itemsPerPageOptions = [10, 20, 50, 100],
+    rows
+  } = params;
+  if (rows.length === 0) {
+    dv.paragraph("No items found");
+    return;
+  }
+  const container = dv.container;
+  let itemsPerPage = ensureNonNullable(itemsPerPageOptions[0], "Items per page options are empty");
+  let totalPages = Math.ceil(rows.length / itemsPerPage);
+  await renderPage(1);
+  function createPaginationControls(pageNumber) {
+    const paginationDiv = container.createDiv({ cls: "pagination" });
+    const paginationRow1Div = paginationDiv.createDiv();
+    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 index = Math.max(1, pageNumber - SECOND_PAGE_NUMBER); index <= Math.min(totalPages, pageNumber + SECOND_PAGE_NUMBER); index++) {
+      const pageLink = createPageLink({ currentPageNumber: index, disabled: index === pageNumber, text: String(index) });
+      if (index === pageNumber) {
+        pageLink.addClass("current");
+      }
+    }
+    if (pageNumber < totalPages - SECOND_PAGE_NUMBER) {
+      paginationRow1Div.createSpan({ text: "..." });
+    }
+    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");
+    for (const option of itemsPerPageOptions) {
+      itemsPerPageSelect.createEl("option", { text: String(option), value: String(option) });
+    }
+    itemsPerPageSelect.value = String(itemsPerPage);
+    itemsPerPageSelect.addEventListener(
+      "change",
+      convertAsyncToSync(async () => {
+        itemsPerPage = parseInt(itemsPerPageSelect.value, 10);
+        totalPages = Math.ceil(rows.length / itemsPerPage);
+        await renderPage(1);
+      })
+    );
+    paginationRow2Div.createSpan({ text: ` ${t(($) => $.obsidianDevUtils.dataview.jumpToPage)} ` });
+    const jumpToPageInput = paginationRow2Div.createEl("input", { attr: { max: totalPages, min: 1 }, type: "number" });
+    jumpToPageInput.addEventListener(
+      "keydown",
+      convertAsyncToSync(async (event) => {
+        if (event.key !== "Enter") {
+          return;
+        }
+        const page = parseInt(jumpToPageInput.value, 10);
+        if (page >= 1 && page <= totalPages) {
+          await renderPage(page);
+        }
+      })
+    );
+    paginationRow2Div.createSpan({ text: t(($) => $.obsidianDevUtils.dataview.pageHeader, { pageNumber, totalItems: rows.length, totalPages }) });
+    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");
+        link.onclick = (event) => {
+          event.preventDefault();
+        };
+      } else {
+        link.onclick = convertAsyncToSync(async (event) => {
+          event.preventDefault();
+          await renderPage(currentPageNumber);
+        });
+      }
+      return link;
+    }
+  }
+  async function renderPage(pageNumber) {
+    container.empty();
+    container.createEl("style", { text: paginationCss });
+    const startIndex = (pageNumber - 1) * itemsPerPage;
+    const endIndex = startIndex + itemsPerPage;
+    const rowsForCurrentPage = rows.slice(startIndex, endIndex);
+    const oldContainer = dv.container;
+    dv.container = container;
+    try {
+      await params.renderer(rowsForCurrentPage);
+    } catch (error) {
+      dv.paragraph(`\u274C${errorToString(error)}`);
+    } finally {
+      dv.container = oldContainer;
+    }
+    createPaginationControls(pageNumber);
+  }
+}
+export {
+  getRenderedContainer,
+  insertCodeBlock,
+  reloadCurrentFileCache,
+  renderIframe,
+  renderPaginatedList,
+  renderPaginatedTable
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/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 { convertAsyncToSync } from '@mnaoumov/typescript-lib/async';\nimport { errorToString } from '@mnaoumov/typescript-lib/error';\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\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 {\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 array - The array of items to wrap.\n   * @returns A {@link DataArray} containing the items.\n   */\n  array: <T>(array: 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  readonly 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 temporaryContainer = dv.paragraph('');\n  dv.container = temporaryContainer;\n  dv.container.empty();\n\n  try {\n    await renderer();\n  } catch (error) {\n    dv.paragraph(`\u274C${errorToString(error)}`);\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    temporaryContainer.remove();\n  }\n\n  return temporaryContainer;\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 = [...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 index = Math.max(1, pageNumber - SECOND_PAGE_NUMBER); index <= Math.min(totalPages, pageNumber + SECOND_PAGE_NUMBER); index++) {\n      const pageLink = createPageLink({ currentPageNumber: index, disabled: index === pageNumber, text: String(index) });\n      if (index === 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    for (const option of itemsPerPageOptions) {\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          return;\n        }\n\n        const page = parseInt(jumpToPageInput.value, 10);\n        if (page >= 1 && page <= totalPages) {\n          await renderPage(page);\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        // eslint-disable-next-line unicorn/prefer-add-event-listener -- The handler is assigned to `onclick` so it stays readable back off the element, which is how it is invoked in tests and how a later assignment can replace it.\n        link.onclick = (event: MouseEvent): void => {\n          event.preventDefault();\n        };\n      } else {\n        // eslint-disable-next-line unicorn/prefer-add-event-listener -- The handler is assigned to `onclick` so it stays readable back off the element, which is how it is invoked in tests and how a later assignment can replace it.\n        link.onclick = convertAsyncToSync(async (event: MouseEvent): Promise<void> => {\n          event.preventDefault();\n          await renderPage(currentPageNumber);\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 (error) {\n      dv.paragraph(`\u274C${errorToString(error)}`);\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": []
}


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

@@ -0,0 +1,19 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * The debuggers of `@mnaoumov/obsidian-lib`'s own modules.
+ */
+import { getDebugger } from '@mnaoumov/typescript-lib/debug';
+/**
+ * Returns a debugger for one of this library's own modules.
+ *
+ * The namespace is always under {@link OBSIDIAN_LIBRARY_NAME}, whether or not `initPluginContext` has run yet, so
+ * a namespace a guide tells users to enable (`obsidian-dev-utils:PluginApi`) means the same thing in a test, in a
+ * script and in a plugin. The generic modules of `@mnaoumov/typescript-lib` log under the namespace
+ * `initPluginContext` injects into the generic `Library`, which is the same one once a plugin is up.
+ *
+ * @param namespace - The namespace within the library's.
+ * @returns The debugger.
+ */
+export declare function getObsidianLibDebugger(namespace: string): ReturnType<typeof getDebugger>;

package/dist/lib/esm/debug.mjs

@@ -0,0 +1,59 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { getDebugger } from "@mnaoumov/typescript-lib/debug";
+import { Library } from "@mnaoumov/typescript-lib/library";
+import { OBSIDIAN_LIBRARY_NAME } from "./library.mjs";
+function getObsidianLibDebugger(namespace) {
+  return getDebugger(`${Library.debugPrefixNamespace}${OBSIDIAN_LIBRARY_NAME}:${namespace}`);
+}
+export {
+  getObsidianLibDebugger
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2RlYnVnLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogVGhlIGRlYnVnZ2VycyBvZiBgQG1uYW91bW92L29ic2lkaWFuLWxpYmAncyBvd24gbW9kdWxlcy5cbiAqL1xuXG5pbXBvcnQgeyBnZXREZWJ1Z2dlciB9IGZyb20gJ0BtbmFvdW1vdi90eXBlc2NyaXB0LWxpYi9kZWJ1Zyc7XG5pbXBvcnQgeyBMaWJyYXJ5IH0gZnJvbSAnQG1uYW91bW92L3R5cGVzY3JpcHQtbGliL2xpYnJhcnknO1xuXG5pbXBvcnQgeyBPQlNJRElBTl9MSUJSQVJZX05BTUUgfSBmcm9tICcuL2xpYnJhcnkudHMnO1xuXG4vKipcbiAqIFJldHVybnMgYSBkZWJ1Z2dlciBmb3Igb25lIG9mIHRoaXMgbGlicmFyeSdzIG93biBtb2R1bGVzLlxuICpcbiAqIFRoZSBuYW1lc3BhY2UgaXMgYWx3YXlzIHVuZGVyIHtAbGluayBPQlNJRElBTl9MSUJSQVJZX05BTUV9LCB3aGV0aGVyIG9yIG5vdCBgaW5pdFBsdWdpbkNvbnRleHRgIGhhcyBydW4geWV0LCBzb1xuICogYSBuYW1lc3BhY2UgYSBndWlkZSB0ZWxscyB1c2VycyB0byBlbmFibGUgKGBvYnNpZGlhbi1kZXYtdXRpbHM6UGx1Z2luQXBpYCkgbWVhbnMgdGhlIHNhbWUgdGhpbmcgaW4gYSB0ZXN0LCBpbiBhXG4gKiBzY3JpcHQgYW5kIGluIGEgcGx1Z2luLiBUaGUgZ2VuZXJpYyBtb2R1bGVzIG9mIGBAbW5hb3Vtb3YvdHlwZXNjcmlwdC1saWJgIGxvZyB1bmRlciB0aGUgbmFtZXNwYWNlXG4gKiBgaW5pdFBsdWdpbkNvbnRleHRgIGluamVjdHMgaW50byB0aGUgZ2VuZXJpYyBgTGlicmFyeWAsIHdoaWNoIGlzIHRoZSBzYW1lIG9uZSBvbmNlIGEgcGx1Z2luIGlzIHVwLlxuICpcbiAqIEBwYXJhbSBuYW1lc3BhY2UgLSBUaGUgbmFtZXNwYWNlIHdpdGhpbiB0aGUgbGlicmFyeSdzLlxuICogQHJldHVybnMgVGhlIGRlYnVnZ2VyLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0T2JzaWRpYW5MaWJEZWJ1Z2dlcihuYW1lc3BhY2U6IHN0cmluZyk6IFJldHVyblR5cGU8dHlwZW9mIGdldERlYnVnZ2VyPiB7XG4gIHJldHVybiBnZXREZWJ1Z2dlcihgJHtMaWJyYXJ5LmRlYnVnUHJlZml4TmFtZXNwYWNlfSR7T0JTSURJQU5fTElCUkFSWV9OQU1FfToke25hbWVzcGFjZX1gKTtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFNQSxTQUFTLG1CQUFtQjtBQUM1QixTQUFTLGVBQWU7QUFFeEIsU0FBUyw2QkFBNkI7QUFhL0IsU0FBUyx1QkFBdUIsV0FBbUQ7QUFDeEYsU0FBTyxZQUFZLEdBQUcsUUFBUSxvQkFBb0IsR0FBRyxxQkFBcUIsSUFBSSxTQUFTLEVBQUU7QUFDM0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/esm/demo-vault-helper-settings.d.mts

@@ -0,0 +1,29 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * The `demo-vault-helper` plugin's own settings — the contract between the demo-vault packaging step
+ * and the bootstrap that runs inside the opened vault.
+ *
+ * The helper has to name the plugin the vault demonstrates, and nothing inside the vault reliably says
+ * which one that is: the plugin folders also hold the helper itself, CodeScript Toolkit once the
+ * bootstrap has installed it, and anything a demo note's prerequisites installed, so counting them
+ * guesses (and guesses differently on a re-open). The packaging step, on the other hand, KNOWS — it
+ * reads the plugin's `manifest.json` to name the archive — so it writes the id down here and the
+ * bootstrap simply reads it.
+ *
+ * The marker and the helper binary are written together, by the same `obsidian-dev-utils` version, into
+ * the same archive, so the two can never disagree.
+ *
+ * Kept free of `obsidian` imports on purpose: the packaging step ({@link archivePluginDemoVault}) runs
+ * under Node, where the `obsidian` module does not exist.
+ */
+/**
+ * The `demo-vault-helper` plugin's `data.json`, written into the demo vault at packaging time.
+ */
+export interface DemoVaultHelperSettings {
+    /**
+     * The id of the plugin the vault demonstrates, taken from that plugin's `manifest.json`.
+     */
+    readonly demoedPluginId: string;
+}

package/dist/lib/esm/demo-vault-helper-settings.mjs

@@ -0,0 +1,50 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/esm/demo-vault-helper.d.mts

@@ -0,0 +1,61 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Bootstraps a demo vault by installing, configuring, and enabling CodeScript Toolkit.
+ *
+ * A plugin's demo vault showcases the plugin through notes whose `code-button`s run TypeScript via
+ * CodeScript Toolkit. A demo vault that does not itself ship CodeScript Toolkit therefore needs it
+ * installed, configured, and enabled before those buttons work. {@link bootstrapDemoVault} does exactly
+ * that with no committed CodeScript Toolkit config and no manual setup, so it can be driven from a tiny
+ * committed bootstrap plugin (`demo-vault-helper`) that is injected into every demo vault at release
+ * time.
+ *
+ * The plugin the vault demonstrates is read from the helper's own `data.json`, written by the packaging
+ * step ({@link DemoVaultHelperSettings}); a vault without that marker is refused as not a demo vault.
+ *
+ * It writes CodeScript Toolkit's settings BEFORE enabling it, so the plugin loads already configured —
+ * no reload. CodeScript Toolkit then runs the vault's `startup.ts` (via its `startupScriptPath`
+ * setting), which is where each vault opens its start note and does any plugin-specific setup.
+ *
+ * It also creates CodeScript Toolkit's invocable-scripts folder if it is missing, so every demo vault
+ * has the same layout even when the vault ships no invocable scripts — the vaults themselves commit no
+ * empty folder for it.
+ *
+ * It then installs the Folder Notes plugin, configured to treat `README.md` as a folder's own note. A
+ * demo vault that has outgrown a flat note list groups its notes into folders, and a group folder only
+ * says what it is for if it has a note of its own — `README.md`, because that is also the file GitHub
+ * renders under the file list when the same vault is browsed as a repository, so one file serves both
+ * readers.
+ *
+ * Finally it raises the sandbox notice explaining that the opened vault is a throwaway copy, so a user
+ * who writes their own notes in it is never surprised by them being absent from the next copy. Settings
+ * is closed first, so the notice lands in the vault's main window rather than in the settings popout.
+ */
+import type { App } from 'obsidian';
+/**
+ * Parameters for {@link bootstrapDemoVault}.
+ */
+export interface BootstrapDemoVaultParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+}
+/**
+ * Bootstraps a demo vault so its notes' `code-button`s work with no manual setup: installs CodeScript
+ * Toolkit from the community store (if it is not already installed), writes its settings, then enables
+ * it — writing the settings BEFORE enabling so a fresh enable loads it already configured, with no
+ * reload. If CodeScript Toolkit is already enabled but the settings just changed, it is reloaded
+ * (disabled then enabled) so it re-reads `data.json`; when the settings were already in place, nothing is
+ * reloaded (so a routine vault re-open does not re-run CodeScript Toolkit's startup). CodeScript Toolkit
+ * then runs the vault's `startup.ts`. Folder Notes is installed next, configured to treat `README.md` as
+ * a folder's own note, so a vault whose notes are grouped into folders describes each group in the file
+ * explorer. Finally it closes Settings (so the notice cannot be raised inside the settings popout) and
+ * raises the sandbox notice describing the opened vault as a throwaway copy.
+ *
+ * @param params - The {@link BootstrapDemoVaultParams}.
+ * @returns A {@link Promise} that resolves once CodeScript Toolkit is installed, configured, and enabled
+ * and the sandbox notice has been shown.
+ */
+export declare function bootstrapDemoVault(params: BootstrapDemoVaultParams): Promise<void>;