create-fluxstack 1.14.0 → 1.15.0

package/core/client/components/Live.tsx

@@ -1,111 +0,0 @@
-// 🔥 FluxStack Live - Hook para componentes real-time
-//
-// Uso:
-//   import { Live } from '@/core/client'
-//   import { LiveForm } from '@server/live/LiveForm'
-//
-//   // Sem estado inicial - usa defaultState do componente
-//   const form = Live.use(LiveForm)
-//
-//   // Com estado inicial parcial (override)
-//   const form = Live.use(LiveForm, { name: 'João' })
-//
-//   return (
-//     <input {...form.$field('name', { syncOn: 'blur' })} />
-//     <button onClick={() => form.submit()}>Enviar</button>
-//   )
-//
-// 🔥 Broadcasts Tipados (Discriminated Union):
-//   // No servidor, defina a interface de broadcasts:
-//   export interface LiveFormBroadcasts {
-//     FORM_SUBMITTED: { formId: string; data: any }
-//     FIELD_CHANGED: { field: string; value: any }
-//   }
-//
-//   // No cliente, use com tipagem automática (discriminated union):
-//   import { LiveForm, type LiveFormBroadcasts } from '@server/live/LiveForm'
-//
-//   const form = Live.use(LiveForm)
-//   form.$onBroadcast<LiveFormBroadcasts>((event) => {
-//     switch (event.type) {
-//       case 'FORM_SUBMITTED':
-//         console.log(event.data.formId) // ✅ Tipado como string!
-//         break
-//       case 'FIELD_CHANGED':
-//         console.log(event.data.field)  // ✅ Tipado como string!
-//         break
-//     }
-//   })
-
-import { useLiveComponent } from '../hooks/useLiveComponent'
-import type { UseLiveComponentOptions, LiveProxy, LiveProxyWithBroadcasts } from '../hooks/useLiveComponent'
-
-// ===== Tipos para Inferência do Servidor =====
-
-// Extrai o defaultState estático da classe
-type ExtractDefaultState<T> = T extends { defaultState: infer S }
-  ? S extends Record<string, any> ? S : Record<string, any>
-  : Record<string, any>
-
-// Extrai o State da classe do servidor (via instance.state)
-type ExtractState<T> = T extends { new(...args: any[]): { state: infer S } }
-  ? S extends Record<string, any> ? S : Record<string, any>
-  : ExtractDefaultState<T>
-
-// Extrai os nomes de publicActions como union type
-type ExtractPublicActionNames<T> = T extends { publicActions: readonly (infer A)[] }
-  ? A extends string ? A : never
-  : never
-
-// Extrai as Actions respeitando publicActions (MANDATORY)
-// - Se publicActions está definido: somente métodos listados são expostos
-// - Se publicActions NÃO está definido: nenhuma action disponível (secure by default)
-type ExtractActions<T> = T extends { new(...args: any[]): infer Instance }
-  ? T extends { publicActions: readonly string[] }
-    ? {
-        [K in keyof Instance as K extends ExtractPublicActionNames<T>
-          ? Instance[K] extends (...args: any[]) => Promise<any> ? K : never
-          : never
-        ]: Instance[K]
-      }
-    : Record<string, never>
-  : Record<string, never>
-
-// ===== Opções do Live.use() =====
-
-interface LiveUseOptions<TState> extends UseLiveComponentOptions {
-  /** Estado inicial para o componente */
-  initialState?: Partial<TState>
-}
-
-// ===== Hook Principal =====
-
-function useLive<
-  T extends { new(...args: any[]): any; defaultState?: Record<string, any>; componentName: string; publicActions?: readonly string[] },
-  TBroadcasts extends Record<string, any> = Record<string, any>
->(
-  ComponentClass: T,
-  options?: LiveUseOptions<ExtractState<T>>
-): LiveProxyWithBroadcasts<ExtractState<T>, ExtractActions<T>, TBroadcasts> {
-  // Use static componentName (required for production builds with minification)
-  const componentName = ComponentClass.componentName
-
-  // Usa defaultState da classe se não passar initialState
-  const defaultState = (ComponentClass as any).defaultState || {}
-  const { initialState, ...restOptions } = options || {}
-  const mergedState = { ...defaultState, ...initialState } as ExtractState<T>
-
-  return useLiveComponent<ExtractState<T>, ExtractActions<T>, TBroadcasts>(
-    componentName,
-    mergedState,
-    restOptions
-  )
-}
-
-// ===== Export =====
-
-export const Live = {
-  use: useLive
-}
-
-export default Live

package/core/client/hooks/AdaptiveChunkSizer.ts

@@ -1,215 +0,0 @@
-// 🚀 Adaptive Chunk Sizing - Dynamic chunk size adjustment based on connection speed
-// Automatically optimizes upload speed by adjusting chunk sizes
-
-export interface AdaptiveChunkConfig {
-  minChunkSize: number      // Minimum chunk size (default: 16KB)
-  maxChunkSize: number      // Maximum chunk size (default: 1MB)
-  initialChunkSize: number  // Starting chunk size (default: 64KB)
-  targetLatency: number     // Target latency per chunk in ms (default: 200ms)
-  adjustmentFactor: number  // How aggressively to adjust (default: 1.5)
-  measurementWindow: number // Number of chunks to measure (default: 3)
-}
-
-export interface ChunkMetrics {
-  chunkIndex: number
-  chunkSize: number
-  startTime: number
-  endTime: number
-  latency: number
-  throughput: number // bytes per second
-  success: boolean
-}
-
-export class AdaptiveChunkSizer {
-  private config: Required<AdaptiveChunkConfig>
-  private currentChunkSize: number
-  private metrics: ChunkMetrics[] = []
-  private consecutiveErrors = 0
-  private consecutiveSuccesses = 0
-
-  constructor(config: Partial<AdaptiveChunkConfig> = {}) {
-    this.config = {
-      minChunkSize: config.minChunkSize ?? 16 * 1024,      // 16KB
-      maxChunkSize: config.maxChunkSize ?? 1024 * 1024,    // 1MB
-      initialChunkSize: config.initialChunkSize ?? 64 * 1024, // 64KB
-      targetLatency: config.targetLatency ?? 200,          // 200ms
-      adjustmentFactor: config.adjustmentFactor ?? 1.5,
-      measurementWindow: config.measurementWindow ?? 3
-    }
-
-    this.currentChunkSize = this.config.initialChunkSize
-  }
-
-  /**
-   * Get the current optimal chunk size
-   */
-  getChunkSize(): number {
-    return this.currentChunkSize
-  }
-
-  /**
-   * Record the start of a chunk upload
-   */
-  recordChunkStart(chunkIndex: number): number {
-    return Date.now()
-  }
-
-  /**
-   * Record the completion of a chunk upload and adjust chunk size
-   */
-  recordChunkComplete(
-    chunkIndex: number,
-    chunkSize: number,
-    startTime: number,
-    success: boolean
-  ): void {
-    const endTime = Date.now()
-    const latency = endTime - startTime
-    const throughput = success ? (chunkSize / latency) * 1000 : 0 // bytes per second
-
-    const metric: ChunkMetrics = {
-      chunkIndex,
-      chunkSize,
-      startTime,
-      endTime,
-      latency,
-      throughput,
-      success
-    }
-
-    this.metrics.push(metric)
-
-    // Keep only recent measurements
-    if (this.metrics.length > this.config.measurementWindow * 2) {
-      this.metrics = this.metrics.slice(-this.config.measurementWindow * 2)
-    }
-
-    if (success) {
-      this.consecutiveSuccesses++
-      this.consecutiveErrors = 0
-      this.adjustChunkSizeUp(latency)
-    } else {
-      this.consecutiveErrors++
-      this.consecutiveSuccesses = 0
-      this.adjustChunkSizeDown()
-    }
-
-    console.log(`📊 Adaptive Chunk Stats:`, {
-      chunkIndex,
-      currentSize: this.formatBytes(this.currentChunkSize),
-      latency: `${latency}ms`,
-      throughput: `${this.formatBytes(throughput)}/s`,
-      avgThroughput: `${this.formatBytes(this.getAverageThroughput())}/s`,
-      success
-    })
-  }
-
-  /**
-   * Increase chunk size if connection is fast
-   */
-  private adjustChunkSizeUp(latency: number): void {
-    // Only increase if we have enough successful measurements
-    if (this.consecutiveSuccesses < 2) return
-
-    // Only increase if latency is below target
-    if (latency > this.config.targetLatency) return
-
-    // Calculate new chunk size based on how much faster we are than target
-    const latencyRatio = this.config.targetLatency / latency
-    let newSize = Math.floor(this.currentChunkSize * Math.min(latencyRatio, this.config.adjustmentFactor))
-
-    // Cap at max chunk size
-    newSize = Math.min(newSize, this.config.maxChunkSize)
-
-    if (newSize > this.currentChunkSize) {
-      console.log(`⬆️ Increasing chunk size: ${this.formatBytes(this.currentChunkSize)} → ${this.formatBytes(newSize)}`)
-      this.currentChunkSize = newSize
-    }
-  }
-
-  /**
-   * Decrease chunk size if connection is slow or unstable
-   */
-  private adjustChunkSizeDown(): void {
-    // Decrease more aggressively on errors
-    const decreaseFactor = this.consecutiveErrors > 1 ? 2 : this.config.adjustmentFactor
-
-    let newSize = Math.floor(this.currentChunkSize / decreaseFactor)
-
-    // Cap at min chunk size
-    newSize = Math.max(newSize, this.config.minChunkSize)
-
-    if (newSize < this.currentChunkSize) {
-      console.log(`⬇️ Decreasing chunk size: ${this.formatBytes(this.currentChunkSize)} → ${this.formatBytes(newSize)}`)
-      this.currentChunkSize = newSize
-    }
-  }
-
-  /**
-   * Get average throughput from recent measurements
-   */
-  getAverageThroughput(): number {
-    if (this.metrics.length === 0) return 0
-
-    const recentMetrics = this.metrics
-      .slice(-this.config.measurementWindow)
-      .filter(m => m.success)
-
-    if (recentMetrics.length === 0) return 0
-
-    const totalThroughput = recentMetrics.reduce((sum, m) => sum + m.throughput, 0)
-    return totalThroughput / recentMetrics.length
-  }
-
-  /**
-   * Get average latency from recent measurements
-   */
-  getAverageLatency(): number {
-    if (this.metrics.length === 0) return 0
-
-    const recentMetrics = this.metrics
-      .slice(-this.config.measurementWindow)
-      .filter(m => m.success)
-
-    if (recentMetrics.length === 0) return 0
-
-    const totalLatency = recentMetrics.reduce((sum, m) => sum + m.latency, 0)
-    return totalLatency / recentMetrics.length
-  }
-
-  /**
-   * Get current performance statistics
-   */
-  getStats() {
-    return {
-      currentChunkSize: this.currentChunkSize,
-      averageThroughput: this.getAverageThroughput(),
-      averageLatency: this.getAverageLatency(),
-      consecutiveSuccesses: this.consecutiveSuccesses,
-      consecutiveErrors: this.consecutiveErrors,
-      totalMeasurements: this.metrics.length,
-      config: this.config
-    }
-  }
-
-  /**
-   * Reset the adaptive chunking state
-   */
-  reset(): void {
-    this.currentChunkSize = this.config.initialChunkSize
-    this.metrics = []
-    this.consecutiveErrors = 0
-    this.consecutiveSuccesses = 0
-  }
-
-  /**
-   * Format bytes for display
-   */
-  private formatBytes(bytes: number): string {
-    if (bytes === 0) return '0 B'
-    const k = 1024
-    const sizes = ['B', 'KB', 'MB', 'GB']
-    const i = Math.floor(Math.log(bytes) / Math.log(k))
-    return Math.round(bytes / Math.pow(k, i) * 100) / 100 + ' ' + sizes[i]
-  }
-}

package/core/client/hooks/state-validator.ts

@@ -1,130 +0,0 @@
-// 🔥 State Validation Utilities
-
-import type { StateValidation, StateConflict, HybridState } from '@core/types/types'
-
-export class StateValidator {
-  /**
-   * Generate checksum for state object
-   */
-  static generateChecksum(state: any): string {
-    const json = JSON.stringify(state, Object.keys(state).sort())
-    let hash = 0
-    for (let i = 0; i < json.length; i++) {
-      const char = json.charCodeAt(i)
-      hash = ((hash << 5) - hash) + char
-      hash = hash & hash // Convert to 32-bit integer
-    }
-    return Math.abs(hash).toString(16)
-  }
-
-  /**
-   * Create validation metadata
-   */
-  static createValidation(
-    state: any, 
-    source: 'client' | 'server' | 'mount' = 'client'
-  ): StateValidation {
-    return {
-      checksum: this.generateChecksum(state),
-      version: Date.now(),
-      timestamp: Date.now(),
-      source
-    }
-  }
-
-  /**
-   * Compare two states and detect conflicts
-   */
-  static detectConflicts<T>(
-    clientState: T, 
-    serverState: T,
-    excludeFields: string[] = ['lastUpdated', 'version']
-  ): StateConflict[] {
-    const conflicts: StateConflict[] = []
-    
-    const clientKeys = Object.keys(clientState as any)
-    const serverKeys = Object.keys(serverState as any)
-    const allKeys = Array.from(new Set([...clientKeys, ...serverKeys]))
-
-    for (const key of allKeys) {
-      if (excludeFields.includes(key)) continue
-
-      const clientValue = (clientState as any)?.[key]
-      const serverValue = (serverState as any)?.[key]
-
-      if (JSON.stringify(clientValue) !== JSON.stringify(serverValue)) {
-        conflicts.push({
-          property: key as string,
-          clientValue,
-          serverValue,
-          timestamp: Date.now(),
-          resolved: false
-        })
-      }
-    }
-
-    return conflicts
-  }
-
-  /**
-   * Merge states with conflict resolution
-   */
-  static mergeStates<T>(
-    clientState: T,
-    serverState: T,
-    conflicts: StateConflict[],
-    strategy: 'client' | 'server' | 'smart' = 'smart'
-  ): T {
-    const merged = { ...clientState }
-
-    for (const conflict of conflicts) {
-      switch (strategy) {
-        case 'client':
-          // Keep client value
-          break
-        
-        case 'server':
-          (merged as any)[conflict.property] = conflict.serverValue
-          break
-          
-        case 'smart':
-          // Smart resolution based on field type and context
-          if (conflict.property === 'lastUpdated') {
-            // Server timestamp wins
-            (merged as any)[conflict.property] = conflict.serverValue
-          } else if (typeof conflict.serverValue === 'number' && typeof conflict.clientValue === 'number') {
-            // For numbers, use the higher value (e.g., counters)
-            (merged as any)[conflict.property] = Math.max(conflict.serverValue, conflict.clientValue)
-          } else {
-            // Default to server for other types
-            (merged as any)[conflict.property] = conflict.serverValue
-          }
-          break
-      }
-    }
-
-    return merged
-  }
-
-  /**
-   * Validate state integrity
-   */
-  static validateState<T>(hybridState: HybridState<T>): boolean {
-    const currentChecksum = this.generateChecksum(hybridState.data)
-    return currentChecksum === hybridState.validation.checksum
-  }
-
-  /**
-   * Update validation after state change
-   */
-  static updateValidation<T>(
-    hybridState: HybridState<T>,
-    source: 'client' | 'server' | 'mount' = 'client'
-  ): HybridState<T> {
-    return {
-      ...hybridState,
-      validation: this.createValidation(hybridState.data, source),
-      status: 'synced'
-    }
-  }
-}