@mnaoumov/obsidian-dev-toolkit 2.1.0 → 3.0.0

package/dist/lib/esm/bundlers/obsidian-plugin-build.d.mts

@@ -0,0 +1,217 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * The bundler-independent half of building an Obsidian plugin: which modules stay external, where the
+ * output goes, what the output folder holds besides the bundle, and how a development build reaches the
+ * vault. Every bundler adapter in this folder (esbuild, rollup, vite, webpack, parcel) is a thin layer over
+ * it, so all of them produce the same `main.js` + `styles.css` + `manifest.json` layout.
+ */
+/**
+ * Enumeration representing the build modes.
+ */
+export declare enum BuildMode {
+    /**
+    Development mode for building the plugin
+     */
+    Development = 0,
+    /**
+    Production mode for building the plugin
+     */
+    Production = 1
+}
+/**
+ * The modules Obsidian supplies at runtime. A plugin must never bundle its own copy of them: a second copy
+ * of the API breaks `instanceof` against the running one, and a second CodeMirror breaks every extension.
+ *
+ * `esbuild` and `eslint` are here because a plugin that imports one of the toolkit's build-time modules
+ * would otherwise drag either into `main.js`.
+ */
+export declare const OBSIDIAN_PLUGIN_RUNTIME_MODULES: readonly string[];
+/**
+ * The module ids an Obsidian plugin bundle leaves to `require()` at runtime: the
+ * {@link OBSIDIAN_PLUGIN_RUNTIME_MODULES} and the Node builtins. Every `node:`-prefixed id is external too,
+ * which a bundler takes as a pattern (esbuild's `node:*`) or through {@link isObsidianPluginExternal}.
+ */
+export declare const OBSIDIAN_PLUGIN_EXTERNALS: readonly string[];
+/**
+ * A CSS file a bundler emitted, as {@link mergeCssAssets} sees it.
+ */
+export interface CssAsset {
+    /**
+     * The file name relative to the output folder.
+     */
+    readonly fileName: string;
+    /**
+     * The file's contents.
+     */
+    readonly source: string;
+}
+/**
+ * What {@link mergeCssAssets} decided.
+ */
+export interface MergeCssAssetsResult {
+    /**
+     * The file names to drop from the output, because their contents moved into `styles.css`. Includes
+     * `styles.css` itself when the bundler already emitted one, so it is always written afresh.
+     */
+    readonly fileNamesToRemove: readonly string[];
+    /**
+     * The contents of `styles.css`, or `undefined` when there is nothing to do: the bundle has no CSS at all,
+     * or its one CSS file already is `styles.css`.
+     */
+    readonly stylesCss: string | undefined;
+}
+/**
+ * Where a plugin build writes its output and what it builds.
+ */
+export interface ObsidianPluginBuildContext {
+    /**
+     * The absolute path of the folder the build writes `main.js`, `styles.css` and `manifest.json` into.
+     */
+    readonly distFolder: string;
+    /**
+     * The absolute path of the plugin's entry point, `src/main.ts`.
+     */
+    readonly entryPoint: string;
+    /**
+     * Whether this is a production build.
+     */
+    readonly isProductionBuild: boolean;
+    /**
+     * The absolute path of the emitted `main.js`.
+     */
+    readonly mainJsPath: string;
+    /**
+     * The Obsidian configuration folder a development build is deployed into, or an empty string when none
+     * is configured.
+     */
+    readonly obsidianConfigFolder: string;
+    /**
+     * The plugin's folder name inside `<vault>/.obsidian/plugins`, which is the package name.
+     */
+    readonly pluginName: string;
+    /**
+     * How a development build is reloaded in Obsidian once it is deployed.
+     */
+    readonly reload: ObsidianPluginReload;
+}
+/**
+ * Where a development build is deployed and how Obsidian picks it up. Every bundler adapter takes these.
+ */
+export interface ObsidianPluginDeploymentOptions {
+    /**
+     * A folder for Obsidian configuration. Defaults to the `OBSIDIAN_CONFIG_FOLDER` environment variable,
+     * read from the process or from a `.env` file in the project root.
+     */
+    readonly obsidianConfigFolder?: string;
+    /**
+     * How a development build is reloaded in Obsidian once it is copied into the vault. Defaults to
+     * `'hot-reload-plugin'`.
+     */
+    readonly reload?: ObsidianPluginReload;
+}
+/**
+ * How a development build is reloaded in Obsidian once it is copied into the vault.
+ *
+ * - `'hot-reload-plugin'`: the build writes the `.hotreload` marker, and `npm run dev` opens the vault in an
+ *   Obsidian instance it owns, with the HotReload plugin installed and enabled there.
+ * - `'obsidian-cli'`: every rebuild runs `obsidian plugin:reload` against the Obsidian you already have open,
+ *   through the Obsidian CLI (Settings → General → Command line interface). No HotReload, no second instance.
+ * - `false`: the build is copied into the vault and nothing reloads it.
+ */
+export type ObsidianPluginReload = 'hot-reload-plugin' | 'obsidian-cli' | false;
+/**
+ * Options for {@link resolveObsidianPluginBuildContext}.
+ */
+export interface ResolveObsidianPluginBuildContextParams extends ObsidianPluginDeploymentOptions {
+    /**
+     * The output folder. Defaults to `dist/build` for a production build and `dist/dev` for a development
+     * one.
+     */
+    readonly distFolder?: string;
+    /**
+     * The build mode.
+     */
+    readonly mode: BuildMode;
+}
+/**
+ * Removes the output folder of a build and creates it empty again.
+ *
+ * @param distFolder - The output folder.
+ * @returns A {@link Promise} that resolves once the folder exists and is empty.
+ */
+export declare function cleanObsidianPluginDistFolder(distFolder: string): Promise<void>;
+/**
+ * Puts the files a plugin folder needs besides the bundle into the output folder: `manifest.json`, and for
+ * a development build reloaded by the HotReload plugin the empty `.hotreload` marker it watches for.
+ *
+ * @param context - The build context.
+ * @returns A {@link Promise} that resolves once the files are written.
+ */
+export declare function completeObsidianPluginDistFolder(context: ObsidianPluginBuildContext): Promise<void>;
+/**
+ * Builds the banner placed at the top of `main.js`.
+ *
+ * @param bundlerName - The bundler's name, as the banner states it.
+ * @returns The banner, a block comment followed by a newline.
+ */
+export declare function getObsidianPluginBanner(bundlerName: string): string;
+/**
+ * Resolves the default output folder of a build: `dist/build` for a production build, `dist/dev` for a
+ * development one.
+ *
+ * @param mode - The build mode.
+ * @returns The absolute path of the output folder.
+ */
+export declare function getObsidianPluginDistFolder(mode: BuildMode): string;
+/**
+ * Resolves the plugin's entry point, `src/main.ts`.
+ *
+ * @returns The absolute path of the entry point.
+ */
+export declare function getObsidianPluginEntryPoint(): string;
+/**
+ * Tells whether a file name is a CSS file.
+ *
+ * @param fileName - The file name.
+ * @returns `true` for a `.css` file.
+ */
+export declare function isCssFileName(fileName: string): boolean;
+/**
+ * Tells whether a module id is one an Obsidian plugin bundle must leave external: one of
+ * {@link OBSIDIAN_PLUGIN_EXTERNALS}, a subpath of one (`@codemirror/view/dist/index.js`, `fs/promises`),
+ * or any `node:`-prefixed id.
+ *
+ * @param moduleId - The module id as written in the importing file.
+ * @returns `true` when the bundle must leave the module to `require()` at runtime.
+ */
+export declare function isObsidianPluginExternal(moduleId: string): boolean;
+/**
+ * Decides how the CSS a bundler emitted becomes the one `styles.css` Obsidian loads.
+ *
+ * Obsidian reads a plugin's stylesheet from `styles.css` and nothing else, while a bundler names the CSS
+ * after the entry (`main.css`), after the package, or with a content hash. A lone CSS file is renamed; when
+ * there are several, they are concatenated in the order given.
+ *
+ * @param cssAssets - The CSS files the bundler emitted, in output order.
+ * @returns What to write as `styles.css` and which emitted files to drop.
+ */
+export declare function mergeCssAssets(cssAssets: readonly CssAsset[]): MergeCssAssetsResult;
+/**
+ * Resolves a path against the project root.
+ *
+ * @param path - The path, relative to the project root or absolute.
+ * @returns The absolute path.
+ */
+export declare function resolveFromRoot(path: string): string;
+/**
+ * Resolves where a plugin build writes its output, which entry point it builds and which vault a
+ * development build is deployed into.
+ *
+ * Loads the project's `.env` file first, so `OBSIDIAN_CONFIG_FOLDER` can live there.
+ *
+ * @param params - The {@link ResolveObsidianPluginBuildContextParams}.
+ * @returns A {@link Promise} that resolves to the {@link ObsidianPluginBuildContext}.
+ */
+export declare function resolveObsidianPluginBuildContext(params: ResolveObsidianPluginBuildContextParams): Promise<ObsidianPluginBuildContext>;

package/dist/lib/esm/bundlers/obsidian-plugin-build.mjs

@@ -0,0 +1,166 @@
+/*
+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();
+})();
+
+import { readPackageJson } from "@mnaoumov/typescript-dev-toolkit/npm";
+import { resolvePathFromRoot } from "@mnaoumov/typescript-dev-toolkit/root";
+import {
+  basename,
+  join
+} from "@mnaoumov/typescript-lib/path";
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import { existsSync } from "node:fs";
+import {
+  cp,
+  mkdir,
+  rm,
+  writeFile
+} from "node:fs/promises";
+import { builtinModules } from "node:module";
+import process, { loadEnvFile } from "node:process";
+import { ObsidianPluginRepoPaths } from "../obsidian-plugin-repo-paths.mjs";
+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,
+  ...builtinModules
+];
+const NODE_PREFIX = "node:";
+const STYLES_CSS_FILE_NAME = ObsidianPluginRepoPaths.StylesCss;
+const OBSIDIAN_PLUGIN_EXTERNALS_SET = new Set(OBSIDIAN_PLUGIN_EXTERNALS);
+async function cleanObsidianPluginDistFolder(distFolder) {
+  if (existsSync(distFolder)) {
+    await rm(distFolder, { recursive: true });
+  }
+  await mkdir(distFolder, { recursive: true });
+}
+async function completeObsidianPluginDistFolder(context) {
+  await mkdir(context.distFolder, { recursive: true });
+  if (!context.isProductionBuild && context.reload === "hot-reload-plugin") {
+    await writeFile(join(context.distFolder, ObsidianPluginRepoPaths.HotReload), "", "utf-8");
+  }
+  const manifestPath = resolvePathFromRoot({ path: ObsidianPluginRepoPaths.ManifestJson });
+  if (manifestPath && existsSync(manifestPath)) {
+    await cp(manifestPath, join(context.distFolder, 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 */ ? ObsidianPluginRepoPaths.DistBuild : ObsidianPluginRepoPaths.DistDev);
+}
+function getObsidianPluginEntryPoint() {
+  return resolveFromRoot(join(ObsidianPluginRepoPaths.Src, ObsidianPluginRepoPaths.MainTs));
+}
+function isCssFileName(fileName) {
+  return 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 ensureNonNullable(resolvePathFromRoot({ path }), `Could not resolve '${path}' against the project root`);
+}
+async function resolveObsidianPluginBuildContext(params) {
+  const envPath = resolvePathFromRoot({ path: ".env" });
+  if (envPath && existsSync(envPath)) {
+    loadEnvFile(envPath);
+  }
+  const obsidianPluginBuilderEnv = process.env;
+  const isProductionBuild = params.mode === 1 /* Production */;
+  const distFolder = params.distFolder === void 0 ? getObsidianPluginDistFolder(params.mode) : resolveFromRoot(params.distFolder);
+  const packageJson = await readPackageJson();
+  return {
+    distFolder,
+    entryPoint: getObsidianPluginEntryPoint(),
+    isProductionBuild,
+    mainJsPath: join(distFolder, ObsidianPluginRepoPaths.MainJs),
+    obsidianConfigFolder: params.obsidianConfigFolder ?? obsidianPluginBuilderEnv.OBSIDIAN_CONFIG_FOLDER ?? "",
+    pluginName: packageJson.name ?? "(unknown)",
+    reload: params.reload ?? "hot-reload-plugin"
+  };
+}
+export {
+  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"]}

package/dist/lib/esm/bundlers/obsidian-plugin-features.d.mts

@@ -0,0 +1,186 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * The build features every bundler adapter offers beside the plain plugin build: a UI framework, the stylesheet
+ * pipeline and WebAssembly. Every adapter takes the same {@link ObsidianPluginFeatureOptions}, so a project that
+ * switches bundler keeps its options and its installed packages.
+ *
+ * Each feature's packages are optional peer dependencies of the toolkit, imported from the PROJECT's own
+ * `node_modules` only when the feature is on, through {@link importOptionalPeer}.
+ *
+ * Erasable TypeScript only (no enums, no parameter properties): `obsidian-plugin-transforms.ts` imports this module,
+ * and a webpack loader or a parcel worker loads that one straight from source when the toolkit runs from source.
+ */
+/**
+ * Which shared transform a module goes through, as {@link getFeatureFileKind} tells it.
+ */
+export type FeatureFileKind = 'jsx' | 'stylesheet' | 'svelte' | 'wasm';
+/**
+ * Parameters for {@link getFrameworkDefines}.
+ */
+export interface GetFrameworkDefinesParams {
+    /**
+     * The UI framework, if any.
+     */
+    readonly framework: ObsidianPluginFramework | undefined;
+    /**
+     * Whether this is a production build.
+     */
+    readonly isProductionBuild: boolean;
+}
+/**
+ * Parameters for {@link importOptionalPeer}.
+ */
+export interface ImportOptionalPeerParams {
+    /**
+     * The option that needs the package, as the error message names it, e.g. `framework: 'solid'`.
+     */
+    readonly feature: string;
+    /**
+     * The package to install when it is missing.
+     */
+    readonly packageName: string;
+    /**
+     * The folder whose `node_modules` the package is resolved from. Defaults to the project root.
+     */
+    readonly projectFolder?: string;
+    /**
+     * The module to import. Defaults to {@link packageName}.
+     */
+    readonly specifier?: string;
+}
+/**
+ * The build features beside the plain plugin build. Every option is off unless set.
+ */
+export interface ObsidianPluginFeatureOptions {
+    /**
+     * The UI framework whose components the build compiles.
+     */
+    readonly framework?: ObsidianPluginFramework;
+    /**
+     * The stylesheet pipeline.
+     */
+    readonly styles?: ObsidianPluginStylesOptions;
+    /**
+     * Whether `import bytes from './module.wasm'` imports the module's bytes as a `Uint8Array`, inlined into `main.js`.
+     */
+    readonly wasm?: boolean;
+}
+/**
+ * A UI framework the bundler adapters compile.
+ *
+ * - `react` and `preact` compile JSX with the automatic runtime from `react` / `preact`.
+ * - `solid` compiles JSX with `babel-preset-solid`.
+ * - `svelte` compiles `.svelte` components and `.svelte.ts` / `.svelte.js` modules with the project's `svelte`.
+ * - `vue` compiles single-file components with `unplugin-vue` (on parcel, with `@parcel/transformer-vue`).
+ */
+export type ObsidianPluginFramework = 'preact' | 'react' | 'solid' | 'svelte' | 'vue';
+/**
+ * The stylesheet pipeline of {@link ObsidianPluginFeatureOptions}.
+ */
+export interface ObsidianPluginStylesOptions {
+    /**
+     * Whether a `*.module.css` file is a CSS module: its class names are scoped, and importing it gives the scoped
+     * names by their original ones.
+     */
+    readonly cssModules?: boolean;
+    /**
+     * Whether every stylesheet goes through the project's PostCSS configuration (`postcss.config.*`, `.postcssrc*`, or
+     * `postcss` in `package.json`).
+     */
+    readonly postcss?: boolean;
+    /**
+     * Whether every stylesheet goes through Tailwind CSS 4 (`@tailwindcss/postcss`), so `@import "tailwindcss";`
+     * expands to the utilities the sources use.
+     */
+    readonly tailwind?: boolean;
+}
+/**
+ * Parameters for {@link requireOptionalPeer}: the same as {@link ImportOptionalPeerParams}.
+ */
+export type RequireOptionalPeerParams = ImportOptionalPeerParams;
+/**
+ * Parameters for {@link resolveOptionalPeer}: the same as {@link ImportOptionalPeerParams}.
+ */
+export type ResolveOptionalPeerParams = ImportOptionalPeerParams;
+/**
+ * Tells which shared transform a module of a rollup-family build goes through, by its id.
+ *
+ * A virtual module (an id starting with `\0`) goes through none. A query is part of the match for a stylesheet, so a
+ * Vue component's `?vue&type=style&lang.css` block counts as one, and is cut off for the rest.
+ *
+ * @param id - The module id.
+ * @returns The kind of file, or `undefined` for a module no feature transforms.
+ */
+export declare function getFeatureFileKind(id: string): FeatureFileKind | undefined;
+/**
+ * Builds the compile-time constants a framework's runtime reads, which Obsidian's renderer does not define.
+ *
+ * `process.env.NODE_ENV` picks a runtime's production build (React, Preact's devtools, Vue, Solid), and without it a
+ * production plugin would bundle and run the development one. Vue also reads its three feature flags.
+ *
+ * @param params - The {@link GetFrameworkDefinesParams}.
+ * @returns The constants, by expression, each value a JavaScript literal. Empty when there is no framework.
+ */
+export declare function getFrameworkDefines(params: GetFrameworkDefinesParams): Record<string, string>;
+/**
+ * Tells which package supplies the automatic JSX runtime of a framework.
+ *
+ * @param framework - The UI framework, if any.
+ * @returns `react` or `preact`, or `undefined` for a framework that does not compile JSX with the automatic runtime.
+ */
+export declare function getJsxImportSource(framework: ObsidianPluginFramework | undefined): 'preact' | 'react' | undefined;
+/**
+ * Imports an optional peer dependency from the project's own `node_modules`.
+ *
+ * Resolved from the project rather than from the toolkit, so a package manager that does not hoist still finds what
+ * the project installed.
+ *
+ * @typeParam Module - The module's type.
+ * @param params - The {@link ImportOptionalPeerParams}.
+ * @returns A {@link Promise} that resolves to the module namespace.
+ * @throws If the project does not have the package, naming the option that needs it and the command that installs it.
+ */
+export declare function importOptionalPeer<Module>(params: ImportOptionalPeerParams): Promise<Module>;
+/**
+ * Tells whether a stylesheet is a CSS module by its file name.
+ *
+ * @param filePath - The stylesheet's path.
+ * @returns `true` for `*.module.css` (and `.module.pcss`, `.module.scss`, `.module.sass`).
+ */
+export declare function isCssModuleFile(filePath: string): boolean;
+/**
+ * Tells whether a stylesheet goes through PostCSS at all.
+ *
+ * @param styles - The stylesheet options, if any.
+ * @returns `true` when the project's PostCSS configuration or Tailwind applies.
+ */
+export declare function isPostcssNeeded(styles: ObsidianPluginStylesOptions | undefined): boolean;
+/**
+ * Replaces each compile-time constant in a module's code with its value, as a bundler's `define` does: only where
+ * the whole expression stands on its own, so `process.env.NODE_ENV` is replaced and `a.process.env.NODE_ENV` or
+ * `process.env.NODE_ENV_X` are not.
+ *
+ * @param code - The module's code.
+ * @param defines - The constants, by expression, each value a JavaScript literal.
+ * @returns The code with the constants replaced.
+ */
+export declare function replaceDefines(code: string, defines: Readonly<Record<string, string>>): string;
+/**
+ * Loads an optional peer dependency from the project's own `node_modules` synchronously, for a bundler whose plugins
+ * are applied synchronously (webpack). Loads an ES module too, through `require`.
+ *
+ * @param params - The {@link RequireOptionalPeerParams}.
+ * @returns The module, for the caller to type.
+ * @throws If the project does not have the package, naming the option that needs it and the command that installs it.
+ */
+export declare function requireOptionalPeer(params: RequireOptionalPeerParams): unknown;
+/**
+ * Resolves an optional peer dependency from the project's own `node_modules`.
+ *
+ * @param params - The {@link ResolveOptionalPeerParams}.
+ * @returns The absolute path of the module.
+ * @throws If the project does not have the package, naming the option that needs it and the command that installs it.
+ */
+export declare function resolveOptionalPeer(params: ResolveOptionalPeerParams): string;