obsidian-dev-utils
Version:
This is the collection of useful functions that you can use for your Obsidian plugin development
364 lines (360 loc) • 33.8 kB
JavaScript
/*
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 {
convertAsyncToSync,
invokeAsyncSafely,
invokeAsyncSafelyAfterDelay
} from "../../Async.mjs";
import { AsyncEvents } from "../../AsyncEvents.mjs";
import { getDebugger } from "../../Debug.mjs";
import {
registerAsyncErrorEventHandler,
SilentError
} from "../../Error.mjs";
import { noopAsync } from "../../Function.mjs";
import { registerAsyncEvent } from "../Components/AsyncEventsComponent.mjs";
import {
initI18N,
t
} from "../i18n/i18n.mjs";
import { defaultTranslationsMap } from "../i18n/locales/translationsMap.mjs";
import { getAllDomWindows } from "../Workspace.mjs";
import {
initDebugController,
initPluginContext
} from "./PluginContext.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/PluginBase.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\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 './PluginTypesBase.ts';\n\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely,\n  invokeAsyncSafelyAfterDelay\n} from '../../Async.ts';\nimport { AsyncEvents } from '../../AsyncEvents.ts';\nimport { getDebugger } from '../../Debug.ts';\nimport {\n  registerAsyncErrorEventHandler,\n  SilentError\n} from '../../Error.ts';\nimport { noopAsync } from '../../Function.ts';\nimport { registerAsyncEvent } from '../Components/AsyncEventsComponent.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 './PluginContext.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"],
  "mappings": "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",
  "names": []
}
