@moontra/moonui-pro 2.0.22 → 2.1.0

package/src/utils/data-processing.ts

@@ -0,0 +1,151 @@
+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-guard.tsx

@@ -0,0 +1,177 @@
+"use client"
+
+import React, { useEffect, useState } from 'react';
+
+const API_BASE = process.env.NEXT_PUBLIC_MOONUI_API || 'https://moonui.dev';
+
+interface LicenseCheckResult {
+  valid: boolean;
+  error?: string;
+  loading: boolean;
+}
+
+// In-memory cache for license check
+let licenseCache: {
+  result: boolean;
+  timestamp: number;
+} | null = null;
+
+const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
+
+export function useLicenseCheck(): LicenseCheckResult {
+  const [state, setState] = useState<LicenseCheckResult>({
+    valid: false,
+    loading: true,
+    error: undefined
+  });
+
+  useEffect(() => {
+    checkLicense().then(result => {
+      setState({
+        valid: result.valid,
+        loading: false,
+        error: result.error
+      });
+    });
+  }, []);
+
+  return state;
+}
+
+async function checkLicense(): Promise<{ valid: boolean; error?: string }> {
+  // Check cache first
+  if (licenseCache && Date.now() - licenseCache.timestamp < CACHE_DURATION) {
+    return { valid: licenseCache.result };
+  }
+
+  try {
+    // Get auth token from localStorage or cookie
+    const token = getAuthToken();
+    
+    if (!token) {
+      return { valid: false, error: 'No authentication token found' };
+    }
+
+    const response = await fetch(`${API_BASE}/api/license/verify`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        component: 'runtime-check',
+        source: 'moonui-pro'
+      })
+    });
+
+    if (!response.ok) {
+      return { valid: false, error: 'License verification failed' };
+    }
+
+    const data = await response.json();
+    
+    // Cache the result
+    licenseCache = {
+      result: data.valid && data.planType !== 'free',
+      timestamp: Date.now()
+    };
+
+    return { valid: licenseCache.result };
+  } catch (error) {
+    return { valid: false, error: 'Network error during license check' };
+  }
+}
+
+function getAuthToken(): string | null {
+  // First check localStorage (for client-side)
+  if (typeof window !== 'undefined') {
+    const stored = localStorage.getItem('moonui_auth');
+    if (stored) {
+      try {
+        const auth = JSON.parse(stored);
+        return auth.accessToken;
+      } catch {
+        // Invalid JSON
+      }
+    }
+  }
+
+  // Check cookies (for SSR)
+  if (typeof document !== 'undefined') {
+    const cookies = document.cookie.split(';');
+    for (const cookie of cookies) {
+      const [name, value] = cookie.trim().split('=');
+      if (name === 'moonui_token') {
+        return decodeURIComponent(value);
+      }
+    }
+  }
+
+  return null;
+}
+
+// License Guard HOC
+export function withLicenseGuard<P extends object>(
+  Component: React.ComponentType<P>,
+  options?: {
+    fallback?: React.ReactNode;
+    onUnauthorized?: () => void;
+  }
+) {
+  return function LicenseGuardedComponent(props: P) {
+    const { valid, loading, error } = useLicenseCheck();
+
+    useEffect(() => {
+      if (!loading && !valid && options?.onUnauthorized) {
+        options.onUnauthorized();
+      }
+    }, [loading, valid]);
+
+    if (loading) {
+      return (
+        <div className="flex items-center justify-center p-8">
+          <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-gray-900"></div>
+        </div>
+      );
+    }
+
+    if (!valid) {
+      if (options?.fallback) {
+        return <>{options.fallback}</>;
+      }
+
+      return (
+        <div className="rounded-lg border border-red-200 bg-red-50 p-8 text-center">
+          <h3 className="text-lg font-semibold text-red-900 mb-2">
+            Pro License Required
+          </h3>
+          <p className="text-red-700 mb-4">
+            This component requires a MoonUI Pro license.
+          </p>
+          <a
+            href="https://moonui.dev/pricing"
+            className="inline-flex items-center justify-center rounded-md bg-red-600 px-4 py-2 text-sm font-medium text-white hover:bg-red-700"
+          >
+            Get Pro License
+          </a>
+          {error && (
+            <p className="text-xs text-red-600 mt-4">
+              Error: {error}
+            </p>
+          )}
+        </div>
+      );
+    }
+
+    return <Component {...props} />;
+  };
+}
+
+// Self-protecting component wrapper
+export function ProComponent<P extends object>({
+  component: Component,
+  ...props
+}: P & { component: React.ComponentType<P> }) {
+  const GuardedComponent = withLicenseGuard(Component);
+  return <GuardedComponent {...(props as P)} />;
+}

package/src/utils/license-validator.tsx

@@ -0,0 +1,183 @@
+/**
+ * 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';

package/src/utils/package-guard.ts

@@ -0,0 +1,60 @@
+/**
+ * Package Access Guard
+ * Prevents direct NPM package usage without CLI
+ */
+
+const ALLOWED_CALLERS = [
+  '@moontra/moonui-cli',
+  'moonui-cli',
+  '.moonui/temp', // CLI temp directory
+];
+
+const DEV_MODE = process.env.NODE_ENV === 'development';
+
+export function checkPackageAccess(): void {
+  // Skip in development mode for easier testing
+  if (DEV_MODE) {
+    return;
+  }
+
+  // Check if running in a browser (client-side)
+  if (typeof window !== 'undefined') {
+    // Client-side access is allowed after server-side validation
+    return;
+  }
+
+  // Server-side check
+  const stack = new Error().stack;
+  
+  if (!stack) {
+    throw new Error(
+      'MoonUI Pro: This package can only be used via @moontra/moonui-cli. ' +
+      'Please install components using: npx @moontra/moonui-cli add <component>'
+    );
+  }
+
+  // Check if called from allowed sources
+  const isAllowed = ALLOWED_CALLERS.some(caller => stack.includes(caller));
+  
+  // Also check for local file paths that indicate CLI usage
+  const isCliGenerated = stack.includes('/components/ui/') || 
+                        stack.includes('/components/pro/');
+
+  if (!isAllowed && !isCliGenerated) {
+    console.error('Stack trace:', stack);
+    throw new Error(
+      'MoonUI Pro: Unauthorized package access detected.\n' +
+      'This package can only be used via @moontra/moonui-cli.\n' +
+      'Install components using: npx @moontra/moonui-cli add <component>\n\n' +
+      'If you have a Pro license, make sure to:\n' +
+      '1. Login with: npx @moontra/moonui-cli login\n' +
+      '2. Install components via CLI\n\n' +
+      'Learn more at: https://moonui.dev/docs/installation'
+    );
+  }
+}
+
+// Auto-check on import
+if (typeof window === 'undefined') {
+  checkPackageAccess();
+}