@mnaoumov/obsidian-dev-toolkit 2.1.0 → 3.0.0

package/dist/lib/esm/bundlers/vite.mjs

@@ -0,0 +1,144 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import {
+  BuildMode,
+  cleanObsidianPluginDistFolder,
+  completeObsidianPluginDistFolder,
+  getObsidianPluginBanner,
+  resolveObsidianPluginBuildContext
+} from "./obsidian-plugin-build.mjs";
+import {
+  getFrameworkDefines,
+  getJsxImportSource,
+  isPostcssNeeded
+} from "./obsidian-plugin-features.mjs";
+import { loadPostcssConfig } from "./obsidian-plugin-transforms.mjs";
+import { deployToObsidianPluginsFolder } from "./obsidian-plugins-folder-deployment.mjs";
+import {
+  createRollupCompatibleFeaturePlugin,
+  createUnpluginVuePlugin
+} from "./rollup-compatible-features.mjs";
+import {
+  combineExternal,
+  renameCssAssets
+} from "./rollup-compatible.mjs";
+function getViteBuildMode(userConfig, env) {
+  return userConfig.build?.watch || env.mode === "development" ? BuildMode.Development : BuildMode.Production;
+}
+function getViteConfigDefaults(userConfig, buildContext) {
+  const build = userConfig.build ?? {};
+  const rolldownOptions = build.rolldownOptions ?? build.rollupOptions ?? {};
+  const output = Array.isArray(rolldownOptions.output) ? void 0 : rolldownOptions.output ?? {};
+  return {
+    build: {
+      // An Obsidian release ships `main.js` and `styles.css` and nothing else, so any asset emitted beside
+      // the bundle is a file the installed plugin looks for and does not find.
+      assetsInlineLimit: build.assetsInlineLimit ?? Number.MAX_SAFE_INTEGER,
+      // eslint-disable-next-line unicorn/name-replacements -- `emptyOutDir` is the name vite's config reads.
+      emptyOutDir: false,
+      lib: build.lib ?? {
+        cssFileName: "styles",
+        entry: buildContext.entryPoint,
+        fileName: () => "main.js",
+        formats: ["cjs"]
+      },
+      minify: build.minify ?? buildContext.isProductionBuild,
+      // eslint-disable-next-line unicorn/name-replacements -- `outDir` is the name vite's config reads.
+      outDir: buildContext.distFolder,
+      rolldownOptions: {
+        external: combineExternal(rolldownOptions.external),
+        ...output !== void 0 && {
+          output: {
+            // `postBanner` rather than `banner`: it is added after minification, which strips an ordinary comment.
+            ...output.banner === void 0 && output.postBanner === void 0 && { postBanner: getObsidianPluginBanner("vite") },
+            // An Obsidian plugin is one file: the manifest names `main.js` and nothing loads a second chunk.
+            // eslint-disable-next-line @typescript-eslint/no-deprecated -- A consumer's config may still set the deprecated option, which then wins.
+            ...output.codeSplitting === void 0 && output.inlineDynamicImports === void 0 && { codeSplitting: false }
+          }
+        }
+      },
+      sourcemap: build.sourcemap ?? (!buildContext.isProductionBuild && "inline")
+    }
+  };
+}
+function getViteFeatureConfig(params) {
+  const { features, isProductionBuild, postcssConfig, userConfig } = params;
+  const config = {};
+  const userDefine = userConfig.define ?? {};
+  const define = Object.fromEntries(
+    Object.entries(getFrameworkDefines({ framework: features.framework, isProductionBuild })).filter(([expression]) => !Object.hasOwn(userDefine, expression))
+  );
+  if (Object.keys(define).length > 0) {
+    config.define = define;
+  }
+  const jsxImportSource = getJsxImportSource(features.framework);
+  if (jsxImportSource !== void 0 && userConfig.oxc !== false && userConfig.oxc?.jsx === void 0) {
+    config.oxc = { jsx: { development: !isProductionBuild, importSource: jsxImportSource, runtime: "automatic" } };
+  }
+  if (postcssConfig && postcssConfig.plugins.length > 0 && userConfig.css?.postcss === void 0) {
+    config.css = { postcss: { plugins: [...postcssConfig.plugins] } };
+  }
+  return config;
+}
+function obsidianPluginVite(options = {}) {
+  const state = {
+    buildContext: void 0,
+    isDistFolderCleaned: false
+  };
+  function getBuildContext() {
+    if (!state.buildContext) {
+      throw new Error("The obsidian-plugin vite plugin has not resolved its build context: its `config` hook did not run.");
+    }
+    return state.buildContext;
+  }
+  const featurePlugin = createRollupCompatibleFeaturePlugin({
+    features: options,
+    isProductionBuild: () => getBuildContext().isProductionBuild,
+    shouldCompileStylesheets: false,
+    shouldReplaceDefines: false
+  });
+  const plugin = {
+    apply: "build",
+    async config(userConfig, env) {
+      state.buildContext = await resolveObsidianPluginBuildContext({
+        ...options,
+        ...userConfig.build?.outDir !== void 0 && { distFolder: userConfig.build.outDir },
+        mode: options.mode ?? getViteBuildMode(userConfig, env)
+      });
+      const { isProductionBuild } = state.buildContext;
+      const postcssConfig = isPostcssNeeded(options.styles) ? await loadPostcssConfig({ isProductionBuild, styles: options.styles ?? {} }) : void 0;
+      const featureConfig = getViteFeatureConfig({ features: options, isProductionBuild, postcssConfig, userConfig });
+      const config = getViteConfigDefaults(userConfig, state.buildContext);
+      return { ...featureConfig, ...config };
+    },
+    generateBundle: {
+      handler(_outputOptions, bundle) {
+        renameCssAssets(this, bundle);
+      },
+      order: "post"
+    },
+    name: "obsidian-plugin",
+    async renderStart() {
+      if (state.isDistFolderCleaned) {
+        return;
+      }
+      state.isDistFolderCleaned = true;
+      await cleanObsidianPluginDistFolder(getBuildContext().distFolder);
+    },
+    async writeBundle() {
+      await completeObsidianPluginDistFolder(getBuildContext());
+      await deployToObsidianPluginsFolder(getBuildContext());
+    }
+  };
+  return [plugin, { ...featurePlugin, apply: "build" }, createUnpluginVuePlugin({ bundler: "vite", features: options })];
+}
+export {
+  getViteBuildMode,
+  getViteConfigDefaults,
+  getViteFeatureConfig,
+  obsidianPluginVite
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/bundlers/vite.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Builds an Obsidian plugin with vite: a vite plugin that turns `vite build` into a library build of\n * `src/main.ts` with the same `main.js` + `styles.css` + `manifest.json` layout the esbuild builder\n * produces, deploys a `vite build --watch` build into the vault, and fills in only the options the\n * consumer's own `vite.config` leaves unset.\n *\n * `vite` is an optional peer dependency and this module only imports its types, so a plugin built with\n * esbuild installs nothing extra.\n */\n\nimport type {\n  ConfigEnv,\n  Plugin,\n  PluginOption,\n  UserConfig\n} from 'vite';\n\nimport type {\n  ObsidianPluginBuildContext,\n  ObsidianPluginDeploymentOptions\n} from './obsidian-plugin-build.ts';\nimport type { ObsidianPluginFeatureOptions } from './obsidian-plugin-features.ts';\nimport type { PostcssConfig } from './obsidian-plugin-transforms.ts';\nimport type {\n  AssetEmitter,\n  BundleOutputLike\n} from './rollup-compatible.ts';\n\nimport {\n  BuildMode,\n  cleanObsidianPluginDistFolder,\n  completeObsidianPluginDistFolder,\n  getObsidianPluginBanner,\n  resolveObsidianPluginBuildContext\n} from './obsidian-plugin-build.ts';\nimport {\n  getFrameworkDefines,\n  getJsxImportSource,\n  isPostcssNeeded\n} from './obsidian-plugin-features.ts';\nimport { loadPostcssConfig } from './obsidian-plugin-transforms.ts';\nimport { deployToObsidianPluginsFolder } from './obsidian-plugins-folder-deployment.ts';\nimport {\n  createRollupCompatibleFeaturePlugin,\n  createUnpluginVuePlugin\n} from './rollup-compatible-features.ts';\nimport {\n  combineExternal,\n  renameCssAssets\n} from './rollup-compatible.ts';\n\n/**\n * Parameters for {@link getViteFeatureConfig}.\n */\nexport interface GetViteFeatureConfigParams {\n  /**\n   * The build features.\n   */\n  readonly features: ObsidianPluginFeatureOptions;\n\n  /**\n   * Whether this is a production build.\n   */\n  readonly isProductionBuild: boolean;\n\n  /**\n   * The PostCSS plugins of the `styles` option, or `undefined` when it needs none.\n   */\n  readonly postcssConfig: PostcssConfig | undefined;\n\n  /**\n   * The consumer's vite config.\n   */\n  readonly userConfig: UserConfig;\n}\n\n/**\n * Options for {@link obsidianPluginVite}.\n */\nexport interface ObsidianPluginViteOptions extends ObsidianPluginDeploymentOptions, ObsidianPluginFeatureOptions {\n  /**\n   * The build mode. Defaults to {@link BuildMode.Development} for `vite build --watch` (or\n   * `--mode development`) and {@link BuildMode.Production} otherwise.\n   */\n  readonly mode?: BuildMode;\n}\n\n/**\n * The state one {@link obsidianPluginVite} instance keeps across the hooks of a build, and across the\n * rebuilds of a watch.\n */\ninterface ObsidianPluginViteState {\n  buildContext: ObsidianPluginBuildContext | undefined;\n  isDistFolderCleaned: boolean;\n}\n\n/**\n * Decides the build mode of a vite build from the consumer's config: development for a watch build or for\n * `--mode development`, production otherwise.\n *\n * @param userConfig - The consumer's vite config.\n * @param env - The vite config environment.\n * @returns The build mode.\n */\nexport function getViteBuildMode(userConfig: UserConfig, env: Pick<ConfigEnv, 'mode'>): BuildMode {\n  return userConfig.build?.watch || env.mode === 'development' ? BuildMode.Development : BuildMode.Production;\n}\n\n/**\n * Builds the part of the vite config the plugin contributes: only the options the consumer left unset.\n *\n * @param userConfig - The consumer's vite config.\n * @param buildContext - The build context.\n * @returns The config vite merges into the consumer's.\n */\nexport function getViteConfigDefaults(userConfig: UserConfig, buildContext: ObsidianPluginBuildContext): UserConfig {\n  const build = userConfig.build ?? {};\n  // eslint-disable-next-line @typescript-eslint/no-deprecated -- A consumer's config may still use the deprecated alias, and vite still honors it.\n  const rolldownOptions = build.rolldownOptions ?? build.rollupOptions ?? {};\n  const output = Array.isArray(rolldownOptions.output) ? undefined : rolldownOptions.output ?? {};\n\n  return {\n    build: {\n      // An Obsidian release ships `main.js` and `styles.css` and nothing else, so any asset emitted beside\n      // the bundle is a file the installed plugin looks for and does not find.\n      assetsInlineLimit: build.assetsInlineLimit ?? Number.MAX_SAFE_INTEGER,\n      // eslint-disable-next-line unicorn/name-replacements -- `emptyOutDir` is the name vite's config reads.\n      emptyOutDir: false,\n      lib: build.lib ?? {\n        cssFileName: 'styles',\n        entry: buildContext.entryPoint,\n        fileName: (): string => 'main.js',\n        formats: ['cjs']\n      },\n      minify: build.minify ?? buildContext.isProductionBuild,\n      // eslint-disable-next-line unicorn/name-replacements -- `outDir` is the name vite's config reads.\n      outDir: buildContext.distFolder,\n      rolldownOptions: {\n        external: combineExternal(rolldownOptions.external),\n        ...(output !== undefined && {\n          output: {\n            // `postBanner` rather than `banner`: it is added after minification, which strips an ordinary comment.\n            ...(output.banner === undefined && output.postBanner === undefined && { postBanner: getObsidianPluginBanner('vite') }),\n            // An Obsidian plugin is one file: the manifest names `main.js` and nothing loads a second chunk.\n            // eslint-disable-next-line @typescript-eslint/no-deprecated -- A consumer's config may still set the deprecated option, which then wins.\n            ...(output.codeSplitting === undefined && output.inlineDynamicImports === undefined && { codeSplitting: false })\n          }\n        })\n      },\n      sourcemap: build.sourcemap ?? (!buildContext.isProductionBuild && 'inline')\n    }\n  };\n}\n\n/**\n * Builds the part of the vite config the build features contribute, each only where the consumer's config left it\n * unset: the framework's compile-time constants (`define`), the automatic JSX runtime for React and Preact\n * (`oxc.jsx`), and the PostCSS plugins of the `styles` option (`css.postcss`).\n *\n * @param params - The {@link GetViteFeatureConfigParams}.\n * @returns The config vite merges into the consumer's.\n */\nexport function getViteFeatureConfig(params: GetViteFeatureConfigParams): UserConfig {\n  const { features, isProductionBuild, postcssConfig, userConfig } = params;\n  const config: UserConfig = {};\n\n  const userDefine = userConfig.define ?? {};\n  const define = Object.fromEntries(\n    Object.entries(getFrameworkDefines({ framework: features.framework, isProductionBuild })).filter(([expression]) => !Object.hasOwn(userDefine, expression))\n  );\n  if (Object.keys(define).length > 0) {\n    config.define = define;\n  }\n\n  const jsxImportSource = getJsxImportSource(features.framework);\n  if (jsxImportSource !== undefined && userConfig.oxc !== false && userConfig.oxc?.jsx === undefined) {\n    config.oxc = { jsx: { development: !isProductionBuild, importSource: jsxImportSource, runtime: 'automatic' } };\n  }\n\n  if (postcssConfig && postcssConfig.plugins.length > 0 && userConfig.css?.postcss === undefined) {\n    config.css = { postcss: { plugins: [...postcssConfig.plugins] } };\n  }\n  return config;\n}\n\n/**\n * Creates a vite plugin that builds an Obsidian plugin.\n *\n * What it does, each only when the consumer's config has not said otherwise:\n *\n * - `build.lib` builds `src/main.ts` as one CommonJS `main.js`, with its CSS in `styles.css`.\n * - `build.outDir` is `dist/build` (`dist/dev` in development).\n * - `build.minify` is on in production only, and `build.sourcemap` is inline in development only.\n * - Every asset is inlined, because an Obsidian release ships `main.js` and `styles.css` and nothing else.\n * - Dynamic imports are inlined into `main.js`, and the generated-file banner heads it.\n *\n * And always: Obsidian's own modules (`obsidian`, `electron`, CodeMirror, Lezer) and the Node builtins are\n * external beside the consumer's own `external`, the output folder is emptied once before the first write\n * (`build.emptyOutDir` is turned off, since this plugin does it), every emitted CSS file ends up in\n * `styles.css`, `manifest.json` (and in development `.hotreload`) is copied beside it, and a development\n * build is deployed into the vault named by `OBSIDIAN_CONFIG_FOLDER`.\n *\n * The build features ({@link ObsidianPluginFeatureOptions}):\n *\n * - `framework: 'react' | 'preact'` sets `oxc.jsx` to the automatic runtime (unless set).\n * - `framework: 'solid' | 'svelte'` compiles the components with the toolkit's shared transforms, and `'vue'` adds\n *   `unplugin-vue`.\n * - Any framework defines `process.env.NODE_ENV` (and Vue's feature flags), which a library build leaves alone.\n * - `styles.postcss` and `styles.tailwind` set `css.postcss` (unless set); vite scopes `*.module.css` itself, so\n *   `styles.cssModules` changes nothing here.\n * - `wasm` imports a `.wasm` module as its bytes.\n *\n * @param options - The {@link ObsidianPluginViteOptions}.\n * @returns The vite plugins, which vite takes as one entry of its `plugins`.\n */\nexport function obsidianPluginVite(options: ObsidianPluginViteOptions = {}): PluginOption[] {\n  const state: ObsidianPluginViteState = {\n    buildContext: undefined,\n    isDistFolderCleaned: false\n  };\n\n  /* v8 ignore start -- Vite hooks; exercised by the bundler integration test against a real vite build. */\n  function getBuildContext(): ObsidianPluginBuildContext {\n    if (!state.buildContext) {\n      throw new Error('The obsidian-plugin vite plugin has not resolved its build context: its `config` hook did not run.');\n    }\n    return state.buildContext;\n  }\n\n  const featurePlugin = createRollupCompatibleFeaturePlugin({\n    features: options,\n    isProductionBuild: () => getBuildContext().isProductionBuild,\n    shouldCompileStylesheets: false,\n    shouldReplaceDefines: false\n  });\n\n  const plugin = {\n    apply: 'build',\n    async config(userConfig: UserConfig, env: ConfigEnv): Promise<UserConfig> {\n      state.buildContext = await resolveObsidianPluginBuildContext({\n        ...options,\n        ...(userConfig.build?.outDir !== undefined && { distFolder: userConfig.build.outDir }),\n        mode: options.mode ?? getViteBuildMode(userConfig, env)\n      });\n      const { isProductionBuild } = state.buildContext;\n      const postcssConfig = isPostcssNeeded(options.styles)\n        ? await loadPostcssConfig({ isProductionBuild, styles: options.styles ?? {} })\n        : undefined;\n      const featureConfig = getViteFeatureConfig({ features: options, isProductionBuild, postcssConfig, userConfig });\n      const config = getViteConfigDefaults(userConfig, state.buildContext);\n      return { ...featureConfig, ...config };\n    },\n    generateBundle: {\n      handler(this: AssetEmitter, _outputOptions: unknown, bundle: Record<string, BundleOutputLike>): void {\n        renameCssAssets(this, bundle);\n      },\n      order: 'post'\n    },\n    name: 'obsidian-plugin',\n    async renderStart(): Promise<void> {\n      if (state.isDistFolderCleaned) {\n        return;\n      }\n      state.isDistFolderCleaned = true;\n      await cleanObsidianPluginDistFolder(getBuildContext().distFolder);\n    },\n    async writeBundle(): Promise<void> {\n      await completeObsidianPluginDistFolder(getBuildContext());\n      await deployToObsidianPluginsFolder(getBuildContext());\n    }\n  } as Plugin;\n  return [plugin, { ...featurePlugin, apply: 'build' } as Plugin, createUnpluginVuePlugin({ bundler: 'vite', features: options }) as Promise<null | Plugin>];\n  /* v8 ignore stop */\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/bundlers/webpack.d.mts

@@ -0,0 +1,133 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Builds an Obsidian plugin with webpack: a webpack plugin that gives a build the same `main.js` +
+ * `styles.css` + `manifest.json` layout the esbuild builder produces, deploys a watch build into the vault,
+ * and fills in only the options the consumer's own `webpack.config` leaves unset.
+ *
+ * `webpack` is an optional peer dependency. This module only imports its types and reaches webpack's
+ * classes through `compiler.webpack`, so a plugin built with esbuild installs nothing extra.
+ */
+import type { Compiler, RuleSetRule, WebpackOptionsNormalized, WebpackPluginInstance } from 'webpack';
+import type { ObsidianPluginDeploymentOptions } from './obsidian-plugin-build.mjs';
+import type { ObsidianPluginFeatureOptions } from './obsidian-plugin-features.mjs';
+import { BuildMode } from './obsidian-plugin-build.mjs';
+/**
+ * Parameters for {@link getWebpackFeatureRules}.
+ */
+export interface GetWebpackFeatureRulesParams {
+    /**
+     * The path of `css-loader`, for the stylesheet rule.
+     */
+    readonly cssLoaderPath: string;
+    /**
+     * The build features.
+     */
+    readonly features: ObsidianPluginFeatureOptions;
+    /**
+     * Whether this is a production build.
+     */
+    readonly isProductionBuild: boolean;
+    /**
+     * The path of the toolkit's own loader.
+     */
+    readonly loaderPath: string;
+    /**
+     * The path of `mini-css-extract-plugin`'s loader, for the stylesheet rule.
+     */
+    readonly miniCssExtractLoaderPath: string;
+}
+/**
+ * Options for {@link ObsidianPluginWebpackPlugin}.
+ */
+export interface ObsidianPluginWebpackPluginOptions extends ObsidianPluginDeploymentOptions, ObsidianPluginFeatureOptions {
+    /**
+     * The build mode. Defaults to {@link BuildMode.Development} when webpack watches (`webpack --watch`) or
+     * its `mode` is `development`, and {@link BuildMode.Production} otherwise.
+     */
+    readonly mode?: BuildMode;
+}
+/**
+ * The callback webpack's function form of `externals` takes.
+ */
+type ExternalsCallback = (error?: Error | null, result?: string) => void;
+/**
+ * The argument webpack's function form of `externals` receives.
+ */
+interface ExternalsData {
+    readonly request?: string;
+}
+/**
+ * A webpack plugin that builds an Obsidian plugin.
+ *
+ * What it does, each only when the consumer's config has not said otherwise:
+ *
+ * - `entry` is `src/main.ts`, and `mode` follows the build mode.
+ * - The output is one CommonJS (`commonjs2`) `main.js` in `dist/build` (`dist/dev` in development), with no
+ *   async chunks, so a dynamic import cannot become a sibling file.
+ * - `target` is `node`, which is what Obsidian's renderer runs, so Node builtins resolve, while the export
+ *   conditions are the browser's (`browser`, `webpack`, the mode, `module`, `import`, `require`, and never `node`),
+ *   so packages hand over their browser builds, as on mobile they must.
+ * - `devtool` is an inline source map in development only.
+ *
+ * And always: Obsidian's own modules (`obsidian`, `electron`, CodeMirror, Lezer) and the Node builtins are
+ * external beside the consumer's own `externals`, the generated-file banner heads `main.js`, license
+ * comments a minimizer extracted into `main.js.LICENSE.txt` (which no Obsidian release ships) are put back
+ * into `main.js`, the output folder is emptied before the first build, every emitted CSS file ends up in
+ * `styles.css`, `manifest.json` (and in development `.hotreload`) is copied beside it, and a development
+ * build is deployed into the vault named by `OBSIDIAN_CONFIG_FOLDER`.
+ *
+ * TypeScript stays the consumer's choice of loader, as it would be without this plugin. The build features
+ * ({@link ObsidianPluginFeatureOptions}) are the plugin's:
+ *
+ * - `framework: 'react' | 'preact'` needs nothing here: the TypeScript loader reads the automatic JSX runtime from the
+ *   toolkit's tsconfig preset, and webpack's `mode` defines `process.env.NODE_ENV`.
+ * - `framework: 'solid' | 'svelte'` adds rules that compile the components with the toolkit's shared transforms, and
+ *   `'vue'` applies `unplugin-vue` and defines Vue's feature flags.
+ * - `styles` adds the one rule every stylesheet goes through (PostCSS and Tailwind, then `css-loader`, scoping
+ *   `*.module.css` only with `cssModules`, then `mini-css-extract-plugin`), and applies `mini-css-extract-plugin`
+ *   unless the config already does; leave your own `.css` rule out. `styles: {}` compiles plain CSS.
+ * - `wasm` imports a `.wasm` module as its bytes.
+ */
+export declare class ObsidianPluginWebpackPlugin implements WebpackPluginInstance {
+    private readonly options;
+    /**
+     * Creates the plugin.
+     *
+     * @param options - The {@link ObsidianPluginWebpackPluginOptions}.
+     */
+    constructor(options?: ObsidianPluginWebpackPluginOptions);
+    /**
+     * Applies the plugin to a webpack compiler.
+     *
+     * @param compiler - The webpack compiler.
+     */
+    apply(compiler: Compiler): void;
+}
+/**
+ * Decides the build mode of a webpack build from the consumer's config: development when webpack watches
+ * or its `mode` is `development`, production otherwise.
+ *
+ * @param options - The normalized webpack options.
+ * @returns The build mode.
+ */
+export declare function getWebpackBuildMode(options: Pick<WebpackOptionsNormalized, 'mode' | 'watch'>): BuildMode;
+/**
+ * Builds the module rules the build features add, each running the toolkit's own loader: Solid's JSX before the
+ * project's TypeScript loader, Svelte components and modules, `.wasm` modules as JavaScript, and with `styles` the
+ * stylesheet rule.
+ *
+ * @param params - The {@link GetWebpackFeatureRulesParams}.
+ * @returns The rules, empty when no feature needs one.
+ */
+export declare function getWebpackFeatureRules(params: GetWebpackFeatureRulesParams): RuleSetRule[];
+/**
+ * Tells webpack's function form of `externals` to leave Obsidian's modules and the Node builtins to
+ * `require()`.
+ *
+ * @param data - The request webpack is resolving.
+ * @param callback - The callback to answer through.
+ */
+export declare function obsidianPluginWebpackExternals(data: ExternalsData, callback: ExternalsCallback): void;
+export {};

package/dist/lib/esm/bundlers/webpack.mjs

@@ -0,0 +1,259 @@
+/*
+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 { extractDefaultExportInterop } from "@mnaoumov/typescript-lib/object-utils";
+import { extname } from "@mnaoumov/typescript-lib/path";
+import { fileURLToPath } from "node:url";
+import { ObsidianPluginRepoPaths } from "../obsidian-plugin-repo-paths.mjs";
+import {
+  BuildMode,
+  cleanObsidianPluginDistFolder,
+  completeObsidianPluginDistFolder,
+  getObsidianPluginBanner,
+  getObsidianPluginDistFolder,
+  getObsidianPluginEntryPoint,
+  isCssFileName,
+  isObsidianPluginExternal,
+  mergeCssAssets,
+  resolveObsidianPluginBuildContext
+} from "./obsidian-plugin-build.mjs";
+import {
+  getFrameworkDefines,
+  isPostcssNeeded,
+  requireOptionalPeer,
+  resolveOptionalPeer
+} from "./obsidian-plugin-features.mjs";
+import { deployToObsidianPluginsFolder } from "./obsidian-plugins-folder-deployment.mjs";
+const PLUGIN_NAME = "ObsidianPluginWebpackPlugin";
+const MINI_CSS_EXTRACT_PLUGIN = "mini-css-extract-plugin";
+class ObsidianPluginWebpackPlugin {
+  /**
+   * Creates the plugin.
+   *
+   * @param options - The {@link ObsidianPluginWebpackPluginOptions}.
+   */
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  /* v8 ignore start -- Webpack hooks; exercised by the bundler integration test against a real webpack build. */
+  /**
+   * Applies the plugin to a webpack compiler.
+   *
+   * @param compiler - The webpack compiler.
+   */
+  apply(compiler) {
+    const mode = this.options.mode ?? getWebpackBuildMode(compiler.options);
+    applyWebpackOptionDefaults(compiler.options, mode);
+    applyWebpackFeatures(compiler, this.options, mode === BuildMode.Production);
+    new compiler.webpack.BannerPlugin({
+      banner: getObsidianPluginBanner("webpack"),
+      raw: true,
+      stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_REPORT,
+      test: /\.js$/u
+    }).apply(compiler);
+    const buildContextPromise = resolveObsidianPluginBuildContext({
+      ...this.options,
+      ...compiler.options.output.path !== void 0 && { distFolder: compiler.options.output.path },
+      mode
+    });
+    let isDistFolderCleaned = false;
+    async function prepare() {
+      const buildContext = await buildContextPromise;
+      if (isDistFolderCleaned) {
+        return;
+      }
+      isDistFolderCleaned = true;
+      await cleanObsidianPluginDistFolder(buildContext.distFolder);
+    }
+    compiler.hooks.beforeRun.tapPromise(PLUGIN_NAME, prepare);
+    compiler.hooks.watchRun.tapPromise(PLUGIN_NAME, prepare);
+    compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+      compilation.hooks.processAssets.tap(
+        { name: PLUGIN_NAME, stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE },
+        () => {
+          renameWebpackCssAssets(compilation, compiler);
+          inlineExtractedLicenses(compilation, compiler);
+        }
+      );
+    });
+    compiler.hooks.afterEmit.tapPromise(PLUGIN_NAME, async (compilation) => {
+      if (compilation.getStats().hasErrors()) {
+        return;
+      }
+      const buildContext = await buildContextPromise;
+      await completeObsidianPluginDistFolder(buildContext);
+      await deployToObsidianPluginsFolder(buildContext);
+    });
+  }
+  /* v8 ignore stop */
+}
+function getWebpackBuildMode(options) {
+  return options.watch || options.mode === "development" ? BuildMode.Development : BuildMode.Production;
+}
+function getWebpackFeatureRules(params) {
+  const { cssLoaderPath, features, isProductionBuild, loaderPath, miniCssExtractLoaderPath } = params;
+  const rules = [];
+  function featureLoader(kind, styles) {
+    const options = { isProductionBuild, kind, ...styles && { styles } };
+    return [{ loader: loaderPath, options }];
+  }
+  switch (features.framework) {
+    case "solid": {
+      rules.push({ enforce: "pre", test: /\.[jt]sx$/iu, use: featureLoader("jsx") });
+      break;
+    }
+    case "svelte": {
+      rules.push(
+        { test: /\.svelte$/iu, use: featureLoader("svelte") },
+        { enforce: "pre", test: /\.svelte\.[cm]?[jt]s$/iu, use: featureLoader("svelte") }
+      );
+      break;
+    }
+    case "vue": {
+      rules.push({ enforce: "post", test: /\.vue(?:\?|%3F).*lang\.ts$/iu, use: featureLoader("typescript") });
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+  if (features.wasm) {
+    rules.push({ test: /\.wasm$/iu, type: "javascript/auto", use: featureLoader("wasm") });
+  }
+  if (features.styles) {
+    rules.push({
+      test: /\.p?css$/iu,
+      use: [
+        miniCssExtractLoaderPath,
+        {
+          loader: cssLoaderPath,
+          options: {
+            importLoaders: 1,
+            modules: features.styles.cssModules ? { auto: true, namedExport: false } : false
+          }
+        },
+        ...isPostcssNeeded(features.styles) ? featureLoader("stylesheet", features.styles) : []
+      ]
+    });
+  }
+  return rules;
+}
+function obsidianPluginWebpackExternals(data, callback) {
+  if (data.request !== void 0 && isObsidianPluginExternal(data.request)) {
+    callback(null, `commonjs2 ${data.request}`);
+    return;
+  }
+  callback();
+}
+function applyWebpackFeatures(compiler, features, isProductionBuild) {
+  let miniCssExtractLoaderPath = "";
+  let cssLoaderPath = "";
+  if (features.styles) {
+    const stylesFeature = "styles";
+    cssLoaderPath = resolveOptionalPeer({ feature: stylesFeature, packageName: "css-loader" });
+    const MiniCssExtractPlugin = extractDefaultExportInterop(
+      requireOptionalPeer({ feature: stylesFeature, packageName: MINI_CSS_EXTRACT_PLUGIN })
+    );
+    miniCssExtractLoaderPath = MiniCssExtractPlugin.loader;
+    const hasMiniCssExtractPlugin = compiler.options.plugins.some((plugin) => plugin.constructor.name === "MiniCssExtractPlugin");
+    if (!hasMiniCssExtractPlugin) {
+      new MiniCssExtractPlugin().apply(compiler);
+    }
+  }
+  const loaderPath = fileURLToPath(new URL(`obsidian-plugin-webpack-loader${extname(fileURLToPath(import.meta.url))}`, import.meta.url));
+  compiler.options.module.rules.push(...getWebpackFeatureRules({ cssLoaderPath, features, isProductionBuild, loaderPath, miniCssExtractLoaderPath }));
+  if (features.framework !== "vue") {
+    return;
+  }
+  const unpluginVue = extractDefaultExportInterop(
+    requireOptionalPeer({ feature: "framework: 'vue'", packageName: "unplugin-vue", specifier: "unplugin-vue/webpack" })
+  );
+  unpluginVue().apply(compiler);
+  const { "process.env.NODE_ENV": _nodeEnv, ...vueFlags } = getFrameworkDefines({ framework: features.framework, isProductionBuild });
+  new compiler.webpack.DefinePlugin(vueFlags).apply(compiler);
+}
+function applyWebpackOptionDefaults(options, mode) {
+  const isProductionBuild = mode === BuildMode.Production;
+  options.mode ??= isProductionBuild ? "production" : "development";
+  options.target ??= "node";
+  options.devtool ??= !isProductionBuild && "inline-source-map";
+  if (typeof options.entry === "object" && Object.keys(options.entry).length === 1 && options.entry["main"]?.import === void 0) {
+    options.entry = { main: { import: [getObsidianPluginEntryPoint()] } };
+  }
+  options.output.path ??= getObsidianPluginDistFolder(mode);
+  options.output.filename ??= ObsidianPluginRepoPaths.MainJs;
+  options.output.library ??= { type: "commonjs2" };
+  options.output.asyncChunks ??= false;
+  options.resolve.conditionNames ??= ["browser", "webpack", isProductionBuild ? "production" : "development", "module", "import", "require"];
+  const userExternals = options.externals;
+  options.externals = [obsidianPluginWebpackExternals, ...Array.isArray(userExternals) ? userExternals : [userExternals]];
+}
+function inlineExtractedLicenses(compilation, compiler) {
+  const LICENSE_SUFFIX = ".LICENSE.txt";
+  for (const licenseAsset of compilation.getAssets()) {
+    if (!licenseAsset.name.endsWith(LICENSE_SUFFIX)) {
+      continue;
+    }
+    const sourceFileName = licenseAsset.name.slice(0, -LICENSE_SUFFIX.length);
+    const sourceAsset = compilation.getAsset(sourceFileName);
+    if (!sourceAsset) {
+      continue;
+    }
+    const licenseFileName = licenseAsset.name.split("/").at(-1) ?? licenseAsset.name;
+    const reference = `/*! For license information please see ${licenseFileName} */`;
+    const source = sourceAsset.source.source().toString();
+    const licenses = licenseAsset.source.source().toString().trimEnd();
+    const updatedSource = source.includes(reference) ? source.replace(reference, () => licenses) : `${licenses}
+${source}`;
+    compilation.updateAsset(sourceFileName, new compiler.webpack.sources.RawSource(updatedSource));
+    compilation.deleteAsset(licenseAsset.name);
+  }
+}
+function renameWebpackCssAssets(compilation, compiler) {
+  const cssAssets = compilation.getAssets().filter((asset) => isCssFileName(asset.name)).map((asset) => ({ fileName: asset.name, source: asset.source.source().toString() }));
+  const { fileNamesToRemove, stylesCss } = mergeCssAssets(cssAssets);
+  if (stylesCss === void 0) {
+    return;
+  }
+  for (const fileName of fileNamesToRemove) {
+    compilation.deleteAsset(fileName);
+  }
+  compilation.emitAsset(ObsidianPluginRepoPaths.StylesCss, new compiler.webpack.sources.RawSource(stylesCss));
+}
+export {
+  ObsidianPluginWebpackPlugin,
+  getWebpackBuildMode,
+  getWebpackFeatureRules,
+  obsidianPluginWebpackExternals
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/bundlers/webpack.ts"],"sourcesContent":["/**\n * @file\n *\n * Builds an Obsidian plugin with webpack: a webpack plugin that gives a build the same `main.js` +\n * `styles.css` + `manifest.json` layout the esbuild builder produces, deploys a watch build into the vault,\n * and fills in only the options the consumer's own `webpack.config` leaves unset.\n *\n * `webpack` is an optional peer dependency. This module only imports its types and reaches webpack's\n * classes through `compiler.webpack`, so a plugin built with esbuild installs nothing extra.\n */\n\nimport type {\n  Compilation,\n  Compiler,\n  RuleSetRule,\n  RuleSetUseItem,\n  WebpackOptionsNormalized,\n  WebpackPluginInstance\n} from 'webpack';\n\nimport { extractDefaultExportInterop } from '@mnaoumov/typescript-lib/object-utils';\nimport { extname } from '@mnaoumov/typescript-lib/path';\nimport { fileURLToPath } from 'node:url';\n\nimport type { ObsidianPluginDeploymentOptions } from './obsidian-plugin-build.ts';\nimport type {\n  ObsidianPluginFeatureOptions,\n  ObsidianPluginStylesOptions\n} from './obsidian-plugin-features.ts';\nimport type { ObsidianPluginWebpackLoaderOptions } from './obsidian-plugin-webpack-loader.ts';\n\nimport { ObsidianPluginRepoPaths } from '../obsidian-plugin-repo-paths.ts';\nimport {\n  BuildMode,\n  cleanObsidianPluginDistFolder,\n  completeObsidianPluginDistFolder,\n  getObsidianPluginBanner,\n  getObsidianPluginDistFolder,\n  getObsidianPluginEntryPoint,\n  isCssFileName,\n  isObsidianPluginExternal,\n  mergeCssAssets,\n  resolveObsidianPluginBuildContext\n} from './obsidian-plugin-build.ts';\nimport {\n  getFrameworkDefines,\n  isPostcssNeeded,\n  requireOptionalPeer,\n  resolveOptionalPeer\n} from './obsidian-plugin-features.ts';\nimport { deployToObsidianPluginsFolder } from './obsidian-plugins-folder-deployment.ts';\n\n/**\n * Parameters for {@link getWebpackFeatureRules}.\n */\nexport interface GetWebpackFeatureRulesParams {\n  /**\n   * The path of `css-loader`, for the stylesheet rule.\n   */\n  readonly cssLoaderPath: string;\n\n  /**\n   * The build features.\n   */\n  readonly features: ObsidianPluginFeatureOptions;\n\n  /**\n   * Whether this is a production build.\n   */\n  readonly isProductionBuild: boolean;\n\n  /**\n   * The path of the toolkit's own loader.\n   */\n  readonly loaderPath: string;\n\n  /**\n   * The path of `mini-css-extract-plugin`'s loader, for the stylesheet rule.\n   */\n  readonly miniCssExtractLoaderPath: string;\n}\n\n/**\n * Options for {@link ObsidianPluginWebpackPlugin}.\n */\nexport interface ObsidianPluginWebpackPluginOptions extends ObsidianPluginDeploymentOptions, ObsidianPluginFeatureOptions {\n  /**\n   * The build mode. Defaults to {@link BuildMode.Development} when webpack watches (`webpack --watch`) or\n   * its `mode` is `development`, and {@link BuildMode.Production} otherwise.\n   */\n  readonly mode?: BuildMode;\n}\n\n/**\n * The callback webpack's function form of `externals` takes.\n */\ntype ExternalsCallback = (error?: Error | null, result?: string) => void;\n\n/**\n * The argument webpack's function form of `externals` receives.\n */\ninterface ExternalsData {\n  readonly request?: string;\n}\n\n/**\n * The `mini-css-extract-plugin` class.\n */\ninterface MiniCssExtractPluginClass {\n  readonly loader: string;\n  new (): WebpackPluginInstance;\n}\n\n/**\n * The part of `mini-css-extract-plugin` the adapter uses.\n */\ninterface MiniCssExtractPluginModule {\n  readonly default: MiniCssExtractPluginClass;\n}\n\n/**\n * The part of `unplugin-vue/webpack` the adapter uses.\n */\ninterface UnpluginVueWebpackModule {\n  readonly default: () => WebpackPluginInstance;\n}\n\nconst PLUGIN_NAME = 'ObsidianPluginWebpackPlugin';\nconst MINI_CSS_EXTRACT_PLUGIN = 'mini-css-extract-plugin';\n\n/**\n * A webpack plugin that builds an Obsidian plugin.\n *\n * What it does, each only when the consumer's config has not said otherwise:\n *\n * - `entry` is `src/main.ts`, and `mode` follows the build mode.\n * - The output is one CommonJS (`commonjs2`) `main.js` in `dist/build` (`dist/dev` in development), with no\n *   async chunks, so a dynamic import cannot become a sibling file.\n * - `target` is `node`, which is what Obsidian's renderer runs, so Node builtins resolve, while the export\n *   conditions are the browser's (`browser`, `webpack`, the mode, `module`, `import`, `require`, and never `node`),\n *   so packages hand over their browser builds, as on mobile they must.\n * - `devtool` is an inline source map in development only.\n *\n * And always: Obsidian's own modules (`obsidian`, `electron`, CodeMirror, Lezer) and the Node builtins are\n * external beside the consumer's own `externals`, the generated-file banner heads `main.js`, license\n * comments a minimizer extracted into `main.js.LICENSE.txt` (which no Obsidian release ships) are put back\n * into `main.js`, the output folder is emptied before the first build, every emitted CSS file ends up in\n * `styles.css`, `manifest.json` (and in development `.hotreload`) is copied beside it, and a development\n * build is deployed into the vault named by `OBSIDIAN_CONFIG_FOLDER`.\n *\n * TypeScript stays the consumer's choice of loader, as it would be without this plugin. The build features\n * ({@link ObsidianPluginFeatureOptions}) are the plugin's:\n *\n * - `framework: 'react' | 'preact'` needs nothing here: the TypeScript loader reads the automatic JSX runtime from the\n *   toolkit's tsconfig preset, and webpack's `mode` defines `process.env.NODE_ENV`.\n * - `framework: 'solid' | 'svelte'` adds rules that compile the components with the toolkit's shared transforms, and\n *   `'vue'` applies `unplugin-vue` and defines Vue's feature flags.\n * - `styles` adds the one rule every stylesheet goes through (PostCSS and Tailwind, then `css-loader`, scoping\n *   `*.module.css` only with `cssModules`, then `mini-css-extract-plugin`), and applies `mini-css-extract-plugin`\n *   unless the config already does; leave your own `.css` rule out. `styles: {}` compiles plain CSS.\n * - `wasm` imports a `.wasm` module as its bytes.\n */\nexport class ObsidianPluginWebpackPlugin implements WebpackPluginInstance {\n  /**\n   * Creates the plugin.\n   *\n   * @param options - The {@link ObsidianPluginWebpackPluginOptions}.\n   */\n  public constructor(private readonly options: ObsidianPluginWebpackPluginOptions = {}) {}\n\n  /* v8 ignore start -- Webpack hooks; exercised by the bundler integration test against a real webpack build. */\n  /**\n   * Applies the plugin to a webpack compiler.\n   *\n   * @param compiler - The webpack compiler.\n   */\n  public apply(compiler: Compiler): void {\n    const mode = this.options.mode ?? getWebpackBuildMode(compiler.options);\n    applyWebpackOptionDefaults(compiler.options, mode);\n    applyWebpackFeatures(compiler, this.options, mode === BuildMode.Production);\n    // Added at the report stage, after minification, which would otherwise strip it as an ordinary comment.\n    new compiler.webpack.BannerPlugin({\n      banner: getObsidianPluginBanner('webpack'),\n      raw: true,\n      stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_REPORT,\n      test: /\\.js$/u\n    }).apply(compiler);\n\n    const buildContextPromise = resolveObsidianPluginBuildContext({\n      ...this.options,\n      ...(compiler.options.output.path !== undefined && { distFolder: compiler.options.output.path }),\n      mode\n    });\n    let isDistFolderCleaned = false;\n\n    async function prepare(): Promise<void> {\n      const buildContext = await buildContextPromise;\n      if (isDistFolderCleaned) {\n        return;\n      }\n      isDistFolderCleaned = true;\n      await cleanObsidianPluginDistFolder(buildContext.distFolder);\n    }\n    compiler.hooks.beforeRun.tapPromise(PLUGIN_NAME, prepare);\n    compiler.hooks.watchRun.tapPromise(PLUGIN_NAME, prepare);\n\n    compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {\n      compilation.hooks.processAssets.tap(\n        { name: PLUGIN_NAME, stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE },\n        () => {\n          renameWebpackCssAssets(compilation, compiler);\n          inlineExtractedLicenses(compilation, compiler);\n        }\n      );\n    });\n\n    compiler.hooks.afterEmit.tapPromise(PLUGIN_NAME, async (compilation) => {\n      if (compilation.getStats().hasErrors()) {\n        return;\n      }\n      const buildContext = await buildContextPromise;\n      await completeObsidianPluginDistFolder(buildContext);\n      await deployToObsidianPluginsFolder(buildContext);\n    });\n  }\n  /* v8 ignore stop */\n}\n\n/**\n * Decides the build mode of a webpack build from the consumer's config: development when webpack watches\n * or its `mode` is `development`, production otherwise.\n *\n * @param options - The normalized webpack options.\n * @returns The build mode.\n */\nexport function getWebpackBuildMode(options: Pick<WebpackOptionsNormalized, 'mode' | 'watch'>): BuildMode {\n  return options.watch || options.mode === 'development' ? BuildMode.Development : BuildMode.Production;\n}\n\n/**\n * Builds the module rules the build features add, each running the toolkit's own loader: Solid's JSX before the\n * project's TypeScript loader, Svelte components and modules, `.wasm` modules as JavaScript, and with `styles` the\n * stylesheet rule.\n *\n * @param params - The {@link GetWebpackFeatureRulesParams}.\n * @returns The rules, empty when no feature needs one.\n */\nexport function getWebpackFeatureRules(params: GetWebpackFeatureRulesParams): RuleSetRule[] {\n  const { cssLoaderPath, features, isProductionBuild, loaderPath, miniCssExtractLoaderPath } = params;\n  const rules: RuleSetRule[] = [];\n\n  function featureLoader(kind: ObsidianPluginWebpackLoaderOptions['kind'], styles?: ObsidianPluginStylesOptions): RuleSetUseItem[] {\n    const options: ObsidianPluginWebpackLoaderOptions = { isProductionBuild, kind, ...(styles && { styles }) };\n    return [{ loader: loaderPath, options }];\n  }\n\n  switch (features.framework) {\n    case 'solid': {\n      rules.push({ enforce: 'pre', test: /\\.[jt]sx$/iu, use: featureLoader('jsx') });\n      break;\n    }\n    case 'svelte': {\n      rules.push(\n        { test: /\\.svelte$/iu, use: featureLoader('svelte') },\n        { enforce: 'pre', test: /\\.svelte\\.[cm]?[jt]s$/iu, use: featureLoader('svelte') }\n      );\n      break;\n    }\n    case 'vue': {\n      // `unplugin-vue` hands a `<script lang=\"ts\">` block on as a module of its own after the project's TypeScript\n      // Loader ran, so a post loader strips its types. Its id names the component and the block's language.\n      rules.push({ enforce: 'post', test: /\\.vue(?:\\?|%3F).*lang\\.ts$/iu, use: featureLoader('typescript') });\n      break;\n    }\n    default: {\n      break;\n    }\n  }\n  if (features.wasm) {\n    rules.push({ test: /\\.wasm$/iu, type: 'javascript/auto', use: featureLoader('wasm') });\n  }\n  if (features.styles) {\n    rules.push({\n      test: /\\.p?css$/iu,\n      use: [\n        miniCssExtractLoaderPath,\n        {\n          loader: cssLoaderPath,\n          options: {\n            importLoaders: 1,\n            modules: features.styles.cssModules ? { auto: true, namedExport: false } : false\n          }\n        },\n        ...isPostcssNeeded(features.styles) ? featureLoader('stylesheet', features.styles) : []\n      ]\n    });\n  }\n  return rules;\n}\n\n/**\n * Tells webpack's function form of `externals` to leave Obsidian's modules and the Node builtins to\n * `require()`.\n *\n * @param data - The request webpack is resolving.\n * @param callback - The callback to answer through.\n */\nexport function obsidianPluginWebpackExternals(data: ExternalsData, callback: ExternalsCallback): void {\n  if (data.request !== undefined && isObsidianPluginExternal(data.request)) {\n    callback(null, `commonjs2 ${data.request}`);\n    return;\n  }\n  callback();\n}\n\n/* v8 ignore start -- Part of the webpack hooks above. */\n/**\n * Applies the build features to a compiler: the rules of {@link getWebpackFeatureRules}, `mini-css-extract-plugin`\n * for `styles` unless the config already applies it, and `unplugin-vue` with Vue's feature flags for Vue.\n *\n * @param compiler - The webpack compiler.\n * @param features - The build features.\n * @param isProductionBuild - Whether this is a production build.\n */\nfunction applyWebpackFeatures(compiler: Compiler, features: ObsidianPluginFeatureOptions, isProductionBuild: boolean): void {\n  let miniCssExtractLoaderPath = '';\n  let cssLoaderPath = '';\n  if (features.styles) {\n    const stylesFeature = 'styles';\n    cssLoaderPath = resolveOptionalPeer({ feature: stylesFeature, packageName: 'css-loader' });\n    const MiniCssExtractPlugin = extractDefaultExportInterop(\n      requireOptionalPeer({ feature: stylesFeature, packageName: MINI_CSS_EXTRACT_PLUGIN }) as MiniCssExtractPluginModule\n    );\n    miniCssExtractLoaderPath = MiniCssExtractPlugin.loader;\n    const hasMiniCssExtractPlugin = compiler.options.plugins.some((plugin) => plugin.constructor.name === 'MiniCssExtractPlugin');\n    if (!hasMiniCssExtractPlugin) {\n      new MiniCssExtractPlugin().apply(compiler);\n    }\n  }\n\n  const loaderPath = fileURLToPath(new URL(`obsidian-plugin-webpack-loader${extname(fileURLToPath(import.meta.url))}`, import.meta.url));\n  compiler.options.module.rules.push(...getWebpackFeatureRules({ cssLoaderPath, features, isProductionBuild, loaderPath, miniCssExtractLoaderPath }));\n\n  if (features.framework !== 'vue') {\n    return;\n  }\n  const unpluginVue = extractDefaultExportInterop(\n    requireOptionalPeer({ feature: 'framework: \\'vue\\'', packageName: 'unplugin-vue', specifier: 'unplugin-vue/webpack' }) as UnpluginVueWebpackModule\n  );\n  unpluginVue().apply(compiler);\n  // `process.env.NODE_ENV` is left out: webpack's `mode` defines it, and a second definition conflicts.\n  const { 'process.env.NODE_ENV': _nodeEnv, ...vueFlags } = getFrameworkDefines({ framework: features.framework, isProductionBuild });\n  new compiler.webpack.DefinePlugin(vueFlags).apply(compiler);\n}\n\n/**\n * Fills in the normalized webpack options the consumer left unset.\n *\n * Runs while the plugin is applied, which webpack does after normalizing the consumer's config and before\n * applying its own defaults, so an unset option still reads `undefined` here.\n *\n * @param options - The normalized webpack options, changed in place.\n * @param mode - The build mode.\n */\nfunction applyWebpackOptionDefaults(options: WebpackOptionsNormalized, mode: BuildMode): void {\n  const isProductionBuild = mode === BuildMode.Production;\n  options.mode ??= isProductionBuild ? 'production' : 'development';\n  options.target ??= 'node';\n  options.devtool ??= !isProductionBuild && 'inline-source-map';\n\n  if (typeof options.entry === 'object' && Object.keys(options.entry).length === 1 && options.entry['main']?.import === undefined) {\n    options.entry = { main: { import: [getObsidianPluginEntryPoint()] } };\n  }\n\n  options.output.path ??= getObsidianPluginDistFolder(mode);\n  options.output.filename ??= ObsidianPluginRepoPaths.MainJs;\n  options.output.library ??= { type: 'commonjs2' };\n  options.output.asyncChunks ??= false;\n\n  // Listed in full rather than with `'...'`, which would bring in the `node` condition of `target: 'node'`: export\n  // Maps are matched in the package's key order, not this one's, so a package listing `node` before `browser` (Vue,\n  // `fflate`) would hand over its Node build, which does not load on mobile.\n  options.resolve.conditionNames ??= ['browser', 'webpack', isProductionBuild ? 'production' : 'development', 'module', 'import', 'require'];\n\n  const userExternals = options.externals;\n  options.externals = [obsidianPluginWebpackExternals, ...(Array.isArray(userExternals) ? userExternals : [userExternals])];\n}\n\n/**\n * Puts license comments a minimizer extracted into a `<file>.LICENSE.txt` back into the file they came from.\n *\n * Webpack's default minimizer moves every bundled dependency's license comment into a\n * `main.js.LICENSE.txt` beside `main.js`, which no Obsidian release ships, so the installed plugin would\n * carry code without the notices it is licensed under. Done after minification rather than by replacing\n * the minimizer, so it holds whichever minimizer the consumer or webpack picked.\n *\n * @param compilation - The compilation.\n * @param compiler - The compiler, for webpack's `sources` classes.\n */\nfunction inlineExtractedLicenses(compilation: Compilation, compiler: Compiler): void {\n  const LICENSE_SUFFIX = '.LICENSE.txt';\n  for (const licenseAsset of compilation.getAssets()) {\n    if (!licenseAsset.name.endsWith(LICENSE_SUFFIX)) {\n      continue;\n    }\n    const sourceFileName = licenseAsset.name.slice(0, -LICENSE_SUFFIX.length);\n    const sourceAsset = compilation.getAsset(sourceFileName);\n    if (!sourceAsset) {\n      continue;\n    }\n    const licenseFileName = licenseAsset.name.split('/').at(-1) ?? licenseAsset.name;\n    const reference = `/*! For license information please see ${licenseFileName} */`;\n    const source = sourceAsset.source.source().toString();\n    const licenses = licenseAsset.source.source().toString().trimEnd();\n    const updatedSource = source.includes(reference) ? source.replace(reference, () => licenses) : `${licenses}\\n${source}`;\n    compilation.updateAsset(sourceFileName, new compiler.webpack.sources.RawSource(updatedSource));\n    compilation.deleteAsset(licenseAsset.name);\n  }\n}\n\n/**\n * Moves every CSS asset of a compilation into `styles.css`.\n *\n * @param compilation - The compilation.\n * @param compiler - The compiler, for webpack's `sources` classes.\n */\nfunction renameWebpackCssAssets(compilation: Compilation, compiler: Compiler): void {\n  const cssAssets = compilation.getAssets()\n    .filter((asset) => isCssFileName(asset.name))\n    .map((asset) => ({ fileName: asset.name, source: asset.source.source().toString() }));\n  const { fileNamesToRemove, stylesCss } = mergeCssAssets(cssAssets);\n  if (stylesCss === undefined) {\n    return;\n  }\n  for (const fileName of fileNamesToRemove) {\n    compilation.deleteAsset(fileName);\n  }\n  compilation.emitAsset(ObsidianPluginRepoPaths.StylesCss, new compiler.webpack.sources.RawSource(stylesCss));\n}\n/* v8 ignore stop */\n"],"mappings":"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","names":[]}

package/dist/lib/esm/demo-vault-cli.d.mts

@@ -0,0 +1,15 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * The `archive-demo-vault` command: runs {@link archivePluginDemoVault} on the built plugin and turns the result into
+ * an exit code. The `obsidian-plugin-release.yml` reusable workflow runs it after the build, so a release made in CI
+ * carries the same demo vault archive as one made with `npm run version`.
+ */
+/**
+ * Runs `archive-demo-vault`. A plugin without a `demo-vault/` folder is not a failure: there is nothing to archive.
+ *
+ * @returns A {@link Promise} that resolves to the exit code: `0` once the archive is written or when there is no demo
+ *   vault, `1` on any failure, which is printed to stderr.
+ */
+export declare function runArchiveDemoVaultCli(): Promise<number>;