@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.0.0

package/dist/lib/cjs/bundlers/esbuild-impl/preprocess-plugin.d.cts

@@ -0,0 +1,143 @@
+/// <reference path="../../index.d.cts" />
+/**
+ * @file
+ *
+ * This module defines a custom esbuild plugin that preprocesses JavaScript and TypeScript files for any build target.
+ *
+ * @remarks
+ * We cannot use `.` instead of `(dot)` in the above description because the file itself is preprocessed with the same rule.
+ *
+ * `initCjs`, `initEsm` and the shims they call are stringified with `String(fn)` and injected into every
+ * built bundle as an esbuild banner, so they must be reachable from one another by BARE identifier. That is
+ * why they all live in this module: esbuild compiles a cross-module call to `(0, import_module.fn)(…)`,
+ * which would name a binding the emitted bundle does not have. Same-module references stay bare, and
+ * {@link makePreprocessBanner} serializes the shims alongside the `init` function so they are in scope there. A shim
+ * that is not serialized silently degrades to whatever the consumer's global scope holds under that name — which
+ * is how `__name` used to end up holding `window.name`.
+ *
+ * A caller that needs more in the banner (the Obsidian plugin builder patches `require`) hands in
+ * {@link PreprocessPluginOptions.additionalBannerInitFunctions}. Each one is serialized as its OWN immediately
+ * invoked function after the shared scope, so it must be self-contained: it cannot see the shims, and calling one
+ * from another module would hit exactly the cross-module trap above.
+ */
+import type { Plugin } from 'esbuild' with { 'resolution-mode': 'import' };
+/**
+ * Options for {@link makePreprocessBanner}.
+ */
+export interface MakePreprocessBannerOptions {
+    /**
+     * Self-contained functions serialized after the shared shims, each invoked once.
+     */
+    readonly additionalBannerInitFunctions?: readonly (() => void)[];
+    /**
+     * Whether the build is for an ESM format.
+     */
+    readonly isEsm?: boolean;
+}
+/**
+ * Options for {@link preprocessPlugin}.
+ */
+export interface PreprocessPluginOptions {
+    /**
+     * Self-contained functions serialized into the banner after the shared shims, each invoked once.
+     *
+     * @remarks
+     * Each function is emitted as `(${String(fn)})();`, so it may reference only globals and what it declares itself.
+     */
+    readonly additionalBannerInitFunctions?: readonly (() => void)[];
+    /**
+     * The self-contained function whose result replaces `import(dot)meta(dot)url` in a CommonJS build. Serialized into
+     * every file that reads it.
+     *
+     * @default A function returning the file URL of `__filename`, or `location.href` where there is no `__filename`.
+     */
+    readonly cjsImportMetaUrlProvider?: () => string;
+    /**
+     * Whether the build is for an ESM format.
+     */
+    readonly isEsm?: boolean;
+}
+/**
+ * The slice of the `Symbol` constructor {@link ensureDisposeSymbols} reads and writes, with the two dispose
+ * symbols optional because an engine without Explicit Resource Management does not have them.
+ */
+interface DisposeSymbolHost {
+    asyncDispose?: symbol;
+    dispose?: symbol;
+    for: (key: string) => symbol;
+}
+/**
+ * Ensures the bundle runs against a `process` global that browser-targeting packages recognize.
+ *
+ * @remarks
+ * Serialized into the emitted banner, so it never runs in the builder process — but it is an ordinary
+ * function here, so it is unit-tested directly rather than by evaluating the banner text.
+ *
+ * Fills in the keys MISSING from a host-provided `process` rather than replacing or skipping it. Obsidian
+ * Mobile exposes a partial `process`, and the whole-object guards this replaced (`if (globalThis.process) {
+ * return; }` / `globalThisRecord['process'] ??= …`) took that as "already shimmed", so `browser` never
+ * landed. The bundled `debug` package then selected its Node entry point, which calls
+ * `require('util').deprecate()` at module top level, and on mobile the patched `require` returns `{}` — so
+ * the plugin threw before its `onload` ran.
+ *
+ * A real Node or Electron `process` is left completely untouched. `process.versions.node` is the signal for
+ * it, and it is self-contained, so it also holds in the Node CLI bundles this banner is emitted into.
+ */
+export declare function ensureBrowserProcess(): void;
+/**
+ * Makes `Symbol.dispose` and `Symbol.asyncDispose` exist, falling back to the registry symbols esbuild's
+ * `using` helpers look up.
+ *
+ * @param symbolConstructor - The `Symbol` constructor to patch. Defaults to the ambient one; the parameter
+ * exists so a test can hand in an engine that lacks the well-known symbols.
+ *
+ * @remarks
+ * Serialized into the emitted banner. A disposable declares its method under the LITERAL key
+ * `[Symbol.dispose]`, while esbuild lowers every `using` to a lookup through `__knownSymbol('dispose')`,
+ * which falls back to `Symbol.for('Symbol.dispose')` when the engine has no well-known symbol. On such an
+ * engine the literal key evaluates to `undefined`, the method lands under the string `"undefined"`, and
+ * every `using` of it throws `Object not disposable`. Filling the well-known slot with that same registry
+ * symbol makes both sides name one key on every engine. A host that already has the symbol is left
+ * untouched: `??=` never reaches the assignment, which the host's non-writable property would refuse.
+ *
+ * The default names `Symbol` bare on purpose: it exists on every engine this runs on, and a bare reference
+ * resolves against whatever scope the banner is evaluated in, exactly as the bundle's own
+ * `[Symbol.dispose]` keys do.
+ */
+export declare function ensureDisposeSymbols(symbolConstructor?: DisposeSymbolHost): void;
+/**
+ * Returns its argument unchanged.
+ *
+ * @param $unknown - The value to return.
+ * @returns The value passed in.
+ *
+ * @remarks
+ * Serialized into the emitted banner, where it stands in for esbuild's `__name` helper — which names a
+ * function and returns it — for bundles that reference the helper without emitting their own.
+ */
+export declare function keepName($unknown: unknown): unknown;
+/**
+ * Builds the banner injected at the top of every emitted bundle.
+ *
+ * `String(fn)` captures only the function's own body, so every shim the `init` function calls has to be
+ * serialized next to it and wrapped in one shared scope; otherwise the call it makes resolves against the
+ * consumer's global scope at runtime. See this file's `@file` remarks.
+ *
+ * @param options - The banner options.
+ * @returns The banner source to prepend to the emitted bundle.
+ */
+export declare function makePreprocessBanner(options?: MakePreprocessBannerOptions): string;
+/**
+ * Creates an esbuild plugin that preprocesses JavaScript and TypeScript files.
+ *
+ * This plugin performs the following tasks:
+ * - Replaces instances of `import(dot)meta(dot)url` with a CommonJS-compatible `__filename` alternative.
+ * - Modifies the `sourceMappingURL` comment so a template literal ending a file does not swallow it.
+ * - Adds a basic `process` object to the global scope if `process` is referenced but not defined.
+ * - Fills in `Symbol.dispose` / `Symbol.asyncDispose` on engines that lack them, so `using` works there.
+ *
+ * @param options - The plugin options.
+ * @returns An esbuild `Plugin` object that handles the preprocessing.
+ */
+export declare function preprocessPlugin(options?: PreprocessPluginOptions): Plugin;
+export {};

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

@@ -0,0 +1,129 @@
+/*
+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 keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"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 svelte_wrapper_plugin_exports = {};
+__export(svelte_wrapper_plugin_exports, {
+  svelteWrapperPlugin: () => svelteWrapperPlugin
+});
+module.exports = __toCommonJS(svelte_wrapper_plugin_exports);
+var import_object_utils = require('@mnaoumov/typescript-lib/object-utils');
+var import_esbuild_svelte = __toESM(__extractDefault(require('esbuild-svelte')), 1);
+var import_svelte_preprocess = require('svelte-preprocess');
+var import_npm = require('../../npm.cjs');
+const esbuildSvelte = (0, import_object_utils.extractDefaultExportInterop)(import_esbuild_svelte.default);
+function svelteWrapperPlugin(isProductionBuild) {
+  const esbuildSveltePlugin = esbuildSvelte({
+    compilerOptions: {
+      css: "injected",
+      dev: !isProductionBuild
+    },
+    moduleCompilerOptions: {
+      dev: !isProductionBuild
+    },
+    preprocess: (0, import_svelte_preprocess.sveltePreprocess)()
+  });
+  return {
+    name: "svelte-wrapper",
+    async setup(build) {
+      const packageJson = await (0, import_npm.readPackageJson)();
+      const format = packageJson.type === "module" ? "esm" : "cjs";
+      await esbuildSveltePlugin.setup({
+        ...build,
+        initialOptions: {
+          ...build.initialOptions,
+          format
+        }
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  svelteWrapperPlugin
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/bundlers/esbuild-impl/svelte-wrapper-plugin.d.cts

@@ -0,0 +1,14 @@
+/// <reference path="../../index.d.cts" />
+/**
+ * @file
+ *
+ * Svelte wrapper esbuild plugin.
+ */
+import type { Plugin } from 'esbuild' with { 'resolution-mode': 'import' };
+/**
+ * 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/cjs/bundlers/index.cjs

@@ -0,0 +1,99 @@
+/*
+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 keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"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 bundlers_exports = {};
+__export(bundlers_exports, {
+  "esbuild-impl": () => esbuild_impl
+});
+module.exports = __toCommonJS(bundlers_exports);
+var esbuild_impl = __toESM(__extractDefault(require('./esbuild-impl/index.cjs')), 1);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  "esbuild-impl": null
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2J1bmRsZXJzL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKiBUSElTIElTIEEgR0VORVJBVEVEL0JVTkRMRUQgRklMRSBCWSBCVUlMRCBTQ1JJUFQgKi9cblxuZXhwb3J0ICogYXMgJ2VzYnVpbGQtaW1wbCcgZnJvbSAnLi9lc2J1aWxkLWltcGwvaW5kZXgudHMnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQSx3QkFBQUE7QUFBQTtBQUFBO0FBRUEsSUFBQUEsZUFBZ0M7IiwKICAibmFtZXMiOiBbImVzYnVpbGQtaW1wbCJdCn0K

package/dist/lib/cjs/bundlers/index.d.cts

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

package/dist/lib/cjs/check-project-types.cjs

@@ -0,0 +1,163 @@
+/*
+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 keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"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 check_project_types_exports = {};
+__export(check_project_types_exports, {
+  checkProjectTypes: () => checkProjectTypes,
+  parseTsConfig: () => parseTsConfig,
+  toCanonical: () => toCanonical
+});
+module.exports = __toCommonJS(check_project_types_exports);
+var import_node_process = __toESM(__extractDefault(require('node:process')), 1);
+var import_typescript = require('typescript');
+const FORMAT_HOST = {
+  getCanonicalFileName: (fileName) => fileName,
+  getCurrentDirectory: () => import_typescript.sys.getCurrentDirectory(),
+  getNewLine: () => import_typescript.sys.newLine
+};
+function checkProjectTypes(params) {
+  const options = {
+    ...params.options,
+    skipLibCheck: false
+  };
+  const program = (0, import_typescript.createProgram)({
+    options,
+    rootNames: [...params.rootNames]
+  });
+  const allDiagnostics = (0, import_typescript.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) {
+    import_node_process.default.stdout.write((0, import_typescript.formatDiagnosticsWithColorAndContext)(keptDiagnostics, FORMAT_HOST));
+  }
+  import_node_process.default.stdout.write(`Ignored ${String(ignoredCount)} diagnostic(s) outside the validated set.
+`);
+  if (params.isVerbose && ignoredCount > 0) {
+    const ignoredDiagnostics = allDiagnostics.filter((diagnostic) => !keptDiagnostics.includes(diagnostic));
+    import_node_process.default.stdout.write((0, import_typescript.formatDiagnosticsWithColorAndContext)(ignoredDiagnostics, FORMAT_HOST));
+  }
+  return keptDiagnostics.every((diagnostic) => diagnostic.category !== import_typescript.DiagnosticCategory.Error);
+}
+function parseTsConfig(tsConfigPath) {
+  const host = {
+    fileExists: (path) => import_typescript.sys.fileExists(path),
+    getCurrentDirectory: () => import_typescript.sys.getCurrentDirectory(),
+    onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
+      throw new Error((0, import_typescript.formatDiagnostic)(diagnostic, FORMAT_HOST));
+    },
+    readDirectory: (rootDirectory, extensions, excludes, includes, depth) => import_typescript.sys.readDirectory(rootDirectory, extensions, excludes, includes, depth),
+    readFile: (path) => import_typescript.sys.readFile(path),
+    useCaseSensitiveFileNames: import_typescript.sys.useCaseSensitiveFileNames
+  };
+  const parsed = (0, import_typescript.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}:
+${(0, import_typescript.formatDiagnostics)(parsed.errors, FORMAT_HOST)}`);
+  }
+  return {
+    fileNames: parsed.fileNames,
+    options: parsed.options
+  };
+}
+function toCanonical(fileName) {
+  const normalized = fileName.replaceAll("\\", "/");
+  return import_typescript.sys.useCaseSensitiveFileNames ? normalized : normalized.toLowerCase();
+}
+function shouldKeepDiagnosticByFile(diagnostic, shouldKeepFile) {
+  return !diagnostic.file || shouldKeepFile(toCanonical(diagnostic.file.fileName));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAmBA,0BAAoB;AACpB,wBASO;AA6DP,MAAM,cAAqC;AAAA,EACzC,sBAAsB,CAAC,aAAa;AAAA,EACpC,qBAAqB,MAAM,sBAAI,oBAAoB;AAAA,EACnD,YAAY,MAAM,sBAAI;AACxB;AAWO,SAAS,kBAAkB,QAA0C;AAC1E,QAAM,UAA2B;AAAA,IAC/B,GAAG,OAAO;AAAA,IACV,cAAc;AAAA,EAChB;AAEA,QAAM,cAAU,iCAAc;AAAA,IAC5B;AAAA,IACA,WAAW,CAAC,GAAG,OAAO,SAAS;AAAA,EACjC,CAAC;AAED,QAAM,qBAAiB,yCAAsB,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,wBAAAA,QAAQ,OAAO,UAAM,wDAAqC,iBAAiB,WAAW,CAAC;AAAA,EACzF;AAEA,sBAAAA,QAAQ,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,wBAAAA,QAAQ,OAAO,UAAM,wDAAqC,oBAAoB,WAAW,CAAC;AAAA,EAC5F;AAEA,SAAO,gBAAgB,MAAM,CAAC,eAAe,WAAW,aAAa,qCAAmB,KAAK;AAC/F;AAUO,SAAS,cAAc,cAAsC;AAClE,QAAM,OAA4B;AAAA,IAChC,YAAY,CAAC,SAAS,sBAAI,WAAW,IAAI;AAAA,IACzC,qBAAqB,MAAM,sBAAI,oBAAoB;AAAA,IACnD,qCAAqC,CAAC,eAAe;AACnD,YAAM,IAAI,UAAM,oCAAiB,YAAY,WAAW,CAAC;AAAA,IAC3D;AAAA,IACA,eAAe,CAAC,eAAe,YAAY,UAAU,UAAU,UAAU,sBAAI,cAAc,eAAe,YAAY,UAAU,UAAU,KAAK;AAAA,IAC/I,UAAU,CAAC,SAAS,sBAAI,SAAS,IAAI;AAAA,IACrC,2BAA2B,sBAAI;AAAA,EACjC;AAEA,QAAM,aAAS,oDAAiC,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,MAAM,qCAAkB,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,sBAAI,4BAA4B,aAAa,WAAW,YAAY;AAC7E;AAEA,SAAS,2BAA2B,YAAwB,gBAAwD;AAClH,SAAO,CAAC,WAAW,QAAQ,eAAe,YAAY,WAAW,KAAK,QAAQ,CAAC;AACjF;",
  "names": ["process"]
}


package/dist/lib/cjs/check-project-types.d.cts

@@ -0,0 +1,92 @@
+/// <reference path="./index.d.cts" />
+/**
+ * @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' with { 'resolution-mode': 'import' };
+/**
+ * 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;