@aiready/components 0.13.19 → 0.13.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/components",
-  "version": "0.13.19",
+  "version": "0.13.20",
   "description": "Unified shared components library (UI, charts, hooks, utilities) for AIReady",
   "type": "module",
   "main": "./dist/index.js",
@@ -128,7 +128,7 @@
     "framer-motion": "^12.35.0",
     "lucide-react": "^0.577.0",
     "tailwind-merge": "^3.0.0",
-    "@aiready/core": "0.23.20"
+    "@aiready/core": "0.23.21"
   },
   "devDependencies": {
     "@testing-library/jest-dom": "^6.6.5",

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

@@ -1,28 +1,49 @@
 import { describe, it, expect } from 'vitest';
-import { scoreColor, scoreBg, scoreLabel, getScoreRating } from '../score';
+import {
+  scoreColor,
+  scoreBg,
+  scoreLabel,
+  getScoreRating,
+  scoreGlow,
+} from '../score';
 
 describe('Score Utilities', () => {
   it('should return correct color for scores', () => {
+    expect(scoreColor(95)).toBe('text-emerald-400');
     expect(scoreColor(80)).toBe('text-emerald-400');
-    expect(scoreColor(60)).toBe('text-amber-400');
-    expect(scoreColor(30)).toBe('text-red-400');
+    expect(scoreColor(65)).toBe('text-amber-400');
+    expect(scoreColor(45)).toBe('text-red-400');
+    expect(scoreColor(20)).toBe('text-red-400');
     expect(scoreColor(null)).toBe('text-slate-400');
   });
 
   it('should return correct background for scores', () => {
+    expect(scoreBg(95)).toContain('emerald');
     expect(scoreBg(80)).toContain('emerald');
-    expect(scoreBg(60)).toContain('amber');
-    expect(scoreBg(30)).toContain('red');
+    expect(scoreBg(65)).toContain('amber');
+    expect(scoreBg(45)).toContain('red');
+    expect(scoreBg(20)).toContain('red');
     expect(scoreBg(null)).toContain('slate');
   });
 
   it('should return correct labels', () => {
+    expect(scoreLabel(95)).toBe('Excellent');
     expect(scoreLabel(80)).toBe('AI-Ready');
-    expect(scoreLabel(60)).toBe('Fair');
-    expect(scoreLabel(30)).toBe('Critical Issues');
+    expect(scoreLabel(65)).toBe('Fair');
+    expect(scoreLabel(45)).toBe('Needs Improvement');
+    expect(scoreLabel(20)).toBe('Critical Issues');
     expect(scoreLabel(null)).toBe('Not analyzed');
   });
 
+  it('should return correct glow for scores', () => {
+    expect(scoreGlow(95)).toContain('emerald');
+    expect(scoreGlow(80)).toContain('emerald');
+    expect(scoreGlow(65)).toContain('amber');
+    expect(scoreGlow(45)).toContain('red');
+    expect(scoreGlow(20)).toContain('red');
+    expect(scoreGlow(null)).toBe('');
+  });
+
   it('should return correct rating strings', () => {
     expect(getScoreRating(95)).toBe('excellent');
     expect(getScoreRating(80)).toBe('good');

package/src/utils/score.ts

@@ -1,82 +1,95 @@
 import { getRatingSlug } from '@aiready/core/client';
 
+type RatingSlug = 'excellent' | 'good' | 'fair' | 'needs-work' | 'critical';
+
+interface ScoreMetadata {
+  color: string;
+  bg: string;
+  label: string;
+  glow: string;
+}
+
+const SCORE_METADATA: Record<RatingSlug, ScoreMetadata> = {
+  excellent: {
+    color: 'text-emerald-400',
+    bg: 'bg-emerald-900/30 border-emerald-500/30',
+    label: 'Excellent',
+    glow: 'shadow-emerald-500/20',
+  },
+  good: {
+    color: 'text-emerald-400',
+    bg: 'bg-emerald-900/30 border-emerald-500/30',
+    label: 'AI-Ready',
+    glow: 'shadow-emerald-500/20',
+  },
+  fair: {
+    color: 'text-amber-400',
+    bg: 'bg-amber-900/30 border-amber-500/30',
+    label: 'Fair',
+    glow: 'shadow-amber-500/20',
+  },
+  'needs-work': {
+    color: 'text-red-400',
+    bg: 'bg-red-900/30 border-red-500/30',
+    label: 'Needs Improvement',
+    glow: 'shadow-red-500/20',
+  },
+  critical: {
+    color: 'text-red-400',
+    bg: 'bg-red-900/30 border-red-500/30',
+    label: 'Critical Issues',
+    glow: 'shadow-red-500/20',
+  },
+};
+
+const DEFAULT_METADATA: ScoreMetadata = {
+  color: 'text-slate-400',
+  bg: 'bg-slate-800/50 border-slate-700',
+  label: 'Not analyzed',
+  glow: '',
+};
+
+/**
+ * Get the metadata for a score using core rating system
+ */
+function getMetadata(score: number | null | undefined): ScoreMetadata {
+  if (score == null) return DEFAULT_METADATA;
+  const rating = getRatingSlug(score) as RatingSlug;
+  return SCORE_METADATA[rating] || SCORE_METADATA.critical;
+}
+
 /**
  * Get the Tailwind color class for a score using core rating system
  */
 export function scoreColor(score: number | null | undefined): string {
-  if (score == null) return 'text-slate-400';
-  const rating = getRatingSlug(score);
-  switch (rating) {
-    case 'excellent':
-    case 'good':
-      return 'text-emerald-400';
-    case 'fair':
-      return 'text-amber-400';
-    default:
-      return 'text-red-400';
-  }
+  return getMetadata(score).color;
 }
 
 /**
  * Get the Tailwind background/border class for a score using core rating system
  */
 export function scoreBg(score: number | null | undefined): string {
-  if (score == null) return 'bg-slate-800/50 border-slate-700';
-  const rating = getRatingSlug(score);
-  switch (rating) {
-    case 'excellent':
-    case 'good':
-      return 'bg-emerald-900/30 border-emerald-500/30';
-    case 'fair':
-      return 'bg-amber-900/30 border-amber-500/30';
-    default:
-      return 'bg-red-900/30 border-red-500/30';
-  }
+  return getMetadata(score).bg;
 }
 
 /**
  * Get the display label for a score using core rating system
  */
 export function scoreLabel(score: number | null | undefined): string {
-  if (score == null) return 'Not analyzed';
-  const rating = getRatingSlug(score);
-  switch (rating) {
-    case 'excellent':
-      return 'Excellent';
-    case 'good':
-      return 'AI-Ready';
-    case 'fair':
-      return 'Fair';
-    case 'needs-work':
-      return 'Needs Improvement';
-    default:
-      return 'Critical Issues';
-  }
+  return getMetadata(score).label;
 }
 
 /**
  * Get the Tailwind shadow glow class for a score using core rating system
  */
 export function scoreGlow(score: number | null | undefined): string {
-  if (score == null) return '';
-  const rating = getRatingSlug(score);
-  switch (rating) {
-    case 'excellent':
-    case 'good':
-      return 'shadow-emerald-500/20';
-    case 'fair':
-      return 'shadow-amber-500/20';
-    default:
-      return 'shadow-red-500/20';
-  }
+  return getMetadata(score).glow;
 }
 
 /**
  * Get rating from score (for use with ScoreBar component)
  */
-export function getScoreRating(
-  score: number | null | undefined
-): 'excellent' | 'good' | 'fair' | 'needs-work' | 'critical' {
+export function getScoreRating(score: number | null | undefined): RatingSlug {
   if (score == null) return 'critical';
-  return getRatingSlug(score) as any;
+  return getRatingSlug(score) as RatingSlug;
 }