javascript codemod package

Author: danieldelcore

community/javascript/codeshift.config.js

@@ -0,0 +1,14 @@
+module.exports = {
+  maintainers: [],
+  targets: [],
+  description: 'Codemods for javascript',
+  transforms: {},
+  presets: {
+    'import-from-root': require.resolve('./import-from-root/transform'),
+    'remove-debugger': require.resolve('./remove-debugger/transform'),
+    'sort-object-props': require.resolve('./sort-object-props/transform'),
+    'use-named-exports': require.resolve('./use-named-exports/transform'),
+    'use-named-imports': require.resolve('./use-named-imports/transform'),
+    'var-to-let': require.resolve('./var-to-let/transform'),
+  },
+};

community/javascript/import-from-root/README.md

@@ -0,0 +1,15 @@
+# import-from-root
+
+Rewrite deep imports to import from a packages' root index.
+
+> Set the Environment Variable `IMPORT_FROM_ROOT` to apply this transform only
+> to packages whose name starts with that string:
+> `IMPORT_FROM_ROOT=some-package yarn import-from-root <path-to-file>`
+
+```js
+/* INPUT */
+import { foo } from "some-package/foo/bar/baz";
+
+/* OUTPUT */
+import { foo } from "some-package";
+```

community/javascript/import-from-root/transform.spec.ts

@@ -0,0 +1,17 @@
+import { applyTransform } from '@codeshift/test-utils';
+import * as transformer from './transform';
+
+describe('react@1.0.0 transform', () => {
+  it('should transform correctly', () => {
+    const result = applyTransform(
+      transformer,
+      `
+        import foo from '<% packageName %>';
+        console.log(foo);
+      `,
+      { parser: 'tsx' },
+    );
+
+    expect(result).toMatchInlineSnapshot();
+  });
+});

community/javascript/import-from-root/transform.ts

@@ -0,0 +1,32 @@
+import { API, FileInfo, Options } from 'jscodeshift';
+
+export default function transformer(
+  file: FileInfo,
+  { jscodeshift: j }: API,
+  options: Options,
+) {
+  const source = j(file.source);
+
+  const { IMPORT_FROM_ROOT = '' } = process.env;
+
+  const matchesUserFilter = importDeclaration =>
+    IMPORT_FROM_ROOT &&
+    importDeclaration.source.value.startsWith(IMPORT_FROM_ROOT);
+
+  source
+    .find(j.ImportDeclaration)
+    .filter(path => matchesUserFilter(path.value))
+    .forEach(path => {
+      const importDeclaration = path.value;
+      const paths = importDeclaration.source.value.split('/');
+      if (importDeclaration.source.value.startsWith('@')) {
+        const [scope, packageName] = paths;
+        importDeclaration.source.value = `${scope}/${packageName}`;
+      } else {
+        const [packageName] = paths;
+        importDeclaration.source.value = `${packageName}`;
+      }
+    });
+
+  return source.toSource(options.printOptions);
+}

community/javascript/remove-debugger/README.md

@@ -0,0 +1,12 @@
+# remove-debugger
+
+Removes all `debugger` statements.
+
+```js
+/* INPUT */
+console.log('hello world');
+debugger;
+
+/* OUTPUT */
+console.log('hello world');
+```

community/javascript/remove-debugger/transform.spec.ts

@@ -0,0 +1,33 @@
+import { applyTransform } from '@codeshift/test-utils';
+import * as transformer from './transform';
+
+describe('react@1.0.0 transform', () => {
+  it('should not modify files with no debugger statements', () => {
+    const result = applyTransform(transformer, `console.log('foooo');`, {
+      parser: 'tsx',
+    });
+
+    expect(result).toMatchInlineSnapshot();
+  });
+
+  it('should remove top-level debugger statement', () => {
+    const result = applyTransform(transformer, 'debugger;', { parser: 'tsx' });
+
+    expect(result).toMatchInlineSnapshot();
+  });
+
+  it('should debuggers in function statements', () => {
+    const result = applyTransform(
+      transformer,
+      `
+      function foo () {
+        debugger;
+        setTimeout(() => { debugger; console.log('foo') });debugger;
+      }
+    `,
+      { parser: 'tsx' },
+    );
+
+    expect(result).toMatchInlineSnapshot();
+  });
+});

community/javascript/remove-debugger/transform.ts

@@ -0,0 +1,18 @@
+import { API, FileInfo, Options } from 'jscodeshift';
+
+export default function transformer(
+  file: FileInfo,
+  { jscodeshift: j }: API,
+  options: Options,
+) {
+  const source = j(file.source);
+  const debuggerStatements = source.find(j.DebuggerStatement);
+
+  if (debuggerStatements.length === 0) {
+    return file.source;
+  }
+
+  debuggerStatements.remove();
+
+  return source.toSource(options.printOptions);
+}

community/javascript/sort-object-props/README.md

@@ -0,0 +1,11 @@
+# sort-object-props
+
+Sort members of Object Literals alphabetically.
+
+```js
+/* INPUT */
+const players = { messi: true, bergkamp: true, ginola: true };
+
+/* OUTPUT */
+const players = { bergkamp: true, ginola: true, messi: true };
+```

community/javascript/sort-object-props/transform.spec.ts

@@ -0,0 +1,17 @@
+import { applyTransform } from '@codeshift/test-utils';
+import * as transformer from './transform';
+
+describe('react@1.0.0 transform', () => {
+  it('should transform correctly', () => {
+    const result = applyTransform(
+      transformer,
+      `
+        import foo from '<% packageName %>';
+        console.log(foo);
+      `,
+      { parser: 'tsx' },
+    );
+
+    expect(result).toMatchInlineSnapshot();
+  });
+});

community/javascript/sort-object-props/transform.ts

@@ -0,0 +1,51 @@
+import { API, FileInfo, Options } from 'jscodeshift';
+
+export default function transformer(
+  file: FileInfo,
+  { jscodeshift: j }: API,
+  options: Options,
+) {
+  const isSpreadElement = prop => prop && prop.type === 'SpreadElement';
+  const isValue = prop => prop && prop.type !== 'SpreadElement';
+  const getPropName = prop =>
+    (prop.key && (prop.key.name || prop.key.value)) || '';
+  const sortByPropName = (a, b) => {
+    if (a < b) return -1;
+    if (a > b) return 1;
+    return 0;
+  };
+  const sortProps = props => {
+    props.sort((a, b) => sortByPropName(getPropName(a), getPropName(b)));
+  };
+
+  return j(file.source)
+    .find(api.jscodeshift.ObjectExpression)
+    .forEach(path => {
+      const chunks = [];
+      const nextProperties = [];
+      const objectExpression = path.value;
+
+      objectExpression.properties.forEach((prop, i, props) => {
+        if (isValue(prop)) {
+          const prev = props[i - 1];
+          const next = props[i + 1];
+          const isChunkStart = !isValue(prev);
+          const isChunkEnd = !isValue(next);
+
+          isChunkStart && chunks.push([]);
+          const [chunk] = chunks.slice(-1);
+          chunk.push(prop);
+
+          if (isChunkEnd) {
+            sortProps(chunk);
+            nextProperties.push(...chunk);
+          }
+        } else if (isSpreadElement(prop)) {
+          nextProperties.push(prop);
+        }
+      });
+
+      objectExpression.properties = nextProperties;
+    })
+    .toSource(options.printOptions);
+}