@jmruthers/pace-core 0.6.10 → 0.6.11

package/src/components/DataTable/core/LocalDataAdapter.ts

@@ -1,274 +0,0 @@
-/**
- * @file Local Data Adapter
- * @package @jmruthers/pace-core
- * @module Components/DataTable/Architecture/Adapters
- * @since 0.3.0
- */
-
-import type { DataAdapter, FetchOptions, ExportFormat, ExportOptions } from './interfaces';
-import type { DataRecord } from '../types';
-import { generateCSVContent } from '../utils/exportUtils';
-
-/**
- * Local data adapter for in-memory data operations
- * Implements DataAdapter interface for local data management
- */
-export class LocalDataAdapter<TData extends DataRecord = DataRecord> implements DataAdapter<TData> {
-  public name = 'local';
-  private data: TData[] = [];
-  private error: Error | null = null;
-
-  constructor(initialData: TData[] = []) {
-    this.data = [...initialData];
-  }
-
-  /**
-   * Fetch data with filtering, sorting, and pagination
-   */
-  async fetchData(options: FetchOptions = {}): Promise<TData[]> {
-    try {
-      this.error = null;
-      let result = [...this.data];
-
-      // Apply search filter
-      if (options.search) {
-        const searchTerm = options.search.toLowerCase();
-        result = result.filter(item =>
-          Object.values(item).some(value =>
-            String(value).toLowerCase().includes(searchTerm)
-          )
-        );
-      }
-
-      // Apply column filters
-      if (options.filters) {
-        result = result.filter(item => {
-          return Object.entries(options.filters!).every(([key, value]) => {
-            const itemValue = item[key];
-            if (value === null || value === undefined) return true;
-            if (typeof value === 'string') {
-              return String(itemValue).toLowerCase().includes(value.toLowerCase());
-            }
-            return itemValue === value;
-          });
-        });
-      }
-
-      // Apply sorting
-      if (options.sortBy) {
-        result.sort((a, b) => {
-          const aValue = a[options.sortBy!];
-          const bValue = b[options.sortBy!];
-          
-          // Handle null/undefined values
-          if (aValue == null && bValue == null) return 0;
-          if (aValue == null) return 1;
-          if (bValue == null) return -1;
-          
-          // Compare values - convert to comparable types
-          const aComparable = typeof aValue === 'string' ? aValue.toLowerCase() : aValue;
-          const bComparable = typeof bValue === 'string' ? bValue.toLowerCase() : bValue;
-          
-          if (aComparable < bComparable) return options.sortDirection === 'desc' ? 1 : -1;
-          if (aComparable > bComparable) return options.sortDirection === 'desc' ? -1 : 1;
-          return 0;
-        });
-      }
-
-      // Apply pagination
-      if (options.page !== undefined && options.pageSize) {
-        const start = options.page * options.pageSize;
-        const end = start + options.pageSize;
-        result = result.slice(start, end);
-      }
-
-      return result;
-    } catch (error) {
-      this.error = error as Error;
-      throw error;
-    }
-  }
-
-  /**
-   * Update a data item
-   */
-  async updateData(id: string, data: Partial<TData>): Promise<void> {
-    try {
-      this.error = null;
-      const index = this.data.findIndex(item => this.getRowId(item) === id);
-      
-      if (index === -1) {
-        throw new Error(`Item with ID "${id}" not found`);
-      }
-
-      this.data[index] = { ...this.data[index], ...data };
-    } catch (error) {
-      this.error = error as Error;
-      throw error;
-    }
-  }
-
-  /**
-   * Delete a data item
-   */
-  async deleteData(id: string): Promise<void> {
-    try {
-      this.error = null;
-      const index = this.data.findIndex(item => this.getRowId(item) === id);
-      
-      if (index === -1) {
-        throw new Error(`Item with ID "${id}" not found`);
-      }
-
-      this.data.splice(index, 1);
-    } catch (error) {
-      this.error = error as Error;
-      throw error;
-    }
-  }
-
-  /**
-   * Create a new data item
-   */
-  async createData(data: Partial<TData>): Promise<TData> {
-    try {
-      this.error = null;
-      const newItem = {
-        id: this.generateId(),
-        ...data,
-      } as unknown as TData;
-
-      this.data.push(newItem);
-      return newItem;
-    } catch (error) {
-      this.error = error as Error;
-      throw error;
-    }
-  }
-
-  /**
-   * Export data in specified format
-   */
-  async exportData(format: ExportFormat, options: ExportOptions = {}): Promise<string> {
-    try {
-      this.error = null;
-      
-      switch (format) {
-        case 'csv':
-          return this.exportToCSV(options);
-        case 'json':
-          return this.exportToJSON(options);
-        case 'xlsx':
-          return this.exportToXLSX(options);
-        default:
-          throw new Error(`Unsupported export format: ${format}`);
-      }
-    } catch (error) {
-      this.error = error as Error;
-      throw error;
-    }
-  }
-
-  /**
-   * Import data
-   */
-  async importData(data: TData[]): Promise<void> {
-    try {
-      this.error = null;
-      this.data = [...data];
-    } catch (error) {
-      this.error = error as Error;
-      throw error;
-    }
-  }
-
-  /**
-   * Check if adapter is connected
-   */
-  isConnected(): boolean {
-    return true; // Local adapter is always connected
-  }
-
-  /**
-   * Get current error
-   */
-  getError(): Error | null {
-    return this.error;
-  }
-
-  /**
-   * Set data directly
-   */
-  setData(data: TData[]): void {
-    this.data = [...data];
-  }
-
-  /**
-   * Get all data without filtering
-   */
-  getAllData(): TData[] {
-    return [...this.data];
-  }
-
-  /**
-   * Get data count
-   */
-  getDataCount(): number {
-    return this.data.length;
-  }
-
-  /**
-   * Clear all data
-   */
-  clearData(): void {
-    this.data = [];
-  }
-
-  /**
-   * Get row ID from data item
-   */
-  private getRowId(item: TData): string {
-    const record = item as Record<string, unknown>;
-    return (record.id ? String(record.id) : record.key ? String(record.key) : JSON.stringify(item));
-  }
-
-  /**
-   * Generate unique ID
-   */
-  private generateId(): string {
-    return `id-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  /**
-   * Export to CSV format
-   */
-  private exportToCSV(options: ExportOptions): string {
-    if (this.data.length === 0) return '';
-
-    // Create column definitions from data keys
-    const columns = Object.keys(this.data[0]).map(key => ({
-      accessorKey: key,
-      header: key
-    }));
-
-    return generateCSVContent(this.data, columns, {
-      includeHeaders: options.includeHeaders
-    });
-  }
-
-  /**
-   * Export to JSON format
-   */
-  private exportToJSON(_options: ExportOptions): string {
-    return JSON.stringify(this.data, null, 2);
-  }
-
-  /**
-   * Export to XLSX format (simplified - returns JSON for now)
-   */
-  private exportToXLSX(options: ExportOptions): string {
-    // In a real implementation, you would use a library like xlsx
-    // For now, return JSON format
-    return this.exportToJSON(options);
-  }
-} 

package/src/components/DataTable/core/PluginRegistry.ts

@@ -1,229 +0,0 @@
-/**
- * @file DataTable Plugin Registry
- * @package @jmruthers/pace-core
- * @module Components/DataTable/Architecture
- * @since 0.3.0
- */
-
-import type { PluginRegistry, DataTablePlugin, DataTableContext } from './interfaces';
-import type { DataRecord } from '../types';
-
-/**
- * Plugin registry implementation
- * Manages plugin registration, dependency resolution, and lifecycle
- */
-export class PluginRegistryImpl<TData extends DataRecord = DataRecord> implements PluginRegistry<TData> {
-  private plugins = new Map<string, DataTablePlugin<TData>>();
-  private initializedPlugins = new Set<string>();
-
-  /**
-   * Register a plugin
-   */
-  register(plugin: DataTablePlugin<TData>): void {
-    if (this.plugins.has(plugin.name)) {
-      throw new Error(`Plugin "${plugin.name}" is already registered`);
-    }
-
-    this.plugins.set(plugin.name, plugin);
-  }
-
-  /**
-   * Unregister a plugin
-   */
-  unregister(name: string): void {
-    const plugin = this.plugins.get(name);
-    if (!plugin) {
-      throw new Error(`Plugin "${name}" is not registered`);
-    }
-
-    // Cleanup if initialized
-    if (this.initializedPlugins.has(name)) {
-      plugin.cleanup().catch(_error => {
-        // Error logged silently - plugin cleanup failures should not break the app
-      });
-      this.initializedPlugins.delete(name);
-    }
-
-    this.plugins.delete(name);
-  }
-
-  /**
-   * Get a plugin by name
-   */
-  getPlugin(name: string): DataTablePlugin<TData> | undefined {
-    return this.plugins.get(name);
-  }
-
-  /**
-   * Get all enabled plugins
-   */
-  getEnabledPlugins(): DataTablePlugin<TData>[] {
-    return Array.from(this.plugins.values());
-  }
-
-  /**
-   * Get plugins in dependency order
-   */
-  getDependencyOrder(): DataTablePlugin<TData>[] {
-    const sorted: DataTablePlugin<TData>[] = [];
-    const visited = new Set<string>();
-    const visiting = new Set<string>();
-
-    const visit = (pluginName: string) => {
-      if (visiting.has(pluginName)) {
-        throw new Error(`Circular dependency detected: ${pluginName}`);
-      }
-
-      if (visited.has(pluginName)) {
-        return;
-      }
-
-      const plugin = this.plugins.get(pluginName);
-      if (!plugin) {
-        throw new Error(`Plugin "${pluginName}" not found`);
-      }
-
-      visiting.add(pluginName);
-
-      // Visit dependencies first
-      if (plugin.dependencies) {
-        for (const dependency of plugin.dependencies) {
-          visit(dependency);
-        }
-      }
-
-      visiting.delete(pluginName);
-      visited.add(pluginName);
-      sorted.push(plugin);
-    };
-
-    // Visit all plugins
-    for (const pluginName of this.plugins.keys()) {
-      if (!visited.has(pluginName)) {
-        visit(pluginName);
-      }
-    }
-
-    return sorted;
-  }
-
-  /**
-   * Initialize all plugins
-   */
-  async initializePlugins(context: DataTableContext<TData>): Promise<void> {
-    const plugins = this.getDependencyOrder();
-
-    for (const plugin of plugins) {
-      try {
-        await plugin.initialize(context);
-        this.initializedPlugins.add(plugin.name);
-      } catch (error) {
-        // Re-throw error - initialization failures should be handled by caller
-        throw error;
-      }
-    }
-  }
-
-  /**
-   * Cleanup all plugins
-   */
-  async cleanupPlugins(): Promise<void> {
-    const plugins = this.getDependencyOrder().reverse(); // Reverse for cleanup order
-
-    for (const plugin of plugins) {
-      if (this.initializedPlugins.has(plugin.name)) {
-        try {
-          await plugin.cleanup();
-          this.initializedPlugins.delete(plugin.name);
-        } catch (_error) {
-          // Error logged silently - plugin cleanup failures should not break the app
-        }
-      }
-    }
-  }
-
-  /**
-   * Render all plugins
-   */
-  renderPlugins(): React.ReactNode[] {
-    return this.getEnabledPlugins()
-      .filter(plugin => this.initializedPlugins.has(plugin.name))
-      .map(plugin => plugin.render());
-  }
-
-  /**
-   * Check if plugin is initialized
-   */
-  isPluginInitialized(name: string): boolean {
-    return this.initializedPlugins.has(name);
-  }
-
-  /**
-   * Get plugin count
-   */
-  getPluginCount(): number {
-    return this.plugins.size;
-  }
-
-  /**
-   * Get initialized plugin count
-   */
-  getInitializedPluginCount(): number {
-    return this.initializedPlugins.size;
-  }
-
-  /**
-   * Check if plugin has dependencies
-   */
-  hasDependencies(name: string): boolean {
-    const plugin = this.plugins.get(name);
-    return plugin ? !!(plugin.dependencies && plugin.dependencies.length > 0) : false;
-  }
-
-  /**
-   * Get plugin dependencies
-   */
-  getPluginDependencies(name: string): string[] {
-    const plugin = this.plugins.get(name);
-    return plugin?.dependencies || [];
-  }
-
-  /**
-   * Check if all dependencies are satisfied
-   */
-  areDependenciesSatisfied(name: string): boolean {
-    const dependencies = this.getPluginDependencies(name);
-    return dependencies.every(dep => this.plugins.has(dep));
-  }
-
-  /**
-   * Get plugins that depend on a specific plugin
-   */
-  getDependents(name: string): DataTablePlugin<TData>[] {
-    return Array.from(this.plugins.values()).filter(plugin => 
-      plugin.dependencies?.includes(name)
-    );
-  }
-
-  /**
-   * Validate plugin dependencies
-   */
-  validateDependencies(): { valid: boolean; errors: string[] } {
-    const errors: string[] = [];
-
-    for (const [name, plugin] of this.plugins) {
-      if (plugin.dependencies) {
-        for (const dependency of plugin.dependencies) {
-          if (!this.plugins.has(dependency)) {
-            errors.push(`Plugin "${name}" depends on "${dependency}" which is not registered`);
-          }
-        }
-      }
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-}