@mnaoumov/obsidian-dev-toolkit 2.1.0 → 3.0.0

package/dist/lib/cjs/bundlers/index.cjs

@@ -108,14 +108,50 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var bundlers_exports = {};
 __export(bundlers_exports, {
   esbuild: () => esbuild,
-  "esbuild-impl": () => esbuild_impl
+  "esbuild-impl": () => esbuild_impl,
+  "obsidian-cli-reload": () => obsidian_cli_reload,
+  "obsidian-plugin-build": () => obsidian_plugin_build,
+  "obsidian-plugin-features": () => obsidian_plugin_features,
+  "obsidian-plugin-transforms": () => obsidian_plugin_transforms,
+  "obsidian-plugin-webpack-loader": () => obsidian_plugin_webpack_loader,
+  "obsidian-plugins-folder-deployment": () => obsidian_plugins_folder_deployment,
+  parcel: () => parcel,
+  rollup: () => rollup,
+  "rollup-compatible": () => rollup_compatible,
+  "rollup-compatible-features": () => rollup_compatible_features,
+  vite: () => vite,
+  webpack: () => webpack
 });
 module.exports = __toCommonJS(bundlers_exports);
 var esbuild_impl = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./esbuild-impl/index.cjs')), 1);
 var esbuild = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./esbuild.cjs')), 1);
+var obsidian_cli_reload = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./obsidian-cli-reload.cjs')), 1);
+var obsidian_plugin_build = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./obsidian-plugin-build.cjs')), 1);
+var obsidian_plugin_features = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./obsidian-plugin-features.cjs')), 1);
+var obsidian_plugin_transforms = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./obsidian-plugin-transforms.cjs')), 1);
+var obsidian_plugin_webpack_loader = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./obsidian-plugin-webpack-loader.cjs')), 1);
+var obsidian_plugins_folder_deployment = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./obsidian-plugins-folder-deployment.cjs')), 1);
+var parcel = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./parcel.cjs')), 1);
+var rollup_compatible_features = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./rollup-compatible-features.cjs')), 1);
+var rollup_compatible = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./rollup-compatible.cjs')), 1);
+var rollup = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./rollup.cjs')), 1);
+var vite = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./vite.cjs')), 1);
+var webpack = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./webpack.cjs')), 1);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   esbuild,
-  "esbuild-impl": null
+  "esbuild-impl": null,
+  "obsidian-cli-reload": null,
+  "obsidian-plugin-build": null,
+  "obsidian-plugin-features": null,
+  "obsidian-plugin-transforms": null,
+  "obsidian-plugin-webpack-loader": null,
+  "obsidian-plugins-folder-deployment": null,
+  parcel,
+  rollup,
+  "rollup-compatible": null,
+  "rollup-compatible-features": null,
+  vite,
+  webpack
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9idW5kbGVycy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiBUSElTIElTIEEgR0VORVJBVEVEL0JVTkRMRUQgRklMRSBCWSBCVUlMRCBTQ1JJUFQgKi9cblxuZXhwb3J0ICogYXMgJ2VzYnVpbGQtaW1wbCcgZnJvbSAnLi9lc2J1aWxkLWltcGwvaW5kZXgudHMnO1xuZXhwb3J0ICogYXMgJ2VzYnVpbGQnIGZyb20gJy4vZXNidWlsZC50cyc7XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUEsd0JBQUFBO0FBQUE7QUFBQTtBQUVBLElBQUFBLGVBQWdDO0FBQ2hDLGNBQTJCOyIsIm5hbWVzIjpbImVzYnVpbGQtaW1wbCJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/bundlers/index.d.cts

@@ -1,3 +1,15 @@
 /// <reference path="../library-references.d.cts" />
 export * as 'esbuild-impl' from './esbuild-impl/index.cjs';
 export * as 'esbuild' from './esbuild.cjs';
+export * as 'obsidian-cli-reload' from './obsidian-cli-reload.cjs';
+export * as 'obsidian-plugin-build' from './obsidian-plugin-build.cjs';
+export * as 'obsidian-plugin-features' from './obsidian-plugin-features.cjs';
+export * as 'obsidian-plugin-transforms' from './obsidian-plugin-transforms.cjs';
+export * as 'obsidian-plugin-webpack-loader' from './obsidian-plugin-webpack-loader.cjs';
+export * as 'obsidian-plugins-folder-deployment' from './obsidian-plugins-folder-deployment.cjs';
+export * as 'parcel' from './parcel.cjs';
+export * as 'rollup-compatible-features' from './rollup-compatible-features.cjs';
+export * as 'rollup-compatible' from './rollup-compatible.cjs';
+export * as 'rollup' from './rollup.cjs';
+export * as 'vite' from './vite.cjs';
+export * as 'webpack' from './webpack.cjs';

package/dist/lib/cjs/bundlers/obsidian-cli-reload.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_cli_reload_exports = {};
+__export(obsidian_cli_reload_exports, {
+  OBSIDIAN_CLI_COMMAND: () => OBSIDIAN_CLI_COMMAND,
+  reloadPluginWithObsidianCli: () => reloadPluginWithObsidianCli
+});
+module.exports = __toCommonJS(obsidian_cli_reload_exports);
+var import_exec = require('@mnaoumov/typescript-dev-toolkit/exec');
+const OBSIDIAN_CLI_COMMAND = "obsidian";
+const OBSIDIAN_CLI_SETUP_HINT = `Turn the Obsidian CLI on in Obsidian (Settings \u2192 General \u2192 Command line interface), make sure \`${OBSIDIAN_CLI_COMMAND}\` is on PATH, and keep Obsidian running. Or build with \`reload: 'hot-reload-plugin'\` instead.`;
+async function reloadPluginWithObsidianCli(params) {
+  const { pluginId, vaultName } = params;
+  const reloadOutput = await runObsidianCli([`vault=${vaultName}`, "plugin:reload", `id=${pluginId}`]);
+  if (!isPluginNotFoundOutput(reloadOutput)) {
+    assertObsidianCliSucceeded(reloadOutput, `reload plugin '${pluginId}' in vault '${vaultName}'`);
+    return;
+  }
+  const enableOutput = await runObsidianCli([`vault=${vaultName}`, "eval", `code=${getEnableNewPluginCode(pluginId)}`]);
+  assertObsidianCliSucceeded(enableOutput, `enable new plugin '${pluginId}' in vault '${vaultName}'`);
+}
+function assertObsidianCliSucceeded(output, action) {
+  if (output === "Vault not found." || output.startsWith("Error:")) {
+    throw new Error(`The Obsidian CLI could not ${action}: ${output}
+${OBSIDIAN_CLI_SETUP_HINT}`);
+  }
+}
+function formatCommandFailure(result) {
+  return [result.stderr.trim(), result.stdout.trim()].filter(Boolean).join("\n") || `exit code ${String(result.exitCode)}`;
+}
+function getEnableNewPluginCode(pluginId) {
+  return `app.plugins.loadManifests().then(() => app.plugins.enablePluginAndSave(${JSON.stringify(pluginId)}))`;
+}
+function isPluginNotFoundOutput(output) {
+  return output.startsWith("Error: Plugin ") && output.includes(" not found");
+}
+async function runObsidianCli(cliArguments) {
+  let result;
+  try {
+    result = await (0, import_exec.exec)([OBSIDIAN_CLI_COMMAND, ...cliArguments], {
+      isQuiet: true,
+      shouldIgnoreExitCode: true,
+      shouldIncludeDetails: true
+    });
+  } catch (error) {
+    throw new Error(`The Obsidian CLI (\`${OBSIDIAN_CLI_COMMAND}\`) could not be started.
+${OBSIDIAN_CLI_SETUP_HINT}`, { cause: error });
+  }
+  if (result.exitCode !== 0) {
+    throw new Error(`The Obsidian CLI (\`${OBSIDIAN_CLI_COMMAND}\`) failed: ${formatCommandFailure(result)}
+${OBSIDIAN_CLI_SETUP_HINT}`);
+  }
+  return result.stdout.trim();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OBSIDIAN_CLI_COMMAND,
+  reloadPluginWithObsidianCli
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/bundlers/obsidian-cli-reload.d.cts

@@ -0,0 +1,37 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * Reloads a deployed development build through the Obsidian CLI (`obsidian`, Obsidian 1.12 and later), in the
+ * Obsidian the developer already has open. It is the `reload: 'obsidian-cli'` half of
+ * `obsidian-plugins-folder-deployment.ts`.
+ */
+/**
+ * Parameters for {@link reloadPluginWithObsidianCli}.
+ */
+export interface ReloadPluginWithObsidianCliParams {
+    /**
+     * The plugin id, from its `manifest.json`.
+     */
+    readonly pluginId: string;
+    /**
+     * The vault's name as Obsidian knows it, which is the name of the vault's folder.
+     */
+    readonly vaultName: string;
+}
+/**
+ * The command the Obsidian CLI is run as.
+ */
+export declare const OBSIDIAN_CLI_COMMAND = "obsidian";
+/**
+ * Reloads a plugin in the running Obsidian through the Obsidian CLI, enabling it first when Obsidian does not
+ * know it yet.
+ *
+ * The CLI exits with code 0 even when the command failed, and says so in its output (`Vault not found.`,
+ * `Error: ...`), so the output is what is checked.
+ *
+ * @param params - The {@link ReloadPluginWithObsidianCliParams}.
+ * @returns A {@link Promise} that resolves once the plugin is reloaded.
+ * @throws When the CLI cannot be run, or reports a failure.
+ */
+export declare function reloadPluginWithObsidianCli(params: ReloadPluginWithObsidianCliParams): Promise<void>;

package/dist/lib/cjs/bundlers/obsidian-plugin-build.cjs

@@ -0,0 +1,278 @@
+/*
+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_plugin_build_exports = {};
+__export(obsidian_plugin_build_exports, {
+  BuildMode: () => BuildMode,
+  OBSIDIAN_PLUGIN_EXTERNALS: () => OBSIDIAN_PLUGIN_EXTERNALS,
+  OBSIDIAN_PLUGIN_RUNTIME_MODULES: () => OBSIDIAN_PLUGIN_RUNTIME_MODULES,
+  cleanObsidianPluginDistFolder: () => cleanObsidianPluginDistFolder,
+  completeObsidianPluginDistFolder: () => completeObsidianPluginDistFolder,
+  getObsidianPluginBanner: () => getObsidianPluginBanner,
+  getObsidianPluginDistFolder: () => getObsidianPluginDistFolder,
+  getObsidianPluginEntryPoint: () => getObsidianPluginEntryPoint,
+  isCssFileName: () => isCssFileName,
+  isObsidianPluginExternal: () => isObsidianPluginExternal,
+  mergeCssAssets: () => mergeCssAssets,
+  resolveFromRoot: () => resolveFromRoot,
+  resolveObsidianPluginBuildContext: () => resolveObsidianPluginBuildContext
+});
+module.exports = __toCommonJS(obsidian_plugin_build_exports);
+var import_npm = require('@mnaoumov/typescript-dev-toolkit/npm');
+var import_root = require('@mnaoumov/typescript-dev-toolkit/root');
+var import_path = require('@mnaoumov/typescript-lib/path');
+var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
+var import_node_fs = require('node:fs');
+var import_promises = require('node:fs/promises');
+var import_node_module = require('node:module');
+var import_node_process = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('node:process')), 1);
+var import_obsidian_plugin_repo_paths = require('../obsidian-plugin-repo-paths.cjs');
+var BuildMode = /* @__PURE__ */ ((BuildMode2) => {
+  BuildMode2[BuildMode2["Development"] = 0] = "Development";
+  BuildMode2[BuildMode2["Production"] = 1] = "Production";
+  return BuildMode2;
+})(BuildMode || {});
+const OBSIDIAN_PLUGIN_RUNTIME_MODULES = [
+  "obsidian",
+  "electron",
+  "@codemirror/autocomplete",
+  "@codemirror/collab",
+  "@codemirror/commands",
+  "@codemirror/language",
+  "@codemirror/lint",
+  "@codemirror/search",
+  "@codemirror/state",
+  "@codemirror/view",
+  "@lezer/common",
+  "@lezer/highlight",
+  "@lezer/lr",
+  "esbuild",
+  "eslint"
+];
+const OBSIDIAN_PLUGIN_EXTERNALS = [
+  ...OBSIDIAN_PLUGIN_RUNTIME_MODULES,
+  ...import_node_module.builtinModules
+];
+const NODE_PREFIX = "node:";
+const STYLES_CSS_FILE_NAME = import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.StylesCss;
+const OBSIDIAN_PLUGIN_EXTERNALS_SET = new Set(OBSIDIAN_PLUGIN_EXTERNALS);
+async function cleanObsidianPluginDistFolder(distFolder) {
+  if ((0, import_node_fs.existsSync)(distFolder)) {
+    await (0, import_promises.rm)(distFolder, { recursive: true });
+  }
+  await (0, import_promises.mkdir)(distFolder, { recursive: true });
+}
+async function completeObsidianPluginDistFolder(context) {
+  await (0, import_promises.mkdir)(context.distFolder, { recursive: true });
+  if (!context.isProductionBuild && context.reload === "hot-reload-plugin") {
+    await (0, import_promises.writeFile)((0, import_path.join)(context.distFolder, import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.HotReload), "", "utf-8");
+  }
+  const manifestPath = (0, import_root.resolvePathFromRoot)({ path: import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.ManifestJson });
+  if (manifestPath && (0, import_node_fs.existsSync)(manifestPath)) {
+    await (0, import_promises.cp)(manifestPath, (0, import_path.join)(context.distFolder, import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.ManifestJson));
+  }
+}
+function getObsidianPluginBanner(bundlerName) {
+  return `/*
+THIS IS A GENERATED/BUNDLED FILE BY ${bundlerName.toUpperCase()}
+if you want to view the source, please visit the github repository of this plugin
+*/
+`;
+}
+function getObsidianPluginDistFolder(mode) {
+  return resolveFromRoot(mode === 1 /* Production */ ? import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.DistBuild : import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.DistDev);
+}
+function getObsidianPluginEntryPoint() {
+  return resolveFromRoot((0, import_path.join)(import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.Src, import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.MainTs));
+}
+function isCssFileName(fileName) {
+  return (0, import_path.basename)(fileName).toLowerCase().endsWith(".css");
+}
+function isObsidianPluginExternal(moduleId) {
+  if (moduleId.startsWith(NODE_PREFIX) || OBSIDIAN_PLUGIN_EXTERNALS_SET.has(moduleId)) {
+    return true;
+  }
+  const SCOPED_PACKAGE_SEGMENT_COUNT = 2;
+  const packageName = moduleId.split("/").slice(0, moduleId.startsWith("@") ? SCOPED_PACKAGE_SEGMENT_COUNT : 1).join("/");
+  return packageName !== moduleId && OBSIDIAN_PLUGIN_EXTERNALS_SET.has(packageName);
+}
+function mergeCssAssets(cssAssets) {
+  const [firstCssAsset] = cssAssets;
+  if (firstCssAsset === void 0 || cssAssets.length === 1 && firstCssAsset.fileName === STYLES_CSS_FILE_NAME) {
+    return { fileNamesToRemove: [], stylesCss: void 0 };
+  }
+  return {
+    fileNamesToRemove: cssAssets.map((asset) => asset.fileName),
+    stylesCss: cssAssets.map((asset) => asset.source).join("\n")
+  };
+}
+function resolveFromRoot(path) {
+  return (0, import_type_guards.ensureNonNullable)((0, import_root.resolvePathFromRoot)({ path }), `Could not resolve '${path}' against the project root`);
+}
+async function resolveObsidianPluginBuildContext(params) {
+  const envPath = (0, import_root.resolvePathFromRoot)({ path: ".env" });
+  if (envPath && (0, import_node_fs.existsSync)(envPath)) {
+    (0, import_node_process.loadEnvFile)(envPath);
+  }
+  const obsidianPluginBuilderEnv = import_node_process.default.env;
+  const isProductionBuild = params.mode === 1 /* Production */;
+  const distFolder = params.distFolder === void 0 ? getObsidianPluginDistFolder(params.mode) : resolveFromRoot(params.distFolder);
+  const packageJson = await (0, import_npm.readPackageJson)();
+  return {
+    distFolder,
+    entryPoint: getObsidianPluginEntryPoint(),
+    isProductionBuild,
+    mainJsPath: (0, import_path.join)(distFolder, import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.MainJs),
+    obsidianConfigFolder: params.obsidianConfigFolder ?? obsidianPluginBuilderEnv.OBSIDIAN_CONFIG_FOLDER ?? "",
+    pluginName: packageJson.name ?? "(unknown)",
+    reload: params.reload ?? "hot-reload-plugin"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BuildMode,
+  OBSIDIAN_PLUGIN_EXTERNALS,
+  OBSIDIAN_PLUGIN_RUNTIME_MODULES,
+  cleanObsidianPluginDistFolder,
+  completeObsidianPluginDistFolder,
+  getObsidianPluginBanner,
+  getObsidianPluginDistFolder,
+  getObsidianPluginEntryPoint,
+  isCssFileName,
+  isObsidianPluginExternal,
+  mergeCssAssets,
+  resolveFromRoot,
+  resolveObsidianPluginBuildContext
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/bundlers/obsidian-plugin-build.ts"],"sourcesContent":["/**\n * @file\n *\n * The bundler-independent half of building an Obsidian plugin: which modules stay external, where the\n * output goes, what the output folder holds besides the bundle, and how a development build reaches the\n * vault. Every bundler adapter in this folder (esbuild, rollup, vite, webpack, parcel) is a thin layer over\n * it, so all of them produce the same `main.js` + `styles.css` + `manifest.json` layout.\n */\n\nimport { readPackageJson } from '@mnaoumov/typescript-dev-toolkit/npm';\nimport { resolvePathFromRoot } from '@mnaoumov/typescript-dev-toolkit/root';\nimport {\n  basename,\n  join\n} from '@mnaoumov/typescript-lib/path';\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { existsSync } from 'node:fs';\nimport {\n  cp,\n  mkdir,\n  rm,\n  writeFile\n} from 'node:fs/promises';\nimport { builtinModules } from 'node:module';\nimport process, { loadEnvFile } from 'node:process';\n\nimport { ObsidianPluginRepoPaths } from '../obsidian-plugin-repo-paths.ts';\n\n/**\n * Enumeration representing the build modes.\n */\nexport enum BuildMode {\n  /**\n  Development mode for building the plugin\n   */\n  Development,\n  /**\n  Production mode for building the plugin\n   */\n  Production\n}\n\n/**\n * The modules Obsidian supplies at runtime. A plugin must never bundle its own copy of them: a second copy\n * of the API breaks `instanceof` against the running one, and a second CodeMirror breaks every extension.\n *\n * `esbuild` and `eslint` are here because a plugin that imports one of the toolkit's build-time modules\n * would otherwise drag either into `main.js`.\n */\nexport const OBSIDIAN_PLUGIN_RUNTIME_MODULES: readonly string[] = [\n  'obsidian',\n  'electron',\n  '@codemirror/autocomplete',\n  '@codemirror/collab',\n  '@codemirror/commands',\n  '@codemirror/language',\n  '@codemirror/lint',\n  '@codemirror/search',\n  '@codemirror/state',\n  '@codemirror/view',\n  '@lezer/common',\n  '@lezer/highlight',\n  '@lezer/lr',\n  'esbuild',\n  'eslint'\n];\n\n/**\n * The module ids an Obsidian plugin bundle leaves to `require()` at runtime: the\n * {@link OBSIDIAN_PLUGIN_RUNTIME_MODULES} and the Node builtins. Every `node:`-prefixed id is external too,\n * which a bundler takes as a pattern (esbuild's `node:*`) or through {@link isObsidianPluginExternal}.\n */\nexport const OBSIDIAN_PLUGIN_EXTERNALS: readonly string[] = [\n  ...OBSIDIAN_PLUGIN_RUNTIME_MODULES,\n  ...builtinModules\n];\n\nconst NODE_PREFIX = 'node:';\nconst STYLES_CSS_FILE_NAME: string = ObsidianPluginRepoPaths.StylesCss;\n\nconst OBSIDIAN_PLUGIN_EXTERNALS_SET = new Set(OBSIDIAN_PLUGIN_EXTERNALS);\n\n/**\n * A CSS file a bundler emitted, as {@link mergeCssAssets} sees it.\n */\nexport interface CssAsset {\n  /**\n   * The file name relative to the output folder.\n   */\n  readonly fileName: string;\n\n  /**\n   * The file's contents.\n   */\n  readonly source: string;\n}\n\n/**\n * What {@link mergeCssAssets} decided.\n */\nexport interface MergeCssAssetsResult {\n  /**\n   * The file names to drop from the output, because their contents moved into `styles.css`. Includes\n   * `styles.css` itself when the bundler already emitted one, so it is always written afresh.\n   */\n  readonly fileNamesToRemove: readonly string[];\n\n  /**\n   * The contents of `styles.css`, or `undefined` when there is nothing to do: the bundle has no CSS at all,\n   * or its one CSS file already is `styles.css`.\n   */\n  readonly stylesCss: string | undefined;\n}\n\n/**\n * Where a plugin build writes its output and what it builds.\n */\nexport interface ObsidianPluginBuildContext {\n  /**\n   * The absolute path of the folder the build writes `main.js`, `styles.css` and `manifest.json` into.\n   */\n  readonly distFolder: string;\n\n  /**\n   * The absolute path of the plugin's entry point, `src/main.ts`.\n   */\n  readonly entryPoint: string;\n\n  /**\n   * Whether this is a production build.\n   */\n  readonly isProductionBuild: boolean;\n\n  /**\n   * The absolute path of the emitted `main.js`.\n   */\n  readonly mainJsPath: string;\n\n  /**\n   * The Obsidian configuration folder a development build is deployed into, or an empty string when none\n   * is configured.\n   */\n  readonly obsidianConfigFolder: string;\n\n  /**\n   * The plugin's folder name inside `<vault>/.obsidian/plugins`, which is the package name.\n   */\n  readonly pluginName: string;\n\n  /**\n   * How a development build is reloaded in Obsidian once it is deployed.\n   */\n  readonly reload: ObsidianPluginReload;\n}\n\n/**\n * Where a development build is deployed and how Obsidian picks it up. Every bundler adapter takes these.\n */\nexport interface ObsidianPluginDeploymentOptions {\n  /**\n   * A folder for Obsidian configuration. Defaults to the `OBSIDIAN_CONFIG_FOLDER` environment variable,\n   * read from the process or from a `.env` file in the project root.\n   */\n  readonly obsidianConfigFolder?: string;\n\n  /**\n   * How a development build is reloaded in Obsidian once it is copied into the vault. Defaults to\n   * `'hot-reload-plugin'`.\n   */\n  readonly reload?: ObsidianPluginReload;\n}\n\n/**\n * How a development build is reloaded in Obsidian once it is copied into the vault.\n *\n * - `'hot-reload-plugin'`: the build writes the `.hotreload` marker, and `npm run dev` opens the vault in an\n *   Obsidian instance it owns, with the HotReload plugin installed and enabled there.\n * - `'obsidian-cli'`: every rebuild runs `obsidian plugin:reload` against the Obsidian you already have open,\n *   through the Obsidian CLI (Settings → General → Command line interface). No HotReload, no second instance.\n * - `false`: the build is copied into the vault and nothing reloads it.\n */\nexport type ObsidianPluginReload = 'hot-reload-plugin' | 'obsidian-cli' | false;\n\n/**\n * Options for {@link resolveObsidianPluginBuildContext}.\n */\nexport interface ResolveObsidianPluginBuildContextParams extends ObsidianPluginDeploymentOptions {\n  /**\n   * The output folder. Defaults to `dist/build` for a production build and `dist/dev` for a development\n   * one.\n   */\n  readonly distFolder?: string;\n\n  /**\n   * The build mode.\n   */\n  readonly mode: BuildMode;\n}\n\ninterface ObsidianPluginBuilderEnv {\n  OBSIDIAN_CONFIG_FOLDER: string;\n}\n\n/**\n * Removes the output folder of a build and creates it empty again.\n *\n * @param distFolder - The output folder.\n * @returns A {@link Promise} that resolves once the folder exists and is empty.\n */\nexport async function cleanObsidianPluginDistFolder(distFolder: string): Promise<void> {\n  if (existsSync(distFolder)) {\n    await rm(distFolder, { recursive: true });\n  }\n  await mkdir(distFolder, { recursive: true });\n}\n\n/**\n * Puts the files a plugin folder needs besides the bundle into the output folder: `manifest.json`, and for\n * a development build reloaded by the HotReload plugin the empty `.hotreload` marker it watches for.\n *\n * @param context - The build context.\n * @returns A {@link Promise} that resolves once the files are written.\n */\nexport async function completeObsidianPluginDistFolder(context: ObsidianPluginBuildContext): Promise<void> {\n  await mkdir(context.distFolder, { recursive: true });\n  if (!context.isProductionBuild && context.reload === 'hot-reload-plugin') {\n    await writeFile(join(context.distFolder, ObsidianPluginRepoPaths.HotReload), '', 'utf-8');\n  }\n\n  const manifestPath = resolvePathFromRoot({ path: ObsidianPluginRepoPaths.ManifestJson });\n  if (manifestPath && existsSync(manifestPath)) {\n    await cp(manifestPath, join(context.distFolder, ObsidianPluginRepoPaths.ManifestJson));\n  }\n}\n\n/**\n * Builds the banner placed at the top of `main.js`.\n *\n * @param bundlerName - The bundler's name, as the banner states it.\n * @returns The banner, a block comment followed by a newline.\n */\nexport function getObsidianPluginBanner(bundlerName: string): string {\n  return `/*\nTHIS IS A GENERATED/BUNDLED FILE BY ${bundlerName.toUpperCase()}\nif you want to view the source, please visit the github repository of this plugin\n*/\n`;\n}\n\n/**\n * Resolves the default output folder of a build: `dist/build` for a production build, `dist/dev` for a\n * development one.\n *\n * @param mode - The build mode.\n * @returns The absolute path of the output folder.\n */\nexport function getObsidianPluginDistFolder(mode: BuildMode): string {\n  return resolveFromRoot(mode === BuildMode.Production ? ObsidianPluginRepoPaths.DistBuild : ObsidianPluginRepoPaths.DistDev);\n}\n\n/**\n * Resolves the plugin's entry point, `src/main.ts`.\n *\n * @returns The absolute path of the entry point.\n */\nexport function getObsidianPluginEntryPoint(): string {\n  return resolveFromRoot(join(ObsidianPluginRepoPaths.Src, ObsidianPluginRepoPaths.MainTs));\n}\n\n/**\n * Tells whether a file name is a CSS file.\n *\n * @param fileName - The file name.\n * @returns `true` for a `.css` file.\n */\nexport function isCssFileName(fileName: string): boolean {\n  return basename(fileName).toLowerCase().endsWith('.css');\n}\n\n/**\n * Tells whether a module id is one an Obsidian plugin bundle must leave external: one of\n * {@link OBSIDIAN_PLUGIN_EXTERNALS}, a subpath of one (`@codemirror/view/dist/index.js`, `fs/promises`),\n * or any `node:`-prefixed id.\n *\n * @param moduleId - The module id as written in the importing file.\n * @returns `true` when the bundle must leave the module to `require()` at runtime.\n */\nexport function isObsidianPluginExternal(moduleId: string): boolean {\n  if (moduleId.startsWith(NODE_PREFIX) || OBSIDIAN_PLUGIN_EXTERNALS_SET.has(moduleId)) {\n    return true;\n  }\n\n  const SCOPED_PACKAGE_SEGMENT_COUNT = 2;\n  const packageName = moduleId.split('/').slice(0, moduleId.startsWith('@') ? SCOPED_PACKAGE_SEGMENT_COUNT : 1).join('/');\n  return packageName !== moduleId && OBSIDIAN_PLUGIN_EXTERNALS_SET.has(packageName);\n}\n\n/**\n * Decides how the CSS a bundler emitted becomes the one `styles.css` Obsidian loads.\n *\n * Obsidian reads a plugin's stylesheet from `styles.css` and nothing else, while a bundler names the CSS\n * after the entry (`main.css`), after the package, or with a content hash. A lone CSS file is renamed; when\n * there are several, they are concatenated in the order given.\n *\n * @param cssAssets - The CSS files the bundler emitted, in output order.\n * @returns What to write as `styles.css` and which emitted files to drop.\n */\nexport function mergeCssAssets(cssAssets: readonly CssAsset[]): MergeCssAssetsResult {\n  const [firstCssAsset] = cssAssets;\n  if (firstCssAsset === undefined || (cssAssets.length === 1 && firstCssAsset.fileName === STYLES_CSS_FILE_NAME)) {\n    return { fileNamesToRemove: [], stylesCss: undefined };\n  }\n\n  return {\n    fileNamesToRemove: cssAssets.map((asset) => asset.fileName),\n    stylesCss: cssAssets.map((asset) => asset.source).join('\\n')\n  };\n}\n\n/**\n * Resolves a path against the project root.\n *\n * @param path - The path, relative to the project root or absolute.\n * @returns The absolute path.\n */\nexport function resolveFromRoot(path: string): string {\n  return ensureNonNullable(resolvePathFromRoot({ path }), `Could not resolve '${path}' against the project root`);\n}\n\n/**\n * Resolves where a plugin build writes its output, which entry point it builds and which vault a\n * development build is deployed into.\n *\n * Loads the project's `.env` file first, so `OBSIDIAN_CONFIG_FOLDER` can live there.\n *\n * @param params - The {@link ResolveObsidianPluginBuildContextParams}.\n * @returns A {@link Promise} that resolves to the {@link ObsidianPluginBuildContext}.\n */\nexport async function resolveObsidianPluginBuildContext(params: ResolveObsidianPluginBuildContextParams): Promise<ObsidianPluginBuildContext> {\n  const envPath = resolvePathFromRoot({ path: '.env' });\n  if (envPath && existsSync(envPath)) {\n    loadEnvFile(envPath);\n  }\n  const obsidianPluginBuilderEnv = process.env as Partial<ObsidianPluginBuilderEnv>;\n\n  const isProductionBuild = params.mode === BuildMode.Production;\n  const distFolder = params.distFolder === undefined ? getObsidianPluginDistFolder(params.mode) : resolveFromRoot(params.distFolder);\n  const packageJson = await readPackageJson();\n\n  return {\n    distFolder,\n    entryPoint: getObsidianPluginEntryPoint(),\n    isProductionBuild,\n    mainJsPath: join(distFolder, ObsidianPluginRepoPaths.MainJs),\n    obsidianConfigFolder: params.obsidianConfigFolder ?? obsidianPluginBuilderEnv.OBSIDIAN_CONFIG_FOLDER ?? '',\n    pluginName: packageJson.name ?? '(unknown)',\n    reload: params.reload ?? 'hot-reload-plugin'\n  };\n}\n"],"mappings":"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","names":["BuildMode","process"]}