@dialpad/dialtone-css 8.80.0-next.6 → 8.80.0-next.7

package/lib/build/js/dialtone_migrate_border_radius/index.mjs

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+
+/**
+ * @fileoverview Migration script for deprecated physical border-radius utility classes.
+ *
+ * DLT-3329  Physical directional border-radius utility classes have been replaced
+ *           by logical equivalents. This script rewrites:
+ *
+ *   All-corners numeric:  d-bar6     → d-bar-350
+ *   Pair numeric:         d-btr8     → d-bbsr-400
+ *   Pair keyword:         d-btr-pill → d-bbsr-pill
+ *
+ * The full pair-prefix mapping is:
+ *   btr → bbsr   (top    → block-start pair)
+ *   bbr → bber   (bottom → block-end pair)
+ *   blr → bisr   (left   → inline-start pair)
+ *   brr → bier   (right  → inline-end pair)
+ *
+ * Usage:
+ *   npx dialtone-migrate-border-radius [options]
+ *
+ * Options:
+ *   --cwd <path>     Working directory (default: current directory)
+ *   --dry-run        Show changes without applying them
+ *   --yes            Apply all changes without prompting
+ *   --help           Show help
+ *
+ * Examples:
+ *   npx dialtone-migrate-border-radius
+ *   npx dialtone-migrate-border-radius --dry-run
+ *   npx dialtone-migrate-border-radius --cwd ./src
+ *   npx dialtone-migrate-border-radius --yes
+ */
+
+import fs from 'fs/promises';
+import { realpathSync } from 'node:fs';
+import path from 'path';
+import readline from 'readline';
+import { fileURLToPath } from 'node:url';
+
+// ---------------------------------------------------------------------------
+// Mapping — MUST STAY IN SYNC with:
+// - packages/eslint-plugin-dialtone/lib/rules/deprecated-radius-utility-classes.js
+// - packages/dialtone-css/postcss/constants.cjs  (RADIUS_STOPS)
+// ---------------------------------------------------------------------------
+
+const RADIUS_STOP_MAP = {
+  0: '0', 1: '100', 2: '200', 4: '300', 6: '350',
+  8: '400', 12: '450', 16: '500', 24: '550', 32: '600',
+};
+
+const PAIR_PREFIX_MAP = {
+  btr: 'bbsr', // top    → block-start pair
+  bbr: 'bber', // bottom → block-end pair
+  blr: 'bisr', // left   → inline-start pair
+  brr: 'bier', // right  → inline-end pair
+};
+
+// Ordered by descending string length so regex alternation matches longest first.
+const NUMERIC_SUFFIXES = Object.keys(RADIUS_STOP_MAP)
+  .sort((a, b) => b.length - a.length || Number(b) - Number(a))
+  .join('|');
+const PAIR_PREFIXES = Object.keys(PAIR_PREFIX_MAP).join('|');
+
+// Word-boundary anchored patterns to avoid matching inside unrelated class names.
+const ALL_CORNERS_NUMERIC = new RegExp(`(?<=[\\s"'=\`])d-bar(${NUMERIC_SUFFIXES})(?=[\\s"'>;\`])`, 'g');
+const PAIR_NUMERIC        = new RegExp(`(?<=[\\s"'=\`])d-(${PAIR_PREFIXES})(${NUMERIC_SUFFIXES})(?=[\\s"'>;\`])`, 'g');
+const PAIR_KEYWORD        = new RegExp(`(?<=[\\s"'=\`])d-(${PAIR_PREFIXES})-(pill|circle)(?=[\\s"'>;\`])`, 'g');
+
+// ---------------------------------------------------------------------------
+// Transform
+// ---------------------------------------------------------------------------
+
+export function transformContent (content) {
+  let transformed = content;
+  let count = 0;
+
+  transformed = transformed
+    .replace(ALL_CORNERS_NUMERIC, (_, px) => { count++; return `d-bar-${RADIUS_STOP_MAP[px]}`; })
+    .replace(PAIR_NUMERIC, (_, legacyPrefix, px) => { count++; return `d-${PAIR_PREFIX_MAP[legacyPrefix]}-${RADIUS_STOP_MAP[px]}`; })
+    .replace(PAIR_KEYWORD, (_, legacyPrefix, keyword) => { count++; return `d-${PAIR_PREFIX_MAP[legacyPrefix]}-${keyword}`; });
+
+  return { transformed, count };
+}
+
+export { RADIUS_STOP_MAP, PAIR_PREFIX_MAP };
+
+// ---------------------------------------------------------------------------
+// File walker
+// ---------------------------------------------------------------------------
+
+function isIgnoredPath (fullPath, ignore) {
+  const segments = fullPath.split(path.sep);
+  return ignore.some(ig => {
+    if (ig.includes('/')) {
+      const parts = ig.split('/');
+      for (let i = 0; i + parts.length <= segments.length; i++) {
+        if (parts.every((p, j) => segments[i + j] === p)) return true;
+      }
+      return false;
+    }
+    return segments.includes(ig);
+  });
+}
+
+async function findFiles (dir, extensions, ignore = []) {
+  const results = [];
+  async function walk (currentDir) {
+    let entries;
+    try {
+      entries = await fs.readdir(currentDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (isIgnoredPath(fullPath, ignore)) continue;
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+      } else if (entry.isFile() && extensions.some(ext => entry.name.endsWith(ext))) {
+        results.push(fullPath);
+      }
+    }
+  }
+  await walk(dir);
+  return results;
+}
+
+// ---------------------------------------------------------------------------
+// CLI
+// ---------------------------------------------------------------------------
+
+function printHelp () {
+  console.log(`
+Usage: npx dialtone-migrate-border-radius [options]
+
+Replaces deprecated physical border-radius utility classes with logical equivalents (DLT-3329).
+
+  d-bar6     → d-bar-350      (all-corners numeric → token stop)
+  d-btr8     → d-bbsr-400     (top pair → block-start pair)
+  d-bbr-pill → d-bber-pill    (bottom pair → block-end pair)
+  d-blr12    → d-bisr-450     (left pair → inline-start pair)
+  d-brr-circle → d-bier-circle (right pair → inline-end pair)
+
+Pair-prefix mapping:
+  btr → bbsr   (top    → block-start)
+  bbr → bber   (bottom → block-end)
+  blr → bisr   (left   → inline-start)
+  brr → bier   (right  → inline-end)
+
+Numeric-stop mapping:
+  0 → 0     1 → 100   2 → 200   4 → 300    6 → 350
+  8 → 400   12 → 450  16 → 500  24 → 550   32 → 600
+
+Options:
+  --cwd <path>     Working directory (default: current directory)
+  --dry-run        Show changes without applying them
+  --yes            Apply all changes without prompting
+  --help           Show help
+`);
+}
+
+function parseArgs (args) {
+  const cwdIndex = args.indexOf('--cwd');
+  let cwd = process.cwd();
+  if (cwdIndex !== -1) {
+    const next = args[cwdIndex + 1];
+    if (!next || next.startsWith('--')) {
+      console.error('Error: --cwd requires a path argument.');
+      process.exit(1);
+    }
+    cwd = path.resolve(next);
+  }
+  return {
+    help: args.includes('--help'),
+    dryRun: args.includes('--dry-run'),
+    autoYes: args.includes('--yes'),
+    cwd,
+  };
+}
+
+async function prompt (question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    rl.question(question, answer => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+
+// eslint-disable-next-line complexity
+async function main () {
+  const opts = parseArgs(process.argv.slice(2));
+  if (opts.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  console.log(`\nScanning ${opts.cwd} for deprecated border-radius utility classes...\n`);
+
+  const extensions = ['.vue', '.md', '.html', '.js', '.ts', '.jsx', '.tsx'];
+  const ignore = ['node_modules', 'dist', '.git', '.vuepress/public', '.vuepress/.temp', '.vuepress/.cache', 'storybook-static'];
+  const files = await findFiles(opts.cwd, extensions, ignore);
+
+  const changes = [];
+
+  for (const file of files) {
+    try {
+      const content = await fs.readFile(file, 'utf8');
+      const { transformed, count } = transformContent(content);
+      if (count > 0) {
+        changes.push({ file, content, transformed, count });
+      }
+    } catch (err) {
+      console.warn(`  ⚠ skipped (read error): ${path.relative(opts.cwd, file)} — ${err.message}`);
+    }
+  }
+
+  if (changes.length === 0) {
+    console.log('No deprecated border-radius utility classes found. Nothing to migrate.');
+    process.exit(0);
+  }
+
+  console.log(`Found ${changes.reduce((sum, c) => sum + c.count, 0)} deprecated border-radius class references across ${changes.length} file(s):\n`);
+
+  for (const { file, count } of changes) {
+    const rel = path.relative(opts.cwd, file);
+    console.log(`  ${rel} (${count} change${count > 1 ? 's' : ''})`);
+  }
+
+  if (opts.dryRun) {
+    console.log('\n--dry-run: No files were modified.\n');
+    process.exit(0);
+  }
+
+  if (!opts.autoYes) {
+    const answer = await prompt('\nApply changes? (y/N) ');
+    if (answer !== 'y' && answer !== 'yes') {
+      console.log('Cancelled.');
+      process.exit(0);
+    }
+  }
+
+  let written = 0;
+  let migratedRefs = 0;
+  for (const { file, transformed, count } of changes) {
+    try {
+      await fs.writeFile(file, transformed, 'utf8');
+      written++;
+      migratedRefs += count;
+    } catch (err) {
+      console.warn(`  ⚠ skipped (write error): ${path.relative(opts.cwd, file)} — ${err.message}`);
+    }
+  }
+
+  console.log(`\nMigrated ${migratedRefs} references across ${written} file(s).\n`);
+}
+
+const isDirectRun = (() => {
+  try {
+    return realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
+  } catch {
+    return false;
+  }
+})();
+
+if (isDirectRun) {
+  main().catch(err => {
+    console.error(err);
+    process.exit(1);
+  });
+}

package/lib/build/js/dialtone_migrate_border_radius/test.mjs

@@ -0,0 +1,422 @@
+#!/usr/bin/env node
+
+/**
+ * @fileoverview Tests for dialtone-migrate-border-radius codemod.
+ * Run: node packages/dialtone-css/lib/build/js/dialtone_migrate_border_radius/test.mjs
+ */
+
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+import { describe, it } from 'node:test';
+import { transformContent, RADIUS_STOP_MAP, PAIR_PREFIX_MAP } from './index.mjs';
+
+// ---------------------------------------------------------------------------
+// All-corners numeric (d-barN → d-bar-STOP)
+// ---------------------------------------------------------------------------
+
+describe('All-corners numeric renames', () => {
+  it('d-bar0 → d-bar-0', () => {
+    const { transformed, count } = transformContent('<div class="d-bar0" />');
+    assert.equal(transformed, '<div class="d-bar-0" />');
+    assert.equal(count, 1);
+  });
+
+  it('d-bar1 → d-bar-100', () => {
+    const { transformed } = transformContent('<div class="d-bar1" />');
+    assert.equal(transformed, '<div class="d-bar-100" />');
+  });
+
+  it('d-bar2 → d-bar-200', () => {
+    const { transformed } = transformContent('<div class="d-bar2" />');
+    assert.equal(transformed, '<div class="d-bar-200" />');
+  });
+
+  it('d-bar4 → d-bar-300', () => {
+    const { transformed } = transformContent('<div class="d-bar4" />');
+    assert.equal(transformed, '<div class="d-bar-300" />');
+  });
+
+  it('d-bar6 → d-bar-350', () => {
+    const { transformed } = transformContent('<div class="d-bar6" />');
+    assert.equal(transformed, '<div class="d-bar-350" />');
+  });
+
+  it('d-bar8 → d-bar-400', () => {
+    const { transformed } = transformContent('<div class="d-bar8" />');
+    assert.equal(transformed, '<div class="d-bar-400" />');
+  });
+
+  it('d-bar12 → d-bar-450', () => {
+    const { transformed } = transformContent('<div class="d-bar12" />');
+    assert.equal(transformed, '<div class="d-bar-450" />');
+  });
+
+  it('d-bar16 → d-bar-500', () => {
+    const { transformed } = transformContent('<div class="d-bar16" />');
+    assert.equal(transformed, '<div class="d-bar-500" />');
+  });
+
+  it('d-bar24 → d-bar-550', () => {
+    const { transformed } = transformContent('<div class="d-bar24" />');
+    assert.equal(transformed, '<div class="d-bar-550" />');
+  });
+
+  it('d-bar32 → d-bar-600', () => {
+    const { transformed } = transformContent('<div class="d-bar32" />');
+    assert.equal(transformed, '<div class="d-bar-600" />');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Pair numeric (d-{btr|bbr|blr|brr}N → d-{bbsr|bber|bisr|bier}-STOP)
+// ---------------------------------------------------------------------------
+
+describe('Pair numeric renames', () => {
+  it('d-btr6 → d-bbsr-350 (top → block-start)', () => {
+    const { transformed } = transformContent('<div class="d-btr6" />');
+    assert.equal(transformed, '<div class="d-bbsr-350" />');
+  });
+
+  it('d-btr8 → d-bbsr-400', () => {
+    const { transformed } = transformContent('<div class="d-btr8" />');
+    assert.equal(transformed, '<div class="d-bbsr-400" />');
+  });
+
+  it('d-bbr8 → d-bber-400 (bottom → block-end)', () => {
+    const { transformed } = transformContent('<div class="d-bbr8" />');
+    assert.equal(transformed, '<div class="d-bber-400" />');
+  });
+
+  it('d-blr12 → d-bisr-450 (left → inline-start)', () => {
+    const { transformed } = transformContent('<div class="d-blr12" />');
+    assert.equal(transformed, '<div class="d-bisr-450" />');
+  });
+
+  it('d-brr16 → d-bier-500 (right → inline-end)', () => {
+    const { transformed } = transformContent('<div class="d-brr16" />');
+    assert.equal(transformed, '<div class="d-bier-500" />');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Pair keyword (d-{btr|bbr|blr|brr}-{pill|circle} → logical)
+// ---------------------------------------------------------------------------
+
+describe('Pair keyword renames', () => {
+  it('d-btr-pill → d-bbsr-pill', () => {
+    const { transformed } = transformContent('<div class="d-btr-pill" />');
+    assert.equal(transformed, '<div class="d-bbsr-pill" />');
+  });
+
+  it('d-btr-circle → d-bbsr-circle', () => {
+    const { transformed } = transformContent('<div class="d-btr-circle" />');
+    assert.equal(transformed, '<div class="d-bbsr-circle" />');
+  });
+
+  it('d-bbr-pill → d-bber-pill', () => {
+    const { transformed } = transformContent('<div class="d-bbr-pill" />');
+    assert.equal(transformed, '<div class="d-bber-pill" />');
+  });
+
+  it('d-bbr-circle → d-bber-circle', () => {
+    const { transformed } = transformContent('<div class="d-bbr-circle" />');
+    assert.equal(transformed, '<div class="d-bber-circle" />');
+  });
+
+  it('d-blr-pill → d-bisr-pill', () => {
+    const { transformed } = transformContent('<div class="d-blr-pill" />');
+    assert.equal(transformed, '<div class="d-bisr-pill" />');
+  });
+
+  it('d-blr-circle → d-bisr-circle', () => {
+    const { transformed } = transformContent('<div class="d-blr-circle" />');
+    assert.equal(transformed, '<div class="d-bisr-circle" />');
+  });
+
+  it('d-brr-pill → d-bier-pill', () => {
+    const { transformed } = transformContent('<div class="d-brr-pill" />');
+    assert.equal(transformed, '<div class="d-bier-pill" />');
+  });
+
+  it('d-brr-circle → d-bier-circle', () => {
+    const { transformed } = transformContent('<div class="d-brr-circle" />');
+    assert.equal(transformed, '<div class="d-bier-circle" />');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Multiple classes in one attribute
+// ---------------------------------------------------------------------------
+
+describe('Multiple classes in one attribute', () => {
+  it('rewrites multiple legacy classes in one pass', () => {
+    const { transformed, count } = transformContent('<div class="d-bar6 d-btr8 d-blr-pill" />');
+    assert.equal(transformed, '<div class="d-bar-350 d-bbsr-400 d-bisr-pill" />');
+    assert.equal(count, 3);
+  });
+
+  it('leaves non-radius classes untouched', () => {
+    const { transformed, count } = transformContent('<div class="d-p-200 d-bar6 d-fc-primary" />');
+    assert.equal(transformed, '<div class="d-p-200 d-bar-350 d-fc-primary" />');
+    assert.equal(count, 1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Already-migrated classes — no changes
+// ---------------------------------------------------------------------------
+
+describe('Does NOT transform already-migrated classes', () => {
+  it('ignores d-bar-350 (already new format)', () => {
+    const { transformed, count } = transformContent('<div class="d-bar-350" />');
+    assert.equal(transformed, '<div class="d-bar-350" />');
+    assert.equal(count, 0);
+  });
+
+  it('ignores d-bbsr-400', () => {
+    const { transformed, count } = transformContent('<div class="d-bbsr-400" />');
+    assert.equal(transformed, '<div class="d-bbsr-400" />');
+    assert.equal(count, 0);
+  });
+
+  it('ignores d-bber-pill', () => {
+    const { transformed, count } = transformContent('<div class="d-bber-pill" />');
+    assert.equal(transformed, '<div class="d-bber-pill" />');
+    assert.equal(count, 0);
+  });
+
+  it('ignores d-bisr-circle', () => {
+    const { transformed, count } = transformContent('<div class="d-bisr-circle" />');
+    assert.equal(transformed, '<div class="d-bisr-circle" />');
+    assert.equal(count, 0);
+  });
+
+  it('ignores d-bar-pill (all-corners keyword, not deprecated)', () => {
+    const { transformed, count } = transformContent('<div class="d-bar-pill" />');
+    assert.equal(transformed, '<div class="d-bar-pill" />');
+    assert.equal(count, 0);
+  });
+
+  it('ignores d-bar-circle (all-corners keyword, not deprecated)', () => {
+    const { transformed, count } = transformContent('<div class="d-bar-circle" />');
+    assert.equal(transformed, '<div class="d-bar-circle" />');
+    assert.equal(count, 0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Does NOT match inside unrelated class names
+// ---------------------------------------------------------------------------
+
+describe('Does NOT match substrings inside other classes', () => {
+  it('ignores foo-d-bar6', () => {
+    const { transformed, count } = transformContent('<div class="foo-d-bar6" />');
+    assert.equal(transformed, '<div class="foo-d-bar6" />');
+    assert.equal(count, 0);
+  });
+
+  it('ignores my-d-btr8', () => {
+    const { transformed, count } = transformContent('<div class="my-d-btr8" />');
+    assert.equal(transformed, '<div class="my-d-btr8" />');
+    assert.equal(count, 0);
+  });
+
+  it('ignores app-d-brr-pill', () => {
+    const { transformed, count } = transformContent('<div class="app-d-brr-pill" />');
+    assert.equal(transformed, '<div class="app-d-brr-pill" />');
+    assert.equal(count, 0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Unrelated classes — no false positives
+// ---------------------------------------------------------------------------
+
+describe('Does NOT touch unrelated utilities', () => {
+  it('ignores d-p-200 d-m-100 d-fc-primary', () => {
+    const input = '<div class="d-p-200 d-m-100 d-fc-primary" />';
+    const { transformed, count } = transformContent(input);
+    assert.equal(transformed, input);
+    assert.equal(count, 0);
+  });
+
+  it('ignores d-ba d-baw2 d-bas-dashed', () => {
+    const input = '<div class="d-ba d-baw2 d-bas-dashed" />';
+    const { transformed, count } = transformContent(input);
+    assert.equal(transformed, input);
+    assert.equal(count, 0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Different quote styles
+// ---------------------------------------------------------------------------
+
+describe('Different quote styles and contexts', () => {
+  it('handles single-quoted class attribute', () => {
+    const { transformed } = transformContent('<div class=\'d-btr8\' />');
+    assert.equal(transformed, '<div class=\'d-bbsr-400\' />');
+  });
+
+  it('handles class in a Vue template', () => {
+    const input = '<template><div class="d-bar6 d-brr-circle" /></template>';
+    const expected = '<template><div class="d-bar-350 d-bier-circle" /></template>';
+    const { transformed } = transformContent(input);
+    assert.equal(transformed, expected);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Template literals (JS/TS backtick strings)
+// ---------------------------------------------------------------------------
+
+describe('Template literal delimiters', () => {
+  it('transforms d-bar6 inside a simple template literal', () => {
+    const input = 'const cls = `d-bar6`;';
+    const expected = 'const cls = `d-bar-350`;';
+    const { transformed, count } = transformContent(input);
+    assert.equal(transformed, expected);
+    assert.equal(count, 1);
+  });
+
+  it('transforms pair keyword inside a template literal', () => {
+    const input = 'const cls = `d-btr-pill`;';
+    const expected = 'const cls = `d-bbsr-pill`;';
+    const { transformed } = transformContent(input);
+    assert.equal(transformed, expected);
+  });
+
+  it('transforms pair numeric inside a template literal', () => {
+    const input = 'const cls = `d-brr16`;';
+    const expected = 'const cls = `d-bier-500`;';
+    const { transformed } = transformContent(input);
+    assert.equal(transformed, expected);
+  });
+
+  it('transforms multiple classes inside a template literal', () => {
+    const input = 'const cls = `d-bar8 d-btr-circle`;';
+    const expected = 'const cls = `d-bar-400 d-bbsr-circle`;';
+    const { transformed, count } = transformContent(input);
+    assert.equal(transformed, expected);
+    assert.equal(count, 2);
+  });
+
+  it('transforms class inside a template literal with interpolation', () => {
+    const input = 'const cls = `d-bar6 ${otherClass}`;';
+    const expected = 'const cls = `d-bar-350 ${otherClass}`;';
+    const { transformed, count } = transformContent(input);
+    assert.equal(transformed, expected);
+    assert.equal(count, 1);
+  });
+
+  it('does not match inside a non-delimited context (no false positive)', () => {
+    const input = 'const cls = `foo-d-bar6`;';
+    const { transformed, count } = transformContent(input);
+    assert.equal(transformed, input);
+    assert.equal(count, 0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Edge cases
+// ---------------------------------------------------------------------------
+
+describe('Edge cases', () => {
+  it('returns count of 0 for content with no matches', () => {
+    const { count } = transformContent('<div><span>No radius here</span></div>');
+    assert.equal(count, 0);
+  });
+
+  it('handles empty string', () => {
+    const { transformed, count } = transformContent('');
+    assert.equal(transformed, '');
+    assert.equal(count, 0);
+  });
+
+  it('handles d-bar32 at end of attribute (before closing quote)', () => {
+    const { transformed } = transformContent('<div class="d-p-200 d-bar32" />');
+    assert.equal(transformed, '<div class="d-p-200 d-bar-600" />');
+  });
+
+  it('handles class at start of attribute (after opening quote)', () => {
+    const { transformed } = transformContent('<div class="d-bar6 d-p-200" />');
+    assert.equal(transformed, '<div class="d-bar-350 d-p-200" />');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Real-world patterns
+// ---------------------------------------------------------------------------
+
+describe('Real-world patterns', () => {
+  it('transforms radius in a card-like component', () => {
+    const input = '<div class="d-p-200 d-bgc-primary d-bar8 d-bs-sm">';
+    const expected = '<div class="d-p-200 d-bgc-primary d-bar-400 d-bs-sm">';
+    const { transformed } = transformContent(input);
+    assert.equal(transformed, expected);
+  });
+
+  it('transforms top-only radius on a header', () => {
+    const input = '<div class="d-btr6 d-bgc-moderate">';
+    const expected = '<div class="d-bbsr-350 d-bgc-moderate">';
+    const { transformed } = transformContent(input);
+    assert.equal(transformed, expected);
+  });
+
+  it('transforms bottom pill radius', () => {
+    const input = '<div class="d-bbr-pill d-bgc-info">';
+    const expected = '<div class="d-bber-pill d-bgc-info">';
+    const { transformed } = transformContent(input);
+    assert.equal(transformed, expected);
+  });
+
+  it('transforms mixed numeric and keyword across multiple classes', () => {
+    const input = '<div class="d-bar6 d-btr-pill d-bbr-circle d-blr8 d-brr-pill">';
+    const expected = '<div class="d-bar-350 d-bbsr-pill d-bber-circle d-bisr-400 d-bier-pill">';
+    const { transformed, count } = transformContent(input);
+    assert.equal(transformed, expected);
+    assert.equal(count, 5);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Contract: parity with ESLint rule maps
+// ---------------------------------------------------------------------------
+
+describe('Contract: maps match ESLint rule', () => {
+  const require = createRequire(import.meta.url);
+
+  let eslintSource;
+  try {
+    const fs = require('fs');
+    const path = require('path');
+    eslintSource = fs.readFileSync(
+      path.resolve(
+        import.meta.dirname,
+        '../../../../../eslint-plugin-dialtone/lib/rules/deprecated-radius-utility-classes.js',
+      ),
+      'utf8',
+    );
+  } catch { /* will fail tests below with clear message */ }
+
+  function extractObject (source, varName) {
+    const re = new RegExp(`const ${varName}\\s*=\\s*\\{([^}]+)\\}`);
+    const match = source?.match(re);
+    if (!match) return null;
+    return Function(`return {${match[1]}}`)();
+  }
+
+  it('RADIUS_STOP_MAP matches ESLint rule', () => {
+    assert.ok(eslintSource, 'Could not read ESLint rule source file');
+    const eslintMap = extractObject(eslintSource, 'RADIUS_STOP_MAP');
+    assert.ok(eslintMap, 'Could not parse RADIUS_STOP_MAP from ESLint rule');
+    assert.deepEqual(RADIUS_STOP_MAP, eslintMap);
+  });
+
+  it('PAIR_PREFIX_MAP matches ESLint rule', () => {
+    assert.ok(eslintSource, 'Could not read ESLint rule source file');
+    const eslintMap = extractObject(eslintSource, 'PAIR_PREFIX_MAP');
+    assert.ok(eslintMap, 'Could not parse PAIR_PREFIX_MAP from ESLint rule');
+    assert.deepEqual(PAIR_PREFIX_MAP, eslintMap);
+  });
+});