@reapit/elements 5.0.0-beta.71 → 5.0.0-beta.72

package/codemods/__tests__/runner.test.ts

@@ -1,530 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync, rmSync, readFileSync } from 'node:fs'
-import { join } from 'node:path'
-import { tmpdir } from 'node:os'
-import { findFiles, matchesPatterns, run } from '../runner'
-import type { Transform } from '../runner'
-
-let testDir: string
-
-beforeEach(() => {
-  // Create a temporary test directory
-  testDir = join(tmpdir(), `runner-test-${Date.now()}`)
-  mkdirSync(testDir, { recursive: true })
-})
-
-afterEach(() => {
-  // Clean up test directory
-  if (existsSync(testDir)) {
-    rmSync(testDir, { recursive: true, force: true })
-  }
-})
-
-describe('matchesPatterns', () => {
-  test('matches files with *.ext pattern', () => {
-    expect(matchesPatterns('file.ts', ['*.ts'])).toBe(true)
-    expect(matchesPatterns('file.tsx', ['*.tsx'])).toBe(true)
-    expect(matchesPatterns('file.js', ['*.js'])).toBe(true)
-  })
-
-  test('does not match files with wrong extension', () => {
-    expect(matchesPatterns('file.ts', ['*.tsx'])).toBe(false)
-    expect(matchesPatterns('file.js', ['*.ts'])).toBe(false)
-  })
-
-  test('matches with multiple patterns', () => {
-    const patterns = ['*.ts', '*.tsx']
-
-    expect(matchesPatterns('file.ts', patterns)).toBe(true)
-    expect(matchesPatterns('file.tsx', patterns)).toBe(true)
-    expect(matchesPatterns('file.js', patterns)).toBe(false)
-  })
-
-  test('matches exact filename', () => {
-    expect(matchesPatterns('specific-file.ts', ['specific-file.ts'])).toBe(true)
-    expect(matchesPatterns('other-file.ts', ['specific-file.ts'])).toBe(false)
-  })
-
-  test('matches with wildcard in middle of pattern', () => {
-    expect(matchesPatterns('test.spec.ts', ['*.spec.ts'])).toBe(true)
-    expect(matchesPatterns('file.test.ts', ['*.spec.ts'])).toBe(false)
-  })
-
-  test('rejects patterns that are too long (ReDoS protection)', () => {
-    const longPattern = '*'.repeat(200)
-    const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-
-    const result = matchesPatterns('file.ts', [longPattern])
-
-    expect(result).toBe(false)
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('potentially unsafe pattern'))
-
-    consoleSpy.mockRestore()
-  })
-
-  test('rejects patterns with excessive wildcards (ReDoS protection)', () => {
-    const pattern = '*.*.*.*.*.*.ts'
-    const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-
-    const result = matchesPatterns('file.ts', [pattern])
-
-    expect(result).toBe(false)
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('potentially unsafe pattern'))
-
-    consoleSpy.mockRestore()
-  })
-
-  test('rejects filenames that are too long', () => {
-    const longFilename = 'a'.repeat(600) + '.ts'
-    const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-
-    const result = matchesPatterns(longFilename, ['*test*.ts'])
-
-    expect(result).toBe(false)
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Filename too long'))
-
-    consoleSpy.mockRestore()
-  })
-
-  test('matches common file extensions', () => {
-    expect(matchesPatterns('Component.tsx', ['*.tsx', '*.ts', '*.jsx', '*.js'])).toBe(true)
-    expect(matchesPatterns('utils.ts', ['*.tsx', '*.ts', '*.jsx', '*.js'])).toBe(true)
-    expect(matchesPatterns('App.jsx', ['*.tsx', '*.ts', '*.jsx', '*.js'])).toBe(true)
-    expect(matchesPatterns('index.js', ['*.tsx', '*.ts', '*.jsx', '*.js'])).toBe(true)
-  })
-
-  test('returns false for empty pattern array', () => {
-    expect(matchesPatterns('file.ts', [])).toBe(false)
-  })
-
-  test('matches first matching pattern', () => {
-    const patterns = ['*.js', '*.ts', '*.tsx']
-
-    expect(matchesPatterns('file.ts', patterns)).toBe(true)
-  })
-})
-
-describe('findFiles', () => {
-  test('finds files matching patterns in directory', () => {
-    writeFileSync(join(testDir, 'file1.ts'), 'content')
-    writeFileSync(join(testDir, 'file2.tsx'), 'content')
-    writeFileSync(join(testDir, 'file3.js'), 'content')
-
-    const files = findFiles(testDir, ['*.ts', '*.tsx'])
-
-    expect(files).toHaveLength(2)
-    expect(files).toContainEqual(join(testDir, 'file1.ts'))
-    expect(files).toContainEqual(join(testDir, 'file2.tsx'))
-  })
-
-  test('recursively finds files in subdirectories', () => {
-    const subDir = join(testDir, 'subdir')
-    mkdirSync(subDir)
-
-    writeFileSync(join(testDir, 'root.ts'), 'content')
-    writeFileSync(join(subDir, 'nested.ts'), 'content')
-
-    const files = findFiles(testDir, ['*.ts'])
-
-    expect(files).toHaveLength(2)
-    expect(files).toContainEqual(join(testDir, 'root.ts'))
-    expect(files).toContainEqual(join(subDir, 'nested.ts'))
-  })
-
-  test('skips node_modules directory', () => {
-    const nodeModules = join(testDir, 'node_modules')
-    mkdirSync(nodeModules)
-
-    writeFileSync(join(testDir, 'app.ts'), 'content')
-    writeFileSync(join(nodeModules, 'package.ts'), 'content')
-
-    const files = findFiles(testDir, ['*.ts'])
-
-    expect(files).toHaveLength(1)
-    expect(files).toContainEqual(join(testDir, 'app.ts'))
-    expect(files).not.toContainEqual(join(nodeModules, 'package.ts'))
-  })
-
-  test('skips dist directory', () => {
-    const dist = join(testDir, 'dist')
-    mkdirSync(dist)
-
-    writeFileSync(join(testDir, 'source.ts'), 'content')
-    writeFileSync(join(dist, 'compiled.js'), 'content')
-
-    const files = findFiles(testDir, ['*.ts', '*.js'])
-
-    expect(files).toHaveLength(1)
-    expect(files).toContainEqual(join(testDir, 'source.ts'))
-  })
-
-  test('returns empty array when no matching files exist', () => {
-    writeFileSync(join(testDir, 'file.txt'), 'content')
-    writeFileSync(join(testDir, 'file.md'), 'content')
-
-    const files = findFiles(testDir, ['*.ts'])
-
-    expect(files).toEqual([])
-  })
-
-  test('finds files in deeply nested directories', () => {
-    const level1 = join(testDir, 'level1')
-    const level2 = join(level1, 'level2')
-    const level3 = join(level2, 'level3')
-
-    mkdirSync(level3, { recursive: true })
-
-    writeFileSync(join(level3, 'deep.ts'), 'content')
-
-    const files = findFiles(testDir, ['*.ts'])
-
-    expect(files).toHaveLength(1)
-    expect(files).toContainEqual(join(level3, 'deep.ts'))
-  })
-
-  test('handles multiple file types in nested structure', () => {
-    const src = join(testDir, 'src')
-    const components = join(src, 'components')
-    const utils = join(src, 'utils')
-
-    mkdirSync(components, { recursive: true })
-    mkdirSync(utils, { recursive: true })
-
-    writeFileSync(join(components, 'Button.tsx'), 'content')
-    writeFileSync(join(components, 'Input.tsx'), 'content')
-    writeFileSync(join(utils, 'helpers.ts'), 'content')
-    writeFileSync(join(src, 'index.ts'), 'content')
-
-    const files = findFiles(testDir, ['*.ts', '*.tsx'])
-
-    expect(files).toHaveLength(4)
-  })
-
-  test('uses accumulator parameter correctly', () => {
-    writeFileSync(join(testDir, 'file1.ts'), 'content')
-    writeFileSync(join(testDir, 'file2.ts'), 'content')
-
-    const existingResults = ['/existing/file.ts']
-    const files = findFiles(testDir, ['*.ts'], existingResults)
-
-    expect(files).toHaveLength(3)
-    expect(files).toContain('/existing/file.ts')
-  })
-
-  test('prevents path traversal attacks', () => {
-    // This test ensures that symlinks or malicious paths don't escape the base directory
-    writeFileSync(join(testDir, 'safe.ts'), 'content')
-
-    const files = findFiles(testDir, ['*.ts'])
-
-    // All returned files should be within testDir
-    files.forEach((file) => {
-      expect(file.startsWith(testDir)).toBe(true)
-    })
-  })
-})
-
-describe('run', () => {
-  let originalCwd: string
-  let originalExit: typeof process.exit
-  let exitCode: number | null
-  let consoleOutput: string[]
-
-  beforeEach(() => {
-    originalCwd = process.cwd()
-    originalExit = process.exit
-    exitCode = null
-    consoleOutput = []
-
-    // Mock process.exit to capture exit codes
-    process.exit = ((code?: number) => {
-      exitCode = code ?? 0
-      throw new Error(`process.exit(${code})`)
-    }) as typeof process.exit
-
-    // Mock console methods
-    vi.spyOn(console, 'log').mockImplementation((msg) => {
-      consoleOutput.push(String(msg))
-    })
-    vi.spyOn(console, 'error').mockImplementation((msg) => {
-      consoleOutput.push(String(msg))
-    })
-  })
-
-  afterEach(() => {
-    process.exit = originalExit
-    process.chdir(originalCwd)
-    vi.restoreAllMocks()
-  })
-
-  test('exits with help when no args provided', async () => {
-    const transform: Transform = (source) => source
-
-    await expect(
-      run({
-        transform,
-        codemodName: 'test-codemod',
-        args: [],
-      }),
-    ).rejects.toThrow('process.exit(0)')
-
-    expect(exitCode).toBe(0)
-    expect(consoleOutput.join('\n')).toContain('Usage:')
-  })
-
-  test('exits with help when --help flag provided', async () => {
-    const transform: Transform = (source) => source
-
-    await expect(
-      run({
-        transform,
-        codemodName: 'test-codemod',
-        args: ['--help'],
-      }),
-    ).rejects.toThrow('process.exit(0)')
-
-    expect(exitCode).toBe(0)
-    expect(consoleOutput.join('\n')).toContain('Usage:')
-  })
-
-  test('transforms files in directory', async () => {
-    process.chdir(testDir)
-
-    const srcDir = join(testDir, 'src')
-    mkdirSync(srcDir)
-
-    writeFileSync(join(srcDir, 'file1.ts'), 'OLD_CODE')
-    writeFileSync(join(srcDir, 'file2.ts'), 'OLD_CODE')
-
-    const transform: Transform = (source) => source.replace('OLD_CODE', 'NEW_CODE')
-
-    await run({
-      transform,
-      codemodName: 'test-codemod',
-      args: ['src'],
-    })
-
-    const file1Content = readFileSync(join(srcDir, 'file1.ts'), 'utf-8')
-    const file2Content = readFileSync(join(srcDir, 'file2.ts'), 'utf-8')
-
-    expect(file1Content).toBe('NEW_CODE')
-    expect(file2Content).toBe('NEW_CODE')
-  })
-
-  test('performs dry run without modifying files', async () => {
-    process.chdir(testDir)
-
-    const srcDir = join(testDir, 'src')
-    mkdirSync(srcDir)
-
-    writeFileSync(join(srcDir, 'file.ts'), 'OLD_CODE')
-
-    const transform: Transform = (source) => source.replace('OLD_CODE', 'NEW_CODE')
-
-    await run({
-      transform,
-      codemodName: 'test-codemod',
-      args: ['src', '--dry-run'],
-    })
-
-    const fileContent = readFileSync(join(srcDir, 'file.ts'), 'utf-8')
-
-    expect(fileContent).toBe('OLD_CODE')
-    expect(consoleOutput.join('\n')).toContain('Would transform')
-  })
-
-  test('respects custom file extensions', async () => {
-    process.chdir(testDir)
-
-    const srcDir = join(testDir, 'src')
-    mkdirSync(srcDir)
-
-    writeFileSync(join(srcDir, 'file.tsx'), 'OLD_CODE')
-    writeFileSync(join(srcDir, 'file.ts'), 'OLD_CODE')
-    writeFileSync(join(srcDir, 'file.js'), 'OLD_CODE')
-
-    const transform: Transform = (source) => source.replace('OLD_CODE', 'NEW_CODE')
-
-    await run({
-      transform,
-      codemodName: 'test-codemod',
-      args: ['src', '--ext', '.tsx,.jsx'],
-    })
-
-    const tsxContent = readFileSync(join(srcDir, 'file.tsx'), 'utf-8')
-    const tsContent = readFileSync(join(srcDir, 'file.ts'), 'utf-8')
-
-    expect(tsxContent).toBe('NEW_CODE')
-    expect(tsContent).toBe('OLD_CODE') // Not transformed
-  })
-
-  test('exits with error when directory not found', async () => {
-    process.chdir(testDir)
-
-    const transform: Transform = (source) => source
-
-    await expect(
-      run({
-        transform,
-        codemodName: 'test-codemod',
-        args: ['nonexistent'],
-      }),
-    ).rejects.toThrow('process.exit(1)')
-
-    expect(exitCode).toBe(1)
-    expect(consoleOutput.join('\n')).toContain('Directory not found')
-  })
-
-  test('exits with error when no directory provided', async () => {
-    process.chdir(testDir)
-
-    const transform: Transform = (source) => source
-
-    await expect(
-      run({
-        transform,
-        codemodName: 'test-codemod',
-        args: ['--dry-run'],
-      }),
-    ).rejects.toThrow('process.exit(1)')
-
-    expect(exitCode).toBe(1)
-    expect(consoleOutput.join('\n')).toContain('No directory provided')
-  })
-
-  test('prevents directory traversal attacks', async () => {
-    process.chdir(testDir)
-
-    const transform: Transform = (source) => source
-
-    await expect(
-      run({
-        transform,
-        codemodName: 'test-codemod',
-        args: ['../../../etc'],
-      }),
-    ).rejects.toThrow('process.exit(1)')
-
-    expect(exitCode).toBe(1)
-    expect(consoleOutput.join('\n')).toContain('outside the current working directory')
-  })
-
-  test('only transforms files that change', async () => {
-    process.chdir(testDir)
-
-    const srcDir = join(testDir, 'src')
-    mkdirSync(srcDir)
-
-    writeFileSync(join(srcDir, 'changed.ts'), 'OLD_CODE')
-    writeFileSync(join(srcDir, 'unchanged.ts'), 'KEEP_CODE')
-
-    const transform: Transform = (source) => source.replace('OLD_CODE', 'NEW_CODE')
-
-    await run({
-      transform,
-      codemodName: 'test-codemod',
-      args: ['src'],
-    })
-
-    const output = consoleOutput.join('\n')
-    expect(output).toContain('Transformed: src/changed.ts')
-    expect(output).not.toContain('unchanged.ts')
-    expect(output).toContain('Transformed 1 file(s)')
-  })
-
-  test('handles transform errors gracefully', async () => {
-    process.chdir(testDir)
-
-    const srcDir = join(testDir, 'src')
-    mkdirSync(srcDir)
-
-    writeFileSync(join(srcDir, 'file1.ts'), 'content')
-    writeFileSync(join(srcDir, 'file2.ts'), 'content')
-
-    const transform: Transform = (source, filePath) => {
-      if (filePath.includes('file1')) {
-        throw new Error('Transform failed')
-      }
-      return source.replace('content', 'transformed')
-    }
-
-    await run({
-      transform,
-      codemodName: 'test-codemod',
-      args: ['src'],
-    })
-
-    const output = consoleOutput.join('\n')
-    expect(output).toContain('Error processing')
-    expect(output).toContain('Transform failed')
-
-    // Second file should still be transformed
-    const file2Content = readFileSync(join(srcDir, 'file2.ts'), 'utf-8')
-    expect(file2Content).toBe('transformed')
-  })
-
-  test('reports correct file count when no files match', async () => {
-    process.chdir(testDir)
-
-    const srcDir = join(testDir, 'src')
-    mkdirSync(srcDir)
-
-    writeFileSync(join(srcDir, 'file.txt'), 'content')
-
-    const transform: Transform = (source) => source
-
-    await expect(
-      run({
-        transform,
-        codemodName: 'test-codemod',
-        args: ['src'],
-      }),
-    ).rejects.toThrow('process.exit(0)')
-
-    expect(consoleOutput.join('\n')).toContain('No matching files found')
-  })
-
-  test('handles -d shorthand for dry-run', async () => {
-    process.chdir(testDir)
-
-    const srcDir = join(testDir, 'src')
-    mkdirSync(srcDir)
-
-    writeFileSync(join(srcDir, 'file.ts'), 'OLD_CODE')
-
-    const transform: Transform = (source) => source.replace('OLD_CODE', 'NEW_CODE')
-
-    await run({
-      transform,
-      codemodName: 'test-codemod',
-      args: ['src', '-d'],
-    })
-
-    const fileContent = readFileSync(join(srcDir, 'file.ts'), 'utf-8')
-
-    expect(fileContent).toBe('OLD_CODE')
-    expect(consoleOutput.join('\n')).toContain('dry run')
-  })
-
-  test('passes file path to transform function', async () => {
-    process.chdir(testDir)
-
-    const srcDir = join(testDir, 'src')
-    mkdirSync(srcDir)
-
-    writeFileSync(join(srcDir, 'file.ts'), 'content')
-
-    let receivedPath = ''
-    const transform: Transform = (source, filePath) => {
-      receivedPath = filePath
-      return source
-    }
-
-    await run({
-      transform,
-      codemodName: 'test-codemod',
-      args: ['src'],
-    })
-
-    expect(receivedPath).toContain('file.ts')
-  })
-})

package/codemods/at-a-glance-article-card/README.md

@@ -1,122 +0,0 @@
----
-description: Migrates AtAGlance.Card to AtAGlance.ArticleCard
----
-
-# AtAGlance ArticleCard Codemod
-
-Migrates old `AtAGlance.Card` usage to the new `AtAGlance.ArticleCard` component.
-
-## Usage
-
-```bash
-# List available codemods
-yarn dlx @reapit/elements@beta codemod list
-
-# Show detailed info about this codemod
-yarn dlx @reapit/elements@beta codemod info at-a-glance-article-card
-
-# Run on a directory
-yarn dlx @reapit/elements@beta codemod apply at-a-glance-article-card src/
-
-# Preview changes without writing files
-yarn dlx @reapit/elements@beta codemod apply at-a-glance-article-card src/ --dry-run
-
-# Specify file extensions
-yarn dlx @reapit/elements@beta codemod apply at-a-glance-article-card src/ --ext .tsx,.jsx
-```
-
-### Facade Package Support
-
-If your project re-exports `@reapit/elements` through an internal facade package, use the `--facade-package` flag:
-
-```bash
-yarn dlx @reapit/elements@beta codemod apply at-a-glance-article-card src/ --facade-package @company/ui-components
-```
-
-The codemod uses **prefix matching**, so specifying a base package will match all its subpaths:
-
-```bash
-# This will match:
-# - @company/design-system/elements
-# - @company/design-system/core
-# - @company/design-system/utils
-# - etc.
-yarn dlx @reapit/elements@beta codemod apply at-a-glance-article-card src/ --facade-package @company/design-system
-```
-
-If you have multiple unrelated facade packages, run the codemod once for each package:
-
-```bash
-yarn dlx @reapit/elements@beta codemod apply at-a-glance-article-card src/ --facade-package @company/ui
-yarn dlx @reapit/elements@beta codemod apply at-a-glance-article-card src/ --facade-package @another/design-lib
-```
-
-**Example with facade package:**
-
-```tsx
-// Before (with facade package @habio/design-system)
-import { AtAGlanceCard } from '@habio/design-system/elements'
-;<AtAGlanceCard displayValue="42" label="Total" />
-
-// After running with --facade-package @habio/design-system
-import { AtAGlance } from '@habio/design-system/elements'
-;<AtAGlance.ArticleCard displayValue="42" label="Total" />
-```
-
-## Background
-
-The `AtAGlance.Card` component API has changed:
-
-- **Old API**: `AtAGlance.Card` accepted props like `displayValue`, `label`, `description`, and `icon` directly
-- **New API**: `AtAGlance.Card` is now a primitive for custom layouts using the `grid` prop and subcomponents (`CardIcon`, `CardLabel`, `CardDescription`, `CardValue`)
-
-For standard layouts, use the new element-specific card components:
-
-- `AtAGlance.ArticleCard` - static, non-interactive cards
-- `AtAGlance.AnchorCard` - navigable link cards
-- `AtAGlance.ButtonCard` - interactive button cards
-
-## Transformations
-
-Both namespaced and direct component usage are converted to the namespaced `AtAGlance.ArticleCard`:
-
-| Before                                              | After                                                      |
-| --------------------------------------------------- | ---------------------------------------------------------- |
-| `<AtAGlance.Card displayValue="42" label="Total"/>` | `<AtAGlance.ArticleCard displayValue="42" label="Total"/>` |
-| `<AtAGlanceCard displayValue="42" label="Total"/>`  | `<AtAGlance.ArticleCard displayValue="42" label="Total"/>` |
-| `<AtAGlance.Card grid="..." />`                     | No change (already using new primitive API)                |
-| `<AtAGlanceCard grid="..." />`                      | No change (already using new primitive API)                |
-| `<AtAGlance.Card>{children}</AtAGlance.Card>`       | No change (already using new primitive API)                |
-| `<AtAGlanceCard>{children}</AtAGlanceCard>`         | No change (already using new primitive API)                |
-| `<AtAGlance.AnchorCard {...} />`                    | No change (API unchanged)                                  |
-| `<AtAGlanceAnchorCard {...} />`                     | No change (API unchanged)                                  |
-| `<AtAGlance.ButtonCard {...} />`                    | No change (API unchanged)                                  |
-| `<AtAGlanceButtonCard {...} />`                     | No change (API unchanged)                                  |
-
-## Import Handling
-
-The codemod removes `AtAGlanceCard` from imports when it is no longer used and adds the `AtAGlance` import. This works for direct `@reapit/elements` imports and facade packages (when specified via `--facade-package`):
-
-```tsx
-// Before
-import { AtAGlanceCard } from '@reapit/elements'
-;<AtAGlanceCard displayValue="42" label="Total" />
-
-// After
-import { AtAGlance } from '@reapit/elements'
-;<AtAGlance.ArticleCard displayValue="42" label="Total" />
-```
-
-When `AtAGlanceCard` is still used with the new primitive API, the import is kept:
-
-```tsx
-// Before
-import { AtAGlanceCard } from '@reapit/elements'
-<AtAGlanceCard displayValue="42" label="Old" />
-<AtAGlanceCard grid="auto"><span>New</span></AtAGlanceCard>
-
-// After
-import { AtAGlanceCard } from '@reapit/elements'
-<AtAGlance.ArticleCard displayValue="42" label="Old" />
-<AtAGlanceCard grid="auto"><span>New</span></AtAGlanceCard>
-```