juxscript 1.1.231 → 1.1.232

package/lib/storage/DataFrameSource.d.ts

@@ -0,0 +1,158 @@
+import { DataFrame } from './DataFrame.js';
+export interface SourceOptions {
+    dbName?: string;
+    storeName?: string;
+    persistToIndexedDB?: boolean;
+    inferTypes?: boolean;
+    maxFileSize?: number;
+    maxSheetSize?: number;
+    headerRow?: number;
+    delimiter?: string;
+}
+export interface APIOptions {
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    headers?: Record<string, string>;
+    body?: any;
+    credentials?: 'omit' | 'same-origin' | 'include';
+    dataPath?: string;
+}
+export interface StreamOptions {
+    mimeType?: string;
+    chunkSize?: number;
+    cacheToIndexedDB?: boolean;
+}
+export interface MultiSheetResult {
+    sheets: Map<string, DataFrame>;
+    sheetNames: string[];
+    activeSheet: string;
+}
+/**
+ * DataFrameSource - Data acquisition layer for DataFrames
+ *
+ * Responsibilities:
+ * - Load from files (CSV, TSV, Excel)
+ * - Load from URLs (fetch, stream)
+ * - Load from APIs (with auth, JSON traversal)
+ * - Load from IndexedDB
+ * - Load from inline data
+ * - Multi-sheet support
+ * - Progress callbacks
+ *
+ * This is a PURE data layer - no UI concerns
+ */
+export declare class DataFrameSource {
+    private _driver;
+    private _options;
+    private _sheets;
+    private _activeSheet;
+    private _sourceName;
+    private _rawFile;
+    private _rawText;
+    constructor(options?: SourceOptions);
+    /**
+     * Load from a File object (CSV, TSV, Excel)
+     */
+    fromFile(file: File, onProgress?: (loaded: number, total: number | null) => void): Promise<DataFrame | MultiSheetResult>;
+    /**
+     * Fetch CSV/TSV from URL
+     */
+    fromUrl(url: string, onProgress?: (loaded: number, total: number | null) => void): Promise<DataFrame>;
+    /**
+     * Fetch data from API endpoint
+     * Supports JSON response with path traversal
+     */
+    fromAPI(url: string, options?: APIOptions): Promise<DataFrame>;
+    /**
+     * Traverse JSON path like "data.results" or "response.items[0].records"
+     */
+    private _traversePath;
+    /**
+     * Stream binary data from URL, auto-detect format from MIME type
+     */
+    fromStream(url: string, options?: StreamOptions, onProgress?: (loaded: number, total: number | null) => void): Promise<DataFrame | MultiSheetResult>;
+    private _cacheBlob;
+    /**
+     * Load from IndexedDB by key/name
+     */
+    fromStorage(key: string): Promise<DataFrame | null>;
+    /**
+     * List all stored DataFrames
+     */
+    listStored(): Promise<Array<{
+        id: string;
+        name: string;
+        rowCount: number;
+        timestamp: number;
+    }>>;
+    /**
+     * Create from inline data
+     */
+    fromData(data: Record<string, any>[] | Record<string, any[]>, name?: string): DataFrame;
+    /**
+     * Create empty DataFrame with specified columns
+     */
+    empty(columns: string[]): DataFrame;
+    /**
+     * Re-parse with different options
+     */
+    reimport(options: {
+        headerRow?: number;
+        delimiter?: string;
+        sheetName?: string;
+    }): Promise<DataFrame | MultiSheetResult>;
+    /**
+     * Get raw preview rows for header selection UI
+     */
+    getPreviewRows(maxRows?: number): Promise<{
+        row: number;
+        values: any[];
+    }[]>;
+    /**
+     * Get all sheet names
+     */
+    get sheetNames(): string[];
+    /**
+     * Get active sheet
+     */
+    get activeSheet(): string;
+    /**
+     * Set active sheet
+     */
+    setActiveSheet(name: string): DataFrame;
+    /**
+     * Get specific sheet by name
+     */
+    getSheet(name: string): DataFrame | undefined;
+    /**
+     * Get current DataFrame (active sheet)
+     */
+    get df(): DataFrame | null;
+    /**
+     * Get all sheets
+     */
+    get sheets(): Map<string, DataFrame>;
+    /**
+     * Save current DataFrame to IndexedDB
+     */
+    save(key?: string): Promise<string | null>;
+    /**
+     * Save all sheets
+     */
+    saveAll(prefix?: string): Promise<string[]>;
+    /**
+     * Delete from storage
+     */
+    deleteStored(key: string): Promise<void>;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+    get sourceName(): string;
+    get hasRawData(): boolean;
+    get isExcel(): boolean;
+}
+/**
+ * Factory function
+ */
+export declare function dataFrameSource(options?: SourceOptions): DataFrameSource;
+//# sourceMappingURL=DataFrameSource.d.ts.map

package/lib/storage/DataFrameSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataFrameSource.d.ts","sourceRoot":"","sources":["DataFrameSource.ts"],"names":[],"mappings":"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"}

package/lib/storage/DataFrameSource.js

@@ -0,0 +1,409 @@
+import { DataFrame } from './DataFrame.js';
+import { TabularDriver } from './TabularDriver.js';
+/**
+ * DataFrameSource - Data acquisition layer for DataFrames
+ *
+ * Responsibilities:
+ * - Load from files (CSV, TSV, Excel)
+ * - Load from URLs (fetch, stream)
+ * - Load from APIs (with auth, JSON traversal)
+ * - Load from IndexedDB
+ * - Load from inline data
+ * - Multi-sheet support
+ * - Progress callbacks
+ *
+ * This is a PURE data layer - no UI concerns
+ */
+export class DataFrameSource {
+    constructor(options = {}) {
+        this._sheets = new Map();
+        this._activeSheet = '';
+        this._sourceName = '';
+        this._rawFile = null;
+        this._rawText = null;
+        this._options = {
+            dbName: options.dbName ?? 'jux-dataframes',
+            storeName: options.storeName ?? 'frames',
+            persistToIndexedDB: options.persistToIndexedDB ?? false,
+            inferTypes: options.inferTypes ?? true,
+            maxFileSize: options.maxFileSize ?? 50,
+            maxSheetSize: options.maxSheetSize ?? 100000,
+            headerRow: options.headerRow ?? 0,
+            delimiter: options.delimiter
+        };
+        this._driver = new TabularDriver(this._options.dbName, this._options.storeName);
+    }
+    /* ═══════════════════════════════════════════════════
+     * FROM FILE
+     * ═══════════════════════════════════════════════════ */
+    /**
+     * Load from a File object (CSV, TSV, Excel)
+     */
+    async fromFile(file, onProgress) {
+        const fileSizeMB = file.size / (1024 * 1024);
+        if (fileSizeMB > this._options.maxFileSize) {
+            throw new Error(`File too large (${fileSizeMB.toFixed(1)}MB). Max: ${this._options.maxFileSize}MB`);
+        }
+        this._rawFile = file;
+        this._sourceName = file.name;
+        const isExcel = /\.(xlsx?|xls)$/i.test(file.name);
+        if (isExcel) {
+            const sheets = await this._driver.streamFileMultiSheet(file, {
+                maxSheetSize: this._options.maxSheetSize,
+                headerRow: this._options.headerRow,
+                onProgress
+            });
+            this._sheets.clear();
+            const sheetNames = Object.keys(sheets);
+            sheetNames.forEach(name => {
+                this._sheets.set(name, sheets[name]);
+            });
+            this._activeSheet = sheetNames[0] || '';
+            if (this._options.persistToIndexedDB) {
+                await this._driver.store(file.name, sheets[sheetNames[0]], { source: file.name });
+            }
+            if (sheetNames.length > 1) {
+                return {
+                    sheets: this._sheets,
+                    sheetNames,
+                    activeSheet: this._activeSheet
+                };
+            }
+            else {
+                return this._sheets.get(this._activeSheet);
+            }
+        }
+        else {
+            const text = await file.text();
+            this._rawText = text;
+            const df = this._driver.parseCSV(text, {
+                autoDetectDelimiter: !this._options.delimiter,
+                delimiter: this._options.delimiter,
+                headerRow: this._options.headerRow,
+                hasHeader: true
+            });
+            this._sheets.set('Sheet1', df);
+            this._activeSheet = 'Sheet1';
+            if (this._options.persistToIndexedDB) {
+                await this._driver.store(file.name, df, { source: file.name });
+            }
+            return df;
+        }
+    }
+    /* ═══════════════════════════════════════════════════
+     * FROM URL (Simple Fetch)
+     * ═══════════════════════════════════════════════════ */
+    /**
+     * Fetch CSV/TSV from URL
+     */
+    async fromUrl(url, onProgress) {
+        this._sourceName = url.split('/').pop() || url;
+        const df = await this._driver.fetch(url, {
+            autoDetectDelimiter: true,
+            hasHeader: true,
+            headerRow: this._options.headerRow,
+            onProgress
+        });
+        this._sheets.set('Sheet1', df);
+        this._activeSheet = 'Sheet1';
+        if (this._options.persistToIndexedDB) {
+            await this._driver.store(this._sourceName, df, { source: url });
+        }
+        return df;
+    }
+    /* ═══════════════════════════════════════════════════
+     * FROM API (JSON with traversal)
+     * ═══════════════════════════════════════════════════ */
+    /**
+     * Fetch data from API endpoint
+     * Supports JSON response with path traversal
+     */
+    async fromAPI(url, options = {}) {
+        const { method = 'GET', headers = {}, body, credentials = 'same-origin', dataPath } = options;
+        const fetchOptions = {
+            method,
+            headers: {
+                'Accept': 'application/json',
+                ...headers
+            },
+            credentials
+        };
+        if (body && method !== 'GET') {
+            fetchOptions.body = typeof body === 'string' ? body : JSON.stringify(body);
+            if (!headers['Content-Type']) {
+                fetchOptions.headers['Content-Type'] = 'application/json';
+            }
+        }
+        const response = await fetch(url, fetchOptions);
+        if (!response.ok) {
+            throw new Error(`API request failed: ${response.status} ${response.statusText}`);
+        }
+        let data = await response.json();
+        // Traverse to data path if specified
+        if (dataPath) {
+            data = this._traversePath(data, dataPath);
+        }
+        // Convert to DataFrame
+        if (!Array.isArray(data)) {
+            throw new Error('API response must be an array of objects (or use dataPath to navigate to array)');
+        }
+        const df = new DataFrame(data, { inferTypes: this._options.inferTypes });
+        this._sourceName = url;
+        this._sheets.set('Sheet1', df);
+        this._activeSheet = 'Sheet1';
+        if (this._options.persistToIndexedDB) {
+            await this._driver.store(this._sourceName, df, { source: url });
+        }
+        return df;
+    }
+    /**
+     * Traverse JSON path like "data.results" or "response.items[0].records"
+     */
+    _traversePath(obj, path) {
+        const parts = path.split(/\.|\[|\]/).filter(Boolean);
+        let current = obj;
+        for (const part of parts) {
+            if (current === null || current === undefined) {
+                throw new Error(`Cannot traverse path '${path}': null at '${part}'`);
+            }
+            const index = Number(part);
+            if (!isNaN(index)) {
+                current = current[index];
+            }
+            else {
+                current = current[part];
+            }
+        }
+        return current;
+    }
+    /* ═══════════════════════════════════════════════════
+     * FROM STREAM (Binary data with MIME type)
+     * ═══════════════════════════════════════════════════ */
+    /**
+     * Stream binary data from URL, auto-detect format from MIME type
+     */
+    async fromStream(url, options = {}, onProgress) {
+        const { mimeType, cacheToIndexedDB = false } = options;
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Stream request failed: ${response.status}`);
+        }
+        const contentType = mimeType || response.headers.get('content-type') || '';
+        const fileName = url.split('/').pop() || 'stream-data';
+        // Get the blob
+        const blob = await response.blob();
+        const file = new File([blob], fileName, { type: contentType });
+        // Cache to IndexedDB if requested
+        if (cacheToIndexedDB) {
+            // Store raw blob for potential re-parsing
+            await this._cacheBlob(fileName, blob);
+        }
+        // Parse based on content type
+        return this.fromFile(file, onProgress);
+    }
+    async _cacheBlob(name, blob) {
+        // Simple blob caching in IndexedDB
+        const db = await this._driver.open();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction('blobs', 'readwrite');
+            const store = tx.objectStore('blobs');
+            store.put({ name, blob, timestamp: Date.now() });
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    /* ═══════════════════════════════════════════════════
+     * FROM INDEXEDDB
+     * ═══════════════════════════════════════════════════ */
+    /**
+     * Load from IndexedDB by key/name
+     */
+    async fromStorage(key) {
+        const df = await this._driver.loadByName(key);
+        if (df) {
+            this._sourceName = key;
+            this._sheets.set('Sheet1', df);
+            this._activeSheet = 'Sheet1';
+        }
+        return df;
+    }
+    /**
+     * List all stored DataFrames
+     */
+    async listStored() {
+        return this._driver.list();
+    }
+    /* ═══════════════════════════════════════════════════
+     * FROM INLINE DATA
+     * ═══════════════════════════════════════════════════ */
+    /**
+     * Create from inline data
+     */
+    fromData(data, name = 'inline') {
+        const df = new DataFrame(data, { inferTypes: this._options.inferTypes });
+        this._sourceName = name;
+        this._sheets.set('Sheet1', df);
+        this._activeSheet = 'Sheet1';
+        return df;
+    }
+    /**
+     * Create empty DataFrame with specified columns
+     */
+    empty(columns) {
+        const data = {};
+        columns.forEach(c => { data[c] = []; });
+        return this.fromData(data, 'empty');
+    }
+    /* ═══════════════════════════════════════════════════
+     * RE-IMPORT / RE-PARSE
+     * ═══════════════════════════════════════════════════ */
+    /**
+     * Re-parse with different options
+     */
+    async reimport(options) {
+        if (this._rawFile) {
+            // Update options
+            if (options.headerRow !== undefined) {
+                this._options.headerRow = options.headerRow;
+            }
+            if (options.delimiter !== undefined) {
+                this._options.delimiter = options.delimiter;
+            }
+            return this.fromFile(this._rawFile);
+        }
+        else if (this._rawText) {
+            const df = this._driver.parseCSV(this._rawText, {
+                delimiter: options.delimiter || this._options.delimiter,
+                headerRow: options.headerRow ?? this._options.headerRow,
+                hasHeader: true
+            });
+            this._sheets.set(this._activeSheet, df);
+            return df;
+        }
+        throw new Error('No raw data available for reimport');
+    }
+    /**
+     * Get raw preview rows for header selection UI
+     */
+    async getPreviewRows(maxRows = 15) {
+        if (this._rawFile && /\.(xlsx?|xls)$/i.test(this._rawFile.name)) {
+            const rows = await this._driver.readRawExcelRows(this._rawFile, maxRows);
+            return rows.map(r => ({ row: r.sheetRow, values: r.values }));
+        }
+        else if (this._rawText) {
+            const lines = this._rawText.split('\n').slice(0, maxRows);
+            const delimiter = this._driver._detectDelimiter(this._rawText);
+            return lines.map((line, i) => ({
+                row: i,
+                values: this._driver._parseLine(line, delimiter)
+            }));
+        }
+        return [];
+    }
+    /* ═══════════════════════════════════════════════════
+     * MULTI-SHEET ACCESS
+     * ═══════════════════════════════════════════════════ */
+    /**
+     * Get all sheet names
+     */
+    get sheetNames() {
+        return Array.from(this._sheets.keys());
+    }
+    /**
+     * Get active sheet
+     */
+    get activeSheet() {
+        return this._activeSheet;
+    }
+    /**
+     * Set active sheet
+     */
+    setActiveSheet(name) {
+        if (!this._sheets.has(name)) {
+            throw new Error(`Sheet '${name}' not found`);
+        }
+        this._activeSheet = name;
+        return this._sheets.get(name);
+    }
+    /**
+     * Get specific sheet by name
+     */
+    getSheet(name) {
+        return this._sheets.get(name);
+    }
+    /**
+     * Get current DataFrame (active sheet)
+     */
+    get df() {
+        return this._sheets.get(this._activeSheet) || null;
+    }
+    /**
+     * Get all sheets
+     */
+    get sheets() {
+        return new Map(this._sheets);
+    }
+    /* ═══════════════════════════════════════════════════
+     * PERSISTENCE
+     * ═══════════════════════════════════════════════════ */
+    /**
+     * Save current DataFrame to IndexedDB
+     */
+    async save(key) {
+        const df = this.df;
+        if (!df)
+            return null;
+        const name = key || this._sourceName;
+        return this._driver.store(name, df);
+    }
+    /**
+     * Save all sheets
+     */
+    async saveAll(prefix) {
+        const ids = [];
+        for (const [sheetName, df] of this._sheets) {
+            const key = prefix ? `${prefix}_${sheetName}` : `${this._sourceName}_${sheetName}`;
+            const id = await this._driver.store(key, df);
+            ids.push(id);
+        }
+        return ids;
+    }
+    /**
+     * Delete from storage
+     */
+    async deleteStored(key) {
+        const tables = await this._driver.list();
+        const matching = tables.filter(t => t.name === key);
+        for (const table of matching) {
+            await this._driver.delete(table.id);
+        }
+    }
+    /**
+     * Clear all data
+     */
+    clear() {
+        this._sheets.clear();
+        this._activeSheet = '';
+        this._sourceName = '';
+        this._rawFile = null;
+        this._rawText = null;
+    }
+    /* ═══════════════════════════════════════════════════
+     * SOURCE INFO
+     * ═══════════════════════════════════════════════════ */
+    get sourceName() {
+        return this._sourceName;
+    }
+    get hasRawData() {
+        return this._rawFile !== null || this._rawText !== null;
+    }
+    get isExcel() {
+        return this._rawFile !== null && /\.(xlsx?|xls)$/i.test(this._rawFile.name);
+    }
+}
+/**
+ * Factory function
+ */
+export function dataFrameSource(options = {}) {
+    return new DataFrameSource(options);
+}