obsidian-dev-utils 49.0.3 → 51.0.1

package/dist/lib/esm/obsidian/plugin/plugin-base.mjs

@@ -0,0 +1,363 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import {
+  Notice,
+  Plugin as ObsidianPlugin
+} from "obsidian";
+import { AsyncEvents } from "../../async-events.mjs";
+import {
+  convertAsyncToSync,
+  invokeAsyncSafely,
+  invokeAsyncSafelyAfterDelay
+} from "../../async.mjs";
+import { getDebugger } from "../../debug.mjs";
+import {
+  registerAsyncErrorEventHandler,
+  SilentError
+} from "../../error.mjs";
+import { noopAsync } from "../../function.mjs";
+import { registerAsyncEvent } from "../components/async-events-component.mjs";
+import {
+  initI18N,
+  t
+} from "../i18n/i18n.mjs";
+import { defaultTranslationsMap } from "../i18n/locales/translationsMap.mjs";
+import { getAllDomWindows } from "../workspace.mjs";
+import {
+  initDebugController,
+  initPluginContext
+} from "./plugin-context.mjs";
+class PluginBase extends ObsidianPlugin {
+  /**
+   * The events of the plugin.
+   */
+  events = new AsyncEvents();
+  /**
+   * Gets the AbortSignal used for aborting long-running operations.
+   *
+   * @returns The abort signal.
+   * @throws If the abort signal is not defined.
+   */
+  get abortSignal() {
+    if (!this._abortSignal) {
+      throw new Error("Abort signal not defined");
+    }
+    return this._abortSignal;
+  }
+  /**
+   * Gets the readonly plugin settings.
+   *
+   * @returns The readonly plugin settings.
+   */
+  get settings() {
+    return this.settingsManager.settingsWrapper.safeSettings;
+  }
+  /**
+   * Gets the plugin settings manager.
+   *
+   * @returns The plugin settings manager.
+   */
+  get settingsManager() {
+    if (!this._settingsManager) {
+      throw new Error("Settings manager not defined");
+    }
+    return this._settingsManager;
+  }
+  /**
+   * Gets the plugin settings tab.
+   *
+   * @returns The plugin settings tab.
+   */
+  get settingsTab() {
+    if (!this._settingsTab) {
+      throw new Error("Settings tab not defined");
+    }
+    return this._settingsTab;
+  }
+  _abortSignal;
+  _settingsManager = null;
+  _settingsTab = null;
+  lifecycleEventNames = /* @__PURE__ */ new Set();
+  notice;
+  /**
+   * Logs a message to the console.
+   *
+   * Use instead of `console.debug()`.
+   *
+   * Those messages are not shown by default, but they can be shown by enabling `your-plugin-id` debugger namespace.
+   *
+   * @see {@link https://github.com/mnaoumov/obsidian-dev-utils/blob/main/docs/debugging.md} for more information.
+   *
+   * @param message - The message to log.
+   * @param args - The arguments to log.
+   */
+  consoleDebug(message, ...args) {
+    const FRAMES_TO_SKIP = 1;
+    const pluginDebugger = getDebugger(this.manifest.id, FRAMES_TO_SKIP);
+    pluginDebugger(message, ...args);
+  }
+  /**
+   * Called when the external settings change.
+   *
+   * Usually, you don't need to override this method. Consider using {@link onLoadSettings} instead.
+   *
+   * If you still need to override this method, make sure to call `await super.onExternalSettingsChange()` first.
+   */
+  async onExternalSettingsChange() {
+    await super.onExternalSettingsChange?.();
+    await this._settingsManager?.loadFromFile(false);
+  }
+  /**
+   * Called when the plugin is loaded
+   *
+   * Usually, you don't need to override this method. Consider using {@link onloadImpl} instead.
+   *
+   * If you still need to override this method, make sure to call `await super.onload()` first.
+   */
+  async onload() {
+    await super.onload();
+    await this.onloadImpl();
+    invokeAsyncSafelyAfterDelay(this.afterLoad.bind(this));
+  }
+  /**
+   * Called when the plugin is unloaded.
+   *
+   * Usually, you don't need to override this method. Consider using {@link onunloadImpl} instead.
+   *
+   * If you still need to override this method, make sure to call `super.onunload()` first.
+   */
+  onunload() {
+    super.onunload();
+    invokeAsyncSafely(async () => {
+      try {
+        await this.onunloadImpl();
+      } finally {
+        await this.triggerLifecycleEvent("unload");
+      }
+    });
+  }
+  /**
+   * Registers a DOM window handler.
+   *
+   * @param domWindowHandler - The DOM window handler.
+   */
+  registerDomWindowHandler(domWindowHandler) {
+    const mainWindow = window;
+    domWindowHandler(mainWindow);
+    this.app.workspace.onLayoutReady(() => {
+      for (const win of getAllDomWindows(this.app)) {
+        if (win === mainWindow) {
+          continue;
+        }
+        domWindowHandler(win);
+      }
+      this.registerEvent(this.app.workspace.on("window-open", (workspaceWindow) => {
+        domWindowHandler(workspaceWindow.win);
+      }));
+    });
+  }
+  /**
+   * Registers a callback to be executed when a lifecycle event is triggered.
+   *
+   * @param name - The name of the event.
+   * @param callback - The callback to execute.
+   */
+  registerForLifecycleEvent(name, callback) {
+    invokeAsyncSafely(async () => {
+      await this.waitForLifecycleEvent(name);
+      await callback();
+    });
+  }
+  /**
+   * Registers a DOM event for all popup window documents.
+   *
+   * @typeParam DocumentEventType - The type of the event.
+   * @param type - The type of the event.
+   * @param callback - The callback to execute.
+   * @param options - The options for the event.
+   */
+  registerPopupDocumentDomEvent(type, callback, options) {
+    this.registerDomWindowHandler((win) => {
+      this.registerDomEvent(win.document, type, callback, options);
+    });
+  }
+  /**
+   * Registers a DOM event for all popup windows.
+   *
+   * @typeParam WindowEventType - The type of the event.
+   * @param type - The type of the event.
+   * @param callback - The callback to execute.
+   * @param options - The options for the event.
+   */
+  registerPopupWindowDomEvent(type, callback, options) {
+    this.registerDomWindowHandler((win) => {
+      this.registerDomEvent(win, type, callback, options);
+    });
+  }
+  /**
+   * Waits for a lifecycle event to be triggered.
+   *
+   * If you `await` this method during lifecycle event, it might cause a deadlock.
+   *
+   * Consider wrapping this call with {@link invokeAsyncSafely}.
+   *
+   * @param name - The name of the event.
+   * @returns A {@link Promise} that resolves when the event is triggered.
+   */
+  async waitForLifecycleEvent(name) {
+    if (this.lifecycleEventNames.has(name)) {
+      return;
+    }
+    await new Promise((resolve) => {
+      this.events.once(name, () => {
+        resolve();
+      });
+    });
+  }
+  /**
+   * Creates the plugin settings manager. This method must be implemented by subclasses.
+   *
+   * @returns The plugin settings manager.
+   */
+  createSettingsManager() {
+    return null;
+  }
+  /**
+   * Creates a plugin settings tab.
+   *
+   * @returns The settings tab or `null` if not applicable.
+   */
+  createSettingsTab() {
+    return null;
+  }
+  /**
+   * Creates a translations map.
+   *
+   * @returns The translations map.
+   */
+  createTranslationsMap() {
+    return defaultTranslationsMap;
+  }
+  /**
+   * Called when an async error occurs.
+   *
+   * @param _asyncError - The async error.
+   */
+  handleAsyncError(_asyncError) {
+    this.showNotice(t(($) => $.obsidianDevUtils.notices.unhandledError));
+  }
+  /**
+   * Called when the layout is ready.
+   */
+  async onLayoutReady() {
+    await noopAsync();
+  }
+  /**
+   * Executed when the plugin is loaded.
+   *
+   * If this method fails, the plugin will be automatically unloaded.
+   *
+   * @remarks It is important to call `super.onloadImpl()` in overridden method.
+   */
+  async onloadImpl() {
+    initPluginContext(this.app, this.manifest.id);
+    this.registerDomWindowHandler((win) => {
+      initDebugController(win);
+    });
+    await initI18N(this.createTranslationsMap());
+    this.register(registerAsyncErrorEventHandler(this.handleAsyncError.bind(this)));
+    this._settingsManager = this.createSettingsManager();
+    if (this._settingsManager) {
+      registerAsyncEvent(this, this._settingsManager.on("loadSettings", this.onLoadSettings.bind(this)));
+      registerAsyncEvent(this, this._settingsManager.on("saveSettings", this.onSaveSettings.bind(this)));
+    }
+    await this._settingsManager?.loadFromFile(true);
+    this._settingsTab = this.createSettingsTab();
+    if (this._settingsTab) {
+      this.addSettingTab(this._settingsTab);
+    }
+    const abortController = new AbortController();
+    this._abortSignal = abortController.signal;
+    this.register(() => {
+      abortController.abort(new SilentError(`Plugin ${this.manifest.id} had been unloaded`));
+    });
+  }
+  /**
+   * Called when the plugin settings are loaded or reloaded.
+   *
+   * @param _loadedSettings - The loaded settings wrapper.
+   * @param _isInitialLoad - Whether the settings are being loaded for the first time.
+   */
+  async onLoadSettings(_loadedSettings, _isInitialLoad) {
+    await noopAsync();
+  }
+  /**
+   * Called when the plugin settings are saved.
+   *
+   * @param _newSettings - The new settings.
+   * @param _oldSettings - The old settings.
+   * @param _context - The context.
+   */
+  async onSaveSettings(_newSettings, _oldSettings, _context) {
+    await noopAsync();
+  }
+  /**
+   * Called when the plugin is unloaded.
+   */
+  async onunloadImpl() {
+    await noopAsync();
+  }
+  /**
+   * Displays a notice message to the user.
+   *
+   * @param message - The message to display.
+   */
+  showNotice(message) {
+    if (this.notice) {
+      this.notice.hide();
+    }
+    this.notice = new Notice(`${this.manifest.name}
+${message}`);
+  }
+  async afterLoad() {
+    if (this.abortSignal.aborted) {
+      return;
+    }
+    await this.triggerLifecycleEvent("load");
+    this.app.workspace.onLayoutReady(convertAsyncToSync(this.onLayoutReadyBase.bind(this)));
+  }
+  async onLayoutReadyBase() {
+    try {
+      await this.onLayoutReady();
+    } finally {
+      await this.triggerLifecycleEvent("layoutReady");
+    }
+  }
+  async triggerLifecycleEvent(name) {
+    this.lifecycleEventNames.add(name);
+    await this.events.triggerAsync(name);
+  }
+}
+export {
+  PluginBase
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/plugin/plugin-base.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Base class for Obsidian plugins providing utility methods for settings management, error handling, and notifications.\n *\n * This class simplifies the process of managing plugin settings, displaying notifications, and handling errors.\n * Subclasses should implement methods to create default settings and settings tabs, and complete plugin-specific\n * loading tasks.\n */\n\n/* v8 ignore start -- Deeply coupled to Obsidian runtime; requires running vault for meaningful testing. */\n\nimport type { ReadonlyDeep } from 'type-fest';\n\nimport {\n  Notice,\n  Plugin as ObsidianPlugin\n} from 'obsidian';\n\nimport type { TranslationsMap } from '../i18n/i18n.ts';\nimport type {\n  ExtractPluginSettings,\n  ExtractPluginSettingsManager,\n  ExtractPluginSettingsTab,\n  ExtractReadonlyPluginSettingsWrapper,\n  PluginTypesBase\n} from './plugin-types-base.ts';\n\nimport { AsyncEvents } from '../../async-events.ts';\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely,\n  invokeAsyncSafelyAfterDelay\n} from '../../async.ts';\nimport { getDebugger } from '../../debug.ts';\nimport {\n  registerAsyncErrorEventHandler,\n  SilentError\n} from '../../error.ts';\nimport { noopAsync } from '../../function.ts';\nimport { registerAsyncEvent } from '../components/async-events-component.ts';\nimport {\n  initI18N,\n  t\n} from '../i18n/i18n.ts';\nimport { defaultTranslationsMap } from '../i18n/locales/translationsMap.ts';\nimport { getAllDomWindows } from '../workspace.ts';\nimport {\n  initDebugController,\n  initPluginContext\n} from './plugin-context.ts';\n\ntype LifecycleEventName = 'layoutReady' | 'load' | 'unload';\n\n/**\n * Base class for creating Obsidian plugins with built-in support for settings management, error handling, and notifications.\n *\n * @typeParam PluginTypes - Plugin-specific types.\n */\nexport abstract class PluginBase<PluginTypes extends PluginTypesBase> extends ObsidianPlugin {\n  /**\n   * The events of the plugin.\n   */\n  public readonly events = new AsyncEvents();\n\n  /**\n   * Gets the AbortSignal used for aborting long-running operations.\n   *\n   * @returns The abort signal.\n   * @throws If the abort signal is not defined.\n   */\n  public get abortSignal(): AbortSignal {\n    if (!this._abortSignal) {\n      throw new Error('Abort signal not defined');\n    }\n    return this._abortSignal;\n  }\n\n  /**\n   * Gets the readonly plugin settings.\n   *\n   * @returns The readonly plugin settings.\n   */\n  public get settings(): ReadonlyDeep<ExtractPluginSettings<PluginTypes>> {\n    return this.settingsManager.settingsWrapper.safeSettings as ReadonlyDeep<ExtractPluginSettings<PluginTypes>>;\n  }\n\n  /**\n   * Gets the plugin settings manager.\n   *\n   * @returns The plugin settings manager.\n   */\n  public get settingsManager(): ExtractPluginSettingsManager<PluginTypes> {\n    if (!this._settingsManager) {\n      throw new Error('Settings manager not defined');\n    }\n\n    return this._settingsManager;\n  }\n\n  /**\n   * Gets the plugin settings tab.\n   *\n   * @returns The plugin settings tab.\n   */\n  public get settingsTab(): ExtractPluginSettingsTab<PluginTypes> {\n    if (!this._settingsTab) {\n      throw new Error('Settings tab not defined');\n    }\n\n    return this._settingsTab;\n  }\n\n  private _abortSignal?: AbortSignal;\n  private _settingsManager: ExtractPluginSettingsManager<PluginTypes> | null = null;\n  private _settingsTab: ExtractPluginSettingsTab<PluginTypes> | null = null;\n  private readonly lifecycleEventNames = new Set<LifecycleEventName>();\n  private notice?: Notice;\n\n  /**\n   * Logs a message to the console.\n   *\n   * Use instead of `console.debug()`.\n   *\n   * Those messages are not shown by default, but they can be shown by enabling `your-plugin-id` debugger namespace.\n   *\n   * @see {@link https://github.com/mnaoumov/obsidian-dev-utils/blob/main/docs/debugging.md} for more information.\n   *\n   * @param message - The message to log.\n   * @param args - The arguments to log.\n   */\n  public consoleDebug(message: string, ...args: unknown[]): void {\n    // Skip the `consoleDebug()` call itself\n    const FRAMES_TO_SKIP = 1;\n    const pluginDebugger = getDebugger(this.manifest.id, FRAMES_TO_SKIP);\n    pluginDebugger(message, ...args);\n  }\n\n  /**\n   * Called when the external settings change.\n   *\n   * Usually, you don't need to override this method. Consider using {@link onLoadSettings} instead.\n   *\n   * If you still need to override this method, make sure to call `await super.onExternalSettingsChange()` first.\n   */\n  public override async onExternalSettingsChange(): Promise<void> {\n    await super.onExternalSettingsChange?.();\n    await this._settingsManager?.loadFromFile(false);\n  }\n\n  /**\n   * Called when the plugin is loaded\n   *\n   * Usually, you don't need to override this method. Consider using {@link onloadImpl} instead.\n   *\n   * If you still need to override this method, make sure to call `await super.onload()` first.\n   */\n  public override async onload(): Promise<void> {\n    await super.onload();\n    await this.onloadImpl();\n    invokeAsyncSafelyAfterDelay(this.afterLoad.bind(this));\n  }\n\n  /**\n   * Called when the plugin is unloaded.\n   *\n   * Usually, you don't need to override this method. Consider using {@link onunloadImpl} instead.\n   *\n   * If you still need to override this method, make sure to call `super.onunload()` first.\n   */\n  public override onunload(): void {\n    super.onunload();\n    invokeAsyncSafely(async () => {\n      try {\n        await this.onunloadImpl();\n      } finally {\n        await this.triggerLifecycleEvent('unload');\n      }\n    });\n  }\n\n  /**\n   * Registers a DOM window handler.\n   *\n   * @param domWindowHandler - The DOM window handler.\n   */\n  public registerDomWindowHandler(domWindowHandler: (win: Window) => void): void {\n    const mainWindow = window;\n    domWindowHandler(mainWindow);\n\n    this.app.workspace.onLayoutReady(() => {\n      for (const win of getAllDomWindows(this.app)) {\n        if (win === mainWindow) {\n          continue;\n        }\n\n        domWindowHandler(win);\n      }\n\n      this.registerEvent(this.app.workspace.on('window-open', (workspaceWindow) => {\n        domWindowHandler(workspaceWindow.win);\n      }));\n    });\n  }\n\n  /**\n   * Registers a callback to be executed when a lifecycle event is triggered.\n   *\n   * @param name - The name of the event.\n   * @param callback - The callback to execute.\n   */\n  public registerForLifecycleEvent(name: LifecycleEventName, callback: () => Promise<void>): void {\n    invokeAsyncSafely(async () => {\n      await this.waitForLifecycleEvent(name);\n      await callback();\n    });\n  }\n\n  /**\n   * Registers a DOM event for all popup window documents.\n   *\n   * @typeParam DocumentEventType - The type of the event.\n   * @param type - The type of the event.\n   * @param callback - The callback to execute.\n   * @param options - The options for the event.\n   */\n  public registerPopupDocumentDomEvent<DocumentEventType extends keyof DocumentEventMap>(\n    type: DocumentEventType,\n    callback: (this: HTMLElement, evt: DocumentEventMap[DocumentEventType]) => unknown,\n    options?: AddEventListenerOptions | boolean\n  ): void {\n    this.registerDomWindowHandler((win) => {\n      this.registerDomEvent(win.document, type, callback, options);\n    });\n  }\n\n  /**\n   * Registers a DOM event for all popup windows.\n   *\n   * @typeParam WindowEventType - The type of the event.\n   * @param type - The type of the event.\n   * @param callback - The callback to execute.\n   * @param options - The options for the event.\n   */\n  public registerPopupWindowDomEvent<WindowEventType extends keyof WindowEventMap>(\n    type: WindowEventType,\n    callback: (this: HTMLElement, evt: WindowEventMap[WindowEventType]) => unknown,\n    options?: AddEventListenerOptions | boolean\n  ): void {\n    this.registerDomWindowHandler((win) => {\n      this.registerDomEvent(win, type, callback, options);\n    });\n  }\n\n  /**\n   * Waits for a lifecycle event to be triggered.\n   *\n   * If you `await` this method during lifecycle event, it might cause a deadlock.\n   *\n   * Consider wrapping this call with {@link invokeAsyncSafely}.\n   *\n   * @param name - The name of the event.\n   * @returns A {@link Promise} that resolves when the event is triggered.\n   */\n  public async waitForLifecycleEvent(name: LifecycleEventName): Promise<void> {\n    if (this.lifecycleEventNames.has(name)) {\n      return;\n    }\n\n    await new Promise<void>((resolve) => {\n      this.events.once(name, () => {\n        resolve();\n      });\n    });\n  }\n\n  /**\n   * Creates the plugin settings manager. This method must be implemented by subclasses.\n   *\n   * @returns The plugin settings manager.\n   */\n  protected createSettingsManager(): ExtractPluginSettingsManager<PluginTypes> | null {\n    return null;\n  }\n\n  /**\n   * Creates a plugin settings tab.\n   *\n   * @returns The settings tab or `null` if not applicable.\n   */\n  protected createSettingsTab(): ExtractPluginSettingsTab<PluginTypes> | null {\n    return null;\n  }\n\n  /**\n   * Creates a translations map.\n   *\n   * @returns The translations map.\n   */\n  protected createTranslationsMap(): TranslationsMap<PluginTypes> {\n    return defaultTranslationsMap;\n  }\n\n  /**\n   * Called when an async error occurs.\n   *\n   * @param _asyncError - The async error.\n   */\n  protected handleAsyncError(_asyncError: unknown): void {\n    this.showNotice(t(($) => $.obsidianDevUtils.notices.unhandledError));\n  }\n\n  /**\n   * Called when the layout is ready.\n   */\n  protected async onLayoutReady(): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Executed when the plugin is loaded.\n   *\n   * If this method fails, the plugin will be automatically unloaded.\n   *\n   * @remarks It is important to call `super.onloadImpl()` in overridden method.\n   */\n  protected async onloadImpl(): Promise<void> {\n    initPluginContext(this.app, this.manifest.id);\n    this.registerDomWindowHandler((win) => {\n      initDebugController(win);\n    });\n    await initI18N<PluginTypes>(this.createTranslationsMap());\n\n    this.register(registerAsyncErrorEventHandler(this.handleAsyncError.bind(this)));\n\n    this._settingsManager = this.createSettingsManager();\n    if (this._settingsManager) {\n      registerAsyncEvent(this, this._settingsManager.on('loadSettings', this.onLoadSettings.bind(this)));\n      registerAsyncEvent(this, this._settingsManager.on('saveSettings', this.onSaveSettings.bind(this)));\n    }\n\n    await this._settingsManager?.loadFromFile(true);\n    this._settingsTab = this.createSettingsTab();\n    if (this._settingsTab) {\n      this.addSettingTab(this._settingsTab);\n    }\n\n    const abortController = new AbortController();\n    this._abortSignal = abortController.signal;\n    this.register(() => {\n      abortController.abort(new SilentError(`Plugin ${this.manifest.id} had been unloaded`));\n    });\n  }\n\n  /**\n   * Called when the plugin settings are loaded or reloaded.\n   *\n   * @param _loadedSettings - The loaded settings wrapper.\n   * @param _isInitialLoad - Whether the settings are being loaded for the first time.\n   */\n  protected async onLoadSettings(_loadedSettings: ExtractReadonlyPluginSettingsWrapper<PluginTypes>, _isInitialLoad: boolean): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Called when the plugin settings are saved.\n   *\n   * @param _newSettings - The new settings.\n   * @param _oldSettings - The old settings.\n   * @param _context - The context.\n   */\n  protected async onSaveSettings(\n    _newSettings: ExtractReadonlyPluginSettingsWrapper<PluginTypes>,\n    _oldSettings: ExtractReadonlyPluginSettingsWrapper<PluginTypes>,\n    _context: unknown\n  ): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Called when the plugin is unloaded.\n   */\n  protected async onunloadImpl(): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Displays a notice message to the user.\n   *\n   * @param message - The message to display.\n   */\n  protected showNotice(message: string): void {\n    if (this.notice) {\n      this.notice.hide();\n    }\n\n    this.notice = new Notice(`${this.manifest.name}\\n${message}`);\n  }\n\n  private async afterLoad(): Promise<void> {\n    if (this.abortSignal.aborted) {\n      return;\n    }\n    await this.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.triggerLifecycleEvent('layoutReady');\n    }\n  }\n\n  private async triggerLifecycleEvent(name: LifecycleEventName): Promise<void> {\n    this.lifecycleEventNames.add(name);\n    await this.events.triggerAsync(name);\n  }\n}\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/obsidian/plugin/plugin-context.mjs

@@ -0,0 +1,67 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import { compareVersions } from "compare-versions";
+import { CssClass } from "../../css-class.mjs";
+import {
+  getDebugController,
+  showInitialDebugMessage
+} from "../../debug.mjs";
+import {
+  LIBRARY_NAME,
+  LIBRARY_STYLES,
+  LIBRARY_VERSION
+} from "../../library.mjs";
+import { getObsidianDevUtilsState } from "../app.mjs";
+import {
+  getPluginId,
+  setPluginId
+} from "./plugin-id.mjs";
+const STYLES_ID = `${LIBRARY_NAME}-styles`;
+function addPluginCssClasses(el, ...cssClasses) {
+  el.addClass(CssClass.LibraryName, getPluginId(), ...cssClasses);
+}
+function initDebugController(win) {
+  const pluginContextWindow = win;
+  pluginContextWindow.DEBUG = getDebugController();
+}
+function initPluginContext(app, pluginId) {
+  setPluginId(pluginId);
+  showInitialDebugMessage(pluginId);
+  const lastLibraryVersionWrapper = getObsidianDevUtilsState(app, "lastLibraryVersion", "0.0.0");
+  if (compareVersions(LIBRARY_VERSION, lastLibraryVersionWrapper.value) <= 0) {
+    return;
+  }
+  lastLibraryVersionWrapper.value = LIBRARY_VERSION;
+  document.head.querySelector(`#${STYLES_ID}`)?.remove();
+  document.head.createEl("style", {
+    attr: {
+      id: STYLES_ID
+    },
+    text: LIBRARY_STYLES
+  });
+}
+export {
+  addPluginCssClasses,
+  initDebugController,
+  initPluginContext
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/plugin/plugin-id.mjs

@@ -0,0 +1,37 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+const NO_PLUGIN_ID_INITIALIZED = "__no-plugin-id-initialized__";
+let pluginId = NO_PLUGIN_ID_INITIALIZED;
+function getPluginId() {
+  return pluginId;
+}
+function setPluginId(newPluginId) {
+  if (newPluginId) {
+    pluginId = newPluginId;
+  }
+}
+export {
+  NO_PLUGIN_ID_INITIALIZED,
+  getPluginId,
+  setPluginId
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL3BsdWdpbi9wbHVnaW4taWQudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQHBhY2thZ2VEb2N1bWVudGF0aW9uXG4gKlxuICogSG9sZGVyIGZvciB0aGUgcGx1Z2luIElELlxuICovXG5cbi8qKlxuICogQSBwbHVnaW4gSUQgZm9yIG5vIHBsdWdpbi5cbiAqL1xuZXhwb3J0IGNvbnN0IE5PX1BMVUdJTl9JRF9JTklUSUFMSVpFRCA9ICdfX25vLXBsdWdpbi1pZC1pbml0aWFsaXplZF9fJztcblxubGV0IHBsdWdpbklkID0gTk9fUExVR0lOX0lEX0lOSVRJQUxJWkVEO1xuXG4vKipcbiAqIFJldHVybnMgdGhlIHBsdWdpbiBJRC5cbiAqXG4gKiBAcmV0dXJucyBUaGUgcGx1Z2luIElELlxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0UGx1Z2luSWQoKTogc3RyaW5nIHtcbiAgcmV0dXJuIHBsdWdpbklkO1xufVxuXG4vKipcbiAqIFNldHMgdGhlIHBsdWdpbiBJRC5cbiAqXG4gKiBAcGFyYW0gbmV3UGx1Z2luSWQgLSBUaGUgbmV3IHBsdWdpbiBJRC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHNldFBsdWdpbklkKG5ld1BsdWdpbklkOiBzdHJpbmcpOiB2b2lkIHtcbiAgaWYgKG5ld1BsdWdpbklkKSB7XG4gICAgcGx1Z2luSWQgPSBuZXdQbHVnaW5JZDtcbiAgfVxufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBU08sTUFBTSwyQkFBMkI7QUFFeEMsSUFBSSxXQUFXO0FBT1IsU0FBUyxjQUFzQjtBQUNwQyxTQUFPO0FBQ1Q7QUFPTyxTQUFTLFlBQVksYUFBMkI7QUFDckQsTUFBSSxhQUFhO0FBQ2YsZUFBVztBQUFBLEVBQ2I7QUFDRjsiLAogICJuYW1lcyI6IFtdCn0K