@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/esm/view-registrar.d.mts

@@ -0,0 +1,52 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * This file defines the {@link ViewRegistrar} interface and the {@link PluginViewRegistrar} class.
+ */
+import type { View, WorkspaceLeaf } from 'obsidian';
+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/esm/view-registrar.mjs

@@ -0,0 +1,65 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { Plugin } from "obsidian";
+class PluginViewRegistrar {
+  /**
+   * Creates a new instance of the {@link PluginViewRegistrar} class.
+   *
+   * @param plugin - The Obsidian plugin instance used to register views.
+   */
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+  plugin;
+  /**
+   * Registers a view type with a view creator.
+   *
+   * @param params - The parameters for the view registration.
+   */
+  registerView(params) {
+    this.plugin.registerView(params.type, params.viewCreator);
+  }
+}
+export {
+  PluginViewRegistrar
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,81 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * This module provides additional utilities for working with the Obsidian {@link Workspace}.
+ */
+import type { DisposableEx } from '@mnaoumov/typescript-lib/disposable';
+import type { App, WorkspaceContainer } from 'obsidian';
+/**
+ * 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/workspace.mjs

@@ -0,0 +1,84 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { CallbackDisposable } from "@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 CallbackDisposable({
+    callback: () => {
+      window.activeWindow = previousActiveWindow;
+      window.activeDocument = previousActiveDocument;
+    }
+  });
+}
+export {
+  ensureLayoutReady,
+  getAllContainers,
+  getAllDomWindows,
+  getMainWindow,
+  switchToMainWindow,
+  switchToWindow
+};
+//# sourceMappingURL=data:application/json;base64,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