@mnaoumov/obsidian-dev-toolkit 2.1.0 → 3.1.0

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

@@ -0,0 +1,361 @@
+/*
+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 { CliTaskResult } from "@mnaoumov/typescript-dev-toolkit/cli-utils";
+import { npmRunOptional } from "@mnaoumov/typescript-dev-toolkit/npm-run";
+import { invokeAsyncSafely } from "@mnaoumov/typescript-lib/async";
+import {
+  extname,
+  join,
+  relative,
+  toPosixPath
+} from "@mnaoumov/typescript-lib/path";
+import { existsSync } from "node:fs";
+import {
+  mkdir,
+  readFile,
+  writeFile
+} from "node:fs/promises";
+import { ObsidianPluginRepoPaths } from "../obsidian-plugin-repo-paths.mjs";
+import {
+  BuildMode,
+  cleanObsidianPluginDistFolder,
+  completeObsidianPluginDistFolder,
+  getObsidianPluginBanner,
+  OBSIDIAN_PLUGIN_EXTERNALS,
+  resolveFromRoot,
+  resolveObsidianPluginBuildContext
+} from "./obsidian-plugin-build.mjs";
+import {
+  getFrameworkDefines,
+  getJsxImportSource,
+  isPostcssNeeded
+} from "./obsidian-plugin-features.mjs";
+import { deployToObsidianPluginsFolder } from "./obsidian-plugins-folder-deployment.mjs";
+const PARCEL_CACHE_FOLDER = ".parcel-cache";
+const GENERATED_PARCEL_CONFIG_FOLDER = `${PARCEL_CACHE_FOLDER}/obsidian-dev-toolkit`;
+const PARCELRC = ".parcelrc";
+const RESOLVER_FILE_NAME = "obsidian-plugin-resolver.cjs";
+const NAMER_FILE_NAME = "obsidian-plugin-namer.cjs";
+const INLINE_IMPORTS_FILE_NAME = "obsidian-plugin-inline-imports.cjs";
+const OPTIMIZER_FILE_NAME = "obsidian-plugin-optimizer.cjs";
+const FEATURES_FILE_NAME = "obsidian-plugin-features.cjs";
+const JSON_INDENT = 2;
+async function build(options) {
+  const result = await buildObsidianPluginWithParcel({ ...options, mode: BuildMode.Production });
+  result.throwOnFailure();
+}
+async function buildObsidianPluginWithParcel(params) {
+  await npmRunOptional("build:compile");
+  const buildContext = await resolveObsidianPluginBuildContext(params);
+  await cleanObsidianPluginDistFolder(buildContext.distFolder);
+  await completeObsidianPluginDistFolder(buildContext);
+  const configFolder = resolveFromRoot(GENERATED_PARCEL_CONFIG_FOLDER);
+  const consumerParcelrcPath = resolveFromRoot(PARCELRC);
+  await mkdir(configFolder, { recursive: true });
+  const configFiles = getParcelConfigFiles({
+    consumerParcelrcPath: existsSync(consumerParcelrcPath) ? toPosixPath(relative(configFolder, consumerParcelrcPath)) : void 0,
+    features: params
+  });
+  for (const [fileName, contents] of Object.entries(configFiles)) {
+    const filePath = join(configFolder, fileName);
+    if (!existsSync(filePath) || await readFile(filePath, "utf-8") !== contents) {
+      await writeFile(filePath, contents, "utf-8");
+    }
+  }
+  const { Parcel } = await import("@parcel/core");
+  const parcelOptions = getParcelOptions({ buildContext, cacheFolder: resolveFromRoot(PARCEL_CACHE_FOLDER), configPath: join(configFolder, PARCELRC) });
+  const bundler = new Parcel(params.customizeParcelOptions?.(parcelOptions) ?? parcelOptions);
+  if (buildContext.isProductionBuild) {
+    try {
+      const { buildTime, bundleGraph } = await bundler.run();
+      console.warn(`Built ${String(bundleGraph.getBundles().length)} bundle(s) with parcel in ${String(buildTime)} ms.`);
+      return CliTaskResult.Success();
+    } catch (error) {
+      console.error(formatParcelError(error));
+      return CliTaskResult.Failure();
+    }
+  }
+  await bundler.watch((error, event) => {
+    if (error) {
+      console.error(formatParcelError(error));
+      return;
+    }
+    handleWatchEvent(event, buildContext);
+  });
+  return CliTaskResult.DoNotExit();
+}
+async function dev(options) {
+  return await buildObsidianPluginWithParcel({ ...options, mode: BuildMode.Development });
+}
+function getParcelConfigFiles(params) {
+  const { consumerParcelrcPath, features = {} } = params;
+  const featureTransformer = `./${FEATURES_FILE_NAME}`;
+  const transformers = {};
+  if (features.framework === "svelte") {
+    transformers["*.svelte"] = [featureTransformer];
+    transformers["*.svelte.{js,ts}"] = [featureTransformer, `./${INLINE_IMPORTS_FILE_NAME}`, "..."];
+  }
+  if (features.framework === "solid" || getJsxImportSource(features.framework) !== void 0) {
+    transformers["*.{jsx,tsx}"] = [featureTransformer];
+  }
+  if (features.wasm) {
+    transformers["*.wasm"] = [featureTransformer];
+  }
+  if (isPostcssNeeded(features.styles)) {
+    transformers["*.{css,pcss}"] = [featureTransformer, "@parcel/transformer-css"];
+  }
+  const defines = getFrameworkDefines({ framework: features.framework, isProductionBuild: true });
+  transformers["*.{js,mjs,cjs,jsx,ts,mts,cts,tsx}"] = [
+    ...Object.keys(defines).length > 0 ? [featureTransformer] : [],
+    `./${INLINE_IMPORTS_FILE_NAME}`,
+    "..."
+  ];
+  const parcelrc = {
+    extends: consumerParcelrcPath ?? "@parcel/config-default",
+    namers: [`./${NAMER_FILE_NAME}`, "..."],
+    optimizers: {
+      "*.js": ["...", `./${OPTIMIZER_FILE_NAME}`]
+    },
+    resolvers: [`./${RESOLVER_FILE_NAME}`, "..."],
+    transformers
+  };
+  return {
+    [FEATURES_FILE_NAME]: `/*
+ * Generated by @mnaoumov/obsidian-dev-toolkit. Runs the toolkit's shared transforms for the build features, loaded
+ * from the toolkit itself, so parcel compiles each feature the way every other bundler adapter does.
+ */
+const { Transformer } = require('@parcel/plugin');
+
+const FEATURES_MODULE_URL = ${JSON.stringify(getSiblingModuleUrl("obsidian-plugin-features"))};
+const TRANSFORMS_MODULE_URL = ${JSON.stringify(getSiblingModuleUrl("obsidian-plugin-transforms"))};
+const FRAMEWORK = ${JSON.stringify(features.framework ?? null)};
+const STYLES = ${JSON.stringify(features.styles ?? {})};
+
+module.exports = new Transformer({
+  async transform({ asset, options }) {
+    const { getFeatureFileKind, getFrameworkDefines, getJsxImportSource, replaceDefines } = await import(FEATURES_MODULE_URL);
+    const transforms = await import(TRANSFORMS_MODULE_URL);
+    const filePath = asset.filePath;
+    const isProductionBuild = options.mode === 'production';
+    const defines = getFrameworkDefines({ framework: FRAMEWORK ?? undefined, isProductionBuild });
+    switch (getFeatureFileKind(filePath)) {
+      case 'jsx': {
+        const code = await asset.getCode();
+        const jsxImportSource = getJsxImportSource(FRAMEWORK ?? undefined);
+        const result = FRAMEWORK === 'solid'
+          ? await transforms.transformSolid({ code, filePath, isProductionBuild })
+          : await transforms.transformJsx({ code, filePath, isProductionBuild, jsxImportSource });
+        asset.setCode(replaceDefines(result.code, defines));
+        asset.type = 'js';
+        break;
+      }
+      case 'stylesheet': {
+        const result = await transforms.transformCss({ filePath, isCssModuleScoped: false, isProductionBuild, source: await asset.getCode(), styles: STYLES });
+        asset.setCode(result.css);
+        for (const dependency of result.dependencies) {
+          asset.invalidateOnFileChange(dependency);
+        }
+        break;
+      }
+      case 'svelte': {
+        const result = await transforms.transformSvelte({ code: await asset.getCode(), filePath, isProductionBuild });
+        asset.setCode(replaceDefines(result.code, defines));
+        asset.type = 'js';
+        break;
+      }
+      case 'wasm':
+        asset.setCode(transforms.getWasmModuleCode(await asset.getBuffer()));
+        asset.type = 'js';
+        break;
+      default: {
+        // A framework's runtime reads process.env.NODE_ENV, which parcel leaves alone in an electron-renderer library.
+        const code = await asset.getCode();
+        const replaced = replaceDefines(code, defines);
+        if (replaced !== code) {
+          asset.setCode(replaced);
+        }
+        break;
+      }
+    }
+    return [asset];
+  }
+});
+`,
+    // `String.raw`, so the regular expression below reaches the file with its backslashes intact.
+    [INLINE_IMPORTS_FILE_NAME]: String.raw`/*
+ * Generated by @mnaoumov/obsidian-dev-toolkit. Keeps every dynamic import() inside main.js.
+ *
+ * Obsidian loads a plugin's main.js and nothing beside it, and parcel makes every import() a bundle of its
+ * own with no option to inline one. This rewrites import("<literal>") into a require() inside an async
+ * arrow, before parcel's own JavaScript transformer runs: the module still evaluates only when that code
+ * runs, and the promise still rejects when evaluation throws. Only a plain string specifier is rewritten,
+ * since a computed one cannot be bundled by any bundler.
+ */
+const { Transformer } = require('@parcel/plugin');
+
+const DYNAMIC_IMPORT = /\bimport\(\s*(["'])([^"'\x60\n\\]+)\1\s*\)/gu;
+
+module.exports = new Transformer({
+  async transform({ asset }) {
+    const source = await asset.getCode();
+    if (source.includes('import(')) {
+      asset.setCode(source.replace(DYNAMIC_IMPORT, (_match, quote, specifier) => '(async () => require(' + quote + specifier + quote + '))()'));
+    }
+    return [asset];
+  }
+});
+`,
+    [NAMER_FILE_NAME]: `/* Generated by @mnaoumov/obsidian-dev-toolkit. Obsidian loads a plugin's stylesheet from styles.css and nothing else. */
+const { Namer } = require('@parcel/plugin');
+
+module.exports = new Namer({
+  name({ bundle }) {
+    return bundle.type === 'css' ? '${ObsidianPluginRepoPaths.StylesCss}' : null;
+  }
+});
+`,
+    [OPTIMIZER_FILE_NAME]: `/*
+ * Generated by @mnaoumov/obsidian-dev-toolkit. Runs after parcel's own optimizers, on the JavaScript bundle.
+ *
+ * Obsidian evaluates main.js as the body of function (require, module, exports), with a module object that
+ * has no require of its own, and parcel's runtime reaches every external module through module.require.
+ * Without the first line below, the very first require('obsidian') throws "Cannot find module". The banner
+ * goes in here too, after minification, which would otherwise strip it as an ordinary comment.
+ */
+const { Optimizer } = require('@parcel/plugin');
+
+const PREAMBLE = ${JSON.stringify(`${getObsidianPluginBanner("parcel")}if (typeof module === 'object' && typeof module.require !== 'function') { module.require = require; }
+`)};
+const PREAMBLE_LINE_COUNT = ${String(getObsidianPluginBanner("parcel").split("\n").length)};
+
+async function readContents(contents) {
+  if (typeof contents === 'string') {
+    return contents;
+  }
+  if (Buffer.isBuffer(contents)) {
+    return contents.toString('utf-8');
+  }
+  const chunks = [];
+  for await (const chunk of contents) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString('utf-8');
+}
+
+module.exports = new Optimizer({
+  async optimize({ contents, map }) {
+    const code = await readContents(contents);
+    if (map) {
+      map.offsetLines(1, PREAMBLE_LINE_COUNT);
+    }
+    return { contents: PREAMBLE + code, map };
+  }
+});
+`,
+    [PARCELRC]: `${JSON.stringify(parcelrc, null, JSON_INDENT)}
+`,
+    [RESOLVER_FILE_NAME]: `/* Generated by @mnaoumov/obsidian-dev-toolkit. Leaves the modules Obsidian supplies at runtime to require(). */
+const { Resolver } = require('@parcel/plugin');
+
+const EXTERNALS = new Set(${JSON.stringify(OBSIDIAN_PLUGIN_EXTERNALS)});
+
+function getPackageName(specifier) {
+  const segments = specifier.split('/');
+  return specifier.startsWith('@') ? segments.slice(0, 2).join('/') : segments[0];
+}
+
+module.exports = new Resolver({
+  resolve({ specifier }) {
+    const isExternal = specifier.startsWith('node:') || EXTERNALS.has(specifier) || EXTERNALS.has(getPackageName(specifier));
+    return isExternal ? { isExcluded: true } : null;
+  }
+});
+`
+  };
+}
+function getParcelOptions(params) {
+  const { buildContext, cacheFolder, configPath } = params;
+  const target = {
+    context: "electron-renderer",
+    // eslint-disable-next-line unicorn/name-replacements -- `distDir` is the name parcel's API reads.
+    distDir: buildContext.distFolder,
+    includeNodeModules: true,
+    isLibrary: true,
+    optimize: buildContext.isProductionBuild,
+    outputFormat: "commonjs",
+    sourceMap: !buildContext.isProductionBuild && { inline: true }
+  };
+  return {
+    // eslint-disable-next-line unicorn/name-replacements -- `cacheDir` is the name parcel's API reads.
+    cacheDir: cacheFolder,
+    config: configPath,
+    defaultTargetOptions: {
+      // eslint-disable-next-line unicorn/name-replacements -- `distDir` is the name parcel's API reads.
+      distDir: buildContext.distFolder,
+      shouldOptimize: buildContext.isProductionBuild,
+      sourceMaps: !buildContext.isProductionBuild
+    },
+    entries: buildContext.entryPoint,
+    mode: buildContext.isProductionBuild ? "production" : "development",
+    targets: { obsidianPlugin: target }
+  };
+}
+function formatParcelError(error) {
+  const diagnostics = error?.diagnostics;
+  if (diagnostics && diagnostics.length > 0) {
+    return diagnostics.map((diagnostic) => diagnostic.message).join("\n");
+  }
+  return error instanceof Error ? error.stack ?? error.message : String(error);
+}
+function getSiblingModuleUrl(baseName) {
+  return new URL(`${baseName}${extname(new URL(import.meta.url).pathname)}`, import.meta.url).href;
+}
+function handleWatchEvent(event, buildContext) {
+  if (event?.type === "buildFailure") {
+    console.error(event.diagnostics.map((diagnostic) => diagnostic.message).join("\n"));
+    return;
+  }
+  if (event?.type !== "buildSuccess") {
+    return;
+  }
+  console.warn(`Rebuilt with parcel in ${String(event.buildTime)} ms.`);
+  invokeAsyncSafely(() => deployToObsidianPluginsFolder(buildContext));
+}
+export {
+  build,
+  buildObsidianPluginWithParcel,
+  dev,
+  getParcelConfigFiles,
+  getParcelOptions
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/bundlers/parcel.ts"],"sourcesContent":["/**\n * @file\n *\n * Builds an Obsidian plugin with parcel: `build()` and `dev()`, the same two entry points the esbuild\n * builder has, producing the same `main.js` + `styles.css` + `manifest.json` layout.\n *\n * Parcel takes no `external` list and no output file name, only plugins named in a `.parcelrc`. So the\n * build writes a `.parcelrc` of its own into `.parcel-cache`, beside a resolver that leaves\n * Obsidian's modules external, a namer that names the stylesheet `styles.css` and a transformer that keeps\n * dynamic imports inside `main.js`, and extends the\n * consumer's own `.parcelrc` when there is one (or `@parcel/config-default` when there is none), so every\n * transformer the consumer configured still applies.\n *\n * `@parcel/core`, `@parcel/plugin` and `@parcel/config-default` are optional peer dependencies, loaded\n * only when a parcel build runs, so a plugin built with esbuild installs nothing extra.\n */\n\nimport type {\n  BuildEvent,\n  InitialParcelOptions,\n  TargetDescriptor\n} from '@parcel/types';\n\nimport { CliTaskResult } from '@mnaoumov/typescript-dev-toolkit/cli-utils';\nimport { npmRunOptional } from '@mnaoumov/typescript-dev-toolkit/npm-run';\nimport { invokeAsyncSafely } from '@mnaoumov/typescript-lib/async';\nimport {\n  extname,\n  join,\n  relative,\n  toPosixPath\n} from '@mnaoumov/typescript-lib/path';\nimport { existsSync } from 'node:fs';\nimport {\n  mkdir,\n  readFile,\n  writeFile\n} from 'node:fs/promises';\n\nimport type {\n  ObsidianPluginBuildContext,\n  ObsidianPluginDeploymentOptions\n} from './obsidian-plugin-build.ts';\nimport type { ObsidianPluginFeatureOptions } from './obsidian-plugin-features.ts';\n\nimport { ObsidianPluginRepoPaths } from '../obsidian-plugin-repo-paths.ts';\nimport {\n  BuildMode,\n  cleanObsidianPluginDistFolder,\n  completeObsidianPluginDistFolder,\n  getObsidianPluginBanner,\n  OBSIDIAN_PLUGIN_EXTERNALS,\n  resolveFromRoot,\n  resolveObsidianPluginBuildContext\n} from './obsidian-plugin-build.ts';\nimport {\n  getFrameworkDefines,\n  getJsxImportSource,\n  isPostcssNeeded\n} from './obsidian-plugin-features.ts';\nimport { deployToObsidianPluginsFolder } from './obsidian-plugins-folder-deployment.ts';\n\n/**\n * Options for {@link buildObsidianPluginWithParcel}.\n */\nexport interface BuildObsidianPluginWithParcelParams extends BuildOptions {\n  /**\n   * A build mode, either `Development` or `Production`.\n   */\n  readonly mode: BuildMode;\n}\n\n/**\n * Options for {@link build} and {@link dev}.\n */\nexport interface BuildOptions extends ObsidianPluginDeploymentOptions, ObsidianPluginFeatureOptions {\n  /**\n   * Customizes the options handed to parcel's `Parcel` class.\n   */\n  readonly customizeParcelOptions?: (options: InitialParcelOptions) => InitialParcelOptions;\n}\n\n/**\n * Parameters for {@link getParcelConfigFiles}.\n */\nexport interface GetParcelConfigFilesParams {\n  /**\n   * The consumer's own `.parcelrc`, relative to the generated configuration's folder, or `undefined` when the project\n   * has none.\n   */\n  readonly consumerParcelrcPath: string | undefined;\n\n  /**\n   * The build features.\n   */\n  readonly features?: ObsidianPluginFeatureOptions;\n}\n\n/**\n * Parameters for {@link getParcelOptions}.\n */\nexport interface GetParcelOptionsParams {\n  /**\n   * The build context.\n   */\n  readonly buildContext: ObsidianPluginBuildContext;\n\n  /**\n   * Parcel's cache folder. Named explicitly because parcel otherwise takes the folder of the nearest\n   * lockfile for the project root, which in a workspace is not the plugin's.\n   */\n  readonly cacheFolder: string;\n\n  /**\n   * The generated `.parcelrc`.\n   */\n  readonly configPath: string;\n}\n\n/**\n * The files of the generated parcel configuration, by file name.\n */\nexport type ParcelConfigFiles = Readonly<Record<string, string>>;\n\n// Inside parcel's own cache folder: parcel refuses relative plugins in a config under `node_modules` (it\n// takes such a config for a published package), and it never watches its cache folder, so regenerating\n// these files on every build cannot trigger a rebuild.\nconst PARCEL_CACHE_FOLDER = '.parcel-cache';\nconst GENERATED_PARCEL_CONFIG_FOLDER = `${PARCEL_CACHE_FOLDER}/obsidian-dev-toolkit`;\nconst PARCELRC = '.parcelrc';\n\n/**\n * One diagnostic of a {@link ParcelErrorLike}.\n */\ninterface ParcelErrorDiagnostic {\n  readonly message: string;\n}\n\n/**\n * What parcel throws when a build fails: an error carrying its diagnostics.\n */\ninterface ParcelErrorLike {\n  readonly diagnostics?: readonly ParcelErrorDiagnostic[];\n}\nconst RESOLVER_FILE_NAME = 'obsidian-plugin-resolver.cjs';\nconst NAMER_FILE_NAME = 'obsidian-plugin-namer.cjs';\nconst INLINE_IMPORTS_FILE_NAME = 'obsidian-plugin-inline-imports.cjs';\nconst OPTIMIZER_FILE_NAME = 'obsidian-plugin-optimizer.cjs';\nconst FEATURES_FILE_NAME = 'obsidian-plugin-features.cjs';\nconst JSON_INDENT = 2;\n\n/* v8 ignore start -- Runs a real parcel build; exercised by the bundler integration test. */\n/**\n * Builds the Obsidian plugin in production mode using parcel.\n *\n * @param options - Optional build options.\n * @returns A {@link Promise} that resolves when the build is complete.\n */\nexport async function build(options?: BuildOptions): Promise<void> {\n  const result = await buildObsidianPluginWithParcel({ ...options, mode: BuildMode.Production });\n  result.throwOnFailure();\n}\n\n/**\n * Builds the Obsidian plugin with parcel, once for a production build, or watching for a development one.\n *\n * Runs the project's `build:compile` script first when it has one, as the esbuild builder does, since\n * parcel strips TypeScript types without checking them.\n *\n * @param params - The {@link BuildObsidianPluginWithParcelParams}.\n * @returns A {@link Promise} that resolves to a {@link CliTaskResult} indicating the success or failure of the build.\n */\nexport async function buildObsidianPluginWithParcel(params: BuildObsidianPluginWithParcelParams): Promise<CliTaskResult> {\n  await npmRunOptional('build:compile');\n  const buildContext = await resolveObsidianPluginBuildContext(params);\n  await cleanObsidianPluginDistFolder(buildContext.distFolder);\n  await completeObsidianPluginDistFolder(buildContext);\n\n  const configFolder = resolveFromRoot(GENERATED_PARCEL_CONFIG_FOLDER);\n  const consumerParcelrcPath = resolveFromRoot(PARCELRC);\n  await mkdir(configFolder, { recursive: true });\n  const configFiles = getParcelConfigFiles({\n    consumerParcelrcPath: existsSync(consumerParcelrcPath) ? toPosixPath(relative(configFolder, consumerParcelrcPath)) : undefined,\n    features: params\n  });\n  for (const [fileName, contents] of Object.entries(configFiles)) {\n    const filePath = join(configFolder, fileName);\n    // Rewritten only when it changed: parcel invalidates its cache on a config file's modification time.\n    if (!existsSync(filePath) || await readFile(filePath, 'utf-8') !== contents) {\n      await writeFile(filePath, contents, 'utf-8');\n    }\n  }\n\n  const { Parcel } = await import('@parcel/core');\n  const parcelOptions = getParcelOptions({ buildContext, cacheFolder: resolveFromRoot(PARCEL_CACHE_FOLDER), configPath: join(configFolder, PARCELRC) });\n  const bundler = new Parcel(params.customizeParcelOptions?.(parcelOptions) ?? parcelOptions);\n\n  if (buildContext.isProductionBuild) {\n    try {\n      const { buildTime, bundleGraph } = await bundler.run();\n      console.warn(`Built ${String(bundleGraph.getBundles().length)} bundle(s) with parcel in ${String(buildTime)} ms.`);\n      return CliTaskResult.Success();\n    } catch (error) {\n      console.error(formatParcelError(error));\n      return CliTaskResult.Failure();\n    }\n  }\n\n  await bundler.watch((error, event) => {\n    if (error) {\n      console.error(formatParcelError(error));\n      return;\n    }\n    handleWatchEvent(event, buildContext);\n  });\n  return CliTaskResult.DoNotExit();\n}\n\n/**\n * Builds the Obsidian plugin in development mode using parcel, watching for changes and deploying every\n * successful rebuild into the vault.\n *\n * @param options - Optional build options.\n * @returns A {@link Promise} that resolves to a {@link CliTaskResult} indicating the build result.\n */\n// eslint-disable-next-line typescript-dev-toolkit/params-options-name-match -- Intentionally shares BuildOptions with build().\nexport async function dev(options?: BuildOptions): Promise<CliTaskResult> {\n  return await buildObsidianPluginWithParcel({ ...options, mode: BuildMode.Development });\n}\n/* v8 ignore stop */\n\n/**\n * Generates the files of the parcel configuration the build runs with.\n *\n * The build features add pipelines that run the toolkit's shared transforms, through one generated transformer that\n * loads them from the toolkit: Solid's `.jsx` / `.tsx`, Svelte's `.svelte` / `.svelte.ts` / `.svelte.js`, `.wasm`,\n * and with `styles.postcss` or `styles.tailwind` every stylesheet, in place of parcel's own PostCSS step. React and\n * Preact JSX is compiled here too, since parcel reads the JSX runtime from a tsconfig without following its `extends`,\n * and with any framework every script has the framework's compile-time constants replaced. Parcel compiles Vue with\n * `@parcel/transformer-vue` and scopes `*.module.css` itself, so those need no pipeline here.\n *\n * @param params - The {@link GetParcelConfigFilesParams}.\n * @returns The files, by file name.\n */\nexport function getParcelConfigFiles(params: GetParcelConfigFilesParams): ParcelConfigFiles {\n  const { consumerParcelrcPath, features = {} } = params;\n  const featureTransformer = `./${FEATURES_FILE_NAME}`;\n  const transformers: Record<string, string[]> = {};\n  if (features.framework === 'svelte') {\n    transformers['*.svelte'] = [featureTransformer];\n    transformers['*.svelte.{js,ts}'] = [featureTransformer, `./${INLINE_IMPORTS_FILE_NAME}`, '...'];\n  }\n  if (features.framework === 'solid' || getJsxImportSource(features.framework) !== undefined) {\n    transformers['*.{jsx,tsx}'] = [featureTransformer];\n  }\n  if (features.wasm) {\n    transformers['*.wasm'] = [featureTransformer];\n  }\n  if (isPostcssNeeded(features.styles)) {\n    transformers['*.{css,pcss}'] = [featureTransformer, '@parcel/transformer-css'];\n  }\n  const defines = getFrameworkDefines({ framework: features.framework, isProductionBuild: true });\n  transformers['*.{js,mjs,cjs,jsx,ts,mts,cts,tsx}'] = [\n    ...Object.keys(defines).length > 0 ? [featureTransformer] : [],\n    `./${INLINE_IMPORTS_FILE_NAME}`,\n    '...'\n  ];\n\n  const parcelrc = {\n    extends: consumerParcelrcPath ?? '@parcel/config-default',\n    namers: [`./${NAMER_FILE_NAME}`, '...'],\n    optimizers: {\n      '*.js': ['...', `./${OPTIMIZER_FILE_NAME}`]\n    },\n    resolvers: [`./${RESOLVER_FILE_NAME}`, '...'],\n    transformers\n  };\n\n  return {\n    [FEATURES_FILE_NAME]: `/*\n * Generated by @mnaoumov/obsidian-dev-toolkit. Runs the toolkit's shared transforms for the build features, loaded\n * from the toolkit itself, so parcel compiles each feature the way every other bundler adapter does.\n */\nconst { Transformer } = require('@parcel/plugin');\n\nconst FEATURES_MODULE_URL = ${JSON.stringify(getSiblingModuleUrl('obsidian-plugin-features'))};\nconst TRANSFORMS_MODULE_URL = ${JSON.stringify(getSiblingModuleUrl('obsidian-plugin-transforms'))};\nconst FRAMEWORK = ${JSON.stringify(features.framework ?? null)};\nconst STYLES = ${JSON.stringify(features.styles ?? {})};\n\nmodule.exports = new Transformer({\n  async transform({ asset, options }) {\n    const { getFeatureFileKind, getFrameworkDefines, getJsxImportSource, replaceDefines } = await import(FEATURES_MODULE_URL);\n    const transforms = await import(TRANSFORMS_MODULE_URL);\n    const filePath = asset.filePath;\n    const isProductionBuild = options.mode === 'production';\n    const defines = getFrameworkDefines({ framework: FRAMEWORK ?? undefined, isProductionBuild });\n    switch (getFeatureFileKind(filePath)) {\n      case 'jsx': {\n        const code = await asset.getCode();\n        const jsxImportSource = getJsxImportSource(FRAMEWORK ?? undefined);\n        const result = FRAMEWORK === 'solid'\n          ? await transforms.transformSolid({ code, filePath, isProductionBuild })\n          : await transforms.transformJsx({ code, filePath, isProductionBuild, jsxImportSource });\n        asset.setCode(replaceDefines(result.code, defines));\n        asset.type = 'js';\n        break;\n      }\n      case 'stylesheet': {\n        const result = await transforms.transformCss({ filePath, isCssModuleScoped: false, isProductionBuild, source: await asset.getCode(), styles: STYLES });\n        asset.setCode(result.css);\n        for (const dependency of result.dependencies) {\n          asset.invalidateOnFileChange(dependency);\n        }\n        break;\n      }\n      case 'svelte': {\n        const result = await transforms.transformSvelte({ code: await asset.getCode(), filePath, isProductionBuild });\n        asset.setCode(replaceDefines(result.code, defines));\n        asset.type = 'js';\n        break;\n      }\n      case 'wasm':\n        asset.setCode(transforms.getWasmModuleCode(await asset.getBuffer()));\n        asset.type = 'js';\n        break;\n      default: {\n        // A framework's runtime reads process.env.NODE_ENV, which parcel leaves alone in an electron-renderer library.\n        const code = await asset.getCode();\n        const replaced = replaceDefines(code, defines);\n        if (replaced !== code) {\n          asset.setCode(replaced);\n        }\n        break;\n      }\n    }\n    return [asset];\n  }\n});\n`,\n    // `String.raw`, so the regular expression below reaches the file with its backslashes intact.\n    [INLINE_IMPORTS_FILE_NAME]: String.raw`/*\n * Generated by @mnaoumov/obsidian-dev-toolkit. Keeps every dynamic import() inside main.js.\n *\n * Obsidian loads a plugin's main.js and nothing beside it, and parcel makes every import() a bundle of its\n * own with no option to inline one. This rewrites import('<literal>') into a require() inside an async\n * arrow, before parcel's own JavaScript transformer runs: the module still evaluates only when that code\n * runs, and the promise still rejects when evaluation throws. Only a plain string specifier is rewritten,\n * since a computed one cannot be bundled by any bundler.\n */\nconst { Transformer } = require('@parcel/plugin');\n\nconst DYNAMIC_IMPORT = /\\bimport\\(\\s*([\"'])([^\"'\\x60\\n\\\\]+)\\1\\s*\\)/gu;\n\nmodule.exports = new Transformer({\n  async transform({ asset }) {\n    const source = await asset.getCode();\n    if (source.includes('import(')) {\n      asset.setCode(source.replace(DYNAMIC_IMPORT, (_match, quote, specifier) => '(async () => require(' + quote + specifier + quote + '))()'));\n    }\n    return [asset];\n  }\n});\n`,\n    [NAMER_FILE_NAME]: `/* Generated by @mnaoumov/obsidian-dev-toolkit. Obsidian loads a plugin's stylesheet from styles.css and nothing else. */\nconst { Namer } = require('@parcel/plugin');\n\nmodule.exports = new Namer({\n  name({ bundle }) {\n    return bundle.type === 'css' ? '${ObsidianPluginRepoPaths.StylesCss}' : null;\n  }\n});\n`,\n    [OPTIMIZER_FILE_NAME]: `/*\n * Generated by @mnaoumov/obsidian-dev-toolkit. Runs after parcel's own optimizers, on the JavaScript bundle.\n *\n * Obsidian evaluates main.js as the body of function (require, module, exports), with a module object that\n * has no require of its own, and parcel's runtime reaches every external module through module.require.\n * Without the first line below, the very first require('obsidian') throws \"Cannot find module\". The banner\n * goes in here too, after minification, which would otherwise strip it as an ordinary comment.\n */\nconst { Optimizer } = require('@parcel/plugin');\n\nconst PREAMBLE = ${JSON.stringify(`${getObsidianPluginBanner('parcel')}if (typeof module === 'object' && typeof module.require !== 'function') { module.require = require; }\\n`)};\nconst PREAMBLE_LINE_COUNT = ${String(getObsidianPluginBanner('parcel').split('\\n').length)};\n\nasync function readContents(contents) {\n  if (typeof contents === 'string') {\n    return contents;\n  }\n  if (Buffer.isBuffer(contents)) {\n    return contents.toString('utf-8');\n  }\n  const chunks = [];\n  for await (const chunk of contents) {\n    chunks.push(Buffer.from(chunk));\n  }\n  return Buffer.concat(chunks).toString('utf-8');\n}\n\nmodule.exports = new Optimizer({\n  async optimize({ contents, map }) {\n    const code = await readContents(contents);\n    if (map) {\n      map.offsetLines(1, PREAMBLE_LINE_COUNT);\n    }\n    return { contents: PREAMBLE + code, map };\n  }\n});\n`,\n    [PARCELRC]: `${JSON.stringify(parcelrc, null, JSON_INDENT)}\\n`,\n    [RESOLVER_FILE_NAME]: `/* Generated by @mnaoumov/obsidian-dev-toolkit. Leaves the modules Obsidian supplies at runtime to require(). */\nconst { Resolver } = require('@parcel/plugin');\n\nconst EXTERNALS = new Set(${JSON.stringify(OBSIDIAN_PLUGIN_EXTERNALS)});\n\nfunction getPackageName(specifier) {\n  const segments = specifier.split('/');\n  return specifier.startsWith('@') ? segments.slice(0, 2).join('/') : segments[0];\n}\n\nmodule.exports = new Resolver({\n  resolve({ specifier }) {\n    const isExternal = specifier.startsWith('node:') || EXTERNALS.has(specifier) || EXTERNALS.has(getPackageName(specifier));\n    return isExternal ? { isExcluded: true } : null;\n  }\n});\n`\n  };\n}\n\n/**\n * Builds the options handed to parcel's `Parcel` class.\n *\n * The one target is `electron-renderer`, where Obsidian runs a plugin, and CommonJS. Parcel counts that\n * context as both a browser and a node one, and each half matters: node keeps the builtins external, and\n * browser resolves the `browser` export condition. `includeNodeModules` bundles the dependencies, which a\n * node-flavoured context would otherwise leave as `require()` calls nothing installs beside a plugin, and\n * `isLibrary` keeps the entry's default export, which is how Obsidian finds the plugin class.\n *\n * @param params - The {@link GetParcelOptionsParams}.\n * @returns The parcel options.\n */\nexport function getParcelOptions(params: GetParcelOptionsParams): InitialParcelOptions {\n  const { buildContext, cacheFolder, configPath } = params;\n  const target: TargetDescriptor = {\n    context: 'electron-renderer',\n    // eslint-disable-next-line unicorn/name-replacements -- `distDir` is the name parcel's API reads.\n    distDir: buildContext.distFolder,\n    includeNodeModules: true,\n    isLibrary: true,\n    optimize: buildContext.isProductionBuild,\n    outputFormat: 'commonjs',\n    sourceMap: !buildContext.isProductionBuild && { inline: true }\n  };\n\n  return {\n    // eslint-disable-next-line unicorn/name-replacements -- `cacheDir` is the name parcel's API reads.\n    cacheDir: cacheFolder,\n    config: configPath,\n    defaultTargetOptions: {\n      // eslint-disable-next-line unicorn/name-replacements -- `distDir` is the name parcel's API reads.\n      distDir: buildContext.distFolder,\n      shouldOptimize: buildContext.isProductionBuild,\n      sourceMaps: !buildContext.isProductionBuild\n    },\n    entries: buildContext.entryPoint,\n    mode: buildContext.isProductionBuild ? 'production' : 'development',\n    targets: { obsidianPlugin: target }\n  };\n}\n/* v8 ignore start -- Part of the parcel build above. */\nfunction formatParcelError(error: unknown): string {\n  const diagnostics = (error as ParcelErrorLike | undefined)?.diagnostics;\n  if (diagnostics && diagnostics.length > 0) {\n    return diagnostics.map((diagnostic) => diagnostic.message).join('\\n');\n  }\n  return error instanceof Error ? error.stack ?? error.message : String(error);\n}\n\n/**\n * Builds the URL of a module of this folder, in the same form as this one (`.ts` from source, `.mjs` or `.cjs` once\n * built), which the generated transformer imports.\n *\n * @param baseName - The module's file name without its extension.\n * @returns The module's `file:` URL.\n */\nfunction getSiblingModuleUrl(baseName: string): string {\n  return new URL(`${baseName}${extname(new URL(import.meta.url).pathname)}`, import.meta.url).href;\n}\n\nfunction handleWatchEvent(event: BuildEvent | undefined, buildContext: ObsidianPluginBuildContext): void {\n  if (event?.type === 'buildFailure') {\n    console.error(event.diagnostics.map((diagnostic) => diagnostic.message).join('\\n'));\n    return;\n  }\n  if (event?.type !== 'buildSuccess') {\n    return;\n  }\n\n  console.warn(`Rebuilt with parcel in ${String(event.buildTime)} ms.`);\n  invokeAsyncSafely(() => deployToObsidianPluginsFolder(buildContext));\n}\n/* v8 ignore stop */\n"],"mappings":"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","names":[]}

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

@@ -0,0 +1,128 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * The build features of the rollup and vite adapters: one plugin, typed by the shape both bundlers accept, that runs
+ * the shared transforms (Solid, Svelte, stylesheets, WebAssembly) and replaces the framework's compile-time constants,
+ * plus the `unplugin-vue` plugin for Vue.
+ */
+import type { ObsidianPluginFeatureOptions } from './obsidian-plugin-features.mjs';
+import type { SourceMapLike } from './obsidian-plugin-transforms.mjs';
+/**
+ * Parameters for {@link createRollupCompatibleFeaturePlugin}.
+ */
+export interface CreateRollupCompatibleFeaturePluginParams {
+    /**
+     * The build features.
+     */
+    readonly features: ObsidianPluginFeatureOptions;
+    /**
+     * Tells whether the build is a production one. Called from the hooks, after the adapter resolved its build mode.
+     */
+    readonly isProductionBuild: () => boolean;
+    /**
+     * Whether this plugin compiles stylesheets. Vite compiles them itself.
+     */
+    readonly shouldCompileStylesheets: boolean;
+    /**
+     * Whether this plugin replaces the framework's compile-time constants in the code. Vite does it through its own
+     * `define`.
+     */
+    readonly shouldReplaceDefines: boolean;
+}
+/**
+ * Parameters for {@link createUnpluginVuePlugin}.
+ */
+export interface CreateUnpluginVuePluginParams {
+    /**
+     * The bundler, which names the `unplugin-vue` entry.
+     */
+    readonly bundler: 'rollup' | 'vite';
+    /**
+     * The build features.
+     */
+    readonly features: ObsidianPluginFeatureOptions;
+}
+/**
+ * The part of a rollup or rolldown plugin context the feature plugin uses.
+ */
+export interface FeaturePluginContext {
+    /**
+     * Adds a file to watch in a watch build.
+     *
+     * @param id - The file's path.
+     */
+    addWatchFile: (id: string) => void;
+    /**
+     * Emits an asset into the bundle.
+     *
+     * @param emittedFile - The asset to emit.
+     * @returns The reference id of the emitted file.
+     */
+    emitFile: (emittedFile: EmittedAsset) => string;
+}
+/**
+ * The plugin {@link createRollupCompatibleFeaturePlugin} creates, in the shape rollup and vite both accept.
+ */
+export interface RollupCompatibleFeaturePlugin {
+    /**
+     * Loads a `.wasm` module as its bytes.
+     */
+    readonly load: FeaturePluginHook<(this: FeaturePluginContext, id: string) => Promise<null | string>>;
+    /**
+     * The plugin's name.
+     */
+    readonly name: string;
+    /**
+     * Compiles a module the features transform, then replaces the compile-time constants.
+     */
+    readonly transform: FeaturePluginHook<(this: FeaturePluginContext, code: string, id: string) => Promise<null | TransformResultLike>>;
+}
+/**
+ * The asset the feature plugin emits for a stylesheet.
+ */
+interface EmittedAsset {
+    readonly name: string;
+    readonly source: string;
+    readonly type: 'asset';
+}
+/**
+ * A plugin hook with its order.
+ *
+ * @typeParam Handler - The hook's handler.
+ */
+interface FeaturePluginHook<Handler> {
+    readonly handler: Handler;
+    readonly order: 'pre';
+}
+/**
+ * A transform hook's result.
+ */
+interface TransformResultLike {
+    readonly code: string;
+    readonly map?: SourceMapLike | undefined;
+}
+/**
+ * Creates the plugin that runs the shared transforms in a rollup or vite build.
+ *
+ * - `framework: 'solid'` compiles `.jsx` / `.tsx` with `babel-preset-solid`, before the project's TypeScript plugin.
+ * - `framework: 'svelte'` compiles `.svelte` components and `.svelte.ts` / `.svelte.js` modules.
+ * - `styles`, where {@link CreateRollupCompatibleFeaturePluginParams.shouldCompileStylesheets} says so, runs every
+ *   stylesheet through PostCSS, Tailwind and CSS-module scoping and emits it as an asset, which ends up in
+ *   `styles.css`.
+ * - `wasm` loads a `.wasm` module as its bytes.
+ * - A framework's compile-time constants are replaced where
+ *   {@link CreateRollupCompatibleFeaturePluginParams.shouldReplaceDefines} says so.
+ *
+ * @param params - The {@link CreateRollupCompatibleFeaturePluginParams}.
+ * @returns The plugin.
+ */
+export declare function createRollupCompatibleFeaturePlugin(params: CreateRollupCompatibleFeaturePluginParams): RollupCompatibleFeaturePlugin;
+/**
+ * Creates the `unplugin-vue` plugin of one bundler when the framework is Vue.
+ *
+ * @param params - The {@link CreateUnpluginVuePluginParams}.
+ * @returns A {@link Promise} that resolves to the plugin, or `null` when the framework is not Vue.
+ */
+export declare function createUnpluginVuePlugin(params: CreateUnpluginVuePluginParams): Promise<unknown>;
+export {};