@mnaoumov/obsidian-dev-toolkit 2.1.0 → 3.1.0

package/dist/lib/cjs/bundlers/obsidian-plugin-transforms.cjs

@@ -0,0 +1,306 @@
+/*
+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 obsidian_plugin_transforms_exports = {};
+__export(obsidian_plugin_transforms_exports, {
+  appendInlineSourceMap: () => appendInlineSourceMap,
+  getCssModuleCode: () => getCssModuleCode,
+  getWasmModuleCode: () => getWasmModuleCode,
+  loadPostcssConfig: () => loadPostcssConfig,
+  transformCss: () => transformCss,
+  transformJsx: () => transformJsx,
+  transformSolid: () => transformSolid,
+  transformSvelte: () => transformSvelte
+});
+module.exports = __toCommonJS(obsidian_plugin_transforms_exports);
+var import_object_utils = require('@mnaoumov/typescript-lib/object-utils');
+var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
+var import_esbuild = require('esbuild');
+var import_node_process = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('node:process')), 1);
+var import_postcss = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('postcss')), 1);
+var import_postcss_load_config = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('postcss-load-config')), 1);
+var import_postcss_modules = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('postcss-modules')), 1);
+var import_obsidian_plugin_features = require('./obsidian-plugin-features.cjs');
+const postcssLoadConfig = (0, import_object_utils.extractDefaultExportInterop)(import_postcss_load_config.default);
+const postcssModules = (0, import_object_utils.extractDefaultExportInterop)(import_postcss_modules.default);
+const SVELTE_MODULE_PATTERN = /\.svelte\.[cm]?[jt]s$/iu;
+const TYPESCRIPT_MODULE_PATTERN = /\.[cm]?ts$/iu;
+const TAILWIND_POSTCSS_PLUGIN_NAME = "@tailwindcss/postcss";
+function appendInlineSourceMap(module2) {
+  if (!module2.map) {
+    return module2.code;
+  }
+  const base64 = Buffer.from(JSON.stringify(module2.map), "utf-8").toString("base64");
+  return `${module2.code}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,${base64}
+`;
+}
+function getCssModuleCode(moduleExports) {
+  return `export default ${JSON.stringify(moduleExports)};
+`;
+}
+function getWasmModuleCode(bytes) {
+  const base64 = Buffer.from(bytes).toString("base64");
+  return `const binary = atob(${JSON.stringify(base64)});
+const bytes = new Uint8Array(binary.length);
+for (let i = 0; i < binary.length; i++) {
+  bytes[i] = binary.charCodeAt(i);
+}
+export default bytes;
+`;
+}
+async function loadPostcssConfig(params) {
+  const { isProductionBuild, projectFolder, styles } = params;
+  const plugins = [];
+  const dependencies = [];
+  let options = {};
+  if (styles.postcss) {
+    let config;
+    try {
+      config = await postcssLoadConfig({ cwd: projectFolder ?? import_node_process.default.cwd(), env: isProductionBuild ? "production" : "development" }, projectFolder);
+    } catch (error) {
+      throw new Error("The `styles.postcss` build option needs a PostCSS configuration (`postcss.config.mjs`, `.postcssrc.json`, ...) in the project.", {
+        cause: error
+      });
+    }
+    plugins.push(...config.plugins);
+    options = config.options;
+    dependencies.push(config.file);
+  }
+  if (styles.tailwind && plugins.every((plugin) => !isTailwindPlugin(plugin))) {
+    const { default: tailwind } = await (0, import_obsidian_plugin_features.importOptionalPeer)({
+      feature: "styles.tailwind",
+      packageName: TAILWIND_POSTCSS_PLUGIN_NAME,
+      ...projectFolder !== void 0 && { projectFolder }
+    });
+    plugins.unshift(tailwind({ ...projectFolder !== void 0 && { base: projectFolder }, optimize: isProductionBuild }));
+  }
+  return { dependencies, options, plugins };
+}
+async function transformCss(params) {
+  const { filePath, isCssModuleScoped, source, styles } = params;
+  const postcssConfig = await loadPostcssConfig(params);
+  const plugins = [...postcssConfig.plugins];
+  const dependencies = [...postcssConfig.dependencies];
+  let moduleExports;
+  if (styles.cssModules && isCssModuleScoped && (0, import_obsidian_plugin_features.isCssModuleFile)(filePath)) {
+    plugins.push(postcssModules({
+      getJSON(_cssFileName, json) {
+        moduleExports = json;
+      }
+    }));
+  }
+  if (plugins.length === 0) {
+    return { css: source, dependencies, moduleExports };
+  }
+  const result = await (0, import_postcss.default)(plugins).process(source, { ...postcssConfig.options, from: filePath, map: false });
+  for (const message of result.messages) {
+    if (message.type === "dependency" && message.file !== void 0) {
+      dependencies.push(message.file);
+    }
+  }
+  return { css: result.css, dependencies, moduleExports };
+}
+async function transformJsx(params) {
+  const { code, filePath, jsxImportSource } = params;
+  const result = await (0, import_esbuild.transform)(code, {
+    jsx: "automatic",
+    jsxImportSource,
+    loader: /\.tsx$/iu.test(filePath) ? "tsx" : "jsx",
+    sourcefile: filePath,
+    sourcemap: "external"
+  });
+  return { code: result.code, map: JSON.parse(result.map) };
+}
+async function transformSolid(params) {
+  const { code, filePath } = params;
+  const feature = "framework: 'solid'";
+  const projectFolderOption = params.projectFolder === void 0 ? {} : { projectFolder: params.projectFolder };
+  const babel = (0, import_object_utils.extractDefaultExportInterop)(await (0, import_obsidian_plugin_features.importOptionalPeer)({ feature, packageName: "@babel/core", ...projectFolderOption }));
+  const solidPreset = (0, import_object_utils.extractDefaultExportInterop)(await (0, import_obsidian_plugin_features.importOptionalPeer)({ feature, packageName: "babel-preset-solid", ...projectFolderOption }));
+  const stripped = await (0, import_esbuild.transform)(code, {
+    jsx: "preserve",
+    loader: /\.tsx$/iu.test(filePath) ? "tsx" : "jsx",
+    sourcefile: filePath,
+    sourcemap: "external"
+  });
+  const result = await babel.transformAsync(stripped.code, {
+    babelrc: false,
+    configFile: false,
+    filename: filePath,
+    inputSourceMap: JSON.parse(stripped.map),
+    presets: [[solidPreset, { generate: "dom", hydratable: false }]],
+    sourceMaps: true
+  });
+  if (!result?.code) {
+    throw new Error(`Babel produced no code for ${filePath}`);
+  }
+  return { code: result.code, map: (0, import_type_guards.ensureNonNullable)(result.map, `Babel produced no source map for ${filePath}`) };
+}
+async function transformSvelte(params) {
+  const { code, filePath, isProductionBuild } = params;
+  const compiler = (0, import_object_utils.extractDefaultExportInterop)(
+    await (0, import_obsidian_plugin_features.importOptionalPeer)({
+      feature: "framework: 'svelte'",
+      packageName: "svelte",
+      specifier: "svelte/compiler",
+      ...params.projectFolder !== void 0 && { projectFolder: params.projectFolder }
+    })
+  );
+  const moduleOptions = { dev: !isProductionBuild, filename: filePath, generate: "client" };
+  if (SVELTE_MODULE_PATTERN.test(filePath)) {
+    let javaScript = code;
+    if (TYPESCRIPT_MODULE_PATTERN.test(filePath)) {
+      const stripped = await (0, import_esbuild.transform)(code, { loader: "ts", sourcefile: filePath });
+      javaScript = stripped.code;
+    }
+    return compiler.compileModule(javaScript, moduleOptions).js;
+  }
+  return compiler.compile(code, { ...moduleOptions, css: "injected" }).js;
+}
+function isTailwindPlugin(plugin) {
+  return typeof plugin === "object" && "postcssPlugin" in plugin && plugin.postcssPlugin === TAILWIND_POSTCSS_PLUGIN_NAME;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendInlineSourceMap,
+  getCssModuleCode,
+  getWasmModuleCode,
+  loadPostcssConfig,
+  transformCss,
+  transformJsx,
+  transformSolid,
+  transformSvelte
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/bundlers/obsidian-plugin-transforms.ts"],"sourcesContent":["/**\n * @file\n *\n * The source transforms every bundler adapter shares, so a feature compiles the same way whichever bundler runs it:\n * Solid's JSX, Svelte components and modules, stylesheets through PostCSS, Tailwind and CSS modules, and WebAssembly\n * modules as bytes. The esbuild, rollup and vite adapters call them in-process; the webpack adapter through the\n * loader it ships, and the parcel adapter through the transformers it generates.\n *\n * Erasable TypeScript only (no enums, no parameter properties), so a webpack loader or a parcel worker can load this\n * module straight from source when the toolkit runs from source.\n */\n\nimport type { TransformOptions as BabelTransformOptions } from '@babel/core';\nimport type {\n  AcceptedPlugin,\n  ProcessOptions\n} from 'postcss';\n\nimport { extractDefaultExportInterop } from '@mnaoumov/typescript-lib/object-utils';\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { transform as esbuildTransform } from 'esbuild';\nimport process from 'node:process';\nimport postcss from 'postcss';\nimport postcssLoadConfig_ from 'postcss-load-config';\nimport postcssModules_ from 'postcss-modules';\n\nimport type { ObsidianPluginStylesOptions } from './obsidian-plugin-features.ts';\n\nimport {\n  importOptionalPeer,\n  isCssModuleFile\n} from './obsidian-plugin-features.ts';\n\nconst postcssLoadConfig = extractDefaultExportInterop(postcssLoadConfig_);\nconst postcssModules = extractDefaultExportInterop(postcssModules_);\n\n/**\n * Parameters for {@link loadPostcssConfig}.\n */\nexport interface LoadPostcssConfigParams {\n  /**\n   * Whether this is a production build.\n   */\n  readonly isProductionBuild: boolean;\n\n  /**\n   * The folder the project's PostCSS configuration and packages are found from. Defaults to the project root.\n   */\n  readonly projectFolder?: string | undefined;\n\n  /**\n   * The stylesheet options.\n   */\n  readonly styles: ObsidianPluginStylesOptions;\n}\n\n/**\n * What {@link loadPostcssConfig} loaded.\n */\nexport interface PostcssConfig {\n  /**\n   * The files the configuration came from, for a watch build to watch.\n   */\n  readonly dependencies: readonly string[];\n\n  /**\n   * The process options of the project's configuration (a custom parser or syntax, say).\n   */\n  readonly options: ProcessOptions;\n\n  /**\n   * The plugins, in the order they run.\n   */\n  readonly plugins: readonly AcceptedPlugin[];\n}\n\n/**\n * A source map, as the transforms hand it over: the decoded JSON of a version 3 source map.\n */\nexport interface SourceMapLike {\n  /**\n   * The encoded mappings.\n   */\n  readonly mappings: string;\n\n  /**\n   * The original sources.\n   */\n  readonly sources: readonly string[];\n\n  /**\n   * The source map version.\n   */\n  readonly version: number;\n}\n\n/**\n * Parameters for {@link transformCss}.\n */\nexport interface TransformCssParams {\n  /**\n   * The stylesheet's path.\n   */\n  readonly filePath: string;\n\n  /**\n   * Whether `*.module.css` files are scoped here. A bundler that scopes CSS modules itself passes `false`.\n   */\n  readonly isCssModuleScoped: boolean;\n\n  /**\n   * Whether this is a production build.\n   */\n  readonly isProductionBuild: boolean;\n\n  /**\n   * The folder the project's PostCSS configuration and packages are found from. Defaults to the project root.\n   */\n  readonly projectFolder?: string | undefined;\n\n  /**\n   * The stylesheet's contents.\n   */\n  readonly source: string;\n\n  /**\n   * The stylesheet options.\n   */\n  readonly styles: ObsidianPluginStylesOptions;\n}\n\n/**\n * The CSS {@link transformCss} produced.\n */\nexport interface TransformedCss {\n  /**\n   * The stylesheet.\n   */\n  readonly css: string;\n\n  /**\n   * The files besides the stylesheet that the result depends on, for a watch build to watch: a PostCSS configuration,\n   * or a stylesheet a plugin inlined.\n   */\n  readonly dependencies: readonly string[];\n\n  /**\n   * The scoped class names by their original ones, for a CSS module; `undefined` for an ordinary stylesheet.\n   */\n  readonly moduleExports: Readonly<Record<string, string>> | undefined;\n}\n\n/**\n * A JavaScript module a transform produced.\n */\nexport interface TransformedModule {\n  /**\n   * The JavaScript code.\n   */\n  readonly code: string;\n\n  /**\n   * Its source map, or `undefined` when there is none.\n   */\n  readonly map: SourceMapLike | undefined;\n}\n\n/**\n * Parameters for {@link transformJsx}.\n */\nexport interface TransformJsxParams extends TransformModuleParams {\n  /**\n   * The package that supplies the automatic JSX runtime: `react` or `preact`.\n   */\n  readonly jsxImportSource: string;\n}\n\n/**\n * Parameters of a transform that compiles one module.\n */\nexport interface TransformModuleParams {\n  /**\n   * The source code.\n   */\n  readonly code: string;\n\n  /**\n   * The source file's path.\n   */\n  readonly filePath: string;\n\n  /**\n   * Whether this is a production build.\n   */\n  readonly isProductionBuild: boolean;\n\n  /**\n   * The folder the framework's packages are resolved from. Defaults to the project root.\n   */\n  readonly projectFolder?: string;\n}\n\n/**\n * Parameters for {@link transformSolid}.\n */\nexport type TransformSolidParams = TransformModuleParams;\n\n/**\n * Parameters for {@link transformSvelte}.\n */\nexport type TransformSvelteParams = TransformModuleParams;\n\ninterface BabelCoreLike {\n  transformAsync: (code: string, options: BabelTransformOptions) => Promise<BabelResultLike | null>;\n}\n\ninterface BabelResultLike {\n  readonly code?: null | string;\n  readonly map?: null | SourceMapLike;\n}\n\ninterface PostcssDependencyMessage {\n  readonly file?: string;\n  readonly type: string;\n}\n\ninterface SvelteCompileOptionsLike extends SvelteModuleCompileOptionsLike {\n  readonly css: 'injected';\n}\n\ninterface SvelteCompileResultLike {\n  readonly js: TransformedModule;\n}\n\ninterface SvelteCompilerLike {\n  compile: (source: string, options: SvelteCompileOptionsLike) => SvelteCompileResultLike;\n  compileModule: (source: string, options: SvelteModuleCompileOptionsLike) => SvelteCompileResultLike;\n}\n\ninterface SvelteModuleCompileOptionsLike {\n  readonly dev: boolean;\n  readonly filename: string;\n  readonly generate: 'client';\n}\n\ninterface TailwindPostcssModule {\n  readonly default: (options?: TailwindPostcssOptions) => AcceptedPlugin;\n}\n\ninterface TailwindPostcssOptions {\n  readonly base?: string;\n  readonly optimize?: boolean;\n}\n\nconst SVELTE_MODULE_PATTERN = /\\.svelte\\.[cm]?[jt]s$/iu;\nconst TYPESCRIPT_MODULE_PATTERN = /\\.[cm]?ts$/iu;\nconst TAILWIND_POSTCSS_PLUGIN_NAME = '@tailwindcss/postcss';\n\n/**\n * Appends a source map to a module's code as an inline `sourceMappingURL` comment, which is how a bundler that\n * reads a loaded file's own source map takes it.\n *\n * @param module - The module.\n * @returns The code, with the source map inlined when there is one.\n */\nexport function appendInlineSourceMap(module: TransformedModule): string {\n  if (!module.map) {\n    return module.code;\n  }\n  const base64 = Buffer.from(JSON.stringify(module.map), 'utf-8').toString('base64');\n  return `${module.code}\\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${base64}\\n`;\n}\n\n/**\n * Builds the JavaScript module a CSS module's import resolves to: its scoped class names, by their original ones, as\n * the default export.\n *\n * @param moduleExports - The scoped class names.\n * @returns The module's code.\n */\nexport function getCssModuleCode(moduleExports: Readonly<Record<string, string>>): string {\n  return `export default ${JSON.stringify(moduleExports)};\\n`;\n}\n\n/**\n * Builds the JavaScript module a `.wasm` import resolves to: the WebAssembly module's bytes as a `Uint8Array`\n * default export, inlined as base64, because an Obsidian release ships `main.js` and nothing beside it.\n *\n * @param bytes - The WebAssembly module's bytes.\n * @returns The module's code.\n */\nexport function getWasmModuleCode(bytes: Uint8Array): string {\n  const base64 = Buffer.from(bytes).toString('base64');\n  return `const binary = atob(${JSON.stringify(base64)});\nconst bytes = new Uint8Array(binary.length);\nfor (let i = 0; i < binary.length; i++) {\n  bytes[i] = binary.charCodeAt(i);\n}\nexport default bytes;\n`;\n}\n\n/**\n * Loads the PostCSS plugins a stylesheet goes through, without the CSS-module scoping: the project's PostCSS\n * configuration when `postcss` is on, and Tailwind ahead of it when `tailwind` is on and the configuration does not\n * already run it.\n *\n * @param params - The {@link LoadPostcssConfigParams}.\n * @returns A {@link Promise} that resolves to the {@link PostcssConfig}; its `plugins` is empty when neither applies.\n * @throws If `postcss` is on and the project has no PostCSS configuration.\n */\nexport async function loadPostcssConfig(params: LoadPostcssConfigParams): Promise<PostcssConfig> {\n  const { isProductionBuild, projectFolder, styles } = params;\n  const plugins: AcceptedPlugin[] = [];\n  const dependencies: string[] = [];\n  let options: ProcessOptions = {};\n\n  if (styles.postcss) {\n    let config: postcssLoadConfig_.Result;\n    try {\n      config = await postcssLoadConfig({ cwd: projectFolder ?? process.cwd(), env: isProductionBuild ? 'production' : 'development' }, projectFolder);\n    } catch (error) {\n      throw new Error('The `styles.postcss` build option needs a PostCSS configuration (`postcss.config.mjs`, `.postcssrc.json`, ...) in the project.', {\n        cause: error\n      });\n    }\n    plugins.push(...config.plugins as AcceptedPlugin[]);\n    options = config.options;\n    dependencies.push(config.file);\n  }\n\n  if (styles.tailwind && plugins.every((plugin) => !isTailwindPlugin(plugin))) {\n    const { default: tailwind } = await importOptionalPeer<TailwindPostcssModule>({\n      feature: 'styles.tailwind',\n      packageName: TAILWIND_POSTCSS_PLUGIN_NAME,\n      ...(projectFolder !== undefined && { projectFolder })\n    });\n    plugins.unshift(tailwind({ ...(projectFolder !== undefined && { base: projectFolder }), optimize: isProductionBuild }));\n  }\n\n  return { dependencies, options, plugins };\n}\n\n/**\n * Runs a stylesheet through the pipeline its options ask for: the project's PostCSS configuration, Tailwind, and the\n * CSS-module scoping of a `*.module.css` file.\n *\n * @param params - The {@link TransformCssParams}.\n * @returns A {@link Promise} that resolves to the {@link TransformedCss}.\n * @throws If `postcss` is on and the project has no PostCSS configuration.\n */\nexport async function transformCss(params: TransformCssParams): Promise<TransformedCss> {\n  const { filePath, isCssModuleScoped, source, styles } = params;\n  const postcssConfig = await loadPostcssConfig(params);\n  const plugins = [...postcssConfig.plugins];\n  const dependencies = [...postcssConfig.dependencies];\n\n  let moduleExports: Record<string, string> | undefined;\n  if (styles.cssModules && isCssModuleScoped && isCssModuleFile(filePath)) {\n    plugins.push(postcssModules({\n      getJSON(_cssFileName, json): void {\n        moduleExports = json;\n      }\n    }));\n  }\n\n  if (plugins.length === 0) {\n    return { css: source, dependencies, moduleExports };\n  }\n\n  const result = await postcss(plugins).process(source, { ...postcssConfig.options, from: filePath, map: false });\n  for (const message of result.messages as PostcssDependencyMessage[]) {\n    if (message.type === 'dependency' && message.file !== undefined) {\n      dependencies.push(message.file);\n    }\n  }\n  return { css: result.css, dependencies, moduleExports };\n}\n\n/**\n * Compiles a React or Preact JSX or TSX module with the automatic JSX runtime, for a bundler that does not take the\n * runtime from the project's tsconfig (parcel does not follow its `extends`).\n *\n * @param params - The {@link TransformJsxParams}.\n * @returns A {@link Promise} that resolves to the compiled module.\n */\nexport async function transformJsx(params: TransformJsxParams): Promise<TransformedModule> {\n  const { code, filePath, jsxImportSource } = params;\n  const result = await esbuildTransform(code, {\n    jsx: 'automatic',\n    jsxImportSource,\n    loader: /\\.tsx$/iu.test(filePath) ? 'tsx' : 'jsx',\n    sourcefile: filePath,\n    sourcemap: 'external'\n  });\n  return { code: result.code, map: JSON.parse(result.map) as SourceMapLike };\n}\n\n/**\n * Compiles a Solid JSX or TSX module: esbuild strips the TypeScript and keeps the JSX, then `babel-preset-solid`\n * compiles the JSX into DOM expressions.\n *\n * @param params - The {@link TransformModuleParams}.\n * @returns A {@link Promise} that resolves to the compiled module.\n * @throws If Babel produced no code.\n */\nexport async function transformSolid(params: TransformSolidParams): Promise<TransformedModule> {\n  const { code, filePath } = params;\n  const feature = 'framework: \\'solid\\'';\n  const projectFolderOption = params.projectFolder === undefined ? {} : { projectFolder: params.projectFolder };\n  const babel = extractDefaultExportInterop(await importOptionalPeer<BabelCoreLike>({ feature, packageName: '@babel/core', ...projectFolderOption }));\n  const solidPreset = extractDefaultExportInterop(await importOptionalPeer<object>({ feature, packageName: 'babel-preset-solid', ...projectFolderOption }));\n\n  const stripped = await esbuildTransform(code, {\n    jsx: 'preserve',\n    loader: /\\.tsx$/iu.test(filePath) ? 'tsx' : 'jsx',\n    sourcefile: filePath,\n    sourcemap: 'external'\n  });\n\n  const result = await babel.transformAsync(stripped.code, {\n    babelrc: false,\n    configFile: false,\n    filename: filePath,\n    inputSourceMap: JSON.parse(stripped.map) as BabelTransformOptions['inputSourceMap'],\n    presets: [[solidPreset, { generate: 'dom', hydratable: false }]],\n    sourceMaps: true\n  });\n  /* v8 ignore start -- Babel returns no code only when a plugin drops the file, which the Solid preset never does. */\n  if (!result?.code) {\n    throw new Error(`Babel produced no code for ${filePath}`);\n  }\n  /* v8 ignore stop */\n  // With `sourceMaps` on, Babel always returns a source map.\n  return { code: result.code, map: ensureNonNullable(result.map, `Babel produced no source map for ${filePath}`) };\n}\n\n/**\n * Compiles a Svelte component (`.svelte`), with its styles injected by the component itself, or a Svelte module\n * (`.svelte.ts`, `.svelte.js`), whose TypeScript esbuild strips first.\n *\n * @param params - The {@link TransformModuleParams}.\n * @returns A {@link Promise} that resolves to the compiled module.\n */\nexport async function transformSvelte(params: TransformSvelteParams): Promise<TransformedModule> {\n  const { code, filePath, isProductionBuild } = params;\n  const compiler = extractDefaultExportInterop(\n    await importOptionalPeer<SvelteCompilerLike>({\n      feature: 'framework: \\'svelte\\'',\n      packageName: 'svelte',\n      specifier: 'svelte/compiler',\n      ...(params.projectFolder !== undefined && { projectFolder: params.projectFolder })\n    })\n  );\n  const moduleOptions: SvelteModuleCompileOptionsLike = { dev: !isProductionBuild, filename: filePath, generate: 'client' };\n\n  if (SVELTE_MODULE_PATTERN.test(filePath)) {\n    let javaScript = code;\n    if (TYPESCRIPT_MODULE_PATTERN.test(filePath)) {\n      const stripped = await esbuildTransform(code, { loader: 'ts', sourcefile: filePath });\n      javaScript = stripped.code;\n    }\n    return compiler.compileModule(javaScript, moduleOptions).js;\n  }\n\n  return compiler.compile(code, { ...moduleOptions, css: 'injected' }).js;\n}\n\nfunction isTailwindPlugin(plugin: AcceptedPlugin): boolean {\n  return typeof plugin === 'object' && 'postcssPlugin' in plugin && plugin.postcssPlugin === TAILWIND_POSTCSS_PLUGIN_NAME;\n}\n"],"mappings":"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","names":["postcssLoadConfig_","postcssModules_","module","process","postcss","esbuildTransform"]}

package/dist/lib/cjs/bundlers/obsidian-plugin-transforms.d.cts

@@ -0,0 +1,231 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * The source transforms every bundler adapter shares, so a feature compiles the same way whichever bundler runs it:
+ * Solid's JSX, Svelte components and modules, stylesheets through PostCSS, Tailwind and CSS modules, and WebAssembly
+ * modules as bytes. The esbuild, rollup and vite adapters call them in-process; the webpack adapter through the
+ * loader it ships, and the parcel adapter through the transformers it generates.
+ *
+ * Erasable TypeScript only (no enums, no parameter properties), so a webpack loader or a parcel worker can load this
+ * module straight from source when the toolkit runs from source.
+ */
+import type { AcceptedPlugin, ProcessOptions } from 'postcss' with { 'resolution-mode': 'import' };
+import type { ObsidianPluginStylesOptions } from './obsidian-plugin-features.cjs';
+/**
+ * Parameters for {@link loadPostcssConfig}.
+ */
+export interface LoadPostcssConfigParams {
+    /**
+     * Whether this is a production build.
+     */
+    readonly isProductionBuild: boolean;
+    /**
+     * The folder the project's PostCSS configuration and packages are found from. Defaults to the project root.
+     */
+    readonly projectFolder?: string | undefined;
+    /**
+     * The stylesheet options.
+     */
+    readonly styles: ObsidianPluginStylesOptions;
+}
+/**
+ * What {@link loadPostcssConfig} loaded.
+ */
+export interface PostcssConfig {
+    /**
+     * The files the configuration came from, for a watch build to watch.
+     */
+    readonly dependencies: readonly string[];
+    /**
+     * The process options of the project's configuration (a custom parser or syntax, say).
+     */
+    readonly options: ProcessOptions;
+    /**
+     * The plugins, in the order they run.
+     */
+    readonly plugins: readonly AcceptedPlugin[];
+}
+/**
+ * A source map, as the transforms hand it over: the decoded JSON of a version 3 source map.
+ */
+export interface SourceMapLike {
+    /**
+     * The encoded mappings.
+     */
+    readonly mappings: string;
+    /**
+     * The original sources.
+     */
+    readonly sources: readonly string[];
+    /**
+     * The source map version.
+     */
+    readonly version: number;
+}
+/**
+ * Parameters for {@link transformCss}.
+ */
+export interface TransformCssParams {
+    /**
+     * The stylesheet's path.
+     */
+    readonly filePath: string;
+    /**
+     * Whether `*.module.css` files are scoped here. A bundler that scopes CSS modules itself passes `false`.
+     */
+    readonly isCssModuleScoped: boolean;
+    /**
+     * Whether this is a production build.
+     */
+    readonly isProductionBuild: boolean;
+    /**
+     * The folder the project's PostCSS configuration and packages are found from. Defaults to the project root.
+     */
+    readonly projectFolder?: string | undefined;
+    /**
+     * The stylesheet's contents.
+     */
+    readonly source: string;
+    /**
+     * The stylesheet options.
+     */
+    readonly styles: ObsidianPluginStylesOptions;
+}
+/**
+ * The CSS {@link transformCss} produced.
+ */
+export interface TransformedCss {
+    /**
+     * The stylesheet.
+     */
+    readonly css: string;
+    /**
+     * The files besides the stylesheet that the result depends on, for a watch build to watch: a PostCSS configuration,
+     * or a stylesheet a plugin inlined.
+     */
+    readonly dependencies: readonly string[];
+    /**
+     * The scoped class names by their original ones, for a CSS module; `undefined` for an ordinary stylesheet.
+     */
+    readonly moduleExports: Readonly<Record<string, string>> | undefined;
+}
+/**
+ * A JavaScript module a transform produced.
+ */
+export interface TransformedModule {
+    /**
+     * The JavaScript code.
+     */
+    readonly code: string;
+    /**
+     * Its source map, or `undefined` when there is none.
+     */
+    readonly map: SourceMapLike | undefined;
+}
+/**
+ * Parameters for {@link transformJsx}.
+ */
+export interface TransformJsxParams extends TransformModuleParams {
+    /**
+     * The package that supplies the automatic JSX runtime: `react` or `preact`.
+     */
+    readonly jsxImportSource: string;
+}
+/**
+ * Parameters of a transform that compiles one module.
+ */
+export interface TransformModuleParams {
+    /**
+     * The source code.
+     */
+    readonly code: string;
+    /**
+     * The source file's path.
+     */
+    readonly filePath: string;
+    /**
+     * Whether this is a production build.
+     */
+    readonly isProductionBuild: boolean;
+    /**
+     * The folder the framework's packages are resolved from. Defaults to the project root.
+     */
+    readonly projectFolder?: string;
+}
+/**
+ * Parameters for {@link transformSolid}.
+ */
+export type TransformSolidParams = TransformModuleParams;
+/**
+ * Parameters for {@link transformSvelte}.
+ */
+export type TransformSvelteParams = TransformModuleParams;
+/**
+ * Appends a source map to a module's code as an inline `sourceMappingURL` comment, which is how a bundler that
+ * reads a loaded file's own source map takes it.
+ *
+ * @param module - The module.
+ * @returns The code, with the source map inlined when there is one.
+ */
+export declare function appendInlineSourceMap(module: TransformedModule): string;
+/**
+ * Builds the JavaScript module a CSS module's import resolves to: its scoped class names, by their original ones, as
+ * the default export.
+ *
+ * @param moduleExports - The scoped class names.
+ * @returns The module's code.
+ */
+export declare function getCssModuleCode(moduleExports: Readonly<Record<string, string>>): string;
+/**
+ * Builds the JavaScript module a `.wasm` import resolves to: the WebAssembly module's bytes as a `Uint8Array`
+ * default export, inlined as base64, because an Obsidian release ships `main.js` and nothing beside it.
+ *
+ * @param bytes - The WebAssembly module's bytes.
+ * @returns The module's code.
+ */
+export declare function getWasmModuleCode(bytes: Uint8Array): string;
+/**
+ * Loads the PostCSS plugins a stylesheet goes through, without the CSS-module scoping: the project's PostCSS
+ * configuration when `postcss` is on, and Tailwind ahead of it when `tailwind` is on and the configuration does not
+ * already run it.
+ *
+ * @param params - The {@link LoadPostcssConfigParams}.
+ * @returns A {@link Promise} that resolves to the {@link PostcssConfig}; its `plugins` is empty when neither applies.
+ * @throws If `postcss` is on and the project has no PostCSS configuration.
+ */
+export declare function loadPostcssConfig(params: LoadPostcssConfigParams): Promise<PostcssConfig>;
+/**
+ * Runs a stylesheet through the pipeline its options ask for: the project's PostCSS configuration, Tailwind, and the
+ * CSS-module scoping of a `*.module.css` file.
+ *
+ * @param params - The {@link TransformCssParams}.
+ * @returns A {@link Promise} that resolves to the {@link TransformedCss}.
+ * @throws If `postcss` is on and the project has no PostCSS configuration.
+ */
+export declare function transformCss(params: TransformCssParams): Promise<TransformedCss>;
+/**
+ * Compiles a React or Preact JSX or TSX module with the automatic JSX runtime, for a bundler that does not take the
+ * runtime from the project's tsconfig (parcel does not follow its `extends`).
+ *
+ * @param params - The {@link TransformJsxParams}.
+ * @returns A {@link Promise} that resolves to the compiled module.
+ */
+export declare function transformJsx(params: TransformJsxParams): Promise<TransformedModule>;
+/**
+ * Compiles a Solid JSX or TSX module: esbuild strips the TypeScript and keeps the JSX, then `babel-preset-solid`
+ * compiles the JSX into DOM expressions.
+ *
+ * @param params - The {@link TransformModuleParams}.
+ * @returns A {@link Promise} that resolves to the compiled module.
+ * @throws If Babel produced no code.
+ */
+export declare function transformSolid(params: TransformSolidParams): Promise<TransformedModule>;
+/**
+ * Compiles a Svelte component (`.svelte`), with its styles injected by the component itself, or a Svelte module
+ * (`.svelte.ts`, `.svelte.js`), whose TypeScript esbuild strips first.
+ *
+ * @param params - The {@link TransformModuleParams}.
+ * @returns A {@link Promise} that resolves to the compiled module.
+ */
+export declare function transformSvelte(params: TransformSvelteParams): Promise<TransformedModule>;