feat: implement Figlet, Pastel, and Unit tools with a unified layout

- Add Figlet text converter with font selection and history
- Add Pastel color palette generator and manipulation suite
- Add comprehensive Units converter with category-based logic
- Introduce AppShell with Sidebar and Header for navigation
- Modernize theme system with CSS variables and new animations
- Update project configuration and dependencies

lib/pastel/api/client.ts

@@ -0,0 +1,248 @@
+import type {
+  ApiResponse,
+  ColorInfoRequest,
+  ColorInfoData,
+  ConvertFormatRequest,
+  ConvertFormatData,
+  ColorManipulationRequest,
+  ColorManipulationData,
+  ColorMixRequest,
+  ColorMixData,
+  RandomColorsRequest,
+  RandomColorsData,
+  DistinctColorsRequest,
+  DistinctColorsData,
+  GradientRequest,
+  GradientData,
+  ColorDistanceRequest,
+  ColorDistanceData,
+  ColorSortRequest,
+  ColorSortData,
+  ColorBlindnessRequest,
+  ColorBlindnessData,
+  TextColorRequest,
+  TextColorData,
+  NamedColorsData,
+  NamedColorSearchRequest,
+  NamedColorSearchData,
+  HealthData,
+  CapabilitiesData,
+  PaletteGenerateRequest,
+  PaletteGenerateData,
+} from './types';
+import { pastelWASM } from './wasm-client';
+
+export class PastelAPIClient {
+  private baseURL: string;
+
+  constructor(baseURL?: string) {
+    // Use the Next.js API proxy route for runtime configuration
+    // This allows changing the backend API URL without rebuilding
+    this.baseURL = baseURL || '/api/pastel';
+  }
+
+  private async request<T>(
+    endpoint: string,
+    options?: RequestInit
+  ): Promise<ApiResponse<T>> {
+    // Endpoint already includes /api/v1 prefix on backend,
+    // but our proxy route expects paths after /api/v1/
+    const url = `${this.baseURL}${endpoint}`;
+
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          'Content-Type': 'application/json',
+          ...options?.headers,
+        },
+      });
+
+      const data = await response.json();
+
+      if (!response.ok) {
+        return {
+          success: false,
+          error: data.error || {
+            code: 'INTERNAL_ERROR',
+            message: 'An unknown error occurred',
+          },
+        };
+      }
+
+      return data;
+    } catch (error) {
+      return {
+        success: false,
+        error: {
+          code: 'NETWORK_ERROR',
+          message: error instanceof Error ? error.message : 'Network request failed',
+        },
+      };
+    }
+  }
+
+  // Color Information
+  async getColorInfo(request: ColorInfoRequest): Promise<ApiResponse<ColorInfoData>> {
+    return this.request<ColorInfoData>('/colors/info', {
+      method: 'POST',
+      body: JSON.stringify(request),
+    });
+  }
+
+  // Format Conversion
+  async convertFormat(request: ConvertFormatRequest): Promise<ApiResponse<ConvertFormatData>> {
+    return this.request<ConvertFormatData>('/colors/convert', {
+      method: 'POST',
+      body: JSON.stringify(request),
+    });
+  }
+
+  // Color Manipulation
+  async lighten(request: ColorManipulationRequest): Promise<ApiResponse<ColorManipulationData>> {
+    return this.request<ColorManipulationData>('/colors/lighten', {
+      method: 'POST',
+      body: JSON.stringify(request),
+    });
+  }
+
+  async darken(request: ColorManipulationRequest): Promise<ApiResponse<ColorManipulationData>> {
+    return this.request<ColorManipulationData>('/colors/darken', {
+      method: 'POST',
+      body: JSON.stringify(request),
+    });
+  }
+
+  async saturate(request: ColorManipulationRequest): Promise<ApiResponse<ColorManipulationData>> {
+    return this.request<ColorManipulationData>('/colors/saturate', {
+      method: 'POST',
+      body: JSON.stringify(request),
+    });
+  }
+
+  async desaturate(request: ColorManipulationRequest): Promise<ApiResponse<ColorManipulationData>> {
+    return this.request<ColorManipulationData>('/colors/desaturate', {
+      method: 'POST',
+      body: JSON.stringify(request),
+    });
+  }
+
+  async rotate(request: ColorManipulationRequest): Promise<ApiResponse<ColorManipulationData>> {
+    return this.request<ColorManipulationData>('/colors/rotate', {
+      method: 'POST',
+      body: JSON.stringify(request),
+    });
+  }
+
+  async complement(colors: string[]): Promise<ApiResponse<ColorManipulationData>> {
+    return this.request<ColorManipulationData>('/colors/complement', {
+      method: 'POST',
+      body: JSON.stringify({ colors }),
+    });
+  }
+
+  async grayscale(colors: string[]): Promise<ApiResponse<ColorManipulationData>> {
+    return this.request<ColorManipulationData>('/colors/grayscale', {
+      method: 'POST',
+      body: JSON.stringify({ colors }),
+    });
+  }
+
+  async mix(request: ColorMixRequest): Promise<ApiResponse<ColorMixData>> {
+    return this.request<ColorMixData>('/colors/mix', {
+      method: 'POST',
+      body: JSON.stringify(request),
+    });
+  }
+
+  // Color Generation
+  async generateRandom(request: RandomColorsRequest): Promise<ApiResponse<RandomColorsData>> {
+    return this.request<RandomColorsData>('/colors/random', {
+      method: 'POST',
+      body: JSON.stringify(request),
+    });
+  }
+
+  async generateDistinct(request: DistinctColorsRequest): Promise<ApiResponse<DistinctColorsData>> {
+    return this.request<DistinctColorsData>('/colors/distinct', {
+      method: 'POST',
+      body: JSON.stringify(request),
+    });
+  }
+
+  async generateGradient(request: GradientRequest): Promise<ApiResponse<GradientData>> {
+    return this.request<GradientData>('/colors/gradient', {
+      method: 'POST',
+      body: JSON.stringify(request),
+    });
+  }
+
+  // Color Analysis
+  async calculateDistance(request: ColorDistanceRequest): Promise<ApiResponse<ColorDistanceData>> {
+    return this.request<ColorDistanceData>('/colors/distance', {
+      method: 'POST',
+      body: JSON.stringify(request),
+    });
+  }
+
+  async sortColors(request: ColorSortRequest): Promise<ApiResponse<ColorSortData>> {
+    return this.request<ColorSortData>('/colors/sort', {
+      method: 'POST',
+      body: JSON.stringify(request),
+    });
+  }
+
+  // Accessibility
+  async simulateColorBlindness(request: ColorBlindnessRequest): Promise<ApiResponse<ColorBlindnessData>> {
+    return this.request<ColorBlindnessData>('/colors/colorblind', {
+      method: 'POST',
+      body: JSON.stringify(request),
+    });
+  }
+
+  async getTextColor(request: TextColorRequest): Promise<ApiResponse<TextColorData>> {
+    return this.request<TextColorData>('/colors/textcolor', {
+      method: 'POST',
+      body: JSON.stringify(request),
+    });
+  }
+
+  // Named Colors
+  async getNamedColors(): Promise<ApiResponse<NamedColorsData>> {
+    return this.request<NamedColorsData>('/colors/names', {
+      method: 'GET',
+    });
+  }
+
+  async searchNamedColors(request: NamedColorSearchRequest): Promise<ApiResponse<NamedColorSearchData>> {
+    return this.request<NamedColorSearchData>('/colors/names/search', {
+      method: 'POST',
+      body: JSON.stringify(request),
+    });
+  }
+
+  // System
+  async getHealth(): Promise<ApiResponse<HealthData>> {
+    return this.request<HealthData>('/health', {
+      method: 'GET',
+    });
+  }
+
+  async getCapabilities(): Promise<ApiResponse<CapabilitiesData>> {
+    return this.request<CapabilitiesData>('/capabilities', {
+      method: 'GET',
+    });
+  }
+
+  // Palette Generation
+  async generatePalette(request: PaletteGenerateRequest): Promise<ApiResponse<PaletteGenerateData>> {
+    return this.request<PaletteGenerateData>('/palettes/generate', {
+      method: 'POST',
+      body: JSON.stringify(request),
+    });
+  }
+}
+
+// Export singleton instance
+// Now using WASM client for zero-latency, offline-first color operations
+export const pastelAPI = pastelWASM;