@pob/codemods 0.0.0

package/.editorconfig

@@ -0,0 +1,13 @@
+# EditorConfig helps developers define and maintain consistent
+# coding styles between different editors and IDEs
+# http://editorconfig.org
+
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

package/.eslintrc.json

@@ -0,0 +1,5 @@
+{
+  "root": true,
+  "extends": ["@pob/eslint-config/root-module"],
+  "ignorePatterns": ["/build"]
+}

package/.yo-rc.json

@@ -0,0 +1,11 @@
+{
+  "pob": {
+    "app": {
+      "type": "node",
+      "testing": false
+    },
+    "project": {
+      "type": "app"
+    }
+  }
+}

package/LICENSE

@@ -0,0 +1,2 @@
+Copyright (c) 2023 Christophe Hurpeau <302891+christophehurpeau@users.noreply.github.com> (https://christophe.hurpeau.com)
+All rights reserved.

package/bin/migrate.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+import { readdirSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { glob } from 'glob';
+import runJscodeshift from '../lib/runJscodeshift.cjs';
+
+const argv = process.argv.slice(2);
+
+const transformerName = argv[0];
+const globPaths = argv[1];
+
+if (!transformerName || !globPaths) {
+  const transformerList = readdirSync(
+    new URL('../lib/transforms/', import.meta.url),
+  );
+  throw new Error(
+    `Usage: pob-migrate <transformer-name> <glob-paths>\n${transformerList
+      .map((t) => `- "${t.slice(0, -4)}"`)
+      .join('\n')}`,
+  );
+}
+
+const transformPath = fileURLToPath(
+  new URL(`../lib/transforms/${transformerName}.cjs`, import.meta.url),
+);
+const paths = glob.sync(globPaths);
+
+if (paths.length === 0) {
+  throw new Error(`No files found matching ${globPaths}`);
+}
+
+const res = await runJscodeshift(transformPath, paths, {});
+if (res.errors) {
+  process.exitCode = 1;
+}
+console.log('Done!');

package/lib/.eslintrc.json

@@ -0,0 +1,27 @@
+{
+  "root": true,
+  "extends": ["@pob/eslint-config/node-module"],
+  "settings": {
+    "import/resolver": {
+      "node": {
+        "moduleDirectory": ["node_modules", "src"]
+      }
+    }
+  },
+  "overrides": [
+    {
+      "files": ["**/*.test.{cjs,js}", "__tests__/**/*.{cjs,js}"],
+      "env": {
+        "jest": true
+      },
+      "rules": {
+        "import/no-extraneous-dependencies": [
+          "error",
+          {
+            "devDependencies": true
+          }
+        ]
+      }
+    }
+  ]
+}

package/lib/runJscodeshift.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+const { run: jscodeshift } = require('jscodeshift/src/Runner');
+
+module.exports = (...args) => {
+  return jscodeshift(...args);
+};

package/lib/transforms/jest-to-node-runner.cjs

@@ -0,0 +1,145 @@
+/* eslint-disable unicorn/prefer-array-some */
+/* eslint-disable unicorn/no-array-method-this-argument */
+
+'use strict';
+
+const { prependImport } = require('../utils/prependImport.cjs');
+
+const jestToNodeGlobalMethods = {
+  test: 'test',
+  describe: 'describe',
+  it: 'it',
+  beforeAll: 'before',
+  afterAll: 'after',
+  beforeEach: 'beforeEach',
+  afterEach: 'afterEach',
+};
+const propertiesMap = {
+  toBe: { default: 'equal', not: 'notEqual' },
+  toStrictEqual: { default: 'equal', not: 'notEqual' },
+  toEqual: { default: 'equal', not: 'notEqual' },
+};
+
+// const mocks = {
+//   toHaveBeenCalledTimes: {
+//     default: 'mock.calls.length',
+//   },
+// };
+
+module.exports = (file, api, options) => {
+  if (
+    !(
+      file.path.endsWith('.test.js') ||
+      file.path.endsWith('.test.ts') ||
+      file.path.endsWith('.test.tsx')
+    )
+  ) {
+    throw new Error(`Invalid file: "${file.path}"`);
+  }
+
+  const j = api.jscodeshift.withParser('tsx');
+  const root = j(file.source);
+
+  function updateTopLevelMethods() {
+    const topLevelMethodsUsed = new Set();
+
+    root
+      .find(j.CallExpression, {
+        callee: {
+          type: j.Identifier.name,
+          name: (name) => Object.keys(jestToNodeGlobalMethods).includes(name),
+        },
+      })
+      .replaceWith((p) => {
+        const { value } = p;
+        topLevelMethodsUsed.add(value.callee.name);
+
+        return j.callExpression(
+          j.identifier(jestToNodeGlobalMethods[value.callee.name]),
+          value.arguments,
+        );
+      });
+
+    if (topLevelMethodsUsed.size > 0) {
+      prependImport(
+        j,
+        root,
+        j.importDeclaration(
+          [...topLevelMethodsUsed].map((method) =>
+            j.importSpecifier(j.identifier(method)),
+          ),
+          j.stringLiteral('node:test'),
+        ),
+      );
+    }
+  }
+
+  function updateAssertions() {
+    let hasAssertions = false;
+
+    root
+      .find(j.MemberExpression, {
+        object: {
+          callee: { name: 'expect' },
+        },
+      })
+      .forEach((memberExpressionPath) => {
+        const { value: memberExpression, parentPath } = memberExpressionPath;
+        let memberExpressionPathToReplace = memberExpressionPath;
+        let propertyName = memberExpression.property.name;
+        let not = false;
+        if (propertyName === 'not') {
+          not = true;
+          memberExpressionPathToReplace = parentPath;
+          propertyName = parentPath.value.property.name;
+        }
+
+        if (!propertiesMap[propertyName]) {
+          console.warn(`Unsupported expect property: ${propertyName}`);
+          return;
+        }
+
+        const assertPropertyName =
+          propertiesMap[propertyName][not ? 'not' : 'default'];
+        const callExpressionPath = memberExpressionPathToReplace.parentPath;
+
+        const argument0 = callExpressionPath.value.arguments[0];
+        const argument1 = memberExpression.object.arguments[0];
+
+        hasAssertions = true;
+        callExpressionPath.value.callee = j.memberExpression(
+          j.identifier('assert'),
+          j.identifier(assertPropertyName),
+        );
+        callExpressionPath.value.arguments = [argument0, argument1];
+      });
+
+    if (hasAssertions) {
+      root
+        .find(j.ImportDeclaration, { source: { value: 'node:assert' } })
+        .remove();
+      if (
+        (!root.find(j.ImportDeclaration),
+        { source: { value: 'node:assert/strict' } })
+      ) {
+        prependImport(
+          j,
+          root,
+          j.importDeclaration(
+            [j.importDefaultSpecifier(j.identifier('assert'))],
+            j.stringLiteral('node:assert/strict'),
+          ),
+        );
+      }
+    }
+  }
+
+  updateTopLevelMethods();
+  updateAssertions();
+
+  root
+    .find(j.ImportDeclaration, { source: { value: '@jest/globals' } })
+    .remove();
+
+  return root.toSource(options);
+};

package/lib/transforms/update-function-component-return-type.cjs

@@ -0,0 +1,89 @@
+'use strict';
+
+/* eslint-disable complexity */
+module.exports = (file, api, options) => {
+  const j = api.jscodeshift.withParser('tsx');
+  const root = j(file.source);
+  let hasModifications = false;
+
+  function processFunctionComponent(path) {
+    const node = path.value;
+    const { returnType } = node;
+    if (returnType == null) return;
+    if (returnType.type !== 'TSTypeAnnotation') return;
+    const { typeAnnotation } = returnType;
+    if (typeAnnotation == null) return;
+
+    if (
+      typeAnnotation.type === 'TSTypeReference' &&
+      typeAnnotation.typeName &&
+      typeAnnotation.typeName.type === 'Identifier'
+    ) {
+      if (typeAnnotation.typeName.name === 'ReactElement') {
+        typeAnnotation.typeName.name = 'ReactNode';
+        hasModifications = true;
+      }
+    } else if (
+      typeAnnotation.type === 'TSUnionType' &&
+      typeAnnotation.types.every((unionTypeItem) => {
+        if (unionTypeItem.type === 'TSTypeReference') {
+          return (
+            unionTypeItem.typeName &&
+            unionTypeItem.typeName.type === 'Identifier' &&
+            unionTypeItem.typeName.name === 'ReactElement'
+          );
+        }
+
+        if (unionTypeItem.type === 'TSNullKeyword') {
+          return true;
+        }
+
+        return false;
+      })
+    ) {
+      returnType.typeAnnotation = j.tsTypeReference(j.identifier('ReactNode'));
+      hasModifications = true;
+    }
+  }
+
+  root.find(j.FunctionDeclaration).forEach(processFunctionComponent);
+
+  if (hasModifications) {
+    root.find(j.ImportDeclaration).forEach((importDeclaration) => {
+      const { node } = importDeclaration;
+      if (node.source.value !== 'react') return;
+      if (node.importKind !== 'type') return;
+
+      node.specifiers = node.specifiers.filter((importSpecifier) => {
+        if (importSpecifier.local.name !== 'ReactElement') return true;
+        if (importSpecifier.importKind !== 'value') return true;
+        return (
+          j(importDeclaration)
+            .closestScope()
+            // eslint-disable-next-line unicorn/no-array-method-this-argument -- not an array
+            .find(j.Identifier, { name: 'ReactElement' })
+            .filter((p) => {
+              if (p.value.start === importSpecifier.local.start) return false;
+              if (p.parentPath.value.type === 'Property' && p.name === 'key') {
+                return false;
+              }
+              if (p.name === 'property') return false;
+              return true;
+            })
+            .size() > 0
+        );
+      });
+      if (
+        !node.specifiers.some(
+          (specifier) =>
+            specifier.type === 'ImportSpecifier' &&
+            specifier.imported.name === 'ReactNode',
+        )
+      ) {
+        node.specifiers.push(j.importSpecifier(j.identifier('ReactNode')));
+      }
+    });
+  }
+
+  return hasModifications ? root.toSource(options) : null;
+};

package/lib/utils/prependImport.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+exports.prependImport = (j, source, importDeclaration) => {
+  const existingImports = source.find(j.ImportDeclaration);
+  if (existingImports.length > 0) {
+    const firstImport = existingImports.at(0);
+    const firstImportNode = firstImport.nodes()[0];
+    if (firstImportNode?.comments) {
+      importDeclaration.comments = firstImportNode.comments;
+      firstImportNode.comments = null;
+    }
+
+    firstImport.insertBefore(importDeclaration);
+    return;
+  }
+
+  const firstNode = source.find(j.Program).get('body', 0).node;
+  const { comments } = firstNode;
+  if (comments?.length) {
+    const comment = comments[0];
+
+    // Only move comments that look like file-level comments. Ignore
+    // line-level and JSDoc-style comments because these probably belong
+    // to the first node, rather than the file.
+    if (
+      (comment.type === 'Block' || comment.type === 'CommentBlock') &&
+      !comment.value.startsWith('*')
+    ) {
+      importDeclaration.comments = comments;
+      firstNode.comments = null;
+    }
+  }
+
+  source.get('program', 'body').unshift(importDeclaration);
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@pob/codemods",
+  "version": "0.0.0",
+  "description": "codemods for pob",
+  "keywords": [],
+  "author": "Christophe Hurpeau <302891+christophehurpeau@users.noreply.github.com> (https://christophe.hurpeau.com)",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/christophehurpeau/pob.git",
+    "directory": "@pob/codemods"
+  },
+  "homepage": "https://github.com/christophehurpeau/pob",
+  "type": "module",
+  "engines": {
+    "node": ">=20.9.0"
+  },
+  "bin": {
+    "pob-migrate": "./bin/migrate.mjs"
+  },
+  "main": "./lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "install-bin": "ln -s $PWD/bin/migrate.mjs /usr/local/bin/pob-migrate",
+    "lint": "yarn run lint:eslint",
+    "lint:eslint": "yarn ../.. run eslint --report-unused-disable-directives --resolve-plugins-relative-to . --quiet @pob/codemods"
+  },
+  "pob": {},
+  "prettier": "@pob/root/prettier-config",
+  "dependencies": {
+    "glob": "10.3.10",
+    "jscodeshift": "0.15.1"
+  },
+  "devDependencies": {
+    "@types/jscodeshift": "0.11.11"
+  }
+}