obsidian-dev-utils 1.7.7 → 2.0.0

package/dist/lib/obsidian/@types/Dataview/ui/lp-render.d.ts

@@ -0,0 +1,24 @@
+import type { Decoration, DecorationSet, EditorView, ViewPlugin, ViewUpdate } from "@codemirror/view";
+import type { EditorSelection, Range } from "@codemirror/state";
+import type { DataviewSettings } from "../settings.d.ts";
+import type { FullIndex } from "../data-index/index.d.ts";
+import type { App, Component, TFile } from "obsidian";
+import type { DataviewApi } from "../api/plugin-api.d.ts";
+import type { SyntaxNode } from "@lezer/common";
+export declare function selectionAndRangeOverlap(selection: EditorSelection, rangeFrom: number, rangeTo: number): boolean;
+export declare function inlinePlugin(app: App, index: FullIndex, settings: DataviewSettings, api: DataviewApi): ViewPlugin<{
+    decorations: DecorationSet;
+    component: Component;
+    update(update: ViewUpdate): void;
+    updateTree(view: EditorView): void;
+    removeDeco(node: SyntaxNode): void;
+    addDeco(node: SyntaxNode, view: EditorView): void;
+    renderNode(view: EditorView, node: SyntaxNode): {
+        render: boolean;
+        isQuery: boolean;
+    };
+    isInlineQuery(view: EditorView, start: number, end: number): boolean;
+    inlineRender(view: EditorView): DecorationSet | undefined;
+    renderWidget(node: SyntaxNode, view: EditorView, currentFile: TFile): Range<Decoration> | undefined;
+    destroy(): void;
+}>;

package/dist/lib/obsidian/@types/Dataview/ui/markdown.d.ts

@@ -0,0 +1,73 @@
+/** Provides core preact / rendering utilities for all view types. */
+import type { App, MarkdownRenderChild } from "obsidian";
+import type { h, ComponentChildren } from "preact";
+import type { Component } from "obsidian";
+import type { DataviewSettings } from "../settings.d.ts";
+import type { FullIndex } from "../data-index/index.d.ts";
+import type { Literal } from "../data-model/value.d.ts";
+import React from "preact/compat";
+export type MarkdownProps = {
+    contents: string;
+    sourcePath: string;
+};
+export type MarkdownContext = {
+    component: Component;
+};
+/** Context need to create dataviews. */
+export type DataviewInit = {
+    app: App;
+    index: FullIndex;
+    settings: DataviewSettings;
+    container: HTMLElement;
+};
+/** Shared context for dataview views and objects. */
+export type DataviewContexts = DataviewInit & {
+    component: Component;
+};
+export declare const DataviewContext: React.Context<DataviewContexts>;
+/** Hacky preact component which wraps Obsidian's markdown renderer into a neat component. */
+export declare function RawMarkdown({ content, sourcePath, inline, style, cls, onClick, }: {
+    content: string;
+    sourcePath: string;
+    inline?: boolean;
+    style?: string;
+    cls?: string;
+    onClick?: (e: preact.JSX.TargetedMouseEvent<HTMLElement>) => void;
+}): h.JSX.Element;
+/** Hacky preact component which wraps Obsidian's markdown renderer into a neat component. */
+export declare const Markdown: typeof RawMarkdown;
+/** Embeds an HTML element in the react DOM. */
+export declare function RawEmbedHtml({ element }: {
+    element: HTMLElement;
+}): h.JSX.Element;
+/** Embeds an HTML element in the react DOM. */
+export declare const EmbedHtml: typeof RawEmbedHtml;
+/** Intelligently render an arbitrary literal value. */
+export declare function RawLit({ value, sourcePath, inline, depth, }: {
+    value: Literal | undefined;
+    sourcePath: string;
+    inline?: boolean;
+    depth?: number;
+}): h.JSX.Element;
+/** Intelligently render an arbitrary literal value. */
+export declare const Lit: typeof RawLit;
+/** Render a simple nice looking error box in a code style. */
+export declare function ErrorPre(props: {
+    children: ComponentChildren;
+}, {}: {}): h.JSX.Element;
+/** Render a pretty centered error message in a box. */
+export declare function ErrorMessage({ message }: {
+    message: string;
+}): h.JSX.Element;
+/**
+ * Complex convenience hook which calls `compute` every time the index updates, updating the current state.
+ */
+export declare function useIndexBackedState<T>(container: HTMLElement, app: App, settings: DataviewSettings, index: FullIndex, initial: T, compute: () => Promise<T>): T;
+/** A trivial wrapper which allows a react component to live for the duration of a `MarkdownRenderChild`. */
+export declare class ReactRenderer extends MarkdownRenderChild {
+    init: DataviewInit;
+    element: h.JSX.Element;
+    constructor(init: DataviewInit, element: h.JSX.Element);
+    onload(): void;
+    onunload(): void;
+}

package/dist/lib/obsidian/@types/Dataview/ui/refreshable-view.d.ts

@@ -0,0 +1,15 @@
+import type { FullIndex } from "../data-index/index.d.ts";
+import type { App, MarkdownRenderChild } from "obsidian";
+import type { DataviewSettings } from "../settings.d.ts";
+/** Generic code for embedded Dataviews. */
+export declare abstract class DataviewRefreshableRenderer extends MarkdownRenderChild {
+    container: HTMLElement;
+    index: FullIndex;
+    app: App;
+    settings: DataviewSettings;
+    private lastReload;
+    constructor(container: HTMLElement, index: FullIndex, app: App, settings: DataviewSettings);
+    abstract render(): Promise<void>;
+    onload(): void;
+    maybeRefresh: () => void;
+}

package/dist/lib/obsidian/@types/Dataview/ui/render.d.ts

@@ -0,0 +1,12 @@
+import type { App, Component } from "obsidian";
+import type { QuerySettings } from "../settings.d.ts";
+import type { Literal } from "../data-model/value.d.ts";
+/** Render simple fields compactly, removing wrapping content like paragraph and span. */
+export declare function renderCompactMarkdown(app: App, markdown: string, container: HTMLElement, sourcePath: string, component: Component, isInlineFieldLivePreview?: boolean): Promise<void>;
+/** Render a pre block with an error in it; returns the element to allow for dynamic updating. */
+export declare function renderErrorPre(container: HTMLElement, error: string): HTMLElement;
+/** Render a static codeblock. */
+export declare function renderCodeBlock(container: HTMLElement, source: string, language?: string): HTMLElement;
+export type ValueRenderContext = "root" | "list";
+/** Prettily render a value into a container with the given settings. */
+export declare function renderValue(app: App, field: Literal, container: HTMLElement, originFile: string, component: Component, settings: QuerySettings, expandList?: boolean, context?: ValueRenderContext, depth?: number, isInlineFieldLivePreview?: boolean): Promise<void>;

package/dist/lib/obsidian/@types/Dataview/ui/views/calendar-view.d.ts

@@ -0,0 +1,17 @@
+import type { FullIndex } from "../../data-index/index.d.ts";
+import type { App } from "obsidian";
+import type { Query } from "../../query/query.d.ts";
+import type { DataviewSettings } from "../../settings.d.ts";
+import type { DataviewRefreshableRenderer } from "../../ui/refreshable-view.d.ts";
+export declare class DataviewCalendarRenderer extends DataviewRefreshableRenderer {
+    query: Query;
+    container: HTMLElement;
+    index: FullIndex;
+    origin: string;
+    settings: DataviewSettings;
+    app: App;
+    private calendar;
+    constructor(query: Query, container: HTMLElement, index: FullIndex, origin: string, settings: DataviewSettings, app: App);
+    render(): Promise<void>;
+    onClose(): Promise<void>;
+}

package/dist/lib/obsidian/@types/Dataview/ui/views/inline-field-live-preview.d.ts

@@ -0,0 +1,29 @@
+import type { App, Component, TFile } from "obsidian";
+import type { RangeSet, RangeValue, StateField } from "@codemirror/state";
+import type { DecorationSet, EditorView, ViewPlugin, ViewUpdate } from "@codemirror/view";
+import type { InlineField } from "../../data-import/inline-field.d.ts";
+import type { DataviewSettings } from "../../settings.d.ts";
+declare class InlineFieldValue extends RangeValue {
+    field: InlineField;
+    constructor(field: InlineField);
+    eq(other: InlineFieldValue): boolean;
+}
+/** A state field that stores the inline fields and their positions as a range set. */
+export declare const inlineFieldsField: StateField<RangeSet<InlineFieldValue>>;
+/** Create a view plugin that renders inline fields in live preview just as in the reading view. */
+export declare const replaceInlineFieldsInLivePreview: (app: App, settings: DataviewSettings) => ViewPlugin<{
+    decorations: DecorationSet;
+    component: Component;
+    destroy(): void;
+    buildDecorations(view: EditorView): DecorationSet;
+    update(update: ViewUpdate): void;
+    updateDecorations(view: EditorView): void;
+    removeDeco(start: number, end: number): void;
+    addDeco(start: number, end: number, field: InlineField, file: TFile, view: EditorView): void;
+}>;
+/**
+ * A state effect that represents the workspace's layout change.
+ * Mainly intended to detect when the user switches between live preview and source mode.
+ */
+export declare const workspaceLayoutChangeEffect: import("@codemirror/state").StateEffectType<null>;
+export {};

package/dist/lib/obsidian/@types/Dataview/ui/views/inline-view.d.ts

@@ -0,0 +1,19 @@
+import type { FullIndex } from "../../data-index/index.d.ts";
+import type { Field } from "../../expression/field.d.ts";
+import type { App } from "obsidian";
+import type { DataviewSettings } from "../../settings.d.ts";
+import type { DataviewRefreshableRenderer } from "../../ui/refreshable-view.d.ts";
+/** Refreshable renderer which renders inline instead of in a div. */
+export declare class DataviewInlineRenderer extends DataviewRefreshableRenderer {
+    field: Field;
+    fieldText: string;
+    container: HTMLElement;
+    target: HTMLElement;
+    index: FullIndex;
+    origin: string;
+    settings: DataviewSettings;
+    app: App;
+    errorbox?: HTMLElement;
+    constructor(field: Field, fieldText: string, container: HTMLElement, target: HTMLElement, index: FullIndex, origin: string, settings: DataviewSettings, app: App);
+    render(): Promise<void>;
+}

package/dist/lib/obsidian/@types/Dataview/ui/views/js-view.d.ts

@@ -0,0 +1,23 @@
+import type { DataviewRefreshableRenderer } from "../../ui/refreshable-view.d.ts";
+import type { DataviewApi } from "../../api/plugin-api.d.ts";
+export declare class DataviewJSRenderer extends DataviewRefreshableRenderer {
+    api: DataviewApi;
+    script: string;
+    container: HTMLElement;
+    origin: string;
+    static PREAMBLE: string;
+    constructor(api: DataviewApi, script: string, container: HTMLElement, origin: string);
+    render(): Promise<void>;
+}
+/** Inline JS renderer accessible using '=$' by default. */
+export declare class DataviewInlineJSRenderer extends DataviewRefreshableRenderer {
+    api: DataviewApi;
+    script: string;
+    container: HTMLElement;
+    target: HTMLElement;
+    origin: string;
+    static PREAMBLE: string;
+    errorbox?: HTMLElement;
+    constructor(api: DataviewApi, script: string, container: HTMLElement, target: HTMLElement, origin: string);
+    render(): Promise<void>;
+}

package/dist/lib/obsidian/@types/Dataview/ui/views/list-view.d.ts

@@ -0,0 +1,25 @@
+import type { MarkdownRenderChild } from "obsidian";
+import type { Query } from "../../query/query.d.ts";
+import type { DataviewInit } from "../../ui/markdown.d.ts";
+import type { h } from "preact";
+import type { Literal } from "../../data-model/value.d.ts";
+export declare function ListGrouping({ items, sourcePath }: {
+    items: Literal[];
+    sourcePath: string;
+}): h.JSX.Element;
+export type ListViewState = {
+    state: "loading";
+} | {
+    state: "error";
+    error: string;
+} | {
+    state: "ready";
+    items: Literal[];
+};
+/** Pure view over list elements.  */
+export declare function ListView({ query, sourcePath }: {
+    query: Query;
+    sourcePath: string;
+}): h.JSX.Element;
+export declare function createListView(init: DataviewInit, query: Query, sourcePath: string): MarkdownRenderChild;
+export declare function createFixedListView(init: DataviewInit, elements: Literal[], sourcePath: string): MarkdownRenderChild;

package/dist/lib/obsidian/@types/Dataview/ui/views/table-view.d.ts

@@ -0,0 +1,28 @@
+import type { Literal } from "../../data-model/value.d.ts";
+import type { Query } from "../../query/query.d.ts";
+import type { DataviewInit } from "../../ui/markdown.d.ts";
+import type { h } from "preact";
+import type { MarkdownRenderChild } from "obsidian";
+/** Simple table over headings and corresponding values. */
+export declare function TableGrouping({ headings, values, sourcePath, }: {
+    headings: string[];
+    values: Literal[][];
+    sourcePath: string;
+}): h.JSX.Element;
+export type TableViewState = {
+    state: "loading";
+} | {
+    state: "error";
+    error: string;
+} | {
+    state: "ready";
+    headings: string[];
+    values: Literal[][];
+};
+/** Pure view over list elements.  */
+export declare function TableView({ query, sourcePath }: {
+    query: Query;
+    sourcePath: string;
+}): h.JSX.Element;
+export declare function createTableView(init: DataviewInit, query: Query, sourcePath: string): MarkdownRenderChild;
+export declare function createFixedTableView(init: DataviewInit, headings: string[], values: Literal[][], sourcePath: string): MarkdownRenderChild;

package/dist/lib/obsidian/@types/Dataview/ui/views/task-view.d.ts

@@ -0,0 +1,39 @@
+import type { SListItem, STask } from "../../data-model/serialized/markdown.d.ts";
+import type { Grouping } from "../../data-model/value.d.ts";
+import type { MarkdownRenderChild, Vault } from "obsidian";
+import type { h } from "preact";
+import type { Query } from "../../query/query.d.ts";
+import type { DataviewInit } from "../../ui/markdown.d.ts";
+export type TaskViewState = {
+    state: "loading";
+} | {
+    state: "error";
+    error: string;
+} | {
+    state: "ready";
+    items: Grouping<SListItem>;
+};
+/**
+ * Pure view over (potentially grouped) tasks and list items which allows for checking/unchecking tasks and manipulating
+ * the task view.
+ */
+export declare function TaskView({ query, sourcePath }: {
+    query: Query;
+    sourcePath: string;
+}): h.JSX.Element;
+export declare function createTaskView(init: DataviewInit, query: Query, sourcePath: string): MarkdownRenderChild;
+export declare function createFixedTaskView(init: DataviewInit, items: Grouping<SListItem>, sourcePath: string): MarkdownRenderChild;
+/**
+ * Removes tasks from a list if they are already present by being a child of another task. Fixes child pointers.
+ * Retains original order of input list.
+ */
+export declare function nestItems(raw: SListItem[]): [SListItem[], Set<string>];
+/**
+ * Recursively removes tasks from each subgroup if they are already present by being a child of another task.
+ * Fixes child pointers. Retains original order of input list.
+ */
+export declare function nestGroups(raw: Grouping<SListItem>): Grouping<SListItem>;
+/** Set the task completion key on check. */
+export declare function setTaskCompletion(originalText: string, useEmojiShorthand: boolean, completionKey: string, completionDateFormat: string, complete: boolean): string;
+/** Rewrite a task with the given completion status and new text. */
+export declare function rewriteTask(vault: Vault, task: STask, desiredStatus: string, desiredText?: string): Promise<void>;

package/dist/lib/obsidian/@types/Dataview/util/hash.d.ts

@@ -0,0 +1 @@
+export declare function cyrb53(str: string, seed?: number): number;

package/dist/lib/obsidian/@types/Dataview/util/locale.d.ts

@@ -0,0 +1,2 @@
+/** Test-environment-friendly function which fetches the current system locale. */
+export declare function currentLocale(): string;

package/dist/lib/obsidian/@types/Dataview/util/media.d.ts

@@ -0,0 +1,6 @@
+import type { Link } from "../data-model/value.d.ts";
+export declare const IMAGE_EXTENSIONS: Readonly<Set<string>>;
+/** Determines if the given link points to an embedded image. */
+export declare function isImageEmbed(link: Link): boolean;
+/** Extract text of the form 'WxH' or 'W' from the display of a link. */
+export declare function extractImageDimensions(link: Link): [number, number] | [number] | undefined;

package/dist/lib/obsidian/@types/Dataview/util/normalize.d.ts

@@ -0,0 +1,41 @@
+import type { DateTime, Duration } from "luxon";
+import type { Result } from "../api/result.d.ts";
+import type { QuerySettings } from "../settings.d.ts";
+/** Normalize a duration to all of the proper units. */
+export declare function normalizeDuration(dur: Duration): Duration;
+/** Strip the time components of a date time object. */
+export declare function stripTime(dt: DateTime): DateTime;
+/** Try to extract a YYYYMMDD date from a string. */
+export declare function extractDate(str: string): DateTime | undefined;
+/** Get the folder containing the given path (i.e., like computing 'path/..'). */
+export declare function getParentFolder(path: string): string;
+/** Get the file name for the file referenced in the given path, by stripping the parent folders. */
+export declare function getFileName(path: string): string;
+/** Get the "title" for a file, by stripping other parts of the path as well as the extension. */
+export declare function getFileTitle(path: string): string;
+/** Get the extension of a file from the file path. */
+export declare function getExtension(path: string): string;
+/** Parse all subtags out of the given tag. I.e., #hello/i/am would yield [#hello/i/am, #hello/i, #hello]. */
+export declare function extractSubtags(tag: string): string[];
+/** Try calling the given function; on failure, return the error message.  */
+export declare function tryOrPropogate<T>(func: () => Result<T, string>): Result<T, string>;
+/** Try asynchronously calling the given function; on failure, return the error message. */
+export declare function asyncTryOrPropogate<T>(func: () => Promise<Result<T, string>>): Promise<Result<T, string>>;
+/**
+ * Escape regex characters in a string.
+ * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions.
+ */
+export declare function escapeRegex(str: string): string;
+/** Convert an arbitrary variable name into something JS/query friendly. */
+export declare function canonicalizeVarName(name: string): string;
+/**
+ * Normalizes the text in a header to be something that is actually linkable to. This mimics
+ * how Obsidian does it's normalization, collapsing repeated spaces and stripping out control characters.
+ */
+export declare function normalizeHeaderForLink(header: string): string;
+/** Render a DateTime in a minimal format to save space. */
+export declare function renderMinimalDate(time: DateTime, settings: QuerySettings, locale: string): string;
+/** Render a duration in a minimal format to save space. */
+export declare function renderMinimalDuration(dur: Duration): string;
+/** Determine if two sets are equal in contents. */
+export declare function setsEqual<T>(first: Set<T>, second: Set<T>): boolean;

package/dist/lib/obsidian/Dataview.cjs

@@ -221,4 +221,4 @@ function renderIframe({
   renderPaginatedList,
   renderPaginatedTable
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian/Dataview.ts"],
  "sourcesContent": ["var __import_meta_url = globalThis[\"import.meta.url\"] ?? (()=>require(\"node:url\").pathToFileURL(__filename))();\nvar __process = globalThis[\"process\"] ?? {\n  \"cwd\": ()=>\"/\",\n  \"env\": {},\n  \"platform\": \"android\"\n};\nimport type { DataviewInlineApi as DataviewInlineApiOriginal } from \"obsidian-dataview/inline-api\";\nimport type {\n  DataArray,\n  DataviewApi,\n  DateTime,\n  Link,\n  SMarkdownPage\n} from \"obsidian-dataview\";\n\nimport {\n  convertAsyncToSync,\n  type MaybePromise\n} from \"../Async.ts\";\nimport { relativePathToResourceUrl } from \"../obsidian/ResourceUrl.ts\";\nimport { errorToString } from \"../Error.ts\";\n\ndeclare global {\n  // eslint-disable-next-line no-var\n  var DataviewAPI: DataviewApi | undefined;\n}\n\nexport type {\n  DateTime,\n  Link\n};\n\nexport interface DataviewInlineApi<CustomPage = SMarkdownPage> extends DataviewInlineApiOriginal {\n  current: () => Page<CustomPage>;\n  array<T>(arr: T[]): DataArray<T>;\n  pages(query?: string): DataArray<Page<CustomPage>>;\n  paragraph(text: unknown, options?: DomElementInfo & { container?: HTMLElement }): HTMLParagraphElement;\n}\n\nexport async function reloadCurrentFileCache(dv: DataviewInlineApi): Promise<void> {\n  await DataviewAPI?.index.reload(dv.app.vault.getFileByPath(dv.current().file.path)!);\n}\n\nexport type Page<T = SMarkdownPage> = SMarkdownPage & T;\n\ntype PageFile = Page[\"file\"];\nexport type PageFiles = DataArray<PageFile> | PageFile[];\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\ntype ArrayOrDataArray<T> = T[] | DataArray<T>;\n\nexport async function renderPaginatedList<T>({\n  dv,\n  rows,\n  itemsPerPageOptions = [10, 20, 50, 100]\n}: {\n  dv: DataviewInlineApi,\n  rows: ArrayOrDataArray<T>,\n  itemsPerPageOptions?: number[]\n}): Promise<void> {\n  await renderPaginated({\n    dv,\n    rows,\n    itemsPerPageOptions,\n    renderer: async (rows: ArrayOrDataArray<T>): Promise<void> => {\n      await dv.list(rows);\n    }\n  });\n}\n\nexport async function renderPaginatedTable<T extends unknown[]>({\n  dv,\n  headers,\n  rows,\n  itemsPerPageOptions = [10, 20, 50, 100]\n}: {\n  dv: DataviewInlineApi,\n  headers: string[],\n  rows: ArrayOrDataArray<T>,\n  itemsPerPageOptions?: number[]\n}): Promise<void> {\n  await renderPaginated({\n    dv,\n    rows,\n    itemsPerPageOptions,\n    renderer: async (rows: ArrayOrDataArray<T>): Promise<void> => {\n      await dv.table(headers, rows);\n    }\n  });\n}\n\nasync function renderPaginated<T>({\n  dv,\n  rows,\n  itemsPerPageOptions = [10, 20, 50, 100],\n  renderer\n}: {\n  dv: DataviewInlineApi,\n  rows: ArrayOrDataArray<T>,\n  itemsPerPageOptions: number[],\n  renderer: (rows: ArrayOrDataArray<T>) => MaybePromise<void>\n}): Promise<void> {\n  if (rows.length === 0) {\n    dv.paragraph(\"No items found\");\n    return;\n  }\n  const container = dv.container;\n  let itemsPerPage = itemsPerPageOptions[0]!;\n  let totalPages = Math.ceil(rows.length / itemsPerPage);\n  await renderPage(1);\n\n  function createPaginationControls(pageNumber: number): void {\n    const paginationDiv = container.createEl(\"div\", { 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 > 3) {\n      paginationRow1Div.createEl(\"span\", { text: \"...\" });\n    }\n\n    for (let i = Math.max(1, pageNumber - 2); i <= Math.min(totalPages, pageNumber + 2); i++) {\n      const pageLink = createPageLink(i.toString(), i, i === pageNumber);\n      if (i === pageNumber) {\n        pageLink.addClass(\"current\");\n      }\n    }\n\n    if (pageNumber < totalPages - 2) {\n      paginationRow1Div.createEl(\"span\", { 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.createEl(\"span\", { text: \" Items per page: \" });\n\n    const itemsPerPageSelect = paginationRow2Div.createEl(\"select\");\n    itemsPerPageOptions.forEach((option: number): void => {\n      itemsPerPageSelect.createEl(\"option\", { text: option.toString(), value: option.toString() });\n    });\n    itemsPerPageSelect.value = itemsPerPage.toString();\n    itemsPerPageSelect.addEventListener(\"change\", convertAsyncToSync(async (): Promise<void> => {\n      itemsPerPage = parseInt(itemsPerPageSelect.value);\n      totalPages = Math.ceil(rows.length / itemsPerPage);\n      await renderPage(1);\n    }));\n\n    paginationRow2Div.createEl(\"span\", { text: \"  Jump to page: \" });\n\n    const jumpToPageInput = paginationRow2Div.createEl(\"input\", { type: \"number\", attr: { min: 1, max: totalPages } });\n    jumpToPageInput.addEventListener(\"keydown\", convertAsyncToSync(async (event: KeyboardEvent): Promise<void> => {\n      if (event.key === \"Enter\") {\n        const page = parseInt(jumpToPageInput.value);\n        if (page >= 1 && page <= totalPages) {\n          await renderPage(page);\n        }\n      }\n    }));\n\n    paginationRow2Div.createEl(\"span\", { text: `  Page ${pageNumber} of ${totalPages}, Total items: ${rows.length}` });\n\n    function createPageLink(text: string, pageNumber: number, disabled = false): HTMLAnchorElement {\n      const link = paginationRow1Div.createEl(\"a\", { cls: \"page-link\", text: text, href: `#${pageNumber}` });\n      if (disabled) {\n        link.addClass(\"disabled\");\n        link.onclick = (event: MouseEvent): void => event.preventDefault();\n      } else {\n        link.addEventListener(\"click\", convertAsyncToSync(async (event: MouseEvent): Promise<void> => {\n          event.preventDefault();\n          await renderPage(pageNumber);\n        }));\n      }\n      return link;\n    }\n  }\n\n  async function renderPage(pageNumber: number): Promise<void> {\n    container.empty();\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 renderer(rowsForCurrentPage);\n    } catch (e) {\n      dv.paragraph(\"\u274C\" + errorToString(e));\n    } finally {\n      dv.container = oldContainer;\n    }\n\n    createPaginationControls(pageNumber);\n  }\n}\n\nexport async function getRenderedContainer(dv: DataviewInlineApi, renderer: () => MaybePromise<void>): Promise<HTMLParagraphElement> {\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    dv.container = tempContainer.parentElement!;\n    tempContainer.remove();\n  }\n\n  return tempContainer;\n}\n\nexport function renderIframe({\n  dv,\n  relativePath,\n  width = \"100%\",\n  height = \"600px\"\n}: {\n  dv: DataviewInlineApi,\n  relativePath: string,\n  width: string,\n  height: string\n}): void {\n  dv.el(\"iframe\", \"\", {\n    attr: {\n      src: relativePathToResourceUrl(dv.app, relativePath, dv.current().file.path),\n      width,\n      height\n    }\n  });\n}\n"],
  "mappings": "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",
  "names": ["rows", "pageNumber"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian/Dataview.ts"],
  "sourcesContent": ["var __import_meta_url = globalThis[\"import.meta.url\"] ?? (()=>require(\"node:url\").pathToFileURL(__filename))();\nvar __process = globalThis[\"process\"] ?? {\n  \"cwd\": ()=>\"/\",\n  \"env\": {},\n  \"platform\": \"android\"\n};\nimport type { DataviewInlineApi as DataviewInlineApiOriginal } from \"./@types/Dataview/api/inline-api.d.ts\";\nimport type {\n  DataArray,\n  DataviewApi,\n  DateTime,\n  Link,\n  SMarkdownPage\n} from \"./@types/Dataview/index.d.ts\";\n\nimport {\n  convertAsyncToSync,\n  type MaybePromise\n} from \"../Async.ts\";\nimport { relativePathToResourceUrl } from \"../obsidian/ResourceUrl.ts\";\nimport { errorToString } from \"../Error.ts\";\n\ndeclare global {\n  // eslint-disable-next-line no-var\n  var DataviewAPI: DataviewApi | undefined;\n}\n\nexport type {\n  DateTime,\n  Link\n};\n\nexport interface DataviewInlineApi<CustomPage = SMarkdownPage> extends DataviewInlineApiOriginal {\n  current: () => Page<CustomPage>;\n  array<T>(arr: T[]): DataArray<T>;\n  pages(query?: string): DataArray<Page<CustomPage>>;\n  paragraph(text: unknown, options?: DomElementInfo & { container?: HTMLElement }): HTMLParagraphElement;\n}\n\nexport async function reloadCurrentFileCache(dv: DataviewInlineApi): Promise<void> {\n  await DataviewAPI?.index.reload(dv.app.vault.getFileByPath(dv.current().file.path)!);\n}\n\nexport type Page<T = SMarkdownPage> = SMarkdownPage & T;\n\ntype PageFile = Page[\"file\"];\nexport type PageFiles = DataArray<PageFile> | PageFile[];\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\ntype ArrayOrDataArray<T> = T[] | DataArray<T>;\n\nexport async function renderPaginatedList<T>({\n  dv,\n  rows,\n  itemsPerPageOptions = [10, 20, 50, 100]\n}: {\n  dv: DataviewInlineApi,\n  rows: ArrayOrDataArray<T>,\n  itemsPerPageOptions?: number[]\n}): Promise<void> {\n  await renderPaginated({\n    dv,\n    rows,\n    itemsPerPageOptions,\n    renderer: async (rows: ArrayOrDataArray<T>): Promise<void> => {\n      await dv.list(rows);\n    }\n  });\n}\n\nexport async function renderPaginatedTable<T extends unknown[]>({\n  dv,\n  headers,\n  rows,\n  itemsPerPageOptions = [10, 20, 50, 100]\n}: {\n  dv: DataviewInlineApi,\n  headers: string[],\n  rows: ArrayOrDataArray<T>,\n  itemsPerPageOptions?: number[]\n}): Promise<void> {\n  await renderPaginated({\n    dv,\n    rows,\n    itemsPerPageOptions,\n    renderer: async (rows: ArrayOrDataArray<T>): Promise<void> => {\n      await dv.table(headers, rows);\n    }\n  });\n}\n\nasync function renderPaginated<T>({\n  dv,\n  rows,\n  itemsPerPageOptions = [10, 20, 50, 100],\n  renderer\n}: {\n  dv: DataviewInlineApi,\n  rows: ArrayOrDataArray<T>,\n  itemsPerPageOptions: number[],\n  renderer: (rows: ArrayOrDataArray<T>) => MaybePromise<void>\n}): Promise<void> {\n  if (rows.length === 0) {\n    dv.paragraph(\"No items found\");\n    return;\n  }\n  const container = dv.container;\n  let itemsPerPage = itemsPerPageOptions[0]!;\n  let totalPages = Math.ceil(rows.length / itemsPerPage);\n  await renderPage(1);\n\n  function createPaginationControls(pageNumber: number): void {\n    const paginationDiv = container.createEl(\"div\", { 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 > 3) {\n      paginationRow1Div.createEl(\"span\", { text: \"...\" });\n    }\n\n    for (let i = Math.max(1, pageNumber - 2); i <= Math.min(totalPages, pageNumber + 2); i++) {\n      const pageLink = createPageLink(i.toString(), i, i === pageNumber);\n      if (i === pageNumber) {\n        pageLink.addClass(\"current\");\n      }\n    }\n\n    if (pageNumber < totalPages - 2) {\n      paginationRow1Div.createEl(\"span\", { 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.createEl(\"span\", { text: \" Items per page: \" });\n\n    const itemsPerPageSelect = paginationRow2Div.createEl(\"select\");\n    itemsPerPageOptions.forEach((option: number): void => {\n      itemsPerPageSelect.createEl(\"option\", { text: option.toString(), value: option.toString() });\n    });\n    itemsPerPageSelect.value = itemsPerPage.toString();\n    itemsPerPageSelect.addEventListener(\"change\", convertAsyncToSync(async (): Promise<void> => {\n      itemsPerPage = parseInt(itemsPerPageSelect.value);\n      totalPages = Math.ceil(rows.length / itemsPerPage);\n      await renderPage(1);\n    }));\n\n    paginationRow2Div.createEl(\"span\", { text: \"  Jump to page: \" });\n\n    const jumpToPageInput = paginationRow2Div.createEl(\"input\", { type: \"number\", attr: { min: 1, max: totalPages } });\n    jumpToPageInput.addEventListener(\"keydown\", convertAsyncToSync(async (event: KeyboardEvent): Promise<void> => {\n      if (event.key === \"Enter\") {\n        const page = parseInt(jumpToPageInput.value);\n        if (page >= 1 && page <= totalPages) {\n          await renderPage(page);\n        }\n      }\n    }));\n\n    paginationRow2Div.createEl(\"span\", { text: `  Page ${pageNumber} of ${totalPages}, Total items: ${rows.length}` });\n\n    function createPageLink(text: string, pageNumber: number, disabled = false): HTMLAnchorElement {\n      const link = paginationRow1Div.createEl(\"a\", { cls: \"page-link\", text: text, href: `#${pageNumber}` });\n      if (disabled) {\n        link.addClass(\"disabled\");\n        link.onclick = (event: MouseEvent): void => event.preventDefault();\n      } else {\n        link.addEventListener(\"click\", convertAsyncToSync(async (event: MouseEvent): Promise<void> => {\n          event.preventDefault();\n          await renderPage(pageNumber);\n        }));\n      }\n      return link;\n    }\n  }\n\n  async function renderPage(pageNumber: number): Promise<void> {\n    container.empty();\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 renderer(rowsForCurrentPage);\n    } catch (e) {\n      dv.paragraph(\"\u274C\" + errorToString(e));\n    } finally {\n      dv.container = oldContainer;\n    }\n\n    createPaginationControls(pageNumber);\n  }\n}\n\nexport async function getRenderedContainer(dv: DataviewInlineApi, renderer: () => MaybePromise<void>): Promise<HTMLParagraphElement> {\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    dv.container = tempContainer.parentElement!;\n    tempContainer.remove();\n  }\n\n  return tempContainer;\n}\n\nexport function renderIframe({\n  dv,\n  relativePath,\n  width = \"100%\",\n  height = \"600px\"\n}: {\n  dv: DataviewInlineApi,\n  relativePath: string,\n  width: string,\n  height: string\n}): void {\n  dv.el(\"iframe\", \"\", {\n    attr: {\n      src: relativePathToResourceUrl(dv.app, relativePath, dv.current().file.path),\n      width,\n      height\n    }\n  });\n}\n"],
  "mappings": "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",
  "names": ["rows", "pageNumber"]
}


package/dist/lib/obsidian/Dataview.d.ts

@@ -1,5 +1,5 @@
-import type { DataviewInlineApi as DataviewInlineApiOriginal } from "obsidian-dataview/inline-api";
-import type { DataArray, DataviewApi, DateTime, Link, SMarkdownPage } from "obsidian-dataview";
+import type { DataviewInlineApi as DataviewInlineApiOriginal } from "./@types/Dataview/api/inline-api.d.ts";
+import type { DataArray, DataviewApi, DateTime, Link, SMarkdownPage } from "./@types/Dataview/index.d.ts";
 import { type MaybePromise } from "../Async.ts";
 declare global {
     var DataviewAPI: DataviewApi | undefined;