@gradio/dataframe 0.22.0 → 0.23.1

package/dist/shared/utils/filter_utils.js

@@ -1,123 +0,0 @@
-import { filter_table_data } from "./table_utils";
-export function filter_data(data, filter_columns) {
-    if (!data || !data.length || !data[0]) {
-        return [];
-    }
-    let row_indices = [...Array(data.length)].map((_, i) => i);
-    if (filter_columns.length > 0) {
-        filter_columns.forEach((column) => {
-            if (column.datatype === "string") {
-                switch (column.filter) {
-                    case "Contains":
-                        row_indices = row_indices.filter((i) => data[i][column.col]?.value.toString().includes(column.value));
-                        break;
-                    case "Does not contain":
-                        row_indices = row_indices.filter((i) => !data[i][column.col]?.value.toString().includes(column.value));
-                        break;
-                    case "Starts with":
-                        row_indices = row_indices.filter((i) => data[i][column.col]?.value.toString().startsWith(column.value));
-                        break;
-                    case "Ends with":
-                        row_indices = row_indices.filter((i) => data[i][column.col]?.value.toString().endsWith(column.value));
-                        break;
-                    case "Is":
-                        row_indices = row_indices.filter((i) => data[i][column.col]?.value.toString() === column.value);
-                        break;
-                    case "Is not":
-                        row_indices = row_indices.filter((i) => !(data[i][column.col]?.value.toString() === column.value));
-                        break;
-                    case "Is empty":
-                        row_indices = row_indices.filter((i) => data[i][column.col]?.value.toString() === "");
-                        break;
-                    case "Is not empty":
-                        row_indices = row_indices.filter((i) => !(data[i][column.col]?.value.toString() === ""));
-                        break;
-                }
-            }
-            else if (column.datatype === "number") {
-                switch (column.filter) {
-                    case "=":
-                        row_indices = row_indices.filter((i) => {
-                            if (!isNaN(Number(data[i][column.col]?.value)) &&
-                                !isNaN(Number(column.value))) {
-                                return (Number(data[i][column.col]?.value) === Number(column.value));
-                            }
-                            return false;
-                        });
-                        break;
-                    case "≠":
-                        row_indices = row_indices.filter((i) => {
-                            if (!isNaN(Number(data[i][column.col]?.value)) &&
-                                !isNaN(Number(column.value))) {
-                                return !(Number(data[i][column.col]?.value) === Number(column.value));
-                            }
-                            return false;
-                        });
-                        break;
-                    case ">":
-                        row_indices = row_indices.filter((i) => {
-                            if (!isNaN(Number(data[i][column.col]?.value)) &&
-                                !isNaN(Number(column.value))) {
-                                return (Number(data[i][column.col]?.value) > Number(column.value));
-                            }
-                            return false;
-                        });
-                        break;
-                    case "<":
-                        row_indices = row_indices.filter((i) => {
-                            if (!isNaN(Number(data[i][column.col]?.value)) &&
-                                !isNaN(Number(column.value))) {
-                                return (Number(data[i][column.col]?.value) < Number(column.value));
-                            }
-                            return false;
-                        });
-                        break;
-                    case "≥":
-                        row_indices = row_indices.filter((i) => {
-                            if (!isNaN(Number(data[i][column.col]?.value)) &&
-                                !isNaN(Number(column.value))) {
-                                return (Number(data[i][column.col]?.value) >= Number(column.value));
-                            }
-                            return false;
-                        });
-                        break;
-                    case "≤":
-                        row_indices = row_indices.filter((i) => {
-                            if (!isNaN(Number(data[i][column.col]?.value)) &&
-                                !isNaN(Number(column.value))) {
-                                return (Number(data[i][column.col]?.value) <= Number(column.value));
-                            }
-                            return false;
-                        });
-                        break;
-                    case "Is empty":
-                        row_indices = row_indices.filter((i) => data[i][column.col]?.value.toString() === "");
-                        break;
-                    case "Is not empty":
-                        row_indices = row_indices.filter((i) => {
-                            if (!isNaN(Number(data[i][column.col]?.value))) {
-                                return !(data[i][column.col]?.value.toString() === "");
-                            }
-                            return false;
-                        });
-                        break;
-                }
-            }
-        });
-        return row_indices;
-    }
-    return [...Array(data.length)].map((_, i) => i);
-}
-export function filter_data_and_preserve_selection(data, display_value, styling, filter_columns, selected, get_current_indices, original_data, original_display_value, original_styling) {
-    let id = null;
-    if (selected && selected[0] in data && selected[1] in data[selected[0]]) {
-        id = data[selected[0]][selected[1]].id;
-    }
-    filter_table_data(data, display_value, styling, filter_columns, original_data, original_display_value, original_styling);
-    let new_selected = selected;
-    if (id) {
-        const [i, j] = get_current_indices(id, data);
-        new_selected = [i, j];
-    }
-    return { data, selected: new_selected };
-}

package/dist/shared/utils/keyboard_utils.d.ts

@@ -1,3 +0,0 @@
-import type { DataFrameContext } from "../context/dataframe_context";
-export declare function handle_cell_blur(event: FocusEvent, ctx: DataFrameContext, coords: [number, number]): Promise<void>;
-export declare function handle_keydown(event: KeyboardEvent, context: DataFrameContext): Promise<void>;

package/dist/shared/utils/keyboard_utils.js

@@ -1,236 +0,0 @@
-import { dequal } from "dequal/lite";
-import { handle_delete_key } from "../utils/selection_utils";
-import { tick } from "svelte";
-import { get } from "svelte/store";
-import { copy_table_data } from "./table_utils";
-async function save_cell_value(input_value, ctx, row, col) {
-    if (!ctx.data || !ctx.data[row] || !ctx.data[row][col])
-        return;
-    const old_value = ctx.data[row][col].value;
-    ctx.data[row][col].value = input_value;
-    if (ctx.data[row][col].display_value !== undefined) {
-        ctx.data[row][col].display_value = input_value;
-    }
-    if (old_value !== input_value && ctx.dispatch) {
-        ctx.dispatch("change", {
-            data: ctx.data.map((row) => row.map((cell) => cell.value)),
-            headers: ctx.headers?.map((h) => h.value) || [],
-            metadata: null
-        });
-    }
-    ctx.actions.set_selected([row, col]);
-}
-export async function handle_cell_blur(event, ctx, coords) {
-    if (!ctx.data || !ctx.headers || !ctx.els)
-        return;
-    const input_el = event.target;
-    if (!input_el || input_el.value === undefined)
-        return;
-    await save_cell_value(input_el.value, ctx, coords[0], coords[1]);
-}
-function handle_header_navigation(event, ctx) {
-    const state = get(ctx.state);
-    const selected_header = state.ui_state.selected_header;
-    const header_edit = state.ui_state.header_edit;
-    const headers = ctx.headers || [];
-    if (selected_header === false || header_edit !== false)
-        return false;
-    switch (event.key) {
-        case "ArrowDown":
-            ctx.actions.set_selected_header(false);
-            ctx.actions.set_selected([0, selected_header]);
-            ctx.actions.set_selected_cells([[0, selected_header]]);
-            return true;
-        case "ArrowLeft":
-            ctx.actions.set_selected_header(selected_header > 0 ? selected_header - 1 : selected_header);
-            return true;
-        case "ArrowRight":
-            ctx.actions.set_selected_header(selected_header < headers.length - 1
-                ? selected_header + 1
-                : selected_header);
-            return true;
-        case "Escape":
-            event.preventDefault();
-            ctx.actions.set_selected_header(false);
-            return true;
-        case "Enter":
-            event.preventDefault();
-            if (state.config.editable) {
-                ctx.actions.set_header_edit(selected_header);
-            }
-            return true;
-    }
-    return false;
-}
-// eslint-disable-next-line complexity
-function handle_delete_operation(event, ctx) {
-    if (!ctx.data || !ctx.headers || !ctx.els || !ctx.dispatch)
-        return false;
-    const state = get(ctx.state);
-    if (!state.config.editable)
-        return false;
-    if (event.key !== "Delete" && event.key !== "Backspace")
-        return false;
-    const editing = state.ui_state.editing;
-    const selected_cells = state.ui_state.selected_cells;
-    const static_columns = state.config.static_columns || [];
-    if (selected_cells.some(([_, col]) => static_columns.includes(col))) {
-        return false;
-    }
-    if (editing) {
-        const [row, col] = editing;
-        const input_el = ctx.els[ctx.data[row][col].id]?.input;
-        if (input_el && input_el.selectionStart !== input_el.selectionEnd) {
-            return false;
-        }
-        if (event.key === "Delete" &&
-            input_el?.selectionStart !== input_el?.value.length) {
-            return false;
-        }
-        if (event.key === "Backspace" && input_el?.selectionStart !== 0) {
-            return false;
-        }
-    }
-    event.preventDefault();
-    if (selected_cells.length > 0) {
-        const new_data = handle_delete_key(ctx.data, selected_cells);
-        ctx.dispatch("change", {
-            data: new_data.map((row) => row.map((cell) => cell.value)),
-            headers: ctx.headers.map((h) => h.value),
-            metadata: null
-        });
-    }
-    return true;
-}
-function handle_arrow_keys(event, ctx, i, j) {
-    const state = get(ctx.state);
-    const editing = state.ui_state.editing;
-    const selected_cells = state.ui_state.selected_cells;
-    if (editing)
-        return false;
-    if (!ctx.data)
-        return false;
-    event.preventDefault();
-    const next_coords = ctx.actions.move_cursor(event, [i, j], ctx.data);
-    if (next_coords) {
-        if (event.shiftKey) {
-            ctx.actions.set_selected_cells(ctx.actions.get_range_selection(selected_cells.length > 0 ? selected_cells[0] : [i, j], next_coords));
-            ctx.actions.set_editing(false);
-        }
-        else {
-            ctx.actions.set_selected_cells([next_coords]);
-            ctx.actions.set_editing(false);
-        }
-        ctx.actions.set_selected(next_coords);
-    }
-    else if (next_coords === false && event.key === "ArrowUp" && i === 0) {
-        ctx.actions.set_selected_header(j);
-        ctx.actions.set_selected(false);
-        ctx.actions.set_selected_cells([]);
-        ctx.actions.set_editing(false);
-    }
-    return true;
-}
-async function handle_enter_key(event, ctx, i, j) {
-    if (!ctx.data || !ctx.els)
-        return false;
-    const state = get(ctx.state);
-    if (!state.config.editable)
-        return false;
-    const editing = state.ui_state.editing;
-    if (editing && event.shiftKey)
-        return false;
-    event.preventDefault();
-    if (editing && dequal(editing, [i, j])) {
-        const cell_id = ctx.data[i][j].id;
-        const input_el = ctx.els[cell_id]?.input;
-        if (input_el) {
-            await save_cell_value(input_el.value, ctx, i, j);
-        }
-        ctx.actions.set_editing(false);
-        await tick();
-        ctx.parent_element?.focus();
-    }
-    else {
-        ctx.actions.set_editing([i, j]);
-    }
-    return true;
-}
-function handle_tab_key(event, ctx, i, j) {
-    if (!ctx.data)
-        return false;
-    event.preventDefault();
-    ctx.actions.set_editing(false);
-    const next_cell = ctx.actions.get_next_cell_coordinates([i, j], ctx.data, event.shiftKey);
-    if (next_cell) {
-        ctx.actions.set_selected_cells([next_cell]);
-        ctx.actions.set_selected(next_cell);
-        if (get(ctx.state).config.editable) {
-            ctx.actions.set_editing(next_cell);
-        }
-    }
-    return true;
-}
-function handle_default_key(event, ctx, i, j) {
-    const state = get(ctx.state);
-    if (!state.config.editable)
-        return false;
-    const editing = state.ui_state.editing;
-    if (event.key.length === 1 && (!editing || !dequal(editing, [i, j]))) {
-        ctx.actions.set_editing([i, j]);
-        return true;
-    }
-    return false;
-}
-async function handle_cell_navigation(event, ctx) {
-    if (!ctx.data)
-        return false;
-    const state = get(ctx.state);
-    const selected = state.ui_state.selected;
-    const selected_cells = state.ui_state.selected_cells;
-    if (!selected)
-        return false;
-    if (event.key === "c" && (event.metaKey || event.ctrlKey)) {
-        event.preventDefault();
-        if (selected_cells.length > 0) {
-            await copy_table_data(ctx.data, selected_cells);
-        }
-        ctx.actions.set_copy_flash(true);
-        return true;
-    }
-    const [i, j] = selected;
-    switch (event.key) {
-        case "ArrowRight":
-        case "ArrowLeft":
-        case "ArrowDown":
-        case "ArrowUp":
-            return handle_arrow_keys(event, ctx, i, j);
-        case "Escape":
-            if (!state.config.editable)
-                return false;
-            event.preventDefault();
-            ctx.actions.set_editing(false);
-            tick().then(() => {
-                if (ctx.parent_element) {
-                    ctx.parent_element.focus();
-                }
-            });
-            return true;
-        case "Enter":
-            return await handle_enter_key(event, ctx, i, j);
-        case "Tab":
-            return handle_tab_key(event, ctx, i, j);
-        case "Delete":
-        case "Backspace":
-            return handle_delete_operation(event, ctx);
-        default:
-            return handle_default_key(event, ctx, i, j);
-    }
-}
-export async function handle_keydown(event, context) {
-    if (handle_header_navigation(event, context))
-        return;
-    if (handle_delete_operation(event, context))
-        return;
-    await handle_cell_navigation(event, context);
-}

package/dist/shared/utils/menu_utils.d.ts

@@ -1,42 +0,0 @@
-export declare function toggle_header_menu(event: MouseEvent, col: number, active_header_menu: {
-    col: number;
-    x: number;
-    y: number;
-} | null, set_active_header_menu: (menu: {
-    col: number;
-    x: number;
-    y: number;
-} | null) => void): void;
-export declare function toggle_cell_menu(event: MouseEvent, row: number, col: number, active_cell_menu: {
-    row: number;
-    col: number;
-    x: number;
-    y: number;
-} | null, set_active_cell_menu: (menu: {
-    row: number;
-    col: number;
-    x: number;
-    y: number;
-} | null) => void): void;
-export declare function add_row_at(index: number, position: "above" | "below", add_row: (index?: number) => void, clear_menus: () => void): void;
-export declare function add_col_at(index: number, position: "left" | "right", add_col: (index?: number) => void, clear_menus: () => void): void;
-export declare function delete_row_at(index: number, delete_row: (index: number) => void, clear_menus: () => void): void;
-export declare function delete_col_at(index: number, delete_col: (index: number) => void, clear_menus: () => void): void;
-export declare function toggle_header_button(col: number, active_button: {
-    type: "header" | "cell";
-    row?: number;
-    col: number;
-} | null, set_active_button: (button: {
-    type: "header" | "cell";
-    row?: number;
-    col: number;
-} | null) => void): void;
-export declare function toggle_cell_button(row: number, col: number, active_button: {
-    type: "header" | "cell";
-    row?: number;
-    col: number;
-} | null, set_active_button: (button: {
-    type: "header" | "cell";
-    row?: number;
-    col: number;
-} | null) => void): void;

package/dist/shared/utils/menu_utils.js

@@ -1,58 +0,0 @@
-export function toggle_header_menu(event, col, active_header_menu, set_active_header_menu) {
-    event.stopPropagation();
-    if (active_header_menu && active_header_menu.col === col) {
-        set_active_header_menu(null);
-    }
-    else {
-        const header = event.target.closest("th");
-        if (header) {
-            const rect = header.getBoundingClientRect();
-            set_active_header_menu({ col, x: rect.right, y: rect.bottom });
-        }
-    }
-}
-export function toggle_cell_menu(event, row, col, active_cell_menu, set_active_cell_menu) {
-    event.stopPropagation();
-    if (active_cell_menu &&
-        active_cell_menu.row === row &&
-        active_cell_menu.col === col) {
-        set_active_cell_menu(null);
-    }
-    else {
-        const cell = event.target.closest("td");
-        if (cell) {
-            const rect = cell.getBoundingClientRect();
-            set_active_cell_menu({ row, col, x: rect.right, y: rect.bottom });
-        }
-    }
-}
-export function add_row_at(index, position, add_row, clear_menus) {
-    const row_index = position === "above" ? index : index + 1;
-    add_row(row_index);
-    clear_menus();
-}
-export function add_col_at(index, position, add_col, clear_menus) {
-    const col_index = position === "left" ? index : index + 1;
-    add_col(col_index);
-    clear_menus();
-}
-export function delete_row_at(index, delete_row, clear_menus) {
-    delete_row(index);
-    clear_menus();
-}
-export function delete_col_at(index, delete_col, clear_menus) {
-    delete_col(index);
-    clear_menus();
-}
-export function toggle_header_button(col, active_button, set_active_button) {
-    set_active_button(active_button?.type === "header" && active_button.col === col
-        ? null
-        : { type: "header", col });
-}
-export function toggle_cell_button(row, col, active_button, set_active_button) {
-    set_active_button(active_button?.type === "cell" &&
-        active_button.row === row &&
-        active_button.col === col
-        ? null
-        : { type: "cell", row, col });
-}

package/dist/shared/utils/sort_utils.d.ts

@@ -1,26 +0,0 @@
-import type { Headers, CellValue } from "../types";
-export type SortDirection = "asc" | "desc";
-export declare function get_sort_status(name: string, sort_columns: {
-    col: number;
-    direction: SortDirection;
-}[], headers: Headers): "none" | "asc" | "desc";
-export declare function sort_data(data: {
-    id: string;
-    value: CellValue;
-}[][], sort_columns: {
-    col: number;
-    direction: SortDirection;
-}[]): number[];
-export declare function sort_data_and_preserve_selection(data: {
-    id: string;
-    value: CellValue;
-}[][], display_value: string[][] | null, styling: string[][] | null, sort_columns: {
-    col: number;
-    direction: SortDirection;
-}[], selected: [number, number] | false, get_current_indices: (id: string, data: {
-    id: string;
-    value: CellValue;
-}[][]) => [number, number]): {
-    data: typeof data;
-    selected: [number, number] | false;
-};

package/dist/shared/utils/sort_utils.js

@@ -1,59 +0,0 @@
-import { sort_table_data } from "./table_utils";
-export function get_sort_status(name, sort_columns, headers) {
-    if (!sort_columns.length)
-        return "none";
-    const sort_item = sort_columns.find((item) => {
-        const col = item.col;
-        if (col < 0 || col >= headers.length)
-            return false;
-        return headers[col] === name;
-    });
-    if (!sort_item)
-        return "none";
-    return sort_item.direction;
-}
-export function sort_data(data, sort_columns) {
-    if (!data || !data.length || !data[0]) {
-        return [];
-    }
-    if (sort_columns.length > 0) {
-        const row_indices = [...Array(data.length)].map((_, i) => i);
-        row_indices.sort((row_a_idx, row_b_idx) => {
-            const row_a = data[row_a_idx];
-            const row_b = data[row_b_idx];
-            for (const { col: sort_by, direction } of sort_columns) {
-                if (!row_a ||
-                    !row_b ||
-                    sort_by < 0 ||
-                    sort_by >= row_a.length ||
-                    sort_by >= row_b.length ||
-                    !row_a[sort_by] ||
-                    !row_b[sort_by]) {
-                    continue;
-                }
-                const val_a = row_a[sort_by].value;
-                const val_b = row_b[sort_by].value;
-                const comparison = val_a < val_b ? -1 : val_a > val_b ? 1 : 0;
-                if (comparison !== 0) {
-                    return direction === "asc" ? comparison : -comparison;
-                }
-            }
-            return 0;
-        });
-        return row_indices;
-    }
-    return [...Array(data.length)].map((_, i) => i);
-}
-export function sort_data_and_preserve_selection(data, display_value, styling, sort_columns, selected, get_current_indices) {
-    let id = null;
-    if (selected && selected[0] in data && selected[1] in data[selected[0]]) {
-        id = data[selected[0]][selected[1]].id;
-    }
-    sort_table_data(data, display_value, styling, sort_columns);
-    let new_selected = selected;
-    if (id) {
-        const [i, j] = get_current_indices(id, data);
-        new_selected = [i, j];
-    }
-    return { data, selected: new_selected };
-}