@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/cjs/view-registrar.d.cts

@@ -0,0 +1,52 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * This file defines the {@link ViewRegistrar} interface and the {@link PluginViewRegistrar} class.
+ */
+import type { View, WorkspaceLeaf } from 'obsidian' with { 'resolution-mode': 'import' };
+import { Plugin } from 'obsidian';
+/**
+ * A registrar for views.
+ */
+export interface ViewRegistrar {
+    /**
+     * Registers a view type with a view creator.
+     *
+     * @param params - The parameters for the view registration.
+     */
+    registerView: (params: PluginViewRegistrarRegisterViewParams) => void;
+}
+type PluginViewRegistrarRegisterViewParams = ViewRegistrarRegisterViewParams;
+interface ViewRegistrarRegisterViewParams {
+    /**
+     * The type of the view to register.
+     */
+    readonly type: string;
+    /**
+     * The view creator function that creates a view instance for the given type.
+     *
+     * @param leaf - The workspace leaf where the view will be created.
+     * @returns The created view instance.
+     */
+    readonly viewCreator: (leaf: WorkspaceLeaf) => View;
+}
+/**
+ * A registrar for views that registers views with a plugin.
+ */
+export declare class PluginViewRegistrar implements ViewRegistrar {
+    protected readonly plugin: Plugin;
+    /**
+     * Creates a new instance of the {@link PluginViewRegistrar} class.
+     *
+     * @param plugin - The Obsidian plugin instance used to register views.
+     */
+    constructor(plugin: Plugin);
+    /**
+     * Registers a view type with a view creator.
+     *
+     * @param params - The parameters for the view registration.
+     */
+    registerView(params: PluginViewRegistrarRegisterViewParams): void;
+}
+export {};

package/dist/lib/cjs/workspace.cjs

@@ -0,0 +1,186 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord["__name"] ??= keepName;
+  globalThisRecord["__extractDefault"] ??= extractDefault;
+  ensureBrowserProcess();
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    if (globalThis.app.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workspace_exports = {};
+__export(workspace_exports, {
+  ensureLayoutReady: () => ensureLayoutReady,
+  getAllContainers: () => getAllContainers,
+  getAllDomWindows: () => getAllDomWindows,
+  getMainWindow: () => getMainWindow,
+  switchToMainWindow: () => switchToMainWindow,
+  switchToWindow: () => switchToWindow
+});
+module.exports = __toCommonJS(workspace_exports);
+var import_disposable = require('@mnaoumov/typescript-lib/disposable');
+async function ensureLayoutReady(app) {
+  await new Promise((resolve) => {
+    app.workspace.onLayoutReady(resolve);
+  });
+}
+function getAllContainers(app) {
+  const containers = /* @__PURE__ */ new Set();
+  app.workspace.iterateAllLeaves((leaf) => {
+    containers.add(leaf.getContainer());
+  });
+  return [...containers];
+}
+function getAllDomWindows(app) {
+  return getAllContainers(app).map((container) => container.win);
+}
+function getMainWindow(app) {
+  return app.workspace.rootSplit.win;
+}
+function switchToMainWindow(app) {
+  return switchToWindow(getMainWindow(app));
+}
+function switchToWindow(win) {
+  const previousActiveWindow = activeWindow;
+  const previousActiveDocument = activeDocument;
+  window.activeWindow = win;
+  window.activeDocument = win.document;
+  return new import_disposable.CallbackDisposable({
+    callback: () => {
+      window.activeWindow = previousActiveWindow;
+      window.activeDocument = previousActiveDocument;
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ensureLayoutReady,
+  getAllContainers,
+  getAllDomWindows,
+  getMainWindow,
+  switchToMainWindow,
+  switchToWindow
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/workspace.d.cts

@@ -0,0 +1,81 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * This module provides additional utilities for working with the Obsidian {@link Workspace}.
+ */
+import type { DisposableEx } from '@mnaoumov/typescript-lib/disposable' with { 'resolution-mode': 'import' };
+import type { App, WorkspaceContainer } from 'obsidian' with { 'resolution-mode': 'import' };
+/**
+ * Waits until the workspace layout is ready.
+ *
+ * Resolves immediately when the layout is already ready; otherwise resolves once Obsidian fires the
+ * layout-ready event.
+ *
+ * @param app - The Obsidian app.
+ * @returns A {@link Promise} that resolves once the workspace layout is ready.
+ */
+export declare function ensureLayoutReady(app: App): Promise<void>;
+/**
+ * Returns all containers in the workspace.
+ *
+ * @param app - The Obsidian app.
+ * @returns All containers in the workspace.
+ */
+export declare function getAllContainers(app: App): WorkspaceContainer[];
+/**
+ * Returns all DOM windows in the workspace.
+ *
+ * @param app - The Obsidian app.
+ * @returns All DOM windows in the workspace.
+ */
+export declare function getAllDomWindows(app: App): Window[];
+/**
+ * Returns the app's main window — the one the vault opened in, as opposed to any popout window.
+ *
+ * Read from the root split, which is the one workspace container that always lives in the main window
+ * (every popout is a {@link WorkspaceWindow} under `floatingSplit`). Prefer this over the global
+ * `window`, which only happens to be the main window because plugin code runs in its context.
+ *
+ * @param app - The Obsidian app.
+ * @returns The app's main window.
+ */
+export declare function getMainWindow(app: App): Window;
+/**
+ * Makes the app's main window the active one until the returned {@link DisposableEx} is disposed.
+ *
+ * See {@link switchToWindow} for why this is needed and what it changes, and {@link getMainWindow} for
+ * what counts as the main window.
+ *
+ * @param app - The Obsidian app.
+ * @returns A {@link DisposableEx} that restores the previously active window when disposed.
+ * @example
+ * ```ts
+ * // Raise a notice in the main window even while the settings window is open.
+ * using _mainWindowSwitch = switchToMainWindow(app);
+ * new Notice('This vault is a temporary sandbox.');
+ * ```
+ */
+export declare function switchToMainWindow(app: App): DisposableEx;
+/**
+ * Makes the given window the active one until the returned {@link DisposableEx} is disposed.
+ *
+ * Obsidian tracks the focused window in the `activeWindow` / `activeDocument` globals and updates them
+ * whenever a window takes focus — including when a popout such as the settings window opens. UI it
+ * creates for "the current window" reads those globals at creation time and offers no way to name a
+ * window: `new Notice(...)`, for instance, is built inside whatever window `activeWindow` points at,
+ * and cannot be moved afterwards. Pointing the globals at the wanted window for exactly that creation,
+ * then putting them back, is what this does.
+ *
+ * Restore is what makes it safe, so always bind it with `using` (or dispose it in a `finally`): leaving
+ * the globals pointed at the wrong window would misplace every later window-sensitive Obsidian call.
+ *
+ * @param win - The window to make active.
+ * @returns A {@link DisposableEx} that restores the previously active window when disposed.
+ * @example
+ * ```ts
+ * using _windowSwitch = switchToWindow(otherWindow);
+ * new Notice('This notice belongs to the other window.');
+ * ```
+ */
+export declare function switchToWindow(win: Window): DisposableEx;

package/dist/lib/esm/@types/dataview/api/data-array.d.mts

@@ -0,0 +1,137 @@
+/// <reference path="../../../library.d.mts" />
+import type { QuerySettings } from '../settings.d.mjs';
+/** A function which maps an array element to some value. */
+export type ArrayFunc<T, O> = (elem: T, index: number, arr: T[]) => O;
+/** A function which compares two types. */
+export type ArrayComparator<T> = (a: T, b: T) => number;
+/** Finds the value of the lowest value type in a grouping. */
+export type LowestKey<T> = T extends {
+  key: any;
+  rows: any;
+} ? LowestKey<T['rows'][0]>
+  : T;
+/** A ridiculous type which properly types the result of the 'groupIn' command. */
+export type Ingrouped<U, T> = T extends {
+  key: any;
+  rows: any;
+} ? {
+    key: T['key'];
+    rows: Ingrouped<U, T['rows'][0]>;
+  }
+  : {
+    key: U;
+    rows: T[];
+  };
+/**
+ * Proxied interface which allows manipulating array-based data. All functions on a data array produce a NEW array
+ * (i.e., the arrays are immutable).
+ */
+export interface DataArray<T> {
+  /** The total number of elements in the array. */
+  length: number;
+  /** Filter the data array down to just elements which match the given predicate. */
+  where(predicate: ArrayFunc<T, boolean>): DataArray<T>;
+  /** Alias for 'where' for people who want array semantics. */
+  filter(predicate: ArrayFunc<T, boolean>): DataArray<T>;
+  /** Map elements in the data array by applying a function to each. */
+  map<U>(f: ArrayFunc<T, U>): DataArray<U>;
+  /** Map elements in the data array by applying a function to each, then flatten the results to produce a new array. */
+  flatMap<U>(f: ArrayFunc<T, U[]>): DataArray<U>;
+  /** Mutably change each value in the array, returning the same array which you can further chain off of. */
+  mutate(f: ArrayFunc<T, void>): DataArray<T>;
+  /** Limit the total number of entries in the array to the given value. */
+  limit(count: number): DataArray<T>;
+  /**
+   * Take a slice of the array. If `start` is undefined, it is assumed to be 0; if `end` is undefined, it is assumed
+   * to be the end of the array.
+   */
+  slice(start?: number, end?: number): DataArray<T>;
+  /** Concatenate the values in this data array with those of another iterable / data array / array. */
+  concat(other: Iterable<T>): DataArray<T>;
+  /** Return the first index of the given (optionally starting the search) */
+  indexOf(element: T, fromIndex?: number): number;
+  /** Return the first element that satisfies the given predicate. */
+  find(pred: ArrayFunc<T, boolean>): T | undefined;
+  /** Find the index of the first element that satisfies the given predicate. Returns -1 if nothing was found. */
+  findIndex(pred: ArrayFunc<T, boolean>, fromIndex?: number): number;
+  /** Returns true if the array contains the given element, and false otherwise. */
+  includes(element: T): boolean;
+  /**
+   * Return a string obtained by converting each element in the array to a string, and joining it with the
+   * given separator (which defaults to ', ').
+   */
+  join(sep?: string): string;
+  /**
+   * Return a sorted array sorted by the given key; an optional comparator can be provided, which will
+   * be used to compare the keys in lieu of the default dataview comparator.
+   */
+  sort<U>(key: ArrayFunc<T, U>, direction?: 'asc' | 'desc', comparator?: ArrayComparator<U>): DataArray<T>;
+  /**
+   * Mutably modify the current array with an in place sort; this is less flexible than a regular sort in exchange
+   * for being a little more performant. Only use this is performance is a serious consideration.
+   */
+  sortInPlace<U>(key: (v: T) => U, direction?: 'asc' | 'desc', comparator?: ArrayComparator<U>): DataArray<T>;
+  /**
+   * Return an array where elements are grouped by the given key; the resulting array will have objects of the form
+   * { key: <key value>, rows: DataArray }.
+   */
+  groupBy<U>(key: ArrayFunc<T, U>, comparator?: ArrayComparator<U>): DataArray<{
+    key: U;
+    rows: DataArray<T>;
+  }>;
+  /**
+   * If the array is not grouped, groups it as `groupBy` does; otherwise, groups the elements inside each current
+   * group. This allows for top-down recursive grouping which may be easier than bottom-up grouping.
+   */
+  groupIn<U>(key: ArrayFunc<LowestKey<T>, U>, comparator?: ArrayComparator<U>): DataArray<Ingrouped<U, T>>;
+  /**
+   * Return distinct entries. If a key is provided, then rows with distinct keys are returned.
+   */
+  distinct<U>(key?: ArrayFunc<T, U>, comparator?: ArrayComparator<U>): DataArray<T>;
+  /** Return true if the predicate is true for all values. */
+  every(f: ArrayFunc<T, boolean>): boolean;
+  /** Return true if the predicate is true for at least one value. */
+  some(f: ArrayFunc<T, boolean>): boolean;
+  /** Return true if the predicate is FALSE for all values. */
+  none(f: ArrayFunc<T, boolean>): boolean;
+  /** Return the first element in the data array. Returns undefined if the array is empty. */
+  first(): T;
+  /** Return the last element in the data array. Returns undefined if the array is empty. */
+  last(): T;
+  /** Map every element in this data array to the given key, and then flatten it.*/
+  to(key: string): DataArray<any>;
+  /** Map every element in this data array to the given key; unlike to(), does not flatten the result. */
+  into(key: string): DataArray<any>;
+  /**
+   * Recursively expand the given key, flattening a tree structure based on the key into a flat array. Useful for handling
+   * hierarchical data like tasks with 'subtasks'.
+   */
+  expand(key: string): DataArray<any>;
+  /** Run a lambda on each element in the array. */
+  forEach(f: ArrayFunc<T, void>): void;
+  /** Calculate the sum of the elements in the array. */
+  sum(): number;
+  /** Calculate the average of the elements in the array. */
+  avg(): number;
+  /** Calculate the minimum of the elements in the array. */
+  min(): number;
+  /** Calculate the maximum of the elements in the array. */
+  max(): number;
+  /** Convert this to a plain javascript array. */
+  array(): T[];
+  /** Allow iterating directly over the array. */
+  [Symbol.iterator](): Iterator<T>;
+  /** Map indexes to values. */
+  [index: number]: any;
+  /** Automatic flattening of fields. Equivalent to implicitly calling `array.to("field")` */
+  [field: string]: any;
+}
+/** Provides utility functions for generating data arrays. */
+export declare namespace DataArray {
+  /** Create a new Dataview data array. */
+  function wrap<T>(raw: T[] | DataArray<T>, settings: QuerySettings): DataArray<T>;
+  /** Create a new DataArray from an iterable object. */
+  function from<T>(raw: Iterable<T>, settings: QuerySettings): DataArray<T>;
+  /** Return true if the given object is a data array. */
+  function isDataArray(obj: any): obj is DataArray<any>;
+}

package/dist/lib/esm/@types/dataview/api/extensions.d.mts

@@ -0,0 +1,16 @@
+/// <reference path="../../../library.d.mts" />
+import type { STask } from '../data-model/serialized/markdown.d.mjs';
+/** A general function for deciding how to check a task given it's current state. */
+export type TaskStatusSelector = (task: STask) => Promise<string>;
+/**
+ * A dataview extension; allows for registering new functions, altering views, and altering some more
+ * advanced dataview behavior.
+ */
+export declare class Extension {
+  plugin: string;
+  /** All registered task status selectors for this extension. */
+  taskStatusSelectors: Record<string, TaskStatusSelector>;
+  constructor(plugin: string);
+  /** Register a task status selector under the given name. */
+  taskStatusSelector(name: string, selector: TaskStatusSelector): Extension;
+}

package/dist/lib/esm/@types/dataview/api/inline-api.d.mts

@@ -0,0 +1,187 @@
+/// <reference path="../../../library.d.mts" />
+/** Fancy wrappers for the JavaScript API, used both by external plugins AND by the dataview javascript view. */
+import type {
+  DateTime,
+  Duration
+} from 'luxon';
+import * as Luxon from 'luxon';
+import type {
+  App,
+  Component
+} from 'obsidian';
+import type { FullIndex } from '../data-index/index.d.mjs';
+import type { SListItem } from '../data-model/serialized/markdown.d.mjs';
+import type {
+  DataObject,
+  Grouping,
+  Link,
+  Literal,
+  Values,
+  Widgets
+} from '../data-model/value.d.mjs';
+import type { Context } from '../expression/context.d.mjs';
+import type { BoundFunctionImpl } from '../expression/functions.d.mjs';
+import type {
+  DataviewSettings,
+  ExportSettings
+} from '../settings.d.mjs';
+import type { DataArray } from './data-array.d.mjs';
+import type {
+  DataviewApi,
+  DataviewIOApi,
+  QueryApiSettings,
+  QueryResult
+} from './plugin-api.d.mjs';
+import type { Result } from './result.d.mjs';
+/** Asynchronous API calls related to file / system IO. */
+export declare class DataviewInlineIOApi {
+  api: DataviewIOApi;
+  currentFile: string;
+  constructor(api: DataviewIOApi, currentFile: string);
+  /** Load the contents of a CSV asynchronously, returning a data array of rows (or undefined if it does not exist). */
+  csv(path: string, originFile?: string): Promise<DataArray<DataObject> | undefined>;
+  /** Asynchronously load the contents of any link or path in an Obsidian vault. */
+  load(path: Link | string, originFile?: string): Promise<string | undefined>;
+  /** Normalize a link or path relative to an optional origin file. Returns a textual fully-qualified-path. */
+  normalize(path: Link | string, originFile?: string): string;
+}
+export declare class DataviewInlineApi {
+  /**
+   * The raw dataview indices, which track file <-> metadata relations. Use these if the intuitive API does not support
+   * your use case.
+   */
+  index: FullIndex;
+  /** The component that handles the lifetime of this view. Use it if you are adding custom event handlers/components. */
+  component: Component;
+  /** The path to the current file this script is running in. */
+  currentFilePath: string;
+  /**
+   * The container which holds the output of this view. You can directly append fields to this, if you wish, though
+   * the rendering API is likely to be easier for straight-forward purposes.
+   */
+  container: HTMLElement;
+  /** Directly access the Obsidian app object, such as for reaching out to other plugins. */
+  app: App;
+  /** The general plugin API which much of this inline API delegates to. */
+  api: DataviewApi;
+  /** Settings which determine defaults, incl. many rendering options. */
+  settings: DataviewSettings;
+  /** Evaluation context which expressions can be evaluated in. */
+  evaluationContext: Context;
+  /** Value utilities which allow for type-checking and comparisons. */
+  value: typeof Values;
+  /** Widget utility functions for creating built-in widgets. */
+  widget: typeof Widgets;
+  /** IO utilities which are largely asynchronous. */
+  io: DataviewInlineIOApi;
+  /** Re-exporting of luxon for people who can't easily require it. Sorry! */
+  luxon: typeof Luxon;
+  /** Dataview functions which can be called from DataviewJS. */
+  func: Record<string, BoundFunctionImpl>;
+  constructor(api: DataviewApi, component: Component, container: HTMLElement, currentFilePath: string);
+  /** Return an array of paths (as strings) corresponding to pages which match the query. */
+  pagePaths(query?: string): DataArray<string>;
+  /** Map a page path to the actual data contained within that page. */
+  page(path: string | Link): DataObject | undefined;
+  /** Return an array of page objects corresponding to pages which match the query. */
+  pages(query?: string): DataArray<any>;
+  /** Return the information about the current page. */
+  current(): Record<string, any> | undefined;
+  /** Execute a Dataview query, returning the results in programmatic form. */
+  query(source: string, originFile?: string, settings?: QueryApiSettings): Promise<Result<QueryResult, string>>;
+  /** Error-throwing version of {@link query}. */
+  tryQuery(source: string, originFile?: string, settings?: QueryApiSettings): Promise<QueryResult>;
+  /** Execute a Dataview query, returning the results in Markdown. */
+  queryMarkdown(source: string, originFile?: string, settings?: QueryApiSettings): Promise<Result<string, string>>;
+  /** Error-throwing version of {@link queryMarkdown}. */
+  tryQueryMarkdown(source: string, originFile?: string, settings?: QueryApiSettings): Promise<string>;
+  /**
+   * Evaluate a dataview expression (like '2 + 2' or 'link("hello")'), returning the evaluated result.
+   * This takes an optional second argument which provides definitions for variables, such as:
+   *
+   * ```
+   * dv.evaluate("x + 6", { x: 2 }) = 8
+   * dv.evaluate('link(target)', { target: "Okay" }) = [[Okay]]
+   * ```
+   *
+   * Note that `this` is implicitly available and refers to the current file.
+   *
+   * This method returns a Result type instead of throwing an error; you can check the result of the
+   * execution via `result.successful` and obtain `result.value` or `result.error` accordingly. If
+   * you'd rather this method throw on an error, use `dv.tryEvaluate`.
+   */
+  evaluate(expression: string, context?: DataObject): Result<Literal, string>;
+  /** Error-throwing version of `dv.evaluate`. */
+  tryEvaluate(expression: string, context?: DataObject): Literal;
+  /** Execute a Dataview query and embed it into the current view. */
+  execute(source: string): Promise<void>;
+  /** Execute a DataviewJS query and embed it into the current view. */
+  executeJs(code: string): Promise<void>;
+  /**
+   * Convert an input element or array into a Dataview data-array. If the input is already a data array,
+   * it is returned unchanged.
+   */
+  array(raw: any): DataArray<any>;
+  /** Return true if the given value is a javascript array OR a dataview data array. */
+  isArray(raw: any): raw is DataArray<any> | Array<any>;
+  /** Return true if the given value is a dataview data array; this returns FALSE for plain JS arrays. */
+  isDataArray(raw: unknown): raw is DataArray<any>;
+  /** Create a dataview file link to the given path. */
+  fileLink(path: string, embed?: boolean, display?: string): Link;
+  /** Create a dataview section link to the given path. */
+  sectionLink(path: string, section: string, embed?: boolean, display?: string): Link;
+  /** Create a dataview block link to the given path. */
+  blockLink(path: string, blockId: string, embed?: boolean, display?: string): Link;
+  /** Attempt to extract a date from a string, link or date. */
+  date(pathlike: string | Link | DateTime): DateTime | null;
+  /** Attempt to extract a duration from a string or duration. */
+  duration(dur: string | Duration): Duration | null;
+  /** Parse a raw textual value into a complex Dataview type, if possible. */
+  parse(value: string): Literal;
+  /** Convert a basic JS type into a Dataview type by parsing dates, links, durations, and so on. */
+  literal(value: any): Literal;
+  /** Deep clone the given literal, returning a new literal which is independent of the original. */
+  clone(value: Literal): Literal;
+  /**
+   * Compare two arbitrary JavaScript values using Dataview's default comparison rules. Returns a negative value if
+   * a < b, 0 if a = b, and a positive value if a > b.
+   */
+  compare(a: any, b: any): number;
+  /** Return true if the two given JavaScript values are equal using Dataview's default comparison rules. */
+  equal(a: any, b: any): boolean;
+  /** Render an HTML element, containing arbitrary text. */
+  el<K extends keyof HTMLElementTagNameMap>(el: K, text: any, { container, ...options }?: DomElementInfo & {
+    container?: HTMLElement;
+  }): HTMLElementTagNameMap[K];
+  /** Render an HTML header; the level can be anything from 1 - 6. */
+  header(level: number, text: any, options?: DomElementInfo): HTMLHeadingElement;
+  /** Render an HTML paragraph, containing arbitrary text. */
+  paragraph(text: any, options?: DomElementInfo): HTMLParagraphElement;
+  /** Render an inline span, containing arbitrary text. */
+  span(text: any, options?: DomElementInfo): HTMLSpanElement;
+  /**
+   * Render HTML from the output of a template "view" saved as a file in the vault.
+   * Takes a filename and arbitrary input data.
+   */
+  view(viewName: string, input: any): Promise<void>;
+  /** Render a dataview list of the given values. */
+  list(values?: any[] | DataArray<any>): Promise<void>;
+  /** Render a dataview table with the given headers, and the 2D array of values. */
+  table(headers: string[], values?: any[][] | DataArray<any>): Promise<void>;
+  /** Render a dataview task view with the given tasks. */
+  taskList(tasks: Grouping<SListItem>, groupByFile?: boolean): Promise<void>;
+  /** Render a table directly to markdown, returning the markdown. */
+  markdownTable(headers: string[], values?: any[][] | DataArray<any>, settings?: Partial<ExportSettings>): string;
+  /** Render a list directly to markdown, returning the markdown. */
+  markdownList(values?: any[] | DataArray<any> | undefined, settings?: Partial<ExportSettings>): string;
+  /** Render at ask list directly to markdown, returning the markdown. */
+  markdownTaskList(values: Grouping<SListItem>, settings?: Partial<ExportSettings>): string;
+}
+/**
+ * Evaluate a script where 'this' for the script is set to the given context. Allows you to define global variables.
+ */
+export declare function evalInContext(script: string, context: any): any;
+/**
+ * Evaluate a script possibly asynchronously, if the script contains `async/await` blocks.
+ */
+export declare function asyncEvalInContext(script: string, context: any): Promise<any>;