obsidian-dev-utils 55.4.1 → 56.0.0

package/dist/lib/cjs/obsidian/plugin/plugin.cjs

@@ -4,6 +4,7 @@ if you want to view the source, please visit the github repository of this plugi
 */
 
 (function initCjs() {
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
   const globalThisRecord = globalThis;
   globalThisRecord['__name'] ??= name;
   const originalRequire = require;
@@ -83,11 +84,12 @@ if you want to view the source, please visit the github repository of this plugi
       return originalRequire?.(id);
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-deprecated, @typescript-eslint/no-unnecessary-condition -- We need access to app here which might not be available yet.
-    if (globalThis?.app?.isMobile) {
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/prefer-active-doc  -- 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.`);
+        // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
         return globalThis.process;
       }
     } else {
@@ -123,12 +125,141 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var plugin_exports = {};
 __export(plugin_exports, {
+  PluginBase: () => PluginBase,
   reloadPlugin: () => reloadPlugin,
   showErrorAndDisablePlugin: () => showErrorAndDisablePlugin
 });
 module.exports = __toCommonJS(plugin_exports);
 var import_obsidian = require('obsidian');
+var import_async = require('../../async.cjs');
 var import_error = require('../../error.cjs');
+var import_function = require('../../function.cjs');
+var import_type_guards = require('../../type-guards.cjs');
+var import_abort_signal_component = require('./components/abort-signal-component.cjs');
+var import_async_error_handler_component = require('./components/async-error-handler-component.cjs');
+var import_console_debug_component = require('./components/console-debug-component.cjs');
+var import_i18n_component = require('./components/i18n-component.cjs');
+var import_lifecycle_events_component = require('./components/lifecycle-events-component.cjs');
+var import_plugin_context_component = require('./components/plugin-context-component.cjs');
+var import_plugin_notice_component = require('./components/plugin-notice-component.cjs');
+var import_plugin_settings_component = require('./components/plugin-settings-component.cjs');
+class PluginBase extends import_obsidian.Plugin {
+  /**
+   * The abort signal component. Aborted when the plugin is unloaded.
+   */
+  abortSignalComponent;
+  /**
+   * The console debug component. Provides namespaced debug logging.
+   */
+  consoleDebugComponent;
+  /**
+   * The lifecycle events component. Provides load, layoutReady, and unload events.
+   */
+  lifecycleEventsComponent;
+  /**
+   * The notice component. Displays notices to the user.
+   */
+  noticeComponent;
+  /**
+   * The settings component. Manages plugin settings lifecycle.
+   */
+  settingsComponent;
+  componentsMap = /* @__PURE__ */ new Map();
+  preloadKeys = /* @__PURE__ */ new Set();
+  /**
+   * Creates a new PluginBase.
+   *
+   * @param app - The Obsidian app instance.
+   * @param manifest - The plugin manifest.
+   */
+  constructor(app, manifest) {
+    super(app, manifest);
+    this.registerComponent({ component: new import_plugin_context_component.PluginContextComponent(app, manifest.id), shouldPreload: true });
+    this.registerComponent({ component: new import_i18n_component.I18nComponent(), shouldPreload: true });
+    this.noticeComponent = this.registerComponent({ component: new import_plugin_notice_component.PluginNoticeComponent(manifest.name) });
+    this.registerComponent({ component: new import_async_error_handler_component.AsyncErrorHandlerComponent(this.noticeComponent) });
+    this.abortSignalComponent = this.registerComponent({ component: new import_abort_signal_component.AbortSignalComponent(manifest.id) });
+    this.consoleDebugComponent = this.registerComponent({ component: new import_console_debug_component.ConsoleDebugComponent(manifest.id) });
+    this.lifecycleEventsComponent = this.registerComponent({ component: new import_lifecycle_events_component.LifecycleEventsComponent(app) });
+    this.settingsComponent = this.registerComponent({ component: new import_plugin_settings_component.EmptyPluginSettingsComponent(), shouldPreload: true });
+  }
+  /**
+   * Called when the external settings change.
+   *
+   * Override in subclass if needed. Make sure to call `await super.onExternalSettingsChange()` first.
+   */
+  async onExternalSettingsChange() {
+    await super.onExternalSettingsChange?.();
+    await this.settingsComponent.onExternalSettingsChange();
+  }
+  /**
+   * Called when the plugin is loaded. Force-loads components that must be ready
+   * before plugin logic, then calls `onloadImpl()`.
+   *
+   * Usually, you don't need to override this method. Override {@link onloadImpl} instead.
+   */
+  async onload() {
+    await super.onload();
+    for (const key of this.preloadKeys) {
+      const component = this.componentsMap.get(key);
+      (0, import_type_guards.assertNonNullable)(component, `Component with key '${key}' not found`);
+      await component.load();
+    }
+    await this.onloadImpl();
+    (0, import_async.invokeAsyncSafelyAfterDelay)(this.afterLoad.bind(this));
+  }
+  /**
+   * Called when the layout is ready.
+   */
+  async onLayoutReady() {
+    await (0, import_function.noopAsync)();
+  }
+  /**
+   * Called after all pre-load components are initialized. Override this to add plugin-specific logic.
+   *
+   * @remarks It is important to call `super.onloadImpl()` in overridden method.
+   */
+  async onloadImpl() {
+    await (0, import_function.noopAsync)();
+  }
+  /**
+   * Registers a component with the plugin. If a component with the same key is already registered,
+   * the old component is removed and replaced.
+   *
+   * @typeParam T - The component type.
+   * @param params - The registration params.
+   * @returns The registered component.
+   */
+  registerComponent(params) {
+    const resolvedKey = params.key ?? params.component.constructor.name;
+    const oldComponent = this.componentsMap.get(resolvedKey);
+    if (oldComponent) {
+      this.removeChild(oldComponent);
+    }
+    this.componentsMap.set(resolvedKey, params.component);
+    this.addChild(params.component);
+    if (params.shouldPreload) {
+      this.preloadKeys.add(resolvedKey);
+    } else {
+      this.preloadKeys.delete(resolvedKey);
+    }
+    return params.component;
+  }
+  async afterLoad() {
+    if (this.abortSignalComponent.abortSignal.aborted) {
+      return;
+    }
+    await this.lifecycleEventsComponent.triggerLifecycleEvent("load");
+    this.app.workspace.onLayoutReady((0, import_async.convertAsyncToSync)(this.onLayoutReadyBase.bind(this)));
+  }
+  async onLayoutReadyBase() {
+    try {
+      await this.onLayoutReady();
+    } finally {
+      await this.lifecycleEventsComponent.triggerLifecycleEvent("layoutReady");
+    }
+  }
+}
 async function reloadPlugin(plugin) {
   const plugins = plugin.app.plugins;
   const pluginId = plugin.manifest.id;
@@ -142,7 +273,8 @@ async function showErrorAndDisablePlugin(plugin, message) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  PluginBase,
   reloadPlugin,
   showErrorAndDisablePlugin
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/plugin/plugin.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Base class for Obsidian plugins using a component-based architecture.\n *\n * PluginBase registers universal components (context, i18n, error handling, abort signal, lifecycle events, debug).\n * Subclasses add their own components via {@link registerComponent} in their constructor.\n * Any universal component can be replaced by calling {@link registerComponent} with a new instance of the same class.\n */\n\nimport type {\n  App,\n  PluginManifest\n} from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport {\n  Component,\n  Notice,\n  Plugin as ObsidianPlugin\n} from 'obsidian';\n\nimport type { PluginSettingsComponentBase } from './components/plugin-settings-component.ts';\n\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafelyAfterDelay\n} from '../../async.ts';\nimport { printError } from '../../error.ts';\nimport { noopAsync } from '../../function.ts';\nimport { assertNonNullable } from '../../type-guards.ts';\nimport { AbortSignalComponent } from './components/abort-signal-component.ts';\nimport { AsyncErrorHandlerComponent } from './components/async-error-handler-component.ts';\nimport { ConsoleDebugComponent } from './components/console-debug-component.ts';\nimport { I18nComponent } from './components/i18n-component.ts';\nimport { LifecycleEventsComponent } from './components/lifecycle-events-component.ts';\nimport { PluginContextComponent } from './components/plugin-context-component.ts';\nimport { PluginNoticeComponent } from './components/plugin-notice-component.ts';\nimport { EmptyPluginSettingsComponent } from './components/plugin-settings-component.ts';\n\n/**\n * Params for {@link PluginBase.registerComponent}.\n *\n * @typeParam T - The component type.\n */\nexport interface RegisterComponentParams<T extends Component = Component> {\n  /**\n   * The component to register.\n   */\n  readonly component: T;\n\n  /**\n   * Optional key. Defaults to the component's constructor name.\n   */\n  readonly key?: string;\n\n  /**\n   * Whether this component should be loaded before the plugin's `onloadImpl()` runs.\n   * Components marked with this flag are force-loaded during `onload()`, ensuring they are\n   * fully initialized before plugin logic executes.\n   */\n  readonly shouldPreload?: boolean;\n}\n\n/**\n * Base class for creating Obsidian plugins with a component-based architecture.\n *\n * Registers universal components automatically. Subclasses add or replace components\n * via {@link registerComponent} in their constructor.\n */\nexport abstract class PluginBase extends ObsidianPlugin {\n  /**\n   * The abort signal component. Aborted when the plugin is unloaded.\n   */\n  protected readonly abortSignalComponent: AbortSignalComponent;\n\n  /**\n   * The console debug component. Provides namespaced debug logging.\n   */\n  protected readonly consoleDebugComponent: ConsoleDebugComponent;\n\n  /**\n   * The lifecycle events component. Provides load, layoutReady, and unload events.\n   */\n  protected readonly lifecycleEventsComponent: LifecycleEventsComponent;\n\n  /**\n   * The notice component. Displays notices to the user.\n   */\n  protected readonly noticeComponent: PluginNoticeComponent;\n\n  /**\n   * The settings component. Manages plugin settings lifecycle.\n   */\n  protected readonly settingsComponent: PluginSettingsComponentBase<object>;\n\n  private readonly componentsMap = new Map<string, Component>();\n  private readonly preloadKeys = new Set<string>();\n\n  /**\n   * Creates a new PluginBase.\n   *\n   * @param app - The Obsidian app instance.\n   * @param manifest - The plugin manifest.\n   */\n  public constructor(app: App, manifest: PluginManifest) {\n    super(app, manifest);\n\n    this.registerComponent({ component: new PluginContextComponent(app, manifest.id), shouldPreload: true });\n    this.registerComponent({ component: new I18nComponent(), shouldPreload: true });\n    this.noticeComponent = this.registerComponent({ component: new PluginNoticeComponent(manifest.name) });\n    this.registerComponent({ component: new AsyncErrorHandlerComponent(this.noticeComponent) });\n    this.abortSignalComponent = this.registerComponent({ component: new AbortSignalComponent(manifest.id) });\n    this.consoleDebugComponent = this.registerComponent({ component: new ConsoleDebugComponent(manifest.id) });\n    this.lifecycleEventsComponent = this.registerComponent({ component: new LifecycleEventsComponent(app) });\n    this.settingsComponent = this.registerComponent({ component: new EmptyPluginSettingsComponent(), shouldPreload: true });\n  }\n\n  /**\n   * Called when the external settings change.\n   *\n   * Override in subclass if needed. Make sure to call `await super.onExternalSettingsChange()` first.\n   */\n  public override async onExternalSettingsChange(): Promise<void> {\n    await super.onExternalSettingsChange?.();\n    await this.settingsComponent.onExternalSettingsChange();\n  }\n\n  /**\n   * Called when the plugin is loaded. Force-loads components that must be ready\n   * before plugin logic, then calls `onloadImpl()`.\n   *\n   * Usually, you don't need to override this method. Override {@link onloadImpl} instead.\n   */\n  public override async onload(): Promise<void> {\n    await super.onload();\n\n    for (const key of this.preloadKeys) {\n      const component = this.componentsMap.get(key);\n      assertNonNullable(component, `Component with key '${key}' not found`);\n      // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression -- Component.load() returns void|Promise at runtime despite void typing.\n      await (component.load() as Promisable<void>);\n    }\n\n    await this.onloadImpl();\n    invokeAsyncSafelyAfterDelay(this.afterLoad.bind(this));\n  }\n\n  /**\n   * Called when the layout is ready.\n   */\n  protected async onLayoutReady(): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Called after all pre-load components are initialized. Override this to add plugin-specific logic.\n   *\n   * @remarks It is important to call `super.onloadImpl()` in overridden method.\n   */\n  protected async onloadImpl(): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Registers a component with the plugin. If a component with the same key is already registered,\n   * the old component is removed and replaced.\n   *\n   * @typeParam T - The component type.\n   * @param params - The registration params.\n   * @returns The registered component.\n   */\n  protected registerComponent<T extends Component>(params: RegisterComponentParams<T>): T {\n    const resolvedKey = params.key ?? params.component.constructor.name;\n    const oldComponent = this.componentsMap.get(resolvedKey);\n    if (oldComponent) {\n      this.removeChild(oldComponent);\n    }\n    this.componentsMap.set(resolvedKey, params.component);\n    this.addChild(params.component);\n\n    if (params.shouldPreload) {\n      this.preloadKeys.add(resolvedKey);\n    } else {\n      this.preloadKeys.delete(resolvedKey);\n    }\n\n    return params.component;\n  }\n\n  private async afterLoad(): Promise<void> {\n    if (this.abortSignalComponent.abortSignal.aborted) {\n      return;\n    }\n    await this.lifecycleEventsComponent.triggerLifecycleEvent('load');\n    this.app.workspace.onLayoutReady(convertAsyncToSync(this.onLayoutReadyBase.bind(this)));\n  }\n\n  private async onLayoutReadyBase(): Promise<void> {\n    try {\n      await this.onLayoutReady();\n    } finally {\n      await this.lifecycleEventsComponent.triggerLifecycleEvent('layoutReady');\n    }\n  }\n}\n\n/**\n * Reloads the specified plugin by disabling and then re-enabling it.\n *\n * @param plugin - The plugin to reload.\n * @returns A {@link Promise} that resolves when the plugin is reloaded.\n */\nexport async function reloadPlugin(plugin: ObsidianPlugin): Promise<void> {\n  const plugins = plugin.app.plugins;\n  const pluginId = plugin.manifest.id;\n  await plugins.disablePlugin(pluginId);\n  await plugins.enablePlugin(pluginId);\n}\n\n/**\n * Displays an error message as a notice, logs it to the console, and disables the specified plugin.\n *\n * @param plugin - The plugin to disable.\n * @param message - The error message to display and log.\n * @returns A {@link Promise} that resolves when the plugin is disabled.\n */\nexport async function showErrorAndDisablePlugin(plugin: ObsidianPlugin, message: string): Promise<void> {\n  new Notice(message);\n  printError(new Error(message));\n  await plugin.app.plugins.disablePlugin(plugin.manifest.id);\n}\n"],
  "mappings": "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",
  "names": ["ObsidianPlugin"]
}


package/dist/lib/cjs/obsidian/plugin/plugin.d.cts

@@ -1,17 +1,118 @@
 /**
  * @file
  *
- * This module provides utility functions for managing Obsidian plugins,
- * including displaying error messages, disabling plugins, and reloading them.
+ * Base class for Obsidian plugins using a component-based architecture.
+ *
+ * PluginBase registers universal components (context, i18n, error handling, abort signal, lifecycle events, debug).
+ * Subclasses add their own components via {@link registerComponent} in their constructor.
+ * Any universal component can be replaced by calling {@link registerComponent} with a new instance of the same class.
+ */
+import type { App, PluginManifest } from 'obsidian';
+import { Component, Plugin as ObsidianPlugin } from 'obsidian';
+import type { PluginSettingsComponentBase } from './components/plugin-settings-component.cjs';
+import { AbortSignalComponent } from './components/abort-signal-component.cjs';
+import { ConsoleDebugComponent } from './components/console-debug-component.cjs';
+import { LifecycleEventsComponent } from './components/lifecycle-events-component.cjs';
+import { PluginNoticeComponent } from './components/plugin-notice-component.cjs';
+/**
+ * Params for {@link PluginBase.registerComponent}.
+ *
+ * @typeParam T - The component type.
+ */
+export interface RegisterComponentParams<T extends Component = Component> {
+    /**
+     * The component to register.
+     */
+    readonly component: T;
+    /**
+     * Optional key. Defaults to the component's constructor name.
+     */
+    readonly key?: string;
+    /**
+     * Whether this component should be loaded before the plugin's `onloadImpl()` runs.
+     * Components marked with this flag are force-loaded during `onload()`, ensuring they are
+     * fully initialized before plugin logic executes.
+     */
+    readonly shouldPreload?: boolean;
+}
+/**
+ * Base class for creating Obsidian plugins with a component-based architecture.
+ *
+ * Registers universal components automatically. Subclasses add or replace components
+ * via {@link registerComponent} in their constructor.
  */
-import type { Plugin } from 'obsidian';
+export declare abstract class PluginBase extends ObsidianPlugin {
+    /**
+     * The abort signal component. Aborted when the plugin is unloaded.
+     */
+    protected readonly abortSignalComponent: AbortSignalComponent;
+    /**
+     * The console debug component. Provides namespaced debug logging.
+     */
+    protected readonly consoleDebugComponent: ConsoleDebugComponent;
+    /**
+     * The lifecycle events component. Provides load, layoutReady, and unload events.
+     */
+    protected readonly lifecycleEventsComponent: LifecycleEventsComponent;
+    /**
+     * The notice component. Displays notices to the user.
+     */
+    protected readonly noticeComponent: PluginNoticeComponent;
+    /**
+     * The settings component. Manages plugin settings lifecycle.
+     */
+    protected readonly settingsComponent: PluginSettingsComponentBase<object>;
+    private readonly componentsMap;
+    private readonly preloadKeys;
+    /**
+     * Creates a new PluginBase.
+     *
+     * @param app - The Obsidian app instance.
+     * @param manifest - The plugin manifest.
+     */
+    constructor(app: App, manifest: PluginManifest);
+    /**
+     * Called when the external settings change.
+     *
+     * Override in subclass if needed. Make sure to call `await super.onExternalSettingsChange()` first.
+     */
+    onExternalSettingsChange(): Promise<void>;
+    /**
+     * Called when the plugin is loaded. Force-loads components that must be ready
+     * before plugin logic, then calls `onloadImpl()`.
+     *
+     * Usually, you don't need to override this method. Override {@link onloadImpl} instead.
+     */
+    onload(): Promise<void>;
+    /**
+     * Called when the layout is ready.
+     */
+    protected onLayoutReady(): Promise<void>;
+    /**
+     * Called after all pre-load components are initialized. Override this to add plugin-specific logic.
+     *
+     * @remarks It is important to call `super.onloadImpl()` in overridden method.
+     */
+    protected onloadImpl(): Promise<void>;
+    /**
+     * Registers a component with the plugin. If a component with the same key is already registered,
+     * the old component is removed and replaced.
+     *
+     * @typeParam T - The component type.
+     * @param params - The registration params.
+     * @returns The registered component.
+     */
+    protected registerComponent<T extends Component>(params: RegisterComponentParams<T>): T;
+    private afterLoad;
+    private onLayoutReadyBase;
+}
 /**
  * Reloads the specified plugin by disabling and then re-enabling it.
  *
  * @param plugin - The plugin to reload.
  * @returns A {@link Promise} that resolves when the plugin is reloaded.
  */
-export declare function reloadPlugin(plugin: Plugin): Promise<void>;
+export declare function reloadPlugin(plugin: ObsidianPlugin): Promise<void>;
 /**
  * Displays an error message as a notice, logs it to the console, and disables the specified plugin.
  *
@@ -19,4 +120,4 @@ export declare function reloadPlugin(plugin: Plugin): Promise<void>;
  * @param message - The error message to display and log.
  * @returns A {@link Promise} that resolves when the plugin is disabled.
  */
-export declare function showErrorAndDisablePlugin(plugin: Plugin, message: string): Promise<void>;
+export declare function showErrorAndDisablePlugin(plugin: ObsidianPlugin, message: string): Promise<void>;

package/dist/lib/cjs/obsidian/queue.cjs

@@ -4,6 +4,7 @@ if you want to view the source, please visit the github repository of this plugi
 */
 
 (function initCjs() {
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
   const globalThisRecord = globalThis;
   globalThisRecord['__name'] ??= name;
   const originalRequire = require;
@@ -83,11 +84,12 @@ if you want to view the source, please visit the github repository of this plugi
       return originalRequire?.(id);
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-deprecated, @typescript-eslint/no-unnecessary-condition -- We need access to app here which might not be available yet.
-    if (globalThis?.app?.isMobile) {
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/prefer-active-doc  -- 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.`);
+        // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
         return globalThis.process;
       }
     } else {
@@ -200,4 +202,4 @@ async function processNextQueueItem(app) {
   addToQueueAndWait,
   flushQueue
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/queue.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for enqueuing and processing functions in Obsidian.\n */\n\nimport type { App } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport type { ValueWrapper } from './app.ts';\n\nimport {\n  abortSignalAny,\n  abortSignalNever\n} from '../abort-controller.ts';\nimport {\n  addErrorHandler,\n  invokeAsyncSafely\n} from '../async.ts';\nimport { getStackTrace } from '../error.ts';\nimport { noop } from '../function.ts';\nimport { getObsidianDevUtilsState } from './app.ts';\nimport { runWithTimeoutNotice } from './async-with-notice.ts';\nimport { t } from './i18n/i18n.ts';\nimport { invokeAsyncAndLog } from './logger.ts';\n\n/**\n * Options for the {@link addToQueueAndWait} function.\n */\nexport interface AddToQueueAndWaitParams {\n  /**\n   * Optional abort signal.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * The Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * The function to add.\n   */\n  readonly operationFn: (abortSignal: AbortSignal) => Promisable<void>;\n\n  /**\n   * Optional name of the operation.\n   */\n  readonly operationName?: string;\n\n  /**\n   * Whether to show a timeout notice. Default is `true`.\n   */\n  readonly shouldShowTimeoutNotice?: boolean;\n\n  /**\n   * Optional stack trace.\n   */\n  readonly stackTrace?: string;\n\n  /**\n   * The timeout in milliseconds.\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * Options for the {@link addToQueue} function.\n */\nexport interface AddToQueueParams {\n  /**\n   * Optional abort signal.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * The Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * The function to add.\n   */\n  readonly operationFn: (abortSignal: AbortSignal) => Promisable<void>;\n\n  /**\n   * Optional name of the operation.\n   */\n  readonly operationName?: string;\n\n  /**\n   * Whether to show a timeout notice. Default is `true`.\n   */\n  readonly shouldShowTimeoutNotice?: boolean;\n\n  /**\n   * Optional stack trace.\n   */\n  readonly stackTrace?: string;\n\n  /**\n   * The timeout in milliseconds.\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\ninterface Queue {\n  items: QueueItem[];\n  promise: Promise<void>;\n}\n\ninterface QueueItem {\n  abortSignal: AbortSignal;\n  operationFn(this: void, abortSignal: AbortSignal): Promisable<void>;\n  operationName: string;\n  shouldShowTimeoutNotice: boolean;\n  stackTrace: string;\n  timeoutInMilliseconds: number;\n}\n\n/**\n * Adds an asynchronous function to be executed after the previous function completes.\n *\n * @param params - The parameters for the function.\n */\nexport function addToQueue(params: AddToQueueParams): void {\n  const stackTrace = params.stackTrace ?? getStackTrace(1);\n  invokeAsyncSafely(() => addToQueueAndWait(params), stackTrace);\n}\n\n/**\n * Adds an asynchronous function to be executed after the previous function completes and returns a {@link Promise} that resolves when the function completes.\n *\n * @param params - The parameters for the function.\n */\nexport async function addToQueueAndWait(params: AddToQueueAndWaitParams): Promise<void> {\n  const abortSignal = params.abortSignal ?? abortSignalNever();\n  abortSignal.throwIfAborted();\n\n  const DEFAULT_TIMEOUT_IN_MILLISECONDS = 60000;\n  const timeoutInMilliseconds = params.timeoutInMilliseconds ?? DEFAULT_TIMEOUT_IN_MILLISECONDS;\n  const stackTrace = params.stackTrace ?? getStackTrace(1);\n  const operationName = params.operationName ?? '';\n  const queue = getQueue(params.app).value;\n  queue.items.push({\n    abortSignal,\n    operationFn: params.operationFn,\n    operationName,\n    shouldShowTimeoutNotice: params.shouldShowTimeoutNotice ?? true,\n    stackTrace,\n    timeoutInMilliseconds\n  });\n  queue.promise = queue.promise.then(() => processNextQueueItem(params.app));\n  await queue.promise;\n}\n\n/**\n * Flushes the queue;\n *\n * @param app - The Obsidian application instance.\n */\nexport async function flushQueue(app: App): Promise<void> {\n  await addToQueueAndWait({\n    app,\n    operationFn: noop,\n    operationName: t(($) => $.obsidianDevUtils.queue.flushQueue)\n  });\n}\n\nfunction getQueue(app: App): ValueWrapper<Queue> {\n  return getObsidianDevUtilsState(app, 'queue', { items: [], promise: Promise.resolve() });\n}\n\nasync function processNextQueueItem(app: App): Promise<void> {\n  const queue = getQueue(app).value;\n  const item = queue.items[0];\n  /* v8 ignore start -- Defensive check; processNextQueueItem is only called after an item is pushed. */\n  if (!item) {\n    return;\n  }\n  /* v8 ignore stop */\n\n  await addErrorHandler(() =>\n    runWithTimeoutNotice({\n      context: { queuedFn: item.operationFn },\n      async operationFn(abortSignal: AbortSignal): Promise<void> {\n        await invokeAsyncAndLog(\n          item.operationName || processNextQueueItem.name,\n          item.operationFn,\n          abortSignalAny(abortSignal, item.abortSignal),\n          item.stackTrace\n        );\n      },\n      operationName: item.operationName,\n      shouldShowTimeoutNotice: item.shouldShowTimeoutNotice,\n      stackTrace: item.stackTrace,\n      timeoutInMilliseconds: item.timeoutInMilliseconds\n    })\n  );\n  queue.items.shift();\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,8BAGO;AACP,mBAGO;AACP,mBAA8B;AAC9B,sBAAqB;AACrB,iBAAyC;AACzC,+BAAqC;AACrC,kBAAkB;AAClB,oBAAkC;AAqG3B,SAAS,WAAW,QAAgC;AACzD,QAAM,aAAa,OAAO,kBAAc,4BAAc,CAAC;AACvD,sCAAkB,MAAM,kBAAkB,MAAM,GAAG,UAAU;AAC/D;AAOA,eAAsB,kBAAkB,QAAgD;AACtF,QAAM,cAAc,OAAO,mBAAe,0CAAiB;AAC3D,cAAY,eAAe;AAE3B,QAAM,kCAAkC;AACxC,QAAM,wBAAwB,OAAO,yBAAyB;AAC9D,QAAM,aAAa,OAAO,kBAAc,4BAAc,CAAC;AACvD,QAAM,gBAAgB,OAAO,iBAAiB;AAC9C,QAAM,QAAQ,SAAS,OAAO,GAAG,EAAE;AACnC,QAAM,MAAM,KAAK;AAAA,IACf;AAAA,IACA,aAAa,OAAO;AAAA,IACpB;AAAA,IACA,yBAAyB,OAAO,2BAA2B;AAAA,IAC3D;AAAA,IACA;AAAA,EACF,CAAC;AACD,QAAM,UAAU,MAAM,QAAQ,KAAK,MAAM,qBAAqB,OAAO,GAAG,CAAC;AACzE,QAAM,MAAM;AACd;AAOA,eAAsB,WAAW,KAAyB;AACxD,QAAM,kBAAkB;AAAA,IACtB;AAAA,IACA,aAAa;AAAA,IACb,mBAAe,eAAE,CAAC,MAAM,EAAE,iBAAiB,MAAM,UAAU;AAAA,EAC7D,CAAC;AACH;AAEA,SAAS,SAAS,KAA+B;AAC/C,aAAO,qCAAyB,KAAK,SAAS,EAAE,OAAO,CAAC,GAAG,SAAS,QAAQ,QAAQ,EAAE,CAAC;AACzF;AAEA,eAAe,qBAAqB,KAAyB;AAC3D,QAAM,QAAQ,SAAS,GAAG,EAAE;AAC5B,QAAM,OAAO,MAAM,MAAM,CAAC;AAE1B,MAAI,CAAC,MAAM;AACT;AAAA,EACF;AAGA,YAAM;AAAA,IAAgB,UACpB,+CAAqB;AAAA,MACnB,SAAS,EAAE,UAAU,KAAK,YAAY;AAAA,MACtC,MAAM,YAAY,aAAyC;AACzD,kBAAM;AAAA,UACJ,KAAK,iBAAiB,qBAAqB;AAAA,UAC3C,KAAK;AAAA,cACL,wCAAe,aAAa,KAAK,WAAW;AAAA,UAC5C,KAAK;AAAA,QACP;AAAA,MACF;AAAA,MACA,eAAe,KAAK;AAAA,MACpB,yBAAyB,KAAK;AAAA,MAC9B,YAAY,KAAK;AAAA,MACjB,uBAAuB,KAAK;AAAA,IAC9B,CAAC;AAAA,EACH;AACA,QAAM,MAAM,MAAM;AACpB;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/queue.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for enqueuing and processing functions in Obsidian.\n */\n\nimport type { App } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport type { ValueWrapper } from './app.ts';\n\nimport {\n  abortSignalAny,\n  abortSignalNever\n} from '../abort-controller.ts';\nimport {\n  addErrorHandler,\n  invokeAsyncSafely\n} from '../async.ts';\nimport { getStackTrace } from '../error.ts';\nimport { noop } from '../function.ts';\nimport { getObsidianDevUtilsState } from './app.ts';\nimport { runWithTimeoutNotice } from './async-with-notice.ts';\nimport { t } from './i18n/i18n.ts';\nimport { invokeAsyncAndLog } from './logger.ts';\n\n/**\n * Options for the {@link addToQueueAndWait} function.\n */\nexport interface AddToQueueAndWaitParams {\n  /**\n   * Optional abort signal.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * The Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * The function to add.\n   */\n  readonly operationFn: (abortSignal: AbortSignal) => Promisable<void>;\n\n  /**\n   * Optional name of the operation.\n   */\n  readonly operationName?: string;\n\n  /**\n   * Whether to show a timeout notice. Default is `true`.\n   */\n  readonly shouldShowTimeoutNotice?: boolean;\n\n  /**\n   * Optional stack trace.\n   */\n  readonly stackTrace?: string;\n\n  /**\n   * The timeout in milliseconds.\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * Options for the {@link addToQueue} function.\n */\nexport interface AddToQueueParams {\n  /**\n   * Optional abort signal.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * The Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * The function to add.\n   */\n  readonly operationFn: (abortSignal: AbortSignal) => Promisable<void>;\n\n  /**\n   * Optional name of the operation.\n   */\n  readonly operationName?: string;\n\n  /**\n   * Whether to show a timeout notice. Default is `true`.\n   */\n  readonly shouldShowTimeoutNotice?: boolean;\n\n  /**\n   * Optional stack trace.\n   */\n  readonly stackTrace?: string;\n\n  /**\n   * The timeout in milliseconds.\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\ninterface Queue {\n  items: QueueItem[];\n  promise: Promise<void>;\n}\n\ninterface QueueItem {\n  abortSignal: AbortSignal;\n  operationFn(this: void, abortSignal: AbortSignal): Promisable<void>;\n  operationName: string;\n  shouldShowTimeoutNotice: boolean;\n  stackTrace: string;\n  timeoutInMilliseconds: number;\n}\n\n/**\n * Adds an asynchronous function to be executed after the previous function completes.\n *\n * @param params - The parameters for the function.\n */\nexport function addToQueue(params: AddToQueueParams): void {\n  const stackTrace = params.stackTrace ?? getStackTrace(1);\n  invokeAsyncSafely(() => addToQueueAndWait(params), stackTrace);\n}\n\n/**\n * Adds an asynchronous function to be executed after the previous function completes and returns a {@link Promise} that resolves when the function completes.\n *\n * @param params - The parameters for the function.\n */\nexport async function addToQueueAndWait(params: AddToQueueAndWaitParams): Promise<void> {\n  const abortSignal = params.abortSignal ?? abortSignalNever();\n  abortSignal.throwIfAborted();\n\n  const DEFAULT_TIMEOUT_IN_MILLISECONDS = 60000;\n  const timeoutInMilliseconds = params.timeoutInMilliseconds ?? DEFAULT_TIMEOUT_IN_MILLISECONDS;\n  const stackTrace = params.stackTrace ?? getStackTrace(1);\n  const operationName = params.operationName ?? '';\n  const queue = getQueue(params.app).value;\n  queue.items.push({\n    abortSignal,\n    operationFn: params.operationFn,\n    operationName,\n    shouldShowTimeoutNotice: params.shouldShowTimeoutNotice ?? true,\n    stackTrace,\n    timeoutInMilliseconds\n  });\n  queue.promise = queue.promise.then(() => processNextQueueItem(params.app));\n  await queue.promise;\n}\n\n/**\n * Flushes the queue;\n *\n * @param app - The Obsidian application instance.\n */\nexport async function flushQueue(app: App): Promise<void> {\n  await addToQueueAndWait({\n    app,\n    operationFn: noop,\n    operationName: t(($) => $.obsidianDevUtils.queue.flushQueue)\n  });\n}\n\nfunction getQueue(app: App): ValueWrapper<Queue> {\n  return getObsidianDevUtilsState(app, 'queue', { items: [], promise: Promise.resolve() });\n}\n\nasync function processNextQueueItem(app: App): Promise<void> {\n  const queue = getQueue(app).value;\n  const item = queue.items[0];\n  /* v8 ignore start -- Defensive check; processNextQueueItem is only called after an item is pushed. */\n  if (!item) {\n    return;\n  }\n  /* v8 ignore stop */\n\n  await addErrorHandler(() =>\n    runWithTimeoutNotice({\n      context: { queuedFn: item.operationFn },\n      async operationFn(abortSignal: AbortSignal): Promise<void> {\n        await invokeAsyncAndLog(\n          item.operationName || processNextQueueItem.name,\n          item.operationFn,\n          abortSignalAny(abortSignal, item.abortSignal),\n          item.stackTrace\n        );\n      },\n      operationName: item.operationName,\n      shouldShowTimeoutNotice: item.shouldShowTimeoutNotice,\n      stackTrace: item.stackTrace,\n      timeoutInMilliseconds: item.timeoutInMilliseconds\n    })\n  );\n  queue.items.shift();\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,8BAGO;AACP,mBAGO;AACP,mBAA8B;AAC9B,sBAAqB;AACrB,iBAAyC;AACzC,+BAAqC;AACrC,kBAAkB;AAClB,oBAAkC;AAqG3B,SAAS,WAAW,QAAgC;AACzD,QAAM,aAAa,OAAO,kBAAc,4BAAc,CAAC;AACvD,sCAAkB,MAAM,kBAAkB,MAAM,GAAG,UAAU;AAC/D;AAOA,eAAsB,kBAAkB,QAAgD;AACtF,QAAM,cAAc,OAAO,mBAAe,0CAAiB;AAC3D,cAAY,eAAe;AAE3B,QAAM,kCAAkC;AACxC,QAAM,wBAAwB,OAAO,yBAAyB;AAC9D,QAAM,aAAa,OAAO,kBAAc,4BAAc,CAAC;AACvD,QAAM,gBAAgB,OAAO,iBAAiB;AAC9C,QAAM,QAAQ,SAAS,OAAO,GAAG,EAAE;AACnC,QAAM,MAAM,KAAK;AAAA,IACf;AAAA,IACA,aAAa,OAAO;AAAA,IACpB;AAAA,IACA,yBAAyB,OAAO,2BAA2B;AAAA,IAC3D;AAAA,IACA;AAAA,EACF,CAAC;AACD,QAAM,UAAU,MAAM,QAAQ,KAAK,MAAM,qBAAqB,OAAO,GAAG,CAAC;AACzE,QAAM,MAAM;AACd;AAOA,eAAsB,WAAW,KAAyB;AACxD,QAAM,kBAAkB;AAAA,IACtB;AAAA,IACA,aAAa;AAAA,IACb,mBAAe,eAAE,CAAC,MAAM,EAAE,iBAAiB,MAAM,UAAU;AAAA,EAC7D,CAAC;AACH;AAEA,SAAS,SAAS,KAA+B;AAC/C,aAAO,qCAAyB,KAAK,SAAS,EAAE,OAAO,CAAC,GAAG,SAAS,QAAQ,QAAQ,EAAE,CAAC;AACzF;AAEA,eAAe,qBAAqB,KAAyB;AAC3D,QAAM,QAAQ,SAAS,GAAG,EAAE;AAC5B,QAAM,OAAO,MAAM,MAAM,CAAC;AAE1B,MAAI,CAAC,MAAM;AACT;AAAA,EACF;AAGA,YAAM;AAAA,IAAgB,UACpB,+CAAqB;AAAA,MACnB,SAAS,EAAE,UAAU,KAAK,YAAY;AAAA,MACtC,MAAM,YAAY,aAAyC;AACzD,kBAAM;AAAA,UACJ,KAAK,iBAAiB,qBAAqB;AAAA,UAC3C,KAAK;AAAA,cACL,wCAAe,aAAa,KAAK,WAAW;AAAA,UAC5C,KAAK;AAAA,QACP;AAAA,MACF;AAAA,MACA,eAAe,KAAK;AAAA,MACpB,yBAAyB,KAAK;AAAA,MAC9B,YAAY,KAAK;AAAA,MACjB,uBAAuB,KAAK;AAAA,IAC9B,CAAC;AAAA,EACH;AACA,QAAM,MAAM,MAAM;AACpB;",
  "names": []
}


package/dist/lib/cjs/obsidian/react/app-context.cjs

@@ -4,6 +4,7 @@ if you want to view the source, please visit the github repository of this plugi
 */
 
 (function initCjs() {
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
   const globalThisRecord = globalThis;
   globalThisRecord['__name'] ??= name;
   const originalRequire = require;
@@ -83,11 +84,12 @@ if you want to view the source, please visit the github repository of this plugi
       return originalRequire?.(id);
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-deprecated, @typescript-eslint/no-unnecessary-condition -- We need access to app here which might not be available yet.
-    if (globalThis?.app?.isMobile) {
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/prefer-active-doc  -- 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.`);
+        // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
         return globalThis.process;
       }
     } else {
@@ -139,4 +141,4 @@ function useApp() {
   AppContext,
   useApp
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL3JlYWN0L2FwcC1jb250ZXh0LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogUGFzc2VzIG9ic2lkaWFuIHtAbGluayBBcHB9IGluc3RhbmNlIHRvIFJlYWN0IGNvbXBvbmVudHMuXG4gKi9cblxuaW1wb3J0IHsgQXBwIH0gZnJvbSAnb2JzaWRpYW4nO1xuaW1wb3J0IHtcbiAgY3JlYXRlQ29udGV4dCxcbiAgdXNlQ29udGV4dFxufSBmcm9tICdyZWFjdCc7XG5cbmltcG9ydCB7IGVuc3VyZU5vbk51bGxhYmxlIH0gZnJvbSAnLi4vLi4vdHlwZS1ndWFyZHMudHMnO1xuXG4vKipcbiAqIEEgY29udGV4dCBmb3IgdGhlIGFwcC5cbiAqXG4gKiBVc2FnZTpcbiAqIGBgYHRzeFxuICogPEFwcENvbnRleHQuUHJvdmlkZXIgdmFsdWU9e2FwcH0+XG4gKiAgIDxZb3VyQ29tcG9uZW50IC8+XG4gKiA8L0FwcENvbnRleHQuUHJvdmlkZXI+XG4gKiBgYGBcbiAqL1xuLyogdjggaWdub3JlIHN0YXJ0IC0tIFJlYWN0IGNvbnRleHQgcmVxdWlyZXMgUmVhY3QgdGVzdGluZyBzZXR1cCB0aGF0IGlzIG5vdCBhdmFpbGFibGUgaW4gdGhpcyBwcm9qZWN0LiAqL1xuZXhwb3J0IGNvbnN0IEFwcENvbnRleHQgPSBjcmVhdGVDb250ZXh0PEFwcCB8IHVuZGVmaW5lZD4odW5kZWZpbmVkKTtcblxuLyoqXG4gKiBBIGhvb2sgdG8gdXNlIHRoZSBhcHAgY29udGV4dC5cbiAqXG4gKiBAcmV0dXJucyBUaGUgYXBwIGluc3RhbmNlLlxuICovXG5leHBvcnQgZnVuY3Rpb24gdXNlQXBwKCk6IEFwcCB7XG4gIHJldHVybiBlbnN1cmVOb25OdWxsYWJsZSh1c2VDb250ZXh0KEFwcENvbnRleHQpLCAnQXBwQ29udGV4dCBub3QgZm91bmQnKTtcbn1cbi8qIHY4IGlnbm9yZSBzdG9wICovXG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFNQSxzQkFBb0I7QUFDcEIsbUJBR087QUFFUCx5QkFBa0M7QUFhM0IsTUFBTSxpQkFBYSw0QkFBK0IsTUFBUztBQU8zRCxTQUFTLFNBQWM7QUFDNUIsYUFBTywwQ0FBa0IseUJBQVcsVUFBVSxHQUFHLHNCQUFzQjtBQUN6RTsiLAogICJuYW1lcyI6IFtdCn0K
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL3JlYWN0L2FwcC1jb250ZXh0LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogUGFzc2VzIG9ic2lkaWFuIHtAbGluayBBcHB9IGluc3RhbmNlIHRvIFJlYWN0IGNvbXBvbmVudHMuXG4gKi9cblxuaW1wb3J0IHsgQXBwIH0gZnJvbSAnb2JzaWRpYW4nO1xuaW1wb3J0IHtcbiAgY3JlYXRlQ29udGV4dCxcbiAgdXNlQ29udGV4dFxufSBmcm9tICdyZWFjdCc7XG5cbmltcG9ydCB7IGVuc3VyZU5vbk51bGxhYmxlIH0gZnJvbSAnLi4vLi4vdHlwZS1ndWFyZHMudHMnO1xuXG4vKipcbiAqIEEgY29udGV4dCBmb3IgdGhlIGFwcC5cbiAqXG4gKiBVc2FnZTpcbiAqIGBgYHRzeFxuICogPEFwcENvbnRleHQuUHJvdmlkZXIgdmFsdWU9e2FwcH0+XG4gKiAgIDxZb3VyQ29tcG9uZW50IC8+XG4gKiA8L0FwcENvbnRleHQuUHJvdmlkZXI+XG4gKiBgYGBcbiAqL1xuLyogdjggaWdub3JlIHN0YXJ0IC0tIFJlYWN0IGNvbnRleHQgcmVxdWlyZXMgUmVhY3QgdGVzdGluZyBzZXR1cCB0aGF0IGlzIG5vdCBhdmFpbGFibGUgaW4gdGhpcyBwcm9qZWN0LiAqL1xuZXhwb3J0IGNvbnN0IEFwcENvbnRleHQgPSBjcmVhdGVDb250ZXh0PEFwcCB8IHVuZGVmaW5lZD4odW5kZWZpbmVkKTtcblxuLyoqXG4gKiBBIGhvb2sgdG8gdXNlIHRoZSBhcHAgY29udGV4dC5cbiAqXG4gKiBAcmV0dXJucyBUaGUgYXBwIGluc3RhbmNlLlxuICovXG5leHBvcnQgZnVuY3Rpb24gdXNlQXBwKCk6IEFwcCB7XG4gIHJldHVybiBlbnN1cmVOb25OdWxsYWJsZSh1c2VDb250ZXh0KEFwcENvbnRleHQpLCAnQXBwQ29udGV4dCBub3QgZm91bmQnKTtcbn1cbi8qIHY4IGlnbm9yZSBzdG9wICovXG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQU1BLHNCQUFvQjtBQUNwQixtQkFHTztBQUVQLHlCQUFrQztBQWEzQixNQUFNLGlCQUFhLDRCQUErQixNQUFTO0FBTzNELFNBQVMsU0FBYztBQUM1QixhQUFPLDBDQUFrQix5QkFBVyxVQUFVLEdBQUcsc0JBQXNCO0FBQ3pFOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/cjs/obsidian/react/index.cjs

@@ -4,6 +4,7 @@ if you want to view the source, please visit the github repository of this plugi
 */
 
 (function initCjs() {
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
   const globalThisRecord = globalThis;
   globalThisRecord['__name'] ??= name;
   const originalRequire = require;
@@ -83,11 +84,12 @@ if you want to view the source, please visit the github repository of this plugi
       return originalRequire?.(id);
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-deprecated, @typescript-eslint/no-unnecessary-condition -- We need access to app here which might not be available yet.
-    if (globalThis?.app?.isMobile) {
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/prefer-active-doc  -- 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.`);
+        // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
         return globalThis.process;
       }
     } else {
@@ -141,4 +143,4 @@ var app_context = __toESM(__extractDefault(require('./app-context.cjs')), 1);
 0 && (module.exports = {
   app_context
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL3JlYWN0L2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKiBUSElTIElTIEEgR0VORVJBVEVEL0JVTkRMRUQgRklMRSBCWSBCVUlMRCBTQ1JJUFQgKi9cblxuZXhwb3J0ICogYXMgYXBwX2NvbnRleHQgZnJvbSAnLi9hcHAtY29udGV4dC50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUVBLGtCQUE2QjsiLAogICJuYW1lcyI6IFtdCn0K
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL3JlYWN0L2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKiBUSElTIElTIEEgR0VORVJBVEVEL0JVTkRMRUQgRklMRSBCWSBCVUlMRCBTQ1JJUFQgKi9cblxuZXhwb3J0ICogYXMgYXBwX2NvbnRleHQgZnJvbSAnLi9hcHAtY29udGV4dC50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBRUEsa0JBQTZCOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/cjs/obsidian/reference.cjs

@@ -4,6 +4,7 @@ if you want to view the source, please visit the github repository of this plugi
 */
 
 (function initCjs() {
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
   const globalThisRecord = globalThis;
   globalThisRecord['__name'] ??= name;
   const originalRequire = require;
@@ -83,11 +84,12 @@ if you want to view the source, please visit the github repository of this plugi
       return originalRequire?.(id);
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-deprecated, @typescript-eslint/no-unnecessary-condition -- We need access to app here which might not be available yet.
-    if (globalThis?.app?.isMobile) {
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/prefer-active-doc  -- 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.`);
+        // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
         return globalThis.process;
       }
     } else {
@@ -176,4 +178,4 @@ function sortReferences(references) {
   referenceToFileChange,
   sortReferences
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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