@aiready/components 0.13.19 → 0.13.21

package/dist/useForceSimulation-BNhxX4gH.d.ts

@@ -0,0 +1,49 @@
+import * as d3 from 'd3';
+
+interface SimulationNode extends d3.SimulationNodeDatum {
+    id: string;
+    [key: string]: any;
+}
+interface SimulationLink extends d3.SimulationLinkDatum<SimulationNode> {
+    source: string | SimulationNode;
+    target: string | SimulationNode;
+    [key: string]: any;
+}
+interface ForceSimulationOptions {
+    chargeStrength?: number;
+    linkDistance?: number;
+    linkStrength?: number;
+    collisionStrength?: number;
+    collisionRadius?: number;
+    centerStrength?: number;
+    width: number;
+    height: number;
+    alphaDecay?: number;
+    alphaTarget?: number;
+    warmAlpha?: number;
+    alphaMin?: number;
+    stabilizeOnStop?: boolean;
+    tickThrottleMs?: number;
+    maxSimulationTimeMs?: number;
+    velocityDecay?: number;
+    onTick?: (nodes: SimulationNode[], links: SimulationLink[], sim: d3.Simulation<SimulationNode, SimulationLink>) => void;
+}
+interface UseForceSimulationReturn {
+    nodes: SimulationNode[];
+    links: SimulationLink[];
+    restart: () => void;
+    stop: () => void;
+    isRunning: boolean;
+    alpha: number;
+}
+
+declare function useForceSimulation(initialNodes: SimulationNode[], initialLinks: SimulationLink[], options: ForceSimulationOptions): UseForceSimulationReturn & {
+    setForcesEnabled: (enabled: boolean) => void;
+};
+declare function useDrag(simulation: d3.Simulation<SimulationNode, any> | null | undefined): {
+    onDragStart: (event: any, node: SimulationNode) => void;
+    onDrag: (event: any, node: SimulationNode) => void;
+    onDragEnd: (event: any, node: SimulationNode) => void;
+};
+
+export { type ForceSimulationOptions as F, type SimulationLink as S, type UseForceSimulationReturn as U, type SimulationNode as a, useForceSimulation as b, useDrag as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/components",
-  "version": "0.13.19",
+  "version": "0.13.21",
   "description": "Unified shared components library (UI, charts, hooks, utilities) for AIReady",
   "type": "module",
   "main": "./dist/index.js",
@@ -91,8 +91,8 @@
       "import": "./dist/hooks/useForceSimulation.js"
     },
     "./charts/ForceDirectedGraph": {
-      "types": "./dist/charts/ForceDirectedGraph.d.ts",
-      "import": "./dist/charts/ForceDirectedGraph.js"
+      "types": "./dist/charts/ForceDirectedGraph/index.d.ts",
+      "import": "./dist/charts/ForceDirectedGraph/index.js"
     },
     "./tailwind-config": "./tailwind.config.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.22"
   },
   "devDependencies": {
     "@testing-library/jest-dom": "^6.6.5",

package/src/charts/{ForceDirectedGraph.tsx → ForceDirectedGraph/index.tsx}

@@ -6,7 +6,7 @@ export {
   type GraphNode,
   type GraphLink,
   type LayoutType,
-} from './force-directed';
+} from '../force-directed';
 
 // Default export for backward compatibility
-export { ForceDirectedGraph as default } from './force-directed';
+export { ForceDirectedGraph as default } from '../force-directed';

package/src/hooks/useForceSimulation.ts

@@ -1,11 +1,3 @@
-// Re-export types from separate module for backward compatibility
-export {
-  type SimulationNode,
-  type SimulationLink,
-  type ForceSimulationOptions,
-  type UseForceSimulationReturn,
-} from './simulation-types';
-
 // Import helpers from separate module
 import { stabilizeNodes, seedRandomPositions } from './simulation-helpers';
 import type {

package/src/index.ts

@@ -96,14 +96,13 @@ export * from './utils/score';
 // Hooks
 export { useDebounce } from './hooks/useDebounce';
 export { useD3, useD3WithResize } from './hooks/useD3';
+export { useForceSimulation, useDrag } from './hooks/useForceSimulation';
 export {
-  useForceSimulation,
-  useDrag,
   type SimulationNode,
   type SimulationLink,
   type ForceSimulationOptions,
   type UseForceSimulationReturn,
-} from './hooks/useForceSimulation';
+} from './hooks/simulation-types';
 
 // Charts
 export {

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;
 }

package/src/components/icons.tsx

@@ -1,3 +0,0 @@
-import * as AllIcons from './icons/index';
-export * from './icons/index';
-export default AllIcons.default;