@mnaoumov/obsidian-dev-toolkit 2.1.0 → 3.1.0

package/dist/lib/cjs/bundlers/parcel.cjs

@@ -0,0 +1,462 @@
+/*
+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 __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parcel_exports = {};
+__export(parcel_exports, {
+  build: () => build,
+  buildObsidianPluginWithParcel: () => buildObsidianPluginWithParcel,
+  dev: () => dev,
+  getParcelConfigFiles: () => getParcelConfigFiles,
+  getParcelOptions: () => getParcelOptions
+});
+module.exports = __toCommonJS(parcel_exports);
+var import_cli_utils = require('@mnaoumov/typescript-dev-toolkit/cli-utils');
+var import_npm_run = require('@mnaoumov/typescript-dev-toolkit/npm-run');
+var import_async = require('@mnaoumov/typescript-lib/async');
+var import_path = require('@mnaoumov/typescript-lib/path');
+var import_node_fs = require('node:fs');
+var import_promises = require('node:fs/promises');
+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 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: import_obsidian_plugin_build.BuildMode.Production });
+  result.throwOnFailure();
+}
+async function buildObsidianPluginWithParcel(params) {
+  await (0, import_npm_run.npmRunOptional)("build:compile");
+  const buildContext = await (0, import_obsidian_plugin_build.resolveObsidianPluginBuildContext)(params);
+  await (0, import_obsidian_plugin_build.cleanObsidianPluginDistFolder)(buildContext.distFolder);
+  await (0, import_obsidian_plugin_build.completeObsidianPluginDistFolder)(buildContext);
+  const configFolder = (0, import_obsidian_plugin_build.resolveFromRoot)(GENERATED_PARCEL_CONFIG_FOLDER);
+  const consumerParcelrcPath = (0, import_obsidian_plugin_build.resolveFromRoot)(PARCELRC);
+  await (0, import_promises.mkdir)(configFolder, { recursive: true });
+  const configFiles = getParcelConfigFiles({
+    consumerParcelrcPath: (0, import_node_fs.existsSync)(consumerParcelrcPath) ? (0, import_path.toPosixPath)((0, import_path.relative)(configFolder, consumerParcelrcPath)) : void 0,
+    features: params
+  });
+  for (const [fileName, contents] of Object.entries(configFiles)) {
+    const filePath = (0, import_path.join)(configFolder, fileName);
+    if (!(0, import_node_fs.existsSync)(filePath) || await (0, import_promises.readFile)(filePath, "utf-8") !== contents) {
+      await (0, import_promises.writeFile)(filePath, contents, "utf-8");
+    }
+  }
+  const { Parcel } = await import("@parcel/core");
+  const parcelOptions = getParcelOptions({ buildContext, cacheFolder: (0, import_obsidian_plugin_build.resolveFromRoot)(PARCEL_CACHE_FOLDER), configPath: (0, import_path.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 import_cli_utils.CliTaskResult.Success();
+    } catch (error) {
+      console.error(formatParcelError(error));
+      return import_cli_utils.CliTaskResult.Failure();
+    }
+  }
+  await bundler.watch((error, event) => {
+    if (error) {
+      console.error(formatParcelError(error));
+      return;
+    }
+    handleWatchEvent(event, buildContext);
+  });
+  return import_cli_utils.CliTaskResult.DoNotExit();
+}
+async function dev(options) {
+  return await buildObsidianPluginWithParcel({ ...options, mode: import_obsidian_plugin_build.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" || (0, import_obsidian_plugin_features.getJsxImportSource)(features.framework) !== void 0) {
+    transformers["*.{jsx,tsx}"] = [featureTransformer];
+  }
+  if (features.wasm) {
+    transformers["*.wasm"] = [featureTransformer];
+  }
+  if ((0, import_obsidian_plugin_features.isPostcssNeeded)(features.styles)) {
+    transformers["*.{css,pcss}"] = [featureTransformer, "@parcel/transformer-css"];
+  }
+  const defines = (0, import_obsidian_plugin_features.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' ? '${import_obsidian_plugin_repo_paths.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(`${(0, import_obsidian_plugin_build.getObsidianPluginBanner)("parcel")}if (typeof module === 'object' && typeof module.require !== 'function') { module.require = require; }
+`)};
+const PREAMBLE_LINE_COUNT = ${String((0, import_obsidian_plugin_build.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(import_obsidian_plugin_build.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}${(0, import_path.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.`);
+  (0, import_async.invokeAsyncSafely)(() => (0, import_obsidian_plugins_folder_deployment.deployToObsidianPluginsFolder)(buildContext));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  build,
+  buildObsidianPluginWithParcel,
+  dev,
+  getParcelConfigFiles,
+  getParcelOptions
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/bundlers/parcel.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 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/cjs/bundlers/parcel.d.cts

@@ -0,0 +1,128 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * Builds an Obsidian plugin with parcel: `build()` and `dev()`, the same two entry points the esbuild
+ * builder has, producing the same `main.js` + `styles.css` + `manifest.json` layout.
+ *
+ * Parcel takes no `external` list and no output file name, only plugins named in a `.parcelrc`. So the
+ * build writes a `.parcelrc` of its own into `.parcel-cache`, beside a resolver that leaves
+ * Obsidian's modules external, a namer that names the stylesheet `styles.css` and a transformer that keeps
+ * dynamic imports inside `main.js`, and extends the
+ * consumer's own `.parcelrc` when there is one (or `@parcel/config-default` when there is none), so every
+ * transformer the consumer configured still applies.
+ *
+ * `@parcel/core`, `@parcel/plugin` and `@parcel/config-default` are optional peer dependencies, loaded
+ * only when a parcel build runs, so a plugin built with esbuild installs nothing extra.
+ */
+import type { InitialParcelOptions } from '@parcel/types' with { 'resolution-mode': 'import' };
+import { CliTaskResult } from '@mnaoumov/typescript-dev-toolkit/cli-utils';
+import type { ObsidianPluginBuildContext, ObsidianPluginDeploymentOptions } from './obsidian-plugin-build.cjs';
+import type { ObsidianPluginFeatureOptions } from './obsidian-plugin-features.cjs';
+import { BuildMode } from './obsidian-plugin-build.cjs';
+/**
+ * Options for {@link buildObsidianPluginWithParcel}.
+ */
+export interface BuildObsidianPluginWithParcelParams extends BuildOptions {
+    /**
+     * A build mode, either `Development` or `Production`.
+     */
+    readonly mode: BuildMode;
+}
+/**
+ * Options for {@link build} and {@link dev}.
+ */
+export interface BuildOptions extends ObsidianPluginDeploymentOptions, ObsidianPluginFeatureOptions {
+    /**
+     * Customizes the options handed to parcel's `Parcel` class.
+     */
+    readonly customizeParcelOptions?: (options: InitialParcelOptions) => InitialParcelOptions;
+}
+/**
+ * Parameters for {@link getParcelConfigFiles}.
+ */
+export interface GetParcelConfigFilesParams {
+    /**
+     * The consumer's own `.parcelrc`, relative to the generated configuration's folder, or `undefined` when the project
+     * has none.
+     */
+    readonly consumerParcelrcPath: string | undefined;
+    /**
+     * The build features.
+     */
+    readonly features?: ObsidianPluginFeatureOptions;
+}
+/**
+ * Parameters for {@link getParcelOptions}.
+ */
+export interface GetParcelOptionsParams {
+    /**
+     * The build context.
+     */
+    readonly buildContext: ObsidianPluginBuildContext;
+    /**
+     * Parcel's cache folder. Named explicitly because parcel otherwise takes the folder of the nearest
+     * lockfile for the project root, which in a workspace is not the plugin's.
+     */
+    readonly cacheFolder: string;
+    /**
+     * The generated `.parcelrc`.
+     */
+    readonly configPath: string;
+}
+/**
+ * The files of the generated parcel configuration, by file name.
+ */
+export type ParcelConfigFiles = Readonly<Record<string, string>>;
+/**
+ * Builds the Obsidian plugin in production mode using parcel.
+ *
+ * @param options - Optional build options.
+ * @returns A {@link Promise} that resolves when the build is complete.
+ */
+export declare function build(options?: BuildOptions): Promise<void>;
+/**
+ * Builds the Obsidian plugin with parcel, once for a production build, or watching for a development one.
+ *
+ * Runs the project's `build:compile` script first when it has one, as the esbuild builder does, since
+ * parcel strips TypeScript types without checking them.
+ *
+ * @param params - The {@link BuildObsidianPluginWithParcelParams}.
+ * @returns A {@link Promise} that resolves to a {@link CliTaskResult} indicating the success or failure of the build.
+ */
+export declare function buildObsidianPluginWithParcel(params: BuildObsidianPluginWithParcelParams): Promise<CliTaskResult>;
+/**
+ * Builds the Obsidian plugin in development mode using parcel, watching for changes and deploying every
+ * successful rebuild into the vault.
+ *
+ * @param options - Optional build options.
+ * @returns A {@link Promise} that resolves to a {@link CliTaskResult} indicating the build result.
+ */
+export declare function dev(options?: BuildOptions): Promise<CliTaskResult>;
+/**
+ * Generates the files of the parcel configuration the build runs with.
+ *
+ * The build features add pipelines that run the toolkit's shared transforms, through one generated transformer that
+ * loads them from the toolkit: Solid's `.jsx` / `.tsx`, Svelte's `.svelte` / `.svelte.ts` / `.svelte.js`, `.wasm`,
+ * and with `styles.postcss` or `styles.tailwind` every stylesheet, in place of parcel's own PostCSS step. React and
+ * Preact JSX is compiled here too, since parcel reads the JSX runtime from a tsconfig without following its `extends`,
+ * and with any framework every script has the framework's compile-time constants replaced. Parcel compiles Vue with
+ * `@parcel/transformer-vue` and scopes `*.module.css` itself, so those need no pipeline here.
+ *
+ * @param params - The {@link GetParcelConfigFilesParams}.
+ * @returns The files, by file name.
+ */
+export declare function getParcelConfigFiles(params: GetParcelConfigFilesParams): ParcelConfigFiles;
+/**
+ * Builds the options handed to parcel's `Parcel` class.
+ *
+ * The one target is `electron-renderer`, where Obsidian runs a plugin, and CommonJS. Parcel counts that
+ * context as both a browser and a node one, and each half matters: node keeps the builtins external, and
+ * browser resolves the `browser` export condition. `includeNodeModules` bundles the dependencies, which a
+ * node-flavoured context would otherwise leave as `require()` calls nothing installs beside a plugin, and
+ * `isLibrary` keeps the entry's default export, which is how Obsidian finds the plugin class.
+ *
+ * @param params - The {@link GetParcelOptionsParams}.
+ * @returns The parcel options.
+ */
+export declare function getParcelOptions(params: GetParcelOptionsParams): InitialParcelOptions;