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

package/src/transforms/helpers/jsxReportingUtils.ts

@@ -1,224 +0,0 @@
-import type { ASTPath, JSCodeshift, JSXAttribute, JSXElement, Node } from 'jscodeshift';
-
-export interface ReporterOptions {
-  jscodeshift: JSCodeshift;
-  issues: string[];
-}
-
-/**
- * CodemodReporter is a utility class for reporting issues found during codemod transformations.
- * It provides methods to report issues related to JSX elements, props, and attributes.
- *
- * @example
- * ```typescript
- * const issues: string[] = [];
- * const reporter = createReporter(j, issues);
- *
- * // Report a deprecated prop
- * reporter.reportDeprecatedProp(buttonElement, 'flat', 'variant="text"');
- *
- * // Report complex expression that needs review
- * reporter.reportAmbiguousExpression(element, 'size');
- *
- * // Auto-detect common issues
- * reporter.reportAttributeIssues(element);
- * ```
- */
-export class CodemodReporter {
-  private readonly j: JSCodeshift;
-  private readonly issues: string[];
-
-  constructor(options: ReporterOptions) {
-    this.j = options.jscodeshift;
-    this.issues = options.issues;
-  }
-
-  /**
-   * Reports an issue with a JSX element
-   */
-  reportElement(element: JSXElement | ASTPath<JSXElement>, reason: string): void {
-    const node = this.getNode(element);
-    const componentName = this.getComponentName(node);
-    const line = this.getLineNumber(node);
-
-    this.addIssue(`Manual review required: <${componentName}> at line ${line} ${reason}.`);
-  }
-
-  /**
-   * Reports an issue with a specific prop
-   */
-  reportProp(element: JSXElement | ASTPath<JSXElement>, propName: string, reason: string): void {
-    const node = this.getNode(element);
-    const componentName = this.getComponentName(node);
-    const line = this.getLineNumber(node);
-
-    this.addIssue(
-      `Manual review required: prop "${propName}" on <${componentName}> at line ${line} ${reason}.`,
-    );
-  }
-
-  /**
-   * Reports an issue with a JSX attribute directly
-   */
-  reportAttribute(
-    attr: JSXAttribute,
-    element: JSXElement | ASTPath<JSXElement>,
-    reason?: string,
-  ): void {
-    const node = this.getNode(element);
-    const componentName = this.getComponentName(node);
-    const propName = this.getAttributeName(attr);
-    const line = this.getLineNumber(attr) || this.getLineNumber(node);
-
-    const defaultReason = this.getAttributeReason(attr);
-    const finalReason = reason || defaultReason;
-
-    this.addIssue(
-      `Manual review required: prop "${propName}" on <${componentName}> at line ${line} ${finalReason}.`,
-    );
-  }
-
-  /**
-   * Reports spread props on an element
-   */
-  reportSpreadProps(element: JSXElement | ASTPath<JSXElement>): void {
-    this.reportElement(element, 'contains spread props that need manual review');
-  }
-
-  /**
-   * Reports conflicting prop and children
-   */
-  reportPropWithChildren(element: JSXElement | ASTPath<JSXElement>, propName: string): void {
-    this.reportProp(
-      element,
-      propName,
-      `conflicts with children - both "${propName}" prop and children are present`,
-    );
-  }
-
-  /**
-   * Reports unsupported prop value
-   */
-  reportUnsupportedValue(
-    element: JSXElement | ASTPath<JSXElement>,
-    propName: string,
-    value: string,
-  ): void {
-    this.reportProp(element, propName, `has unsupported value "${value}"`);
-  }
-
-  /**
-   * Reports ambiguous expression in prop
-   */
-  reportAmbiguousExpression(element: JSXElement | ASTPath<JSXElement>, propName: string): void {
-    this.reportProp(element, propName, 'contains a complex expression that needs manual review');
-  }
-
-  /**
-   * Reports ambiguous children (like dynamic icons)
-   */
-  reportAmbiguousChildren(element: JSXElement | ASTPath<JSXElement>, childType = 'content'): void {
-    this.reportElement(element, `contains ambiguous ${childType} that needs manual review`);
-  }
-
-  /**
-   * Reports deprecated prop usage
-   */
-  reportDeprecatedProp(
-    element: JSXElement | ASTPath<JSXElement>,
-    propName: string,
-    alternative?: string,
-  ): void {
-    const suggestion = alternative ? ` Use ${alternative} instead` : '';
-    this.reportProp(element, propName, `is deprecated${suggestion}`);
-  }
-
-  /**
-   * Reports missing required prop
-   */
-  reportMissingRequiredProp(element: JSXElement | ASTPath<JSXElement>, propName: string): void {
-    this.reportProp(element, propName, 'is required but missing');
-  }
-
-  /**
-   * Reports conflicting props
-   */
-  reportConflictingProps(element: JSXElement | ASTPath<JSXElement>, propNames: string[]): void {
-    const propList = propNames.map((name) => `"${name}"`).join(', ');
-    this.reportElement(element, `has conflicting props: ${propList} cannot be used together`);
-  }
-
-  /**
-   * Auto-detects and reports common attribute issues
-   */
-  reportAttributeIssues(element: JSXElement | ASTPath<JSXElement>): void {
-    const node = this.getNode(element);
-    const { attributes } = node.openingElement;
-
-    if (!attributes) return;
-
-    // Check for spread props
-    if (attributes.some((attr) => attr.type === 'JSXSpreadAttribute')) {
-      this.reportSpreadProps(element);
-    }
-
-    // Check for complex expressions in attributes
-    attributes.forEach((attr) => {
-      if (attr.type === 'JSXAttribute' && attr.value?.type === 'JSXExpressionContainer') {
-        this.reportAttribute(attr, element);
-      }
-    });
-  }
-
-  // Private helper methods
-  private getNode(element: JSXElement | ASTPath<JSXElement>): JSXElement {
-    return 'node' in element ? element.node : element;
-  }
-
-  private getComponentName(node: JSXElement): string {
-    const { name } = node.openingElement;
-    if (name.type === 'JSXIdentifier') {
-      return name.name;
-    }
-    // Handle JSXMemberExpression, JSXNamespacedName, etc.
-    return this.j(name).toSource();
-  }
-
-  private getLineNumber(node: JSXElement | JSXAttribute | Node): string {
-    return node.loc?.start.line?.toString() || 'unknown';
-  }
-
-  private getAttributeName(attr: JSXAttribute): string {
-    if (attr.name.type === 'JSXIdentifier') {
-      return attr.name.name;
-    }
-    return this.j(attr.name).toSource();
-  }
-
-  private getAttributeReason(attr: JSXAttribute): string {
-    if (!attr.value) return 'has no value';
-
-    if (attr.value.type === 'JSXExpressionContainer') {
-      const expr = attr.value.expression;
-      const expressionType = expr.type.replace('Expression', '').toLowerCase();
-
-      // Show actual value for simple cases
-      if (expr.type === 'Identifier' || expr.type === 'MemberExpression') {
-        const valueText = this.j(expr).toSource();
-        return `contains a ${expressionType} (${valueText})`;
-      }
-
-      return `contains a complex ${expressionType} expression`;
-    }
-
-    return 'needs manual review';
-  }
-
-  private addIssue(message: string): void {
-    this.issues.push(message);
-  }
-}
-
-export const createReporter = (j: JSCodeshift, issues: string[]): CodemodReporter => {
-  return new CodemodReporter({ jscodeshift: j, issues });
-};

package/src/utils/__tests__/getOptions.test.ts

@@ -1,170 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import { confirm, input, select as list } from '@inquirer/prompts';
-
-import getOptions from '../getOptions';
-
-jest.mock('@inquirer/prompts', () => ({
-  select: jest.fn(),
-  input: jest.fn(),
-  confirm: jest.fn(),
-}));
-
-describe('getOptions', () => {
-  const transformFiles = ['fileA.js', 'fileB.ts', 'fileC.tsx'];
-
-  beforeEach(() => {
-    process.argv = ['node', 'script.js'];
-    (list as jest.Mock).mockClear();
-    (input as jest.Mock).mockClear();
-    (confirm as jest.Mock).mockClear();
-  });
-
-  it('should return options from command line arguments when provided', async () => {
-    process.argv = ['node', 'script.js', 'fileB.ts', './src', '--dry', '--print'];
-    const options = await getOptions(transformFiles);
-    expect(options).toEqual({
-      transformFile: 'fileB.ts',
-      targetPath: './src',
-      dry: true,
-      print: true,
-      gitignore: true,
-      ignorePattern: undefined,
-    });
-  });
-
-  it('should parse --ignore-pattern argument from CLI', async () => {
-    process.argv = [
-      'node',
-      'script.js',
-      'fileA.js',
-      './src',
-      '--ignore-pattern',
-      'node_modules/**',
-    ];
-    const options = await getOptions(transformFiles);
-    expect(options.ignorePattern).toBe('node_modules/**');
-  });
-
-  it('should parse --gitignore and --no-gitignore arguments from CLI and prioritize --gitignore', async () => {
-    process.argv = ['node', 'script.js', 'fileA.js', './src', '--gitignore', '--no-gitignore'];
-    const options = await getOptions(transformFiles);
-    expect(options.gitignore).toBe(true);
-
-    process.argv = ['node', 'script.js', 'fileA.js', './src', '--no-gitignore'];
-    const optionsNo = await getOptions(transformFiles);
-    expect(optionsNo.gitignore).toBe(false);
-  });
-
-  it('should prompt for ignorePattern and gitignore when no CLI args', async () => {
-    (list as jest.Mock).mockResolvedValue('fileB.ts');
-    (input as jest.Mock).mockResolvedValueOnce('./output').mockResolvedValueOnce('node_modules/**');
-    (confirm as jest.Mock)
-      .mockResolvedValueOnce(true)
-      .mockResolvedValueOnce(false)
-      .mockResolvedValueOnce(true);
-
-    const optionsPromise = getOptions(transformFiles);
-    const options = await optionsPromise;
-
-    expect(input).toHaveBeenCalledWith({
-      message: 'Enter ignore pattern(s) (comma separated) or leave empty:',
-      validate: expect.any(Function),
-    });
-    expect(confirm).toHaveBeenCalledWith({
-      message: 'Respect .gitignore files?',
-      default: true,
-    });
-    expect(options.ignorePattern).toBe('node_modules/**');
-    expect(options.gitignore).toBe(true);
-  });
-
-  it('should throw an error if transform file is invalid via command line', async () => {
-    process.argv = ['node', 'script.js', 'invalid.js', './dist'];
-    await expect(getOptions(transformFiles)).rejects.toThrow('Invalid transform file specified.');
-  });
-
-  it('should throw an error if target path is empty via command line', async () => {
-    process.argv = ['node', 'script.js', 'fileA.js', ''];
-    await expect(getOptions(transformFiles)).rejects.toThrow('Target path cannot be empty.');
-  });
-
-  it('should prompt for transform file, target path, dry mode, and print when no arguments are provided', async () => {
-    (list as jest.Mock).mockResolvedValue('fileB.ts');
-    (input as jest.Mock).mockResolvedValue('./output');
-    (confirm as jest.Mock).mockResolvedValueOnce(true).mockResolvedValueOnce(false);
-
-    const options = await getOptions(transformFiles);
-
-    expect(list).toHaveBeenCalledWith({
-      message: 'Select a codemod transform to run:',
-      choices: transformFiles.map((file) => ({ name: file, value: file })),
-    });
-    expect(input).toHaveBeenCalledWith({
-      message: 'Enter the target directory or file path to run codemod on:',
-      validate: expect.any(Function),
-    });
-    expect(confirm).toHaveBeenCalledWith({
-      message: 'Run in dry mode (no changes written to files)?',
-      default: true,
-    });
-    expect(confirm).toHaveBeenCalledWith({
-      message: 'Print transformed source to console?',
-      default: false,
-    });
-    expect(options).toEqual({
-      transformFile: 'fileB.ts',
-      targetPath: './output',
-      dry: true,
-      print: false,
-      gitignore: undefined,
-      ignorePattern: './output',
-    });
-  });
-
-  it('should handle target path validation error', async () => {
-    (list as jest.Mock).mockResolvedValue('fileA.js');
-    (input as jest.Mock).mockResolvedValueOnce('   ');
-    (confirm as jest.Mock).mockResolvedValue(true);
-
-    await getOptions(transformFiles);
-
-    expect(input).toHaveBeenCalledTimes(2);
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    const validateFn = (input as jest.Mock).mock.calls[0][0].validate!;
-    expect(validateFn('   ')).toBe('Target path cannot be empty');
-    expect(validateFn('./valid-path')).toBe(true); // Ensure valid input passes validation
-    expect(input).toHaveBeenCalledWith({
-      message: 'Enter the target directory or file path to run codemod on:',
-      validate: expect.any(Function),
-    });
-  });
-
-  it('should allow changing the default dry mode', async () => {
-    (list as jest.Mock).mockResolvedValue('fileC.tsx');
-    (input as jest.Mock).mockResolvedValue('./another-path');
-    (confirm as jest.Mock).mockResolvedValueOnce(false).mockResolvedValueOnce(false);
-
-    const options = await getOptions(transformFiles);
-
-    expect(confirm).toHaveBeenCalledWith({
-      message: 'Run in dry mode (no changes written to files)?',
-      default: true,
-    });
-    expect(options.dry).toBe(false);
-  });
-
-  it('should allow changing the default print mode', async () => {
-    (list as jest.Mock).mockResolvedValue('fileA.js');
-    (input as jest.Mock).mockResolvedValue('./yet-another-path');
-    (confirm as jest.Mock).mockResolvedValueOnce(true).mockResolvedValueOnce(true);
-
-    const options = await getOptions(transformFiles);
-
-    expect(confirm).toHaveBeenCalledWith({
-      message: 'Print transformed source to console?',
-      default: false,
-    });
-    expect(options.print).toBe(true);
-  });
-});

package/src/utils/__tests__/handleError.test.ts

@@ -1,18 +0,0 @@
-import handleError from '../handleError';
-
-describe('handleError', () => {
-  beforeEach(() => {
-    jest.spyOn(process, 'exit').mockImplementation(() => {
-      throw new Error('process.exit called');
-    });
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  it('should throw an error with the given message', () => {
-    const errorMessage = 'Test error message';
-    expect(() => handleError(errorMessage)).toThrow(new Error('process.exit called'));
-  });
-});

package/src/utils/__tests__/loadTransformModules.test.ts

@@ -1,51 +0,0 @@
-import { promises as fs } from 'fs';
-
-import loadTransformModules from '../loadTransformModules';
-
-jest.mock('fs', () => ({
-  promises: {
-    readdir: jest.fn(),
-  },
-}));
-
-jest.mock('path', () => ({
-  join: jest.fn((...args) => args.join('/')),
-}));
-
-jest.mock(
-  '/mock/transforms/transformA.js',
-  () => ({
-    default: { default: 'transformA' },
-  }),
-  { virtual: true },
-);
-
-jest.mock(
-  '/mock/transforms/transformB.js',
-  () => ({
-    default: { default: 'transformB' },
-  }),
-  { virtual: true },
-);
-
-describe('loadTransformModules - simplified test', () => {
-  it('should return transformModules and transformFiles correctly', async () => {
-    const mockTransformsDir = '/mock/transforms';
-
-    const mockFiles = ['transformA.js', 'transformB.js'];
-    (fs.readdir as jest.Mock).mockResolvedValue(mockFiles);
-
-    const { transformModules, transformFiles } = await loadTransformModules(mockTransformsDir);
-
-    expect(transformModules).toEqual({
-      'transformA.js': {
-        default: 'transformA',
-      },
-      'transformB.js': {
-        default: 'transformB',
-      },
-    });
-
-    expect(transformFiles).toEqual(['transformA', 'transformB']);
-  });
-});

package/src/utils/__tests__/reportManualReview.test.ts

@@ -1,42 +0,0 @@
-import fs from 'node:fs/promises';
-
-import path from 'path';
-
-import reportManualReview from '../reportManualReview';
-
-const REPORT_PATH = path.resolve(process.cwd(), 'codemod-report.txt');
-
-describe('reportManualReview', () => {
-  beforeEach(async () => {
-    try {
-      await fs.access(REPORT_PATH);
-      await fs.unlink(REPORT_PATH);
-    } catch {
-      // File doesn't exist, that's fine
-    }
-    await fs.writeFile(REPORT_PATH, '', 'utf8');
-  });
-
-  afterEach(async () => {
-    try {
-      await fs.access(REPORT_PATH);
-      await fs.unlink(REPORT_PATH);
-    } catch {
-      // File doesn't exist, that's fine
-    }
-  });
-
-  it('writes a manual review entry to the report file', async () => {
-    await reportManualReview('src/file.tsx', 'Manual review required: something at line 10');
-    const content = await fs.readFile(REPORT_PATH, 'utf8');
-    expect(content).toContain('[src/file.tsx:10] Manual review required: something');
-  });
-
-  it('appends multiple manual review entries', async () => {
-    await reportManualReview('src/file1.tsx', 'Manual review required: issue 1');
-    await reportManualReview('src/file2.tsx', 'Manual review required: issue 2');
-    const content = await fs.readFile(REPORT_PATH, 'utf8');
-    expect(content).toContain('[src/file1.tsx] Manual review required: issue 1');
-    expect(content).toContain('[src/file2.tsx] Manual review required: issue 2');
-  });
-});

package/src/utils/getOptions.ts

@@ -1,63 +0,0 @@
-import { confirm, input, select as list } from '@inquirer/prompts';
-
-async function getOptions(transformFiles: string[]) {
-  const args = process.argv.slice(2);
-  if (args.length > 0) {
-    const [transformFile, targetPath] = args;
-    const dry = args.includes('--dry') || args.includes('--dry-run');
-    const print = args.includes('--print');
-    const ignorePatternIndex = args.findIndex((arg) => arg === '--ignore-pattern');
-    let ignorePattern: string | undefined;
-    if (ignorePatternIndex !== -1 && args.length > ignorePatternIndex + 1) {
-      ignorePattern = args[ignorePatternIndex + 1];
-    }
-    const gitignore = args.includes('--gitignore');
-    const noGitignore = args.includes('--no-gitignore');
-
-    if (!transformFile || !transformFiles.includes(transformFile)) {
-      throw new Error('Invalid transform file specified.');
-    }
-    if (!targetPath) {
-      throw new Error('Target path cannot be empty.');
-    }
-
-    // If both --gitignore and --no-gitignore are specified, prioritize --gitignore
-    const useGitignore = !!(gitignore || (!gitignore && !noGitignore));
-
-    return { transformFile, targetPath, dry, print, ignorePattern, gitignore: useGitignore };
-  }
-
-  const transformFile = await list({
-    message: 'Select a codemod transform to run:',
-    choices: transformFiles.map((file) => ({ name: file, value: file })),
-  });
-
-  const targetPath = await input({
-    message: 'Enter the target directory or file path to run codemod on:',
-    validate: (value) => value.trim() !== '' || 'Target path cannot be empty',
-  });
-
-  const dry = await confirm({
-    message: 'Run in dry mode (no changes written to files)?',
-    default: true,
-  });
-
-  const print = await confirm({
-    message: 'Print transformed source to console?',
-    default: false,
-  });
-
-  const ignorePattern = await input({
-    message: 'Enter ignore pattern(s) (comma separated) or leave empty:',
-    validate: (value) => true,
-  });
-
-  const gitignore = await confirm({
-    message: 'Respect .gitignore files?',
-    default: true,
-  });
-
-  return { transformFile, targetPath, dry, print, ignorePattern, gitignore };
-}
-
-export default getOptions;

package/src/utils/handleError.ts

@@ -1,6 +0,0 @@
-function handleError(message: string): void {
-  console.error(message);
-  process.exit(1);
-}
-
-export default handleError;

package/src/utils/index.ts

@@ -1,4 +0,0 @@
-export { default as getOptions } from './getOptions';
-export { default as handleError } from './handleError';
-export { default as loadTransformModules } from './loadTransformModules';
-export { default as reportManualReview } from './reportManualReview';

package/src/utils/loadTransformModules.ts

@@ -1,28 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-
-interface TransformModule {
-  default: {
-    default: unknown;
-  };
-}
-
-async function loadTransformModules(transformsDir: string) {
-  let transformModules: Record<string, unknown> = {};
-
-  const files = await fs.readdir(transformsDir);
-  const transformFiles = await Promise.all(
-    files
-      .filter((file) => file.endsWith('.js'))
-      .map(async (file) => {
-        const transformPath = path.join(transformsDir, file);
-        const transformModule = (await import(transformPath)) as TransformModule;
-        transformModules = { ...transformModules, [file]: transformModule.default.default };
-        return file.replace('.js', '');
-      }),
-  );
-
-  return { transformModules, transformFiles };
-}
-
-export default loadTransformModules;

package/src/utils/reportManualReview.ts

@@ -1,17 +0,0 @@
-import fs from 'node:fs/promises';
-
-import path from 'path';
-
-const REPORT_PATH = path.resolve(process.cwd(), 'codemod-report.txt');
-
-const reportManualReview = async (filePath: string, message: string): Promise<void> => {
-  const lineMatch = /at line (\d+)/u.exec(message);
-  const lineNumber = lineMatch?.[1];
-
-  const cleanMessage = message.replace(/ at line \d+/u, '');
-  const lineInfo = lineNumber ? `:${lineNumber}` : '';
-
-  await fs.appendFile(REPORT_PATH, `[${filePath}${lineInfo}] ${cleanMessage}\n`, 'utf8');
-};
-
-export default reportManualReview;