declapract-typescript-ehmpathy 0.49.13 → 0.49.14

package/dist/.test/assets/tool-swap-removals/declarations/practices/tests-node/bad-practices/deprecated-test-deps/package.json.declapract.ts

@@ -0,0 +1,60 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+
+const deprecatedDeps = [
+  'babel-jest',
+  '@babel/core',
+  '@babel/preset-env',
+  'core-js',
+  'ts-jest',
+];
+
+/**
+ * .what = flags a package.json that holds ANY deprecated test dep, in either section.
+ * .why  = the prior `CONTAINS` check matched only a repo that held ALL five, in devDependencies;
+ *         a repo with just `core-js` + `ts-jest` was never flagged, so the fix never ran (#660).
+ */
+export const check: FileCheckFunction = (contents) => {
+  const pkg = JSON.parse(contents ?? '{}');
+  const declared = { ...pkg.dependencies, ...pkg.devDependencies };
+  if (deprecatedDeps.some((dep) => dep in declared)) return; // bad practice detected
+  throw new Error('does not match bad practice: no deprecated test dep');
+};
+
+/**
+ * .what = returns a deps map with every deprecated key removed, without any mutation
+ * .why  = the fix strips deprecated test deps; rule.require.immutable-vars forbids a
+ *         delete-in-place on the copied deps object, so it filters into a fresh map instead
+ */
+const withoutDeprecatedDeps = (
+  deps: Record<string, string> | undefined,
+): Record<string, string> =>
+  Object.fromEntries(
+    Object.entries(deps ?? {}).filter(([dep]) => !deprecatedDeps.includes(dep)),
+  );
+
+/**
+ * .what = removes the deprecated node-jest test deps from a package.json's
+ *         dependencies + devDependencies
+ * .why  = deps like babel-jest, ts-jest, @babel/* belong to the retired node-jest
+ *         toolchain; a repo on the @swc/jest config no longer needs them, so this
+ *         bad-practice fix drops them
+ */
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return { contents }; // no-op when the file is absent
+  const packageJSON = JSON.parse(contents);
+
+  // remove deprecated deps from devDependencies + dependencies (non-mutating filter)
+  const updatedDevDeps = withoutDeprecatedDeps(packageJSON.devDependencies);
+  const updatedDeps = withoutDeprecatedDeps(packageJSON.dependencies);
+
+  const updatedPackageJSON = {
+    ...packageJSON,
+    dependencies: Object.keys(updatedDeps).length > 0 ? updatedDeps : undefined,
+    devDependencies:
+      Object.keys(updatedDevDeps).length > 0 ? updatedDevDeps : undefined,
+  };
+
+  return {
+    contents: JSON.stringify(updatedPackageJSON, null, 2),
+  };
+};

package/dist/.test/assets/tool-swap-removals/declarations/practices/typescript-any/bad-practices/legacy-tsconfig-lib/.declapract.readme.md

@@ -0,0 +1,7 @@
+a tsconfig `lib` override with no es2022-capable entry (e.g. a legacy `lib: ["DOM"]`).
+
+a `lib` override replaces the `@tsconfig/node20` default, so it drops the ES2022 `ErrorOptions`
+type, and the shipped `new Error(msg, { cause })` templates fail `test:types` with TS2554.
+
+the fix appends `"ES2023"` to the array and keeps each extant entry and comment. to drop the
+override entirely is also correct, when the repo needs none of its entries.

package/dist/.test/assets/tool-swap-removals/declarations/practices/typescript-any/bad-practices/legacy-tsconfig-lib/tsconfig.json.declapract.ts

@@ -0,0 +1,105 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+
+/**
+ * .what = the `"lib": [ … ]` array of a tsconfig, read as text.
+ * .why  = a tsconfig is jsonc (comments, a final comma), so a JSON.parse round-trip would drop
+ *         the comments an adopter wrote; the fix edits the array text in place instead.
+ */
+const LIB_ARRAY_PATTERN = /("lib"\s*:\s*\[)([^\]]*)(\])/;
+
+/**
+ * .what = a lib entry that carries the ES2022 `ErrorOptions` type (`es2022`+ or `esnext`).
+ */
+const ES2022_CAPABLE_LIB_PATTERN =
+  /^(?:es202[2-9]|es20[3-9]\d|esnext)(?:\.|$)/i;
+
+/**
+ * .what = the lib entry the fix appends.
+ * .why  = matches the `@tsconfig/node20` default lib, which a repo with no `lib` override inherits.
+ */
+const LIB_ENTRY_APPENDED = 'ES2023';
+
+/**
+ * .what = the string entries of a lib array's inner text.
+ */
+const asLibEntries = (input: { inner: string }): string[] =>
+  [...input.inner.matchAll(/"([^"]*)"/g)].map((match) => match[1] ?? '');
+
+/**
+ * .what = flags a tsconfig whose `lib` override lacks an es2022-capable entry.
+ * .why  = a `lib` override REPLACES the `@tsconfig/node20` default, so a legacy `lib: ["DOM"]`
+ *         drops `ErrorOptions`, and the shipped `new Error(msg, { cause })` templates fail
+ *         `test:types` with TS2554 (#517).
+ */
+export const check: FileCheckFunction = (contents) => {
+  const inner = contents?.match(LIB_ARRAY_PATTERN)?.[2];
+  if (
+    inner !== undefined &&
+    !asLibEntries({ inner }).some((entry) =>
+      ES2022_CAPABLE_LIB_PATTERN.test(entry),
+    )
+  )
+    return; // bad practice detected
+  throw new Error(
+    'does not match bad practice: no lib override, or the lib override is es2022-capable',
+  );
+};
+
+/**
+ * .what = appends `"ES2023"` after the last lib entry, in the array's own layout.
+ * .why  = keeps each entry the adopter chose (e.g. `DOM`) and every comment around them; it adds
+ *         only the one entry the shipped templates need.
+ */
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return { contents };
+  const match = contents.match(LIB_ARRAY_PATTERN);
+  if (!match) return { contents };
+  const whole = match[0];
+  const open = match[1] ?? '';
+  const inner = match[2] ?? '';
+  const close = match[3] ?? '';
+
+  // append the entry in the array's own layout
+  const innerAfter = asLibInnerWithEntryAppended({
+    inner,
+    entry: LIB_ENTRY_APPENDED,
+  });
+  return { contents: contents.replace(whole, `${open}${innerAfter}${close}`) };
+};
+
+/**
+ * .what = the inner text of a lib array with one more `"<entry>"` after its last entry.
+ * .why  = keeps the array's own layout: an empty array takes the entry bare, a one-line array takes
+ *         it after `, `, and a multi-line array takes it on its own line at the last entry's indent.
+ */
+const asLibInnerWithEntryAppended = (input: {
+  inner: string;
+  entry: string;
+}): string => {
+  // an empty array takes the entry bare
+  const lastEntry = [...input.inner.matchAll(/"[^"]*"/g)].pop();
+  if (!lastEntry || lastEntry.index === undefined) return `"${input.entry}"`;
+
+  // otherwise the entry lands right after the last entry, with the separator its layout uses
+  const insertAt = lastEntry.index + lastEntry[0].length;
+  const separator = asLibEntrySeparator({
+    inner: input.inner,
+    entryAt: lastEntry.index,
+  });
+  return `${input.inner.slice(0, insertAt)}${separator}"${input.entry}"${input.inner.slice(insertAt)}`;
+};
+
+/**
+ * .what = the separator a new lib entry takes: `, ` on a one-line array, or a newline plus the
+ *         last entry's indent on a multi-line array.
+ */
+const asLibEntrySeparator = (input: {
+  inner: string;
+  entryAt: number;
+}): string => {
+  const lineStart = input.inner.lastIndexOf('\n', input.entryAt);
+  if (lineStart === -1) return ', ';
+  const indent =
+    input.inner.slice(lineStart + 1, input.entryAt).match(/^\s*/)?.[0] ?? '';
+  return `,\n${indent}`;
+};

package/dist/.test/assets/tool-swap-removals/declarations/practices/typescript-any/bad-practices/ts-node-beside-esbuild-register/.declapract.readme.md

@@ -0,0 +1,6 @@
+`ts-node` left in package.json after the jest loader moved to `esbuild-register`.
+
+the fix removes `ts-node` only when `esbuild-register` is declared and no part of the repo still
+reaches `ts-node`: no package.json command calls it, no code file imports or requires it, and
+every root `jest.*.ts` config names a `@jest-config-loader` (jest loads a .ts config via ts-node by
+default).

package/dist/.test/assets/tool-swap-removals/declarations/practices/typescript-any/bad-practices/ts-node-beside-esbuild-register/package.json.declapract.ts

@@ -0,0 +1,127 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { asPackageJSON } from '../../../../utils/asPackageJSON';
+import { isPackageImportedInRepo } from '../../../../utils/isPackageImportedInRepo';
+
+const PRACTICE = 'typescript-any/ts-node-beside-esbuild-register';
+
+/**
+ * .what = whether the repo still needs ts-node.
+ * .why  = the tests practice moved the jest config loader to esbuild-register; ts-node stays only
+ *         where a file or script still reaches it (F42):
+ *         - a script that calls it
+ *         - a code file that imports or requires it
+ *         - a root jest config with no `@jest-config-loader` pragma (jest loads a .ts config via
+ *           ts-node by default)
+ */
+const isTsNodeStillUsed = (input: {
+  scripts: Record<string, string>;
+  projectRoot: string | null;
+}): boolean => {
+  // a package.json command that calls ts-node
+  if (
+    Object.values(input.scripts).some((command) => /\bts-node\b/.test(command))
+  )
+    return true;
+
+  // with no repo root to read, keep it
+  const root = input.projectRoot;
+  if (!root || !existsSync(root)) return true;
+
+  // a code file that imports or requires it
+  if (
+    isPackageImportedInRepo({
+      projectRoot: root,
+      packageName: 'ts-node',
+      dirs: ['.'],
+    })
+  )
+    return true;
+
+  // a root jest .ts config that jest would load via ts-node
+  return readdirSync(root)
+    .filter((name) => /^jest\..*\.ts$/.test(name))
+    .some(
+      (name) =>
+        !readFileSync(path.join(root, name), 'utf-8').includes(
+          '@jest-config-loader',
+        ),
+    );
+};
+
+interface PackageJsonDeps {
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  scripts?: Record<string, string>;
+}
+
+/**
+ * .what = whether a package.json holds ts-node beside esbuild-register.
+ */
+const isTsNodeBesideEsbuildRegister = (input: {
+  pkg: PackageJsonDeps;
+}): boolean => {
+  const all = { ...input.pkg.dependencies, ...input.pkg.devDependencies };
+  return !!all['ts-node'] && !!all['esbuild-register'];
+};
+
+/**
+ * .what = flags ts-node once esbuild-register replaced it and no file still reaches it.
+ * .why  = the jest move to @swc/jest + esbuild-register left ts-node installed, which depcheck then
+ *         flags (#660).
+ */
+export const check: FileCheckFunction = (contents, context) => {
+  const pkg: PackageJsonDeps = asPackageJSON(
+    { contents: contents ?? '{}' },
+    { practice: PRACTICE },
+  );
+  if (
+    isTsNodeBesideEsbuildRegister({ pkg }) &&
+    !isTsNodeStillUsed({
+      scripts: pkg.scripts ?? {},
+      projectRoot: context?.getProjectRootDirectory?.() ?? null,
+    })
+  )
+    return; // bad practice detected
+  throw new Error(
+    'does not match bad practice: no ts-node beside esbuild-register, or ts-node is still used',
+  );
+};
+
+/**
+ * .what = removes ts-node from both dep sections.
+ */
+export const fix: FileFixFunction = (contents, context) => {
+  if (!contents) return { contents };
+  const pkg: PackageJsonDeps = asPackageJSON(
+    { contents },
+    { practice: PRACTICE },
+  );
+  if (
+    !isTsNodeBesideEsbuildRegister({ pkg }) ||
+    isTsNodeStillUsed({
+      scripts: pkg.scripts ?? {},
+      projectRoot: context?.getProjectRootDirectory?.() ?? null,
+    })
+  )
+    return { contents };
+  const without = (deps: Record<string, string> | undefined) =>
+    deps
+      ? Object.fromEntries(
+          Object.entries(deps).filter(([name]) => name !== 'ts-node'),
+        )
+      : undefined;
+  return {
+    contents: JSON.stringify(
+      {
+        ...pkg,
+        dependencies: without(pkg.dependencies),
+        devDependencies: without(pkg.devDependencies),
+      },
+      null,
+      2,
+    ),
+  };
+};

package/dist/.test/assets/tool-swap-removals/declarations/practices/typescript-node/bad-practices/node-lts-strictest/.declapract.readme.md

@@ -0,0 +1,5 @@
+`@tsconfig/node-lts-strictest` left in package.json after the tsconfig swap.
+
+the typescript-node tsconfig extends `@tsconfig/strictest` + `@tsconfig/node20`. once no root
+`tsconfig*.json` extends `@tsconfig/node-lts-strictest`, the fix removes it, so depcheck stops
+flags on it. while a tsconfig still extends it, the package stays, so tsc can still load the config.

package/dist/.test/assets/tool-swap-removals/declarations/practices/typescript-node/bad-practices/node-lts-strictest/package.json.declapract.ts

@@ -0,0 +1,90 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { asPackageJSON } from '../../../../utils/asPackageJSON';
+
+const PRACTICE = 'typescript-node/node-lts-strictest';
+
+const RETIRED_TSCONFIG = '@tsconfig/node-lts-strictest';
+
+/**
+ * .what = whether any root tsconfig*.json still extends the retired tsconfig base.
+ * .why  = the package must stay while a tsconfig extends it, or tsc cannot load the config (F42).
+ */
+const isRetiredTsconfigExtended = (input: {
+  projectRoot: string | null;
+}): boolean => {
+  const root = input.projectRoot;
+  if (!root || !existsSync(root)) return false;
+  return readdirSync(root)
+    .filter((name) => /^tsconfig.*\.json$/.test(name))
+    .some((name) =>
+      readFileSync(path.join(root, name), 'utf-8').includes(RETIRED_TSCONFIG),
+    );
+};
+
+/**
+ * .what = whether a package.json declares the retired tsconfig base, in either section.
+ */
+const isRetiredTsconfigDeclared = (input: {
+  contents: string | null;
+}): boolean => {
+  const pkg = asPackageJSON(
+    { contents: input.contents ?? '{}' },
+    { practice: PRACTICE },
+  );
+  return !!(
+    pkg.dependencies?.[RETIRED_TSCONFIG] ??
+    pkg.devDependencies?.[RETIRED_TSCONFIG]
+  );
+};
+
+/**
+ * .what = flags `@tsconfig/node-lts-strictest` once no tsconfig extends it.
+ * .why  = the typescript-node practice swapped it for `@tsconfig/strictest` + `@tsconfig/node20`
+ *         and left the old package in devDependencies, which depcheck then flags (#660).
+ */
+export const check: FileCheckFunction = (contents, context) => {
+  if (
+    isRetiredTsconfigDeclared({ contents }) &&
+    !isRetiredTsconfigExtended({
+      projectRoot: context?.getProjectRootDirectory?.() ?? null,
+    })
+  )
+    return; // bad practice detected
+  throw new Error(
+    `does not match bad practice: ${RETIRED_TSCONFIG} absent, or a tsconfig still extends it`,
+  );
+};
+
+/**
+ * .what = removes the retired tsconfig base from both dep sections.
+ */
+export const fix: FileFixFunction = (contents, context) => {
+  if (
+    !contents ||
+    isRetiredTsconfigExtended({
+      projectRoot: context?.getProjectRootDirectory?.() ?? null,
+    })
+  )
+    return { contents };
+  const pkg = asPackageJSON({ contents }, { practice: PRACTICE });
+  const without = (deps: Record<string, string> | undefined) =>
+    deps
+      ? Object.fromEntries(
+          Object.entries(deps).filter(([name]) => name !== RETIRED_TSCONFIG),
+        )
+      : undefined;
+  return {
+    contents: JSON.stringify(
+      {
+        ...pkg,
+        dependencies: without(pkg.dependencies),
+        devDependencies: without(pkg.devDependencies),
+      },
+      null,
+      2,
+    ),
+  };
+};

package/dist/.test/assets/tool-swap-removals/declarations/useCases.yml

@@ -0,0 +1,7 @@
+# minimal use case for the tool-swap removal integration test
+use-cases:
+  lambda-service:
+    practices:
+      - typescript-any
+      - typescript-node
+      - tests-node

package/dist/.test/assets/tool-swap-removals/repo-after-swaps/declapract.use.yml

@@ -0,0 +1,2 @@
+declarations: 'declarations/declapract.declare.yml'
+useCase: lambda-service

package/dist/.test/assets/tool-swap-removals/repo-after-swaps/jest.unit.config.ts

@@ -0,0 +1,8 @@
+/**
+ * @jest-config-loader esbuild-register
+ */
+import type { Config } from 'jest';
+
+const config: Config = { testMatch: ['**/*.test.ts'] };
+
+export default config;

package/dist/.test/assets/tool-swap-removals/repo-after-swaps/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "test-project",
+  "version": "1.0.0",
+  "devDependencies": {
+    "@swc/jest": "0.2.39",
+    "@tsconfig/node-lts-strictest": "18.12.1",
+    "@tsconfig/node20": "20.1.5",
+    "@tsconfig/strictest": "2.0.5",
+    "core-js": "3.26.1",
+    "esbuild-register": "3.6.0",
+    "jest": "30.2.0",
+    "ts-jest": "29.1.3",
+    "ts-node": "10.9.2"
+  }
+}

package/dist/.test/assets/tool-swap-removals/repo-after-swaps/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": ["@tsconfig/strictest/tsconfig.json", "@tsconfig/node20/tsconfig.json"],
+  "compilerOptions": {
+    "lib": ["DOM"], // the browser types this repo needs
+    "outDir": "dist"
+  }
+}

package/dist/.test/assets/tool-swap-removals/repo-mid-swaps/declapract.use.yml

@@ -0,0 +1,2 @@
+declarations: 'declarations/declapract.declare.yml'
+useCase: lambda-service

package/dist/.test/assets/tool-swap-removals/repo-mid-swaps/jest.unit.config.ts

@@ -0,0 +1,5 @@
+import type { Config } from 'jest';
+
+const config: Config = { testMatch: ['**/*.test.ts'] };
+
+export default config;

package/dist/.test/assets/tool-swap-removals/repo-mid-swaps/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "test-project",
+  "version": "1.0.0",
+  "devDependencies": {
+    "@tsconfig/node-lts-strictest": "18.12.1",
+    "esbuild-register": "3.6.0",
+    "jest": "30.2.0",
+    "ts-node": "10.9.2"
+  }
+}

package/dist/.test/assets/tool-swap-removals/repo-mid-swaps/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "@tsconfig/node-lts-strictest/tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist"
+  }
+}

package/dist/.test/assets/typecheck-templates/declarations/declapract.declare.yml

@@ -0,0 +1,9 @@
+# declarations for the best-practice template type-check clamp
+# .why  = the test clones this dir into its OWN temp dir and symlinks `practices` -> src/practices and
+#         `useCases.yml` -> src/useCases.yml there, so the REAL practices and REAL usecases are
+#         applied — never a curated copy. this dir sits OUTSIDE the applied repo: a whole-usecase
+#         apply walks every path of the repo it applies to, and a link from that repo into src/ would
+#         let a `**` fix write through it into this repo's own source.
+declare:
+  practices: practices
+  use-cases: useCases.yml

package/dist/.test/assets/typecheck-templates/repo-bare/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "typecheck-demo",
+  "version": "0.0.0",
+  "private": true,
+  "dependencies": {},
+  "devDependencies": {}
+}