ts-codemod-lib 1.0.1

package/package.json

@@ -0,0 +1,134 @@
+{
+  "name": "ts-codemod-lib",
+  "version": "1.0.1",
+  "private": false,
+  "keywords": [
+    "typescript",
+    "codemod",
+    "ast",
+    "transformation"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/noshiro-pf/ts-codemod-lib.git"
+  },
+  "license": "Apache-2.0",
+  "author": "noshiro-pf <noshiro.pf@gmail.com>",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/types.d.mts",
+        "default": "./dist/entry-point.mjs"
+      }
+    }
+  },
+  "module": "./dist/entry-point.mjs",
+  "types": "./dist/types.d.mts",
+  "bin": {
+    "convert-interface-to-type": "./dist/cmd/convert-interface-to-type.mjs",
+    "convert-to-readonly": "./dist/cmd/convert-to-readonly.mjs",
+    "replace-record-with-unknown-record": "./dist/cmd/replace-record-with-unknown-record.mjs"
+  },
+  "files": [
+    "src",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "cmd-ts": "0.14.3",
+    "dedent": "1.7.1",
+    "ts-morph": "27.0.2",
+    "ts-repo-utils": "8.0.2"
+  },
+  "devDependencies": {
+    "@rollup/plugin-replace": "6.0.3",
+    "@rollup/plugin-strip": "3.0.4",
+    "@rollup/plugin-typescript": "12.3.0",
+    "@semantic-release/changelog": "6.0.3",
+    "@semantic-release/commit-analyzer": "13.0.1",
+    "@semantic-release/exec": "7.1.0",
+    "@semantic-release/git": "10.0.1",
+    "@semantic-release/github": "12.0.2",
+    "@semantic-release/npm": "13.1.3",
+    "@semantic-release/release-notes-generator": "14.1.0",
+    "@types/node": "25.0.6",
+    "@vitest/browser-playwright": "4.0.16",
+    "@vitest/coverage-v8": "4.0.16",
+    "@vitest/ui": "4.0.16",
+    "conventional-changelog-conventionalcommits": "9.1.0",
+    "cspell": "9.4.0",
+    "eslint": "9.39.2",
+    "eslint-config-typed": "4.4.1",
+    "github-settings-as-code": "1.0.7",
+    "jiti": "2.6.1",
+    "markdownlint": "0.40.0",
+    "markdownlint-cli2": "0.20.0",
+    "npm-run-all2": "8.0.4",
+    "playwright": "1.57.0",
+    "prettier": "3.7.4",
+    "prettier-plugin-organize-imports": "4.3.0",
+    "prettier-plugin-packagejson": "2.5.20",
+    "rollup": "4.54.0",
+    "semantic-release": "25.0.2",
+    "ts-data-forge": "6.2.1",
+    "ts-type-forge": "2.3.0",
+    "tslib": "2.8.1",
+    "tsx": "4.21.0",
+    "typedoc": "0.28.15",
+    "typedoc-github-theme": "0.3.1",
+    "typescript": "5.9.3",
+    "vite": "7.3.0",
+    "vitest": "4.0.16"
+  },
+  "engines": {
+    "node": ">=22",
+    "pnpm": ">=8.0.0"
+  },
+  "volta": {
+    "node": "25.2.1"
+  },
+  "scripts": {
+    "build": "tsx ./scripts/cmd/build.mts",
+    "build:min": "tsx ./scripts/cmd/build.mts --skip-check",
+    "check-all": "tsx ./scripts/cmd/check-all.mts",
+    "check:ext": "tsx ./scripts/cmd/check-ext.mts",
+    "clean": "pnpm run /clean:.*/",
+    "clean:logs": "npx rimraf ./*.log",
+    "cspell": "cspell \"**\" --gitignore --gitignore-root ./ --no-progress",
+    "doc": "tsx ./scripts/cmd/gen-docs.mts",
+    "doc:embed": "tsx ./scripts/cmd/embed-samples.mts",
+    "doc:preview": "vite preview --config ./configs/vite.doc.config.mts",
+    "doc:watch": "typedoc --options ./configs/typedoc.config.mjs --watch",
+    "fmt": "format-uncommitted",
+    "fmt:diff": "format-diff-from origin/main",
+    "fmt:full": "prettier --write .",
+    "gh:apply-all": "gh-apply-all",
+    "gh:apply-repository-settings": "gh-apply-repository-settings",
+    "gh:apply-rulesets": "gh-apply-rulesets",
+    "gh:apply-variables": "gh-apply-variables",
+    "gh:backup-all": "gh-backup-all",
+    "gh:backup-repository-settings": "gh-backup-repository-settings",
+    "gh:backup-rulesets": "gh-backup-rulesets",
+    "gi": "run-s gi:src fmt",
+    "gi:src": "gen-index-ts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --exclude entry-point.mts --exclude cmd",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "md": "markdownlint-cli2",
+    "run:cmd": "tsx ./src/cmd/convert-to-readonly.mts ./test/convert-to-readonly.mts",
+    "test": "pnpm run z:vitest:node run",
+    "test:browser": "pnpm run z:vitest --project='Browser' run",
+    "test:cov": "pnpm run z:vitest:node run --coverage",
+    "test:cov:ui": "vite preview --outDir ./coverage",
+    "test:ui": "pnpm run z:vitest:node --ui",
+    "testw": "pnpm run z:vitest:node watch",
+    "tsc": "tsc --noEmit",
+    "tscw": "tsc --noEmit --watch -p ./tsconfig.json",
+    "type-check": "tsc --noEmit",
+    "update-packages": "pnpm update --latest",
+    "z:vitest": "vitest --config ./configs/vitest.config.mts",
+    "z:vitest:node": "vitest --config ./configs/vitest.config.mts --project='Node.js'"
+  }
+}

package/src/cmd/convert-to-readonly.mts

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+/* eslint-disable no-await-in-loop */
+
+import * as cmd from 'cmd-ts';
+import dedent from 'dedent';
+import { castMutable, Result, unknownToString } from 'ts-data-forge';
+import 'ts-repo-utils';
+import {
+  convertToReadonlyTypeTransformer,
+  transformSourceCode,
+} from '../functions/index.mjs';
+
+const cmdDef = cmd.command({
+  name: 'convert-to-readonly-cli',
+  version: '1.0.0',
+  args: {
+    baseDir: cmd.positional({
+      type: cmd.string,
+      displayName: 'baseDir',
+      description: 'The base directory in which to perform the conversion',
+    }),
+    exclude: cmd.multioption({
+      long: 'exclude',
+      type: cmd.optional(cmd.array(cmd.string)),
+      description:
+        'Glob patterns of files to exclude from the base directory (e.g., "src/generated/**/*.mts")',
+    }),
+    silent: cmd.flag({
+      long: 'silent',
+      type: cmd.optional(cmd.boolean),
+      description: 'If true, suppresses output messages (default: false)',
+    }),
+  },
+  handler: (args) => {
+    convertToReadonlyCLI({
+      baseDir: args.baseDir,
+      exclude: args.exclude ?? [],
+      silent: args.silent ?? false,
+    }).catch((error: unknown) => {
+      console.error('An error occurred:', error);
+
+      process.exit(1);
+    });
+  },
+});
+
+type Args = Readonly<{
+  baseDir: string;
+  exclude: readonly string[];
+  silent: boolean;
+}>;
+
+const convertToReadonlyCLI = async (
+  args: Args,
+): Promise<Result<undefined, undefined>> => {
+  const echoIfNotSilent = args.silent ? () => {} : echo;
+
+  const errorIfNotSilent = args.silent ? () => {} : console.error;
+
+  // Find all files matching the glob
+  const globResult = await glob(args.baseDir, {
+    ignore: castMutable(args.exclude),
+  });
+
+  if (Result.isErr(globResult)) {
+    errorIfNotSilent('Error finding files matching pattern:', globResult.value);
+
+    return Result.err(undefined);
+  }
+
+  const files = globResult.value;
+
+  if (files.length === 0) {
+    echoIfNotSilent('No files found matching pattern:', args.baseDir);
+
+    return Result.ok(undefined);
+  }
+
+  const { errorFiles, transformedCount, unchangedCount } = await transformFiles(
+    files,
+    args.silent,
+  );
+
+  const hr = '='.repeat(50);
+
+  echoIfNotSilent(dedent`
+    ${hr}
+    Summary:
+      ✅ Transformed: ${transformedCount}
+      ⏭️ Unchanged:   ${unchangedCount}
+      ❌ Errors:      ${errorFiles.length}
+      📊 Total:       ${files.length}
+  `);
+
+  if (errorFiles.length > 0) {
+    echoIfNotSilent('\nFiles with errors:');
+
+    for (const fileName of errorFiles) {
+      echoIfNotSilent(`  - ${fileName}`);
+    }
+  }
+
+  echoIfNotSilent(hr);
+
+  if (errorFiles.length > 0) {
+    return Result.err(undefined);
+  }
+
+  return Result.ok(undefined);
+};
+
+const transformFiles = async (
+  filePaths: readonly string[],
+  silent: boolean,
+): Promise<
+  Readonly<{
+    transformedCount: number;
+    unchangedCount: number;
+    errorFiles: readonly string[];
+  }>
+> => {
+  let mut_transformedCount: number = 0;
+
+  let mut_unchangedCount: number = 0;
+
+  const mut_errorFiles: string[] = [];
+
+  for (const filePath of filePaths) {
+    const result = await transformOneFile(filePath, silent);
+
+    if (Result.isOk(result)) {
+      switch (result.value) {
+        case 'transformed':
+          mut_transformedCount += 1;
+
+          break;
+
+        case 'unchanged':
+          mut_unchangedCount += 1;
+
+          break;
+      }
+    } else {
+      mut_errorFiles.push(path.basename(filePath));
+    }
+  }
+
+  return {
+    transformedCount: mut_transformedCount,
+    unchangedCount: mut_unchangedCount,
+    errorFiles: mut_errorFiles,
+  };
+};
+
+const transformOneFile = async (
+  filePath: string,
+  silent: boolean,
+): Promise<Result<'unchanged' | 'transformed', string>> => {
+  const echoIfNotSilent = silent ? () => {} : echo;
+
+  const errorIfNotSilent = silent ? () => {} : console.error;
+
+  const fileName = path.basename(filePath);
+
+  try {
+    const originalCode = await fs.readFile(filePath, 'utf8');
+
+    // Transform the code with all transformers
+    const transformedCode = transformSourceCode(originalCode, false, [
+      convertToReadonlyTypeTransformer(),
+    ]);
+
+    // Check if the code was actually changed
+    if (transformedCode === originalCode) {
+      echoIfNotSilent(`⏭️ ${fileName} - no changes needed`);
+
+      return Result.ok('unchanged');
+    } else {
+      // Write back the transformed code
+      await fs.writeFile(filePath, transformedCode, 'utf8');
+
+      echoIfNotSilent(`✅ ${fileName} - transformed`);
+
+      return Result.ok('transformed');
+    }
+  } catch (error) {
+    const errStr = unknownToString(error);
+
+    errorIfNotSilent(`❌ ${fileName} - error: ${errStr}`);
+
+    return Result.err(errStr);
+  }
+};
+
+await cmd.run(cmdDef, process.argv.slice(2));

package/src/entry-point.mts

@@ -0,0 +1 @@
+export * from './index.mjs';

package/src/functions/ast-transformers/convert-interface-to-type.mts

@@ -0,0 +1,119 @@
+/* eslint-disable unicorn/consistent-function-scoping -- helper functions are kept inside for clarity */
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types -- ts-morph uses mutable types */
+import { Arr } from 'ts-data-forge';
+import type * as tsm from 'ts-morph';
+import { type TsMorphTransformer } from './types.mjs';
+
+/**
+ * interface による型定義を type による型定義に変換する。
+ * @typescript-eslint/consistent-type-definitions: ["error", "type"] と同等の動作
+ */
+export const convertInterfaceToTypeTransformer =
+  (): TsMorphTransformer => (sourceAst) => {
+    const processInterfaces = (
+      container: tsm.SourceFile | tsm.ModuleDeclaration,
+    ): void => {
+      const interfaces = container.getInterfaces();
+
+      for (const interfaceDecl of interfaces) {
+        convertInterfaceToType(interfaceDecl);
+      }
+    };
+
+    const convertInterfaceToType = (
+      interfaceDecl: tsm.InterfaceDeclaration,
+    ): void => {
+      const interfaceName = interfaceDecl.getName();
+
+      const typeParameters = interfaceDecl.getTypeParameters();
+
+      const extendsExpressions = interfaceDecl.getExtends();
+
+      const members = interfaceDecl.getMembers();
+
+      // Build type parameters string
+      const typeParamsStr =
+        typeParameters.length > 0
+          ? `<${typeParameters.map((tp) => tp.getText()).join(', ')}>`
+          : '';
+
+      // Build type literal from members
+      const mut_typeBody: string = (() => {
+        if (extendsExpressions.length === 0) {
+          // No extends: simple type literal
+          return buildTypeLiteral(members);
+        }
+
+        if (members.length === 0) {
+          // Only extends, no own members: union of extended types
+          const extendedTypes = extendsExpressions.map((ext) => ext.getText());
+
+          return Arr.isArrayOfLength(extendedTypes, 1)
+            ? extendedTypes[0]
+            : extendedTypes.join(' & ');
+        }
+
+        // Both extends and own members: intersection
+        const extendedTypesWithMembers = extendsExpressions.map((ext) =>
+          ext.getText(),
+        );
+
+        const ownType = buildTypeLiteral(members);
+
+        return [...extendedTypesWithMembers, ownType].join(' & ');
+      })();
+
+      // Get export keyword
+      const isExported = interfaceDecl.isExported();
+
+      const exportKeyword = isExported ? 'export ' : '';
+
+      // Get leading comments (including JSDoc)
+      const leadingComments = interfaceDecl.getLeadingCommentRanges();
+
+      const commentTexts = leadingComments
+        .map((range) => range.getText())
+        .join('\n');
+
+      const jsDocText = commentTexts.length > 0 ? `${commentTexts}\n` : '';
+
+      // Replace interface with type alias
+      const typeAliasText = `${jsDocText}${exportKeyword}type ${interfaceName}${typeParamsStr} = ${mut_typeBody};`;
+
+      interfaceDecl.replaceWithText(typeAliasText);
+    };
+
+    const buildTypeLiteral = (
+      members: readonly tsm.TypeElementTypes[],
+    ): string => {
+      if (members.length === 0) {
+        return 'Record<string, never>';
+      }
+
+      const memberTexts = members.map((member) => {
+        // Preserve comments
+        const leadingComments = member
+          .getLeadingCommentRanges()
+          .map((range) => range.getText())
+          .join('\n');
+
+        const memberText = member.getText();
+
+        return leadingComments.length > 0
+          ? `${leadingComments}\n${memberText}`
+          : memberText;
+      });
+
+      return `{\n  ${memberTexts.join('\n  ')}\n}`;
+    };
+
+    // Process top-level interface declarations
+    processInterfaces(sourceAst);
+
+    // Process interfaces inside namespaces/modules
+    const namespaces = sourceAst.getModules();
+
+    for (const namespace of namespaces) {
+      processInterfaces(namespace);
+    }
+  };