@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.0.0

package/dist/lib/esm/bundlers/esbuild-impl/preprocess-plugin.mjs

@@ -0,0 +1,176 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+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;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import {
+  FunctionHandlingMode,
+  toJson
+} from "@mnaoumov/typescript-lib/object-utils";
+import {
+  makeValidVariableName,
+  replaceAll
+} from "@mnaoumov/typescript-lib/string";
+import { readFile } from "node:fs/promises";
+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;
+}
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+function keepName($unknown) {
+  return $unknown;
+}
+function makePreprocessBanner(options = {}) {
+  const { additionalBannerInitFunctions = [], isEsm = false } = options;
+  const shims = isEsm ? [ensureDisposeSymbols, ensureBrowserProcess] : [ensureDisposeSymbols, ensureBrowserProcess, keepName];
+  const init = isEsm ? initEsm : initCjs;
+  const additionalInits = additionalBannerInitFunctions.map((function_) => `(${String(function_)})();
+`).join("");
+  return `
+(function () {
+${shims.map(String).join("\n\n")}
+
+(${String(init)})();
+})();
+${additionalInits}`;
+}
+function preprocessPlugin(options = {}) {
+  const { additionalBannerInitFunctions = [], cjsImportMetaUrlProvider = getCjsImportMetaUrl, isEsm = false } = options;
+  const replacements = isEsm ? {} : {
+    [replaceAll({
+      $string: "import(dot)meta(dot)url",
+      replacer: ".",
+      searchValue: "(dot)"
+    })]: cjsImportMetaUrlProvider
+  };
+  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"] += makePreprocessBanner({ additionalBannerInitFunctions, isEsm });
+      build.onLoad({ filter: /\.(?:js|ts|cjs|mjs|cts|mts)$/ }, async ($arguments) => {
+        let contents = await readFile($arguments.path, "utf-8");
+        for (const [key, value] of Object.entries(replacements)) {
+          const variable = `__${makeValidVariableName(key)}`;
+          if (!contents.includes(key) || contents.includes(`var ${variable}`)) {
+            continue;
+          }
+          const valueString = typeof value === "function" ? `(${String(value)})()` : toJson(value, { functionHandlingMode: FunctionHandlingMode.Full });
+          contents = `var ${variable} = globalThis['${key}'] ?? ${valueString};
+${contents}`;
+        }
+        contents = replaceAll({
+          $string: contents,
+          // eslint-disable-next-line no-template-curly-in-string -- It is intentional, the string looks like a template literal, but it is not.
+          replacer: "`\n//#${''} sourceMappingURL",
+          searchValue: /`\r?\n\/\/# sourceMappingURL/g
+        });
+        return {
+          contents,
+          loader: "ts"
+        };
+      });
+    }
+  };
+}
+function getCjsImportMetaUrl() {
+  if (typeof __filename === "string") {
+    const localRequire = require;
+    const url = localRequire("node:url");
+    if (typeof url.pathToFileURL === "function") {
+      return url.pathToFileURL(__filename).href;
+    }
+  }
+  return globalThis.location?.href ?? "";
+}
+function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord["__name"] ??= keepName;
+  globalThisRecord["__extractDefault"] ??= extractDefault;
+  ensureBrowserProcess();
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+}
+function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+}
+export {
+  ensureBrowserProcess,
+  ensureDisposeSymbols,
+  keepName,
+  makePreprocessBanner,
+  preprocessPlugin
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/bundlers/esbuild-impl/preprocess-plugin.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module defines a custom esbuild plugin that preprocesses JavaScript and TypeScript files for any build target.\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 * `initCjs`, `initEsm` and the shims they call are stringified with `String(fn)` and injected into every\n * built bundle as an esbuild banner, so they must be reachable from one another by BARE identifier. That is\n * why they all live in this module: esbuild compiles a cross-module call to `(0, import_module.fn)(\u2026)`,\n * which would name a binding the emitted bundle does not have. Same-module references stay bare, and\n * {@link makePreprocessBanner} serializes the shims alongside the `init` function so they are in scope there. A shim\n * that is not serialized silently degrades to whatever the consumer's global scope holds under that name \u2014 which\n * is how `__name` used to end up holding `window.name`.\n *\n * A caller that needs more in the banner (the Obsidian plugin builder patches `require`) hands in\n * {@link PreprocessPluginOptions.additionalBannerInitFunctions}. Each one is serialized as its OWN immediately\n * invoked function after the shared scope, so it must be self-contained: it cannot see the shims, and calling one\n * from another module would hit exactly the cross-module trap above.\n */\n\nimport type { GenericObject } from '@mnaoumov/typescript-lib/type-guards';\nimport type { Plugin } from 'esbuild';\nimport type { pathToFileURL } from 'node:url';\n\nimport {\n  FunctionHandlingMode,\n  toJson\n} from '@mnaoumov/typescript-lib/object-utils';\nimport {\n  makeValidVariableName,\n  replaceAll\n} from '@mnaoumov/typescript-lib/string';\nimport { readFile } from 'node:fs/promises';\n\n/**\n * Options for {@link makePreprocessBanner}.\n */\nexport interface MakePreprocessBannerOptions {\n  /**\n   * Self-contained functions serialized after the shared shims, each invoked once.\n   */\n  readonly additionalBannerInitFunctions?: readonly (() => void)[];\n\n  /**\n   * Whether the build is for an ESM format.\n   */\n  readonly isEsm?: boolean;\n}\n\n/**\n * Options for {@link preprocessPlugin}.\n */\nexport interface PreprocessPluginOptions {\n  /**\n   * Self-contained functions serialized into the banner after the shared shims, each invoked once.\n   *\n   * @remarks\n   * Each function is emitted as `(${String(fn)})();`, so it may reference only globals and what it declares itself.\n   */\n  readonly additionalBannerInitFunctions?: readonly (() => void)[];\n\n  /**\n   * The self-contained function whose result replaces `import(dot)meta(dot)url` in a CommonJS build. Serialized into\n   * every file that reads it.\n   *\n   * @default A function returning the file URL of `__filename`, or `location.href` where there is no `__filename`.\n   */\n  readonly cjsImportMetaUrlProvider?: () => string;\n\n  /**\n   * Whether the build is for an ESM format.\n   */\n  readonly isEsm?: boolean;\n}\n\n/**\n * A browser-flavored stand-in for Node's `process` global.\n */\ninterface BrowserProcess extends Partial<NodeJS.Process> {\n  /**\n   * Marks the process as a browser one. The bundled `debug` package selects its browser entry point on it.\n   */\n  browser: boolean;\n}\n\n/**\n * The slice of the `Symbol` constructor {@link ensureDisposeSymbols} reads and writes, with the two dispose\n * symbols optional because an engine without Explicit Resource Management does not have them.\n */\ninterface DisposeSymbolHost {\n  asyncDispose?: symbol;\n  dispose?: symbol;\n  for: (key: string) => symbol;\n}\n\ninterface EsmModule {\n  __esModule: boolean;\n  default: unknown;\n}\n\n/**\n * The slice of a browser global {@link getCjsImportMetaUrl} reads, optional because a non-browser host has none.\n */\ninterface LocationHost {\n  location?: PageLocation;\n}\n\ninterface PageLocation {\n  href: string;\n}\n\ninterface UrlModule {\n  pathToFileURL: typeof pathToFileURL;\n}\n\n/**\n * Ensures the bundle runs against a `process` global that browser-targeting packages recognize.\n *\n * @remarks\n * Serialized into the emitted banner, so it never runs in the builder process \u2014 but it is an ordinary\n * function here, so it is unit-tested directly rather than by evaluating the banner text.\n *\n * Fills in the keys MISSING from a host-provided `process` rather than replacing or skipping it. Obsidian\n * Mobile exposes a partial `process`, and the whole-object guards this replaced (`if (globalThis.process) {\n * return; }` / `globalThisRecord['process'] ??= \u2026`) took that as \"already shimmed\", so `browser` never\n * landed. The bundled `debug` package then selected its Node entry point, which calls\n * `require('util').deprecate()` at module top level, and on mobile the patched `require` returns `{}` \u2014 so\n * the plugin threw before its `onload` ran.\n *\n * A real Node or Electron `process` is left completely untouched. `process.versions.node` is the signal for\n * it, and it is self-contained, so it also holds in the Node CLI bundles this banner is emitted into.\n */\nexport function ensureBrowserProcess(): void {\n  const browserProcess: GenericObject<BrowserProcess> = {\n    browser: true,\n    cwd() {\n      return '/';\n    },\n    env: {},\n    platform: 'android'\n  };\n\n  const existingProcess = globalThis.process as Partial<NodeJS.Process> | undefined;\n\n  if (!existingProcess) {\n    globalThis.process = browserProcess as NodeJS.Process;\n    return;\n  }\n\n  if (existingProcess.versions?.node) {\n    return;\n  }\n\n  const existingProcessRecord = existingProcess as GenericObject;\n\n  for (const [key, value] of Object.entries(browserProcess)) {\n    existingProcessRecord[key] ??= value;\n  }\n\n  existingProcessRecord['browser'] = true;\n}\n\n/**\n * Makes `Symbol.dispose` and `Symbol.asyncDispose` exist, falling back to the registry symbols esbuild's\n * `using` helpers look up.\n *\n * @param symbolConstructor - The `Symbol` constructor to patch. Defaults to the ambient one; the parameter\n * exists so a test can hand in an engine that lacks the well-known symbols.\n *\n * @remarks\n * Serialized into the emitted banner. A disposable declares its method under the LITERAL key\n * `[Symbol.dispose]`, while esbuild lowers every `using` to a lookup through `__knownSymbol('dispose')`,\n * which falls back to `Symbol.for('Symbol.dispose')` when the engine has no well-known symbol. On such an\n * engine the literal key evaluates to `undefined`, the method lands under the string `\"undefined\"`, and\n * every `using` of it throws `Object not disposable`. Filling the well-known slot with that same registry\n * symbol makes both sides name one key on every engine. A host that already has the symbol is left\n * untouched: `??=` never reaches the assignment, which the host's non-writable property would refuse.\n *\n * The default names `Symbol` bare on purpose: it exists on every engine this runs on, and a bare reference\n * resolves against whatever scope the banner is evaluated in, exactly as the bundle's own\n * `[Symbol.dispose]` keys do.\n */\nexport function ensureDisposeSymbols(symbolConstructor: DisposeSymbolHost = Symbol): void {\n  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');\n  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');\n}\n\n/**\n * Returns its argument unchanged.\n *\n * @param $unknown - The value to return.\n * @returns The value passed in.\n *\n * @remarks\n * Serialized into the emitted banner, where it stands in for esbuild's `__name` helper \u2014 which names a\n * function and returns it \u2014 for bundles that reference the helper without emitting their own.\n */\nexport function keepName($unknown: unknown): unknown {\n  return $unknown;\n}\n\n/**\n * Builds the banner injected at the top of every emitted bundle.\n *\n * `String(fn)` captures only the function's own body, so every shim the `init` function calls has to be\n * serialized next to it and wrapped in one shared scope; otherwise the call it makes resolves against the\n * consumer's global scope at runtime. See this file's `@file` remarks.\n *\n * @param options - The banner options.\n * @returns The banner source to prepend to the emitted bundle.\n */\nexport function makePreprocessBanner(options: MakePreprocessBannerOptions = {}): string {\n  const { additionalBannerInitFunctions = [], isEsm = false } = options;\n  const shims = isEsm ? [ensureDisposeSymbols, ensureBrowserProcess] : [ensureDisposeSymbols, ensureBrowserProcess, keepName];\n  const init = isEsm ? initEsm : initCjs;\n  const additionalInits = additionalBannerInitFunctions.map((function_) => `(${String(function_)})();\\n`).join('');\n  return `\\n(function () {\\n${shims.map(String).join('\\n\\n')}\\n\\n(${String(init)})();\\n})();\\n${additionalInits}`;\n}\n\n/* v8 ignore start -- Everything from here to the matching `stop` either needs a live esbuild context or is serialized into the emitted banner and so runs inside the built bundle, never in this process. The shims above are deliberately NOT ignored: they are ordinary functions here and are unit-tested directly. */\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 CommonJS-compatible `__filename` alternative.\n * - Modifies the `sourceMappingURL` comment so a template literal ending a file does not swallow it.\n * - Adds a basic `process` object to the global scope if `process` is referenced but not defined.\n * - Fills in `Symbol.dispose` / `Symbol.asyncDispose` on engines that lack them, so `using` works there.\n *\n * @param options - The plugin options.\n * @returns An esbuild `Plugin` object that handles the preprocessing.\n */\nexport function preprocessPlugin(options: PreprocessPluginOptions = {}): Plugin {\n  const { additionalBannerInitFunctions = [], cjsImportMetaUrlProvider = getCjsImportMetaUrl, isEsm = false } = options;\n  const replacements = isEsm\n    ? {}\n    : {\n      [\n        replaceAll({\n          $string: 'import(dot)meta(dot)url',\n          replacer: '.',\n          searchValue: '(dot)'\n        })\n      ]: cjsImportMetaUrlProvider\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'] += makePreprocessBanner({ additionalBannerInitFunctions, isEsm });\n\n      build.onLoad({ filter: /\\.(?:js|ts|cjs|mjs|cts|mts)$/ }, async ($arguments) => {\n        let contents = await readFile($arguments.path, 'utf-8');\n\n        for (const [key, value] of Object.entries(replacements)) {\n          const variable = `__${makeValidVariableName(key)}`;\n          if (!contents.includes(key) || contents.includes(`var ${variable}`)) {\n            continue;\n          }\n          const valueString = typeof value === 'function' ? `(${String(value)})()` : toJson(value, { functionHandlingMode: FunctionHandlingMode.Full });\n          contents = `var ${variable} = globalThis['${key}'] ?? ${valueString};\\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\n        contents = replaceAll({\n          $string: contents,\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          replacer: '`\\n//#${\\'\\'} sourceMappingURL',\n          searchValue: /`\\r?\\n\\/\\/# sourceMappingURL/g\n        });\n\n        return {\n          contents,\n          loader: 'ts'\n        };\n      });\n    }\n  };\n}\n\nfunction getCjsImportMetaUrl(): string {\n  if (typeof __filename === 'string') {\n    const localRequire = require;\n    const url = localRequire('node:url') as UrlModule;\n    if (typeof url.pathToFileURL === 'function') {\n      return url.pathToFileURL(__filename).href;\n    }\n  }\n\n  // Fallback to the page URL, or an empty string if the environment is unknown.\n  return (globalThis as LocationHost).location?.href ?? '';\n}\n\nfunction initCjs(): void {\n  const globalThisRecord = globalThis as GenericObject;\n  ensureDisposeSymbols();\n  globalThisRecord['__name'] ??= keepName;\n  globalThisRecord['__extractDefault'] ??= extractDefault;\n\n  ensureBrowserProcess();\n\n  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.\n  function extractDefault(module: Partial<EsmModule> | undefined): unknown {\n    return module && module.__esModule && 'default' in module ? module.default : module;\n  }\n}\n\nfunction initEsm(): void {\n  ensureDisposeSymbols();\n  ensureBrowserProcess();\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/bundlers/esbuild-impl/svelte-wrapper-plugin.d.mts

@@ -0,0 +1,14 @@
+/// <reference path="../../index.d.mts" />
+/**
+ * @file
+ *
+ * Svelte wrapper esbuild plugin.
+ */
+import type { Plugin } from 'esbuild';
+/**
+ * Wraps the esbuild-svelte plugin to ensure that the correct format is used.
+ *
+ * @param isProductionBuild - Whether the build is a production build.
+ * @returns The esbuild plugin.
+ */
+export declare function svelteWrapperPlugin(isProductionBuild: boolean): Plugin;

package/dist/lib/esm/bundlers/esbuild-impl/svelte-wrapper-plugin.mjs

@@ -0,0 +1,82 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+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;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { extractDefaultExportInterop } from "@mnaoumov/typescript-lib/object-utils";
+import esbuildSvelte_ from "esbuild-svelte";
+import { sveltePreprocess } from "svelte-preprocess";
+import { readPackageJson } from "../../npm.mjs";
+const esbuildSvelte = extractDefaultExportInterop(esbuildSvelte_);
+function svelteWrapperPlugin(isProductionBuild) {
+  const esbuildSveltePlugin = esbuildSvelte({
+    compilerOptions: {
+      css: "injected",
+      dev: !isProductionBuild
+    },
+    moduleCompilerOptions: {
+      dev: !isProductionBuild
+    },
+    preprocess: sveltePreprocess()
+  });
+  return {
+    name: "svelte-wrapper",
+    async setup(build) {
+      const packageJson = await readPackageJson();
+      const format = packageJson.type === "module" ? "esm" : "cjs";
+      await esbuildSveltePlugin.setup({
+        ...build,
+        initialOptions: {
+          ...build.initialOptions,
+          format
+        }
+      });
+    }
+  };
+}
+export {
+  svelteWrapperPlugin
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,2 @@
+/// <reference path="../index.d.mts" />
+export * as 'esbuild-impl' from './esbuild-impl/index.mjs';

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

@@ -0,0 +1,52 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+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;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import * as esbuild_impl from "./esbuild-impl/index.mjs";
+export {
+  esbuild_impl as "esbuild-impl"
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2J1bmRsZXJzL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKiBUSElTIElTIEEgR0VORVJBVEVEL0JVTkRMRUQgRklMRSBCWSBCVUlMRCBTQ1JJUFQgKi9cblxuZXhwb3J0ICogYXMgJ2VzYnVpbGQtaW1wbCcgZnJvbSAnLi9lc2J1aWxkLWltcGwvaW5kZXgudHMnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFQSxZQUFZQSxrQkFBb0I7IiwKICAibmFtZXMiOiBbImVzYnVpbGQtaW1wbCJdCn0K

package/dist/lib/esm/check-project-types.d.mts

@@ -0,0 +1,92 @@
+/// <reference path="./index.d.mts" />
+/**
+ * @file
+ *
+ * Type-checks a set of TypeScript files with `skipLibCheck` disabled, but reports only the
+ * diagnostics whose source file we own. This lets the general build run with `skipLibCheck: true`
+ * (so it does not fail on broken upstream `.d.ts` files we do not control, such as a given
+ * version's `obsidian.d.ts`) while still fully validating the declarations we author.
+ *
+ * When upstream types are fixed, the `Ignored N diagnostic(s)` count drops to `0`, signalling the
+ * workaround is no longer doing anything.
+ */
+import type { CompilerOptions, Diagnostic } from 'typescript';
+/**
+ * Parameters for {@link checkProjectTypes}.
+ */
+export interface CheckProjectTypesParams {
+    /**
+     * When `true`, the ignored diagnostics (those dropped by {@link CheckProjectTypesParams.shouldKeepFile}
+     * or {@link CheckProjectTypesParams.shouldKeepDiagnostic}) are printed in full after the ignored
+     * count, so they can be inspected. When omitted or `false`, only the count is printed.
+     *
+     * @default `false`
+     */
+    readonly isVerbose?: boolean;
+    /**
+    Compiler options for the program. `skipLibCheck` is always forced to `false`.
+     */
+    readonly options: CompilerOptions;
+    /**
+    The root files to type-check.
+     */
+    readonly rootNames: readonly string[];
+    /**
+     * Decides whether a diagnostic should be reported, based on the diagnostic itself rather than its
+     * source file. Runs in addition to {@link CheckProjectTypesParams.shouldKeepFile} — a diagnostic is
+     * reported only when both predicates keep it. Use this to drop diagnostics that are reported in a
+     * file we own but are caused by something we do not control (e.g. a cross-module-format interop
+     * complaint about a third-party import). When omitted, no diagnostic is dropped on this basis.
+     *
+     * @param diagnostic - The diagnostic to evaluate.
+     * @returns `true` to report the diagnostic, `false` to ignore it.
+     */
+    readonly shouldKeepDiagnostic?: (diagnostic: Diagnostic) => boolean;
+    /**
+     * Decides whether a diagnostic's source file is one we care about.
+     *
+     * @param fileName - The diagnostic's source file, already passed through {@link toCanonical}.
+     * @returns `true` to report the diagnostic, `false` to ignore it.
+     */
+    readonly shouldKeepFile: (fileName: string) => boolean;
+}
+/**
+ * The resolved result of {@link parseTsConfig}.
+ */
+export interface ParsedTsConfig {
+    /**
+    The resolved list of files the config includes (absolute paths).
+     */
+    readonly fileNames: readonly string[];
+    /**
+    The resolved compiler options (with `extends` applied).
+     */
+    readonly options: CompilerOptions;
+}
+/**
+ * Type-checks a set of files with `skipLibCheck: false`, but reports only the diagnostics whose
+ * source file passes `shouldKeepFile`. Diagnostics from files we do not control (e.g. broken
+ * third-party `.d.ts` pulled in transitively) are dropped, while still being counted for
+ * visibility. When `isVerbose` is set, the dropped diagnostics are also printed in full.
+ *
+ * @param params - The program inputs and the keep predicate.
+ * @returns `true` when no reported diagnostic is an error, `false` otherwise.
+ */
+export declare function checkProjectTypes(params: CheckProjectTypesParams): boolean;
+/**
+ * Parses a `tsconfig.json` (resolving `extends`, `include`, `exclude`) into the resolved file list
+ * and compiler options.
+ *
+ * @param tsConfigPath - Absolute path to the config file.
+ * @returns The resolved file names and options.
+ * @throws If the config cannot be parsed or contains errors.
+ */
+export declare function parseTsConfig(tsConfigPath: string): ParsedTsConfig;
+/**
+ * Normalizes a file path for comparison: forward slashes everywhere, lower-cased on a
+ * case-insensitive file system.
+ *
+ * @param fileName - The path to normalize.
+ * @returns The canonical path.
+ */
+export declare function toCanonical(fileName: string): string;

package/dist/lib/esm/check-project-types.mjs

@@ -0,0 +1,123 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+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;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import process from "node:process";
+import {
+  createProgram,
+  DiagnosticCategory,
+  formatDiagnostic,
+  formatDiagnostics,
+  formatDiagnosticsWithColorAndContext,
+  getParsedCommandLineOfConfigFile,
+  getPreEmitDiagnostics,
+  sys
+} from "typescript";
+const FORMAT_HOST = {
+  getCanonicalFileName: (fileName) => fileName,
+  getCurrentDirectory: () => sys.getCurrentDirectory(),
+  getNewLine: () => sys.newLine
+};
+function checkProjectTypes(params) {
+  const options = {
+    ...params.options,
+    skipLibCheck: false
+  };
+  const program = createProgram({
+    options,
+    rootNames: [...params.rootNames]
+  });
+  const allDiagnostics = getPreEmitDiagnostics(program);
+  const keptDiagnostics = allDiagnostics.filter((diagnostic) => shouldKeepDiagnosticByFile(diagnostic, params.shouldKeepFile) && (params.shouldKeepDiagnostic?.(diagnostic) ?? true));
+  const ignoredCount = allDiagnostics.length - keptDiagnostics.length;
+  if (keptDiagnostics.length > 0) {
+    process.stdout.write(formatDiagnosticsWithColorAndContext(keptDiagnostics, FORMAT_HOST));
+  }
+  process.stdout.write(`Ignored ${String(ignoredCount)} diagnostic(s) outside the validated set.
+`);
+  if (params.isVerbose && ignoredCount > 0) {
+    const ignoredDiagnostics = allDiagnostics.filter((diagnostic) => !keptDiagnostics.includes(diagnostic));
+    process.stdout.write(formatDiagnosticsWithColorAndContext(ignoredDiagnostics, FORMAT_HOST));
+  }
+  return keptDiagnostics.every((diagnostic) => diagnostic.category !== DiagnosticCategory.Error);
+}
+function parseTsConfig(tsConfigPath) {
+  const host = {
+    fileExists: (path) => sys.fileExists(path),
+    getCurrentDirectory: () => sys.getCurrentDirectory(),
+    onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
+      throw new Error(formatDiagnostic(diagnostic, FORMAT_HOST));
+    },
+    readDirectory: (rootDirectory, extensions, excludes, includes, depth) => sys.readDirectory(rootDirectory, extensions, excludes, includes, depth),
+    readFile: (path) => sys.readFile(path),
+    useCaseSensitiveFileNames: sys.useCaseSensitiveFileNames
+  };
+  const parsed = getParsedCommandLineOfConfigFile(tsConfigPath, void 0, host);
+  if (!parsed) {
+    throw new Error(`Failed to parse TypeScript config: ${tsConfigPath}`);
+  }
+  if (parsed.errors.length > 0) {
+    throw new Error(`Errors while parsing TypeScript config ${tsConfigPath}:
+${formatDiagnostics(parsed.errors, FORMAT_HOST)}`);
+  }
+  return {
+    fileNames: parsed.fileNames,
+    options: parsed.options
+  };
+}
+function toCanonical(fileName) {
+  const normalized = fileName.replaceAll("\\", "/");
+  return sys.useCaseSensitiveFileNames ? normalized : normalized.toLowerCase();
+}
+function shouldKeepDiagnosticByFile(diagnostic, shouldKeepFile) {
+  return !diagnostic.file || shouldKeepFile(toCanonical(diagnostic.file.fileName));
+}
+export {
+  checkProjectTypes,
+  parseTsConfig,
+  toCanonical
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/check-project-types.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Type-checks a set of TypeScript files with `skipLibCheck` disabled, but reports only the\n * diagnostics whose source file we own. This lets the general build run with `skipLibCheck: true`\n * (so it does not fail on broken upstream `.d.ts` files we do not control, such as a given\n * version's `obsidian.d.ts`) while still fully validating the declarations we author.\n *\n * When upstream types are fixed, the `Ignored N diagnostic(s)` count drops to `0`, signalling the\n * workaround is no longer doing anything.\n */\n\nimport type {\n  CompilerOptions,\n  Diagnostic,\n  FormatDiagnosticsHost,\n  ParseConfigFileHost\n} from 'typescript';\n\nimport process from 'node:process';\nimport {\n  createProgram,\n  DiagnosticCategory,\n  formatDiagnostic,\n  formatDiagnostics,\n  formatDiagnosticsWithColorAndContext,\n  getParsedCommandLineOfConfigFile,\n  getPreEmitDiagnostics,\n  sys\n} from 'typescript';\n\n/**\n * Parameters for {@link checkProjectTypes}.\n */\nexport interface CheckProjectTypesParams {\n  /**\n   * When `true`, the ignored diagnostics (those dropped by {@link CheckProjectTypesParams.shouldKeepFile}\n   * or {@link CheckProjectTypesParams.shouldKeepDiagnostic}) are printed in full after the ignored\n   * count, so they can be inspected. When omitted or `false`, only the count is printed.\n   *\n   * @default `false`\n   */\n  readonly isVerbose?: boolean;\n\n  /**\n  Compiler options for the program. `skipLibCheck` is always forced to `false`.\n   */\n  readonly options: CompilerOptions;\n\n  /**\n  The root files to type-check.\n   */\n  readonly rootNames: readonly string[];\n\n  /**\n   * Decides whether a diagnostic should be reported, based on the diagnostic itself rather than its\n   * source file. Runs in addition to {@link CheckProjectTypesParams.shouldKeepFile} \u2014 a diagnostic is\n   * reported only when both predicates keep it. Use this to drop diagnostics that are reported in a\n   * file we own but are caused by something we do not control (e.g. a cross-module-format interop\n   * complaint about a third-party import). When omitted, no diagnostic is dropped on this basis.\n   *\n   * @param diagnostic - The diagnostic to evaluate.\n   * @returns `true` to report the diagnostic, `false` to ignore it.\n   */\n  readonly shouldKeepDiagnostic?: (diagnostic: Diagnostic) => boolean;\n\n  /**\n   * Decides whether a diagnostic's source file is one we care about.\n   *\n   * @param fileName - The diagnostic's source file, already passed through {@link toCanonical}.\n   * @returns `true` to report the diagnostic, `false` to ignore it.\n   */\n  readonly shouldKeepFile: (fileName: string) => boolean;\n}\n\n/**\n * The resolved result of {@link parseTsConfig}.\n */\nexport interface ParsedTsConfig {\n  /**\n  The resolved list of files the config includes (absolute paths).\n   */\n  readonly fileNames: readonly string[];\n\n  /**\n  The resolved compiler options (with `extends` applied).\n   */\n  readonly options: CompilerOptions;\n}\n\nconst FORMAT_HOST: FormatDiagnosticsHost = {\n  getCanonicalFileName: (fileName) => fileName,\n  getCurrentDirectory: () => sys.getCurrentDirectory(),\n  getNewLine: () => sys.newLine\n};\n\n/**\n * Type-checks a set of files with `skipLibCheck: false`, but reports only the diagnostics whose\n * source file passes `shouldKeepFile`. Diagnostics from files we do not control (e.g. broken\n * third-party `.d.ts` pulled in transitively) are dropped, while still being counted for\n * visibility. When `isVerbose` is set, the dropped diagnostics are also printed in full.\n *\n * @param params - The program inputs and the keep predicate.\n * @returns `true` when no reported diagnostic is an error, `false` otherwise.\n */\nexport function checkProjectTypes(params: CheckProjectTypesParams): boolean {\n  const options: CompilerOptions = {\n    ...params.options,\n    skipLibCheck: false\n  };\n\n  const program = createProgram({\n    options,\n    rootNames: [...params.rootNames]\n  });\n\n  const allDiagnostics = getPreEmitDiagnostics(program);\n  const keptDiagnostics = allDiagnostics.filter((diagnostic) => shouldKeepDiagnosticByFile(diagnostic, params.shouldKeepFile) && (params.shouldKeepDiagnostic?.(diagnostic) ?? true));\n  const ignoredCount = allDiagnostics.length - keptDiagnostics.length;\n\n  if (keptDiagnostics.length > 0) {\n    process.stdout.write(formatDiagnosticsWithColorAndContext(keptDiagnostics, FORMAT_HOST));\n  }\n\n  process.stdout.write(`Ignored ${String(ignoredCount)} diagnostic(s) outside the validated set.\\n`);\n\n  if (params.isVerbose && ignoredCount > 0) {\n    const ignoredDiagnostics = allDiagnostics.filter((diagnostic) => !keptDiagnostics.includes(diagnostic));\n    process.stdout.write(formatDiagnosticsWithColorAndContext(ignoredDiagnostics, FORMAT_HOST));\n  }\n\n  return keptDiagnostics.every((diagnostic) => diagnostic.category !== DiagnosticCategory.Error);\n}\n\n/**\n * Parses a `tsconfig.json` (resolving `extends`, `include`, `exclude`) into the resolved file list\n * and compiler options.\n *\n * @param tsConfigPath - Absolute path to the config file.\n * @returns The resolved file names and options.\n * @throws If the config cannot be parsed or contains errors.\n */\nexport function parseTsConfig(tsConfigPath: string): ParsedTsConfig {\n  const host: ParseConfigFileHost = {\n    fileExists: (path) => sys.fileExists(path),\n    getCurrentDirectory: () => sys.getCurrentDirectory(),\n    onUnRecoverableConfigFileDiagnostic: (diagnostic) => {\n      throw new Error(formatDiagnostic(diagnostic, FORMAT_HOST));\n    },\n    readDirectory: (rootDirectory, extensions, excludes, includes, depth) => sys.readDirectory(rootDirectory, extensions, excludes, includes, depth),\n    readFile: (path) => sys.readFile(path),\n    useCaseSensitiveFileNames: sys.useCaseSensitiveFileNames\n  };\n\n  const parsed = getParsedCommandLineOfConfigFile(tsConfigPath, undefined, host);\n\n  if (!parsed) {\n    throw new Error(`Failed to parse TypeScript config: ${tsConfigPath}`);\n  }\n\n  if (parsed.errors.length > 0) {\n    throw new Error(`Errors while parsing TypeScript config ${tsConfigPath}:\\n${formatDiagnostics(parsed.errors, FORMAT_HOST)}`);\n  }\n\n  return {\n    fileNames: parsed.fileNames,\n    options: parsed.options\n  };\n}\n\n/**\n * Normalizes a file path for comparison: forward slashes everywhere, lower-cased on a\n * case-insensitive file system.\n *\n * @param fileName - The path to normalize.\n * @returns The canonical path.\n */\nexport function toCanonical(fileName: string): string {\n  const normalized = fileName.replaceAll('\\\\', '/');\n  return sys.useCaseSensitiveFileNames ? normalized : normalized.toLowerCase();\n}\n\nfunction shouldKeepDiagnosticByFile(diagnostic: Diagnostic, shouldKeepFile: (fileName: string) => boolean): boolean {\n  return !diagnostic.file || shouldKeepFile(toCanonical(diagnostic.file.fileName));\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmBA,OAAO,aAAa;AACpB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AA6DP,MAAM,cAAqC;AAAA,EACzC,sBAAsB,CAAC,aAAa;AAAA,EACpC,qBAAqB,MAAM,IAAI,oBAAoB;AAAA,EACnD,YAAY,MAAM,IAAI;AACxB;AAWO,SAAS,kBAAkB,QAA0C;AAC1E,QAAM,UAA2B;AAAA,IAC/B,GAAG,OAAO;AAAA,IACV,cAAc;AAAA,EAChB;AAEA,QAAM,UAAU,cAAc;AAAA,IAC5B;AAAA,IACA,WAAW,CAAC,GAAG,OAAO,SAAS;AAAA,EACjC,CAAC;AAED,QAAM,iBAAiB,sBAAsB,OAAO;AACpD,QAAM,kBAAkB,eAAe,OAAO,CAAC,eAAe,2BAA2B,YAAY,OAAO,cAAc,MAAM,OAAO,uBAAuB,UAAU,KAAK,KAAK;AAClL,QAAM,eAAe,eAAe,SAAS,gBAAgB;AAE7D,MAAI,gBAAgB,SAAS,GAAG;AAC9B,YAAQ,OAAO,MAAM,qCAAqC,iBAAiB,WAAW,CAAC;AAAA,EACzF;AAEA,UAAQ,OAAO,MAAM,WAAW,OAAO,YAAY,CAAC;AAAA,CAA6C;AAEjG,MAAI,OAAO,aAAa,eAAe,GAAG;AACxC,UAAM,qBAAqB,eAAe,OAAO,CAAC,eAAe,CAAC,gBAAgB,SAAS,UAAU,CAAC;AACtG,YAAQ,OAAO,MAAM,qCAAqC,oBAAoB,WAAW,CAAC;AAAA,EAC5F;AAEA,SAAO,gBAAgB,MAAM,CAAC,eAAe,WAAW,aAAa,mBAAmB,KAAK;AAC/F;AAUO,SAAS,cAAc,cAAsC;AAClE,QAAM,OAA4B;AAAA,IAChC,YAAY,CAAC,SAAS,IAAI,WAAW,IAAI;AAAA,IACzC,qBAAqB,MAAM,IAAI,oBAAoB;AAAA,IACnD,qCAAqC,CAAC,eAAe;AACnD,YAAM,IAAI,MAAM,iBAAiB,YAAY,WAAW,CAAC;AAAA,IAC3D;AAAA,IACA,eAAe,CAAC,eAAe,YAAY,UAAU,UAAU,UAAU,IAAI,cAAc,eAAe,YAAY,UAAU,UAAU,KAAK;AAAA,IAC/I,UAAU,CAAC,SAAS,IAAI,SAAS,IAAI;AAAA,IACrC,2BAA2B,IAAI;AAAA,EACjC;AAEA,QAAM,SAAS,iCAAiC,cAAc,QAAW,IAAI;AAE7E,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,sCAAsC,YAAY,EAAE;AAAA,EACtE;AAEA,MAAI,OAAO,OAAO,SAAS,GAAG;AAC5B,UAAM,IAAI,MAAM,0CAA0C,YAAY;AAAA,EAAM,kBAAkB,OAAO,QAAQ,WAAW,CAAC,EAAE;AAAA,EAC7H;AAEA,SAAO;AAAA,IACL,WAAW,OAAO;AAAA,IAClB,SAAS,OAAO;AAAA,EAClB;AACF;AASO,SAAS,YAAY,UAA0B;AACpD,QAAM,aAAa,SAAS,WAAW,MAAM,GAAG;AAChD,SAAO,IAAI,4BAA4B,aAAa,WAAW,YAAY;AAC7E;AAEA,SAAS,2BAA2B,YAAwB,gBAAwD;AAClH,SAAO,CAAC,WAAW,QAAQ,eAAe,YAAY,WAAW,KAAK,QAAQ,CAAC;AACjF;",
  "names": []
}
