juxscript 1.1.240 → 1.1.244

package/lib/components/dataframe/DataFrameSource.js

@@ -1,421 +0,0 @@
-import { DataFrame } from '../../storage/DataFrame.js';
-import { TabularDriver } from '../../storage/TabularDriver.js';
-/**
- * DataFrameSource - Handles data acquisition from various sources
- *
- * Responsibilities:
- * - Load data from files (CSV, Excel)
- * - Load data from URLs
- * - Load data from IndexedDB storage
- * - Load data from inline arrays/objects
- * - Validate and detect malformed data
- * - Persist to storage if configured
- *
- * Does NOT handle:
- * - UI rendering
- * - User interactions
- * - Modals/dialogs
- */
-export class DataFrameSource {
-    constructor(options = {}) {
-        this._df = null;
-        this._sheets = new Map();
-        this._rawFileData = null;
-        this._sourceName = '';
-        this._onLoad = null;
-        this._onProgress = null;
-        this._onError = null;
-        this._options = {
-            maxFileSize: options.maxFileSize ?? 50,
-            maxSheetSize: options.maxSheetSize ?? 100000,
-            sheetChunkSize: options.sheetChunkSize ?? 10000,
-            persistToIndexedDB: options.persistToIndexedDB ?? false,
-            dbName: options.dbName ?? 'jux-dataframes',
-            storeName: options.storeName ?? 'frames'
-        };
-        this._driver = new TabularDriver(this._options.dbName, this._options.storeName);
-    }
-    /* ═══════════════════════════════════════════════════
-     * CALLBACKS
-     * ═══════════════════════════════════════════════════ */
-    onLoad(callback) {
-        this._onLoad = callback;
-        return this;
-    }
-    onProgress(callback) {
-        this._onProgress = callback;
-        return this;
-    }
-    onError(callback) {
-        this._onError = callback;
-        return this;
-    }
-    /* ═══════════════════════════════════════════════════
-     * DATA SOURCES
-     * ═══════════════════════════════════════════════════ */
-    /**
-     * Load from a FileUpload component
-     */
-    fromUpload(upload) {
-        upload.bind('change', async (files) => {
-            if (!files || files.length === 0) {
-                this.clear();
-                return;
-            }
-            await this.fromFile(files[0]);
-        });
-        return this;
-    }
-    /**
-     * Load from a File object directly
-     */
-    async fromFile(file) {
-        const fileSizeMB = file.size / (1024 * 1024);
-        if (fileSizeMB > this._options.maxFileSize) {
-            const error = `File too large (${fileSizeMB.toFixed(1)}MB). Max: ${this._options.maxFileSize}MB`;
-            this._onError?.(error);
-            return { df: null, sourceName: file.name, isMultiSheet: false, error };
-        }
-        try {
-            const isExcel = /\.(xlsx?|xls)$/i.test(file.name);
-            if (isExcel) {
-                return await this._loadExcel(file);
-            }
-            else {
-                return await this._loadCSV(file);
-            }
-        }
-        catch (err) {
-            const error = `Error parsing ${file.name}: ${err.message}`;
-            this._onError?.(error);
-            return { df: null, sourceName: file.name, isMultiSheet: false, error };
-        }
-    }
-    /**
-     * Load from a URL
-     */
-    async fromUrl(url) {
-        try {
-            this._onProgress?.(0, 100);
-            const df = await this._driver.fetch(url, {
-                autoDetectDelimiter: true,
-                hasHeader: true,
-                onProgress: (loaded, total) => {
-                    this._onProgress?.(loaded, total ?? 100);
-                }
-            });
-            this._df = df;
-            this._sourceName = url.split('/').pop() || url;
-            const result = {
-                df,
-                sourceName: this._sourceName,
-                isMultiSheet: false
-            };
-            if (this._options.persistToIndexedDB) {
-                await this._driver.store(this._sourceName, df, { source: url });
-            }
-            this._onLoad?.(result);
-            return result;
-        }
-        catch (err) {
-            const error = `Error fetching ${url}: ${err.message}`;
-            this._onError?.(error);
-            return { df: null, sourceName: url, isMultiSheet: false, error };
-        }
-    }
-    /**
-     * Load from IndexedDB storage by key
-     */
-    async fromStorage(key) {
-        try {
-            const df = await this._driver.loadByName(key);
-            if (!df) {
-                const error = `No data found with key: ${key}`;
-                this._onError?.(error);
-                return { df: null, sourceName: key, isMultiSheet: false, error };
-            }
-            this._df = df;
-            this._sourceName = key;
-            const result = {
-                df,
-                sourceName: key,
-                isMultiSheet: false
-            };
-            this._onLoad?.(result);
-            return result;
-        }
-        catch (err) {
-            const error = `Error loading from storage: ${err.message}`;
-            this._onError?.(error);
-            return { df: null, sourceName: key, isMultiSheet: false, error };
-        }
-    }
-    /**
-     * Load from inline data (array of objects or columnar format)
-     */
-    fromData(data, sourceName = 'inline data') {
-        try {
-            const df = new DataFrame(data);
-            this._df = df;
-            this._sourceName = sourceName;
-            const result = {
-                df,
-                sourceName,
-                isMultiSheet: false
-            };
-            this._onLoad?.(result);
-            return result;
-        }
-        catch (err) {
-            const error = `Error creating DataFrame: ${err.message}`;
-            this._onError?.(error);
-            return { df: null, sourceName, isMultiSheet: false, error };
-        }
-    }
-    /**
-     * Re-parse with different options (header row, delimiter)
-     */
-    async reimport(options) {
-        if (!this._rawFileData) {
-            const error = 'No raw file data available for reimport';
-            this._onError?.(error);
-            return { df: null, sourceName: this._sourceName, isMultiSheet: false, error };
-        }
-        try {
-            if (this._rawFileData.isExcel) {
-                const sheets = await this._driver.streamFileMultiSheet(this._rawFileData.file, {
-                    headerRow: options.headerRow ?? 0,
-                    maxSheetSize: this._options.maxSheetSize,
-                    sheetChunkSize: this._options.sheetChunkSize
-                });
-                return this._processSheets(sheets, this._rawFileData.file.name);
-            }
-            else {
-                const df = this._driver.parseCSV(this._rawFileData.text, {
-                    delimiter: options.delimiter,
-                    headerRow: options.headerRow ?? 0,
-                    hasHeader: true
-                });
-                this._df = df;
-                if (this._options.persistToIndexedDB) {
-                    await this._driver.store(this._rawFileData.file.name, df);
-                }
-                const result = {
-                    df,
-                    sourceName: this._rawFileData.file.name,
-                    isMultiSheet: false
-                };
-                this._onLoad?.(result);
-                return result;
-            }
-        }
-        catch (err) {
-            const error = `Error reimporting: ${err.message}`;
-            this._onError?.(error);
-            return { df: null, sourceName: this._sourceName, isMultiSheet: false, error };
-        }
-    }
-    /* ═══════════════════════════════════════════════════
-     * ACCESSORS
-     * ═══════════════════════════════════════════════════ */
-    get df() {
-        return this._df;
-    }
-    get sheets() {
-        return this._sheets;
-    }
-    get sourceName() {
-        return this._sourceName;
-    }
-    get rawFileData() {
-        return this._rawFileData;
-    }
-    get driver() {
-        return this._driver;
-    }
-    get shape() {
-        return this._df?.shape ?? [0, 0];
-    }
-    get columns() {
-        return this._df?.columns ?? [];
-    }
-    get height() {
-        return this._df?.height ?? 0;
-    }
-    get width() {
-        return this._df?.width ?? 0;
-    }
-    /* ═══════════════════════════════════════════════════
-     * DATA QUALITY
-     * ═══════════════════════════════════════════════════ */
-    /**
-     * Detect if the data appears malformed (bad headers, metadata rows, etc.)
-     */
-    detectMalformed() {
-        if (!this._df)
-            return false;
-        const columns = this._df.columns;
-        const rows = this._df.toRows();
-        // Check for generic/empty column names
-        const hasGenericColumns = columns.some(col => col.startsWith('__EMPTY') ||
-            /^_\d+$/.test(col) ||
-            /^col_\d+$/.test(col));
-        if (hasGenericColumns)
-            return true;
-        // Check if first row looks like metadata
-        if (rows.length > 0) {
-            const firstRow = rows[0];
-            const values = Object.values(firstRow);
-            const nonEmpty = values.filter(v => v !== null && v !== undefined && String(v).trim() !== '');
-            // Sparse first row suggests header issues
-            if (nonEmpty.length < columns.length * 0.5)
-                return true;
-            // Common metadata patterns
-            const hasMetadata = values.some(v => String(v).includes('Exported') ||
-                String(v).includes('Generated') ||
-                String(v).includes('Report'));
-            if (hasMetadata)
-                return true;
-        }
-        return false;
-    }
-    /**
-     * Get raw preview rows for header selection UI
-     */
-    async getPreviewRows(maxRows = 15) {
-        if (!this._rawFileData?.file)
-            return [];
-        if (this._rawFileData.isExcel) {
-            return this._driver.readRawExcelRows(this._rawFileData.file, maxRows);
-        }
-        else if (this._rawFileData.text) {
-            return this._parseCSVPreview(this._rawFileData.text, maxRows);
-        }
-        return [];
-    }
-    /* ═══════════════════════════════════════════════════
-     * PERSISTENCE
-     * ═══════════════════════════════════════════════════ */
-    async save(key) {
-        if (!this._df)
-            return null;
-        const name = key ?? this._sourceName;
-        return this._driver.store(name, this._df);
-    }
-    async clearStorage() {
-        if (this._rawFileData?.file) {
-            const tables = await this._driver.list();
-            const matching = tables.filter(t => t.name === this._rawFileData.file.name);
-            for (const table of matching) {
-                await this._driver.delete(table.id);
-            }
-        }
-    }
-    clear() {
-        this._df = null;
-        this._sheets.clear();
-        this._rawFileData = null;
-        this._sourceName = '';
-    }
-    /* ═══════════════════════════════════════════════════
-     * PRIVATE HELPERS
-     * ═══════════════════════════════════════════════════ */
-    async _loadExcel(file) {
-        this._rawFileData = { file, isExcel: true };
-        const sheets = await this._driver.streamFileMultiSheet(file, {
-            maxSheetSize: this._options.maxSheetSize,
-            sheetChunkSize: this._options.sheetChunkSize,
-            onProgress: (loaded, total) => {
-                this._onProgress?.(loaded, total ?? 100);
-            }
-        });
-        return this._processSheets(sheets, file.name);
-    }
-    async _loadCSV(file) {
-        const text = await file.text();
-        this._rawFileData = { file, text, isExcel: false };
-        const df = this._driver.parseCSV(text, {
-            autoDetectDelimiter: true,
-            hasHeader: true
-        });
-        // Strip fully empty __EMPTY columns
-        const cleanDf = this._stripEmptyColumns(df);
-        this._df = cleanDf;
-        this._sourceName = file.name;
-        if (this._options.persistToIndexedDB) {
-            await this._driver.store(file.name, cleanDf, { source: file.name });
-        }
-        const result = {
-            df: cleanDf,
-            sourceName: file.name,
-            isMultiSheet: false
-        };
-        this._onLoad?.(result);
-        return result;
-    }
-    async _processSheets(sheets, sourceName) {
-        const sheetNames = Object.keys(sheets);
-        if (sheetNames.length === 0) {
-            const error = 'No data found in file';
-            this._onError?.(error);
-            return { df: null, sourceName, isMultiSheet: false, error };
-        }
-        this._sheets.clear();
-        sheetNames.forEach(name => {
-            this._sheets.set(name, this._stripEmptyColumns(sheets[name]));
-        });
-        const firstSheet = this._sheets.get(sheetNames[0]);
-        this._df = firstSheet;
-        this._sourceName = sourceName;
-        if (this._options.persistToIndexedDB) {
-            await this._driver.store(sourceName, firstSheet, { source: sourceName });
-        }
-        const result = {
-            df: firstSheet,
-            sheets: Object.fromEntries(this._sheets),
-            sourceName,
-            isMultiSheet: sheetNames.length > 1
-        };
-        this._onLoad?.(result);
-        return result;
-    }
-    _stripEmptyColumns(df) {
-        const cols = df.columns;
-        const rows = df.toRows();
-        const emptyColumns = cols.filter(c => {
-            if (!c.startsWith('__EMPTY'))
-                return false;
-            return rows.every(row => {
-                const val = row[c];
-                return val === null || val === undefined || String(val).trim() === '';
-            });
-        });
-        if (emptyColumns.length > 0) {
-            const keepCols = cols.filter(c => !emptyColumns.includes(c));
-            if (keepCols.length > 0) {
-                return df.select(...keepCols);
-            }
-        }
-        return df;
-    }
-    _parseCSVPreview(text, maxRows) {
-        const lines = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
-        const delimiter = this._driver._detectDelimiter(text);
-        const rows = [];
-        for (let i = 0; i < Math.min(lines.length, maxRows); i++) {
-            if (!lines[i]) {
-                rows.push({ sheetRow: i, values: [''] });
-                continue;
-            }
-            const values = this._driver._parseLine(lines[i], delimiter);
-            rows.push({ sheetRow: i, values });
-        }
-        return rows;
-    }
-}
-/**
- * Factory function
- */
-export function dataFrameSource(options = {}) {
-    return new DataFrameSource(options);
-}