@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

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,210 @@
+/*
+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 keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+
+  // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+  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 = 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 = 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);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        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);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    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;
+}