obsidian-dev-utils 86.1.2 → 86.2.0

package/dist/lib/esm/obsidian/index.mjs

@@ -44,6 +44,7 @@ import * as desktop_trusted_input from "./desktop-trusted-input.mjs";
 import * as editor_extension_registrar from "./editor-extension-registrar.mjs";
 import * as editor_suggest_registrar from "./editor-suggest-registrar.mjs";
 import * as editor from "./editor.mjs";
+import * as events from "./events.mjs";
 import * as extensions_registrar from "./extensions-registrar.mjs";
 import * as file_change from "./file-change.mjs";
 import * as file_manager from "./file-manager.mjs";
@@ -112,6 +113,7 @@ export {
   editor,
   editor_extension_registrar as "editor-extension-registrar",
   editor_suggest_registrar as "editor-suggest-registrar",
+  events,
   extensions_registrar as "extensions-registrar",
   file_change as "file-change",
   file_manager as "file-manager",
@@ -157,4 +159,4 @@ export {
   view_registrar as "view-registrar",
   workspace
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/index.ts"],
  "sourcesContent": ["/* THIS IS A GENERATED/BUNDLED FILE BY BUILD SCRIPT */\n\nexport * as 'active-file-provider' from './active-file-provider.ts';\nexport * as 'app' from './app.ts';\nexport * as 'async-with-notice' from './async-with-notice.ts';\nexport * as 'attachment-path' from './attachment-path.ts';\nexport * as 'backlink' from './backlink.ts';\nexport * as 'bases-view-registrar' from './bases-view-registrar.ts';\nexport * as 'callout' from './callout.ts';\nexport * as 'case-insensitive-file-index' from './case-insensitive-file-index.ts';\nexport * as 'code-block-markdown-information' from './code-block-markdown-information.ts';\nexport * as 'command-handlers' from './command-handlers/index.ts';\nexport * as 'command-registrar' from './command-registrar.ts';\nexport * as 'community-plugins' from './community-plugins.ts';\nexport * as 'components' from './components/index.ts';\nexport * as 'constructors' from './constructors/index.ts';\nexport * as 'css-class' from './css-class.ts';\nexport * as 'data-handler' from './data-handler.ts';\nexport * as 'dataview-link' from './dataview-link.ts';\nexport * as 'dataview' from './dataview.ts';\nexport * as 'desktop-demo-vault-opener' from './desktop-demo-vault-opener.ts';\nexport * as 'desktop-trusted-input' from './desktop-trusted-input.ts';\nexport * as 'editor-extension-registrar' from './editor-extension-registrar.ts';\nexport * as 'editor-suggest-registrar' from './editor-suggest-registrar.ts';\nexport * as 'editor' from './editor.ts';\nexport * as 'extensions-registrar' from './extensions-registrar.ts';\nexport * as 'file-change' from './file-change.ts';\nexport * as 'file-manager' from './file-manager.ts';\nexport * as 'file-system' from './file-system.ts';\nexport * as 'frontmatter-link-cache-with-offsets' from './frontmatter-link-cache-with-offsets.ts';\nexport * as 'frontmatter' from './frontmatter.ts';\nexport * as 'hover-link-source-registrar' from './hover-link-source-registrar.ts';\nexport * as 'html-element' from './html-element.ts';\nexport * as 'i18n' from './i18n/index.ts';\nexport * as 'is-in-obsidian' from './is-in-obsidian.ts';\nexport * as 'link' from './link.ts';\nexport * as 'logger' from './logger.ts';\nexport * as 'loop' from './loop.ts';\nexport * as 'markdown-code-block-processor-registrar' from './markdown-code-block-processor-registrar.ts';\nexport * as 'markdown-code-block-processor' from './markdown-code-block-processor.ts';\nexport * as 'markdown-post-processor-registrar' from './markdown-post-processor-registrar.ts';\nexport * as 'markdown-view' from './markdown-view.ts';\nexport * as 'markdown' from './markdown.ts';\nexport * as 'menu-event-registrar' from './menu-event-registrar.ts';\nexport * as 'metadata-cache' from './metadata-cache.ts';\nexport * as 'modals' from './modals/index.ts';\nexport * as 'obsidian-protocol-handler-registrar' from './obsidian-protocol-handler-registrar.ts';\nexport * as 'obsidian-settings' from './obsidian-settings.ts';\nexport * as 'parse-link' from './parse-link.ts';\nexport * as 'path-settings' from './path-settings.ts';\nexport * as 'pdf' from './pdf.ts';\nexport * as 'plugin' from './plugin/index.ts';\nexport * as 'plugin-cli-handler-registrar' from './plugin-cli-handler-registrar.ts';\nexport * as 'queue' from './queue.ts';\nexport * as 'react' from './react/index.ts';\nexport * as 'reference' from './reference.ts';\nexport * as 'resource-lock' from './resource-lock.ts';\nexport * as 'resource-url' from './resource-url.ts';\nexport * as 'ribbon-icon-registrar' from './ribbon-icon-registrar.ts';\nexport * as 'setting-components' from './setting-components/index.ts';\nexport * as 'setting-ex' from './setting-ex.ts';\nexport * as 'setting-group-ex' from './setting-group-ex.ts';\nexport * as 'status-bar-item-registrar' from './status-bar-item-registrar.ts';\nexport * as 'validation' from './validation.ts';\nexport * as 'vault-delete' from './vault-delete.ts';\nexport * as 'vault-transaction' from './vault-transaction.ts';\nexport * as 'vault' from './vault.ts';\nexport * as 'view-registrar' from './view-registrar.ts';\nexport * as 'workspace' from './workspace.ts';\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAEA,YAAYA,0BAA4B;AACxC,YAAY,SAAW;AACvB,YAAYC,uBAAyB;AACrC,YAAYC,qBAAuB;AACnC,YAAY,cAAgB;AAC5B,YAAYC,0BAA4B;AACxC,YAAY,aAAe;AAC3B,YAAYC,iCAAmC;AAC/C,YAAYC,qCAAuC;AACnD,YAAYC,sBAAwB;AACpC,YAAYC,uBAAyB;AACrC,YAAYC,uBAAyB;AACrC,YAAY,gBAAkB;AAC9B,YAAY,kBAAoB;AAChC,YAAYC,eAAiB;AAC7B,YAAYC,kBAAoB;AAChC,YAAYC,mBAAqB;AACjC,YAAY,cAAgB;AAC5B,YAAYC,+BAAiC;AAC7C,YAAYC,2BAA6B;AACzC,YAAYC,gCAAkC;AAC9C,YAAYC,8BAAgC;AAC5C,YAAY,YAAc;AAC1B,YAAYC,0BAA4B;AACxC,YAAYC,iBAAmB;AAC/B,YAAYC,kBAAoB;AAChC,YAAYC,iBAAmB;AAC/B,YAAYC,yCAA2C;AACvD,YAAY,iBAAmB;AAC/B,YAAYC,iCAAmC;AAC/C,YAAYC,kBAAoB;AAChC,YAAY,UAAY;AACxB,YAAYC,oBAAsB;AAClC,YAAY,UAAY;AACxB,YAAY,YAAc;AAC1B,YAAY,UAAY;AACxB,YAAYC,6CAA+C;AAC3D,YAAYC,mCAAqC;AACjD,YAAYC,uCAAyC;AACrD,YAAYC,mBAAqB;AACjC,YAAY,cAAgB;AAC5B,YAAYC,0BAA4B;AACxC,YAAYC,oBAAsB;AAClC,YAAY,YAAc;AAC1B,YAAYC,yCAA2C;AACvD,YAAYC,uBAAyB;AACrC,YAAYC,gBAAkB;AAC9B,YAAYC,mBAAqB;AACjC,YAAY,SAAW;AACvB,YAAY,YAAc;AAC1B,YAAYC,kCAAoC;AAChD,YAAY,WAAa;AACzB,YAAY,WAAa;AACzB,YAAY,eAAiB;AAC7B,YAAYC,mBAAqB;AACjC,YAAYC,kBAAoB;AAChC,YAAYC,2BAA6B;AACzC,YAAYC,wBAA0B;AACtC,YAAYC,gBAAkB;AAC9B,YAAYC,sBAAwB;AACpC,YAAYC,+BAAiC;AAC7C,YAAY,gBAAkB;AAC9B,YAAYC,kBAAoB;AAChC,YAAYC,uBAAyB;AACrC,YAAY,WAAa;AACzB,YAAYC,oBAAsB;AAClC,YAAY,eAAiB;",
  "names": ["active-file-provider", "async-with-notice", "attachment-path", "bases-view-registrar", "case-insensitive-file-index", "code-block-markdown-information", "command-handlers", "command-registrar", "community-plugins", "css-class", "data-handler", "dataview-link", "desktop-demo-vault-opener", "desktop-trusted-input", "editor-extension-registrar", "editor-suggest-registrar", "extensions-registrar", "file-change", "file-manager", "file-system", "frontmatter-link-cache-with-offsets", "hover-link-source-registrar", "html-element", "is-in-obsidian", "markdown-code-block-processor-registrar", "markdown-code-block-processor", "markdown-post-processor-registrar", "markdown-view", "menu-event-registrar", "metadata-cache", "obsidian-protocol-handler-registrar", "obsidian-settings", "parse-link", "path-settings", "plugin-cli-handler-registrar", "resource-lock", "resource-url", "ribbon-icon-registrar", "setting-components", "setting-ex", "setting-group-ex", "status-bar-item-registrar", "vault-delete", "vault-transaction", "view-registrar"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/index.ts"],
  "sourcesContent": ["/* THIS IS A GENERATED/BUNDLED FILE BY BUILD SCRIPT */\n\nexport * as 'active-file-provider' from './active-file-provider.ts';\nexport * as 'app' from './app.ts';\nexport * as 'async-with-notice' from './async-with-notice.ts';\nexport * as 'attachment-path' from './attachment-path.ts';\nexport * as 'backlink' from './backlink.ts';\nexport * as 'bases-view-registrar' from './bases-view-registrar.ts';\nexport * as 'callout' from './callout.ts';\nexport * as 'case-insensitive-file-index' from './case-insensitive-file-index.ts';\nexport * as 'code-block-markdown-information' from './code-block-markdown-information.ts';\nexport * as 'command-handlers' from './command-handlers/index.ts';\nexport * as 'command-registrar' from './command-registrar.ts';\nexport * as 'community-plugins' from './community-plugins.ts';\nexport * as 'components' from './components/index.ts';\nexport * as 'constructors' from './constructors/index.ts';\nexport * as 'css-class' from './css-class.ts';\nexport * as 'data-handler' from './data-handler.ts';\nexport * as 'dataview-link' from './dataview-link.ts';\nexport * as 'dataview' from './dataview.ts';\nexport * as 'desktop-demo-vault-opener' from './desktop-demo-vault-opener.ts';\nexport * as 'desktop-trusted-input' from './desktop-trusted-input.ts';\nexport * as 'editor-extension-registrar' from './editor-extension-registrar.ts';\nexport * as 'editor-suggest-registrar' from './editor-suggest-registrar.ts';\nexport * as 'editor' from './editor.ts';\nexport * as 'events' from './events.ts';\nexport * as 'extensions-registrar' from './extensions-registrar.ts';\nexport * as 'file-change' from './file-change.ts';\nexport * as 'file-manager' from './file-manager.ts';\nexport * as 'file-system' from './file-system.ts';\nexport * as 'frontmatter-link-cache-with-offsets' from './frontmatter-link-cache-with-offsets.ts';\nexport * as 'frontmatter' from './frontmatter.ts';\nexport * as 'hover-link-source-registrar' from './hover-link-source-registrar.ts';\nexport * as 'html-element' from './html-element.ts';\nexport * as 'i18n' from './i18n/index.ts';\nexport * as 'is-in-obsidian' from './is-in-obsidian.ts';\nexport * as 'link' from './link.ts';\nexport * as 'logger' from './logger.ts';\nexport * as 'loop' from './loop.ts';\nexport * as 'markdown-code-block-processor-registrar' from './markdown-code-block-processor-registrar.ts';\nexport * as 'markdown-code-block-processor' from './markdown-code-block-processor.ts';\nexport * as 'markdown-post-processor-registrar' from './markdown-post-processor-registrar.ts';\nexport * as 'markdown-view' from './markdown-view.ts';\nexport * as 'markdown' from './markdown.ts';\nexport * as 'menu-event-registrar' from './menu-event-registrar.ts';\nexport * as 'metadata-cache' from './metadata-cache.ts';\nexport * as 'modals' from './modals/index.ts';\nexport * as 'obsidian-protocol-handler-registrar' from './obsidian-protocol-handler-registrar.ts';\nexport * as 'obsidian-settings' from './obsidian-settings.ts';\nexport * as 'parse-link' from './parse-link.ts';\nexport * as 'path-settings' from './path-settings.ts';\nexport * as 'pdf' from './pdf.ts';\nexport * as 'plugin' from './plugin/index.ts';\nexport * as 'plugin-cli-handler-registrar' from './plugin-cli-handler-registrar.ts';\nexport * as 'queue' from './queue.ts';\nexport * as 'react' from './react/index.ts';\nexport * as 'reference' from './reference.ts';\nexport * as 'resource-lock' from './resource-lock.ts';\nexport * as 'resource-url' from './resource-url.ts';\nexport * as 'ribbon-icon-registrar' from './ribbon-icon-registrar.ts';\nexport * as 'setting-components' from './setting-components/index.ts';\nexport * as 'setting-ex' from './setting-ex.ts';\nexport * as 'setting-group-ex' from './setting-group-ex.ts';\nexport * as 'status-bar-item-registrar' from './status-bar-item-registrar.ts';\nexport * as 'validation' from './validation.ts';\nexport * as 'vault-delete' from './vault-delete.ts';\nexport * as 'vault-transaction' from './vault-transaction.ts';\nexport * as 'vault' from './vault.ts';\nexport * as 'view-registrar' from './view-registrar.ts';\nexport * as 'workspace' from './workspace.ts';\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAEA,YAAYA,0BAA4B;AACxC,YAAY,SAAW;AACvB,YAAYC,uBAAyB;AACrC,YAAYC,qBAAuB;AACnC,YAAY,cAAgB;AAC5B,YAAYC,0BAA4B;AACxC,YAAY,aAAe;AAC3B,YAAYC,iCAAmC;AAC/C,YAAYC,qCAAuC;AACnD,YAAYC,sBAAwB;AACpC,YAAYC,uBAAyB;AACrC,YAAYC,uBAAyB;AACrC,YAAY,gBAAkB;AAC9B,YAAY,kBAAoB;AAChC,YAAYC,eAAiB;AAC7B,YAAYC,kBAAoB;AAChC,YAAYC,mBAAqB;AACjC,YAAY,cAAgB;AAC5B,YAAYC,+BAAiC;AAC7C,YAAYC,2BAA6B;AACzC,YAAYC,gCAAkC;AAC9C,YAAYC,8BAAgC;AAC5C,YAAY,YAAc;AAC1B,YAAY,YAAc;AAC1B,YAAYC,0BAA4B;AACxC,YAAYC,iBAAmB;AAC/B,YAAYC,kBAAoB;AAChC,YAAYC,iBAAmB;AAC/B,YAAYC,yCAA2C;AACvD,YAAY,iBAAmB;AAC/B,YAAYC,iCAAmC;AAC/C,YAAYC,kBAAoB;AAChC,YAAY,UAAY;AACxB,YAAYC,oBAAsB;AAClC,YAAY,UAAY;AACxB,YAAY,YAAc;AAC1B,YAAY,UAAY;AACxB,YAAYC,6CAA+C;AAC3D,YAAYC,mCAAqC;AACjD,YAAYC,uCAAyC;AACrD,YAAYC,mBAAqB;AACjC,YAAY,cAAgB;AAC5B,YAAYC,0BAA4B;AACxC,YAAYC,oBAAsB;AAClC,YAAY,YAAc;AAC1B,YAAYC,yCAA2C;AACvD,YAAYC,uBAAyB;AACrC,YAAYC,gBAAkB;AAC9B,YAAYC,mBAAqB;AACjC,YAAY,SAAW;AACvB,YAAY,YAAc;AAC1B,YAAYC,kCAAoC;AAChD,YAAY,WAAa;AACzB,YAAY,WAAa;AACzB,YAAY,eAAiB;AAC7B,YAAYC,mBAAqB;AACjC,YAAYC,kBAAoB;AAChC,YAAYC,2BAA6B;AACzC,YAAYC,wBAA0B;AACtC,YAAYC,gBAAkB;AAC9B,YAAYC,sBAAwB;AACpC,YAAYC,+BAAiC;AAC7C,YAAY,gBAAkB;AAC9B,YAAYC,kBAAoB;AAChC,YAAYC,uBAAyB;AACrC,YAAY,WAAa;AACzB,YAAYC,oBAAsB;AAClC,YAAY,eAAiB;",
  "names": ["active-file-provider", "async-with-notice", "attachment-path", "bases-view-registrar", "case-insensitive-file-index", "code-block-markdown-information", "command-handlers", "command-registrar", "community-plugins", "css-class", "data-handler", "dataview-link", "desktop-demo-vault-opener", "desktop-trusted-input", "editor-extension-registrar", "editor-suggest-registrar", "extensions-registrar", "file-change", "file-manager", "file-system", "frontmatter-link-cache-with-offsets", "hover-link-source-registrar", "html-element", "is-in-obsidian", "markdown-code-block-processor-registrar", "markdown-code-block-processor", "markdown-post-processor-registrar", "markdown-view", "menu-event-registrar", "metadata-cache", "obsidian-protocol-handler-registrar", "obsidian-settings", "parse-link", "path-settings", "plugin-cli-handler-registrar", "resource-lock", "resource-url", "ribbon-icon-registrar", "setting-components", "setting-ex", "setting-group-ex", "status-bar-item-registrar", "vault-delete", "vault-transaction", "view-registrar"]
}


package/dist/lib/esm/obsidian/menu-event-registrar.d.mts

@@ -5,6 +5,7 @@
  * Menu event registrar.
  */
 import type { Editor, MarkdownFileInfo, Menu, TAbstractFile, WorkspaceLeaf } from 'obsidian';
+import type { DisposableEx } from '../disposable.mjs';
 /**
  * Handler for the editor context menu event.
  *
@@ -39,18 +40,21 @@ export interface MenuEventRegistrar {
      * Registers a handler for the editor context menu event.
      *
      * @param handler - The handler to register.
+     * @returns A {@link DisposableEx} that unregisters the handler when disposed.
      */
-    registerEditorMenuEventHandler(handler: EditorMenuEventHandler): void;
+    registerEditorMenuEventHandler(handler: EditorMenuEventHandler): DisposableEx;
     /**
      * Registers a handler for the single-file context menu event.
      *
      * @param handler - The handler to register.
+     * @returns A {@link DisposableEx} that unregisters the handler when disposed.
      */
-    registerFileMenuEventHandler(handler: FileMenuEventHandler): void;
+    registerFileMenuEventHandler(handler: FileMenuEventHandler): DisposableEx;
     /**
      * Registers a handler for the multi-file context menu event.
      *
      * @param handler - The handler to register.
+     * @returns A {@link DisposableEx} that unregisters the handler when disposed.
      */
-    registerFilesMenuEventHandler(handler: FilesMenuEventHandler): void;
+    registerFilesMenuEventHandler(handler: FilesMenuEventHandler): DisposableEx;
 }

package/dist/lib/esm/script-utils/bundlers/esbuild-impl/change-extension-plugin.d.mts

@@ -12,3 +12,14 @@ import type { Plugin } from 'esbuild';
  * @returns An esbuild `Plugin` object that handles the renaming and modification of output files.
  */
 export declare function changeExtensionPlugin(extension: string): Plugin;
+/**
+ * Rewrites the extension of every import-like path in an emitted module's text from `.ts` to the target
+ * output extension (`.mjs` / `.cjs`), so the multi-file `dist/lib` build references its real siblings.
+ *
+ * Covers `require('…')`, static `from "…"`, and dynamic `import("…")` occurrences.
+ *
+ * @param text - The emitted module text to rewrite.
+ * @param extension - The output extension to rewrite `.ts` paths to (e.g. `.mjs` or `.cjs`).
+ * @returns The rewritten module text.
+ */
+export declare function rewriteImportPathExtensions(text: string, extension: string): string;

package/dist/lib/esm/script-utils/bundlers/esbuild-impl/change-extension-plugin.mjs

@@ -38,43 +38,40 @@ function changeExtensionPlugin(extension) {
             searchValue: /\.js$/g,
             str: file.path
           });
-          let newText = replaceAll({
-            replacer: ({ capturedGroupArgs: [importPath = ""] }) => {
-              if (importPath.endsWith(ObsidianDevUtilsRepoPaths.DtsExtension)) {
-                return "undefined";
-              }
-              const fixedImportPath = replaceAll({
-                replacer: extension,
-                searchValue: /\.ts$/g,
-                str: importPath
-              });
-              return `require('${fixedImportPath}')`;
-            },
-            searchValue: /require\(["'](?<ImportPath>.+?)["']\)/g,
-            str: file.text
-          });
-          newText = replaceAll({
-            replacer: ({ capturedGroupArgs: [importPath = ""] }) => {
-              if (importPath.endsWith(ObsidianDevUtilsRepoPaths.DtsExtension)) {
-                return "undefined";
-              }
-              const fixedImportPath = replaceAll({
-                replacer: extension,
-                searchValue: /\.ts$/g,
-                str: importPath
-              });
-              return `from "${fixedImportPath}"`;
-            },
-            searchValue: /from "(?<ImportPath>.+?)"/g,
-            str: newText
-          });
+          const newText = rewriteImportPathExtensions(file.text, extension);
           await writeFile(newPath, newText);
         }
       });
     }
   };
 }
+function rewriteImportPathExtensions(text, extension) {
+  let newText = replaceAll({
+    replacer: ({ capturedGroupArgs: [importPath = ""] }) => `require('${rewriteTsExtension(importPath, extension)}')`,
+    searchValue: /require\(["'](?<ImportPath>.+?)["']\)/g,
+    str: text
+  });
+  newText = replaceAll({
+    replacer: ({ capturedGroupArgs: [importPath = ""] }) => `from "${rewriteTsExtension(importPath, extension)}"`,
+    searchValue: /from "(?<ImportPath>.+?)"/g,
+    str: newText
+  });
+  newText = replaceAll({
+    replacer: ({ capturedGroupArgs: [importPath = ""] }) => `import("${rewriteTsExtension(importPath, extension)}")`,
+    searchValue: /import\(["'](?<ImportPath>.+?)["']\)/g,
+    str: newText
+  });
+  return newText;
+}
+function rewriteTsExtension(importPath, extension) {
+  return replaceAll({
+    replacer: extension,
+    searchValue: /\.ts$/g,
+    str: importPath
+  });
+}
 export {
-  changeExtensionPlugin
+  changeExtensionPlugin,
+  rewriteImportPathExtensions
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/script-utils/bundlers/esbuild-impl/copy-to-obsidian-plugins-folder-plugin.mjs

@@ -21,12 +21,9 @@ if you want to view the source, please visit the github repository of this plugi
   globalThis.process = browserProcess;
 })();
 
-import { existsSync } from "node:fs";
 import {
   cp,
-  mkdir,
-  readFile,
-  writeFile
+  mkdir
 } from "node:fs/promises";
 import process from "node:process";
 import {
@@ -66,63 +63,16 @@ function copyToObsidianPluginsFolderPlugin(params) {
         }
         obsidianConfigFolder = toPosixPath(obsidianConfigFolder);
         const pluginFolder = join(obsidianConfigFolder, "plugins", pluginName);
-        if (!existsSync(pluginFolder)) {
-          await mkdir(pluginFolder, { recursive: true });
-        }
+        await mkdir(pluginFolder, { recursive: true });
         await cp(distFolder, pluginFolder, { recursive: true });
-        const hotReloadFolder = join(obsidianConfigFolder, "plugins/hot-reload");
-        if (!existsSync(hotReloadFolder)) {
-          await mkdir(hotReloadFolder, { recursive: true });
-          const hotReloadRepoUrl = "https://raw.githubusercontent.com/pjeby/hot-reload/master/";
-          for (const fileName of ["main.js", "manifest.json"]) {
-            const fileUrl = hotReloadRepoUrl + fileName;
-            const response = await fetch(fileUrl);
-            const text = await response.text();
-            await writeFile(join(hotReloadFolder, fileName), text);
-          }
-        }
-        await enableCommunityPlugin({
+        await installAndEnableHotReload({
           obsidianConfigFolder,
-          pluginId: "hot-reload"
-        });
-        await enableCommunityPlugin({
-          obsidianConfigFolder,
-          pluginId: pluginName
+          pluginName
         });
       });
     }
   };
 }
-async function enableCommunityPlugin(params) {
-  const { obsidianConfigFolder, pluginId } = params;
-  const communityPluginsPath = join(obsidianConfigFolder, "community-plugins.json");
-  let plugins = [];
-  if (existsSync(communityPluginsPath)) {
-    const content = await readFile(communityPluginsPath, "utf-8");
-    plugins = JSON.parse(content);
-  }
-  if (!plugins.includes(pluginId)) {
-    plugins.push(pluginId);
-    const JSON_INDENT = 2;
-    await writeFile(communityPluginsPath, JSON.stringify(plugins, null, JSON_INDENT), "utf-8");
-  }
-  const vaultPath = dirname(obsidianConfigFolder);
-  try {
-    const transport = await getOrLaunchDevInstance(vaultPath);
-    await evalInObsidian({
-      args: { pluginId },
-      // eslint-disable-next-line no-shadow -- No actual shadowing as the function is executed externally.
-      async fn({ app, pluginId: pluginId2 }) {
-        await app.plugins.enablePluginAndSave(pluginId2);
-      },
-      shouldSkipPreflightChecks: true,
-      transport,
-      vaultPath
-    });
-  } catch (e) {
-    getLibDebugger("copyToObsidianPluginsFolderPlugin")(`Failed to live-enable plugin '${pluginId}'. It will be enabled on the next vault open.`, e);
-  }
-}
 async function getOrLaunchDevInstance(vaultPath) {
   devInstanceTransportPromise ??= launchDevInstance(vaultPath);
   try {
@@ -132,6 +82,41 @@ async function getOrLaunchDevInstance(vaultPath) {
     throw e;
   }
 }
+async function installAndEnableHotReload(params) {
+  const {
+    obsidianConfigFolder,
+    pluginName
+  } = params;
+  const vaultPath = dirname(obsidianConfigFolder);
+  const transport = await getOrLaunchDevInstance(vaultPath);
+  await evalInObsidian({
+    args: { pluginName },
+    // eslint-disable-next-line no-shadow -- No actual shadowing as the function is executed externally.
+    async fn({ app, obsidianModule, pluginName: pluginName2 }) {
+      const HOT_RELOAD_PLUGIN_ID = "hot-reload";
+      const COMMUNITY_PLUGINS_REGISTRY_URL = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/HEAD/community-plugins.json";
+      const { requestUrl } = obsidianModule;
+      if (!app.plugins.manifests[HOT_RELOAD_PLUGIN_ID]) {
+        const registryEntries = (await requestUrl(COMMUNITY_PLUGINS_REGISTRY_URL)).json;
+        const entry = registryEntries.find((candidate) => candidate.id === HOT_RELOAD_PLUGIN_ID);
+        if (!entry) {
+          throw new Error(`Plugin '${HOT_RELOAD_PLUGIN_ID}' was not found in the Obsidian community plugins registry.`);
+        }
+        const latestRelease = (await requestUrl(`https://api.github.com/repos/${entry.repo}/releases/latest`)).json;
+        const version = latestRelease.tag_name;
+        const manifest = (await requestUrl(`https://github.com/${entry.repo}/releases/download/${version}/manifest.json`)).json;
+        await app.plugins.installPlugin(entry.repo, version, manifest);
+      }
+      if (!app.plugins.enabledPlugins.has(HOT_RELOAD_PLUGIN_ID)) {
+        await app.plugins.enablePluginAndSave(HOT_RELOAD_PLUGIN_ID);
+      }
+      await app.plugins.enablePluginAndSave(pluginName2);
+    },
+    shouldSkipPreflightChecks: true,
+    transport,
+    vaultPath
+  });
+}
 async function launchDevInstance(vaultPath) {
   const transport = await createTransportFromOptions();
   try {
@@ -166,4 +151,4 @@ function registerDevInstanceCleanup(transport) {
 export {
   copyToObsidianPluginsFolderPlugin
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../../src/script-utils/bundlers/esbuild-impl/copy-to-obsidian-plugins-folder-plugin.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module defines an esbuild plugin that automatically copies the build output\n * to the Obsidian plugins folder during development. This plugin helps streamline\n * the development workflow by ensuring that the latest build is always available\n * in the correct Obsidian folder for testing and use.\n */\n\n/* v8 ignore start -- esbuild plugin that copies build output to Obsidian plugins folder; requires a live esbuild context. */\n\nimport type { Plugin } from 'esbuild';\nimport type { ObsidianTransport } from 'obsidian-integration-testing';\n\nimport { existsSync } from 'node:fs';\nimport {\n  cp,\n  mkdir,\n  readFile,\n  writeFile\n} from 'node:fs/promises';\nimport process from 'node:process';\nimport {\n  createTransportFromOptions,\n  evalInObsidian\n} from 'obsidian-integration-testing';\n\nimport { getLibDebugger } from '../../../debug.ts';\nimport {\n  dirname,\n  join,\n  toPosixPath\n} from '../../../path.ts';\n\n/**\n * Parameters for {@link copyToObsidianPluginsFolderPlugin}.\n */\nexport interface CopyToObsidianPluginsFolderPluginParams {\n  /**\n   * The folder where the built files are located.\n   */\n  readonly distFolder: string;\n\n  /**\n   * A boolean indicating whether the build is a production build.\n   */\n  readonly isProductionBuild: boolean;\n\n  /**\n   * The folder of the Obsidian configuration. If not provided, the plugin will not copy files.\n   */\n  readonly obsidianConfigFolder: string;\n\n  /**\n   * The name of the Obsidian plugin.\n   */\n  readonly pluginName: string;\n}\n\n/**\n * Parameters for {@link enableCommunityPlugin}.\n */\ninterface EnableCommunityPluginParams {\n  /**\n   * The folder of the Obsidian configuration.\n   */\n  readonly obsidianConfigFolder: string;\n\n  /**\n   * The ID of the community plugin to enable.\n   */\n  readonly pluginId: string;\n}\n\n// The `npm run dev`-owned Obsidian instance: launched on the first rebuild and reused across rebuilds.\n// It is closed when the `npm run dev` process terminates (see `registerDevInstanceCleanup`).\nlet devInstanceTransportPromise: Promise<ObsidianTransport> | undefined;\nlet isDevInstanceCleanupRegistered = false;\nlet isDevInstanceDisposed = false;\n\n/**\n * Creates an esbuild plugin that copies the build output to the Obsidian plugins folder.\n *\n * @param params - The parameters for the function.\n * @returns An esbuild `Plugin` object.\n */\nexport function copyToObsidianPluginsFolderPlugin(params: CopyToObsidianPluginsFolderPluginParams): Plugin {\n  const {\n    distFolder,\n    isProductionBuild,\n    pluginName\n  } = params;\n  let {\n    obsidianConfigFolder\n  } = params;\n  return {\n    name: 'copy-to-obsidian-plugins-folder',\n    setup(build): void {\n      build.onEnd(async () => {\n        if (isProductionBuild) {\n          return;\n        }\n\n        if (!obsidianConfigFolder) {\n          getLibDebugger('copyToObsidianPluginsFolderPlugin')(\n            'No Obsidian config folder configured. `OBSIDIAN_CONFIG_FOLDER` environment variable is not set in system or in `.env` file. The compiled plugin will not be copied into Obsidian plugins folder.'\n          );\n          return;\n        }\n\n        obsidianConfigFolder = toPosixPath(obsidianConfigFolder);\n\n        const pluginFolder = join(obsidianConfigFolder, 'plugins', pluginName);\n\n        if (!existsSync(pluginFolder)) {\n          await mkdir(pluginFolder, { recursive: true });\n        }\n\n        await cp(distFolder, pluginFolder, { recursive: true });\n\n        const hotReloadFolder = join(obsidianConfigFolder, 'plugins/hot-reload');\n        if (!existsSync(hotReloadFolder)) {\n          await mkdir(hotReloadFolder, { recursive: true });\n          const hotReloadRepoUrl = 'https://raw.githubusercontent.com/pjeby/hot-reload/master/';\n          for (const fileName of ['main.js', 'manifest.json']) {\n            const fileUrl = hotReloadRepoUrl + fileName;\n            // eslint-disable-next-line no-restricted-globals -- We run this outside of Obsidian, so we don't have `requestUrl()`.\n            const response = await fetch(fileUrl);\n            const text = await response.text();\n            await writeFile(join(hotReloadFolder, fileName), text);\n          }\n        }\n\n        await enableCommunityPlugin({\n          obsidianConfigFolder,\n          pluginId: 'hot-reload'\n        });\n        await enableCommunityPlugin({\n          obsidianConfigFolder,\n          pluginId: pluginName\n        });\n      });\n    }\n  };\n}\n\n/**\n * Enables a community plugin in the Obsidian configuration.\n *\n * @param params - The parameters for enabling the community plugin.\n * @returns A {@link Promise} that resolves when the plugin is enabled.\n */\nasync function enableCommunityPlugin(params: EnableCommunityPluginParams): Promise<void> {\n  const { obsidianConfigFolder, pluginId } = params;\n  const communityPluginsPath = join(obsidianConfigFolder, 'community-plugins.json');\n  let plugins: string[] = [];\n  if (existsSync(communityPluginsPath)) {\n    const content = await readFile(communityPluginsPath, 'utf-8');\n    plugins = JSON.parse(content) as string[];\n  }\n\n  if (!plugins.includes(pluginId)) {\n    plugins.push(pluginId);\n    const JSON_INDENT = 2;\n    await writeFile(communityPluginsPath, JSON.stringify(plugins, null, JSON_INDENT), 'utf-8');\n  }\n\n  const vaultPath = dirname(obsidianConfigFolder);\n\n  // Live-enabling is best-effort: the plugin is already registered in `community-plugins.json`, so it is enabled on the next vault open even if this fails (and hot-reload picks up rebuilds meanwhile).\n  try {\n    const transport = await getOrLaunchDevInstance(vaultPath);\n    await evalInObsidian({\n      args: { pluginId },\n      // eslint-disable-next-line no-shadow -- No actual shadowing as the function is executed externally.\n      async fn({ app, pluginId }) {\n        await app.plugins.enablePluginAndSave(pluginId);\n      },\n      shouldSkipPreflightChecks: true,\n      transport,\n      vaultPath\n    });\n  } catch (e: unknown) {\n    getLibDebugger('copyToObsidianPluginsFolderPlugin')(`Failed to live-enable plugin '${pluginId}'. It will be enabled on the next vault open.`, e);\n  }\n}\n\n/**\n * Returns the `npm run dev`-owned Obsidian instance for the given vault, launching it on first use and\n * reusing it on subsequent rebuilds.\n *\n * @param vaultPath - The absolute path to the vault folder to open.\n * @returns A {@link Promise} resolving to the owned {@link ObsidianTransport}.\n */\nasync function getOrLaunchDevInstance(vaultPath: string): Promise<ObsidianTransport> {\n  devInstanceTransportPromise ??= launchDevInstance(vaultPath);\n  try {\n    return await devInstanceTransportPromise;\n  } catch (e) {\n    // Clear the cache so a later rebuild retries the launch.\n    devInstanceTransportPromise = undefined;\n    throw e;\n  }\n}\n\n/**\n * Launches a fresh owned Obsidian instance (isolated user-data dir) and opens the given vault.\n *\n * @param vaultPath - The absolute path to the vault folder to open.\n * @returns A {@link Promise} resolving to the launched {@link ObsidianTransport}.\n */\nasync function launchDevInstance(vaultPath: string): Promise<ObsidianTransport> {\n  const transport = await createTransportFromOptions();\n  try {\n    await transport.registerVault(vaultPath);\n  } catch (e) {\n    transport.disposeSync?.();\n    throw e;\n  }\n  registerDevInstanceCleanup(transport);\n  return transport;\n}\n\n/**\n * Registers process-exit and signal handlers (once) that synchronously close the owned Obsidian\n * instance when the `npm run dev` process terminates.\n *\n * @param transport - The owned transport to dispose on shutdown.\n */\nfunction registerDevInstanceCleanup(transport: ObsidianTransport): void {\n  if (isDevInstanceCleanupRegistered) {\n    return;\n  }\n  isDevInstanceCleanupRegistered = true;\n\n  // `exit` covers any `process.exit()`, but a default Ctrl+C terminates WITHOUT firing `exit`, so the signal handlers guarantee the owned Obsidian is killed on shutdown.\n  process.on('exit', disposeDevInstance);\n  for (const signal of ['SIGHUP', 'SIGINT', 'SIGTERM'] as const) {\n    process.once(signal, () => {\n      disposeDevInstance();\n      process.exit();\n    });\n  }\n\n  function disposeDevInstance(): void {\n    if (isDevInstanceDisposed) {\n      return;\n    }\n    isDevInstanceDisposed = true;\n    transport.disposeSync?.();\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAcA,SAAS,kBAAkB;AAC3B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,OAAO,aAAa;AACpB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,sBAAsB;AAC/B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AA4CP,IAAI;AACJ,IAAI,iCAAiC;AACrC,IAAI,wBAAwB;AAQrB,SAAS,kCAAkC,QAAyD;AACzG,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AACJ,MAAI;AAAA,IACF;AAAA,EACF,IAAI;AACJ,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM,OAAa;AACjB,YAAM,MAAM,YAAY;AACtB,YAAI,mBAAmB;AACrB;AAAA,QACF;AAEA,YAAI,CAAC,sBAAsB;AACzB,yBAAe,mCAAmC;AAAA,YAChD;AAAA,UACF;AACA;AAAA,QACF;AAEA,+BAAuB,YAAY,oBAAoB;AAEvD,cAAM,eAAe,KAAK,sBAAsB,WAAW,UAAU;AAErE,YAAI,CAAC,WAAW,YAAY,GAAG;AAC7B,gBAAM,MAAM,cAAc,EAAE,WAAW,KAAK,CAAC;AAAA,QAC/C;AAEA,cAAM,GAAG,YAAY,cAAc,EAAE,WAAW,KAAK,CAAC;AAEtD,cAAM,kBAAkB,KAAK,sBAAsB,oBAAoB;AACvE,YAAI,CAAC,WAAW,eAAe,GAAG;AAChC,gBAAM,MAAM,iBAAiB,EAAE,WAAW,KAAK,CAAC;AAChD,gBAAM,mBAAmB;AACzB,qBAAW,YAAY,CAAC,WAAW,eAAe,GAAG;AACnD,kBAAM,UAAU,mBAAmB;AAEnC,kBAAM,WAAW,MAAM,MAAM,OAAO;AACpC,kBAAM,OAAO,MAAM,SAAS,KAAK;AACjC,kBAAM,UAAU,KAAK,iBAAiB,QAAQ,GAAG,IAAI;AAAA,UACvD;AAAA,QACF;AAEA,cAAM,sBAAsB;AAAA,UAC1B;AAAA,UACA,UAAU;AAAA,QACZ,CAAC;AACD,cAAM,sBAAsB;AAAA,UAC1B;AAAA,UACA,UAAU;AAAA,QACZ,CAAC;AAAA,MACH,CAAC;AAAA,IACH;AAAA,EACF;AACF;AAQA,eAAe,sBAAsB,QAAoD;AACvF,QAAM,EAAE,sBAAsB,SAAS,IAAI;AAC3C,QAAM,uBAAuB,KAAK,sBAAsB,wBAAwB;AAChF,MAAI,UAAoB,CAAC;AACzB,MAAI,WAAW,oBAAoB,GAAG;AACpC,UAAM,UAAU,MAAM,SAAS,sBAAsB,OAAO;AAC5D,cAAU,KAAK,MAAM,OAAO;AAAA,EAC9B;AAEA,MAAI,CAAC,QAAQ,SAAS,QAAQ,GAAG;AAC/B,YAAQ,KAAK,QAAQ;AACrB,UAAM,cAAc;AACpB,UAAM,UAAU,sBAAsB,KAAK,UAAU,SAAS,MAAM,WAAW,GAAG,OAAO;AAAA,EAC3F;AAEA,QAAM,YAAY,QAAQ,oBAAoB;AAG9C,MAAI;AACF,UAAM,YAAY,MAAM,uBAAuB,SAAS;AACxD,UAAM,eAAe;AAAA,MACnB,MAAM,EAAE,SAAS;AAAA;AAAA,MAEjB,MAAM,GAAG,EAAE,KAAK,UAAAA,UAAS,GAAG;AAC1B,cAAM,IAAI,QAAQ,oBAAoBA,SAAQ;AAAA,MAChD;AAAA,MACA,2BAA2B;AAAA,MAC3B;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH,SAAS,GAAY;AACnB,mBAAe,mCAAmC,EAAE,iCAAiC,QAAQ,iDAAiD,CAAC;AAAA,EACjJ;AACF;AASA,eAAe,uBAAuB,WAA+C;AACnF,kCAAgC,kBAAkB,SAAS;AAC3D,MAAI;AACF,WAAO,MAAM;AAAA,EACf,SAAS,GAAG;AAEV,kCAA8B;AAC9B,UAAM;AAAA,EACR;AACF;AAQA,eAAe,kBAAkB,WAA+C;AAC9E,QAAM,YAAY,MAAM,2BAA2B;AACnD,MAAI;AACF,UAAM,UAAU,cAAc,SAAS;AAAA,EACzC,SAAS,GAAG;AACV,cAAU,cAAc;AACxB,UAAM;AAAA,EACR;AACA,6BAA2B,SAAS;AACpC,SAAO;AACT;AAQA,SAAS,2BAA2B,WAAoC;AACtE,MAAI,gCAAgC;AAClC;AAAA,EACF;AACA,mCAAiC;AAGjC,UAAQ,GAAG,QAAQ,kBAAkB;AACrC,aAAW,UAAU,CAAC,UAAU,UAAU,SAAS,GAAY;AAC7D,YAAQ,KAAK,QAAQ,MAAM;AACzB,yBAAmB;AACnB,cAAQ,KAAK;AAAA,IACf,CAAC;AAAA,EACH;AAEA,WAAS,qBAA2B;AAClC,QAAI,uBAAuB;AACzB;AAAA,IACF;AACA,4BAAwB;AACxB,cAAU,cAAc;AAAA,EAC1B;AACF;",
  "names": ["pluginId"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../../src/script-utils/bundlers/esbuild-impl/copy-to-obsidian-plugins-folder-plugin.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module defines an esbuild plugin that automatically copies the build output\n * to the Obsidian plugins folder during development. This plugin helps streamline\n * the development workflow by ensuring that the latest build is always available\n * in the correct Obsidian folder for testing and use.\n */\n\n/* v8 ignore start -- esbuild plugin that copies build output to Obsidian plugins folder; requires a live esbuild context. */\n\nimport type { Plugin } from 'esbuild';\nimport type { PluginManifest } from 'obsidian';\nimport type { ObsidianTransport } from 'obsidian-integration-testing';\n\nimport {\n  cp,\n  mkdir\n} from 'node:fs/promises';\nimport process from 'node:process';\nimport {\n  createTransportFromOptions,\n  evalInObsidian\n} from 'obsidian-integration-testing';\n\nimport { getLibDebugger } from '../../../debug.ts';\nimport {\n  dirname,\n  join,\n  toPosixPath\n} from '../../../path.ts';\n\n/**\n * Parameters for {@link copyToObsidianPluginsFolderPlugin}.\n */\nexport interface CopyToObsidianPluginsFolderPluginParams {\n  /**\n   * The folder where the built files are located.\n   */\n  readonly distFolder: string;\n\n  /**\n   * A boolean indicating whether the build is a production build.\n   */\n  readonly isProductionBuild: boolean;\n\n  /**\n   * The folder of the Obsidian configuration. If not provided, the plugin will not copy files.\n   */\n  readonly obsidianConfigFolder: string;\n\n  /**\n   * The name of the Obsidian plugin.\n   */\n  readonly pluginName: string;\n}\n\n/**\n * A single entry in Obsidian's community plugins registry (`community-plugins.json`).\n */\ninterface CommunityPluginRegistryEntry {\n  /**\n   * The plugin id.\n   */\n  readonly id: string;\n\n  /**\n   * The `owner/name` GitHub repository the plugin is published from.\n   */\n  readonly repo: string;\n}\n\n/**\n * The subset of a GitHub release we read.\n */\ninterface GitHubRelease {\n  /**\n   * The release tag, a bare version such as `1.2.3`.\n   */\n  readonly tag_name: string;\n}\n\n/**\n * Parameters for {@link installAndEnableHotReload}.\n */\ninterface InstallAndEnableHotReloadParams {\n  /**\n   * The folder of the Obsidian configuration.\n   */\n  readonly obsidianConfigFolder: string;\n\n  /**\n   * The name of the built Obsidian plugin to enable once HotReload is in place.\n   */\n  readonly pluginName: string;\n}\n\n// The `npm run dev`-owned Obsidian instance: launched on the first rebuild and reused across rebuilds.\n// It is closed when the `npm run dev` process terminates (see `registerDevInstanceCleanup`).\nlet devInstanceTransportPromise: Promise<ObsidianTransport> | undefined;\nlet isDevInstanceCleanupRegistered = false;\nlet isDevInstanceDisposed = false;\n\n/**\n * Creates an esbuild plugin that copies the build output to the Obsidian plugins folder.\n *\n * @param params - The parameters for the function.\n * @returns An esbuild `Plugin` object.\n */\nexport function copyToObsidianPluginsFolderPlugin(params: CopyToObsidianPluginsFolderPluginParams): Plugin {\n  const {\n    distFolder,\n    isProductionBuild,\n    pluginName\n  } = params;\n  let {\n    obsidianConfigFolder\n  } = params;\n  return {\n    name: 'copy-to-obsidian-plugins-folder',\n    setup(build): void {\n      build.onEnd(async () => {\n        if (isProductionBuild) {\n          return;\n        }\n\n        if (!obsidianConfigFolder) {\n          getLibDebugger('copyToObsidianPluginsFolderPlugin')(\n            'No Obsidian config folder configured. `OBSIDIAN_CONFIG_FOLDER` environment variable is not set in system or in `.env` file. The compiled plugin will not be copied into Obsidian plugins folder.'\n          );\n          return;\n        }\n\n        obsidianConfigFolder = toPosixPath(obsidianConfigFolder);\n\n        const pluginFolder = join(obsidianConfigFolder, 'plugins', pluginName);\n        await mkdir(pluginFolder, { recursive: true });\n        await cp(distFolder, pluginFolder, { recursive: true });\n\n        await installAndEnableHotReload({\n          obsidianConfigFolder,\n          pluginName\n        });\n      });\n    }\n  };\n}\n\n/**\n * Returns the `npm run dev`-owned Obsidian instance for the given vault, launching it on first use and\n * reusing it on subsequent rebuilds.\n *\n * @param vaultPath - The absolute path to the vault folder to open.\n * @returns A {@link Promise} resolving to the owned {@link ObsidianTransport}.\n */\nasync function getOrLaunchDevInstance(vaultPath: string): Promise<ObsidianTransport> {\n  devInstanceTransportPromise ??= launchDevInstance(vaultPath);\n  try {\n    return await devInstanceTransportPromise;\n  } catch (e) {\n    // Clear the cache so a later rebuild retries the launch.\n    devInstanceTransportPromise = undefined;\n    throw e;\n  }\n}\n\n/**\n * Installs the HotReload plugin from the official community store (if not already installed), enables it\n * (if not already enabled), and enables the freshly-built plugin \u2014 all through the `npm run dev`-owned\n * Obsidian instance, so HotReload then auto-refreshes the deployed plugin on every rebuild.\n *\n * The install goes through Obsidian's own `installPlugin` (the community-store mechanism), and every step\n * runs against the owned instance over CDP; any failure surfaces (the dev build reports it) rather than\n * being silently swallowed.\n *\n * The install-if-missing / enable-if-disabled logic below intentionally mirrors the public\n * `installCommunityPlugin` / `enableCommunityPlugin` helpers in `src/obsidian/community-plugins.ts`. It\n * cannot import and call them: the `fn` is serialized (`toString()`) and executed in the renderer, and\n * this build-owned Obsidian instance is bare \u2014 it has no dev-utils `lib` provider wired (that resolver is\n * registered only in the integration-test setup, whose fixture publishes the merged surface on `window`),\n * so the closure has no access to the library surface and must inline the equivalent steps.\n *\n * @param params - The {@link InstallAndEnableHotReloadParams}.\n * @returns A {@link Promise} that resolves once HotReload and the built plugin are installed and enabled.\n */\nasync function installAndEnableHotReload(params: InstallAndEnableHotReloadParams): Promise<void> {\n  const {\n    obsidianConfigFolder,\n    pluginName\n  } = params;\n  const vaultPath = dirname(obsidianConfigFolder);\n  const transport = await getOrLaunchDevInstance(vaultPath);\n  await evalInObsidian({\n    args: { pluginName },\n    // eslint-disable-next-line no-shadow -- No actual shadowing as the function is executed externally.\n    async fn({ app, obsidianModule, pluginName }) {\n      const HOT_RELOAD_PLUGIN_ID = 'hot-reload';\n      const COMMUNITY_PLUGINS_REGISTRY_URL = 'https://raw.githubusercontent.com/obsidianmd/obsidian-releases/HEAD/community-plugins.json';\n      const { requestUrl } = obsidianModule;\n\n      if (!app.plugins.manifests[HOT_RELOAD_PLUGIN_ID]) {\n        const registryEntries = (await requestUrl(COMMUNITY_PLUGINS_REGISTRY_URL)).json as CommunityPluginRegistryEntry[];\n        const entry = registryEntries.find((candidate) => candidate.id === HOT_RELOAD_PLUGIN_ID);\n        if (!entry) {\n          throw new Error(`Plugin '${HOT_RELOAD_PLUGIN_ID}' was not found in the Obsidian community plugins registry.`);\n        }\n\n        const latestRelease = (await requestUrl(`https://api.github.com/repos/${entry.repo}/releases/latest`)).json as GitHubRelease;\n        const version = latestRelease.tag_name;\n        const manifest = (await requestUrl(`https://github.com/${entry.repo}/releases/download/${version}/manifest.json`)).json as PluginManifest;\n        await app.plugins.installPlugin(entry.repo, version, manifest);\n      }\n\n      if (!app.plugins.enabledPlugins.has(HOT_RELOAD_PLUGIN_ID)) {\n        await app.plugins.enablePluginAndSave(HOT_RELOAD_PLUGIN_ID);\n      }\n\n      await app.plugins.enablePluginAndSave(pluginName);\n    },\n    shouldSkipPreflightChecks: true,\n    transport,\n    vaultPath\n  });\n}\n\n/**\n * Launches a fresh owned Obsidian instance (isolated user-data dir) and opens the given vault.\n *\n * @param vaultPath - The absolute path to the vault folder to open.\n * @returns A {@link Promise} resolving to the launched {@link ObsidianTransport}.\n */\nasync function launchDevInstance(vaultPath: string): Promise<ObsidianTransport> {\n  const transport = await createTransportFromOptions();\n  try {\n    await transport.registerVault(vaultPath);\n  } catch (e) {\n    transport.disposeSync?.();\n    throw e;\n  }\n  registerDevInstanceCleanup(transport);\n  return transport;\n}\n\n/**\n * Registers process-exit and signal handlers (once) that synchronously close the owned Obsidian\n * instance when the `npm run dev` process terminates.\n *\n * @param transport - The owned transport to dispose on shutdown.\n */\nfunction registerDevInstanceCleanup(transport: ObsidianTransport): void {\n  if (isDevInstanceCleanupRegistered) {\n    return;\n  }\n  isDevInstanceCleanupRegistered = true;\n\n  // `exit` covers any `process.exit()`, but a default Ctrl+C terminates WITHOUT firing `exit`, so the signal handlers guarantee the owned Obsidian is killed on shutdown.\n  process.on('exit', disposeDevInstance);\n  for (const signal of ['SIGHUP', 'SIGINT', 'SIGTERM'] as const) {\n    process.once(signal, () => {\n      disposeDevInstance();\n      process.exit();\n    });\n  }\n\n  function disposeDevInstance(): void {\n    if (isDevInstanceDisposed) {\n      return;\n    }\n    isDevInstanceDisposed = true;\n    transport.disposeSync?.();\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["pluginName"]
}


package/dist/lib/esm/script-utils/linters/eslint-no-restricted-syntax.mjs

@@ -26,10 +26,6 @@ const noRestrictedSyntaxRuleEntries = [
     message: "Do not use definite assignment assertions (!). Initialize the field or make it optional.",
     selector: "PropertyDefinition[definite=true]"
   },
-  {
-    message: "Do not use definite assignment assertions (!) on abstract fields.",
-    selector: "TSAbstractPropertyDefinition[definite=true]"
-  },
   {
     message: "Do not use anonymous inline object types. Define a named interface or `type` alias instead.",
     selector: "TSTypeLiteral:not(TSTypeAliasDeclaration > TSTypeLiteral)"
@@ -70,4 +66,4 @@ const noRestrictedSyntaxRuleEntries = [
 export {
   noRestrictedSyntaxRuleEntries
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -4,6 +4,7 @@
  *
  * Type utilities.
  */
+import type { GenericFunction } from './function.mjs';
 /**
  * A type that represents the keys of an object as strings and asserts that all keys are present in a list of keys.
  *
@@ -18,6 +19,22 @@ export type ExactKeys<Type extends object, Keys extends readonly string[]> = Exa
  * @typeParam Keys - The list of members to assert.
  */
 export type ExactMembers<Type extends LiteralKey, Keys extends readonly LiteralKey[]> = Exclude<Keys[number], Type> extends never ? Exclude<Type, Keys[number]> extends never ? Duplicates<Keys> extends [] ? Keys : `ERROR: Duplicate members: ${TupleToCSV<Duplicates<Keys>>}` : `ERROR: Missing members: ${TupleToCSV<UnionToTuple<Exclude<Type, Keys[number]>>>}` : `ERROR: Invalid members: ${TupleToCSV<UnionToTuple<Exclude<Keys[number], Type>>>}`;
+/**
+ * Derives an event map (`{ eventName: [callbackArgs] }`) from a type exposing an overloaded `on(name, callback)`
+ * method — e.g. Obsidian's `Workspace` / `Vault` / `MetadataCache`. Each `on` overload becomes one entry keyed by
+ * the event name, with the callback's parameters as a labeled tuple; the wide `on(name: string, …)` catch-all
+ * overload is dropped. The map auto-tracks upstream overloads (no hand-authoring). It cannot reconstruct
+ * genuinely generic overloads, but Obsidian's event overloads are all concrete string-literal ones.
+ *
+ * @typeParam T - A type exposing an `on(name, callback, …)` method (e.g. an Obsidian `Events` subclass).
+ *
+ * @example
+ * ```ts
+ * type WorkspaceEventMap = ExtractEventMap<Workspace>;
+ * // { 'file-menu': [menu: Menu, file: TAbstractFile, source: string, leaf?: WorkspaceLeaf]; … }
+ * ```
+ */
+export type ExtractEventMap<T extends EventsWithOn> = UnionToIntersection<EntryOfOverload<OverloadUnion<T['on']>>>;
 /**
  * A type that represents a return value that may be `void`.
  *
@@ -36,6 +53,31 @@ export type PropertyValues<T extends object> = T[StringKeys<T>];
  * @typeParam T - The type of the object.
  */
 export type StringKeys<T extends object> = Extract<keyof T, string>;
+type Duplicates<T extends readonly unknown[], Seen extends readonly unknown[] = [], Added extends readonly unknown[] = [], Out extends readonly unknown[] = []> = T extends readonly [infer First, ...infer Rest] ? Includes<Seen, First> extends true ? Includes<Added, First> extends true ? Duplicates<Rest, Seen, Added, Out> : Duplicates<Rest, Seen, [...Added, First], [...Out, First]> : Duplicates<Rest, [...Seen, First], Added, Out> : Out;
+type EntryOfOverload<TOverload> = TOverload extends (name: infer Name, callback: (...args: infer Args) => unknown, ...rest: never[]) => unknown ? Name extends string ? string extends Name ? never : Record<Name, Args> : never : never;
+type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+interface EventsWithOn {
+    on: GenericFunction;
+}
+type Includes<Type extends readonly unknown[], Member> = Type extends readonly [infer First, ...infer Rest] ? Equal<First, Member> extends true ? true : Includes<Rest, Member> : false;
+type LastInUnion<Union> = UnionToIntersection<Union extends unknown ? () => Union : never> extends () => infer Last ? Last : never;
+type LiteralKey = number | string;
+type OverloadUnion<TOverload extends GenericFunction> = Exclude<OverloadUnionRecursive<(() => never) & TOverload>, TOverload extends () => never ? never : () => never>;
+type OverloadUnionRecursive<TOverload, TPartialOverload = unknown> = TOverload extends (...args: infer Args) => infer Return ? TPartialOverload extends TOverload ? never : OverloadUnionRecursive<TPartialOverload & TOverload, TPartialOverload & ((...args: Args) => Return) & Pick<TOverload, keyof TOverload>> | ((...args: Args) => Return) : never;
+type ToString<T> = T extends number | string ? `${T}` : never;
+type TupleToCSV<Tuple extends readonly unknown[]> = Tuple extends readonly [infer First, ...infer Rest] ? First extends LiteralKey ? Rest extends readonly unknown[] ? Rest['length'] extends 0 ? ToString<First> : `${ToString<First>},${TupleToCSV<Rest>}` : never : never : '';
+/**
+ * Internal method shapes for {@link TypeAsserter}: a conditional type disables each method when the
+ * captured type does not support it.
+ *
+ * @typeParam Type - The captured type.
+ */
+interface TypeAssertions<Type> {
+    assertAllKeys: [Type] extends [object] ? <const Keys extends readonly string[]>(keys: ExactMembers<StringKeys<Type>, Keys>) => readonly (keyof Type)[] : never;
+    assertAllMembers: [Type] extends [LiteralKey] ? <const Keys extends readonly LiteralKey[]>(keys: ExactMembers<Type, Keys>) => readonly Type[] : never;
+}
+type UnionToIntersection<Union> = (Union extends unknown ? (key: Union) => void : never) extends (key: infer Intersection) => void ? Intersection : never;
+type UnionToTuple<Union, Last = LastInUnion<Union>> = [Union] extends [never] ? [] : [...UnionToTuple<Exclude<Union, Last>>, Last];
 /**
  * A helper that captures a type parameter and provides methods for compile-time exhaustiveness checks.
  *
@@ -48,55 +90,33 @@ export type StringKeys<T extends object> = Extract<keyof T, string>;
  * @example
  * ```ts
  * type A = { a: 1, b: 2, c: 3 };
- * typeAsserter<A>().assertAllKeys(['a', 'b', 'c']); // OK
- * typeAsserter<A>().assertAllKeys(['c', 'a', 'b']); // OK, order is ignored
- * typeAsserter<A>().assertAllKeys(['a', 'b', 'c', 'd']); // Error: Invalid members: d
- * typeAsserter<A>().assertAllKeys(['a', 'b']); // Error: Missing members: c
+ * new TypeAsserter<A>().assertAllKeys(['a', 'b', 'c']); // OK
+ * new TypeAsserter<A>().assertAllKeys(['c', 'a', 'b']); // OK, order is ignored
+ * new TypeAsserter<A>().assertAllKeys(['a', 'b', 'c', 'd']); // Error: Invalid members: d
+ * new TypeAsserter<A>().assertAllKeys(['a', 'b']); // Error: Missing members: c
  *
  * type B = 1 | 2 | 3 | 'a';
- * typeAsserter<B>().assertAllMembers([1, 2, 3, 'a']); // OK
- * typeAsserter<B>().assertAllMembers([1, 2, 3, 'a', 4]); // Error: Invalid members: 4
- * typeAsserter<B>().assertAllMembers([1, 2, 3]); // Error: Missing members: a
+ * new TypeAsserter<B>().assertAllMembers([1, 2, 3, 'a']); // OK
+ * new TypeAsserter<B>().assertAllMembers([1, 2, 3, 'a', 4]); // Error: Invalid members: 4
+ * new TypeAsserter<B>().assertAllMembers([1, 2, 3]); // Error: Missing members: a
  * ```
  */
-export interface TypeAsserter<Type> {
+export declare class TypeAsserter<Type> {
     /**
      * Asserts that all keys of an object type are present in a list of keys.
      *
      * @remarks Only available when `[Type] extends [object]`.
      */
-    assertAllKeys: [Type] extends [object] ? <const Keys extends readonly string[]>(keys: ExactMembers<StringKeys<Type>, Keys>) => readonly (keyof Type)[] : never;
+    readonly assertAllKeys: TypeAssertions<Type>['assertAllKeys'];
     /**
      * Asserts that all members of a union type are present in a list of members.
      *
      * @remarks Only available when `[Type] extends [LiteralKey]`.
      */
-    assertAllMembers: [Type] extends [LiteralKey] ? <const Keys extends readonly LiteralKey[]>(keys: ExactMembers<Type, Keys>) => readonly Type[] : never;
+    readonly assertAllMembers: TypeAssertions<Type>['assertAllMembers'];
+    /**
+     * Creates a type asserter that captures {@link Type} for compile-time exhaustiveness checks.
+     */
+    constructor();
 }
-type Duplicates<T extends readonly unknown[], Seen extends readonly unknown[] = [], Added extends readonly unknown[] = [], Out extends readonly unknown[] = []> = T extends readonly [infer First, ...infer Rest] ? Includes<Seen, First> extends true ? Includes<Added, First> extends true ? Duplicates<Rest, Seen, Added, Out> : Duplicates<Rest, Seen, [...Added, First], [...Out, First]> : Duplicates<Rest, [...Seen, First], Added, Out> : Out;
-type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
-type Includes<Type extends readonly unknown[], Member> = Type extends readonly [infer First, ...infer Rest] ? Equal<First, Member> extends true ? true : Includes<Rest, Member> : false;
-type LastInUnion<Union> = UnionToIntersection<Union extends unknown ? () => Union : never> extends () => infer Last ? Last : never;
-type LiteralKey = number | string;
-type ToString<T> = T extends number | string ? `${T}` : never;
-type TupleToCSV<Tuple extends readonly unknown[]> = Tuple extends readonly [infer First, ...infer Rest] ? First extends LiteralKey ? Rest extends readonly unknown[] ? Rest['length'] extends 0 ? ToString<First> : `${ToString<First>},${TupleToCSV<Rest>}` : never : never : '';
-type UnionToIntersection<Union> = (Union extends unknown ? (key: Union) => void : never) extends (key: infer Intersection) => void ? Intersection : never;
-type UnionToTuple<Union, Last = LastInUnion<Union>> = [Union] extends [never] ? [] : [...UnionToTuple<Exclude<Union, Last>>, Last];
-/**
- * Creates a type helper that captures a type parameter for compile-time exhaustiveness checks.
- *
- * @typeParam Type - The type to capture.
- * @returns A {@link TypeAsserter} with `assertAllKeys` and `assertAllMembers` methods.
- *
- * @example
- * ```ts
- * type A = { a: 1, b: 2, c: 3 };
- * typeAsserter<A>().assertAllKeys(['a', 'b', 'c']); // OK
- * typeAsserter<A>().assertAllKeys(['c', 'a', 'b']); // OK, order is ignored
- *
- * type B = 1 | 2 | 3 | 'a';
- * typeAsserter<B>().assertAllMembers([1, 2, 3, 'a']); // OK
- * ```
- */
-export declare function typeAsserter<Type>(): TypeAsserter<Type>;
 export {};