@moontra/moonui-pro 2.20.1 → 2.20.3

package/src/utils/chart-helpers.ts

@@ -1,357 +0,0 @@
-import { ChartDataPoint, ChartSeries } from '../components/advanced-chart'
-
-interface ChartTheme {
-  colors: string[]
-  backgroundColor: string
-  textColor: string
-  gridColor: string
-  tooltipBackground: string
-  tooltipBorder: string
-}
-
-export const CHART_THEMES: Record<string, ChartTheme> = {
-  default: {
-    colors: ['#3b82f6', '#ef4444', '#10b981', '#f59e0b', '#8b5cf6', '#06b6d4', '#f97316', '#84cc16', '#ec4899', '#6366f1'],
-    backgroundColor: '#ffffff',
-    textColor: '#374151',
-    gridColor: '#e5e7eb',
-    tooltipBackground: '#1f2937',
-    tooltipBorder: '#374151',
-  },
-  dark: {
-    colors: ['#60a5fa', '#f87171', '#34d399', '#fbbf24', '#a78bfa', '#22d3ee', '#fb923c', '#a3e635', '#f472b6', '#818cf8'],
-    backgroundColor: '#1f2937',
-    textColor: '#f9fafb',
-    gridColor: '#374151',
-    tooltipBackground: '#374151',
-    tooltipBorder: '#4b5563',
-  },
-  minimal: {
-    colors: ['#000000', '#666666', '#999999', '#cccccc'],
-    backgroundColor: '#ffffff',
-    textColor: '#000000',
-    gridColor: '#f3f4f6',
-    tooltipBackground: '#000000',
-    tooltipBorder: '#000000',
-  },
-}
-
-export function generateChartData(
-  count: number,
-  series: string[],
-  options?: {
-    startDate?: Date
-    interval?: 'hour' | 'day' | 'week' | 'month'
-    trend?: 'up' | 'down' | 'random'
-    baseValue?: number
-    variance?: number
-  }
-): ChartDataPoint[] {
-  const {
-    startDate = new Date(),
-    interval = 'day',
-    trend = 'random',
-    baseValue = 100,
-    variance = 20,
-  } = options || {}
-
-  const data: ChartDataPoint[] = []
-  const current = new Date(startDate)
-
-  for (let i = 0; i < count; i++) {
-    const point: ChartDataPoint = {
-      name: formatDateForInterval(current, interval),
-      timestamp: current.getTime(),
-    }
-
-    series.forEach((seriesName, index) => {
-      let value = baseValue
-
-      if (trend === 'up') {
-        value += (i * 5) + (Math.random() - 0.5) * variance
-      } else if (trend === 'down') {
-        value -= (i * 5) + (Math.random() - 0.5) * variance
-      } else {
-        value += (Math.random() - 0.5) * variance * 2
-      }
-
-      // Add some series-specific variation
-      value += index * 10 + (Math.random() - 0.5) * 10
-
-      point[seriesName] = Math.max(0, Math.round(value))
-    })
-
-    data.push(point)
-
-    // Increment date based on interval
-    switch (interval) {
-      case 'hour':
-        current.setHours(current.getHours() + 1)
-        break
-      case 'day':
-        current.setDate(current.getDate() + 1)
-        break
-      case 'week':
-        current.setDate(current.getDate() + 7)
-        break
-      case 'month':
-        current.setMonth(current.getMonth() + 1)
-        break
-    }
-  }
-
-  return data
-}
-
-function formatDateForInterval(date: Date, interval: 'hour' | 'day' | 'week' | 'month'): string {
-  switch (interval) {
-    case 'hour':
-      return date.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' })
-    case 'day':
-      return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' })
-    case 'week':
-      return `Week ${getWeekNumber(date)}`
-    case 'month':
-      return date.toLocaleDateString('en-US', { month: 'short', year: 'numeric' })
-    default:
-      return date.toLocaleDateString()
-  }
-}
-
-function getWeekNumber(date: Date): number {
-  const firstDayOfYear = new Date(date.getFullYear(), 0, 1)
-  const pastDaysOfYear = (date.getTime() - firstDayOfYear.getTime()) / 86400000
-  return Math.ceil((pastDaysOfYear + firstDayOfYear.getDay() + 1) / 7)
-}
-
-export function calculateMovingAverage(data: ChartDataPoint[], key: string, window: number): ChartDataPoint[] {
-  if (window <= 0 || window > data.length) return data
-
-  return data.map((point, index) => {
-    if (index < window - 1) return point
-
-    const windowData = data.slice(index - window + 1, index + 1)
-    const sum = windowData.reduce((acc, item) => acc + (Number(item[key]) || 0), 0)
-    const average = sum / window
-
-    return {
-      ...point,
-      [`${key}_ma${window}`]: Math.round(average * 100) / 100,
-    }
-  })
-}
-
-export function detectOutliers(data: ChartDataPoint[], key: string, threshold: number = 2): ChartDataPoint[] {
-  const values = data.map(point => Number(point[key]) || 0)
-  const mean = values.reduce((sum, val) => sum + val, 0) / values.length
-  const variance = values.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / values.length
-  const stdDev = Math.sqrt(variance)
-
-  return data.map(point => {
-    const value = Number(point[key]) || 0
-    const zScore = Math.abs((value - mean) / stdDev)
-    
-    return {
-      ...point,
-      [`${key}_outlier`]: zScore > threshold,
-      [`${key}_zscore`]: Math.round(zScore * 100) / 100,
-    }
-  })
-}
-
-export function interpolateData(data: ChartDataPoint[], key: string, method: 'linear' | 'polynomial' = 'linear'): ChartDataPoint[] {
-  const result = [...data]
-  
-  for (let i = 0; i < result.length; i++) {
-    const point = result[i]
-    
-    if (point[key] == null || point[key] === '') {
-      // Find nearest non-null values
-      let prevIndex = i - 1
-      let nextIndex = i + 1
-      
-      while (prevIndex >= 0 && (result[prevIndex][key] == null || result[prevIndex][key] === '')) {
-        prevIndex--
-      }
-      
-      while (nextIndex < result.length && (result[nextIndex][key] == null || result[nextIndex][key] === '')) {
-        nextIndex++
-      }
-      
-      if (prevIndex >= 0 && nextIndex < result.length) {
-        const prevValue = Number(result[prevIndex][key])
-        const nextValue = Number(result[nextIndex][key])
-        
-        if (method === 'linear') {
-          const ratio = (i - prevIndex) / (nextIndex - prevIndex)
-          point[key] = prevValue + (nextValue - prevValue) * ratio
-        }
-      } else if (prevIndex >= 0) {
-        point[key] = result[prevIndex][key]
-      } else if (nextIndex < result.length) {
-        point[key] = result[nextIndex][key]
-      }
-    }
-  }
-  
-  return result
-}
-
-export function aggregateDataByPeriod(
-  data: ChartDataPoint[],
-  period: 'hour' | 'day' | 'week' | 'month',
-  aggregations: Record<string, 'sum' | 'avg' | 'min' | 'max' | 'count'>
-): ChartDataPoint[] {
-  const groups: Record<string, ChartDataPoint[]> = {}
-  
-  data.forEach(point => {
-    const timestamp = point.timestamp ? new Date(point.timestamp as number) : new Date()
-    const key = formatDateForInterval(timestamp, period)
-    
-    if (!groups[key]) {
-      groups[key] = []
-    }
-    groups[key].push(point)
-  })
-  
-  return Object.entries(groups).map(([key, groupData]) => {
-    const result: ChartDataPoint = { name: key }
-    
-    Object.entries(aggregations).forEach(([field, operation]) => {
-      const values = groupData.map(point => Number(point[field]) || 0)
-      
-      switch (operation) {
-        case 'sum':
-          result[field] = values.reduce((sum, val) => sum + val, 0)
-          break
-        case 'avg':
-          result[field] = values.reduce((sum, val) => sum + val, 0) / values.length
-          break
-        case 'min':
-          result[field] = Math.min(...values)
-          break
-        case 'max':
-          result[field] = Math.max(...values)
-          break
-        case 'count':
-          result[field] = values.length
-          break
-      }
-    })
-    
-    return result
-  })
-}
-
-export function exportChartAsImage(
-  chartElement: HTMLElement,
-  filename: string = 'chart',
-  format: 'png' | 'jpeg' | 'svg' = 'png'
-): void {
-  // This would typically use html2canvas or similar library
-  // For now, we'll provide a basic implementation
-  console.log(`Exporting chart as ${format} with filename: ${filename}`)
-  
-  // Implementation would go here
-  // This is a placeholder for the actual export functionality
-}
-
-export function exportChartData(
-  data: ChartDataPoint[],
-  filename: string = 'chart-data',
-  format: 'json' | 'csv' = 'json'
-): void {
-  let content: string
-  let mimeType: string
-  
-  if (format === 'json') {
-    content = JSON.stringify(data, null, 2)
-    mimeType = 'application/json'
-  } else {
-    // CSV export
-    const headers = Object.keys(data[0] || {})
-    const csvRows = [
-      headers.join(','),
-      ...data.map(row => 
-        headers.map(header => {
-          const value = row[header]
-          return typeof value === 'string' && value.includes(',') 
-            ? `"${value}"` 
-            : value
-        }).join(',')
-      )
-    ]
-    content = csvRows.join('\n')
-    mimeType = 'text/csv'
-  }
-  
-  const blob = new Blob([content], { type: mimeType })
-  const url = window.URL.createObjectURL(blob)
-  const link = document.createElement('a')
-  link.href = url
-  link.download = `${filename}.${format}`
-  document.body.appendChild(link)
-  link.click()
-  document.body.removeChild(link)
-  window.URL.revokeObjectURL(url)
-}
-
-// Gradient color generator
-export function generateGradientColors(baseColor: string, count: number = 5): string[] {
-  const colors: string[] = []
-  const rgb = hexToRgb(baseColor)
-  
-  if (!rgb) return [baseColor]
-  
-  for (let i = 0; i < count; i++) {
-    const factor = i / (count - 1)
-    const r = Math.round(rgb.r + (255 - rgb.r) * factor * 0.5)
-    const g = Math.round(rgb.g + (255 - rgb.g) * factor * 0.5)
-    const b = Math.round(rgb.b + (255 - rgb.b) * factor * 0.5)
-    colors.push(`rgb(${r}, ${g}, ${b})`)
-  }
-  
-  return colors
-}
-
-function hexToRgb(hex: string): { r: number; g: number; b: number } | null {
-  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex)
-  return result ? {
-    r: parseInt(result[1], 16),
-    g: parseInt(result[2], 16),
-    b: parseInt(result[3], 16)
-  } : null
-}
-
-// Performance optimization helpers
-export function throttleChartData(data: ChartDataPoint[], maxPoints: number = 1000): ChartDataPoint[] {
-  if (data.length <= maxPoints) return data
-  
-  const step = Math.ceil(data.length / maxPoints)
-  return data.filter((_, index) => index % step === 0)
-}
-
-// Format large numbers
-export function formatChartValue(value: number): string {
-  if (value >= 1e9) return `${(value / 1e9).toFixed(1)}B`
-  if (value >= 1e6) return `${(value / 1e6).toFixed(1)}M`
-  if (value >= 1e3) return `${(value / 1e3).toFixed(1)}K`
-  return value.toString()
-}
-
-// Calculate chart statistics
-export function calculateChartStats(data: ChartDataPoint[], keys: string[]): Record<string, { min: number; max: number; avg: number; total: number }> {
-  const stats: Record<string, { min: number; max: number; avg: number; total: number }> = {}
-  
-  keys.forEach(key => {
-    const values = data.map(point => Number(point[key]) || 0)
-    stats[key] = {
-      min: Math.min(...values),
-      max: Math.max(...values),
-      avg: values.reduce((sum, val) => sum + val, 0) / values.length,
-      total: values.reduce((sum, val) => sum + val, 0)
-    }
-  })
-  
-  return stats
-}

package/src/utils/cn.ts

@@ -1,6 +0,0 @@
-import { type ClassValue, clsx } from 'clsx';
-import { twMerge } from 'tailwind-merge';
-
-export function cn(...inputs: ClassValue[]) {
-  return twMerge(clsx(inputs));
-}

package/src/utils/data-processing.ts

@@ -1,151 +0,0 @@
-export interface DataProcessor<T = any> {
-  filter: (data: T[], predicate: (item: T) => boolean) => T[]
-  sort: (data: T[], key: keyof T, direction?: 'asc' | 'desc') => T[]
-  group: (data: T[], key: keyof T) => Record<string, T[]>
-  aggregate: (data: T[], key: keyof T, operation: 'sum' | 'avg' | 'min' | 'max' | 'count') => number
-  paginate: (data: T[], page: number, pageSize: number) => T[]
-  search: (data: T[], query: string, searchKeys?: (keyof T)[]) => T[]
-  transform: <U>(data: T[], transformer: (item: T) => U) => U[]
-}
-
-export function createDataProcessor<T = any>(): DataProcessor<T> {
-  return {
-    filter: (data: T[], predicate: (item: T) => boolean) => {
-      return data.filter(predicate)
-    },
-
-    sort: (data: T[], key: keyof T, direction: 'asc' | 'desc' = 'asc') => {
-      return [...data].sort((a, b) => {
-        const aVal = a[key]
-        const bVal = b[key]
-        
-        if (aVal === bVal) return 0
-        
-        const comparison = aVal < bVal ? -1 : 1
-        return direction === 'asc' ? comparison : -comparison
-      })
-    },
-
-    group: (data: T[], key: keyof T) => {
-      return data.reduce((groups, item) => {
-        const groupKey = String(item[key])
-        if (!groups[groupKey]) {
-          groups[groupKey] = []
-        }
-        groups[groupKey].push(item)
-        return groups
-      }, {} as Record<string, T[]>)
-    },
-
-    aggregate: (data: T[], key: keyof T, operation: 'sum' | 'avg' | 'min' | 'max' | 'count') => {
-      const values = data.map(item => Number(item[key])).filter(val => !isNaN(val))
-      
-      if (values.length === 0) return 0
-      
-      switch (operation) {
-        case 'sum':
-          return values.reduce((sum, val) => sum + val, 0)
-        case 'avg':
-          return values.reduce((sum, val) => sum + val, 0) / values.length
-        case 'min':
-          return Math.min(...values)
-        case 'max':
-          return Math.max(...values)
-        case 'count':
-          return values.length
-        default:
-          return 0
-      }
-    },
-
-    paginate: (data: T[], page: number, pageSize: number) => {
-      const startIndex = (page - 1) * pageSize
-      const endIndex = startIndex + pageSize
-      return data.slice(startIndex, endIndex)
-    },
-
-    search: (data: T[], query: string, searchKeys?: (keyof T)[]) => {
-      if (!query.trim()) return data
-      
-      const lowerQuery = query.toLowerCase()
-      
-      return data.filter(item => {
-        const keysToSearch = searchKeys || Object.keys(item as Record<string, any>) as (keyof T)[]
-        
-        return keysToSearch.some(key => {
-          const value = item[key]
-          if (value == null) return false
-          return String(value).toLowerCase().includes(lowerQuery)
-        })
-      })
-    },
-
-    transform: <U>(data: T[], transformer: (item: T) => U) => {
-      return data.map(transformer)
-    }
-  }
-}
-
-// Utility functions for common data operations
-export function calculatePercentageChange(current: number, previous: number): number {
-  if (previous === 0) return current > 0 ? 100 : 0
-  return ((current - previous) / previous) * 100
-}
-
-export function formatNumber(value: number, options?: {
-  decimals?: number
-  currency?: string
-  percentage?: boolean
-  compact?: boolean
-}): string {
-  const { decimals = 2, currency, percentage = false, compact = false } = options || {}
-  
-  if (percentage) {
-    return `${value.toFixed(decimals)}%`
-  }
-  
-  if (currency) {
-    return new Intl.NumberFormat('en-US', {
-      style: 'currency',
-      currency,
-      minimumFractionDigits: decimals,
-      maximumFractionDigits: decimals,
-    }).format(value)
-  }
-  
-  if (compact && Math.abs(value) >= 1000) {
-    return new Intl.NumberFormat('en-US', {
-      notation: 'compact',
-      minimumFractionDigits: 0,
-      maximumFractionDigits: 1,
-    }).format(value)
-  }
-  
-  return value.toFixed(decimals)
-}
-
-export function generateDateRange(start: Date, end: Date, interval: 'day' | 'week' | 'month' = 'day'): Date[] {
-  const dates: Date[] = []
-  const current = new Date(start)
-  
-  while (current <= end) {
-    dates.push(new Date(current))
-    
-    switch (interval) {
-      case 'day':
-        current.setDate(current.getDate() + 1)
-        break
-      case 'week':
-        current.setDate(current.getDate() + 7)
-        break
-      case 'month':
-        current.setMonth(current.getMonth() + 1)
-        break
-    }
-  }
-  
-  return dates
-}
-
-// debounce function removed to avoid conflicts with @moontra/moonui
-// Use debounce from @moontra/moonui instead

package/src/utils/license-validator.tsx

@@ -1,183 +0,0 @@
-/**
- * License Validation System for MoonUI Pro
- * This ensures that only licensed users can access pro components
- */
-
-interface LicenseData {
-  key: string;
-  email: string;
-  expiresAt?: string;
-  features?: string[];
-}
-
-class LicenseValidator {
-  private static instance: LicenseValidator;
-  private licenseData: LicenseData | null = null;
-  private validationCache: Map<string, boolean> = new Map();
-  private readonly VALIDATION_ENDPOINT = 'https://api.moonui.dev/v1/license/validate';
-
-  private constructor() {
-    // Initialize license from environment or stored data
-    this.initializeLicense();
-  }
-
-  static getInstance(): LicenseValidator {
-    if (!LicenseValidator.instance) {
-      LicenseValidator.instance = new LicenseValidator();
-    }
-    return LicenseValidator.instance;
-  }
-
-  private initializeLicense(): void {
-    // Check environment variables
-    const licenseKey = process.env.MOONUI_LICENSE_KEY;
-    const licenseEmail = process.env.MOONUI_LICENSE_EMAIL;
-    
-    if (licenseKey && licenseEmail) {
-      this.licenseData = {
-        key: licenseKey,
-        email: licenseEmail
-      };
-    }
-    
-    // Check for license file
-    try {
-      const fs = require('fs');
-      const path = require('path');
-      const licensePath = path.join(process.cwd(), '.moonui', 'license.json');
-      
-      if (fs.existsSync(licensePath)) {
-        const fileData = fs.readFileSync(licensePath, 'utf-8');
-        this.licenseData = JSON.parse(fileData);
-      }
-    } catch (error) {
-      // Ignore file reading errors in browser environment
-    }
-  }
-
-  async validateLicense(): Promise<boolean> {
-    if (!this.licenseData) {
-      console.warn('[MoonUI Pro] No license found. Please run "moonui add <pro-component>" to activate your license.');
-      return false;
-    }
-
-    // Check cache first
-    const cacheKey = `${this.licenseData.key}-${this.licenseData.email}`;
-    if (this.validationCache.has(cacheKey)) {
-      return this.validationCache.get(cacheKey)!;
-    }
-
-    // Check expiration date if available
-    if (this.licenseData.expiresAt) {
-      const expiryDate = new Date(this.licenseData.expiresAt);
-      if (expiryDate < new Date()) {
-        console.error('[MoonUI Pro] License has expired. Please renew your subscription.');
-        this.validationCache.set(cacheKey, false);
-        return false;
-      }
-    }
-
-    // Validate with server (with fallback for offline mode)
-    try {
-      const response = await fetch(this.VALIDATION_ENDPOINT, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-          key: this.licenseData.key,
-          email: this.licenseData.email,
-        }),
-      });
-
-      if (response.ok) {
-        const result = await response.json();
-        const isValid = result.valid === true;
-        this.validationCache.set(cacheKey, isValid);
-        
-        if (!isValid) {
-          console.error('[MoonUI Pro] Invalid license. Please check your license key and email.');
-        }
-        
-        return isValid;
-      }
-    } catch (error) {
-      // Fallback for offline mode or network errors
-      // Allow usage if license format is valid
-      const isValidFormat = this.isValidLicenseFormat();
-      this.validationCache.set(cacheKey, isValidFormat);
-      return isValidFormat;
-    }
-
-    return false;
-  }
-
-  private isValidLicenseFormat(): boolean {
-    if (!this.licenseData) return false;
-    
-    // Basic format validation
-    const { key, email } = this.licenseData;
-    return (
-      typeof key === 'string' &&
-      key.length >= 32 &&
-      typeof email === 'string' &&
-      email.includes('@')
-    );
-  }
-
-  hasFeature(feature: string): boolean {
-    if (!this.licenseData || !this.licenseData.features) {
-      return false;
-    }
-    return this.licenseData.features.includes(feature);
-  }
-
-  getLicenseInfo(): Readonly<LicenseData> | null {
-    return this.licenseData ? { ...this.licenseData } : null;
-  }
-}
-
-// Export singleton instance
-export const licenseValidator = LicenseValidator.getInstance();
-
-// Higher-order component for license protection
-export function withLicenseProtection<P extends object>(
-  Component: React.ComponentType<P>,
-  componentName: string
-): React.ComponentType<P> {
-  return (props: P) => {
-    const [isValid, setIsValid] = React.useState<boolean | null>(null);
-
-    React.useEffect(() => {
-      licenseValidator.validateLicense().then(setIsValid);
-    }, []);
-
-    if (isValid === null) {
-      // Loading state
-      return null;
-    }
-
-    if (!isValid) {
-      if (process.env.NODE_ENV === 'development') {
-        console.error(
-          `[MoonUI Pro] Component "${componentName}" requires a valid Pro license.\n` +
-          'Get your license at: https://moonui.dev/pricing'
-        );
-      }
-      
-      // Return a placeholder in production
-      return (
-        <div className="rounded-lg border-2 border-dashed border-gray-300 p-4 text-center">
-          <p className="text-sm text-gray-500">
-            This component requires a MoonUI Pro license.
-          </p>
-        </div>
-      );
-    }
-
-    return <Component {...props} />;
-  };
-}
-
-// Export React for component usage
-import * as React from 'react';