@atlaskit/button 20.5.0 → 20.5.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @atlaskit/button
 
+## 20.5.2
+
+### Patch Changes
+
+- [#113702](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/113702)
+  [`6ac2c34162d59`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/6ac2c34162d59) -
+  Remove old codemods.
+
+## 20.5.1
+
+### Patch Changes
+
+- Updated dependencies
+
 ## 20.5.0
 
 ### Minor Changes

package/dist/cjs/old-button/shared/button-base.js

@@ -133,7 +133,7 @@ var ButtonBase = /*#__PURE__*/_react.default.forwardRef(function ButtonBase(prop
     action: 'clicked',
     componentName: 'button',
     packageName: "@atlaskit/button",
-    packageVersion: "20.5.0",
+    packageVersion: "20.5.2",
     analyticsData: analyticsContext
   });
 

package/dist/es2019/old-button/shared/button-base.js

@@ -119,7 +119,7 @@ const ButtonBase = /*#__PURE__*/React.forwardRef(function ButtonBase(props, ref)
     action: 'clicked',
     componentName: 'button',
     packageName: "@atlaskit/button",
-    packageVersion: "20.5.0",
+    packageVersion: "20.5.2",
     analyticsData: analyticsContext
   });
 

package/dist/esm/old-button/shared/button-base.js

@@ -125,7 +125,7 @@ var ButtonBase = /*#__PURE__*/React.forwardRef(function ButtonBase(props, ref) {
     action: 'clicked',
     componentName: 'button',
     packageName: "@atlaskit/button",
-    packageVersion: "20.5.0",
+    packageVersion: "20.5.2",
     analyticsData: analyticsContext
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/button",
-	"version": "20.5.0",
+	"version": "20.5.2",
 	"description": "A button triggers an event or action. They let users know what will happen next.",
 	"publishConfig": {
 		"registry": "https://registry.npmjs.org/"
@@ -87,12 +87,12 @@
 		"@atlaskit/analytics-next": "^10.3.0",
 		"@atlaskit/ds-lib": "^3.5.0",
 		"@atlaskit/focus-ring": "^2.1.0",
-		"@atlaskit/icon": "^23.6.0",
+		"@atlaskit/icon": "^23.9.0",
 		"@atlaskit/interaction-context": "^2.6.0",
 		"@atlaskit/platform-feature-flags": "^1.0.0",
-		"@atlaskit/primitives": "^13.4.0",
+		"@atlaskit/primitives": "^13.5.0",
 		"@atlaskit/spinner": "^17.1.0",
-		"@atlaskit/theme": "^14.1.0",
+		"@atlaskit/theme": "^15.0.0",
 		"@atlaskit/tokens": "^3.3.0",
 		"@atlaskit/tooltip": "^19.1.0",
 		"@atlaskit/visually-hidden": "^1.6.0",

package/codemods/15.1.1-data-testid.tsx

@@ -1,165 +0,0 @@
-import type { API, default as core, FileInfo, Options } from 'jscodeshift';
-import { type Collection } from 'jscodeshift/src/Collection';
-
-import {
-	addCommentToStartOfFile,
-	getDefaultSpecifierName,
-	getJSXAttributesByName,
-	hasImportDeclaration,
-	type Nullable,
-} from './helpers/helpers-generic';
-const relevantEntryPoints = [
-	'@atlaskit/button',
-	'@atlaskit/button/standard-button',
-	'@atlaskit/button/loading-button',
-	'@atlaskit/button/custom-theme-button',
-];
-
-function isRelevant(j: core.JSCodeshift, source: string): boolean {
-	return relevantEntryPoints.some((entryPoint) => hasImportDeclaration(j, source, entryPoint));
-}
-
-function renameProp({
-	j,
-	base,
-	component,
-	attributeFrom,
-	attributeTo,
-}: {
-	j: core.JSCodeshift;
-	base: Collection<any>;
-	component: string;
-	attributeFrom: string;
-	attributeTo: string;
-}) {
-	base.findJSXElements(component).forEach((element) => {
-		const first = getJSXAttributesByName({
-			j,
-			element: element.value,
-			attributeName: attributeFrom,
-		});
-
-		// not using attribute
-		if (!first.length) {
-			return;
-		}
-
-		// let's check to see if they are using the to attribute
-		const second = getJSXAttributesByName({
-			j,
-			element: element.value,
-			attributeName: attributeTo,
-		});
-
-		// if the attribute we are moving to already exists we are in trouble
-		if (second.length) {
-			addCommentToStartOfFile({
-				j,
-				base,
-				message: `
-        Cannot rename ${attributeFrom} to ${attributeTo} on ${component}.
-        A ${component} was detected with both ${attributeFrom} and ${attributeTo} props.
-        Please remove the ${attributeFrom} prop and check your tests`,
-			});
-			return;
-		}
-
-		first.find(j.JSXIdentifier).replaceWith(j.jsxIdentifier(attributeTo));
-	});
-}
-
-export function getNamedImportName({
-	j,
-	base,
-	importPath,
-	originalName,
-}: {
-	j: core.JSCodeshift;
-	base: Collection<any>;
-	originalName: string;
-	importPath: string;
-}): Nullable<string> {
-	const name: Nullable<string> =
-		base
-			.find(j.ImportDeclaration)
-			.filter((path) => path.node.source.value === importPath)
-			.find(j.ImportSpecifier)
-			.nodes()
-			.map((specifier): Nullable<string> => {
-				if (specifier.imported.name === originalName) {
-					// aliased
-					if (specifier.local) {
-						return specifier.local.name;
-					}
-					// not aliased
-					return originalName;
-				}
-
-				return null;
-			})
-			.filter(Boolean)[0] || null;
-	return name;
-}
-
-export default function transformer(file: FileInfo, { jscodeshift: j }: API, options: Options) {
-	if (!isRelevant(j, file.source)) {
-		return file.source;
-	}
-
-	const base: Collection<any> = j(file.source);
-
-	// renaming default imports for entry points
-	relevantEntryPoints.forEach((importPath) => {
-		const defaultName: Nullable<string> = getDefaultSpecifierName({
-			j,
-			base,
-			packageName: importPath,
-		});
-
-		if (defaultName != null) {
-			renameProp({
-				j,
-				base,
-				component: defaultName,
-				attributeFrom: 'data-testid',
-				attributeTo: 'testId',
-			});
-		}
-	});
-
-	// named imports
-	const standard = getNamedImportName({
-		j,
-		base,
-		importPath: '@atlaskit/button',
-		originalName: 'StandardButton',
-	});
-	const loading = getNamedImportName({
-		j,
-		base,
-		importPath: '@atlaskit/button',
-		originalName: 'LoadingButton',
-	});
-	const customTheme = getNamedImportName({
-		j,
-		base,
-		importPath: '@atlaskit/button',
-		originalName: 'CustomThemeButton',
-	});
-	[standard, loading, customTheme].forEach((name) => {
-		if (name != null) {
-			renameProp({
-				j,
-				base,
-				component: name,
-				attributeFrom: 'data-testid',
-				attributeTo: 'testId',
-			});
-		}
-	});
-
-	return base.toSource({ quote: 'single' });
-}
-
-// Note: not exporting a 'parser' because doing so
-// will prevent consumers overriding it

package/codemods/__tests__/15.1.1-data-testid/rename-data-testid.tsx

@@ -1,185 +0,0 @@
-jest.autoMockOff();
-
-import transformer from '../../15.1.1-data-testid';
-import { check } from '../_framework';
-
-check({
-	transformer,
-	it: 'should rename data-testid to testId (default import)',
-	original: `
-    import DSButton from '@atlaskit/button';
-
-    function App() {
-      return <DSButton data-testid="my-testid">click me</DSButton>;
-    }
-  `,
-	expected: `
-    import DSButton from '@atlaskit/button';
-
-    function App() {
-      return <DSButton testId="my-testid">click me</DSButton>;
-    }
-  `,
-});
-
-check({
-	transformer,
-	it: 'should rename data-testid to testId (standard button)',
-	original: `
-    import Button from '@atlaskit/button/standard-button';
-
-    function App() {
-      return <Button data-testid="my-testid">click me</Button>;
-    }
-  `,
-	expected: `
-    import Button from '@atlaskit/button/standard-button';
-
-    function App() {
-      return <Button testId="my-testid">click me</Button>;
-    }
-  `,
-});
-
-check({
-	transformer,
-	it: 'should rename data-testid to testId (loading button)',
-	original: `
-    import Button from '@atlaskit/button/loading-button';
-
-    function App() {
-      return <Button data-testid="my-testid">click me</Button>;
-    }
-  `,
-	expected: `
-    import Button from '@atlaskit/button/loading-button';
-
-    function App() {
-      return <Button testId="my-testid">click me</Button>;
-    }
-  `,
-});
-
-check({
-	transformer,
-	it: 'should rename data-testid to testId (custom theme button)',
-	original: `
-    import Button from '@atlaskit/button/custom-theme-button';
-
-    function App() {
-      return <Button data-testid="my-testid">click me</Button>;
-    }
-  `,
-	expected: `
-    import Button from '@atlaskit/button/custom-theme-button';
-
-    function App() {
-      return <Button testId="my-testid">click me</Button>;
-    }
-  `,
-});
-
-check({
-	transformer,
-	it: 'should rename data-testid to testId (named imports)',
-	original: `
-    import { StandardButton, LoadingButton, CustomThemeButton } from '@atlaskit/button';
-
-    function App() {
-      return <>
-        <StandardButton data-testid="my-testid">click me</StandardButton>
-        <LoadingButton data-testid="my-testid">click me</LoadingButton>
-        <CustomThemeButton data-testid="my-testid">click me</CustomThemeButton>
-      </>;
-    }
-  `,
-	expected: `
-    import { StandardButton, LoadingButton, CustomThemeButton } from '@atlaskit/button';
-
-    function App() {
-      return <>
-        <StandardButton testId="my-testid">click me</StandardButton>
-        <LoadingButton testId="my-testid">click me</LoadingButton>
-        <CustomThemeButton testId="my-testid">click me</CustomThemeButton>
-      </>;
-    }
-  `,
-});
-
-check({
-	transformer,
-	it: 'should rename data-testid to testId (named imports with alias)',
-	original: `
-    import { StandardButton as SB, LoadingButton as LB, CustomThemeButton as CTB } from '@atlaskit/button';
-
-    function App() {
-      return <>
-        <SB data-testid="my-testid">click me</SB>
-        <LB data-testid="my-testid">click me</LB>
-        <CTB data-testid="my-testid">click me</CTB>
-      </>;
-    }
-  `,
-	expected: `
-    import { StandardButton as SB, LoadingButton as LB, CustomThemeButton as CTB } from '@atlaskit/button';
-
-    function App() {
-      return <>
-        <SB testId="my-testid">click me</SB>
-        <LB testId="my-testid">click me</LB>
-        <CTB testId="my-testid">click me</CTB>
-      </>;
-    }
-  `,
-});
-
-check({
-	transformer,
-	it: 'should add a warning when both the testId and data-testid props are being used',
-	original: `
-    import StandardButton from '@atlaskit/button';
-
-    function App() {
-      return <StandardButton testId="oh-my" data-testid="oh-dear">Click me</StandardButton>
-    }
-  `,
-	expected: `
-    /* TODO: (from codemod) Cannot rename data-testid to testId on StandardButton.
-    A StandardButton was detected with both data-testid and testId props.
-    Please remove the data-testid prop and check your tests */
-    import StandardButton from '@atlaskit/button';
-
-    function App() {
-      return <StandardButton testId="oh-my" data-testid="oh-dear">Click me</StandardButton>
-    }
-  `,
-});
-
-check({
-	transformer,
-	it: 'should not touch unrelated testids',
-	original: `
-    import DSButton from '@atlaskit/button';
-    import Something from '@atlaskit/foobar';
-
-    function App() {
-      return <>
-        <DSButton data-testid="my-testid">
-          <Something data-testid="hello">click me</Something>
-        </DSButton>
-      </>;
-    }
-  `,
-	expected: `
-    import DSButton from '@atlaskit/button';
-    import Something from '@atlaskit/foobar';
-
-    function App() {
-      return <>
-        <DSButton testId="my-testid">
-          <Something data-testid="hello">click me</Something>
-        </DSButton>
-      </>;
-    }
-  `,
-});

package/codemods/__tests__/_framework.tsx

@@ -1,47 +0,0 @@
-import { type API, type FileInfo, type Options } from 'jscodeshift';
-
-import noop from '@atlaskit/ds-lib/noop';
-
-const applyTransform = require('jscodeshift/dist/testUtils').applyTransform;
-
-type Transformer = (file: FileInfo, jscodeshift: API, options: Options) => void;
-
-type TestArgs = {
-	it: string;
-	original: string;
-	expected: string;
-	transformer: Transformer;
-	mode?: 'only' | 'skip' | 'standard';
-	before?: () => void;
-	after?: () => void;
-};
-
-export function check({
-	it: name,
-	original,
-	expected,
-	transformer,
-	before = noop,
-	after = noop,
-	mode = 'standard',
-}: TestArgs) {
-	const run = mode === 'only' ? it.only : mode === 'skip' ? it.skip : it;
-
-	run(name, () => {
-		before();
-		try {
-			const output: string = applyTransform(
-				{ default: transformer, parser: 'tsx' },
-				{},
-				{ source: original },
-			);
-			expect(output).toBe(expected.trim());
-		} catch (e) {
-			// a failed assertion will throw
-			after();
-			throw e;
-		}
-		// will only be hit if we don't throw
-		after();
-	});
-}

package/codemods/helpers/helpers-generic.tsx

@@ -1,629 +0,0 @@
-import { type NodePath } from 'ast-types/lib/node-path';
-import type {
-	ASTPath,
-	default as core,
-	ImportDeclaration,
-	ImportDefaultSpecifier,
-	ImportSpecifier,
-	JSXAttribute,
-	JSXElement,
-	Node,
-	Program,
-} from 'jscodeshift';
-import { type Collection } from 'jscodeshift/src/Collection';
-
-export type Nullable<T> = T | null;
-
-export function hasImportDeclaration(
-	j: core.JSCodeshift,
-	source: string,
-	importPath: string,
-): boolean {
-	return (
-		j(source)
-			.find(j.ImportDeclaration)
-			.filter((path: ASTPath<ImportDeclaration>) => path.node.source.value === importPath).length >
-		0
-	);
-}
-
-export function getDefaultSpecifierName({
-	j,
-	base,
-	packageName,
-}: {
-	j: core.JSCodeshift;
-	base: Collection<any>;
-	packageName: string;
-}): Nullable<string> {
-	const specifiers = base
-		.find(j.ImportDeclaration)
-		.filter((path) => path.node.source.value === packageName)
-		.find(j.ImportDefaultSpecifier);
-
-	if (!specifiers.length) {
-		return null;
-	}
-	return specifiers.nodes()[0]!.local!.name;
-}
-
-export function getJSXAttributesByName({
-	j,
-	element,
-	attributeName,
-}: {
-	j: core.JSCodeshift;
-	element: JSXElement;
-	attributeName: string;
-}): Collection<JSXAttribute> {
-	return j(element)
-		.find(j.JSXOpeningElement)
-		.find(j.JSXAttribute)
-		.filter((attribute) => {
-			const matches = j(attribute)
-				// This will find identifiers on nested jsx elements
-				// so we are going to do a filter to ensure we are only
-				// going one level deep
-				.find(j.JSXIdentifier)
-				.filter((identifer) => {
-					j(identifer).closest(j.JSXOpeningElement);
-					// Checking we are on the same level as the jsx element
-					const closest = j(identifer).closest(j.JSXOpeningElement).nodes()[0];
-
-					if (!closest) {
-						return false;
-					}
-					return (
-						closest.name.type === 'JSXIdentifier' &&
-						element.openingElement.name.type === 'JSXIdentifier' &&
-						element.openingElement.name.name === closest.name.name
-					);
-				})
-				.filter((identifier) => identifier.value.name === attributeName);
-			return Boolean(matches.length);
-		});
-}
-
-export function hasJSXAttributesByName({
-	j,
-	element,
-	attributeName,
-}: {
-	j: core.JSCodeshift;
-	element: JSXElement;
-	attributeName: string;
-}): boolean {
-	return getJSXAttributesByName({ j, element, attributeName }).length > 0;
-}
-
-export function removeImport({
-	j,
-	base,
-	packageName,
-}: {
-	j: core.JSCodeshift;
-	base: Collection<any>;
-	packageName: string;
-}) {
-	base
-		.find(j.ImportDeclaration)
-		.filter((path) => path.node.source.value === packageName)
-		.remove();
-}
-
-export function tryCreateImport({
-	j,
-	base,
-	relativeToPackage,
-	packageName,
-}: {
-	j: core.JSCodeshift;
-	base: Collection<any>;
-	relativeToPackage: string;
-	packageName: string;
-}) {
-	const exists: boolean =
-		base.find(j.ImportDeclaration).filter((path) => path.value.source.value === packageName)
-			.length > 0;
-
-	if (exists) {
-		return;
-	}
-
-	base
-		.find(j.ImportDeclaration)
-		.filter((path) => path.value.source.value === relativeToPackage)
-		.insertBefore(j.importDeclaration([], j.literal(packageName)));
-}
-
-export function addToImport({
-	j,
-	base,
-	importSpecifier,
-	packageName,
-}: {
-	j: core.JSCodeshift;
-	base: Collection<any>;
-	importSpecifier: ImportSpecifier | ImportDefaultSpecifier;
-	packageName: string;
-}) {
-	base
-		.find(j.ImportDeclaration)
-		.filter((path) => path.value.source.value === packageName)
-		.replaceWith((declaration) => {
-			return j.importDeclaration(
-				[
-					// we are appending to the existing specifiers
-					// We are doing a filter hear because sometimes specifiers can be removed
-					// but they hand around in the declaration
-					...(declaration.value.specifiers || []).filter(
-						(item) => item.type === 'ImportSpecifier' && item.imported != null,
-					),
-					importSpecifier,
-				],
-				j.literal(packageName),
-			);
-		});
-}
-
-export function doesIdentifierExist({
-	j,
-	base,
-	name,
-}: {
-	j: core.JSCodeshift;
-	base: Collection<any>;
-	name: string;
-}): boolean {
-	return base.find(j.Identifier).filter((identifer) => identifer.value.name === name).length > 0;
-}
-
-export function isUsingSupportedSpread({
-	j,
-	base,
-	element,
-}: {
-	j: core.JSCodeshift;
-	base: Collection<any>;
-	element: NodePath<JSXElement, JSXElement>;
-}): boolean {
-	const isUsingSpread: boolean = j(element).find(j.JSXSpreadAttribute).length > 0;
-
-	if (!isUsingSpread) {
-		return true;
-	}
-
-	return (
-		j(element)
-			.find(j.JSXSpreadAttribute)
-			.filter((spread) => {
-				const argument = spread.value.argument;
-				// in place expression is supported
-				if (argument.type === 'ObjectExpression') {
-					return true;
-				}
-
-				// Supporting identifiers that point to an a local object expression
-				if (argument.type === 'Identifier') {
-					return (
-						base.find(j.VariableDeclarator).filter((declarator): boolean => {
-							return Boolean(
-								declarator.value.id.type === 'Identifier' &&
-									declarator.value.init &&
-									declarator.value.init.type === 'ObjectExpression',
-							);
-						}).length > 0
-					);
-				}
-
-				// We don't support anything else
-				return false;
-			}).length > 0
-	);
-}
-
-export function isOnlyUsingNameForJSX({
-	j,
-	base,
-	name,
-}: {
-	j: core.JSCodeshift;
-	base: Collection<any>;
-	name: string;
-}): boolean {
-	const jsxIdentifierCount: number = base
-		.find(j.JSXIdentifier)
-		.filter((identifier) => identifier.value.name === name).length;
-
-	// Not used in JSX at all
-	if (jsxIdentifierCount === 0) {
-		return false;
-	}
-
-	const nonJSXIdentifierCount: number = base.find(j.Identifier).filter((identifier) => {
-		if (identifier.value.name !== name) {
-			return false;
-		}
-
-		// @ts-ignore
-		if (identifier.value.type === 'JSXIdentifier') {
-			return false;
-		}
-
-		// Excluding exports
-		if (j(identifier).closest(j.ImportDefaultSpecifier).length) {
-			return false;
-		}
-		if (j(identifier).closest(j.ImportSpecifier).length) {
-			return false;
-		}
-
-		return true;
-	}).length;
-
-	if (nonJSXIdentifierCount > 0) {
-		return false;
-	}
-
-	return true;
-}
-
-export function getSafeImportName({
-	j,
-	base,
-	currentDefaultSpecifierName,
-	desiredName,
-	fallbackName,
-}: {
-	j: core.JSCodeshift;
-	base: Collection<any>;
-	currentDefaultSpecifierName: string;
-	desiredName: string;
-	fallbackName: string;
-}) {
-	if (currentDefaultSpecifierName === desiredName) {
-		return desiredName;
-	}
-
-	const isUsed: boolean = doesIdentifierExist({ j, base, name: desiredName });
-
-	return isUsed ? fallbackName : desiredName;
-}
-
-export function isUsingThroughSpread({
-	j,
-	base,
-	element,
-	propName,
-}: {
-	j: core.JSCodeshift;
-	base: Collection<any>;
-	element: NodePath<JSXElement, JSXElement>;
-	propName: string;
-}): boolean {
-	if (!isUsingSupportedSpread({ j, base, element })) {
-		return false;
-	}
-
-	const isUsedThroughExpression: boolean =
-		j(element)
-			.find(j.JSXSpreadAttribute)
-			.find(j.ObjectExpression)
-			.filter((item) => {
-				const match: boolean =
-					item.value.properties.filter(
-						(property) =>
-							property.type === 'ObjectProperty' &&
-							property.key.type === 'Identifier' &&
-							property.key.name === propName,
-					).length > 0;
-
-				return match;
-			}).length > 0;
-
-	if (isUsedThroughExpression) {
-		return true;
-	}
-
-	const isUsedThroughIdentifier: boolean =
-		j(element)
-			.find(j.JSXSpreadAttribute)
-			.find(j.Identifier)
-			.filter((identifier): boolean => {
-				return (
-					base
-						.find(j.VariableDeclarator)
-						.filter(
-							(declarator) =>
-								declarator.value.id.type === 'Identifier' &&
-								declarator.value.id.name === identifier.value.name,
-						)
-						.filter((declarator) => {
-							const value = declarator.value;
-							if (value.id.type !== 'Identifier') {
-								return false;
-							}
-
-							if (value.id.name !== identifier.value.name) {
-								return false;
-							}
-
-							if (!value.init) {
-								return false;
-							}
-
-							if (value.init.type !== 'ObjectExpression') {
-								return false;
-							}
-
-							const match: boolean =
-								value.init.properties.filter(
-									(property) =>
-										property.type === 'ObjectProperty' &&
-										property.key.type === 'Identifier' &&
-										property.key.name === propName,
-								).length > 0;
-
-							return match;
-						}).length > 0
-				);
-			}).length > 0;
-
-	return isUsedThroughIdentifier;
-}
-
-export function isUsingProp({
-	j,
-	base,
-	element,
-	propName,
-}: {
-	j: core.JSCodeshift;
-	base: Collection<any>;
-	element: NodePath<JSXElement, JSXElement>;
-	propName: string;
-}): boolean {
-	return (
-		hasJSXAttributesByName({
-			j,
-			element: element.value,
-			attributeName: propName,
-		}) ||
-		isUsingThroughSpread({
-			j,
-			base,
-			element,
-			propName,
-		})
-	);
-}
-
-// not replacing newlines (which \s does)
-const spacesAndTabs: RegExp = /[ \t]{2,}/g;
-const lineStartWithSpaces: RegExp = /^[ \t]*/gm;
-
-function clean(value: string): string {
-	return (
-		value
-			.replace(spacesAndTabs, ' ')
-			.replace(lineStartWithSpaces, '')
-			// using .trim() to clear the any newlines before the first text and after last text
-			.trim()
-	);
-}
-
-export function addCommentToStartOfFile({
-	j,
-	base,
-	message,
-}: {
-	j: core.JSCodeshift;
-	base: Collection<Node>;
-	message: string;
-}) {
-	addCommentBefore({
-		j,
-		target: base.find(j.Program),
-		message,
-	});
-}
-
-export function addCommentBefore({
-	j,
-	target,
-	message,
-}: {
-	j: core.JSCodeshift;
-	target: Collection<Node> | Collection<Program> | Collection<ImportDeclaration>;
-	message: string;
-}) {
-	const content: string = ` TODO: (from codemod) ${clean(message)} `;
-	target.forEach((path) => {
-		path.value.comments = path.value.comments || [];
-
-		const exists = path.value.comments.find((comment) => comment.value === content);
-
-		// avoiding duplicates of the same comment
-		if (exists) {
-			return;
-		}
-
-		path.value.comments.push(j.commentBlock(content));
-	});
-}
-
-export function shiftDefaultImport({
-	j,
-	base,
-	defaultName,
-	oldPackagePath,
-	newPackagePath,
-}: {
-	j: core.JSCodeshift;
-	base: Collection<any>;
-	defaultName: string;
-	oldPackagePath: string;
-	newPackagePath: string;
-}) {
-	tryCreateImport({
-		j,
-		base,
-		relativeToPackage: oldPackagePath,
-		packageName: newPackagePath,
-	});
-
-	addToImport({
-		j,
-		base,
-		importSpecifier: j.importDefaultSpecifier(j.identifier(defaultName)),
-		packageName: newPackagePath,
-	});
-
-	// removing old default specifier
-	base
-		.find(j.ImportDeclaration)
-		.filter((path) => path.node.source.value === oldPackagePath)
-		.find(j.ImportDefaultSpecifier)
-		.remove();
-}
-
-type Option =
-	| {
-			type: 'change-name';
-			oldName: string;
-			newName: string;
-			fallbackNameAlias: string;
-	  }
-	| {
-			type: 'keep-name';
-			name: string;
-			behaviour: 'move-to-default-import' | 'keep-as-named-import';
-	  };
-
-// try to avoid this one if you can. I'm not super happy with it
-export function changeImportFor({
-	j,
-	base,
-	option,
-	oldPackagePath,
-	newPackagePath,
-}: {
-	j: core.JSCodeshift;
-	base: Collection<any>;
-	option: Option;
-	oldPackagePath: string;
-	newPackagePath: string;
-}) {
-	const currentName: string = option.type === 'change-name' ? option.oldName : option.name;
-	const desiredName: string = option.type === 'change-name' ? option.newName : option.name;
-
-	const isUsingName: boolean =
-		base
-			.find(j.ImportDeclaration)
-			.filter((path) => path.node.source.value === oldPackagePath)
-			.find(j.ImportSpecifier)
-			.find(j.Identifier)
-			.filter((identifier) => identifier.value.name === currentName).length > 0;
-
-	if (!isUsingName) {
-		return;
-	}
-
-	const existingAlias: Nullable<string> =
-		base
-			.find(j.ImportDeclaration)
-			.filter((path) => path.node.source.value === oldPackagePath)
-			.find(j.ImportSpecifier)
-			.nodes()
-			.map((specifier): Nullable<string> => {
-				if (specifier.imported.name !== currentName) {
-					return null;
-				}
-				// If aliased: return the alias
-				if (specifier.local && specifier.local.name !== currentName) {
-					return specifier.local.name;
-				}
-
-				return null;
-			})
-			.filter(Boolean)[0] || null;
-
-	base
-		.find(j.ImportDeclaration)
-		.filter((path) => path.node.source.value === oldPackagePath)
-		.find(j.ImportSpecifier)
-		.find(j.Identifier)
-		.filter((identifier) => {
-			if (identifier.value.name === currentName) {
-				return true;
-			}
-			if (identifier.value.name === existingAlias) {
-				return true;
-			}
-			return false;
-		})
-		.remove();
-
-	// Check to see if need to create new package path
-	// Try create an import declaration just before the old import
-	tryCreateImport({
-		j,
-		base,
-		relativeToPackage: oldPackagePath,
-		packageName: newPackagePath,
-	});
-
-	if (option.type === 'keep-name') {
-		const newSpecifier: ImportSpecifier | ImportDefaultSpecifier = (() => {
-			if (option.behaviour === 'keep-as-named-import') {
-				if (existingAlias) {
-					return j.importSpecifier(j.identifier(desiredName), j.identifier(existingAlias));
-				}
-
-				return j.importSpecifier(j.identifier(desiredName));
-			}
-
-			// moving to default specifier
-			return j.importDefaultSpecifier(j.identifier(existingAlias || desiredName));
-		})();
-
-		// We don't need to touch anything else in the file
-
-		addToImport({
-			j,
-			base,
-			importSpecifier: newSpecifier,
-			packageName: newPackagePath,
-		});
-		return;
-	}
-
-	const isNewNameAvailable: boolean =
-		base.find(j.Identifier).filter((i) => i.value.name === option.newName).length === 0;
-
-	const newSpecifier: ImportSpecifier = (() => {
-		if (existingAlias) {
-			return j.importSpecifier(j.identifier(desiredName), j.identifier(existingAlias));
-		}
-
-		if (isNewNameAvailable) {
-			return j.importSpecifier(j.identifier(desiredName));
-		}
-
-		// new type name is not available: need to use a new alias
-		return j.importSpecifier(j.identifier(desiredName), j.identifier(option.fallbackNameAlias));
-	})();
-
-	addToImport({
-		j,
-		base,
-		importSpecifier: newSpecifier,
-		packageName: newPackagePath,
-	});
-
-	// Change usages of old type in file
-	base
-		.find(j.Identifier)
-		.filter((identifier) => identifier.value.name === option.oldName)
-		.replaceWith(j.identifier(isNewNameAvailable ? option.newName : option.fallbackNameAlias));
-}

package/codemods/readme.md

@@ -1 +0,0 @@
-We are using the `optimistic-` prefix so that the optimistic codemod won't be run in branch deploys