@atlaskit/code 15.1.2 → 15.2.1

package/codemods/13.0.0-rename-imports.tsx

@@ -1,285 +1,248 @@
 import {
-  API,
-  ASTPath,
-  FileInfo,
-  Identifier,
-  ImportSpecifier,
-  JSCodeshift,
-  Options,
+	type API,
+	type ASTPath,
+	type FileInfo,
+	type Identifier,
+	type ImportSpecifier,
+	type JSCodeshift,
+	type Options,
 } from 'jscodeshift';
-import { Collection } from 'jscodeshift/src/Collection';
+import { type Collection } from 'jscodeshift/src/Collection';
 
 import {
-  getDynamicImportCollection,
-  getImportDeclarationCollection,
-  getImportSpecifierCollection,
-  getImportSpecifierName,
-  hasDynamicImport,
-  hasImportDeclaration,
-  isClassDeclarationIdentifierPresent,
-  isFunctionDeclarationIdentifierPresent,
-  isImportDeclarationIdentifierPresent,
-  isVariableDeclaratorIdentifierPresent,
+	getDynamicImportCollection,
+	getImportDeclarationCollection,
+	getImportSpecifierCollection,
+	getImportSpecifierName,
+	hasDynamicImport,
+	hasImportDeclaration,
+	isClassDeclarationIdentifierPresent,
+	isFunctionDeclarationIdentifierPresent,
+	isImportDeclarationIdentifierPresent,
+	isVariableDeclaratorIdentifierPresent,
 } from './utils/helpers';
 
 const importPath = '@atlaskit/code';
 const importsMapping = {
-  oldImports: {
-    Code: 'AkCode',
-    CodeBlock: 'AkCodeBlock',
-  },
-  newImports: {
-    Code: 'Code',
-    CodeBlock: 'CodeBlock',
-  },
+	oldImports: {
+		Code: 'AkCode',
+		CodeBlock: 'AkCodeBlock',
+	},
+	newImports: {
+		Code: 'Code',
+		CodeBlock: 'CodeBlock',
+	},
 };
 
 function renameNamedImports(
-  j: JSCodeshift,
-  collection: Collection<any>,
-  {
-    fromImportName,
-    toImportName,
-  }: {
-    fromImportName: string;
-    toImportName: string;
-  },
+	j: JSCodeshift,
+	collection: Collection<any>,
+	{
+		fromImportName,
+		toImportName,
+	}: {
+		fromImportName: string;
+		toImportName: string;
+	},
 ) {
-  const importDeclarationCollection = getImportDeclarationCollection(
-    j,
-    collection,
-    importPath,
-  );
-  const importSpecifierCollection = getImportSpecifierCollection(
-    j,
-    importDeclarationCollection,
-    fromImportName,
-  );
-  const importSpecifierName = getImportSpecifierName(importSpecifierCollection);
-
-  if (importSpecifierName === null) {
-    return;
-  }
-
-  importSpecifierCollection.forEach((importSpecifierPath) => {
-    renameBasedOnImportAlias(
-      j,
-      collection,
-      importSpecifierPath,
-      importSpecifierName,
-      {
-        fromImportName,
-        toImportName,
-      },
-    );
-  });
+	const importDeclarationCollection = getImportDeclarationCollection(j, collection, importPath);
+	const importSpecifierCollection = getImportSpecifierCollection(
+		j,
+		importDeclarationCollection,
+		fromImportName,
+	);
+	const importSpecifierName = getImportSpecifierName(importSpecifierCollection);
+
+	if (importSpecifierName === null) {
+		return;
+	}
+
+	importSpecifierCollection.forEach((importSpecifierPath) => {
+		renameBasedOnImportAlias(j, collection, importSpecifierPath, importSpecifierName, {
+			fromImportName,
+			toImportName,
+		});
+	});
 }
 
 function renameBasedOnImportAlias(
-  j: JSCodeshift,
-  collection: Collection<any>,
-  importSpecifierPath: ASTPath<ImportSpecifier>,
-  importSpecifierName: string,
-  {
-    fromImportName,
-    toImportName,
-  }: {
-    fromImportName: string;
-    toImportName: string;
-  },
+	j: JSCodeshift,
+	collection: Collection<any>,
+	importSpecifierPath: ASTPath<ImportSpecifier>,
+	importSpecifierName: string,
+	{
+		fromImportName,
+		toImportName,
+	}: {
+		fromImportName: string;
+		toImportName: string;
+	},
 ) {
-  const isImportAliasPresent = importSpecifierName !== fromImportName;
-
-  if (isImportAliasPresent) {
-    return renameOnlyImportName(j, importSpecifierPath, importSpecifierName, {
-      toImportName,
-    });
-  }
-
-  const isToImportNameIdentifierPresentInSourceCode =
-    isVariableDeclaratorIdentifierPresent(j, collection, toImportName) ||
-    isFunctionDeclarationIdentifierPresent(j, collection, toImportName) ||
-    isClassDeclarationIdentifierPresent(j, collection, toImportName) ||
-    isImportDeclarationIdentifierPresent(j, collection, toImportName);
-
-  if (isToImportNameIdentifierPresentInSourceCode) {
-    return renameOnlyImportNameWithAliasAddition(j, importSpecifierPath, {
-      fromImportName,
-      toImportName,
-    });
-  }
-
-  return renameImportNameWithItsUsage(j, collection, importSpecifierPath, {
-    fromImportName,
-    toImportName,
-  });
+	const isImportAliasPresent = importSpecifierName !== fromImportName;
+
+	if (isImportAliasPresent) {
+		return renameOnlyImportName(j, importSpecifierPath, importSpecifierName, {
+			toImportName,
+		});
+	}
+
+	const isToImportNameIdentifierPresentInSourceCode =
+		isVariableDeclaratorIdentifierPresent(j, collection, toImportName) ||
+		isFunctionDeclarationIdentifierPresent(j, collection, toImportName) ||
+		isClassDeclarationIdentifierPresent(j, collection, toImportName) ||
+		isImportDeclarationIdentifierPresent(j, collection, toImportName);
+
+	if (isToImportNameIdentifierPresentInSourceCode) {
+		return renameOnlyImportNameWithAliasAddition(j, importSpecifierPath, {
+			fromImportName,
+			toImportName,
+		});
+	}
+
+	return renameImportNameWithItsUsage(j, collection, importSpecifierPath, {
+		fromImportName,
+		toImportName,
+	});
 }
 
 function renameOnlyImportName(
-  j: JSCodeshift,
-  importSpecifierPath: ASTPath<ImportSpecifier>,
-  importSpecifierName: string,
-  {
-    toImportName,
-  }: {
-    toImportName: string;
-  },
+	j: JSCodeshift,
+	importSpecifierPath: ASTPath<ImportSpecifier>,
+	importSpecifierName: string,
+	{
+		toImportName,
+	}: {
+		toImportName: string;
+	},
 ) {
-  j(importSpecifierPath).replaceWith(
-    j.importSpecifier(
-      j.identifier(toImportName),
-      j.identifier(importSpecifierName),
-    ),
-  );
+	j(importSpecifierPath).replaceWith(
+		j.importSpecifier(j.identifier(toImportName), j.identifier(importSpecifierName)),
+	);
 }
 
 function renameOnlyImportNameWithAliasAddition(
-  j: JSCodeshift,
-  importSpecifierPath: ASTPath<ImportSpecifier>,
-  {
-    fromImportName,
-    toImportName,
-  }: {
-    fromImportName: string;
-    toImportName: string;
-  },
+	j: JSCodeshift,
+	importSpecifierPath: ASTPath<ImportSpecifier>,
+	{
+		fromImportName,
+		toImportName,
+	}: {
+		fromImportName: string;
+		toImportName: string;
+	},
 ) {
-  j(importSpecifierPath).replaceWith(
-    j.importSpecifier(j.identifier(toImportName), j.identifier(fromImportName)),
-  );
+	j(importSpecifierPath).replaceWith(
+		j.importSpecifier(j.identifier(toImportName), j.identifier(fromImportName)),
+	);
 }
 
 function renameImportNameWithItsUsage(
-  j: JSCodeshift,
-  collection: Collection<any>,
-  importSpecifierPath: ASTPath<ImportSpecifier>,
-  {
-    fromImportName,
-    toImportName,
-  }: {
-    fromImportName: string;
-    toImportName: string;
-  },
+	j: JSCodeshift,
+	collection: Collection<any>,
+	importSpecifierPath: ASTPath<ImportSpecifier>,
+	{
+		fromImportName,
+		toImportName,
+	}: {
+		fromImportName: string;
+		toImportName: string;
+	},
 ) {
-  j(importSpecifierPath).replaceWith(
-    j.importSpecifier(j.identifier(toImportName), j.identifier(toImportName)),
-  );
-
-  collection
-    .find(j.JSXIdentifier)
-    .filter(
-      (jsxIdentifierPath) => jsxIdentifierPath.node.name === fromImportName,
-    )
-    .forEach((jsxIdentifierPath) => {
-      j(jsxIdentifierPath).replaceWith(j.identifier(toImportName));
-    });
-
-  collection.find(j.CallExpression).forEach((callExpressionPath) => {
-    const { arguments: callExpressionArguments } = callExpressionPath.node;
-
-    callExpressionPath.node.arguments = callExpressionArguments.map(
-      (argument) => {
-        if (
-          argument.type === 'Identifier' &&
-          argument.name === fromImportName
-        ) {
-          return j.identifier(toImportName);
-        }
-
-        return argument;
-      },
-    );
-  });
-
-  collection.find(j.VariableDeclarator).forEach((variableDeclaratorPath) => {
-    const { init } = variableDeclaratorPath.node;
-
-    if (
-      init &&
-      init.type === 'Identifier' &&
-      (init as Identifier).name === fromImportName
-    ) {
-      variableDeclaratorPath.node.init = j.identifier(toImportName);
-    }
-  });
+	j(importSpecifierPath).replaceWith(
+		j.importSpecifier(j.identifier(toImportName), j.identifier(toImportName)),
+	);
+
+	collection
+		.find(j.JSXIdentifier)
+		.filter((jsxIdentifierPath) => jsxIdentifierPath.node.name === fromImportName)
+		.forEach((jsxIdentifierPath) => {
+			j(jsxIdentifierPath).replaceWith(j.identifier(toImportName));
+		});
+
+	collection.find(j.CallExpression).forEach((callExpressionPath) => {
+		const { arguments: callExpressionArguments } = callExpressionPath.node;
+
+		callExpressionPath.node.arguments = callExpressionArguments.map((argument) => {
+			if (argument.type === 'Identifier' && argument.name === fromImportName) {
+				return j.identifier(toImportName);
+			}
+
+			return argument;
+		});
+	});
+
+	collection.find(j.VariableDeclarator).forEach((variableDeclaratorPath) => {
+		const { init } = variableDeclaratorPath.node;
+
+		if (init && init.type === 'Identifier' && (init as Identifier).name === fromImportName) {
+			variableDeclaratorPath.node.init = j.identifier(toImportName);
+		}
+	});
 }
 
 function addPromiseThenIdentifier(j: JSCodeshift, collection: Collection<any>) {
-  const thenArgument = 'module';
-
-  getDynamicImportCollection(j, collection, importPath).forEach(
-    (callExpressionPath) => {
-      j(callExpressionPath).replaceWith(
-        j.callExpression(
-          j.memberExpression(callExpressionPath.node, j.identifier('then')),
-          [
-            j.arrowFunctionExpression(
-              [j.identifier(thenArgument)],
-              j.objectExpression([
-                j.objectProperty(
-                  j.identifier(importsMapping.oldImports.Code),
-                  j.memberExpression(
-                    j.identifier(thenArgument),
-                    j.identifier(importsMapping.newImports.Code),
-                  ),
-                ),
-                j.objectProperty(
-                  j.identifier(importsMapping.oldImports.CodeBlock),
-                  j.memberExpression(
-                    j.identifier(thenArgument),
-                    j.identifier(importsMapping.newImports.CodeBlock),
-                  ),
-                ),
-              ]),
-            ),
-          ],
-        ),
-      );
-    },
-  );
+	const thenArgument = 'module';
+
+	getDynamicImportCollection(j, collection, importPath).forEach((callExpressionPath) => {
+		j(callExpressionPath).replaceWith(
+			j.callExpression(j.memberExpression(callExpressionPath.node, j.identifier('then')), [
+				j.arrowFunctionExpression(
+					[j.identifier(thenArgument)],
+					j.objectExpression([
+						j.objectProperty(
+							j.identifier(importsMapping.oldImports.Code),
+							j.memberExpression(
+								j.identifier(thenArgument),
+								j.identifier(importsMapping.newImports.Code),
+							),
+						),
+						j.objectProperty(
+							j.identifier(importsMapping.oldImports.CodeBlock),
+							j.memberExpression(
+								j.identifier(thenArgument),
+								j.identifier(importsMapping.newImports.CodeBlock),
+							),
+						),
+					]),
+				),
+			]),
+		);
+	});
 }
 
-export default function transformer(
-  fileInfo: FileInfo,
-  { jscodeshift: j }: API,
-  options: Options,
-) {
-  const { source } = fileInfo;
-  const collection = j(source);
-
-  const hasCodeImportDeclaration = hasImportDeclaration(
-    j,
-    collection,
-    importPath,
-  );
-
-  const hasDynamicImportCode = hasDynamicImport(j, collection, importPath);
-
-  if (!hasCodeImportDeclaration && !hasDynamicImportCode) {
-    return source;
-  }
-
-  if (hasCodeImportDeclaration) {
-    [
-      {
-        fromImportName: importsMapping.oldImports.Code,
-        toImportName: importsMapping.newImports.Code,
-      },
-      {
-        fromImportName: importsMapping.oldImports.CodeBlock,
-        toImportName: importsMapping.newImports.CodeBlock,
-      },
-    ].forEach(({ fromImportName, toImportName }) => {
-      renameNamedImports(j, collection, {
-        fromImportName,
-        toImportName,
-      });
-    });
-  }
-
-  if (hasDynamicImportCode) {
-    addPromiseThenIdentifier(j, collection);
-  }
-
-  return collection.toSource(options.printOptions || { quote: 'single' });
+export default function transformer(fileInfo: FileInfo, { jscodeshift: j }: API, options: Options) {
+	const { source } = fileInfo;
+	const collection = j(source);
+
+	const hasCodeImportDeclaration = hasImportDeclaration(j, collection, importPath);
+
+	const hasDynamicImportCode = hasDynamicImport(j, collection, importPath);
+
+	if (!hasCodeImportDeclaration && !hasDynamicImportCode) {
+		return source;
+	}
+
+	if (hasCodeImportDeclaration) {
+		[
+			{
+				fromImportName: importsMapping.oldImports.Code,
+				toImportName: importsMapping.newImports.Code,
+			},
+			{
+				fromImportName: importsMapping.oldImports.CodeBlock,
+				toImportName: importsMapping.newImports.CodeBlock,
+			},
+		].forEach(({ fromImportName, toImportName }) => {
+			renameNamedImports(j, collection, {
+				fromImportName,
+				toImportName,
+			});
+		});
+	}
+
+	if (hasDynamicImportCode) {
+		addPromiseThenIdentifier(j, collection);
+	}
+
+	return collection.toSource(options.printOptions || { quote: 'single' });
 }

package/codemods/14.0.0-lite-mode.tsx

@@ -1,18 +1,14 @@
-import { JSCodeshift } from 'jscodeshift';
-import { Collection } from 'jscodeshift/src/Collection';
+import { type JSCodeshift } from 'jscodeshift';
+import { type Collection } from 'jscodeshift/src/Collection';
 
-import {
-  createTransformer,
-  hasImportDeclaration,
-} from '@atlaskit/codemod-utils';
+import { createTransformer, hasImportDeclaration } from '@atlaskit/codemod-utils';
 
 import removeLanguage from './migrations/14.0.0-lite-mode/remove-language';
 import textToChild from './migrations/14.0.0-lite-mode/text-to-child';
 
 const transformer = createTransformer(
-  [removeLanguage, textToChild],
-  (j: JSCodeshift, source: Collection<Node>) =>
-    hasImportDeclaration(j, source, '@atlaskit/code'),
+	[removeLanguage, textToChild],
+	(j: JSCodeshift, source: Collection<Node>) => hasImportDeclaration(j, source, '@atlaskit/code'),
 );
 
 export default transformer;

package/codemods/__tests__/13.0.0-remove-unnecessary-code-props.tsx

@@ -5,24 +5,24 @@ import transformer from '../13.0.0-remove-unnecessary-code-props';
 const defineInlineTest = require('jscodeshift/dist/testUtils').defineInlineTest;
 
 const removePropsMapping = {
-  lineNumberContainerStyle: 'lineNumberContainerStyle',
-  showLineNumbers: 'lineNumberContainerStyle',
-  highlight: 'highlight',
+	lineNumberContainerStyle: 'lineNumberContainerStyle',
+	showLineNumbers: 'lineNumberContainerStyle',
+	highlight: 'highlight',
 };
 
 describe('Remove props', () => {
-  defineInlineTest(
-    { default: transformer, parser: 'tsx' },
-    {},
-    `import React from 'react';`,
-    `import React from 'react';`,
-    'should not transform if imports are not present',
-  );
-
-  defineInlineTest(
-    { default: transformer, parser: 'tsx' },
-    {},
-    `
+	defineInlineTest(
+		{ default: transformer, parser: 'tsx' },
+		{},
+		`import React from 'react';`,
+		`import React from 'react';`,
+		'should not transform if imports are not present',
+	);
+
+	defineInlineTest(
+		{ default: transformer, parser: 'tsx' },
+		{},
+		`
     import React from 'react';
     import { Code } from '@atlaskit/code';
 
@@ -34,7 +34,7 @@ describe('Remove props', () => {
 
     const element = <Code prop="abc" />;
     `,
-    `
+		`
     import React from 'react';
     import { Code } from '@atlaskit/code';
 
@@ -46,14 +46,14 @@ describe('Remove props', () => {
 
     const element = <Code prop="abc" />;
     `,
-    'should not transform if removable props are not preset',
-  );
-
-  describe('when only one prop present', () => {
-    defineInlineTest(
-      { default: transformer, parser: 'tsx' },
-      {},
-      `
+		'should not transform if removable props are not preset',
+	);
+
+	describe('when only one prop present', () => {
+		defineInlineTest(
+			{ default: transformer, parser: 'tsx' },
+			{},
+			`
       import React from 'react';
       import { Code } from '@atlaskit/code';
 
@@ -65,7 +65,7 @@ describe('Remove props', () => {
 
       const element = <Code prop="abc" ${removePropsMapping.lineNumberContainerStyle}={{ fontSize: '14px' }} />;
       `,
-      `
+			`
       import React from 'react';
       import { Code } from '@atlaskit/code';
 
@@ -77,13 +77,13 @@ describe('Remove props', () => {
 
       const element = <Code prop="abc" />;
       `,
-      `removes "${removePropsMapping.lineNumberContainerStyle}" "JSXAttribute" prop`,
-    );
+			`removes "${removePropsMapping.lineNumberContainerStyle}" "JSXAttribute" prop`,
+		);
 
-    defineInlineTest(
-      { default: transformer, parser: 'tsx' },
-      {},
-      `
+		defineInlineTest(
+			{ default: transformer, parser: 'tsx' },
+			{},
+			`
       import React from 'react';
       import { Code } from '@atlaskit/code';
 
@@ -102,7 +102,7 @@ describe('Remove props', () => {
 
       const Component3 = () => <Code prop="abc" {...foo} { ...{ ${removePropsMapping.lineNumberContainerStyle}: { fontSize: '24px' }, key: 'hello' } } {...bar} />;
       `,
-      `
+			`
       import React from 'react';
       import { Code } from '@atlaskit/code';
 
@@ -120,14 +120,14 @@ describe('Remove props', () => {
         key: 'hello'
       } } {...bar} />;
       `,
-      `removes "${removePropsMapping.lineNumberContainerStyle}" "JSXSpreadAttribute" prop`,
-    );
-  });
-
-  defineInlineTest(
-    { default: transformer, parser: 'tsx' },
-    {},
-    `
+			`removes "${removePropsMapping.lineNumberContainerStyle}" "JSXSpreadAttribute" prop`,
+		);
+	});
+
+	defineInlineTest(
+		{ default: transformer, parser: 'tsx' },
+		{},
+		`
     import React from 'react';
     import { Code } from '@atlaskit/code';
 
@@ -165,7 +165,7 @@ describe('Remove props', () => {
 
     const element = <Code prop="abc" ${removePropsMapping.lineNumberContainerStyle}={{ fontSize: '14px' }} ${removePropsMapping.highlight}="2-4" />;
     `,
-    `
+		`
     import React from 'react';
     import { Code } from '@atlaskit/code';
 
@@ -196,6 +196,6 @@ describe('Remove props', () => {
 
     const element = <Code prop="abc" />;
     `,
-    'removes mixture of removable props',
-  );
+		'removes mixture of removable props',
+	);
 });