@winkjs/composer 0.5.0 → 0.6.0

package/src/core/utils/console-formatter/index.js

@@ -1,207 +0,0 @@
-/**
- * Console Formatter for WinkComposer
- *
- * Provides rich, colored console output with structured formatting
- * for development, debugging, and edge device monitoring.
- */
-
-// ANSI color codes for terminal output
-const colors = {
-    reset: '\x1b[0m',
-    bright: '\x1b[1m',
-    dim: '\x1b[2m',
-
-    // Foreground colors
-    black: '\x1b[30m',
-    red: '\x1b[31m',
-    green: '\x1b[32m',
-    yellow: '\x1b[33m',
-    blue: '\x1b[34m',
-    magenta: '\x1b[35m',
-    cyan: '\x1b[36m',
-    white: '\x1b[37m',
-    gray: '\x1b[90m',
-
-    // Background colors
-    bgRed: '\x1b[41m',
-    bgYellow: '\x1b[43m',
-    bgGreen: '\x1b[42m'
-};
-
-// Method-specific configurations
-const methodConfig = {
-    log: {
-        color: colors.reset,
-        symbol: '  ',
-        label: 'INFO'
-    },
-    warn: {
-        color: colors.yellow,
-        symbol: '⚠️ ',
-        label: 'WARN'
-    },
-    error: {
-        color: colors.red,
-        symbol: '✗ ',
-        label: 'ERROR'
-    },
-    table: {
-        color: colors.cyan,
-        symbol: '📊',
-        label: 'DATA'
-    },
-    debug: {
-        color: colors.gray,
-        symbol: '🔍',
-        label: 'DEBUG'
-    },
-    success: {
-        color: colors.green,
-        symbol: '✓ ',
-        label: 'OK'
-    },
-    critical: {
-        color: `${colors.bright}${colors.bgRed}${colors.white}`,
-        symbol: '🔴',
-        label: 'CRITICAL'
-    }
-};
-
-/**
- * Format timestamp for console output
- */
-const formatTimestamp = function () {
-    const now = new Date();
-    const time = now.toTimeString().split( ' ' )[ 0 ];  // HH:MM:SS
-    const ms = now.getMilliseconds().toString().padStart( 3, '0' );
-    return `${colors.gray}[${time}.${ms}]${colors.reset}`;
-}; // formatTimestamp()
-
-/**
- * Format node identifier
- */
-const formatNodeId = function ( partitionKey ) {
-    const partition = partitionKey ? `/${partitionKey}` : '';
-    return `${colors.cyan}[${partition}]${colors.reset}`;
-}; // formatNodeId()
-
-/**
- * Format structured data for console
- */
-const formatData = function ( data, indent = 2 ) {
-    if ( data === null || data === undefined ) {
-        return `${colors.gray}(empty)${colors.reset}`;
-    }
-
-    if ( typeof data === 'string' || typeof data === 'number' || typeof data === 'boolean' ) {
-        return String( data );
-    }
-
-    // For objects, create indented key-value display
-    const spaces = ' '.repeat( indent );
-    const lines = [];
-
-    for ( const [ key, value ] of Object.entries( data ) ) {
-        const formattedKey = `${colors.bright}${key}:${colors.reset}`;
-
-        // Handle different value types
-        let formattedValue;
-        if ( typeof value === 'object' && value !== null ) {
-            // Nested object - use JSON stringify with indent
-            formattedValue = JSON.stringify( value, null, 2 )
-                .split( '\n' )
-                .map( ( line, i ) => ( i === 0 ? line : spaces + line ) )
-                .join( '\n' );
-        } else if ( typeof value === 'string' ) {
-            formattedValue = `"${value}"`;
-        } else {
-            formattedValue = String( value );
-        }
-
-        lines.push( `${spaces}${formattedKey} ${formattedValue}` );
-    }
-
-    return lines.join( '\n' );
-}; // formatData()
-
-/**
- * Create formatted console output
- */
-const createConsoleFormatter = function () {
-
-    /**
-     * Format and emit to console
-     *
-     * @param {string} method - Console method (log, warn, error, table)
-     * @param {Object} data - Data to output
-     * @param {string} [partitionKey] - Optional partition identifier
-     * @param {Object} [metadata] - Optional metadata (UNS, etc.)
-     */
-    const format = function ( method, data, partitionKey, metadata ) {
-        const config = methodConfig[ method ] || methodConfig.log;
-
-        // Build header line
-        const timestamp = formatTimestamp();
-        const nodeId = formatNodeId( partitionKey );
-        const header = `${config.symbol} ${timestamp} ${nodeId}`;
-
-        // Handle table method specially
-        if ( method === 'table' && ( Array.isArray( data ) || typeof data === 'object' ) ) {
-            console.log( `${header} ${config.color}[TABLE]${colors.reset}` );
-            console.table( data );
-            return;
-        }
-
-        // Handle critical alerts with emphasis
-        if ( method === 'critical' ) {
-            console.log( `\n${config.color} ${config.label} ${colors.reset}` );
-            console.log( header );
-            console.log( formatData( data, 4 ) );
-            console.log( `${config.color} ${'═'.repeat( 40 )} ${colors.reset}\n` );
-            return;
-        }
-
-        // Standard formatted output
-        const output = [];
-        output.push( header );
-
-        // Add metadata if present (UNS path, etc.)
-        if ( metadata?.uns ) {
-            output.push( `  ${colors.gray}UNS: ${metadata.uns}${colors.reset}` );
-        }
-
-        // Format main data
-        if ( typeof data === 'string' ) {
-            output.push( `  ${config.color}${data}${colors.reset}` );
-        } else {
-            output.push( formatData( data, 2 ) );
-        }
-
-        // Output using appropriate console method
-        const consoleMethod = [ 'log', 'warn', 'error', 'table' ].includes( method ) ? method : 'log';
-
-        console[ consoleMethod ]( output.join( '\n' ) );
-    }; // format()
-
-    /**
-     * Create separator line for visual grouping
-     */
-    const separator = function ( label, char = '═' ) {
-        const line = char.repeat( 40 );
-        if ( label ) {
-            console.log( `${colors.cyan}${line}${colors.reset}` );
-            console.log( `${colors.bright}${colors.cyan}   ${label}${colors.reset}` );
-            console.log( `${colors.cyan}${line}${colors.reset}` );
-        } else {
-            console.log( `${colors.gray}${line}${colors.reset}` );
-        }
-    }; // separator()
-
-    return {
-        format: format,
-        separator: separator,
-        colors: colors  // Export for custom formatting
-    };
-}; // createConsoleFormatter()
-
-export default createConsoleFormatter;

package/src/nodes/archive/csv/index.js

@@ -1,6 +0,0 @@
-export { default as init } from './init.js';
-export { default as update } from './update.js';
-export { default as reset } from './reset.js';
-// export { default as recompute } from './recompute.js';
-// export { default as publishTo } from './publish-to.js';
-// export * from './introspect.js';

package/src/nodes/archive/csv/init.js

@@ -1,36 +0,0 @@
-// import { getNodeType } from './introspect.js';
-
-const init = function ( spec ) {
-    const state = Object.create( null );
-
-    // CSV source configuration
-    state.source = spec.source;  // URL or file path
-    state.mode = spec.mode || 'stream';  // 'stream' or 'batch'
-    state.rate = spec.rate || 100;  // Messages per second (for stream mode)
-    state.loop = spec.loop !== false;  // Loop when reaching end
-    state.columns = spec.columns || 'auto';  // Column mapping
-
-    // Parsing options for Papaparse
-    state.parseOptions = {
-        header: true,
-        dynamicTyping: true,
-        skipEmptyLines: true,
-        ...( spec.parseOptions || {} )
-    };
-
-    // Runtime state
-    state.data = null;  // Parsed CSV data
-    state.currentIndex = 0;
-    state.lastEmitTime = 0;
-    state.isLoaded = false;
-    state.isPaused = false;
-
-    // For browser environment - store fetch promise
-    state.loadPromise = null;
-
-    state.nodeType = 'CSV'; // getNodeType();
-
-    return state;
-}; // init()
-
-export default init;

package/src/nodes/archive/csv/load.js

@@ -1,70 +0,0 @@
-// nodes/csv-source/load.js
-import SimpleCSV from './simple-parser.js';
-
-const loadCSV = async function ( state ) {
-    try {
-        let csvText;
-
-        // Check if source looks like CSV data (has newlines or commas)
-        const isEmbeddedData = state.source.includes('\n') ||
-                               (state.source.includes(',') && !state.source.endsWith('.csv'));
-
-        // Determine environment and load CSV text
-        if ( typeof window === 'object' ) {
-            // Browser environment
-            if ( isEmbeddedData ) {
-                // Embedded data
-                csvText = state.source;
-            } else if ( state.source.startsWith( 'http' ) || state.source.startsWith( '/' ) ) {
-                // Fetch from URL
-                const response = await fetch( state.source );
-                csvText = await response.text();
-            } else {
-                // Assume it's embedded data if not a URL
-                csvText = state.source;
-            }
-        } else if ( typeof process === 'object' && process.versions && process.versions.node ) {
-            // Node.js environment
-            if ( isEmbeddedData ) {
-                // Embedded data
-                csvText = state.source;
-            } else if ( state.source.startsWith( 'http' ) ) {
-                // Fetch from URL
-                const response = await fetch( state.source );
-                csvText = await response.text();
-            } else {
-                // Read from file
-                const fs = await import( 'fs/promises' );
-                csvText = await fs.readFile( state.source, 'utf8' );
-            }
-        } else {
-            throw new Error( 'Unable to determine environment for CSV loading' );
-        }
-
-        // Parse CSV using SimpleCSV
-        const parsed = SimpleCSV.parse( csvText, state.parseOptions );
-
-        // Handle any parsing errors
-        if ( parsed.errors && parsed.errors.length > 0 ) {
-            console.warn( 'CSV parsing warnings:', parsed.errors );
-        }
-
-        // Store parsed data
-        state.data = parsed.data;
-        state.isLoaded = true;
-        state.currentIndex = 0;
-
-        // Log summary
-        console.log( `Loaded ${state.data.length} rows from CSV` );
-        if ( parsed.meta && parsed.meta.fields ) {
-            console.log( `Columns: ${parsed.meta.fields.join( ', ' )}` );
-        }
-
-    } catch ( error ) {
-        console.error( 'Failed to load CSV:', error );
-        state.data = [];
-        state.isLoaded = false;
-    }
-};
-
-export default loadCSV;

package/src/nodes/archive/csv/reset.js

@@ -1,14 +0,0 @@
-// nodes/csv-source/reset.js
-const reset = function ( state ) {
-    // Reset to initial state
-    state.currentIndex = 0;
-    state.lastEmitTime = 0;
-    state.isPaused = false;
-
-    // Don't clear the data - just reset the reading position
-    // This allows resuming from the beginning without reloading
-
-    return true;
-}; // reset()
-
-export default reset;

package/src/nodes/archive/csv/simple-parser.js

@@ -1,216 +0,0 @@
-// nodes/csv-source/simple-csv-parser.js
-
-const SimpleCSV = {
-    parse: function ( csvText, config = {} ) {
-        // Default configuration
-        const options = {
-            delimiter: config.delimiter || ',',
-            header: config.header !== false,
-            dynamicTyping: config.dynamicTyping !== false,
-            skipEmptyLines: config.skipEmptyLines !== false,
-            transformHeader: config.transformHeader || null,
-            transform: config.transform || null,
-            comments: config.comments || false,
-            quoteChar: config.quoteChar || '"',
-            parseDates: config.parseDates || false
-        };
-
-        const result = {
-            data: [],
-            errors: [],
-            meta: {
-                delimiter: options.delimiter,
-                linebreak: '\n',
-                aborted: false,
-                fields: []
-            }
-        };
-
-        try {
-            // Normalize line breaks
-            csvText = csvText.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
-
-            // Split into lines (handling quoted newlines)
-            const lines = this.splitLines( csvText, options.quoteChar );
-
-            // Filter empty lines and comments
-            const processedLines = lines.filter( (line, index) => {
-                if ( options.skipEmptyLines && line.trim() === '' ) return false;
-                if ( options.comments && line.trim().startsWith( options.comments ) ) return false;
-                return true;
-            });
-
-            if ( processedLines.length === 0 ) {
-                return result;
-            }
-
-            // Parse header if present
-            let headers = [];
-            let dataStartIndex = 0;
-
-            if ( options.header ) {
-                headers = this.parseLine( processedLines[0], options );
-
-                // Transform headers if function provided
-                if ( options.transformHeader ) {
-                    headers = headers.map( (h) => options.transformHeader( h ) );
-                }
-
-                result.meta.fields = headers;
-                dataStartIndex = 1;
-            }
-
-            // Parse data rows
-            for ( let i = dataStartIndex; i < processedLines.length; i += 1 ) {
-                const values = this.parseLine( processedLines[i], options );
-
-                if ( values.length === 0 ) continue;
-
-                // Create row object or array
-                let row;
-                if ( options.header && headers.length > 0 ) {
-                    row = {};
-                    headers.forEach( (header, index) => {
-                        let value = values[index];
-
-                        // Apply dynamic typing
-                        if ( options.dynamicTyping ) {
-                            value = this.castValue( value, options );
-                        }
-
-                        // Apply transform if provided
-                        if ( options.transform ) {
-                            value = options.transform( value, header );
-                        }
-
-                        row[header] = value;
-                    });
-                } else {
-                    row = values.map( (value) => {
-                        if ( options.dynamicTyping ) {
-                            return this.castValue( value );
-                        }
-                        return value;
-                    });
-                }
-
-                result.data.push( row );
-            }
-
-        } catch ( error ) {
-            result.errors.push({
-                type: 'ParseError',
-                code: 'ParseError',
-                message: error.message,
-                row: result.data.length
-            });
-        }
-
-        return result;
-    },
-
-    // Split CSV into lines, respecting quoted newlines
-    splitLines: function ( text, quoteChar ) {
-        const lines = [];
-        let currentLine = '';
-        let inQuotes = false;
-
-        for ( let i = 0; i < text.length; i += 1 ) {
-            const char = text[i];
-            const nextChar = text[i + 1];
-
-            if ( char === quoteChar ) {
-                // Check if it's an escaped quote
-                if ( nextChar === quoteChar && inQuotes ) {
-                    currentLine += quoteChar;
-                    i += 1; // Skip next quote
-                } else {
-                    inQuotes = !inQuotes;
-                    currentLine += char;
-                }
-            } else if ( char === '\n' && !inQuotes ) {
-                lines.push( currentLine );
-                currentLine = '';
-            } else {
-                currentLine += char;
-            }
-        }
-
-        // Don't forget the last line
-        if ( currentLine !== '' ) {
-            lines.push( currentLine );
-        }
-
-        return lines;
-    },
-
-    // Parse a single line into values
-    parseLine: function ( line, options ) {
-        const values = [];
-        let currentValue = '';
-        let inQuotes = false;
-        const delimiter = options.delimiter;
-        const quoteChar = options.quoteChar;
-
-        for ( let i = 0; i < line.length; i += 1 ) {
-            const char = line[i];
-            const nextChar = line[i + 1];
-
-            if ( char === quoteChar ) {
-                if ( inQuotes && nextChar === quoteChar ) {
-                    // Escaped quote
-                    currentValue += quoteChar;
-                    i += 1; // Skip next quote
-                } else if ( inQuotes && ( nextChar === delimiter || nextChar === undefined || i === line.length - 1 ) ) {
-                    // End of quoted value
-                    inQuotes = false;
-                } else if ( !inQuotes && ( currentValue === '' || currentValue === ' '.repeat( currentValue.length ) ) ) {
-                    // Start of quoted value
-                    inQuotes = true;
-                } else {
-                    currentValue += char;
-                }
-            } else if ( char === delimiter && !inQuotes ) {
-                // End of value
-                values.push( currentValue.trim() );
-                currentValue = '';
-            } else {
-                currentValue += char;
-            }
-        }
-
-        // Don't forget the last value
-        values.push( currentValue.trim() );
-
-        return values;
-    },
-
-    // Convert string values to appropriate types
-    castValue: function ( value, options ) {
-        if ( value === '' || value === null || value === undefined ) {
-            return value;
-        }
-
-        // Boolean
-        if ( value.toLowerCase() === 'true' ) return true;
-        if ( value.toLowerCase() === 'false' ) return false;
-
-        // Number
-        if ( !isNaN( value ) && !isNaN( parseFloat( value ) ) ) {
-            return value.indexOf( '.' ) > -1 ? parseFloat( value ) : parseInt( value, 10 );
-        }
-
-        // Date (only if parseDates is true)
-        if ( options.parseDates && (/^\d{4}-\d{2}-\d{2}/).test( value ) ) {
-            const date = new Date( value );
-            if ( !isNaN( date.getTime() ) ) {
-                return date;
-            }
-        }
-
-        // String (default)
-        return value;
-    }
-};
-
-export default SimpleCSV;