juxscript 1.1.240 → 1.1.244

package/lib/data/DataPipeline.ts

@@ -1,452 +0,0 @@
-import { DataFrame } from '../storage/DataFrame.js';
-import { TabularDriver } from '../storage/TabularDriver.js';
-
-export interface PipelineOptions {
-    dbName?: string;
-    storeName?: string;
-}
-
-export interface FetchOptions {
-    delimiter?: string;
-    hasHeader?: boolean;
-    headerRow?: number;
-    mimeType?: 'csv' | 'tsv' | 'json' | 'auto';
-}
-
-export interface GatherOptions extends FetchOptions {
-    /** Authorization bearer token */
-    bearer?: string;
-    /** API key (sent as x-api-key header) */
-    apiKey?: string;
-    /** Custom headers for URL fetches */
-    headers?: Record<string, string>;
-    /** IndexedDB database name override */
-    dbName?: string;
-    /** IndexedDB store name override */
-    storeName?: string;
-}
-
-export interface IntoOptions {
-    /** Override which columns to use (for Table targets) */
-    columns?: string[];
-    /** Column name → display label mapping */
-    columnLabels?: Record<string, string>;
-    /** Key for option labels (Dropdown/Select/List targets) */
-    labelKey?: string;
-    /** Key for option values (Dropdown/Select targets) */
-    valueKey?: string;
-}
-
-/**
- * DataPipeline — Headless, promise-based data loading and transformation.
- *
- * Usage:
- *   const df = await jux.gather('raw/myfile.xlsx').result();
- *   const df = await jux.gather('https://api.com/data', { bearer: 'xxx' }).result();
- *   const df = await jux.gather(myUpload).select('name').result();
- *   const df = await jux.gather([{a:1}, {b:2}]).result();
- *   await jux.gather(key).filter(r => r.active).intoTable(myTable);
- */
-export class DataPipeline {
-    private _driver: TabularDriver;
-    private _pending: Promise<DataFrame> | null = null;
-    private _transforms: ((df: DataFrame) => DataFrame)[] = [];
-    private _gatherOptions: GatherOptions;
-
-    constructor(options: PipelineOptions = {}) {
-        this._driver = new TabularDriver(
-            options.dbName ?? 'jux-dataframes',
-            options.storeName ?? 'frames'
-        );
-        this._gatherOptions = {};
-    }
-
-    /* ═══════════════════════════════════════════════════
-     * SMART SOURCE DETECTION
-     * ═══════════════════════════════════════════════════ */
-
-    /**
-     * Auto-detect source type and load accordingly.
-     *
-     * - string starting with http/https → URL fetch
-     * - string → IndexedDB storage key
-     * - File → parse file
-     * - Array → row objects
-     * - DataFrame → clone
-     * - object with .storageKey → FileUpload cached key
-     * - object with string keys + array values → column-oriented data
-     */
-    from(source: any, options: GatherOptions = {}): this {
-        this._transforms = [];
-        this._gatherOptions = options;
-
-        // Update driver if custom db/store
-        if (options.dbName || options.storeName) {
-            this._driver = new TabularDriver(
-                options.dbName ?? 'jux-dataframes',
-                options.storeName ?? 'frames'
-            );
-        }
-
-        if (source instanceof DataFrame) {
-            this._pending = Promise.resolve(source.clone());
-        } else if (Array.isArray(source)) {
-            this._pending = Promise.resolve(new DataFrame(source));
-        } else if (typeof source === 'string') {
-            if (/^https?:\/\//i.test(source)) {
-                this._pending = this._loadFromUrl(source, options);
-            } else {
-                this._pending = this._loadFromStorage(source);
-            }
-        } else if (source instanceof File) {
-            this._pending = this._loadFromFile(source, options);
-        } else if (source && typeof source === 'object' && 'storageKey' in source) {
-            // FileUpload component with .cache() enabled
-            const key = source.storageKey;
-            if (!key) {
-                this._pending = Promise.reject(
-                    new Error('FileUpload has no cached storage key. Ensure .cache() is enabled and a file has been uploaded.')
-                );
-            } else {
-                this._pending = this._loadFromStorage(key);
-            }
-        } else if (source && typeof source === 'object' && !Array.isArray(source)) {
-            // Column-oriented: { col1: [...], col2: [...] }
-            this._pending = Promise.resolve(new DataFrame(source));
-        } else {
-            this._pending = Promise.reject(new Error('Unrecognized source type passed to gather()'));
-        }
-
-        return this;
-    }
-
-    /* ═══════════════════════════════════════════════════
-     * EXPLICIT SOURCES (still available)
-     * ═══════════════════════════════════════════════════ */
-
-    fromStorage(key: string): this {
-        this._transforms = [];
-        this._pending = this._loadFromStorage(key);
-        return this;
-    }
-
-    fromUrl(url: string, options: GatherOptions = {}): this {
-        this._transforms = [];
-        this._gatherOptions = options;
-        this._pending = this._loadFromUrl(url, options);
-        return this;
-    }
-
-    fromFile(file: File, options: FetchOptions = {}): this {
-        this._transforms = [];
-        this._pending = this._loadFromFile(file, options);
-        return this;
-    }
-
-    fromRows(rows: Record<string, any>[], columns?: string[]): this {
-        this._transforms = [];
-        this._pending = Promise.resolve(new DataFrame(rows, { columns }));
-        return this;
-    }
-
-    fromColumns(columns: Record<string, any[]>): this {
-        this._transforms = [];
-        this._pending = Promise.resolve(new DataFrame(columns));
-        return this;
-    }
-
-    fromJson(json: Record<string, any>[] | Record<string, any[]> | string): this {
-        this._transforms = [];
-        const parsed = typeof json === 'string' ? JSON.parse(json) : json;
-        this._pending = Promise.resolve(new DataFrame(parsed));
-        return this;
-    }
-
-    fromUpload(upload: any): this {
-        this._transforms = [];
-        const key = upload.storageKey;
-        if (!key) {
-            this._pending = Promise.reject(
-                new Error('FileUpload has no cached storage key. Ensure .cache() is enabled and a file has been uploaded.')
-            );
-        } else {
-            this._pending = this._loadFromStorage(key);
-        }
-        return this;
-    }
-
-    /* ═══════════════════════════════════════════════════
-     * TRANSFORMS (chained, lazy — applied on terminal)
-     * ═══════════════════════════════════════════════════ */
-
-    transform(fn: (df: DataFrame) => DataFrame): this {
-        this._transforms.push(fn);
-        return this;
-    }
-
-    select(...cols: string[]): this {
-        return this.transform(df => df.select(...cols));
-    }
-
-    filter(predicate: (row: Record<string, any>, index: number) => boolean): this {
-        return this.transform(df => df.filter(predicate));
-    }
-
-    sort(column: string, descending?: boolean): this {
-        return this.transform(df => df.sort(column, descending));
-    }
-
-    head(n: number = 5): this {
-        return this.transform(df => df.head(n));
-    }
-
-    tail(n: number = 5): this {
-        return this.transform(df => df.tail(n));
-    }
-
-    rename(mapping: Record<string, string>): this {
-        return this.transform(df => df.rename(mapping));
-    }
-
-    withColumn(name: string, fn: (row: Record<string, any>, index: number) => any): this {
-        return this.transform(df => df.withColumn(name, fn));
-    }
-
-    dropna(columns?: string[]): this {
-        return this.transform(df => df.dropna(columns));
-    }
-
-    dropDuplicates(columns?: string[]): this {
-        return this.transform(df => df.dropDuplicates(columns));
-    }
-
-    /* ═══════════════════════════════════════════════════
-     * TERMINAL OPERATIONS
-     * ═══════════════════════════════════════════════════ */
-
-    async result(): Promise<DataFrame> {
-        if (!this._pending) throw new Error('No data source specified. Call gather(source) or from*(source) first.');
-        let df = await this._pending;
-        for (const fn of this._transforms) {
-            df = fn(df);
-        }
-        return df;
-    }
-
-    async toRows(): Promise<Record<string, any>[]> {
-        return (await this.result()).toRows();
-    }
-
-    async toArray(column: string): Promise<any[]> {
-        return (await this.result()).col(column);
-    }
-
-    async toDistinct(column: string): Promise<any[]> {
-        return (await this.result()).distinct(column);
-    }
-
-    async toOptions(labelKey: string, valueKey?: string): Promise<{ label: string; value: any }[]> {
-        const df = await this.result();
-        const vKey = valueKey ?? labelKey;
-        return df.toRows().map(row => ({
-            label: String(row[labelKey] ?? ''),
-            value: row[vKey]
-        }));
-    }
-
-    async toList(column: string): Promise<string[]> {
-        const df = await this.result();
-        return df.col(column).map(v => String(v ?? ''));
-    }
-
-    async intoTable(table: any, columnLabels?: Record<string, string>): Promise<DataFrame> {
-        const df = await this.result();
-        const columnDefs = df.columns.map(col => ({
-            key: col,
-            label: columnLabels?.[col] ?? col
-        }));
-        table.columns(columnDefs).rows(df.toRows());
-        return df;
-    }
-
-    async intoDropdown(dropdown: any, labelKey: string, valueKey?: string): Promise<DataFrame> {
-        const df = await this.result();
-        const vKey = valueKey ?? labelKey;
-        const opts = df.toRows().map(row => ({
-            label: String(row[labelKey] ?? ''),
-            value: row[vKey]
-        }));
-        dropdown.options(opts);
-        return df;
-    }
-
-    async intoList(list: any, column: string): Promise<DataFrame> {
-        const df = await this.result();
-        list.items(df.col(column).map((v: any) => String(v ?? '')));
-        return df;
-    }
-
-    async into(target: any, options: IntoOptions = {}): Promise<DataFrame> {
-        const df = await this.result();
-        const rows = df.toRows();
-
-        if (typeof target.columns === 'function' && typeof target.rows === 'function') {
-            const cols = options.columns ?? df.columns;
-            const columnDefs = cols.map((col: string) => ({
-                key: col,
-                label: options.columnLabels?.[col] ?? col
-            }));
-            target.columns(columnDefs).rows(rows);
-            return df;
-        }
-
-        if (typeof target.fromData === 'function') {
-            target.fromData(rows);
-            return df;
-        }
-
-        if (typeof target.options === 'function') {
-            if (!options.labelKey) {
-                throw new Error(
-                    'Cannot push into dropdown/select without labelKey. ' +
-                    'Use .intoDropdown(target, labelKey, valueKey) or pass { labelKey, valueKey } to .into()'
-                );
-            }
-            const opts = rows.map(row => ({
-                label: String(row[options.labelKey!] ?? ''),
-                value: row[options.valueKey ?? options.labelKey!]
-            }));
-            target.options(opts);
-            return df;
-        }
-
-        if (typeof target.items === 'function') {
-            if (!options.labelKey) {
-                throw new Error(
-                    'Cannot push into list without labelKey. ' +
-                    'Use .intoList(target, column) or pass { labelKey } to .into()'
-                );
-            }
-            target.items(rows.map(row => String(row[options.labelKey!] ?? '')));
-            return df;
-        }
-
-        throw new Error('Target does not have a recognized API (.columns/.rows, .fromData, .options, or .items)');
-    }
-
-    async store(key: string, metadata?: Record<string, any>): Promise<DataFrame> {
-        const df = await this.result();
-        await this._driver.store(key, df, metadata);
-        return df;
-    }
-
-    /* ═══════════════════════════════════════════════════
-     * PRIVATE
-     * ═══════════════════════════════════════════════════ */
-
-    private async _loadFromStorage(key: string): Promise<DataFrame> {
-        // Try by name first, then by id
-        let df = await this._driver.loadByName(key);
-        if (df) return df;
-
-        df = await this._driver.load(key);
-        if (df) return df;
-
-        throw new Error(`No data found in storage with key: "${key}"`);
-    }
-
-    private async _loadFromUrl(url: string, options: GatherOptions): Promise<DataFrame> {
-        const mimeType = options.mimeType ?? this._detectMimeType(url);
-
-        // Build headers from auth options
-        const headers: Record<string, string> = { ...options.headers };
-        if (options.bearer) {
-            headers['Authorization'] = `Bearer ${options.bearer}`;
-        }
-        if (options.apiKey) {
-            headers['x-api-key'] = options.apiKey;
-        }
-
-        if (mimeType === 'json') {
-            const response = await fetch(url, { headers });
-            if (!response.ok) throw new Error(`Fetch failed: ${response.status} ${response.statusText}`);
-            const json = await response.json();
-            return new DataFrame(json);
-        }
-
-        // CSV/TSV — fetch with headers, then parse
-        if (Object.keys(headers).length > 0) {
-            const response = await fetch(url, { headers });
-            if (!response.ok) throw new Error(`Fetch failed: ${response.status} ${response.statusText}`);
-            const text = await response.text();
-            return this._driver.parseCSV(text, {
-                autoDetectDelimiter: !options.delimiter,
-                delimiter: options.delimiter,
-                hasHeader: options.hasHeader ?? true,
-                headerRow: options.headerRow
-            });
-        }
-
-        return this._driver.fetch(url, {
-            autoDetectDelimiter: !options.delimiter,
-            delimiter: options.delimiter,
-            hasHeader: options.hasHeader ?? true,
-            headerRow: options.headerRow
-        });
-    }
-
-    private async _loadFromFile(file: File, options: FetchOptions): Promise<DataFrame> {
-        const isExcel = /\.(xlsx?|xls)$/i.test(file.name);
-
-        if (isExcel) {
-            const sheets = await this._driver.streamFileMultiSheet(file, {
-                headerRow: options.headerRow
-            });
-            const sheetNames = Object.keys(sheets);
-            if (sheetNames.length === 0) throw new Error('No data found in file');
-            return sheets[sheetNames[0]];
-        }
-
-        const text = await file.text();
-        return this._driver.parseCSV(text, {
-            autoDetectDelimiter: !options.delimiter,
-            delimiter: options.delimiter,
-            hasHeader: options.hasHeader ?? true,
-            headerRow: options.headerRow
-        });
-    }
-
-    private _detectMimeType(url: string): 'csv' | 'tsv' | 'json' | 'auto' {
-        const lower = url.toLowerCase().split('?')[0];
-        if (lower.endsWith('.json')) return 'json';
-        if (lower.endsWith('.tsv')) return 'tsv';
-        if (lower.endsWith('.csv')) return 'csv';
-        return 'auto';
-    }
-}
-
-/**
- * Factory function — primary entry point via jux.gather()
- *
- * Smart single-arg:
- *   jux.gather('raw/myfile.xlsx')                              // storage key
- *   jux.gather('https://api.com/data', { bearer: 'xxx' })     // URL with auth
- *   jux.gather(myUpload)                                       // FileUpload
- *   jux.gather([{a:1}, {b:2}])                                 // inline rows
- *   jux.gather(existingDf)                                     // clone DataFrame
- *
- * Explicit source:
- *   jux.gather().fromStorage(key)
- *   jux.gather().fromUrl(url, opts)
- */
-export function gather(source?: any, options?: GatherOptions): DataPipeline {
-    const pipe = new DataPipeline(
-        options?.dbName || options?.storeName
-            ? { dbName: options.dbName, storeName: options.storeName }
-            : {}
-    );
-    if (source !== undefined) {
-        pipe.from(source, options ?? {});
-    }
-    return pipe;
-}

package/lib/globals.d.ts

@@ -1,21 +0,0 @@
-/**
- * Global types for JUX projects
- * This file provides IntelliSense in all .jux files
- */
-
-import type { JuxAPI } from '../index.js';
-import type { code } from './components/code.js';
-
-declare global {
-  /**
-   * The main JUX API - available in all .jux files
-   */
-  const jux: JuxAPI;
-
-  /**
-   * Code component factory - available globally
-   */
-  const code: typeof code;
-}
-
-export { };

package/lib/reactivity/state.d.ts

@@ -1,36 +0,0 @@
-/**
- * Simple reactive state container
- */
-export declare class State<T> {
-    private _value;
-    private _subscribers;
-    constructor(initialValue: T);
-    /**
-     * Get current value
-     */
-    get value(): T;
-    /**
-     * Set new value and notify subscribers
-     */
-    set(newValue: T): void;
-    /**
-     * Subscribe to value changes
-     */
-    subscribe(callback: (value: T) => void): () => void;
-    /**
-     * Notify all subscribers
-     */
-    private _notify;
-    /**
-     * Helper methods for numeric state
-     */
-    increment(): void;
-    decrement(): void;
-    add(amount: number): void;
-    subtract(amount: number): void;
-}
-/**
- * Factory function to create reactive state
- */
-export declare function state<T>(initialValue: T): State<T>;
-//# sourceMappingURL=state.d.ts.map

package/lib/reactivity/state.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["state.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,KAAK,CAAC,CAAC;IAChB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,YAAY,CAAsC;gBAE9C,YAAY,EAAE,CAAC;IAI3B;;OAEG;IACH,IAAI,KAAK,IAAI,CAAC,CAEb;IAED;;OAEG;IACH,GAAG,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI;IAKtB;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI;IAQnD;;OAEG;IACH,OAAO,CAAC,OAAO;IAIf;;OAEG;IACH,SAAS,IAAI,IAAI;IAMjB,SAAS,IAAI,IAAI;IAMjB,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAMzB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;CAKjC;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAElD"}

package/lib/reactivity/state.js

@@ -1,67 +0,0 @@
-/**
- * Simple reactive state container
- */
-export class State {
-    constructor(initialValue) {
-        this._subscribers = new Set();
-        this._value = initialValue;
-    }
-    /**
-     * Get current value
-     */
-    get value() {
-        return this._value;
-    }
-    /**
-     * Set new value and notify subscribers
-     */
-    set(newValue) {
-        this._value = newValue;
-        this._notify();
-    }
-    /**
-     * Subscribe to value changes
-     */
-    subscribe(callback) {
-        this._subscribers.add(callback);
-        // Call immediately with current value
-        callback(this._value);
-        // Return unsubscribe function
-        return () => this._subscribers.delete(callback);
-    }
-    /**
-     * Notify all subscribers
-     */
-    _notify() {
-        this._subscribers.forEach(callback => callback(this._value));
-    }
-    /**
-     * Helper methods for numeric state
-     */
-    increment() {
-        if (typeof this._value === 'number') {
-            this.set((this._value + 1));
-        }
-    }
-    decrement() {
-        if (typeof this._value === 'number') {
-            this.set((this._value - 1));
-        }
-    }
-    add(amount) {
-        if (typeof this._value === 'number') {
-            this.set((this._value + amount));
-        }
-    }
-    subtract(amount) {
-        if (typeof this._value === 'number') {
-            this.set((this._value - amount));
-        }
-    }
-}
-/**
- * Factory function to create reactive state
- */
-export function state(initialValue) {
-    return new State(initialValue);
-}

package/lib/reactivity/state.ts

@@ -1,78 +0,0 @@
-/**
- * Simple reactive state container
- */
-export class State<T> {
-    private _value: T;
-    private _subscribers: Set<(value: T) => void> = new Set();
-
-    constructor(initialValue: T) {
-        this._value = initialValue;
-    }
-
-    /**
-     * Get current value
-     */
-    get value(): T {
-        return this._value;
-    }
-
-    /**
-     * Set new value and notify subscribers
-     */
-    set(newValue: T): void {
-        this._value = newValue;
-        this._notify();
-    }
-
-    /**
-     * Subscribe to value changes
-     */
-    subscribe(callback: (value: T) => void): () => void {
-        this._subscribers.add(callback);
-        // Call immediately with current value
-        callback(this._value);
-        // Return unsubscribe function
-        return () => this._subscribers.delete(callback);
-    }
-
-    /**
-     * Notify all subscribers
-     */
-    private _notify(): void {
-        this._subscribers.forEach(callback => callback(this._value));
-    }
-
-    /**
-     * Helper methods for numeric state
-     */
-    increment(): void {
-        if (typeof this._value === 'number') {
-            this.set((this._value + 1) as T);
-        }
-    }
-
-    decrement(): void {
-        if (typeof this._value === 'number') {
-            this.set((this._value - 1) as T);
-        }
-    }
-
-    add(amount: number): void {
-        if (typeof this._value === 'number') {
-            this.set((this._value + amount) as T);
-        }
-    }
-
-    subtract(amount: number): void {
-        if (typeof this._value === 'number') {
-            this.set((this._value - amount) as T);
-        }
-    }
-}
-
-/**
- * Factory function to create reactive state
- */
-export function state<T>(initialValue: T): State<T> {
-    return new State(initialValue);
-}