@mnaoumov/obsidian-dev-toolkit 2.1.0 → 3.0.0

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

@@ -0,0 +1,105 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * Builds an Obsidian plugin with vite: a vite plugin that turns `vite build` into a library build of
+ * `src/main.ts` with the same `main.js` + `styles.css` + `manifest.json` layout the esbuild builder
+ * produces, deploys a `vite build --watch` build into the vault, and fills in only the options the
+ * consumer's own `vite.config` leaves unset.
+ *
+ * `vite` is an optional peer dependency and this module only imports its types, so a plugin built with
+ * esbuild installs nothing extra.
+ */
+import type { ConfigEnv, PluginOption, UserConfig } from 'vite' with { 'resolution-mode': 'import' };
+import type { ObsidianPluginBuildContext, ObsidianPluginDeploymentOptions } from './obsidian-plugin-build.cjs';
+import type { ObsidianPluginFeatureOptions } from './obsidian-plugin-features.cjs';
+import type { PostcssConfig } from './obsidian-plugin-transforms.cjs';
+import { BuildMode } from './obsidian-plugin-build.cjs';
+/**
+ * Parameters for {@link getViteFeatureConfig}.
+ */
+export interface GetViteFeatureConfigParams {
+    /**
+     * The build features.
+     */
+    readonly features: ObsidianPluginFeatureOptions;
+    /**
+     * Whether this is a production build.
+     */
+    readonly isProductionBuild: boolean;
+    /**
+     * The PostCSS plugins of the `styles` option, or `undefined` when it needs none.
+     */
+    readonly postcssConfig: PostcssConfig | undefined;
+    /**
+     * The consumer's vite config.
+     */
+    readonly userConfig: UserConfig;
+}
+/**
+ * Options for {@link obsidianPluginVite}.
+ */
+export interface ObsidianPluginViteOptions extends ObsidianPluginDeploymentOptions, ObsidianPluginFeatureOptions {
+    /**
+     * The build mode. Defaults to {@link BuildMode.Development} for `vite build --watch` (or
+     * `--mode development`) and {@link BuildMode.Production} otherwise.
+     */
+    readonly mode?: BuildMode;
+}
+/**
+ * Decides the build mode of a vite build from the consumer's config: development for a watch build or for
+ * `--mode development`, production otherwise.
+ *
+ * @param userConfig - The consumer's vite config.
+ * @param env - The vite config environment.
+ * @returns The build mode.
+ */
+export declare function getViteBuildMode(userConfig: UserConfig, env: Pick<ConfigEnv, 'mode'>): BuildMode;
+/**
+ * Builds the part of the vite config the plugin contributes: only the options the consumer left unset.
+ *
+ * @param userConfig - The consumer's vite config.
+ * @param buildContext - The build context.
+ * @returns The config vite merges into the consumer's.
+ */
+export declare function getViteConfigDefaults(userConfig: UserConfig, buildContext: ObsidianPluginBuildContext): UserConfig;
+/**
+ * Builds the part of the vite config the build features contribute, each only where the consumer's config left it
+ * unset: the framework's compile-time constants (`define`), the automatic JSX runtime for React and Preact
+ * (`oxc.jsx`), and the PostCSS plugins of the `styles` option (`css.postcss`).
+ *
+ * @param params - The {@link GetViteFeatureConfigParams}.
+ * @returns The config vite merges into the consumer's.
+ */
+export declare function getViteFeatureConfig(params: GetViteFeatureConfigParams): UserConfig;
+/**
+ * Creates a vite plugin that builds an Obsidian plugin.
+ *
+ * What it does, each only when the consumer's config has not said otherwise:
+ *
+ * - `build.lib` builds `src/main.ts` as one CommonJS `main.js`, with its CSS in `styles.css`.
+ * - `build.outDir` is `dist/build` (`dist/dev` in development).
+ * - `build.minify` is on in production only, and `build.sourcemap` is inline in development only.
+ * - Every asset is inlined, because an Obsidian release ships `main.js` and `styles.css` and nothing else.
+ * - Dynamic imports are inlined into `main.js`, and the generated-file banner heads it.
+ *
+ * And always: Obsidian's own modules (`obsidian`, `electron`, CodeMirror, Lezer) and the Node builtins are
+ * external beside the consumer's own `external`, the output folder is emptied once before the first write
+ * (`build.emptyOutDir` is turned off, since this plugin does it), 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`.
+ *
+ * The build features ({@link ObsidianPluginFeatureOptions}):
+ *
+ * - `framework: 'react' | 'preact'` sets `oxc.jsx` to the automatic runtime (unless set).
+ * - `framework: 'solid' | 'svelte'` compiles the components with the toolkit's shared transforms, and `'vue'` adds
+ *   `unplugin-vue`.
+ * - Any framework defines `process.env.NODE_ENV` (and Vue's feature flags), which a library build leaves alone.
+ * - `styles.postcss` and `styles.tailwind` set `css.postcss` (unless set); vite scopes `*.module.css` itself, so
+ *   `styles.cssModules` changes nothing here.
+ * - `wasm` imports a `.wasm` module as its bytes.
+ *
+ * @param options - The {@link ObsidianPluginViteOptions}.
+ * @returns The vite plugins, which vite takes as one entry of its `plugins`.
+ */
+export declare function obsidianPluginVite(options?: ObsidianPluginViteOptions): PluginOption[];

package/dist/lib/cjs/bundlers/webpack.cjs

@@ -0,0 +1,354 @@
+/*
+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 webpack_exports = {};
+__export(webpack_exports, {
+  ObsidianPluginWebpackPlugin: () => ObsidianPluginWebpackPlugin,
+  getWebpackBuildMode: () => getWebpackBuildMode,
+  getWebpackFeatureRules: () => getWebpackFeatureRules,
+  obsidianPluginWebpackExternals: () => obsidianPluginWebpackExternals
+});
+module.exports = __toCommonJS(webpack_exports);
+var import_object_utils = require('@mnaoumov/typescript-lib/object-utils');
+var import_path = require('@mnaoumov/typescript-lib/path');
+var import_node_url = require('node:url');
+var import_obsidian_plugin_repo_paths = require('../obsidian-plugin-repo-paths.cjs');
+var import_obsidian_plugin_build = require('./obsidian-plugin-build.cjs');
+var import_obsidian_plugin_features = require('./obsidian-plugin-features.cjs');
+var import_obsidian_plugins_folder_deployment = require('./obsidian-plugins-folder-deployment.cjs');
+var __import_meta_url = globalThis["import.meta.url"] ?? (function getObsidianCjsImportMetaUrl() {
+  if (typeof __filename === "string") {
+    const localRequire = require;
+    const url = localRequire("node:url");
+    if (typeof url.pathToFileURL === "function") {
+      return url.pathToFileURL(__filename).href;
+    }
+  }
+  return typeof window === "undefined" ? "" : activeWindow.location.href;
+})();
+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 === import_obsidian_plugin_build.BuildMode.Production);
+    new compiler.webpack.BannerPlugin({
+      banner: (0, import_obsidian_plugin_build.getObsidianPluginBanner)("webpack"),
+      raw: true,
+      stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_REPORT,
+      test: /\.js$/u
+    }).apply(compiler);
+    const buildContextPromise = (0, import_obsidian_plugin_build.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 (0, import_obsidian_plugin_build.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 (0, import_obsidian_plugin_build.completeObsidianPluginDistFolder)(buildContext);
+      await (0, import_obsidian_plugins_folder_deployment.deployToObsidianPluginsFolder)(buildContext);
+    });
+  }
+  /* v8 ignore stop */
+}
+function getWebpackBuildMode(options) {
+  return options.watch || options.mode === "development" ? import_obsidian_plugin_build.BuildMode.Development : import_obsidian_plugin_build.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
+          }
+        },
+        ...(0, import_obsidian_plugin_features.isPostcssNeeded)(features.styles) ? featureLoader("stylesheet", features.styles) : []
+      ]
+    });
+  }
+  return rules;
+}
+function obsidianPluginWebpackExternals(data, callback) {
+  if (data.request !== void 0 && (0, import_obsidian_plugin_build.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 = (0, import_obsidian_plugin_features.resolveOptionalPeer)({ feature: stylesFeature, packageName: "css-loader" });
+    const MiniCssExtractPlugin = (0, import_object_utils.extractDefaultExportInterop)(
+      (0, import_obsidian_plugin_features.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 = (0, import_node_url.fileURLToPath)(new URL(`obsidian-plugin-webpack-loader${(0, import_path.extname)((0, import_node_url.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 = (0, import_object_utils.extractDefaultExportInterop)(
+    (0, import_obsidian_plugin_features.requireOptionalPeer)({ feature: "framework: 'vue'", packageName: "unplugin-vue", specifier: "unplugin-vue/webpack" })
+  );
+  unpluginVue().apply(compiler);
+  const { "process.env.NODE_ENV": _nodeEnv, ...vueFlags } = (0, import_obsidian_plugin_features.getFrameworkDefines)({ framework: features.framework, isProductionBuild });
+  new compiler.webpack.DefinePlugin(vueFlags).apply(compiler);
+}
+function applyWebpackOptionDefaults(options, mode) {
+  const isProductionBuild = mode === import_obsidian_plugin_build.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: [(0, import_obsidian_plugin_build.getObsidianPluginEntryPoint)()] } };
+  }
+  options.output.path ??= (0, import_obsidian_plugin_build.getObsidianPluginDistFolder)(mode);
+  options.output.filename ??= import_obsidian_plugin_repo_paths.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) => (0, import_obsidian_plugin_build.isCssFileName)(asset.name)).map((asset) => ({ fileName: asset.name, source: asset.source.source().toString() }));
+  const { fileNamesToRemove, stylesCss } = (0, import_obsidian_plugin_build.mergeCssAssets)(cssAssets);
+  if (stylesCss === void 0) {
+    return;
+  }
+  for (const fileName of fileNamesToRemove) {
+    compilation.deleteAsset(fileName);
+  }
+  compilation.emitAsset(import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.StylesCss, new compiler.webpack.sources.RawSource(stylesCss));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ObsidianPluginWebpackPlugin,
+  getWebpackBuildMode,
+  getWebpackFeatureRules,
+  obsidianPluginWebpackExternals
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/bundlers/webpack.ts"],"sourcesContent":["var __import_meta_url = globalThis['import.meta.url'] ?? (function getObsidianCjsImportMetaUrl() {\n  if (typeof __filename === 'string') {\n    const localRequire = require;\n    const url = localRequire('node:url');\n    if (typeof url.pathToFileURL === 'function') {\n      return url.pathToFileURL(__filename).href;\n    }\n  }\n\n  // Fallback to an empty string if the environment is unknown\n  return typeof window === 'undefined' ? '' : activeWindow.location.href;\n})();\n/**\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/cjs/bundlers/webpack.d.cts

@@ -0,0 +1,133 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @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' with { 'resolution-mode': 'import' };
+import type { ObsidianPluginDeploymentOptions } from './obsidian-plugin-build.cjs';
+import type { ObsidianPluginFeatureOptions } from './obsidian-plugin-features.cjs';
+import { BuildMode } from './obsidian-plugin-build.cjs';
+/**
+ * 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 {};