@mnaoumov/obsidian-dev-toolkit 2.1.0 → 3.0.0

package/dist/lib/cjs/bundlers/obsidian-plugin-webpack-loader.cjs

@@ -0,0 +1,182 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureBrowserProcess();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/highlight',
+  '@lezer/lr',
+  'obsidian']
+  );
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip']
+  );
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var obsidian_plugin_webpack_loader_exports = {};
+__export(obsidian_plugin_webpack_loader_exports, {
+  default: () => obsidianPluginWebpackLoader,
+  raw: () => raw
+});
+module.exports = __toCommonJS(obsidian_plugin_webpack_loader_exports);
+var import_async = require('@mnaoumov/typescript-lib/async');
+var import_esbuild = require('esbuild');
+var import_obsidian_plugin_transforms = require('./obsidian-plugin-transforms.cjs');
+const raw = true;
+function obsidianPluginWebpackLoader(source) {
+  const callback = this.async();
+  (0, import_async.invokeAsyncSafely)(async () => {
+    let result;
+    try {
+      result = await transformModule(this, source);
+    } catch (error) {
+      callback(error);
+      return;
+    }
+    callback(null, result.code, result.map && JSON.stringify(result.map));
+  });
+}
+async function transformModule(context, source) {
+  const { isProductionBuild, kind, styles } = context.getOptions();
+  const filePath = context.resourcePath;
+  const code = source.toString("utf-8");
+  switch (kind) {
+    case "jsx": {
+      return await (0, import_obsidian_plugin_transforms.transformSolid)({ code, filePath, isProductionBuild });
+    }
+    case "stylesheet": {
+      const result = await (0, import_obsidian_plugin_transforms.transformCss)({ filePath, isCssModuleScoped: false, isProductionBuild, source: code, styles: styles ?? {} });
+      for (const dependency of result.dependencies) {
+        context.addDependency(dependency);
+      }
+      return { code: result.css };
+    }
+    case "svelte": {
+      return await (0, import_obsidian_plugin_transforms.transformSvelte)({ code, filePath, isProductionBuild });
+    }
+    case "typescript": {
+      const result = await (0, import_esbuild.transform)(code, { loader: "ts", sourcefile: filePath, sourcemap: "external" });
+      return { code: result.code, map: JSON.parse(result.map) };
+    }
+    case "wasm": {
+      return { code: (0, import_obsidian_plugin_transforms.getWasmModuleCode)(source) };
+    }
+    default: {
+      throw new Error(`Unknown loader kind: ${String(kind)}`);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  raw
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/bundlers/obsidian-plugin-webpack-loader.d.cts

@@ -0,0 +1,47 @@
+/// <reference path="../library-references.d.cts" />
+/// <reference types="node" />
+/**
+ * @file
+ *
+ * The webpack loader the webpack adapter adds for the build features: it runs one of the shared transforms (Solid,
+ * Svelte, a stylesheet's PostCSS and Tailwind, a WebAssembly module's bytes) on the module it is given. The adapter
+ * names it by path in the rules it adds, so a project never names it.
+ *
+ * Erasable TypeScript only (no enums, no parameter properties), so webpack can load it straight from source when the
+ * toolkit runs from source.
+ */
+import type { LoaderContext } from 'webpack' with { 'resolution-mode': 'import' };
+import type { FeatureFileKind, ObsidianPluginStylesOptions } from './obsidian-plugin-features.cjs';
+/**
+ * Which transform the loader runs: one of the shared transforms, or `typescript`, which strips the types of a Vue
+ * component's `<script lang="ts">` block after `unplugin-vue` extracted it.
+ */
+export type ObsidianPluginWebpackLoaderKind = 'typescript' | FeatureFileKind;
+/**
+ * The options the webpack adapter gives the loader.
+ */
+export interface ObsidianPluginWebpackLoaderOptions {
+    /**
+     * Whether this is a production build.
+     */
+    readonly isProductionBuild: boolean;
+    /**
+     * Which transform the loader runs.
+     */
+    readonly kind: ObsidianPluginWebpackLoaderKind;
+    /**
+     * The stylesheet options, for a `stylesheet` loader.
+     */
+    readonly styles?: ObsidianPluginStylesOptions;
+}
+/**
+ * Tells webpack to hand the loader the module's bytes, which a WebAssembly module needs.
+ */
+export declare const raw = true;
+/**
+ * Runs the shared transform the loader's options name on one module.
+ *
+ * @param this - The webpack loader context.
+ * @param source - The module's bytes.
+ */
+export default function obsidianPluginWebpackLoader(this: LoaderContext<ObsidianPluginWebpackLoaderOptions>, source: Buffer): void;

package/dist/lib/cjs/bundlers/obsidian-plugins-folder-deployment.cjs

@@ -0,0 +1,320 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureBrowserProcess();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/highlight',
+  '@lezer/lr',
+  'obsidian']
+  );
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip']
+  );
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var obsidian_plugins_folder_deployment_exports = {};
+__export(obsidian_plugins_folder_deployment_exports, {
+  deployToObsidianPluginsFolder: () => deployToObsidianPluginsFolder
+});
+module.exports = __toCommonJS(obsidian_plugins_folder_deployment_exports);
+var import_async = require('@mnaoumov/typescript-lib/async');
+var import_debug = require('@mnaoumov/typescript-lib/debug');
+var import_path = require('@mnaoumov/typescript-lib/path');
+var import_promises = require('node:fs/promises');
+var import_node_process = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('node:process')), 1);
+var import_obsidian_integration_testing = require('obsidian-integration-testing');
+var import_obsidian_cli_reload = require('./obsidian-cli-reload.cjs');
+const moduleState = {
+  devInstanceTransportPromise: void 0,
+  isDevInstanceCleanupRegistered: false,
+  isDevInstanceDisposed: false
+};
+const DEV_INSTANCE_PROBE_INTERVAL_IN_MILLISECONDS = 2e3;
+const DEV_INSTANCE_CLOSED_PROBE_COUNT = 3;
+async function deployToObsidianPluginsFolder(params) {
+  const {
+    distFolder,
+    isProductionBuild,
+    pluginName
+  } = params;
+  if (isProductionBuild) {
+    return;
+  }
+  if (!params.obsidianConfigFolder) {
+    (0, import_debug.getLibDebugger)("deployToObsidianPluginsFolder")(
+      "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."
+    );
+    return;
+  }
+  const obsidianConfigFolder = (0, import_path.toPosixPath)(params.obsidianConfigFolder);
+  const pluginFolder = (0, import_path.join)(obsidianConfigFolder, "plugins", pluginName);
+  await (0, import_promises.mkdir)(pluginFolder, { recursive: true });
+  await (0, import_promises.cp)(distFolder, pluginFolder, { recursive: true });
+  switch (params.reload ?? "hot-reload-plugin") {
+    case false: {
+      break;
+    }
+    case "hot-reload-plugin": {
+      await installAndEnableHotReload({
+        obsidianConfigFolder,
+        pluginName
+      });
+      break;
+    }
+    case "obsidian-cli": {
+      await (0, import_obsidian_cli_reload.reloadPluginWithObsidianCli)({
+        pluginId: await readPluginId(pluginFolder, pluginName),
+        vaultName: (0, import_path.basename)((0, import_path.dirname)(obsidianConfigFolder))
+      });
+      break;
+    }
+    default: {
+      throw new Error(`Unknown reload option: ${String(params.reload)}`);
+    }
+  }
+}
+async function getOrLaunchDevInstance(vaultPath) {
+  moduleState.devInstanceTransportPromise ??= launchDevInstance(vaultPath);
+  try {
+    return await moduleState.devInstanceTransportPromise;
+  } catch (error) {
+    moduleState.devInstanceTransportPromise = void 0;
+    throw error;
+  }
+}
+async function installAndEnableHotReload(params) {
+  const {
+    obsidianConfigFolder,
+    pluginName
+  } = params;
+  const vaultPath = (0, import_path.dirname)(obsidianConfigFolder);
+  const transport = await getOrLaunchDevInstance(vaultPath);
+  await (0, import_obsidian_integration_testing.evalInObsidian)({
+    // eslint-disable-next-line no-shadow -- No actual shadowing as the function is executed externally.
+    async callback({ 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;
+      await app.plugins.setEnable(true);
+      if (!Object.hasOwn(app.plugins.manifests, HOT_RELOAD_PLUGIN_ID)) {
+        const registryResponse = await requestUrl(COMMUNITY_PLUGINS_REGISTRY_URL);
+        const registryEntries = registryResponse.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 latestReleaseResponse = await requestUrl(`https://api.github.com/repos/${entry.repo}/releases/latest`);
+        const latestRelease = latestReleaseResponse.json;
+        const version = latestRelease.tag_name;
+        const manifestResponse = await requestUrl(`https://github.com/${entry.repo}/releases/download/${version}/manifest.json`);
+        const manifest = manifestResponse.json;
+        await app.plugins.installPlugin(entry.repo, version, manifest);
+      }
+      if (!Object.hasOwn(app.plugins.plugins, HOT_RELOAD_PLUGIN_ID)) {
+        await app.plugins.enablePluginAndSave(HOT_RELOAD_PLUGIN_ID);
+      }
+      await app.plugins.enablePluginAndSave(pluginName2);
+    },
+    input: { pluginName },
+    shouldSkipPreflightChecks: true,
+    transport,
+    vaultPath
+  });
+}
+async function isDevInstanceRunning(cdpUrl) {
+  try {
+    const response = await fetch(`${cdpUrl}/json`);
+    const targets = await response.json();
+    return targets.some((target) => target.type === "page");
+  } catch {
+    return false;
+  }
+}
+async function launchDevInstance(vaultPath) {
+  const transport = await (0, import_obsidian_integration_testing.createTransportFromOptions)();
+  try {
+    await transport.registerVault(vaultPath);
+  } catch (error) {
+    transport.disposeSync?.();
+    throw error;
+  }
+  registerDevInstanceCleanup(transport);
+  watchDevInstanceAndStopOnClose(transport);
+  return transport;
+}
+async function readPluginId(pluginFolder, fallbackId) {
+  try {
+    const manifest = JSON.parse(await (0, import_promises.readFile)((0, import_path.join)(pluginFolder, "manifest.json"), "utf-8"));
+    return manifest.id ?? fallbackId;
+  } catch {
+    return fallbackId;
+  }
+}
+function registerDevInstanceCleanup(transport) {
+  if (moduleState.isDevInstanceCleanupRegistered) {
+    return;
+  }
+  moduleState.isDevInstanceCleanupRegistered = true;
+  import_node_process.default.on("exit", disposeDevInstance);
+  for (const signal of ["SIGHUP", "SIGINT", "SIGTERM"]) {
+    import_node_process.default.once(signal, () => {
+      disposeDevInstance();
+      import_node_process.default.exit();
+    });
+  }
+  function disposeDevInstance() {
+    if (moduleState.isDevInstanceDisposed) {
+      return;
+    }
+    moduleState.isDevInstanceDisposed = true;
+    transport.disposeSync?.();
+  }
+}
+function watchDevInstanceAndStopOnClose(transport) {
+  if (!(transport instanceof import_obsidian_integration_testing.DesktopCdpTransport)) {
+    return;
+  }
+  const endpoint = transport.getOwnedInstanceEndpoint();
+  if (!endpoint) {
+    return;
+  }
+  const cdpUrl = `http://${endpoint.host}:${String(endpoint.port)}`;
+  (0, import_async.invokeAsyncSafely)(stopWhenDevInstanceCloses);
+  async function stopWhenDevInstanceCloses() {
+    let consecutiveFailedProbeCount = 0;
+    while (consecutiveFailedProbeCount < DEV_INSTANCE_CLOSED_PROBE_COUNT) {
+      await (0, import_async.sleep)({ milliseconds: DEV_INSTANCE_PROBE_INTERVAL_IN_MILLISECONDS });
+      if (moduleState.isDevInstanceDisposed) {
+        return;
+      }
+      consecutiveFailedProbeCount = await isDevInstanceRunning(cdpUrl) ? 0 : consecutiveFailedProbeCount + 1;
+    }
+    console.warn("The Obsidian instance owned by `npm run dev` was closed. Stopping the development build.");
+    import_node_process.default.exit();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deployToObsidianPluginsFolder
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/bundlers/obsidian-plugins-folder-deployment.ts"],"sourcesContent":["/**\n * @file\n *\n * Deploys a development build into the vault: copies the output folder into `<vault>/.obsidian/plugins`,\n * then reloads it the way the build's `reload` option says. By default that installs and enables HotReload\n * and the plugin in an Obsidian instance `npm run dev` owns; `'obsidian-cli'` reloads it in the Obsidian the\n * developer has open instead (`obsidian-cli-reload.ts`). Every bundler adapter calls it once each rebuild has\n * written its output, so the latest build is always the one running.\n */\n\n/* v8 ignore start -- Copies build output into a vault and drives a live Obsidian over CDP. */\n\nimport type { PluginManifest } from 'obsidian';\nimport type { ObsidianTransport } from 'obsidian-integration-testing';\n\nimport {\n  invokeAsyncSafely,\n  sleep\n} from '@mnaoumov/typescript-lib/async';\nimport { getLibDebugger } from '@mnaoumov/typescript-lib/debug';\nimport {\n  basename,\n  dirname,\n  join,\n  toPosixPath\n} from '@mnaoumov/typescript-lib/path';\nimport {\n  cp,\n  mkdir,\n  readFile\n} from 'node:fs/promises';\nimport process from 'node:process';\nimport {\n  createTransportFromOptions,\n  DesktopCdpTransport,\n  evalInObsidian\n} from 'obsidian-integration-testing';\n\nimport type { ObsidianPluginReload } from './obsidian-plugin-build.ts';\n\nimport { reloadPluginWithObsidianCli } from './obsidian-cli-reload.ts';\n\n/**\n * Parameters for {@link deployToObsidianPluginsFolder}.\n */\nexport interface DeployToObsidianPluginsFolderParams {\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   * How the deployed build is reloaded in Obsidian. Defaults to `'hot-reload-plugin'`.\n   */\n  readonly reload?: ObsidianPluginReload;\n}\n\n/**\n * The subset of a CDP target descriptor read from the owned instance's `/json` endpoint.\n */\ninterface CdpTarget {\n  /**\n   * The kind of the target, e.g. `page`.\n   */\n  readonly type: 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// Its lifetime is tied to the `npm run dev` process in BOTH directions.\n// The instance is closed when the process terminates (see `registerDevInstanceCleanup`).\n// The process stops when the instance is closed (see `watchDevInstanceAndStopOnClose`).\n/**\nModule-level mutable state, held in one object so each mutation names it explicitly.\n */\ninterface ModuleState {\n  devInstanceTransportPromise: Promise<ObsidianTransport> | undefined;\n  isDevInstanceCleanupRegistered: boolean;\n  isDevInstanceDisposed: boolean;\n}\n\nconst moduleState: ModuleState = {\n  devInstanceTransportPromise: undefined,\n  isDevInstanceCleanupRegistered: false,\n  isDevInstanceDisposed: false\n};\n\n/**\n * How often the owned Obsidian instance is probed to detect that it was closed.\n */\nconst DEV_INSTANCE_PROBE_INTERVAL_IN_MILLISECONDS = 2000;\n\n/**\n * How many consecutive failed probes are tolerated before the owned instance is considered closed. A\n * single failure can be a transient hiccup (a busy renderer, a momentarily refused connection), so the\n * development build is only stopped once the endpoint stays unreachable.\n */\nconst DEV_INSTANCE_CLOSED_PROBE_COUNT = 3;\n/**\n * Copies a development build into the vault's plugins folder and reloads it there, as the `reload` option\n * says. Does nothing for a production build, or when no Obsidian config folder is configured.\n *\n * @param params - The {@link DeployToObsidianPluginsFolderParams}.\n * @returns A {@link Promise} that resolves once the plugin is deployed.\n */\nexport async function deployToObsidianPluginsFolder(params: DeployToObsidianPluginsFolderParams): Promise<void> {\n  const {\n    distFolder,\n    isProductionBuild,\n    pluginName\n  } = params;\n\n  if (isProductionBuild) {\n    return;\n  }\n\n  if (!params.obsidianConfigFolder) {\n    getLibDebugger('deployToObsidianPluginsFolder')(\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  const obsidianConfigFolder = toPosixPath(params.obsidianConfigFolder);\n\n  const pluginFolder = join(obsidianConfigFolder, 'plugins', pluginName);\n  await mkdir(pluginFolder, { recursive: true });\n  await cp(distFolder, pluginFolder, { recursive: true });\n\n  switch (params.reload ?? 'hot-reload-plugin') {\n    case false: {\n      break;\n    }\n    case 'hot-reload-plugin': {\n      await installAndEnableHotReload({\n        obsidianConfigFolder,\n        pluginName\n      });\n      break;\n    }\n    case 'obsidian-cli': {\n      await reloadPluginWithObsidianCli({\n        pluginId: await readPluginId(pluginFolder, pluginName),\n        vaultName: basename(dirname(obsidianConfigFolder))\n      });\n      break;\n    }\n    default: {\n      throw new Error(`Unknown reload option: ${String(params.reload)}`);\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  moduleState.devInstanceTransportPromise ??= launchDevInstance(vaultPath);\n  try {\n    return await moduleState.devInstanceTransportPromise;\n  } catch (error) {\n    // Clear the cache so a later rebuild retries the launch.\n    moduleState.devInstanceTransportPromise = undefined;\n    throw error;\n  }\n}\n\n/**\n * Installs the HotReload plugin from the official community store (if not already installed), loads it\n * (if not already running), and enables the freshly-built plugin — 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 first step is leaving restricted mode for real, which the owned instance has only faked so far —\n * without it \"enabled\" and \"loaded\" come apart and none of the vault's plugins, HotReload included, are\n * running. See the comment on the `setEnable` call.\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 — 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    // eslint-disable-next-line no-shadow -- No actual shadowing as the function is executed externally.\n    async callback({ 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      /*\n       * Genuinely leave restricted mode before touching anything else. The owned instance boots with a\n       * fresh user-data dir, so Obsidian starts restricted and `Plugins.initialize()` returns before\n       * loading a single plugin. The harness then closes the trust modal and writes the\n       * `enable-plugin-<appId>` localStorage flag directly — deliberately, to avoid a synchronous load —\n       * which leaves `isEnabled()` reporting `true` over a vault where nothing is actually running. Every\n       * `enabledPlugins` reading below (and in the mirrored `community-plugins.ts` helpers) would be\n       * answering about the vault's config file rather than this instance.\n       *\n       * `setEnable(true)` is what Obsidian's own \"Exit restricted mode\" button calls: it re-asserts the\n       * flag and loads everything in `enabledPlugins`. Unconditional on purpose — the flag is already\n       * `true`, so an `isEnabled()` guard would skip the load that is the whole point. Idempotent and\n       * effectively free once warm (`loadPlugin` returns the live instance), so re-running it on every\n       * rebuild costs nothing.\n       */\n      await app.plugins.setEnable(true);\n\n      if (!Object.hasOwn(app.plugins.manifests, HOT_RELOAD_PLUGIN_ID)) {\n        const registryResponse = await requestUrl(COMMUNITY_PLUGINS_REGISTRY_URL);\n        const registryEntries = registryResponse.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 latestReleaseResponse = await requestUrl(`https://api.github.com/repos/${entry.repo}/releases/latest`);\n        const latestRelease = latestReleaseResponse.json as GitHubRelease;\n        const version = latestRelease.tag_name;\n        const manifestResponse = await requestUrl(`https://github.com/${entry.repo}/releases/download/${version}/manifest.json`);\n        const manifest = manifestResponse.json as PluginManifest;\n        await app.plugins.installPlugin(entry.repo, version, manifest);\n      }\n\n      /*\n       * Ask whether HotReload is RUNNING, not whether the vault config lists it as enabled. After the\n       * `setEnable` above the two normally agree, but a HotReload that is listed and failed to load would\n       * pass an `enabledPlugins` check while leaving the dev build without auto-refresh.\n       */\n      if (!Object.hasOwn(app.plugins.plugins, HOT_RELOAD_PLUGIN_ID)) {\n        await app.plugins.enablePluginAndSave(HOT_RELOAD_PLUGIN_ID);\n      }\n\n      await app.plugins.enablePluginAndSave(pluginName);\n    },\n    input: { pluginName },\n    shouldSkipPreflightChecks: true,\n    transport,\n    vaultPath\n  });\n}\n\n/**\n * Probes the owned Obsidian instance's CDP endpoint to determine whether it is still running.\n *\n * A closed instance stops serving CDP altogether, so an unreachable endpoint — or one left with no page\n * targets while the app tears itself down — means the instance is gone.\n *\n * @param cdpUrl - The base CDP URL of the owned instance, e.g. `http://localhost:51888`.\n * @returns A {@link Promise} resolving to `true` while the instance is still serving a page target.\n */\nasync function isDevInstanceRunning(cdpUrl: string): Promise<boolean> {\n  try {\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(`${cdpUrl}/json`);\n    const targets = await response.json() as CdpTarget[];\n    return targets.some((target) => target.type === 'page');\n  } catch {\n    return false;\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 (error) {\n    transport.disposeSync?.();\n    throw error;\n  }\n  registerDevInstanceCleanup(transport);\n  watchDevInstanceAndStopOnClose(transport);\n  return transport;\n}\n\n/**\n * Reads the plugin id from the deployed `manifest.json`, which is what Obsidian and its CLI know the plugin by.\n *\n * @param pluginFolder - The deployed plugin folder.\n * @param fallbackId - The id to use when the folder has no readable manifest.\n * @returns A {@link Promise} resolving to the plugin id.\n */\nasync function readPluginId(pluginFolder: string, fallbackId: string): Promise<string> {\n  try {\n    const manifest = JSON.parse(await readFile(join(pluginFolder, 'manifest.json'), 'utf-8')) as Partial<PluginManifest>;\n    return manifest.id ?? fallbackId;\n  } catch {\n    return fallbackId;\n  }\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 * These handlers cover an orderly shutdown. A `SIGKILL` (or a Task Manager / IDE stop) runs no handler\n * at all, and no operating system kills the instance just for being our child — so that case is caught\n * from the other side, by the harness's parent-liveness watchdog: the instance's renderer holds a socket\n * back to this process and destroys its window when the kernel closes it. See `parent-liveness.ts` in\n * `obsidian-integration-testing`.\n *\n * @param transport - The owned transport to dispose on shutdown.\n */\nfunction registerDevInstanceCleanup(transport: ObsidianTransport): void {\n  if (moduleState.isDevInstanceCleanupRegistered) {\n    return;\n  }\n  moduleState.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 (moduleState.isDevInstanceDisposed) {\n      return;\n    }\n    moduleState.isDevInstanceDisposed = true;\n    transport.disposeSync?.();\n  }\n}\n\n/**\n * Watches the `npm run dev`-owned Obsidian instance and stops the development build once the instance is\n * closed.\n *\n * This is the mirror image of {@link registerDevInstanceCleanup}: that one closes the instance when the\n * `npm run dev` process terminates, this one terminates the process when the user closes the instance, so\n * the two never outlive each other. A build watching an Obsidian that is no longer running has nothing\n * left to deploy to.\n *\n * Only a harness-owned instance is watched. When the transport attaches to an already-running Obsidian\n * (the user's own), that instance is not ours to be tied to and closing it leaves the build running.\n *\n * @param transport - The owned transport whose instance to watch.\n */\nfunction watchDevInstanceAndStopOnClose(transport: ObsidianTransport): void {\n  if (!(transport instanceof DesktopCdpTransport)) {\n    return;\n  }\n\n  const endpoint = transport.getOwnedInstanceEndpoint();\n  if (!endpoint) {\n    return;\n  }\n\n  const cdpUrl = `http://${endpoint.host}:${String(endpoint.port)}`;\n  invokeAsyncSafely(stopWhenDevInstanceCloses);\n\n  async function stopWhenDevInstanceCloses(): Promise<void> {\n    let consecutiveFailedProbeCount = 0;\n    while (consecutiveFailedProbeCount < DEV_INSTANCE_CLOSED_PROBE_COUNT) {\n      await sleep({ milliseconds: DEV_INSTANCE_PROBE_INTERVAL_IN_MILLISECONDS });\n\n      // The process is already shutting down and killed the instance itself; the probes would just race the teardown.\n      if (moduleState.isDevInstanceDisposed) {\n        return;\n      }\n\n      consecutiveFailedProbeCount = await isDevInstanceRunning(cdpUrl) ? 0 : consecutiveFailedProbeCount + 1;\n    }\n\n    console.warn('The Obsidian instance owned by `npm run dev` was closed. Stopping the development build.');\n    process.exit();\n  }\n}\n\n/* v8 ignore stop */\n"],"mappings":"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","names":["pluginName","process"]}

package/dist/lib/cjs/bundlers/obsidian-plugins-folder-deployment.d.cts

@@ -0,0 +1,44 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * Deploys a development build into the vault: copies the output folder into `<vault>/.obsidian/plugins`,
+ * then reloads it the way the build's `reload` option says. By default that installs and enables HotReload
+ * and the plugin in an Obsidian instance `npm run dev` owns; `'obsidian-cli'` reloads it in the Obsidian the
+ * developer has open instead (`obsidian-cli-reload.ts`). Every bundler adapter calls it once each rebuild has
+ * written its output, so the latest build is always the one running.
+ */
+import type { ObsidianPluginReload } from './obsidian-plugin-build.cjs';
+/**
+ * Parameters for {@link deployToObsidianPluginsFolder}.
+ */
+export interface DeployToObsidianPluginsFolderParams {
+    /**
+     * The folder where the built files are located.
+     */
+    readonly distFolder: string;
+    /**
+     * A boolean indicating whether the build is a production build.
+     */
+    readonly isProductionBuild: boolean;
+    /**
+     * The folder of the Obsidian configuration. If not provided, the plugin will not copy files.
+     */
+    readonly obsidianConfigFolder: string;
+    /**
+     * The name of the Obsidian plugin.
+     */
+    readonly pluginName: string;
+    /**
+     * How the deployed build is reloaded in Obsidian. Defaults to `'hot-reload-plugin'`.
+     */
+    readonly reload?: ObsidianPluginReload;
+}
+/**
+ * Copies a development build into the vault's plugins folder and reloads it there, as the `reload` option
+ * says. Does nothing for a production build, or when no Obsidian config folder is configured.
+ *
+ * @param params - The {@link DeployToObsidianPluginsFolderParams}.
+ * @returns A {@link Promise} that resolves once the plugin is deployed.
+ */
+export declare function deployToObsidianPluginsFolder(params: DeployToObsidianPluginsFolderParams): Promise<void>;