obsidian-dev-utils 50.0.0 → 51.1.6

package/dist/lib/esm/script-utils/bundlers/esbuild-impl/fixSourceMapsPlugin.mjs

@@ -0,0 +1,69 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import { existsSync } from "node:fs";
+import {
+  readFile,
+  writeFile
+} from "node:fs/promises";
+import { toPosixPath } from "../../../path.mjs";
+import { replaceAll } from "../../../string.mjs";
+function fixSourceMapsPlugin(isProductionBuild, distPaths, pluginName) {
+  return {
+    name: "fix-source-maps",
+    setup(build) {
+      build.onEnd(async () => {
+        if (isProductionBuild) {
+          return;
+        }
+        for (const distPath of distPaths) {
+          if (!existsSync(distPath)) {
+            continue;
+          }
+          const content = await readFile(distPath, "utf-8");
+          const newContent = replaceAll(
+            content,
+            /(?<Prefix>\n(?:\/\/|\/\*)# sourceMappingURL=data:application\/json;base64,)(?<SourceMapBase64>.+?)(?<Suffix>$|\n| \*\/)(?:.|\n)*/g,
+            (_, prefix, sourceMapBase64, suffix) => `${prefix + fixSourceMap(sourceMapBase64, pluginName) + suffix.trim()}
+/* nosourcemap */`
+          );
+          if (content !== newContent) {
+            await writeFile(distPath, newContent);
+          }
+        }
+      });
+    }
+  };
+}
+function convertPathToObsidianUrl(path, pluginName) {
+  const convertedPath = replaceAll(toPosixPath(path), /^(?:\.\.\/)+/g, "");
+  return `app://obsidian.md/plugin:${pluginName}/${convertedPath}`;
+}
+function fixSourceMap(sourceMapBase64, pluginName) {
+  const sourceMapJson = Buffer.from(sourceMapBase64, "base64").toString("utf-8");
+  const sourceMap = JSON.parse(sourceMapJson);
+  sourceMap.sources = (sourceMap.sources ?? []).map((path) => convertPathToObsidianUrl(path, pluginName));
+  return Buffer.from(JSON.stringify(sourceMap)).toString("base64");
+}
+export {
+  fixSourceMapsPlugin
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/script-utils/bundlers/esbuild-impl/index.d.mts

@@ -0,0 +1,10 @@
+export * as changeExtensionPlugin from './changeExtensionPlugin.mjs';
+export * as copyToObsidianPluginsFolderPlugin from './copyToObsidianPluginsFolderPlugin.mjs';
+export * as customEsbuildOptionsPlugin from './customEsbuildOptionsPlugin.mjs';
+export * as dependency from './dependency.mjs';
+export * as fixEsmPlugin from './fixEsmPlugin.mjs';
+export * as fixSourceMapsPlugin from './fixSourceMapsPlugin.mjs';
+export * as obsidian_plugin_builder from './obsidian-plugin-builder.mjs';
+export * as preprocessPlugin from './preprocessPlugin.mjs';
+export * as renameCssPlugin from './renameCssPlugin.mjs';
+export * as svelteWrapperPlugin from './svelteWrapperPlugin.mjs';

package/dist/lib/esm/script-utils/bundlers/esbuild-impl/index.mjs

@@ -0,0 +1,44 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import * as changeExtensionPlugin from "./changeExtensionPlugin.mjs";
+import * as copyToObsidianPluginsFolderPlugin from "./copyToObsidianPluginsFolderPlugin.mjs";
+import * as customEsbuildOptionsPlugin from "./customEsbuildOptionsPlugin.mjs";
+import * as dependency from "./dependency.mjs";
+import * as fixEsmPlugin from "./fixEsmPlugin.mjs";
+import * as fixSourceMapsPlugin from "./fixSourceMapsPlugin.mjs";
+import * as obsidian_plugin_builder from "./obsidian-plugin-builder.mjs";
+import * as preprocessPlugin from "./preprocessPlugin.mjs";
+import * as renameCssPlugin from "./renameCssPlugin.mjs";
+import * as svelteWrapperPlugin from "./svelteWrapperPlugin.mjs";
+export {
+  changeExtensionPlugin,
+  copyToObsidianPluginsFolderPlugin,
+  customEsbuildOptionsPlugin,
+  dependency,
+  fixEsmPlugin,
+  fixSourceMapsPlugin,
+  obsidian_plugin_builder,
+  preprocessPlugin,
+  renameCssPlugin,
+  svelteWrapperPlugin
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL3NjcmlwdC11dGlscy9idW5kbGVycy9lc2J1aWxkLWltcGwvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyBjaGFuZ2VFeHRlbnNpb25QbHVnaW4gZnJvbSAnLi9jaGFuZ2VFeHRlbnNpb25QbHVnaW4udHMnO1xuZXhwb3J0ICogYXMgY29weVRvT2JzaWRpYW5QbHVnaW5zRm9sZGVyUGx1Z2luIGZyb20gJy4vY29weVRvT2JzaWRpYW5QbHVnaW5zRm9sZGVyUGx1Z2luLnRzJztcbmV4cG9ydCAqIGFzIGN1c3RvbUVzYnVpbGRPcHRpb25zUGx1Z2luIGZyb20gJy4vY3VzdG9tRXNidWlsZE9wdGlvbnNQbHVnaW4udHMnO1xuZXhwb3J0ICogYXMgZGVwZW5kZW5jeSBmcm9tICcuL2RlcGVuZGVuY3kudHMnO1xuZXhwb3J0ICogYXMgZml4RXNtUGx1Z2luIGZyb20gJy4vZml4RXNtUGx1Z2luLnRzJztcbmV4cG9ydCAqIGFzIGZpeFNvdXJjZU1hcHNQbHVnaW4gZnJvbSAnLi9maXhTb3VyY2VNYXBzUGx1Z2luLnRzJztcbmV4cG9ydCAqIGFzIG9ic2lkaWFuX3BsdWdpbl9idWlsZGVyIGZyb20gJy4vb2JzaWRpYW4tcGx1Z2luLWJ1aWxkZXIudHMnO1xuZXhwb3J0ICogYXMgcHJlcHJvY2Vzc1BsdWdpbiBmcm9tICcuL3ByZXByb2Nlc3NQbHVnaW4udHMnO1xuZXhwb3J0ICogYXMgcmVuYW1lQ3NzUGx1Z2luIGZyb20gJy4vcmVuYW1lQ3NzUGx1Z2luLnRzJztcbmV4cG9ydCAqIGFzIHN2ZWx0ZVdyYXBwZXJQbHVnaW4gZnJvbSAnLi9zdmVsdGVXcmFwcGVyUGx1Z2luLnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUVBLFlBQVksMkJBQTJCO0FBQ3ZDLFlBQVksdUNBQXVDO0FBQ25ELFlBQVksZ0NBQWdDO0FBQzVDLFlBQVksZ0JBQWdCO0FBQzVCLFlBQVksa0JBQWtCO0FBQzlCLFlBQVkseUJBQXlCO0FBQ3JDLFlBQVksNkJBQTZCO0FBQ3pDLFlBQVksc0JBQXNCO0FBQ2xDLFlBQVkscUJBQXFCO0FBQ2pDLFlBQVkseUJBQXlCOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/esm/script-utils/bundlers/esbuild-impl/obsidian-plugin-builder.d.mts

@@ -0,0 +1,89 @@
+/**
+ * @packageDocumentation
+ *
+ * This module provides functionality to build and bundle an Obsidian plugin using esbuild.
+ * It includes functions to handle the build process based on different build modes (development or production),
+ * and it sets up various esbuild plugins to preprocess, lint, fix source maps, and copy files to the Obsidian plugins folder.
+ */
+import type { BuildContext, BuildOptions, Plugin } from 'esbuild';
+import { CliTaskResult } from '../../cli-utils.mjs';
+/**
+ * Enumeration representing the build modes.
+ */
+export declare enum BuildMode {
+    /** Development mode for building the plugin */
+    Development = 0,
+    /** Production mode for building the plugin */
+    Production = 1
+}
+/**
+ * Banner text to be included at the top of the generated files.
+ */
+export declare const banner = "/*\nTHIS IS A GENERATED/BUNDLED FILE BY ESBUILD\nif you want to view the source, please visit the github repository of this plugin\n*/\n";
+/**
+ * Options for {@link buildObsidianPlugin}.
+ */
+export interface BuildObsidianPluginParams {
+    /**
+     * Custom esbuild plugins to be used during the build process.
+     */
+    readonly customEsbuildPlugins?: Plugin[];
+    /**
+     * Customizes the `esbuild` options.
+     */
+    readonly customizeEsbuildOptions?: (options: BuildOptions) => void;
+    /**
+     * A build mode, either `Development` or `Production`
+     */
+    readonly mode: BuildMode;
+    /**
+     * A folder for Obsidian configuration. Defaults to the `OBSIDIAN_CONFIG_FOLDER` environment variable.
+     */
+    readonly obsidianConfigFolder?: string;
+}
+/**
+ * Build parameters without the mode field, for use with {@link build} and {@link dev}.
+ */
+export interface BuildParams {
+    /**
+     * Custom esbuild plugins to be used during the build process.
+     */
+    readonly customEsbuildPlugins?: Plugin[];
+    /**
+     * Customizes the `esbuild` options.
+     */
+    readonly customizeEsbuildOptions?: (options: BuildOptions) => void;
+    /**
+     * A folder for Obsidian configuration. Defaults to the `OBSIDIAN_CONFIG_FOLDER` environment variable.
+     */
+    readonly obsidianConfigFolder?: string;
+}
+/**
+ * Builds the Obsidian plugin in production mode using esbuild.
+ *
+ * @param params - Optional build parameters (mode is set to Production automatically).
+ * @returns A {@link Promise} that resolves when the build is complete.
+ */
+export declare function build(params?: BuildParams): Promise<void>;
+/**
+ * Builds the Obsidian plugin based on the specified mode and configuration folder.
+ *
+ * @param params - The parameters for building the plugin.
+ * @returns A {@link Promise} that resolves to a {@link CliTaskResult} indicating the success or failure of the build.
+ */
+export declare function buildObsidianPlugin(params: BuildObsidianPluginParams): Promise<CliTaskResult>;
+/**
+ * Builds the Obsidian plugin in development mode using esbuild with watch.
+ *
+ * @param params - Optional build parameters (mode is set to Development automatically).
+ * @returns A {@link Promise} that resolves when the dev build starts (keeps process alive for watch mode).
+ */
+export declare function dev(params?: BuildParams): Promise<void>;
+/**
+ * Invokes the build process with the provided build context.
+ *
+ * @param buildContext - The build context generated by esbuild.
+ * @param isProductionBuild - A boolean indicating whether the build is a production build.
+ * @returns A {@link Promise} that resolves to a {@link CliTaskResult} indicating the success or failure of the build.
+ */
+export declare function invokeEsbuild(buildContext: BuildContext, isProductionBuild: boolean): Promise<CliTaskResult>;

package/dist/lib/esm/script-utils/bundlers/esbuild-impl/obsidian-plugin-builder.mjs

@@ -0,0 +1,173 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import { context } from "esbuild";
+import sassPlugin_ from "esbuild-sass-plugin";
+import { existsSync } from "node:fs";
+import {
+  cp,
+  mkdir,
+  rm,
+  writeFile
+} from "node:fs/promises";
+import { builtinModules } from "node:module";
+import process, { loadEnvFile } from "node:process";
+import { extractDefaultExportInterop } from "../../../object-utils.mjs";
+import { ObsidianPluginRepoPaths } from "../../../obsidian/plugin/obsidian-plugin-repo-paths.mjs";
+import { join } from "../../../path.mjs";
+import { ensureNonNullable } from "../../../type-guards.mjs";
+import { buildCompile } from "../../build.mjs";
+import { CliTaskResult } from "../../cli-utils.mjs";
+import { readPackageJson } from "../../npm.mjs";
+import { resolvePathFromRoot } from "../../root.mjs";
+import { copyToObsidianPluginsFolderPlugin } from "./copyToObsidianPluginsFolderPlugin.mjs";
+import { customEsbuildOptionsPlugin } from "./customEsbuildOptionsPlugin.mjs";
+import { fixEsmPlugin } from "./fixEsmPlugin.mjs";
+import { fixSourceMapsPlugin } from "./fixSourceMapsPlugin.mjs";
+import { preprocessPlugin } from "./preprocessPlugin.mjs";
+import { renameCssPlugin } from "./renameCssPlugin.mjs";
+import { svelteWrapperPlugin } from "./svelteWrapperPlugin.mjs";
+const sassPlugin = extractDefaultExportInterop(sassPlugin_);
+var BuildMode = /* @__PURE__ */ ((BuildMode2) => {
+  BuildMode2[BuildMode2["Development"] = 0] = "Development";
+  BuildMode2[BuildMode2["Production"] = 1] = "Production";
+  return BuildMode2;
+})(BuildMode || {});
+const banner = `/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+`;
+async function build(params) {
+  const result = await buildObsidianPlugin({ ...params, mode: 1 /* Production */ });
+  result.throwOnFailure();
+}
+async function buildObsidianPlugin(params) {
+  await buildCompile();
+  const envPath = resolvePathFromRoot(".env");
+  if (envPath && existsSync(envPath)) {
+    loadEnvFile(envPath);
+  }
+  const obsidianPluginBuilderEnv = process.env;
+  const obsidianConfigFolder = params.obsidianConfigFolder ?? obsidianPluginBuilderEnv.OBSIDIAN_CONFIG_FOLDER ?? "";
+  const isProductionBuild = params.mode === 1 /* Production */;
+  const distFolder = ensureNonNullable(
+    resolvePathFromRoot(isProductionBuild ? ObsidianPluginRepoPaths.DistBuild : ObsidianPluginRepoPaths.DistDev),
+    "Could not determine the dist folder"
+  );
+  if (existsSync(distFolder)) {
+    await rm(distFolder, { recursive: true });
+  }
+  await mkdir(distFolder, { recursive: true });
+  const distFileNames = [
+    ObsidianPluginRepoPaths.ManifestJson
+  ];
+  if (!isProductionBuild) {
+    await writeFile(join(distFolder, ObsidianPluginRepoPaths.HotReload), "", "utf-8");
+  }
+  for (const fileName of distFileNames) {
+    const localFile = ensureNonNullable(resolvePathFromRoot(fileName), `Could not determine the local file for ${fileName}`);
+    const distFile = join(distFolder, fileName);
+    if (existsSync(localFile)) {
+      await cp(localFile, distFile);
+    }
+  }
+  const distPath = join(distFolder, ObsidianPluginRepoPaths.MainJs);
+  const cssPath = join(distFolder, ObsidianPluginRepoPaths.StylesCss);
+  const packageJson = await readPackageJson();
+  const pluginName = packageJson.name ?? "(unknown)";
+  const buildOptions = {
+    banner: {
+      js: banner
+    },
+    bundle: true,
+    conditions: ["browser"],
+    entryPoints: [
+      ensureNonNullable(
+        resolvePathFromRoot(join(ObsidianPluginRepoPaths.Src, ObsidianPluginRepoPaths.MainTs)),
+        "Could not determine the entry point for the plugin"
+      )
+    ],
+    external: [
+      "obsidian",
+      "electron",
+      "@codemirror/autocomplete",
+      "@codemirror/collab",
+      "@codemirror/commands",
+      "@codemirror/language",
+      "@codemirror/lint",
+      "@codemirror/search",
+      "@codemirror/state",
+      "@codemirror/view",
+      "@lezer/common",
+      "@lezer/highlight",
+      "@lezer/lr",
+      "esbuild",
+      "eslint",
+      ...builtinModules
+    ],
+    format: "cjs",
+    keepNames: true,
+    logLevel: "info",
+    minify: isProductionBuild,
+    outfile: distPath,
+    platform: "node",
+    plugins: [
+      customEsbuildOptionsPlugin(params.customizeEsbuildOptions?.bind(params)),
+      svelteWrapperPlugin(isProductionBuild),
+      sassPlugin({
+        sourceMap: !isProductionBuild
+      }),
+      renameCssPlugin(distFolder),
+      preprocessPlugin(),
+      fixEsmPlugin(),
+      fixSourceMapsPlugin(isProductionBuild, [distPath, cssPath], pluginName),
+      ...params.customEsbuildPlugins ?? [],
+      copyToObsidianPluginsFolderPlugin(isProductionBuild, distFolder, obsidianConfigFolder, pluginName)
+    ],
+    sourcemap: isProductionBuild ? false : "inline",
+    target: "esnext",
+    treeShaking: true
+  };
+  const buildContext = await context(buildOptions);
+  return await invokeEsbuild(buildContext, isProductionBuild);
+}
+async function dev(params) {
+  await buildObsidianPlugin({ ...params, mode: 0 /* Development */ });
+}
+async function invokeEsbuild(buildContext, isProductionBuild) {
+  if (isProductionBuild) {
+    const result = await buildContext.rebuild();
+    const isSuccess = result.errors.length === 0 && result.warnings.length === 0;
+    return CliTaskResult.Success(isSuccess);
+  }
+  await buildContext.watch();
+  return CliTaskResult.DoNotExit();
+}
+export {
+  BuildMode,
+  banner,
+  build,
+  buildObsidianPlugin,
+  dev,
+  invokeEsbuild
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../../src/script-utils/bundlers/esbuild-impl/obsidian-plugin-builder.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * This module provides functionality to build and bundle an Obsidian plugin using esbuild.\n * It includes functions to handle the build process based on different build modes (development or production),\n * and it sets up various esbuild plugins to preprocess, lint, fix source maps, and copy files to the Obsidian plugins folder.\n */\n\n/* v8 ignore start -- esbuild-based build pipeline with sass/svelte plugins and file watchers; requires a live esbuild context. */\n\nimport type {\n  BuildContext,\n  BuildOptions,\n  Plugin\n} from 'esbuild';\n\nimport { context } from 'esbuild';\n// eslint-disable-next-line import-x/no-rename-default -- We need a temp variable to apply `extractDefaultExportInterop()` fix below.\nimport sassPlugin_ from 'esbuild-sass-plugin';\nimport { existsSync } from 'node:fs';\nimport {\n  cp,\n  mkdir,\n  rm,\n  writeFile\n} from 'node:fs/promises';\nimport { builtinModules } from 'node:module';\nimport process, { loadEnvFile } from 'node:process';\n\nimport { extractDefaultExportInterop } from '../../../object-utils.ts';\nimport { ObsidianPluginRepoPaths } from '../../../obsidian/plugin/obsidian-plugin-repo-paths.ts';\nimport { join } from '../../../path.ts';\nimport { ensureNonNullable } from '../../../type-guards.ts';\nimport { buildCompile } from '../../build.ts';\nimport { CliTaskResult } from '../../cli-utils.ts';\nimport { readPackageJson } from '../../npm.ts';\nimport { resolvePathFromRoot } from '../../root.ts';\nimport { copyToObsidianPluginsFolderPlugin } from './copyToObsidianPluginsFolderPlugin.ts';\nimport { customEsbuildOptionsPlugin } from './customEsbuildOptionsPlugin.ts';\nimport { fixEsmPlugin } from './fixEsmPlugin.ts';\nimport { fixSourceMapsPlugin } from './fixSourceMapsPlugin.ts';\nimport { preprocessPlugin } from './preprocessPlugin.ts';\nimport { renameCssPlugin } from './renameCssPlugin.ts';\nimport { svelteWrapperPlugin } from './svelteWrapperPlugin.ts';\n\nconst sassPlugin = extractDefaultExportInterop(sassPlugin_);\n\n/**\n * Enumeration representing the build modes.\n */\nexport enum BuildMode {\n  /** Development mode for building the plugin */\n  Development,\n  /** Production mode for building the plugin */\n  Production\n}\n\n/**\n * Banner text to be included at the top of the generated files.\n */\nexport const banner = `/*\nTHIS IS A GENERATED/BUNDLED FILE BY ESBUILD\nif you want to view the source, please visit the github repository of this plugin\n*/\n`;\n\n/**\n * Options for {@link buildObsidianPlugin}.\n */\nexport interface BuildObsidianPluginParams {\n  /**\n   * Custom esbuild plugins to be used during the build process.\n   */\n  readonly customEsbuildPlugins?: Plugin[];\n\n  /**\n   * Customizes the `esbuild` options.\n   */\n  readonly customizeEsbuildOptions?: (options: BuildOptions) => void;\n\n  /**\n   * A build mode, either `Development` or `Production`\n   */\n  readonly mode: BuildMode;\n\n  /**\n   * A folder for Obsidian configuration. Defaults to the `OBSIDIAN_CONFIG_FOLDER` environment variable.\n   */\n  readonly obsidianConfigFolder?: string;\n}\n\n/**\n * Build parameters without the mode field, for use with {@link build} and {@link dev}.\n */\nexport interface BuildParams {\n  /**\n   * Custom esbuild plugins to be used during the build process.\n   */\n  readonly customEsbuildPlugins?: Plugin[];\n\n  /**\n   * Customizes the `esbuild` options.\n   */\n  readonly customizeEsbuildOptions?: (options: BuildOptions) => void;\n\n  /**\n   * A folder for Obsidian configuration. Defaults to the `OBSIDIAN_CONFIG_FOLDER` environment variable.\n   */\n  readonly obsidianConfigFolder?: string;\n}\n\ninterface ObsidianPluginBuilderEnv {\n  OBSIDIAN_CONFIG_FOLDER: string;\n}\n\n/**\n * Builds the Obsidian plugin in production mode using esbuild.\n *\n * @param params - Optional build parameters (mode is set to Production automatically).\n * @returns A {@link Promise} that resolves when the build is complete.\n */\nexport async function build(params?: BuildParams): Promise<void> {\n  const result = await buildObsidianPlugin({ ...params, mode: BuildMode.Production });\n  result.throwOnFailure();\n}\n\n/**\n * Builds the Obsidian plugin based on the specified mode and configuration folder.\n *\n * @param params - The parameters for building the plugin.\n * @returns A {@link Promise} that resolves to a {@link CliTaskResult} indicating the success or failure of the build.\n */\nexport async function buildObsidianPlugin(params: BuildObsidianPluginParams): Promise<CliTaskResult> {\n  await buildCompile();\n  const envPath = resolvePathFromRoot('.env');\n  if (envPath && existsSync(envPath)) {\n    loadEnvFile(envPath);\n  }\n  const obsidianPluginBuilderEnv = process.env as Partial<ObsidianPluginBuilderEnv>;\n\n  const obsidianConfigFolder = params.obsidianConfigFolder ?? obsidianPluginBuilderEnv.OBSIDIAN_CONFIG_FOLDER ?? '';\n  const isProductionBuild = params.mode === BuildMode.Production;\n\n  const distFolder = ensureNonNullable(\n    resolvePathFromRoot(isProductionBuild ? ObsidianPluginRepoPaths.DistBuild : ObsidianPluginRepoPaths.DistDev),\n    'Could not determine the dist folder'\n  );\n\n  if (existsSync(distFolder)) {\n    await rm(distFolder, { recursive: true });\n  }\n  await mkdir(distFolder, { recursive: true });\n\n  const distFileNames = [\n    ObsidianPluginRepoPaths.ManifestJson\n  ];\n  if (!isProductionBuild) {\n    await writeFile(join(distFolder, ObsidianPluginRepoPaths.HotReload), '', 'utf-8');\n  }\n\n  for (const fileName of distFileNames) {\n    const localFile = ensureNonNullable(resolvePathFromRoot(fileName), `Could not determine the local file for ${fileName}`);\n    const distFile = join(distFolder, fileName);\n\n    if (existsSync(localFile)) {\n      await cp(localFile, distFile);\n    }\n  }\n\n  const distPath = join(distFolder, ObsidianPluginRepoPaths.MainJs);\n  const cssPath = join(distFolder, ObsidianPluginRepoPaths.StylesCss);\n\n  const packageJson = await readPackageJson();\n  const pluginName = packageJson.name ?? '(unknown)';\n\n  const buildOptions: BuildOptions = {\n    banner: {\n      js: banner\n    },\n    bundle: true,\n    conditions: ['browser'],\n    entryPoints: [\n      ensureNonNullable(\n        resolvePathFromRoot(join(ObsidianPluginRepoPaths.Src, ObsidianPluginRepoPaths.MainTs)),\n        'Could not determine the entry point for the plugin'\n      )\n    ],\n    external: [\n      'obsidian',\n      'electron',\n      '@codemirror/autocomplete',\n      '@codemirror/collab',\n      '@codemirror/commands',\n      '@codemirror/language',\n      '@codemirror/lint',\n      '@codemirror/search',\n      '@codemirror/state',\n      '@codemirror/view',\n      '@lezer/common',\n      '@lezer/highlight',\n      '@lezer/lr',\n      'esbuild',\n      'eslint',\n      ...builtinModules\n    ],\n    format: 'cjs',\n    keepNames: true,\n    logLevel: 'info',\n    minify: isProductionBuild,\n    outfile: distPath,\n    platform: 'node',\n    plugins: [\n      customEsbuildOptionsPlugin(params.customizeEsbuildOptions?.bind(params)),\n      svelteWrapperPlugin(isProductionBuild),\n      sassPlugin({\n        sourceMap: !isProductionBuild\n      }),\n      renameCssPlugin(distFolder),\n      preprocessPlugin(),\n      fixEsmPlugin(),\n      fixSourceMapsPlugin(isProductionBuild, [distPath, cssPath], pluginName),\n      ...params.customEsbuildPlugins ?? [],\n      copyToObsidianPluginsFolderPlugin(isProductionBuild, distFolder, obsidianConfigFolder, pluginName)\n    ],\n    sourcemap: isProductionBuild ? false : 'inline',\n    target: 'esnext',\n    treeShaking: true\n  };\n\n  const buildContext = await context(buildOptions);\n  return await invokeEsbuild(buildContext, isProductionBuild);\n}\n\n/**\n * Builds the Obsidian plugin in development mode using esbuild with watch.\n *\n * @param params - Optional build parameters (mode is set to Development automatically).\n * @returns A {@link Promise} that resolves when the dev build starts (keeps process alive for watch mode).\n */\nexport async function dev(params?: BuildParams): Promise<void> {\n  await buildObsidianPlugin({ ...params, mode: BuildMode.Development });\n}\n\n/**\n * Invokes the build process with the provided build context.\n *\n * @param buildContext - The build context generated by esbuild.\n * @param isProductionBuild - A boolean indicating whether the build is a production build.\n * @returns A {@link Promise} that resolves to a {@link CliTaskResult} indicating the success or failure of the build.\n */\nexport async function invokeEsbuild(buildContext: BuildContext, isProductionBuild: boolean): Promise<CliTaskResult> {\n  if (isProductionBuild) {\n    const result = await buildContext.rebuild();\n    const isSuccess = result.errors.length === 0 && result.warnings.length === 0;\n    return CliTaskResult.Success(isSuccess);\n  }\n  await buildContext.watch();\n  return CliTaskResult.DoNotExit();\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["BuildMode"]
}


package/dist/lib/esm/script-utils/bundlers/esbuild-impl/preprocessPlugin.mjs

@@ -0,0 +1,185 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import { readFile } from "node:fs/promises";
+import {
+  FunctionHandlingMode,
+  toJson
+} from "../../../object-utils.mjs";
+import {
+  makeValidVariableName,
+  replaceAll
+} from "../../../string.mjs";
+function preprocessPlugin(isEsm) {
+  const replacements = isEsm ? {} : {
+    [replaceAll("import(dot)meta(dot)url", "(dot)", ".")]: () => {
+      if (typeof __filename === "string") {
+        const localRequire = require;
+        const url = localRequire("node:url");
+        if (typeof url.pathToFileURL === "function") {
+          return url.pathToFileURL(__filename).href;
+        }
+      }
+      if (typeof window !== "undefined") {
+        return window.location.href;
+      }
+      return "";
+    }
+  };
+  return {
+    name: "preprocess",
+    setup(build) {
+      build.initialOptions.define ??= {};
+      for (const key of Object.keys(replacements)) {
+        build.initialOptions.define[key] = `__${makeValidVariableName(key)}`;
+      }
+      build.initialOptions.banner ??= {};
+      build.initialOptions.banner["js"] ??= "";
+      build.initialOptions.banner["js"] += `
+(${String(isEsm ? initEsm : initCjs)})();
+`;
+      build.onLoad({ filter: /\.(?:js|ts|cjs|mjs|cts|mts)$/ }, async (args) => {
+        let contents = await readFile(args.path, "utf-8");
+        for (const [key, value] of Object.entries(replacements)) {
+          const variable = `__${makeValidVariableName(key)}`;
+          if (!contents.includes(key)) {
+            continue;
+          }
+          const valueStr = typeof value === "function" ? `(${String(value)})()` : toJson(value, { functionHandlingMode: FunctionHandlingMode.Full });
+          if (contents.includes(`var ${variable}`)) {
+            continue;
+          }
+          contents = `var ${variable} = globalThis['${key}'] ?? ${valueStr};
+${contents}`;
+        }
+        contents = replaceAll(contents, /`\r?\n\/\/# sourceMappingURL/g, "`\n//#${''} sourceMappingURL");
+        return {
+          contents,
+          loader: "ts"
+        };
+      });
+    }
+  };
+}
+function initCjs() {
+  const globalThisRecord = globalThis;
+  globalThisRecord["__name"] ??= name;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    require = Object.assign(
+      (id) => requirePatched(id),
+      originalRequire,
+      {
+        __isPatched: true
+      }
+    );
+  }
+  const newFuncs = {
+    __extractDefault() {
+      return extractDefault;
+    },
+    process() {
+      const browserProcess = {
+        browser: true,
+        cwd() {
+          return "/";
+        },
+        env: {},
+        platform: "android"
+      };
+      return browserProcess;
+    }
+  };
+  for (const key of Object.keys(newFuncs)) {
+    globalThisRecord[key] ??= newFuncs[key]?.();
+  }
+  function name(obj) {
+    return obj;
+  }
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+    "obsidian",
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/lr",
+    "@lezer/highlight"
+  ];
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+    "@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.includes(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id)) {
+      return originalRequire?.(id);
+    }
+    if (globalThis?.app?.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return globalThis.process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+}
+function initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  globalThis.process = browserProcess;
+}
+export {
+  preprocessPlugin
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../../src/script-utils/bundlers/esbuild-impl/preprocessPlugin.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * This module defines a custom esbuild plugin that preprocesses JavaScript and TypeScript files.\n *\n * @remarks\n * We cannot use `.` instead of `(dot)` in the above description because the file itself is preprocessed with the same rule.\n */\n\n/* v8 ignore start -- esbuild plugin that preprocesses source files with import.meta.url shims and process polyfills; requires a live esbuild context. */\n\nimport type { Plugin } from 'esbuild';\nimport type { pathToFileURL } from 'node:url';\n\nimport { readFile } from 'node:fs/promises';\n\nimport type { GenericObject } from '../../../type-guards.ts';\n\nimport {\n  FunctionHandlingMode,\n  toJson\n} from '../../../object-utils.ts';\nimport {\n  makeValidVariableName,\n  replaceAll\n} from '../../../string.ts';\n\ninterface BrowserProcess extends Partial<NodeJS.Process> {\n  browser: boolean;\n}\n\ninterface EsmModule {\n  __esModule: boolean;\n  default: unknown;\n}\n\ninterface RequirePatched extends NodeJS.Require {\n  __isPatched: boolean;\n}\n\n/**\n * Creates an esbuild plugin that preprocesses JavaScript and TypeScript files.\n *\n * This plugin performs the following tasks:\n * - Replaces instances of `import(dot)meta(dot)url` with a Node.js-compatible `__filename` alternative.\n * - Modifies the `sourceMappingURL` comment to ensure compatibility with Obsidian's plugin system.\n * - Adds a basic `process` object to the global scope if `process` is referenced but not defined.\n *\n * @param isEsm - Whether the build is for an ESM format.\n * @returns An esbuild `Plugin` object that handles the preprocessing.\n */\nexport function preprocessPlugin(isEsm?: boolean): Plugin {\n  const replacements = isEsm\n    ? {}\n    : {\n      [replaceAll('import(dot)meta(dot)url', '(dot)', '.')]: (): string => {\n        if (typeof __filename === 'string') {\n          const localRequire = require;\n          const url = localRequire('node:url') as { pathToFileURL: typeof pathToFileURL };\n          if (typeof url.pathToFileURL === 'function') {\n            return url.pathToFileURL(__filename).href;\n          }\n        }\n\n        if (typeof window !== 'undefined') {\n          return window.location.href;\n        }\n\n        // Fallback to an empty string if the environment is unknown\n        return '';\n      }\n    };\n\n  return {\n    name: 'preprocess',\n    setup(build): void {\n      build.initialOptions.define ??= {};\n\n      for (const key of Object.keys(replacements)) {\n        build.initialOptions.define[key] = `__${makeValidVariableName(key)}`;\n      }\n\n      build.initialOptions.banner ??= {};\n      build.initialOptions.banner['js'] ??= '';\n      build.initialOptions.banner['js'] += `\\n(${String(isEsm ? initEsm : initCjs)})();\\n`;\n\n      build.onLoad({ filter: /\\.(?:js|ts|cjs|mjs|cts|mts)$/ }, async (args) => {\n        let contents = await readFile(args.path, 'utf-8');\n\n        for (const [key, value] of Object.entries(replacements)) {\n          const variable = `__${makeValidVariableName(key)}`;\n          if (!contents.includes(key)) {\n            continue;\n          }\n          const valueStr = typeof value === 'function' ? `(${String(value)})()` : toJson(value, { functionHandlingMode: FunctionHandlingMode.Full });\n          if (contents.includes(`var ${variable}`)) {\n            continue;\n          }\n          contents = `var ${variable} = globalThis['${key}'] ?? ${valueStr};\\n${contents}`;\n        }\n\n        // HACK: The ${''} part is used to ensure Obsidian loads the plugin properly,\n        // Otherwise, it stops loading after the first line of the sourceMappingURL comment.\n        // eslint-disable-next-line no-template-curly-in-string -- It is intentional, the string looks like a template literal, but it is not.\n        contents = replaceAll(contents, /`\\r?\\n\\/\\/# sourceMappingURL/g, '`\\n//#${\\'\\'} sourceMappingURL');\n\n        return {\n          contents,\n          loader: 'ts'\n        };\n      });\n    }\n  };\n}\n\nfunction initCjs(): void {\n  const globalThisRecord = globalThis as GenericObject;\n  globalThisRecord['__name'] ??= name;\n  const originalRequire = require as (NodeJS.Require & Partial<RequirePatched> | undefined);\n  if (originalRequire && !originalRequire.__isPatched) {\n    // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.\n    require = Object.assign(\n      (id: string) => requirePatched(id),\n      originalRequire,\n      {\n        __isPatched: true\n      }\n    ) as RequirePatched;\n  }\n\n  const newFuncs: Record<string, () => unknown> = {\n    __extractDefault() {\n      return extractDefault;\n    },\n    process() {\n      const browserProcess: BrowserProcess = {\n        browser: true,\n        cwd() {\n          return '/';\n        },\n        env: {},\n        platform: 'android'\n      };\n      return browserProcess;\n    }\n  };\n\n  for (const key of Object.keys(newFuncs)) {\n    globalThisRecord[key] ??= newFuncs[key]?.();\n  }\n\n  function name(obj: unknown): unknown {\n    return obj;\n  }\n\n  function extractDefault(module: Partial<EsmModule> | undefined): unknown {\n    return module && module.__esModule && 'default' in module ? module.default : module;\n  }\n\n  const OBSIDIAN_BUILT_IN_MODULE_NAMES = [\n    'obsidian',\n    '@codemirror/autocomplete',\n    '@codemirror/collab',\n    '@codemirror/commands',\n    '@codemirror/language',\n    '@codemirror/lint',\n    '@codemirror/search',\n    '@codemirror/state',\n    '@codemirror/text',\n    '@codemirror/view',\n    '@lezer/common',\n    '@lezer/lr',\n    '@lezer/highlight'\n  ];\n\n  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = [\n    '@codemirror/closebrackets',\n    '@codemirror/comment',\n    '@codemirror/fold',\n    '@codemirror/gutter',\n    '@codemirror/highlight',\n    '@codemirror/history',\n    '@codemirror/matchbrackets',\n    '@codemirror/panel',\n    '@codemirror/rangeset',\n    '@codemirror/rectangular-selection',\n    '@codemirror/stream-parser',\n    '@codemirror/tooltip'\n  ];\n\n  function requirePatched(id: string): unknown {\n    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id)) {\n      return originalRequire?.(id);\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-deprecated, @typescript-eslint/no-unnecessary-condition -- We need access to app here which might not be available yet.\n    if (globalThis?.app?.isMobile) {\n      if (id === 'process' || id === 'node:process') {\n        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);\n        return globalThis.process;\n      }\n    } else {\n      const module = originalRequire?.(id) as (Partial<EsmModule> | undefined);\n      if (module) {\n        return extractDefault(module);\n      }\n    }\n\n    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);\n    return {};\n  }\n}\n\nfunction initEsm(): void {\n  if ((globalThis.process as NodeJS.Process | undefined)) {\n    return;\n  }\n\n  const browserProcess: BrowserProcess = {\n    browser: true,\n    cwd() {\n      return '/';\n    },\n    env: {},\n    platform: 'android'\n  };\n  globalThis.process = browserProcess as NodeJS.Process;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}
