datly 0.0.2 → 0.0.3

package/src/core/dataLoader.js

@@ -1,407 +0,0 @@
-// Detecção de ambiente
-const isNode = typeof process !== 'undefined' &&
-               process.versions != null &&
-               process.versions.node != null;
-
-// Lazy load do fs
-let fs = null;
-let fsPromise = null;
-
-async function getFS() {
-  if (!isNode) return null;
-  if (fs) return fs;
-  if (fsPromise) return fsPromise;
-
-  fsPromise = import('fs').then(m => {
-    fs = m.default || m;
-    return fs;
-  }).catch(() => null);
-
-  return fsPromise;
-}
-
-class DataLoader {
-  async loadCSV(filePath, options = {}) {
-    const defaultOptions = {
-      delimiter: ',',
-      header: true,
-      skipEmptyLines: true,
-      encoding: 'utf8'
-    };
-
-    const config = { ...defaultOptions, ...options };
-
-    try {
-      let content;
-
-      // Node.js
-      if (isNode) {
-        const fsModule = await getFS();
-        if (fsModule) {
-          content = fsModule.readFileSync(filePath, { encoding: config.encoding });
-        }
-      }
-      // Browser com File System Access API
-      if (!content && typeof window !== 'undefined' && window.fs) {
-        content = window.fs.readFileSync
-          ? window.fs.readFileSync(filePath, { encoding: config.encoding })
-          : await window.fs.readFile(filePath, { encoding: config.encoding });
-      }
-      // Fetch API (browser)
-      if (!content && typeof fetch !== 'undefined') {
-        const response = await fetch(filePath);
-        if (!response.ok) {
-          throw new Error(`HTTP error! status: ${response.status}`);
-        }
-        content = await response.text();
-      }
-
-      if (!content) {
-        throw new Error('No file system available. Use fetch, fs module, or pass CSV text directly to parseCSV()');
-      }
-
-      return this.parseCSV(content, config);
-    } catch (error) {
-      throw new Error(`Failed to load CSV: ${error.message}`);
-    }
-  }
-
-  async loadJSON(jsonInput, options = {}) {
-    const defaultOptions = {
-      validateTypes: true,
-      autoInferHeaders: true
-    };
-
-    const config = { ...defaultOptions, ...options };
-
-    try {
-      let jsonData;
-
-      // Se é uma string que parece ser um caminho de arquivo
-      if (typeof jsonInput === 'string' && !jsonInput.trim().startsWith('{') && !jsonInput.trim().startsWith('[')) {
-        let content;
-
-        // Node.js
-        if (isNode) {
-          const fsModule = await getFS();
-          if (fsModule) {
-            content = fsModule.readFileSync(jsonInput, { encoding: 'utf8' });
-          }
-        }
-        // Browser com File System Access API
-        if (!content && typeof window !== 'undefined' && window.fs) {
-          content = window.fs.readFileSync
-            ? window.fs.readFileSync(jsonInput, { encoding: 'utf8' })
-            : await window.fs.readFile(jsonInput, { encoding: 'utf8' });
-        }
-        // Fetch API (browser)
-        if (!content && typeof fetch !== 'undefined') {
-          const response = await fetch(jsonInput);
-          if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
-          }
-          content = await response.text();
-        }
-
-        if (!content) {
-          throw new Error('No file system available');
-        }
-
-        jsonData = JSON.parse(content);
-      }
-      // String JSON
-      else if (typeof jsonInput === 'string') {
-        jsonData = JSON.parse(jsonInput);
-      }
-      // Objeto JS
-      else if (typeof jsonInput === 'object') {
-        jsonData = jsonInput;
-      }
-      else {
-        throw new Error('Invalid JSON input: must be string, file path, or object');
-      }
-
-      return this.parseJSON(jsonData, config);
-    } catch (error) {
-      throw new Error(`Failed to load JSON: ${error.message}`);
-    }
-  }
-
-  parseJSON(jsonData, config) {
-    if (!jsonData) {
-      throw new Error('JSON data is empty or null');
-    }
-
-    if (Array.isArray(jsonData)) {
-      return this.parseJSONArray(jsonData, config);
-    } else if (jsonData.headers && jsonData.data) {
-      return this.parseStructuredJSON(jsonData, config);
-    } else if (typeof jsonData === 'object') {
-      return this.parseJSONObject(jsonData, config);
-    } else {
-      throw new Error('Unsupported JSON format');
-    }
-  }
-
-  parseJSONArray(jsonArray, config) {
-    if (jsonArray.length === 0) {
-      throw new Error('JSON array is empty');
-    }
-
-    const firstRow = jsonArray[0];
-    if (typeof firstRow !== 'object' || firstRow === null) {
-      throw new Error('JSON array must contain objects');
-    }
-
-    let headers;
-    if (config.autoInferHeaders) {
-      const allKeys = new Set();
-      jsonArray.forEach(row => {
-        if (typeof row === 'object' && row !== null) {
-          Object.keys(row).forEach(key => allKeys.add(key));
-        }
-      });
-      headers = Array.from(allKeys);
-    } else {
-      headers = Object.keys(firstRow);
-    }
-
-    const data = jsonArray.map((row, index) => {
-      if (typeof row !== 'object' || row === null) {
-        console.warn(`Row ${index} is not an object, skipping`);
-        return null;
-      }
-
-      const processedRow = {};
-      headers.forEach(header => {
-        let value = row[header];
-        if (config.validateTypes) {
-          value = this.inferType(value);
-        }
-        processedRow[header] = value;
-      });
-      return processedRow;
-    }).filter(row => row !== null);
-
-    return {
-      headers,
-      data,
-      length: data.length,
-      columns: headers.length,
-      source: 'json_array'
-    };
-  }
-
-  parseStructuredJSON(jsonData, config) {
-    const { headers, data } = jsonData;
-
-    if (!Array.isArray(headers)) {
-      throw new Error('Headers must be an array');
-    }
-
-    if (!Array.isArray(data)) {
-      throw new Error('Data must be an array');
-    }
-
-    if (headers.length === 0) {
-      throw new Error('Headers array is empty');
-    }
-
-    const processedData = data.map((row, index) => {
-      if (Array.isArray(row)) {
-        const processedRow = {};
-        headers.forEach((header, i) => {
-          let value = i < row.length ? row[i] : null;
-          if (config.validateTypes) {
-            value = this.inferType(value);
-          }
-          processedRow[header] = value;
-        });
-        return processedRow;
-      } else if (typeof row === 'object' && row !== null) {
-        const processedRow = {};
-        headers.forEach(header => {
-          let value = row[header];
-          if (config.validateTypes) {
-            value = this.inferType(value);
-          }
-          processedRow[header] = value;
-        });
-        return processedRow;
-      } else {
-        console.warn(`Row ${index} has invalid format, skipping`);
-        return null;
-      }
-    }).filter(row => row !== null);
-
-    return {
-      headers,
-      data: processedData,
-      length: processedData.length,
-      columns: headers.length,
-      source: 'structured_json'
-    };
-  }
-
-  parseJSONObject(jsonObject, config) {
-    const entries = Object.entries(jsonObject);
-    if (entries.length === 0) {
-      throw new Error('JSON object is empty');
-    }
-
-    const headers = ['key', 'value'];
-    const data = entries.map(([key, value]) => ({
-      key: key,
-      value: config.validateTypes ? this.inferType(value) : value
-    }));
-
-    return {
-      headers,
-      data,
-      length: data.length,
-      columns: 2,
-      source: 'json_object'
-    };
-  }
-
-  parseCSV(content, options) {
-    const lines = content.split('\n').filter(line =>
-      options.skipEmptyLines ? line.trim() !== '' : true
-    );
-
-    if (lines.length === 0) {
-      throw new Error('CSV file is empty');
-    }
-
-    const headers = options.header
-      ? lines[0].split(options.delimiter).map(h => h.trim().replace(/['"]/g, ''))
-      : Array.from({ length: lines[0].split(options.delimiter).length }, (_, i) => `col_${i}`);
-
-    const startIndex = options.header ? 1 : 0;
-    const data = [];
-
-    for (let i = startIndex; i < lines.length; i++) {
-      const values = lines[i].split(options.delimiter);
-      if (values.length === headers.length) {
-        const row = {};
-        headers.forEach((header, index) => {
-          let value = values[index].trim().replace(/['"]/g, '');
-          row[header] = this.inferType(value);
-        });
-        data.push(row);
-      }
-    }
-
-    return {
-      headers,
-      data,
-      length: data.length,
-      columns: headers.length
-    };
-  }
-
-  inferType(value) {
-    if (value === '' || value === 'null' || value === 'NULL' || value === 'NaN') {
-      return null;
-    }
-
-    if (value === 'true' || value === 'TRUE') return true;
-    if (value === 'false' || value === 'FALSE') return false;
-
-    if (/^-?\d+$/.test(value)) {
-      return parseInt(value, 10);
-    }
-
-    if (/^-?\d*\.\d+$/.test(value)) {
-      return parseFloat(value);
-    }
-
-    return value;
-  }
-
-  cleanData(dataset) {
-    const cleaned = {
-      ...dataset,
-      data: dataset.data.filter(row => {
-        return Object.values(row).some(value => value !== null && value !== undefined);
-      })
-    };
-
-    cleaned.length = cleaned.data.length;
-    return cleaned;
-  }
-
-  getDataInfo(dataset) {
-    const info = {
-      rows: dataset.length,
-      columns: dataset.columns,
-      headers: dataset.headers,
-      types: {},
-      nullCounts: {},
-      uniqueCounts: {}
-    };
-
-    dataset.headers.forEach(header => {
-      const column = dataset.data.map(row => row[header]);
-      const nonNullValues = column.filter(val => val !== null && val !== undefined);
-      const types = [...new Set(nonNullValues.map(val => typeof val))];
-
-      info.types[header] = types.length === 1 ? types[0] : 'mixed';
-      info.nullCounts[header] = column.length - nonNullValues.length;
-      info.uniqueCounts[header] = new Set(nonNullValues).size;
-    });
-
-    return info;
-  }
-
-  getColumn(dataset, columnName) {
-    if (!dataset.headers.includes(columnName)) {
-      throw new Error(`Column '${columnName}' not found`);
-    }
-
-    return dataset.data
-      .map(row => row[columnName])
-      .filter(val => val !== null && val !== undefined && !isNaN(val));
-  }
-
-  getColumns(dataset, columnNames) {
-    const result = {};
-    columnNames.forEach(name => {
-      result[name] = this.getColumn(dataset, name);
-    });
-    return result;
-  }
-
-  filterRows(dataset, condition) {
-    return {
-      ...dataset,
-      data: dataset.data.filter(condition),
-      length: dataset.data.filter(condition).length
-    };
-  }
-
-  sortBy(dataset, columnName, order = 'asc') {
-    const sortedData = [...dataset.data].sort((a, b) => {
-      const aVal = a[columnName];
-      const bVal = b[columnName];
-
-      if (aVal === null || aVal === undefined) return 1;
-      if (bVal === null || bVal === undefined) return -1;
-
-      if (typeof aVal === 'string' && typeof bVal === 'string') {
-        return order === 'asc'
-          ? aVal.localeCompare(bVal)
-          : bVal.localeCompare(aVal);
-      }
-
-      return order === 'asc' ? aVal - bVal : bVal - aVal;
-    });
-
-    return {
-      ...dataset,
-      data: sortedData
-    };
-  }
-}
-
-export default DataLoader;

package/src/core/utils.js

@@ -1,306 +0,0 @@
-class Utils {
-    detectOutliers(column, method = 'iqr') {
-        const sortedData = [...column].sort((a, b) => a - b);
-        const outliers = [];
-        const indices = [];
-
-        switch (method) {
-            case 'iqr':
-                const q1 = this.quantile(sortedData, 0.25);
-                const q3 = this.quantile(sortedData, 0.75);
-                const iqr = q3 - q1;
-                const lowerBound = q1 - 1.5 * iqr;
-                const upperBound = q3 + 1.5 * iqr;
-
-                column.forEach((value, index) => {
-                    if (value < lowerBound || value > upperBound) {
-                        outliers.push(value);
-                        indices.push(index);
-                    }
-                });
-                break;
-
-            case 'zscore':
-                const mean = this.mean(column);
-                const std = this.standardDeviation(column);
-
-                column.forEach((value, index) => {
-                    const zscore = Math.abs((value - mean) / std);
-                    if (zscore > 3) {
-                        outliers.push(value);
-                        indices.push(index);
-                    }
-                });
-                break;
-
-            case 'modified_zscore':
-                const median = this.median(column);
-                const deviations = column.map(x => Math.abs(x - median));
-                const mad = this.median(deviations);
-
-                column.forEach((value, index) => {
-                    const modifiedZScore = 0.6745 * (value - median) / mad;
-                    if (Math.abs(modifiedZScore) > 3.5) {
-                        outliers.push(value);
-                        indices.push(index);
-                    }
-                });
-                break;
-
-            default:
-                throw new Error(`Unknown outlier detection method: ${method}`);
-        }
-
-        return {
-            outliers,
-            indices,
-            count: outliers.length,
-            percentage: (outliers.length / column.length) * 100
-        };
-    }
-
-    frequencyTable(column) {
-        const frequencies = {};
-        const total = column.length;
-
-        column.forEach(value => {
-            const key = value === null || value === undefined ? 'null' : String(value);
-            frequencies[key] = (frequencies[key] || 0) + 1;
-        });
-
-        const result = Object.entries(frequencies).map(([value, count]) => ({
-            value: value === 'null' ? null : value,
-            frequency: count,
-            relativeFrequency: count / total,
-            percentage: (count / total) * 100
-        }));
-
-        return result.sort((a, b) => b.frequency - a.frequency);
-    }
-
-    groupBy(dataset, column, aggregation) {
-        const groups = {};
-
-        dataset.data.forEach(row => {
-            const key = row[column];
-            if (!groups[key]) {
-                groups[key] = [];
-            }
-            groups[key].push(row);
-        });
-
-        const result = {};
-        Object.entries(groups).forEach(([key, rows]) => {
-            result[key] = {
-                count: rows.length,
-                data: rows
-            };
-
-            if (aggregation && typeof aggregation === 'object') {
-                Object.entries(aggregation).forEach(([targetCol, func]) => {
-                    const values = rows.map(row => row[targetCol]).filter(v =>
-                        typeof v === 'number' && !isNaN(v)
-                    );
-
-                    if (values.length > 0) {
-                        result[key][`${func}_${targetCol}`] = this.applyAggregation(values, func);
-                    }
-                });
-            }
-        });
-
-        return result;
-    }
-
-    applyAggregation(values, func) {
-        switch (func) {
-            case 'mean': return this.mean(values);
-            case 'median': return this.median(values);
-            case 'sum': return values.reduce((a, b) => a + b, 0);
-            case 'min': return Math.min(...values);
-            case 'max': return Math.max(...values);
-            case 'std': return this.standardDeviation(values);
-            case 'var': return this.variance(values);
-            case 'count': return values.length;
-            default: throw new Error(`Unknown aggregation function: ${func}`);
-        }
-    }
-
-    sample(dataset, size, method = 'random') {
-        if (size >= dataset.length) {
-            return { ...dataset };
-        }
-
-        let sampledData;
-
-        switch (method) {
-            case 'random':
-                const indices = this.randomSample(dataset.length, size);
-                sampledData = indices.map(i => dataset.data[i]);
-                break;
-
-            case 'systematic':
-                const interval = Math.floor(dataset.length / size);
-                sampledData = [];
-                for (let i = 0; i < size; i++) {
-                    sampledData.push(dataset.data[i * interval]);
-                }
-                break;
-
-            case 'first':
-                sampledData = dataset.data.slice(0, size);
-                break;
-
-            case 'last':
-                sampledData = dataset.data.slice(-size);
-                break;
-
-            default:
-                throw new Error(`Unknown sampling method: ${method}`);
-        }
-
-        return {
-            ...dataset,
-            data: sampledData,
-            length: sampledData.length
-        };
-    }
-
-    randomSample(populationSize, sampleSize) {
-        const indices = Array.from({ length: populationSize }, (_, i) => i);
-        const sample = [];
-
-        for (let i = 0; i < sampleSize; i++) {
-            const randomIndex = Math.floor(Math.random() * indices.length);
-            sample.push(indices.splice(randomIndex, 1)[0]);
-        }
-
-        return sample;
-    }
-
-    bootstrap(sample, statistic, iterations = 1000) {
-        const bootstrapStats = [];
-
-        for (let i = 0; i < iterations; i++) {
-            const bootstrapSample = [];
-            for (let j = 0; j < sample.length; j++) {
-                const randomIndex = Math.floor(Math.random() * sample.length);
-                bootstrapSample.push(sample[randomIndex]);
-            }
-
-            const stat = this.applyStatistic(bootstrapSample, statistic);
-            bootstrapStats.push(stat);
-        }
-
-        return {
-            bootstrapStats: bootstrapStats.sort((a, b) => a - b),
-            mean: this.mean(bootstrapStats),
-            standardError: this.standardDeviation(bootstrapStats),
-            confidenceInterval: {
-                lower: this.quantile(bootstrapStats, 0.025),
-                upper: this.quantile(bootstrapStats, 0.975)
-            }
-        };
-    }
-
-    applyStatistic(sample, statistic) {
-        switch (statistic) {
-            case 'mean': return this.mean(sample);
-            case 'median': return this.median(sample);
-            case 'std': return this.standardDeviation(sample);
-            case 'var': return this.variance(sample);
-            default:
-                if (typeof statistic === 'function') {
-                    return statistic(sample);
-                }
-                throw new Error(`Unknown statistic: ${statistic}`);
-        }
-    }
-
-    contingencyTable(col1, col2) {
-        const uniqueCol1 = [...new Set(col1)];
-        const uniqueCol2 = [...new Set(col2)];
-
-        const table = {};
-        const totals = { row: {}, col: {}, grand: 0 };
-
-        uniqueCol1.forEach(val1 => {
-            table[val1] = {};
-            totals.row[val1] = 0;
-        });
-
-        uniqueCol2.forEach(val2 => {
-            totals.col[val2] = 0;
-        });
-
-        for (let i = 0; i < col1.length; i++) {
-            const val1 = col1[i];
-            const val2 = col2[i];
-
-            if (!table[val1][val2]) {
-                table[val1][val2] = 0;
-            }
-
-            table[val1][val2]++;
-            totals.row[val1]++;
-            totals.col[val2]++;
-            totals.grand++;
-        }
-
-        uniqueCol1.forEach(val1 => {
-            uniqueCol2.forEach(val2 => {
-                if (!table[val1][val2]) {
-                    table[val1][val2] = 0;
-                }
-            });
-        });
-
-        return { table, totals, rows: uniqueCol1, columns: uniqueCol2 };
-    }
-
-    mean(arr) {
-        return arr.reduce((sum, val) => sum + val, 0) / arr.length;
-    }
-
-    median(arr) {
-        const sorted = [...arr].sort((a, b) => a - b);
-        const mid = Math.floor(sorted.length / 2);
-        return sorted.length % 2 === 0 ?
-            (sorted[mid - 1] + sorted[mid]) / 2 :
-            sorted[mid];
-    }
-
-    quantile(arr, q) {
-        const sorted = [...arr].sort((a, b) => a - b);
-        const index = (sorted.length - 1) * q;
-        const lower = Math.floor(index);
-        const upper = Math.ceil(index);
-        const weight = index % 1;
-
-        if (lower === upper) {
-            return sorted[lower];
-        }
-
-        return sorted[lower] * (1 - weight) + sorted[upper] * weight;
-    }
-
-    standardDeviation(arr) {
-        return Math.sqrt(this.variance(arr));
-    }
-
-    variance(arr) {
-        const mean = this.mean(arr);
-        return arr.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / (arr.length - 1);
-    }
-
-    round(value, decimals = 4) {
-        return Math.round(value * Math.pow(10, decimals)) / Math.pow(10, decimals);
-    }
-
-    formatNumber(value, decimals = 4) {
-        if (typeof value !== 'number') return value;
-        return this.round(value, decimals);
-    }
-}
-
-export default Utils;