@mnaoumov/obsidian-dev-toolkit 2.1.0 → 3.0.0

package/dist/lib/esm/bundlers/rollup-compatible-features.mjs

@@ -0,0 +1,93 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { readFile } from "node:fs/promises";
+import { ObsidianPluginRepoPaths } from "../obsidian-plugin-repo-paths.mjs";
+import {
+  getFeatureFileKind,
+  getFrameworkDefines,
+  importOptionalPeer,
+  replaceDefines
+} from "./obsidian-plugin-features.mjs";
+import {
+  getCssModuleCode,
+  getWasmModuleCode,
+  transformCss,
+  transformSolid,
+  transformSvelte
+} from "./obsidian-plugin-transforms.mjs";
+function createRollupCompatibleFeaturePlugin(params) {
+  const { features, isProductionBuild, shouldCompileStylesheets, shouldReplaceDefines } = params;
+  async function transformFeatureFile(context, code, id) {
+    const [filePath = id] = id.split("?", 1);
+    switch (getFeatureFileKind(id)) {
+      case "jsx": {
+        return features.framework === "solid" ? await transformSolid({ code, filePath, isProductionBuild: isProductionBuild() }) : null;
+      }
+      case "stylesheet": {
+        if (!shouldCompileStylesheets || !features.styles) {
+          return null;
+        }
+        const result = await transformCss({
+          filePath,
+          isCssModuleScoped: true,
+          isProductionBuild: isProductionBuild(),
+          source: code,
+          styles: features.styles
+        });
+        for (const dependency of result.dependencies) {
+          context.addWatchFile(dependency);
+        }
+        context.emitFile({ name: ObsidianPluginRepoPaths.StylesCss, source: result.css, type: "asset" });
+        return { code: result.moduleExports ? getCssModuleCode(result.moduleExports) : "export default undefined;\n" };
+      }
+      case "svelte": {
+        return features.framework === "svelte" ? await transformSvelte({ code, filePath, isProductionBuild: isProductionBuild() }) : null;
+      }
+      default: {
+        return null;
+      }
+    }
+  }
+  return {
+    load: {
+      async handler(id) {
+        return !features.wasm || getFeatureFileKind(id) !== "wasm" ? null : getWasmModuleCode(await readFile(id));
+      },
+      order: "pre"
+    },
+    name: "obsidian-plugin-features",
+    transform: {
+      async handler(code, id) {
+        const transformed = await transformFeatureFile(this, code, id);
+        if (!shouldReplaceDefines) {
+          return transformed;
+        }
+        const defines = getFrameworkDefines({ framework: features.framework, isProductionBuild: isProductionBuild() });
+        const source = transformed?.code ?? code;
+        const replaced = replaceDefines(source, defines);
+        return replaced === source ? transformed : { code: replaced, map: transformed?.map };
+      },
+      order: "pre"
+    }
+  };
+}
+async function createUnpluginVuePlugin(params) {
+  const { bundler, features } = params;
+  if (features.framework !== "vue") {
+    return null;
+  }
+  const unpluginVue = await importOptionalPeer({
+    feature: "framework: 'vue'",
+    packageName: "unplugin-vue",
+    specifier: `unplugin-vue/${bundler}`
+  });
+  return unpluginVue.default();
+}
+export {
+  createRollupCompatibleFeaturePlugin,
+  createUnpluginVuePlugin
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/bundlers/rollup-compatible-features.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The build features of the rollup and vite adapters: one plugin, typed by the shape both bundlers accept, that runs\n * the shared transforms (Solid, Svelte, stylesheets, WebAssembly) and replaces the framework's compile-time constants,\n * plus the `unplugin-vue` plugin for Vue.\n */\n\nimport { readFile } from 'node:fs/promises';\n\nimport type { ObsidianPluginFeatureOptions } from './obsidian-plugin-features.ts';\nimport type { SourceMapLike } from './obsidian-plugin-transforms.ts';\n\nimport { ObsidianPluginRepoPaths } from '../obsidian-plugin-repo-paths.ts';\nimport {\n  getFeatureFileKind,\n  getFrameworkDefines,\n  importOptionalPeer,\n  replaceDefines\n} from './obsidian-plugin-features.ts';\nimport {\n  getCssModuleCode,\n  getWasmModuleCode,\n  transformCss,\n  transformSolid,\n  transformSvelte\n} from './obsidian-plugin-transforms.ts';\n\n/**\n * Parameters for {@link createRollupCompatibleFeaturePlugin}.\n */\nexport interface CreateRollupCompatibleFeaturePluginParams {\n  /**\n   * The build features.\n   */\n  readonly features: ObsidianPluginFeatureOptions;\n\n  /**\n   * Tells whether the build is a production one. Called from the hooks, after the adapter resolved its build mode.\n   */\n  readonly isProductionBuild: () => boolean;\n\n  /**\n   * Whether this plugin compiles stylesheets. Vite compiles them itself.\n   */\n  readonly shouldCompileStylesheets: boolean;\n\n  /**\n   * Whether this plugin replaces the framework's compile-time constants in the code. Vite does it through its own\n   * `define`.\n   */\n  readonly shouldReplaceDefines: boolean;\n}\n\n/**\n * Parameters for {@link createUnpluginVuePlugin}.\n */\nexport interface CreateUnpluginVuePluginParams {\n  /**\n   * The bundler, which names the `unplugin-vue` entry.\n   */\n  readonly bundler: 'rollup' | 'vite';\n\n  /**\n   * The build features.\n   */\n  readonly features: ObsidianPluginFeatureOptions;\n}\n\n/**\n * The part of a rollup or rolldown plugin context the feature plugin uses.\n */\nexport interface FeaturePluginContext {\n  /**\n   * Adds a file to watch in a watch build.\n   *\n   * @param id - The file's path.\n   */\n  addWatchFile: (id: string) => void;\n\n  /**\n   * Emits an asset into the bundle.\n   *\n   * @param emittedFile - The asset to emit.\n   * @returns The reference id of the emitted file.\n   */\n  emitFile: (emittedFile: EmittedAsset) => string;\n}\n\n/**\n * The plugin {@link createRollupCompatibleFeaturePlugin} creates, in the shape rollup and vite both accept.\n */\nexport interface RollupCompatibleFeaturePlugin {\n  /**\n   * Loads a `.wasm` module as its bytes.\n   */\n  readonly load: FeaturePluginHook<(this: FeaturePluginContext, id: string) => Promise<null | string>>;\n\n  /**\n   * The plugin's name.\n   */\n  readonly name: string;\n\n  /**\n   * Compiles a module the features transform, then replaces the compile-time constants.\n   */\n  readonly transform: FeaturePluginHook<(this: FeaturePluginContext, code: string, id: string) => Promise<null | TransformResultLike>>;\n}\n\n/**\n * The asset the feature plugin emits for a stylesheet.\n */\ninterface EmittedAsset {\n  readonly name: string;\n  readonly source: string;\n  readonly type: 'asset';\n}\n\n/**\n * A plugin hook with its order.\n *\n * @typeParam Handler - The hook's handler.\n */\ninterface FeaturePluginHook<Handler> {\n  readonly handler: Handler;\n  readonly order: 'pre';\n}\n\n/**\n * A transform hook's result.\n */\ninterface TransformResultLike {\n  readonly code: string;\n  readonly map?: SourceMapLike | undefined;\n}\n\ninterface UnpluginVueModule {\n  readonly default: (options?: object) => unknown;\n}\n\n/**\n * Creates the plugin that runs the shared transforms in a rollup or vite build.\n *\n * - `framework: 'solid'` compiles `.jsx` / `.tsx` with `babel-preset-solid`, before the project's TypeScript plugin.\n * - `framework: 'svelte'` compiles `.svelte` components and `.svelte.ts` / `.svelte.js` modules.\n * - `styles`, where {@link CreateRollupCompatibleFeaturePluginParams.shouldCompileStylesheets} says so, runs every\n *   stylesheet through PostCSS, Tailwind and CSS-module scoping and emits it as an asset, which ends up in\n *   `styles.css`.\n * - `wasm` loads a `.wasm` module as its bytes.\n * - A framework's compile-time constants are replaced where\n *   {@link CreateRollupCompatibleFeaturePluginParams.shouldReplaceDefines} says so.\n *\n * @param params - The {@link CreateRollupCompatibleFeaturePluginParams}.\n * @returns The plugin.\n */\nexport function createRollupCompatibleFeaturePlugin(params: CreateRollupCompatibleFeaturePluginParams): RollupCompatibleFeaturePlugin {\n  const { features, isProductionBuild, shouldCompileStylesheets, shouldReplaceDefines } = params;\n\n  async function transformFeatureFile(context: FeaturePluginContext, code: string, id: string): Promise<null | TransformResultLike> {\n    const [filePath = id] = id.split('?', 1);\n    switch (getFeatureFileKind(id)) {\n      case 'jsx': {\n        return features.framework === 'solid' ? await transformSolid({ code, filePath, isProductionBuild: isProductionBuild() }) : null;\n      }\n      case 'stylesheet': {\n        if (!shouldCompileStylesheets || !features.styles) {\n          return null;\n        }\n        const result = await transformCss({\n          filePath,\n          isCssModuleScoped: true,\n          isProductionBuild: isProductionBuild(),\n          source: code,\n          styles: features.styles\n        });\n        for (const dependency of result.dependencies) {\n          context.addWatchFile(dependency);\n        }\n        context.emitFile({ name: ObsidianPluginRepoPaths.StylesCss, source: result.css, type: 'asset' });\n        return { code: result.moduleExports ? getCssModuleCode(result.moduleExports) : 'export default undefined;\\n' };\n      }\n      case 'svelte': {\n        return features.framework === 'svelte' ? await transformSvelte({ code, filePath, isProductionBuild: isProductionBuild() }) : null;\n      }\n      default: {\n        return null;\n      }\n    }\n  }\n\n  return {\n    load: {\n      async handler(id): Promise<null | string> {\n        return !features.wasm || getFeatureFileKind(id) !== 'wasm' ? null : getWasmModuleCode(await readFile(id));\n      },\n      order: 'pre'\n    },\n    name: 'obsidian-plugin-features',\n    transform: {\n      async handler(code, id): Promise<null | TransformResultLike> {\n        const transformed = await transformFeatureFile(this, code, id);\n        if (!shouldReplaceDefines) {\n          return transformed;\n        }\n        const defines = getFrameworkDefines({ framework: features.framework, isProductionBuild: isProductionBuild() });\n        const source = transformed?.code ?? code;\n        const replaced = replaceDefines(source, defines);\n        return replaced === source ? transformed : { code: replaced, map: transformed?.map };\n      },\n      order: 'pre'\n    }\n  };\n}\n\n/**\n * Creates the `unplugin-vue` plugin of one bundler when the framework is Vue.\n *\n * @param params - The {@link CreateUnpluginVuePluginParams}.\n * @returns A {@link Promise} that resolves to the plugin, or `null` when the framework is not Vue.\n */\nexport async function createUnpluginVuePlugin(params: CreateUnpluginVuePluginParams): Promise<unknown> {\n  const { bundler, features } = params;\n  if (features.framework !== 'vue') {\n    return null;\n  }\n  const unpluginVue = await importOptionalPeer<UnpluginVueModule>({\n    feature: 'framework: \\'vue\\'',\n    packageName: 'unplugin-vue',\n    specifier: `unplugin-vue/${bundler}`\n  });\n  return unpluginVue.default();\n}\n"],
  "mappings": ";;;;;AAQA,SAAS,gBAAgB;AAKzB,SAAS,+BAA+B;AACxC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAiIA,SAAS,oCAAoC,QAAkF;AACpI,QAAM,EAAE,UAAU,mBAAmB,0BAA0B,qBAAqB,IAAI;AAExF,iBAAe,qBAAqB,SAA+B,MAAc,IAAiD;AAChI,UAAM,CAAC,WAAW,EAAE,IAAI,GAAG,MAAM,KAAK,CAAC;AACvC,YAAQ,mBAAmB,EAAE,GAAG;AAAA,MAC9B,KAAK,OAAO;AACV,eAAO,SAAS,cAAc,UAAU,MAAM,eAAe,EAAE,MAAM,UAAU,mBAAmB,kBAAkB,EAAE,CAAC,IAAI;AAAA,MAC7H;AAAA,MACA,KAAK,cAAc;AACjB,YAAI,CAAC,4BAA4B,CAAC,SAAS,QAAQ;AACjD,iBAAO;AAAA,QACT;AACA,cAAM,SAAS,MAAM,aAAa;AAAA,UAChC;AAAA,UACA,mBAAmB;AAAA,UACnB,mBAAmB,kBAAkB;AAAA,UACrC,QAAQ;AAAA,UACR,QAAQ,SAAS;AAAA,QACnB,CAAC;AACD,mBAAW,cAAc,OAAO,cAAc;AAC5C,kBAAQ,aAAa,UAAU;AAAA,QACjC;AACA,gBAAQ,SAAS,EAAE,MAAM,wBAAwB,WAAW,QAAQ,OAAO,KAAK,MAAM,QAAQ,CAAC;AAC/F,eAAO,EAAE,MAAM,OAAO,gBAAgB,iBAAiB,OAAO,aAAa,IAAI,8BAA8B;AAAA,MAC/G;AAAA,MACA,KAAK,UAAU;AACb,eAAO,SAAS,cAAc,WAAW,MAAM,gBAAgB,EAAE,MAAM,UAAU,mBAAmB,kBAAkB,EAAE,CAAC,IAAI;AAAA,MAC/H;AAAA,MACA,SAAS;AACP,eAAO;AAAA,MACT;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AAAA,IACL,MAAM;AAAA,MACJ,MAAM,QAAQ,IAA4B;AACxC,eAAO,CAAC,SAAS,QAAQ,mBAAmB,EAAE,MAAM,SAAS,OAAO,kBAAkB,MAAM,SAAS,EAAE,CAAC;AAAA,MAC1G;AAAA,MACA,OAAO;AAAA,IACT;AAAA,IACA,MAAM;AAAA,IACN,WAAW;AAAA,MACT,MAAM,QAAQ,MAAM,IAAyC;AAC3D,cAAM,cAAc,MAAM,qBAAqB,MAAM,MAAM,EAAE;AAC7D,YAAI,CAAC,sBAAsB;AACzB,iBAAO;AAAA,QACT;AACA,cAAM,UAAU,oBAAoB,EAAE,WAAW,SAAS,WAAW,mBAAmB,kBAAkB,EAAE,CAAC;AAC7G,cAAM,SAAS,aAAa,QAAQ;AACpC,cAAM,WAAW,eAAe,QAAQ,OAAO;AAC/C,eAAO,aAAa,SAAS,cAAc,EAAE,MAAM,UAAU,KAAK,aAAa,IAAI;AAAA,MACrF;AAAA,MACA,OAAO;AAAA,IACT;AAAA,EACF;AACF;AAQA,eAAsB,wBAAwB,QAAyD;AACrG,QAAM,EAAE,SAAS,SAAS,IAAI;AAC9B,MAAI,SAAS,cAAc,OAAO;AAChC,WAAO;AAAA,EACT;AACA,QAAM,cAAc,MAAM,mBAAsC;AAAA,IAC9D,SAAS;AAAA,IACT,aAAa;AAAA,IACb,WAAW,gBAAgB,OAAO;AAAA,EACpC,CAAC;AACD,SAAO,YAAY,QAAQ;AAC7B;",
  "names": []
}


package/dist/lib/esm/bundlers/rollup-compatible.d.mts

@@ -0,0 +1,84 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * The pieces the rollup and vite adapters share. Vite 8 builds with rolldown, whose plugin API is
+ * rollup's but whose types are its own, so these are typed by the shape both accept rather than by either
+ * package's declarations.
+ */
+/**
+ * The part of a rollup or rolldown plugin context {@link renameCssAssets} uses.
+ */
+export interface AssetEmitter {
+    /**
+     * Emits an asset into the bundle.
+     *
+     * @param emittedFile - The asset to emit.
+     * @returns The reference id of the emitted file.
+     */
+    emitFile: (emittedFile: EmittedCssAsset) => string;
+}
+/**
+ * An emitted file of a rollup or rolldown bundle, as {@link renameCssAssets} reads it.
+ */
+export interface BundleOutputLike {
+    /**
+     * The file name relative to the output folder.
+     */
+    readonly fileName: string;
+    /**
+     * An asset's contents.
+     */
+    readonly source?: string | Uint8Array;
+    /**
+     * Whether the file is an asset or a chunk.
+     */
+    readonly type: 'asset' | 'chunk';
+}
+/**
+ * The function {@link combineExternal} returns, which every bundler of the rollup family accepts.
+ */
+export type CombinedExternalFunction = (source: string, importer: string | undefined, isResolved: boolean) => boolean;
+/**
+ * The `styles.css` asset {@link renameCssAssets} emits.
+ */
+export interface EmittedCssAsset {
+    /**
+     * The file name relative to the output folder.
+     */
+    readonly fileName: string;
+    /**
+     * The file's contents.
+     */
+    readonly source: string;
+    /**
+     * The kind of emitted file.
+     */
+    readonly type: 'asset';
+}
+/**
+ * The function form of {@link ExternalLike}. Its result is read for truthiness, as rollup and rolldown read it.
+ */
+export type ExternalFunction = (source: string, importer: string | undefined, isResolved: boolean) => unknown;
+/**
+ * The `external` option of rollup and of rolldown, in the shape both accept.
+ */
+export type ExternalLike = ExternalFunction | ExternalPattern | readonly ExternalPattern[];
+/**
+ * One entry of the array form of {@link ExternalLike}.
+ */
+export type ExternalPattern = RegExp | string;
+/**
+ * Puts Obsidian's modules and the Node builtins beside whatever the consumer's own `external` option names.
+ *
+ * @param external - The consumer's `external` option.
+ * @returns A function form of `external` that keeps both.
+ */
+export declare function combineExternal(external: ExternalLike | undefined): CombinedExternalFunction;
+/**
+ * Moves every CSS asset of a bundle into one `styles.css`, the only stylesheet Obsidian loads.
+ *
+ * @param assetEmitter - The plugin context to emit `styles.css` through.
+ * @param bundle - The bundle about to be written.
+ */
+export declare function renameCssAssets(assetEmitter: AssetEmitter, bundle: Record<string, BundleOutputLike>): void;

package/dist/lib/esm/bundlers/rollup-compatible.mjs

@@ -0,0 +1,43 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { ObsidianPluginRepoPaths } from "../obsidian-plugin-repo-paths.mjs";
+import {
+  isCssFileName,
+  isObsidianPluginExternal,
+  mergeCssAssets
+} from "./obsidian-plugin-build.mjs";
+function combineExternal(external) {
+  return (source, importer, isResolved) => isObsidianPluginExternal(source) || isMatchingExternal(external, source, importer, isResolved);
+}
+function renameCssAssets(assetEmitter, bundle) {
+  const cssAssets = Object.values(bundle).filter((output) => output.type === "asset" && isCssFileName(output.fileName)).map((asset) => ({
+    fileName: asset.fileName,
+    source: typeof asset.source === "string" ? asset.source : new TextDecoder().decode(asset.source)
+  }));
+  const { fileNamesToRemove, stylesCss } = mergeCssAssets(cssAssets);
+  if (stylesCss === void 0) {
+    return;
+  }
+  for (const fileName of fileNamesToRemove) {
+    delete bundle[fileName];
+  }
+  assetEmitter.emitFile({ fileName: ObsidianPluginRepoPaths.StylesCss, source: stylesCss, type: "asset" });
+}
+function isMatchingExternal(external, source, importer, isResolved) {
+  if (external === void 0) {
+    return false;
+  }
+  if (typeof external === "function") {
+    return Boolean(external(source, importer, isResolved));
+  }
+  const patterns = typeof external === "string" || external instanceof RegExp ? [external] : external;
+  return patterns.some((pattern) => typeof pattern === "string" ? pattern === source : pattern.test(source));
+}
+export {
+  combineExternal,
+  renameCssAssets
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,99 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Builds an Obsidian plugin with rollup: a rollup 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 `rollup.config` leaves unset.
+ *
+ * `rollup` is an optional peer dependency and this module only imports its types, so a plugin built with
+ * esbuild installs nothing extra.
+ */
+import type { InputOptions, InputPluginOption, OutputOptions } from 'rollup';
+import type { ObsidianPluginBuildContext, ObsidianPluginDeploymentOptions } from './obsidian-plugin-build.mjs';
+import type { ObsidianPluginFeatureOptions } from './obsidian-plugin-features.mjs';
+import { BuildMode } from './obsidian-plugin-build.mjs';
+/**
+ * Parameters for {@link applyRollupInputDefaults}.
+ */
+export interface ApplyRollupInputDefaultsParams {
+    /**
+     * The build context.
+     */
+    readonly buildContext: ObsidianPluginBuildContext;
+    /**
+     * The build features.
+     */
+    readonly features?: ObsidianPluginFeatureOptions;
+    /**
+     * The consumer's input options.
+     */
+    readonly inputOptions: InputOptions;
+}
+/**
+ * Parameters for {@link applyRollupOutputDefaults}.
+ */
+export interface ApplyRollupOutputDefaultsParams {
+    /**
+     * The build context.
+     */
+    readonly buildContext: ObsidianPluginBuildContext;
+    /**
+     * The consumer's output options.
+     */
+    readonly outputOptions: OutputOptions;
+}
+/**
+ * Options for {@link obsidianPluginRollup}.
+ */
+export interface ObsidianPluginRollupOptions extends ObsidianPluginDeploymentOptions, ObsidianPluginFeatureOptions {
+    /**
+     * The build mode. Defaults to {@link BuildMode.Development} in watch mode (`rollup --watch`) and
+     * {@link BuildMode.Production} otherwise.
+     */
+    readonly mode?: BuildMode;
+}
+/**
+ * Fills in the rollup input options the consumer left unset.
+ *
+ * @param params - The {@link ApplyRollupInputDefaultsParams}.
+ * @returns The input options with the plugin's defaults applied.
+ */
+export declare function applyRollupInputDefaults(params: ApplyRollupInputDefaultsParams): InputOptions;
+/**
+ * Fills in the rollup output options the consumer left unset.
+ *
+ * @param params - The {@link ApplyRollupOutputDefaultsParams}.
+ * @returns The output options with the plugin's defaults applied.
+ */
+export declare function applyRollupOutputDefaults(params: ApplyRollupOutputDefaultsParams): OutputOptions;
+/**
+ * Creates a rollup plugin that builds an Obsidian plugin.
+ *
+ * What it does, each only when the consumer's config has not said otherwise:
+ *
+ * - `input` is `src/main.ts`.
+ * - The output is one CommonJS `main.js` in `dist/build` (`dist/dev` in watch mode), with dynamic imports
+ *   inlined, the generated-file banner, and an inline source map in development.
+ *
+ * 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 before the first write,
+ * 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, dependency resolution and minification stay the consumer's choice of rollup plugins, as they would be
+ * without this one. The build features ({@link ObsidianPluginFeatureOptions}) are the plugin's:
+ *
+ * - `framework: 'react' | 'preact'` sets rollup's `jsx` option to the automatic runtime (unless set), and the
+ *   TypeScript plugin reads the same from the toolkit's tsconfig preset.
+ * - `framework: 'solid' | 'svelte'` compiles the components with the toolkit's shared transforms, and `'vue'` adds
+ *   `unplugin-vue`.
+ * - Any framework replaces `process.env.NODE_ENV` (and Vue's feature flags) in the bundled code.
+ * - `styles` compiles every stylesheet itself (PostCSS, Tailwind, CSS modules), so rollup needs no CSS plugin; leave
+ *   it out. `styles: {}` compiles plain CSS.
+ * - `wasm` imports a `.wasm` module as its bytes.
+ *
+ * @param options - The {@link ObsidianPluginRollupOptions}.
+ * @returns The rollup plugins, which rollup takes as one entry of its `plugins`.
+ */
+export declare function obsidianPluginRollup(options?: ObsidianPluginRollupOptions): InputPluginOption[];

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

@@ -0,0 +1,130 @@
+/*
+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 { dirname } from "@mnaoumov/typescript-lib/path";
+import {
+  BuildMode,
+  cleanObsidianPluginDistFolder,
+  completeObsidianPluginDistFolder,
+  getObsidianPluginBanner,
+  resolveObsidianPluginBuildContext
+} from "./obsidian-plugin-build.mjs";
+import { getJsxImportSource } from "./obsidian-plugin-features.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 applyRollupInputDefaults(params) {
+  const { buildContext, inputOptions } = params;
+  const jsxImportSource = getJsxImportSource(params.features?.framework);
+  return {
+    ...inputOptions,
+    external: combineExternal(inputOptions.external),
+    input: inputOptions.input ?? buildContext.entryPoint,
+    ...jsxImportSource !== void 0 && inputOptions.jsx === void 0 && { jsx: { jsxImportSource, mode: "automatic" } }
+  };
+}
+function applyRollupOutputDefaults(params) {
+  const { buildContext, outputOptions } = params;
+  const hasOutputLocation = outputOptions.file !== void 0 || outputOptions.dir !== void 0;
+  return {
+    ...outputOptions,
+    banner: outputOptions.banner ?? getObsidianPluginBanner("rollup"),
+    format: outputOptions.format ?? "cjs",
+    ...!hasOutputLocation && { file: buildContext.mainJsPath },
+    // An Obsidian plugin is one file: the manifest names `main.js` and nothing loads a second chunk.
+    inlineDynamicImports: outputOptions.inlineDynamicImports ?? true,
+    sourcemap: outputOptions.sourcemap ?? (!buildContext.isProductionBuild && "inline")
+  };
+}
+function obsidianPluginRollup(options = {}) {
+  const state = {
+    buildContext: void 0,
+    isDistFolderCleaned: false
+  };
+  function getBuildContext() {
+    if (!state.buildContext) {
+      throw new Error("The obsidian-plugin rollup plugin has not resolved its build context: its `options` hook did not run.");
+    }
+    return state.buildContext;
+  }
+  const featurePlugin = createRollupCompatibleFeaturePlugin({
+    features: options,
+    isProductionBuild: () => getBuildContext().isProductionBuild,
+    shouldCompileStylesheets: true,
+    shouldReplaceDefines: true
+  });
+  const plugin = {
+    generateBundle: {
+      handler(_outputOptions, bundle) {
+        renameCssAssets(this, bundle);
+      },
+      order: "post"
+    },
+    name: "obsidian-plugin",
+    async options(inputOptions) {
+      const mode = options.mode ?? (this.meta.watchMode ? BuildMode.Development : BuildMode.Production);
+      state.buildContext = await resolveObsidianPluginBuildContext({ ...options, mode });
+      return applyRollupInputDefaults({ buildContext: state.buildContext, features: options, inputOptions });
+    },
+    outputOptions(outputOptions) {
+      return applyRollupOutputDefaults({ buildContext: getBuildContext(), outputOptions });
+    },
+    async renderStart(outputOptions) {
+      if (state.isDistFolderCleaned) {
+        return;
+      }
+      state.isDistFolderCleaned = true;
+      await cleanObsidianPluginDistFolder(getOutputFolder(outputOptions));
+    },
+    async writeBundle(outputOptions) {
+      const buildContext = { ...getBuildContext(), distFolder: getOutputFolder(outputOptions) };
+      await completeObsidianPluginDistFolder(buildContext);
+      await deployToObsidianPluginsFolder(buildContext);
+    }
+  };
+  return [plugin, featurePlugin, createUnpluginVuePlugin({ bundler: "rollup", features: options })];
+}
+function getOutputFolder(outputOptions) {
+  return outputOptions.dir ?? dirname(outputOptions.file ?? "");
+}
+export {
+  applyRollupInputDefaults,
+  applyRollupOutputDefaults,
+  obsidianPluginRollup
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/bundlers/rollup.ts"],"sourcesContent":["/**\n * @file\n *\n * Builds an Obsidian plugin with rollup: a rollup 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 `rollup.config` leaves unset.\n *\n * `rollup` 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  InputOptions,\n  InputPluginOption,\n  NormalizedOutputOptions,\n  OutputOptions,\n  Plugin\n} from 'rollup';\n\nimport { dirname } from '@mnaoumov/typescript-lib/path';\n\nimport type {\n  ObsidianPluginBuildContext,\n  ObsidianPluginDeploymentOptions\n} from './obsidian-plugin-build.ts';\nimport type { ObsidianPluginFeatureOptions } from './obsidian-plugin-features.ts';\n\nimport {\n  BuildMode,\n  cleanObsidianPluginDistFolder,\n  completeObsidianPluginDistFolder,\n  getObsidianPluginBanner,\n  resolveObsidianPluginBuildContext\n} from './obsidian-plugin-build.ts';\nimport { getJsxImportSource } from './obsidian-plugin-features.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 applyRollupInputDefaults}.\n */\nexport interface ApplyRollupInputDefaultsParams {\n  /**\n   * The build context.\n   */\n  readonly buildContext: ObsidianPluginBuildContext;\n\n  /**\n   * The build features.\n   */\n  readonly features?: ObsidianPluginFeatureOptions;\n\n  /**\n   * The consumer's input options.\n   */\n  readonly inputOptions: InputOptions;\n}\n\n/**\n * Parameters for {@link applyRollupOutputDefaults}.\n */\nexport interface ApplyRollupOutputDefaultsParams {\n  /**\n   * The build context.\n   */\n  readonly buildContext: ObsidianPluginBuildContext;\n\n  /**\n   * The consumer's output options.\n   */\n  readonly outputOptions: OutputOptions;\n}\n\n/**\n * Options for {@link obsidianPluginRollup}.\n */\nexport interface ObsidianPluginRollupOptions extends ObsidianPluginDeploymentOptions, ObsidianPluginFeatureOptions {\n  /**\n   * The build mode. Defaults to {@link BuildMode.Development} in watch mode (`rollup --watch`) and\n   * {@link BuildMode.Production} otherwise.\n   */\n  readonly mode?: BuildMode;\n}\n\n/**\n * The state one {@link obsidianPluginRollup} instance keeps across the hooks of a build, and across the\n * rebuilds of a watch.\n */\ninterface ObsidianPluginRollupState {\n  buildContext: ObsidianPluginBuildContext | undefined;\n  isDistFolderCleaned: boolean;\n}\n\n/**\n * Fills in the rollup input options the consumer left unset.\n *\n * @param params - The {@link ApplyRollupInputDefaultsParams}.\n * @returns The input options with the plugin's defaults applied.\n */\nexport function applyRollupInputDefaults(params: ApplyRollupInputDefaultsParams): InputOptions {\n  const { buildContext, inputOptions } = params;\n  const jsxImportSource = getJsxImportSource(params.features?.framework);\n  return {\n    ...inputOptions,\n    external: combineExternal(inputOptions.external),\n    input: inputOptions.input ?? buildContext.entryPoint,\n    ...(jsxImportSource !== undefined && inputOptions.jsx === undefined && { jsx: { jsxImportSource, mode: 'automatic' } })\n  };\n}\n\n/**\n * Fills in the rollup output options the consumer left unset.\n *\n * @param params - The {@link ApplyRollupOutputDefaultsParams}.\n * @returns The output options with the plugin's defaults applied.\n */\nexport function applyRollupOutputDefaults(params: ApplyRollupOutputDefaultsParams): OutputOptions {\n  const { buildContext, outputOptions } = params;\n  const hasOutputLocation = outputOptions.file !== undefined || outputOptions.dir !== undefined;\n  return {\n    ...outputOptions,\n    banner: outputOptions.banner ?? getObsidianPluginBanner('rollup'),\n    format: outputOptions.format ?? 'cjs',\n    ...(!hasOutputLocation && { file: buildContext.mainJsPath }),\n    // An Obsidian plugin is one file: the manifest names `main.js` and nothing loads a second chunk.\n    inlineDynamicImports: outputOptions.inlineDynamicImports ?? true,\n    sourcemap: outputOptions.sourcemap ?? (!buildContext.isProductionBuild && 'inline')\n  };\n}\n\n/**\n * Creates a rollup plugin that builds an Obsidian plugin.\n *\n * What it does, each only when the consumer's config has not said otherwise:\n *\n * - `input` is `src/main.ts`.\n * - The output is one CommonJS `main.js` in `dist/build` (`dist/dev` in watch mode), with dynamic imports\n *   inlined, the generated-file banner, and an inline source map in development.\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 before the first write,\n * every emitted CSS file ends up in `styles.css`, `manifest.json` (and in development `.hotreload`) is\n * copied beside it, and a development build is deployed into the vault named by `OBSIDIAN_CONFIG_FOLDER`.\n *\n * TypeScript, dependency resolution and minification stay the consumer's choice of rollup plugins, as they would be\n * without this one. The build features ({@link ObsidianPluginFeatureOptions}) are the plugin's:\n *\n * - `framework: 'react' | 'preact'` sets rollup's `jsx` option to the automatic runtime (unless set), and the\n *   TypeScript plugin reads the same from the toolkit's tsconfig preset.\n * - `framework: 'solid' | 'svelte'` compiles the components with the toolkit's shared transforms, and `'vue'` adds\n *   `unplugin-vue`.\n * - Any framework replaces `process.env.NODE_ENV` (and Vue's feature flags) in the bundled code.\n * - `styles` compiles every stylesheet itself (PostCSS, Tailwind, CSS modules), so rollup needs no CSS plugin; leave\n *   it out. `styles: {}` compiles plain CSS.\n * - `wasm` imports a `.wasm` module as its bytes.\n *\n * @param options - The {@link ObsidianPluginRollupOptions}.\n * @returns The rollup plugins, which rollup takes as one entry of its `plugins`.\n */\nexport function obsidianPluginRollup(options: ObsidianPluginRollupOptions = {}): InputPluginOption[] {\n  const state: ObsidianPluginRollupState = {\n    buildContext: undefined,\n    isDistFolderCleaned: false\n  };\n\n  /* v8 ignore start -- Rollup hooks; exercised by the bundler integration test against a real rollup build. */\n  function getBuildContext(): ObsidianPluginBuildContext {\n    if (!state.buildContext) {\n      throw new Error('The obsidian-plugin rollup plugin has not resolved its build context: its `options` hook did not run.');\n    }\n    return state.buildContext;\n  }\n\n  const featurePlugin = createRollupCompatibleFeaturePlugin({\n    features: options,\n    isProductionBuild: () => getBuildContext().isProductionBuild,\n    shouldCompileStylesheets: true,\n    shouldReplaceDefines: true\n  });\n\n  const plugin: Plugin = {\n    generateBundle: {\n      handler(_outputOptions, bundle): void {\n        renameCssAssets(this, bundle);\n      },\n      order: 'post'\n    },\n    name: 'obsidian-plugin',\n    async options(inputOptions): Promise<InputOptions> {\n      const mode = options.mode ?? (this.meta.watchMode ? BuildMode.Development : BuildMode.Production);\n      state.buildContext = await resolveObsidianPluginBuildContext({ ...options, mode });\n      return applyRollupInputDefaults({ buildContext: state.buildContext, features: options, inputOptions });\n    },\n    outputOptions(outputOptions): OutputOptions {\n      return applyRollupOutputDefaults({ buildContext: getBuildContext(), outputOptions });\n    },\n    async renderStart(outputOptions): Promise<void> {\n      if (state.isDistFolderCleaned) {\n        return;\n      }\n      state.isDistFolderCleaned = true;\n      await cleanObsidianPluginDistFolder(getOutputFolder(outputOptions));\n    },\n    async writeBundle(outputOptions): Promise<void> {\n      const buildContext = { ...getBuildContext(), distFolder: getOutputFolder(outputOptions) };\n      await completeObsidianPluginDistFolder(buildContext);\n      await deployToObsidianPluginsFolder(buildContext);\n    }\n  };\n  return [plugin, featurePlugin as Plugin, createUnpluginVuePlugin({ bundler: 'rollup', features: options }) as Promise<null | Plugin>];\n  /* v8 ignore stop */\n}\n\n/* v8 ignore start -- Part of the rollup hooks above. */\nfunction getOutputFolder(outputOptions: NormalizedOutputOptions): string {\n  return outputOptions.dir ?? dirname(outputOptions.file ?? '');\n}\n/* v8 ignore stop */\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmBA,SAAS,eAAe;AAQxB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,0BAA0B;AACnC,SAAS,qCAAqC;AAC9C;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AA+DA,SAAS,yBAAyB,QAAsD;AAC7F,QAAM,EAAE,cAAc,aAAa,IAAI;AACvC,QAAM,kBAAkB,mBAAmB,OAAO,UAAU,SAAS;AACrE,SAAO;AAAA,IACL,GAAG;AAAA,IACH,UAAU,gBAAgB,aAAa,QAAQ;AAAA,IAC/C,OAAO,aAAa,SAAS,aAAa;AAAA,IAC1C,GAAI,oBAAoB,UAAa,aAAa,QAAQ,UAAa,EAAE,KAAK,EAAE,iBAAiB,MAAM,YAAY,EAAE;AAAA,EACvH;AACF;AAQO,SAAS,0BAA0B,QAAwD;AAChG,QAAM,EAAE,cAAc,cAAc,IAAI;AACxC,QAAM,oBAAoB,cAAc,SAAS,UAAa,cAAc,QAAQ;AACpF,SAAO;AAAA,IACL,GAAG;AAAA,IACH,QAAQ,cAAc,UAAU,wBAAwB,QAAQ;AAAA,IAChE,QAAQ,cAAc,UAAU;AAAA,IAChC,GAAI,CAAC,qBAAqB,EAAE,MAAM,aAAa,WAAW;AAAA;AAAA,IAE1D,sBAAsB,cAAc,wBAAwB;AAAA,IAC5D,WAAW,cAAc,cAAc,CAAC,aAAa,qBAAqB;AAAA,EAC5E;AACF;AA+BO,SAAS,qBAAqB,UAAuC,CAAC,GAAwB;AACnG,QAAM,QAAmC;AAAA,IACvC,cAAc;AAAA,IACd,qBAAqB;AAAA,EACvB;AAGA,WAAS,kBAA8C;AACrD,QAAI,CAAC,MAAM,cAAc;AACvB,YAAM,IAAI,MAAM,uGAAuG;AAAA,IACzH;AACA,WAAO,MAAM;AAAA,EACf;AAEA,QAAM,gBAAgB,oCAAoC;AAAA,IACxD,UAAU;AAAA,IACV,mBAAmB,MAAM,gBAAgB,EAAE;AAAA,IAC3C,0BAA0B;AAAA,IAC1B,sBAAsB;AAAA,EACxB,CAAC;AAED,QAAM,SAAiB;AAAA,IACrB,gBAAgB;AAAA,MACd,QAAQ,gBAAgB,QAAc;AACpC,wBAAgB,MAAM,MAAM;AAAA,MAC9B;AAAA,MACA,OAAO;AAAA,IACT;AAAA,IACA,MAAM;AAAA,IACN,MAAM,QAAQ,cAAqC;AACjD,YAAM,OAAO,QAAQ,SAAS,KAAK,KAAK,YAAY,UAAU,cAAc,UAAU;AACtF,YAAM,eAAe,MAAM,kCAAkC,EAAE,GAAG,SAAS,KAAK,CAAC;AACjF,aAAO,yBAAyB,EAAE,cAAc,MAAM,cAAc,UAAU,SAAS,aAAa,CAAC;AAAA,IACvG;AAAA,IACA,cAAc,eAA8B;AAC1C,aAAO,0BAA0B,EAAE,cAAc,gBAAgB,GAAG,cAAc,CAAC;AAAA,IACrF;AAAA,IACA,MAAM,YAAY,eAA8B;AAC9C,UAAI,MAAM,qBAAqB;AAC7B;AAAA,MACF;AACA,YAAM,sBAAsB;AAC5B,YAAM,8BAA8B,gBAAgB,aAAa,CAAC;AAAA,IACpE;AAAA,IACA,MAAM,YAAY,eAA8B;AAC9C,YAAM,eAAe,EAAE,GAAG,gBAAgB,GAAG,YAAY,gBAAgB,aAAa,EAAE;AACxF,YAAM,iCAAiC,YAAY;AACnD,YAAM,8BAA8B,YAAY;AAAA,IAClD;AAAA,EACF;AACA,SAAO,CAAC,QAAQ,eAAyB,wBAAwB,EAAE,SAAS,UAAU,UAAU,QAAQ,CAAC,CAA2B;AAEtI;AAGA,SAAS,gBAAgB,eAAgD;AACvE,SAAO,cAAc,OAAO,QAAQ,cAAc,QAAQ,EAAE;AAC9D;","names":[]}

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

@@ -0,0 +1,105 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @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';
+import type { ObsidianPluginBuildContext, ObsidianPluginDeploymentOptions } from './obsidian-plugin-build.mjs';
+import type { ObsidianPluginFeatureOptions } from './obsidian-plugin-features.mjs';
+import type { PostcssConfig } from './obsidian-plugin-transforms.mjs';
+import { BuildMode } from './obsidian-plugin-build.mjs';
+/**
+ * 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[];