@wise/wds-codemods 0.0.1-experimental-cbae00f → 0.0.1-experimental-926a862

package/src/transforms/helpers/__tests__/jsxElementUtils.test.ts

@@ -1,130 +0,0 @@
-import jscodeshift, { type JSXAttribute, type JSXElement, JSXIdentifier } from 'jscodeshift';
-
-import {
-  addAttributesIfMissing,
-  hasAttribute,
-  hasAttributeOnElement,
-  setNameIfJSXIdentifier,
-} from '../jsxElementUtils';
-
-describe('jsxElementUtils', () => {
-  function getRoot(source: string) {
-    return jscodeshift(source);
-  }
-
-  describe('setNameIfJSXIdentifier', () => {
-    it('renames JSXIdentifier element name', () => {
-      const source = `<OldName />`;
-      const root = getRoot(source);
-      const element = (root.findJSXElements('OldName').at(0).get() as { node: JSXElement }).node;
-      const result = setNameIfJSXIdentifier(element.openingElement.name, 'NewName');
-      expect(result).toMatchObject({ type: 'JSXIdentifier', name: 'NewName' });
-    });
-
-    it('returns the same element if not JSXIdentifier', () => {
-      const source = `<A.B />`;
-      const root = getRoot(source);
-      // Find the first JSXElement (which will be <A.B />)
-      const found = root.find(jscodeshift.JSXElement);
-      if (found.length === 0) {
-        throw new Error('No JSX elements found for A.B');
-      }
-      const element = (found.at(0).get() as { node: JSXElement }).node;
-      const result = setNameIfJSXIdentifier(element.openingElement.name, 'NewName');
-      expect(result).toEqual(element.openingElement.name);
-    });
-
-    it('returns undefined if elementName is undefined', () => {
-      const result = setNameIfJSXIdentifier(undefined, 'NewName');
-      expect(result).toBeUndefined();
-    });
-  });
-
-  describe('hasAttribute', () => {
-    it('returns true if attribute with given name exists', () => {
-      const source = `<div foo bar />`;
-      const root = getRoot(source);
-      const element = root.findJSXElements('div').nodes()[0];
-      expect(hasAttribute(element.openingElement.attributes, 'foo')).toBe(true);
-      expect(hasAttribute(element.openingElement.attributes, 'bar')).toBe(true);
-    });
-
-    it('returns false if attribute with given name does not exist', () => {
-      const source = `<div foo />`;
-      const root = getRoot(source);
-      const element = root.findJSXElements('div').nodes()[0];
-      expect(hasAttribute(element.openingElement.attributes, 'baz')).toBe(false);
-    });
-
-    it('ignores JSXSpreadAttribute and returns false if no matching JSXAttribute', () => {
-      const source = `<div {...props} />`;
-      const root = getRoot(source);
-      const element = root.findJSXElements('div').nodes()[0];
-      expect(hasAttribute(element.openingElement.attributes, 'foo')).toBe(false);
-    });
-
-    it('returns false if attributes is undefined or not array', () => {
-      expect(hasAttribute(undefined, 'foo')).toBe(false);
-      expect(hasAttribute(null as never, 'foo')).toBe(false);
-      expect(hasAttribute([], 'foo')).toBe(false);
-    });
-  });
-
-  describe('hasAttributeOnElement', () => {
-    it('returns true if openingElement has attribute', () => {
-      const source = `<div foo />`;
-      const root = getRoot(source);
-      const element = root.findJSXElements('div').nodes()[0];
-      expect(hasAttributeOnElement(element.openingElement, 'foo')).toBe(true);
-    });
-
-    it('returns false if openingElement does not have attribute', () => {
-      const source = `<div bar />`;
-      const root = getRoot(source);
-      const element = root.findJSXElements('div').nodes()[0];
-      expect(hasAttributeOnElement(element.openingElement, 'foo')).toBe(false);
-    });
-  });
-
-  describe('addAttributesIfMissing', () => {
-    it('adds attributes if missing', () => {
-      const source = `<div foo />`;
-      const root = getRoot(source);
-      const element = root.findJSXElements('div').nodes()[0];
-      const j = jscodeshift;
-      const newAttr = j.jsxAttribute(j.jsxIdentifier('bar'));
-      addAttributesIfMissing(j, element.openingElement, [{ attribute: newAttr, name: 'bar' }]);
-      expect(hasAttributeOnElement(element.openingElement, 'bar')).toBe(true);
-    });
-
-    it('does not add attribute if already present', () => {
-      const source = `<div foo />`;
-      const root = getRoot(source);
-      const element = root.findJSXElements('div').nodes()[0];
-      const j = jscodeshift;
-      const existingAttr = element.openingElement.attributes?.find(
-        (attr) =>
-          attr.type === 'JSXAttribute' &&
-          attr.name.type === 'JSXIdentifier' &&
-          attr.name.name === 'foo',
-      ) as JSXAttribute;
-      addAttributesIfMissing(j, element.openingElement, [{ attribute: existingAttr, name: 'foo' }]);
-      // attributes length should remain 1
-      expect(
-        element.openingElement.attributes?.filter((attr) => attr.type === 'JSXAttribute').length,
-      ).toBe(1);
-    });
-
-    it('does nothing if openingElement.attributes is not an array', () => {
-      const source = `<div />`;
-      const root = getRoot(source);
-      const element = root.findJSXElements('div').nodes()[0];
-      const j = jscodeshift;
-      element.openingElement.attributes = null as never;
-      const newAttr = j.jsxAttribute(j.jsxIdentifier('bar'));
-      expect(() =>
-        addAttributesIfMissing(j, element.openingElement, [{ attribute: newAttr, name: 'bar' }]),
-      ).not.toThrow();
-    });
-  });
-});

package/src/transforms/helpers/__tests__/jsxReportingUtils.test.ts

@@ -1,265 +0,0 @@
-import type { JSCodeshift, JSXAttribute, JSXElement } from 'jscodeshift';
-
-import { CodemodReporter, createReporter } from '../jsxReportingUtils';
-
-describe('CodemodReporter', () => {
-  let issues: string[];
-  let reporter: CodemodReporter;
-  let mockJ: JSCodeshift;
-
-  beforeEach(() => {
-    issues = [];
-
-    // Create a proper JSCodeshift mock
-    mockJ = Object.assign(
-      jest.fn(() => ({
-        find: jest.fn(),
-        toSource: jest.fn(() => 'mockedSource'),
-      })),
-      {
-        toSource: jest.fn(() => 'mockedSource'),
-        types: {},
-        match: jest.fn(),
-        template: jest.fn(),
-        registerMethods: jest.fn(),
-      },
-    ) as unknown as JSCodeshift;
-
-    reporter = createReporter(mockJ, issues);
-  });
-
-  // Helper function to create properly typed mock elements
-  const createMockElement = (componentName: string, line = 42): JSXElement =>
-    ({
-      type: 'JSXElement',
-      openingElement: {
-        type: 'JSXOpeningElement',
-        name: { type: 'JSXIdentifier', name: componentName },
-        attributes: [],
-        selfClosing: false,
-      },
-      closingElement: null,
-      children: [],
-      loc: { start: { line, column: 0 }, end: { line, column: 0 } },
-    }) as unknown as JSXElement;
-
-  describe('createReporter', () => {
-    it('should create a reporter instance', () => {
-      expect(reporter).toBeInstanceOf(CodemodReporter);
-    });
-  });
-
-  describe('reportElement', () => {
-    it('should report element issues', () => {
-      const mockElement = createMockElement('Button', 42);
-
-      reporter.reportElement(mockElement, 'has some issue');
-      expect(issues).toHaveLength(1);
-      expect(issues[0]).toBe('Manual review required: <Button> at line 42 has some issue.');
-    });
-  });
-
-  describe('reportProp', () => {
-    it('should report prop issues', () => {
-      const mockElement = createMockElement('Button', 42);
-
-      reporter.reportProp(mockElement, 'size', 'has invalid value');
-      expect(issues).toHaveLength(1);
-      expect(issues[0]).toBe(
-        'Manual review required: prop "size" on <Button> at line 42 has invalid value.',
-      );
-    });
-  });
-
-  describe('reportAttribute', () => {
-    it('should report attribute issues with default reason', () => {
-      const mockElement = createMockElement('Button', 42);
-
-      const mockAttr = {
-        type: 'JSXAttribute',
-        name: { type: 'JSXIdentifier', name: 'size' },
-        value: {
-          type: 'JSXExpressionContainer',
-          expression: { type: 'Identifier', name: 'someVar' },
-        },
-        loc: { start: { line: 42, column: 0 }, end: { line: 42, column: 0 } },
-      } as unknown as JSXAttribute;
-
-      reporter.reportAttribute(mockAttr, mockElement);
-      expect(issues).toHaveLength(1);
-      expect(issues[0]).toContain('prop "size" on <Button> at line 42');
-    });
-
-    it('should report attribute issues with custom reason', () => {
-      const mockElement = createMockElement('Button', 42);
-
-      const mockAttr = {
-        type: 'JSXAttribute',
-        name: { type: 'JSXIdentifier', name: 'size' },
-        value: { type: 'StringLiteral', value: 'large' },
-        loc: { start: { line: 42, column: 0 }, end: { line: 42, column: 0 } },
-      } as unknown as JSXAttribute;
-
-      reporter.reportAttribute(mockAttr, mockElement, 'custom reason');
-      expect(issues).toHaveLength(1);
-      expect(issues[0]).toBe(
-        'Manual review required: prop "size" on <Button> at line 42 custom reason.',
-      );
-    });
-  });
-
-  describe('reportSpreadProps', () => {
-    it('should report spread props issue', () => {
-      const mockElement = createMockElement('Button', 42);
-
-      reporter.reportSpreadProps(mockElement);
-      expect(issues).toHaveLength(1);
-      expect(issues[0]).toBe(
-        'Manual review required: <Button> at line 42 contains spread props that need manual review.',
-      );
-    });
-  });
-
-  describe('reportPropWithChildren', () => {
-    it('should report prop with children issue', () => {
-      const mockElement = createMockElement('Button', 42);
-
-      reporter.reportPropWithChildren(mockElement, 'text');
-      expect(issues).toHaveLength(1);
-      expect(issues[0]).toBe(
-        'Manual review required: prop "text" on <Button> at line 42 conflicts with children - both "text" prop and children are present.',
-      );
-    });
-  });
-
-  describe('reportUnsupportedValue', () => {
-    it('should report unsupported value issue', () => {
-      const mockElement = createMockElement('Button', 42);
-
-      reporter.reportUnsupportedValue(mockElement, 'size', 'huge');
-      expect(issues).toHaveLength(1);
-      expect(issues[0]).toBe(
-        'Manual review required: prop "size" on <Button> at line 42 has unsupported value "huge".',
-      );
-    });
-  });
-
-  describe('reportAmbiguousExpression', () => {
-    it('should report ambiguous expression issue', () => {
-      const mockElement = createMockElement('Button', 42);
-
-      reporter.reportAmbiguousExpression(mockElement, 'size');
-      expect(issues).toHaveLength(1);
-      expect(issues[0]).toBe(
-        'Manual review required: prop "size" on <Button> at line 42 contains a complex expression that needs manual review.',
-      );
-    });
-  });
-
-  describe('reportAmbiguousChildren', () => {
-    it('should report ambiguous children issue', () => {
-      const mockElement = createMockElement('Button', 42);
-
-      reporter.reportAmbiguousChildren(mockElement, 'icon');
-      expect(issues).toHaveLength(1);
-      expect(issues[0]).toBe(
-        'Manual review required: <Button> at line 42 contains ambiguous icon that needs manual review.',
-      );
-    });
-  });
-
-  describe('reportDeprecatedProp', () => {
-    it('should report deprecated prop without alternative', () => {
-      const mockElement = createMockElement('Button', 42);
-
-      reporter.reportDeprecatedProp(mockElement, 'flat');
-      expect(issues).toHaveLength(1);
-      expect(issues[0]).toBe(
-        'Manual review required: prop "flat" on <Button> at line 42 is deprecated.',
-      );
-    });
-
-    it('should report deprecated prop with alternative', () => {
-      const mockElement = createMockElement('Button', 42);
-
-      reporter.reportDeprecatedProp(mockElement, 'flat', 'variant="text"');
-      expect(issues).toHaveLength(1);
-      expect(issues[0]).toBe(
-        'Manual review required: prop "flat" on <Button> at line 42 is deprecated Use variant="text" instead.',
-      );
-    });
-  });
-
-  describe('reportMissingRequiredProp', () => {
-    it('should report missing required prop', () => {
-      const mockElement = createMockElement('Button', 42);
-
-      reporter.reportMissingRequiredProp(mockElement, 'children');
-      expect(issues).toHaveLength(1);
-      expect(issues[0]).toBe(
-        'Manual review required: prop "children" on <Button> at line 42 is required but missing.',
-      );
-    });
-  });
-
-  describe('reportConflictingProps', () => {
-    it('should report conflicting props', () => {
-      const mockElement = createMockElement('Button', 42);
-
-      reporter.reportConflictingProps(mockElement, ['size', 'fullWidth']);
-      expect(issues).toHaveLength(1);
-      expect(issues[0]).toBe(
-        'Manual review required: <Button> at line 42 has conflicting props: "size", "fullWidth" cannot be used together.',
-      );
-    });
-  });
-
-  describe('reportAttributeIssues', () => {
-    it('should not report anything with no attributes', () => {
-      const mockElement = createMockElement('Button', 42);
-
-      reporter.reportAttributeIssues(mockElement);
-      expect(issues).toHaveLength(0);
-    });
-
-    it('should report spread props', () => {
-      const mockElement = {
-        ...createMockElement('Button', 42),
-        openingElement: {
-          ...createMockElement('Button', 42).openingElement,
-          attributes: [
-            { type: 'JSXSpreadAttribute', argument: { type: 'Identifier', name: 'props' } },
-          ],
-        },
-      } as unknown as JSXElement;
-
-      reporter.reportAttributeIssues(mockElement);
-      expect(issues).toHaveLength(1);
-      expect(issues[0]).toContain('spread props');
-    });
-
-    it('should report expression container attributes', () => {
-      const mockElement = {
-        ...createMockElement('Button', 42),
-        openingElement: {
-          ...createMockElement('Button', 42).openingElement,
-          attributes: [
-            {
-              type: 'JSXAttribute',
-              name: { type: 'JSXIdentifier', name: 'size' },
-              value: {
-                type: 'JSXExpressionContainer',
-                expression: { type: 'Identifier', name: 'someVar' },
-              },
-              loc: { start: { line: 42, column: 0 }, end: { line: 42, column: 0 } },
-            },
-          ],
-        },
-      } as unknown as JSXElement;
-
-      reporter.reportAttributeIssues(mockElement);
-      expect(issues).toHaveLength(1);
-      expect(issues[0]).toContain('prop "size" on <Button> at line 42');
-    });
-  });
-});

package/src/transforms/helpers/createTestTransform.ts

@@ -1,18 +0,0 @@
-import type { Options, Transform } from 'jscodeshift';
-import { applyTransform, type TestOptions } from 'jscodeshift/src/testUtils';
-
-/**
- * This function creates a test transform function that applies a given transformer to the input code.
- * It uses the 'tsx' parser to support both TypeScript and JSX syntax.
- *
- * The transform function is used to modify the input code based on the provided transformer.
- */
-function createTestTransform(transformer: Transform) {
-  const options: Options = {};
-  // Use 'tsx' parser to support both TypeScript and JSX syntax
-  const testOptions: TestOptions = { parser: 'tsx' };
-  return (input: { path?: string; source: string }) =>
-    applyTransform(transformer, options, input, testOptions);
-}
-
-export default createTestTransform;

package/src/transforms/helpers/hasImport.ts

@@ -1,60 +0,0 @@
-import type { Collection, JSCodeshift } from 'jscodeshift';
-
-/**
- * Checks if a specific import exists in the given root collection and provides
- * a method to remove it if found.
- */
-function hasImport(
-  root: Collection,
-  sourceValue: string,
-  importName: string,
-  j: JSCodeshift,
-): { exists: boolean; remove: () => void } {
-  const importDeclarations = root.find(j.ImportDeclaration, {
-    source: { value: sourceValue },
-  });
-
-  if (importDeclarations.size() === 0) {
-    return {
-      exists: false,
-      remove: () => {},
-    };
-  }
-
-  const namedImport = importDeclarations.find(j.ImportSpecifier, {
-    imported: { name: importName },
-  });
-
-  const defaultImport = importDeclarations.find(j.ImportDefaultSpecifier, {
-    local: { name: importName },
-  });
-
-  const exists = namedImport.size() > 0 || defaultImport.size() > 0;
-
-  const remove = () => {
-    importDeclarations.forEach((path) => {
-      const filteredSpecifiers =
-        path.node.specifiers?.filter((specifier) => {
-          if (specifier.type === 'ImportSpecifier' && specifier.imported.name === importName) {
-            return false;
-          }
-          if (specifier.type === 'ImportDefaultSpecifier' && specifier.local?.name === importName) {
-            return false;
-          }
-          return true;
-        }) ?? [];
-
-      if (filteredSpecifiers.length === 0) {
-        path.prune();
-      } else {
-        j(path).replaceWith(
-          j.importDeclaration(filteredSpecifiers, path.node.source, path.node.importKind),
-        );
-      }
-    });
-  };
-
-  return { exists, remove };
-}
-
-export default hasImport;

package/src/transforms/helpers/iconUtils.ts

@@ -1,87 +0,0 @@
-import type { JSCodeshift, JSXElement, JSXExpressionContainer } from 'jscodeshift';
-
-/**
- * Process children of a JSX element to detect icon components and add iconStart or iconEnd attributes accordingly.
- * This is specific to icon handling but can be reused in codemods dealing with icon children.
- */
-const processIconChildren = (
-  j: JSCodeshift,
-  children: (JSXElement | JSXExpressionContainer | unknown)[] | undefined,
-  iconImports: Set<string>,
-  openingElement: JSXElement['openingElement'],
-) => {
-  if (!children || !openingElement.attributes) return;
-
-  const unwrapJsxElement = (node: unknown): JSXElement | unknown => {
-    if (
-      typeof node === 'object' &&
-      node !== null &&
-      'type' in node &&
-      node.type === 'JSXExpressionContainer' &&
-      j.JSXElement.check((node as JSXExpressionContainer).expression)
-    ) {
-      return (node as JSXExpressionContainer).expression;
-    }
-    return node;
-  };
-
-  const totalChildren = children.length;
-
-  // Find index of icon child
-  const iconChildIndex = children.findIndex((child) => {
-    const unwrapped = unwrapJsxElement(child);
-    return (
-      j.JSXElement.check(unwrapped) &&
-      unwrapped.openingElement.name.type === 'JSXIdentifier' &&
-      iconImports.has(unwrapped.openingElement.name.name)
-    );
-  });
-
-  if (iconChildIndex === -1) return;
-
-  const iconChild = unwrapJsxElement(children[iconChildIndex]) as JSXElement;
-
-  if (!iconChild || iconChild.openingElement.name.type !== 'JSXIdentifier') return;
-
-  const iconName = iconChild.openingElement.name.name;
-
-  // Determine if icon is closer to start or end
-  const distanceToStart = iconChildIndex;
-  const distanceToEnd = totalChildren - 1 - iconChildIndex;
-  const iconPropName = distanceToStart <= distanceToEnd ? 'addonStart' : 'addonEnd';
-
-  // Build: { type: 'icon', value: <IconName /> }
-  const iconObject = j.objectExpression([
-    j.property('init', j.identifier('type'), j.literal('icon')),
-    j.property('init', j.identifier('value'), iconChild),
-  ]);
-  const iconProp = j.jsxAttribute(
-    j.jsxIdentifier(iconPropName),
-    j.jsxExpressionContainer(iconObject),
-  );
-
-  openingElement.attributes.push(iconProp);
-
-  // Remove the icon child
-  children.splice(iconChildIndex, 1);
-
-  // Helper to check if a child is whitespace-only JSXText
-  const isWhitespaceJsxText = (node: unknown): boolean => {
-    return (
-      typeof node === 'object' &&
-      node !== null &&
-      (node as { type?: unknown }).type === 'JSXText' &&
-      typeof (node as { value?: string }).value === 'string' &&
-      (node as { value?: string }).value!.trim() === ''
-    );
-  };
-
-  // Remove adjacent whitespace-only JSXText node if any
-  if (iconChildIndex - 1 >= 0 && isWhitespaceJsxText(children[iconChildIndex - 1])) {
-    children.splice(iconChildIndex - 1, 1);
-  } else if (isWhitespaceJsxText(children[iconChildIndex])) {
-    children.splice(iconChildIndex, 1);
-  }
-};
-
-export default processIconChildren;

package/src/transforms/helpers/index.ts

@@ -1,5 +0,0 @@
-export { default as createTestTransform } from './createTestTransform';
-export { default as hasImport } from './hasImport';
-export { default as processIconChildren } from './iconUtils';
-export * from './jsxElementUtils';
-export * from './jsxReportingUtils';

package/src/transforms/helpers/jsxElementUtils.ts

@@ -1,67 +0,0 @@
-import type {
-  JSCodeshift,
-  JSXAttribute,
-  JSXElement,
-  JSXIdentifier,
-  JSXMemberExpression,
-  JSXNamespacedName,
-  JSXSpreadAttribute,
-} from 'jscodeshift';
-
-/**
- * Rename a JSX element name if it is a JSXIdentifier.
- */
-export const setNameIfJSXIdentifier = (
-  elementName: JSXIdentifier | JSXNamespacedName | JSXMemberExpression | undefined,
-  newName: string,
-): JSXIdentifier | JSXNamespacedName | JSXMemberExpression | undefined => {
-  if (elementName && elementName.type === 'JSXIdentifier') {
-    return { ...elementName, name: newName };
-  }
-  return elementName;
-};
-
-/**
- * Check if a list of attributes contains a specific attribute by name.
- */
-export const hasAttribute = (
-  attributes: (JSXAttribute | JSXSpreadAttribute)[] | undefined,
-  attributeName: string,
-): boolean => {
-  return (
-    Array.isArray(attributes) &&
-    attributes.some(
-      (attr): attr is JSXAttribute =>
-        attr.type === 'JSXAttribute' &&
-        attr.name.type === 'JSXIdentifier' &&
-        attr.name.name === attributeName,
-    )
-  );
-};
-
-/**
- * Check if a JSX element's openingElement has a specific attribute.
- */
-export const hasAttributeOnElement = (
-  element: JSXElement['openingElement'],
-  attributeName: string,
-): boolean => {
-  return hasAttribute(element.attributes, attributeName);
-};
-
-/**
- * Add specified attributes to a JSX element's openingElement if they are not already present.
- */
-export const addAttributesIfMissing = (
-  j: JSCodeshift,
-  openingElement: JSXElement['openingElement'],
-  attributesToAdd: { attribute: JSXAttribute; name: string }[],
-) => {
-  if (!Array.isArray(openingElement.attributes)) return;
-  const attrs = openingElement.attributes;
-  attributesToAdd.forEach(({ attribute, name }) => {
-    if (!hasAttributeOnElement(openingElement, name)) {
-      attrs.push(attribute);
-    }
-  });
-};