@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.0.0

package/dist/lib/esm/linters/eslint.mjs

@@ -0,0 +1,88 @@
+/*
+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 { getLibDebugger } from "@mnaoumov/typescript-lib/debug";
+import { basename } from "@mnaoumov/typescript-lib/path";
+import { existsSync } from "node:fs";
+import { cp } from "node:fs/promises";
+import { resolveToolCommand } from "../package-manager.mjs";
+import { RepoPaths } from "../repo-paths.mjs";
+import {
+  execFromRoot,
+  resolvePathFromRootSafe
+} from "../root.mjs";
+const ESLINT_WARNINGS_AS_FINDINGS_ARGUMENTS = ["--max-warnings", "0", "--no-warn-ignored"];
+async function lint(options) {
+  const { defaultConfigFilePath, paths, shouldFix } = options ?? {};
+  const configFiles = [
+    RepoPaths.EslintConfigJs,
+    RepoPaths.EslintConfigMjs,
+    RepoPaths.EslintConfigCjs,
+    RepoPaths.EslintConfigTs,
+    RepoPaths.EslintConfigMts,
+    RepoPaths.EslintConfigCts
+  ];
+  const doesConfigFileExist = configFiles.some((configFile) => {
+    const configFilePath = resolvePathFromRootSafe({ path: configFile });
+    return existsSync(configFilePath);
+  });
+  if (!doesConfigFileExist && defaultConfigFilePath) {
+    getLibDebugger("ESLint:lint")("ESLint configuration file not found. Creating default config...");
+    await cp(defaultConfigFilePath, resolvePathFromRootSafe({ path: basename(defaultConfigFilePath) }));
+  }
+  const targets = paths?.length ? paths : [RepoPaths.CurrentFolder];
+  await execFromRoot([
+    ...resolveToolCommand({ tool: "eslint" }),
+    ...ESLINT_WARNINGS_AS_FINDINGS_ARGUMENTS,
+    ...shouldFix ? ["--fix"] : [],
+    { batchedArguments: targets }
+  ]);
+}
+export {
+  lint
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,15 @@
+/// <reference path="../index.d.mts" />
+export * as 'cspell-content' from './cspell-content.mjs';
+export * as 'cspell' from './cspell.mjs';
+export * as 'eslint-agnostic-core-boundary' from './eslint-agnostic-core-boundary.mjs';
+export * as 'eslint-config' from './eslint-config.mjs';
+export * as 'eslint-no-restricted-syntax' from './eslint-no-restricted-syntax.mjs';
+export * as 'eslint-rules' from './eslint-rules/index.mjs';
+export * as 'eslint' from './eslint.mjs';
+export * as 'lint-ignores' from './lint-ignores.mjs';
+export * as 'markdownlint-cli2-config' from './markdownlint-cli2-config.mjs';
+export * as 'markdownlint-content' from './markdownlint-content.mjs';
+export * as 'markdownlint-ignores' from './markdownlint-ignores.mjs';
+export * as 'markdownlint-rules' from './markdownlint-rules/index.mjs';
+export * as 'markdownlint' from './markdownlint.mjs';
+export * as 'over-exposure' from './over-exposure.mjs';

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

@@ -0,0 +1,78 @@
+/*
+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 cspell_content from "./cspell-content.mjs";
+import * as cspell from "./cspell.mjs";
+import * as eslint_agnostic_core_boundary from "./eslint-agnostic-core-boundary.mjs";
+import * as eslint_config from "./eslint-config.mjs";
+import * as eslint_no_restricted_syntax from "./eslint-no-restricted-syntax.mjs";
+import * as eslint_rules from "./eslint-rules/index.mjs";
+import * as eslint from "./eslint.mjs";
+import * as lint_ignores from "./lint-ignores.mjs";
+import * as markdownlint_cli2_config from "./markdownlint-cli2-config.mjs";
+import * as markdownlint_content from "./markdownlint-content.mjs";
+import * as markdownlint_ignores from "./markdownlint-ignores.mjs";
+import * as markdownlint_rules from "./markdownlint-rules/index.mjs";
+import * as markdownlint from "./markdownlint.mjs";
+import * as over_exposure from "./over-exposure.mjs";
+export {
+  cspell,
+  cspell_content as "cspell-content",
+  eslint,
+  eslint_agnostic_core_boundary as "eslint-agnostic-core-boundary",
+  eslint_config as "eslint-config",
+  eslint_no_restricted_syntax as "eslint-no-restricted-syntax",
+  eslint_rules as "eslint-rules",
+  lint_ignores as "lint-ignores",
+  markdownlint,
+  markdownlint_cli2_config as "markdownlint-cli2-config",
+  markdownlint_content as "markdownlint-content",
+  markdownlint_ignores as "markdownlint-ignores",
+  markdownlint_rules as "markdownlint-rules",
+  over_exposure as "over-exposure"
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/linters/lint-ignores.d.mts

@@ -0,0 +1,30 @@
+/// <reference path="../index.d.mts" />
+/**
+ * @file
+ *
+ * The paths every linter in this package skips, whichever file type it lints.
+ *
+ * Both `lint` and `lint:md` derive their ignore set from git — ESLint through `includeIgnoreFile`,
+ * markdownlint-cli2 through `gitignore: true` — and that is right and stays. But both read only
+ * `.gitignore` files, while Claude Code excludes its worktree folder through `.git/info/exclude`
+ * instead. So `git status` reads clean while a second, complete checkout of the repository sits under
+ * the root the linters walk, and each one lints the copy:
+ *
+ * - ESLint ran out of memory rather than reporting anything — `FATAL ERROR: Ineffective mark-compacts
+ *   near heap limit` after 97 s at the default 4 GB heap, with a single worktree present. That reads as
+ *   a broken toolchain, not as a stray directory, which is what makes this worth an explicit entry.
+ * - markdownlint-cli2 reported the copy's markdown, including prose a project deliberately exempts at
+ *   its real path and third-party markdown that is not ours to fix.
+ *
+ * The `linkinator` half of `lint:md`, `cspell` and `dprint` are all unaffected and need nothing:
+ * `linkinator` is handed a `git ls-files` list, and the other two honour `.git/info/exclude` as git
+ * itself does. Measured, not assumed.
+ *
+ * This module is the non-markdown counterpart of `markdownlint-ignores.ts` — that one holds the
+ * exclusions that are about markdown, this one the exclusions that are about no file type at all.
+ */
+/**
+ * The glob matching everything inside {@link RepoPaths.ClaudeWorktrees}, for any linter
+ * that takes an ignore configuration.
+ */
+export declare const CLAUDE_WORKTREES_IGNORE_GLOB: string;

package/dist/lib/esm/linters/lint-ignores.mjs

@@ -0,0 +1,54 @@
+/*
+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 { join } from "@mnaoumov/typescript-lib/path";
+import { RepoPaths } from "../repo-paths.mjs";
+const CLAUDE_WORKTREES_IGNORE_GLOB = join(RepoPaths.ClaudeWorktrees, RepoPaths.AnyPath);
+export {
+  CLAUDE_WORKTREES_IGNORE_GLOB
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/linters/markdownlint-cli2-config.d.mts

@@ -0,0 +1,11 @@
+/// <reference path="../index.d.mts" />
+/**
+ * @file
+ *
+ * Default markdownlint-cli2 configuration for the Obsidian Dev Utils.
+ */
+import type { MarkdownlintCli2ConfigurationSchema as MarkdownlintCli2ConfigSchema } from './markdownlint-types/@types/markdownlint-cli2-config-schema.d.mjs';
+/**
+ * Default markdownlint-cli2 configuration for the Obsidian Dev Utils.
+ */
+export declare const obsidianDevUtilsConfig: MarkdownlintCli2ConfigSchema;

package/dist/lib/esm/linters/markdownlint-cli2-config.mjs

@@ -0,0 +1,122 @@
+/*
+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 relativeLinksRule from "markdownlint-rule-relative-links";
+import { CLAUDE_WORKTREES_IGNORE_GLOB } from "./lint-ignores.mjs";
+import { NODE_MODULES_IGNORE_GLOB } from "./markdownlint-ignores.mjs";
+import { noSoftBreakInParagraphRule } from "./markdownlint-rules/no-soft-break-in-paragraph.mjs";
+const obsidianDevUtilsConfig = {
+  config: {
+    "MD013": false,
+    "MD024": {
+      // eslint-disable-next-line camelcase -- That's how it is defined in the schema.
+      siblings_only: true
+    },
+    "MD025": {
+      // `MD025` counts a front matter `title` property as the document's top-level heading, so a note carrying
+      // both that property and an `# H1` is reported as having two. In an Obsidian vault that premise is false:
+      // Obsidian titles a note by its FILENAME and does nothing with a `title` property, so a vault that uses
+      // one as a name-bearing property would trip this rule on every note that is not wrong. Emptying
+      // `front_matter_title` disables only the front matter half of the rule — two `# H1`s in one document are
+      // still reported, which is the half worth keeping.
+      // eslint-disable-next-line camelcase -- That's how it is defined in the schema.
+      front_matter_title: ""
+    },
+    "MD052": {
+      // eslint-disable-next-line camelcase -- That's how it is defined in the schema.
+      ignored_labels: [
+        // GitHub's five alert types, all of which Obsidian renders as callouts. markdownlint reads the
+        // bracketed marker opening one as a shortcut reference link, so each has to be ignored explicitly.
+        "!caution",
+        "!important",
+        "!note",
+        "!tip",
+        "!warning",
+        // Preserve markdownlint's default ignored label so GFM task-list items (`- [x]`) are not flagged as undefined shortcut references.
+        "x"
+      ],
+      // eslint-disable-next-line camelcase -- That's how it is defined in the schema.
+      shortcut_syntax: true
+    },
+    // Registered but OFF by default. markdownlint enables an unlisted custom rule by default, so landing it
+    // silent has to be said out loud. Every repo in this config's reach was hard-wrapped somewhere when this
+    // landed, and the count is not knowable from a wrapped-line heuristic — one measured against a
+    // heuristic's own top ten over-counted six files and under-counted four, worst cases 158 against 776 and
+    // 74 against 34. So a repo measures itself with the rule, unwraps, and turns it on by overriding this one
+    // key in its own `scripts/markdownlint-cli2-config.ts` — the same seam this repo uses for `ignores`.
+    // This repo's own override does exactly that, and is the worked example.
+    "no-soft-break-in-paragraph": false,
+    "relative-links": true
+  },
+  customRules: [
+    noSoftBreakInParagraphRule,
+    relativeLinksRule
+  ],
+  // Every `.gitignore` in the tree, and up to the repository root — git's own default behavior. A path git
+  // ignores is a path we do not lint, so `node_modules` (including the nested ones under test fixtures),
+  // `dist`, and every generated folder are skipped without anyone maintaining a list that can drift.
+  gitignore: true,
+  globs: [
+    "**/*.md"
+  ],
+  // The residual, explicit list — everything `.gitignore` cannot express for us. Git never "ignores"
+  // `.git` itself (it is simply outside the working tree), and a repository can deliberately TRACK a
+  // vendored `node_modules` tree, whose third-party markdown is not ours to lint. See
+  // `markdownlint-ignores.ts`.
+  // Claude Code's worktree folder is the third case, and a different one again: `gitignore: true` reads
+  // only `.gitignore` files, while git excludes that folder through `.git/info/exclude`.
+  // See `lint-ignores.ts`.
+  ignores: [
+    ".git/**",
+    CLAUDE_WORKTREES_IGNORE_GLOB,
+    NODE_MODULES_IGNORE_GLOB
+  ]
+};
+export {
+  obsidianDevUtilsConfig
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/linters/markdownlint-content.d.mts

@@ -0,0 +1,47 @@
+/// <reference path="../index.d.mts" />
+/**
+ * @file
+ *
+ * Lints markdown that is still in memory, with the repository's own `lint:md` configuration.
+ *
+ * `lint:md` can only answer for what is already on disk, which leaves every document composed during a run
+ * unchecked until the next gate — the release's changelog being the one that costs a red `main`. This module
+ * is the same check one step earlier: the text is linted as the path it is destined for, and a caller that
+ * does not like the answer can stop before writing anything.
+ *
+ * It goes through `markdownlint-cli2` rather than `markdownlint`'s own string API, and that is the whole
+ * point of the module. The question a caller is asking is *"would `lint:md` have failed on this text?"*, and
+ * only the `markdownlint-cli2` layer knows: it is what finds `.markdownlint-cli2.mjs` (through `jiti`, for
+ * the TypeScript configuration this workspace writes), merges the repository's own overrides over the shared
+ * defaults, and loads the custom rules. Reaching for the string API means hand-rolling that resolution over
+ * five configuration file formats, which is a copy of `markdownlint-cli2` that can only ever drift from it.
+ */
+/**
+ * Parameters for {@link lintMarkdownContent}.
+ */
+export interface LintMarkdownContentParams {
+    /**
+     * The markdown to lint.
+     */
+    readonly content: string;
+    /**
+     * A folder inside the project whose markdownlint configuration applies. Defaults to the current working folder.
+     * In a workspace, a package's own folder has no configuration of its own, so a caller linting for the
+     * workspace root names it here.
+     */
+    readonly cwd?: string | undefined;
+    /**
+     * The path the content is linted AS — normally the path it is about to be written to. It decides how the
+     * path-relative rules resolve (`relative-links` walks from the file's own folder), and it is what every
+     * reported finding is named after.
+     */
+    readonly filePath: string;
+}
+/**
+ * Lints markdown content that is not on disk, with the configuration `lint:md` would have used for it.
+ *
+ * @param params - The {@link LintMarkdownContentParams}.
+ * @returns A {@link Promise} that resolves to the findings, each one the line the `lint:md` output would have
+ * carried — `<path>:<line>[:<column>] error <rule> <description>` — or an empty array when there are none.
+ */
+export declare function lintMarkdownContent(params: LintMarkdownContentParams): Promise<string[]>;

package/dist/lib/esm/linters/markdownlint-content.mjs

@@ -0,0 +1,83 @@
+/*
+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 { getLibDebugger } from "@mnaoumov/typescript-lib/debug";
+import { toPosixPath } from "@mnaoumov/typescript-lib/path";
+import { main as markdownlintCli2 } from "markdownlint-cli2";
+import { getRootFolder } from "../root.mjs";
+import { obsidianDevUtilsConfig } from "./markdownlint-cli2-config.mjs";
+const SUCCESS_EXIT_CODE = 0;
+async function lintMarkdownContent(params) {
+  const { content, cwd, filePath } = params;
+  const findings = [];
+  const contentDebugger = getLibDebugger("markdownlint:lintMarkdownContent");
+  const exitCode = await markdownlintCli2({
+    directory: getRootFolder(cwd) ?? cwd ?? process.cwd(),
+    logError: (message) => {
+      findings.push(message);
+    },
+    logMessage: (message) => {
+      contentDebugger(message);
+    },
+    // The content is the only input. Without this the configuration's own `globs` would be expanded too, and
+    // a check on one document would lint the whole repository — slowly, and reporting findings its caller has
+    // no business failing on.
+    noGlobs: true,
+    nonFileContents: { [toPosixPath(filePath)]: content },
+    // The BASE the repository's own configuration is merged over, which matters for a repository that has none
+    // yet: `lint()` copies the template configuration in — which is built on this one — before it lints, so a
+    // run without it would apply markdownlint's stock defaults instead, and `MD013/line-length` would fail at
+    // 80 columns on an ordinary release note that `lint:md` is perfectly happy with. Since a repository's own
+    // configuration overrides this key by key, the worst a mismatch can do is miss a finding, never invent one.
+    optionsDefault: obsidianDevUtilsConfig
+  });
+  return exitCode === SUCCESS_EXIT_CODE ? [] : findings;
+}
+export {
+  lintMarkdownContent
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/linters/markdownlint-ignores.d.mts

@@ -0,0 +1,35 @@
+/// <reference path="../index.d.mts" />
+/**
+ * @file
+ *
+ * The markdown paths `lint:md` skips ON TOP of the ones `.gitignore` already excludes.
+ *
+ * Deriving the ignore set from `.gitignore` is right and stays — git's own semantics, nested ignore files
+ * and all, with no hand-maintained list to drift. But it can only ever skip what git skips, and a
+ * repository can **deliberately track** a vendored `node_modules` tree. `obsidian-codescript-toolkit`
+ * does: `demo-vault/.gitignore` re-includes `_assets/CodeScriptToolkit/node_modules/` on purpose, so the
+ * demo vault's "NPM modules" note can `require('uuid')` offline. `lint:md` then linted a third-party
+ * README and failed the whole gate on its table style, its inline HTML, and a relative link to a file
+ * that only exists in the upstream repository — none of which is this project's to fix.
+ *
+ * So the shared helper is "`.gitignore` **plus** these", which is what the `.gitignore`-derived work
+ * anticipated. This is NOT a return to the hand-maintained globs that preceded it: those were removed
+ * because they DUPLICATED `.gitignore`, not because an explicit entry is ever wrong.
+ *
+ * Both halves of `lint:md` read from here so they cannot disagree — markdownlint-cli2 takes an ignore
+ * configuration, while `linkinator` takes a file list and has to be filtered before it is invoked.
+ */
+/**
+ * The glob form, for markdownlint-cli2's `ignores`.
+ */
+export declare const NODE_MODULES_IGNORE_GLOB = "**/node_modules/**";
+/**
+ * Checks whether a path sits inside a `node_modules` folder at any depth.
+ *
+ * Matches on a full path SEGMENT rather than a substring, so a file whose own name merely contains the
+ * word (`node_modules-migration.md`) is not swept up with it.
+ *
+ * @param path - A path relative to the repository root, separated by `/` (the form `git ls-files` emits).
+ * @returns `true` when the path is inside a `node_modules` folder.
+ */
+export declare function checkIsInNodeModules(path: string): boolean;