@gradio/dataframe 0.22.0 → 0.23.0

package/dist/shared/context/dataframe_context.js

@@ -1,412 +0,0 @@
-import { getContext, setContext } from "svelte";
-import { dequal } from "dequal";
-import { writable, get } from "svelte/store";
-import { sort_table_data } from "../utils/table_utils";
-import { tick } from "svelte";
-import { handle_selection, get_next_cell_coordinates, get_range_selection, move_cursor } from "../utils/selection_utils";
-export const DATAFRAME_KEY = Symbol("dataframe");
-function create_actions(state, context) {
-    const update_state = (updater) => state.update((s) => ({ ...s, ...updater(s) }));
-    const add_row = (data, make_id, index) => {
-        const new_row = data[0]?.length
-            ? Array(data[0].length)
-                .fill(null)
-                .map(() => ({ value: "", id: make_id() }))
-            : [{ value: "", id: make_id() }];
-        const new_data = [...data];
-        index !== undefined
-            ? new_data.splice(index, 0, new_row)
-            : new_data.push(new_row);
-        return new_data;
-    };
-    const add_col = (data, headers, make_id, index) => {
-        const new_headers = [...headers, `Header ${headers.length + 1}`];
-        const new_data = data.map((row) => [...row, { value: "", id: make_id() }]);
-        if (index !== undefined) {
-            new_headers.splice(index, 0, new_headers.pop());
-            new_data.forEach((row) => row.splice(index, 0, row.pop()));
-        }
-        return { data: new_data, headers: new_headers };
-    };
-    const update_array = (source, target) => {
-        if (source && target) {
-            target.splice(0, target.length, ...JSON.parse(JSON.stringify(source)));
-        }
-    };
-    return {
-        handle_search: (query) => update_state((s) => ({ current_search_query: query })),
-        handle_sort: (col, direction) => update_state((s) => {
-            const sort_cols = s.sort_state.sort_columns.filter((c) => c.col !== col);
-            if (!s.sort_state.sort_columns.some((c) => c.col === col && c.direction === direction)) {
-                sort_cols.push({ col, direction });
-            }
-            const initial_data = s.sort_state.initial_data ||
-                (context.data && sort_cols.length > 0
-                    ? {
-                        data: JSON.parse(JSON.stringify(context.data)),
-                        display_value: context.display_value
-                            ? JSON.parse(JSON.stringify(context.display_value))
-                            : null,
-                        styling: context.styling
-                            ? JSON.parse(JSON.stringify(context.styling))
-                            : null
-                    }
-                    : null);
-            return {
-                sort_state: {
-                    ...s.sort_state,
-                    sort_columns: sort_cols.slice(-3),
-                    initial_data: initial_data
-                }
-            };
-        }),
-        handle_filter: (col, datatype, filter, value) => update_state((s) => {
-            const filter_cols = s.filter_state.filter_columns.some((c) => c.col === col)
-                ? s.filter_state.filter_columns.filter((c) => c.col !== col)
-                : [
-                    ...s.filter_state.filter_columns,
-                    { col, datatype, filter, value }
-                ];
-            const initial_data = s.filter_state.initial_data ||
-                (context.data && filter_cols.length > 0
-                    ? {
-                        data: JSON.parse(JSON.stringify(context.data)),
-                        display_value: context.display_value
-                            ? JSON.parse(JSON.stringify(context.display_value))
-                            : null,
-                        styling: context.styling
-                            ? JSON.parse(JSON.stringify(context.styling))
-                            : null
-                    }
-                    : null);
-            return {
-                filter_state: {
-                    ...s.filter_state,
-                    filter_columns: filter_cols,
-                    initial_data: initial_data
-                }
-            };
-        }),
-        get_sort_status: (name, headers) => {
-            const s = get(state);
-            const sort_item = s.sort_state.sort_columns.find((item) => headers[item.col] === name);
-            return sort_item ? sort_item.direction : "none";
-        },
-        sort_data: (data, display_value, styling) => {
-            const { sort_state: { sort_columns } } = get(state);
-            if (sort_columns.length)
-                sort_table_data(data, display_value, styling, sort_columns);
-        },
-        update_row_order: (data) => update_state((s) => ({
-            sort_state: {
-                ...s.sort_state,
-                row_order: s.sort_state.sort_columns.length && data[0]
-                    ? [...Array(data.length)]
-                        .map((_, i) => i)
-                        .sort((a, b) => {
-                        for (const { col, direction } of s.sort_state
-                            .sort_columns) {
-                            const comp = (data[a]?.[col]?.value ?? "") <
-                                (data[b]?.[col]?.value ?? "")
-                                ? -1
-                                : 1;
-                            if (comp)
-                                return direction === "asc" ? comp : -comp;
-                        }
-                        return 0;
-                    })
-                    : [...Array(data.length)].map((_, i) => i)
-            }
-        })),
-        filter_data: (data) => {
-            const query = get(state).current_search_query?.toLowerCase();
-            return query
-                ? data.filter((row) => row.some((cell) => String(cell?.value).toLowerCase().includes(query)))
-                : data;
-        },
-        add_row,
-        add_col,
-        add_row_at: (data, index, position, make_id) => add_row(data, make_id, position === "above" ? index : index + 1),
-        add_col_at: (data, headers, index, position, make_id) => add_col(data, headers, make_id, position === "left" ? index : index + 1),
-        delete_row: (data, index) => data.length > 1 ? data.filter((_, i) => i !== index) : data,
-        delete_col: (data, headers, index) => headers.length > 1
-            ? {
-                data: data.map((row) => row.filter((_, i) => i !== index)),
-                headers: headers.filter((_, i) => i !== index)
-            }
-            : { data, headers },
-        delete_row_at: (data, index) => data.length > 1
-            ? [...data.slice(0, index), ...data.slice(index + 1)]
-            : data,
-        delete_col_at: (data, headers, index) => headers.length > 1
-            ? {
-                data: data.map((row) => [
-                    ...row.slice(0, index),
-                    ...row.slice(index + 1)
-                ]),
-                headers: [...headers.slice(0, index), ...headers.slice(index + 1)]
-            }
-            : { data, headers },
-        trigger_change: async (data, headers, previous_data, previous_headers, value_is_output, dispatch) => {
-            const s = get(state);
-            if (s.current_search_query)
-                return;
-            const current_headers = headers.map((h) => h.value);
-            const current_data = data.map((row) => row.map((cell) => cell.value));
-            if (!dequal(current_data, previous_data) ||
-                !dequal(current_headers, previous_headers)) {
-                if (!dequal(current_headers, previous_headers)) {
-                    update_state((s) => ({
-                        sort_state: { sort_columns: [], row_order: [], initial_data: null },
-                        filter_state: { filter_columns: [], initial_data: null }
-                    }));
-                }
-                dispatch("change", {
-                    data: data.map((row) => row.map((cell) => cell.value)),
-                    headers: current_headers,
-                    metadata: null
-                });
-                const index = s.ui_state.selected;
-                if (index) {
-                    dispatch("edit", {
-                        index,
-                        value: data[index[0]][index[1]].value,
-                        previous_value: previous_data[index[0]][index[1]]
-                    });
-                }
-                if (!value_is_output)
-                    dispatch("input");
-            }
-        },
-        reset_sort_state: () => update_state((s) => {
-            if (s.sort_state.initial_data && context.data) {
-                const original = s.sort_state.initial_data;
-                update_array(original.data, context.data);
-                update_array(original.display_value, context.display_value);
-                update_array(original.styling, context.styling);
-            }
-            return {
-                sort_state: { sort_columns: [], row_order: [], initial_data: null }
-            };
-        }),
-        reset_filter_state: () => update_state((s) => {
-            if (s.filter_state.initial_data && context.data) {
-                const original = s.filter_state.initial_data;
-                update_array(original.data, context.data);
-                update_array(original.display_value, context.display_value);
-                update_array(original.styling, context.styling);
-            }
-            return {
-                filter_state: { filter_columns: [], initial_data: null }
-            };
-        }),
-        set_active_cell_menu: (menu) => update_state((s) => ({
-            ui_state: { ...s.ui_state, active_cell_menu: menu }
-        })),
-        set_active_header_menu: (menu) => update_state((s) => ({
-            ui_state: { ...s.ui_state, active_header_menu: menu }
-        })),
-        set_selected_cells: (cells) => update_state((s) => ({
-            ui_state: { ...s.ui_state, selected_cells: cells }
-        })),
-        set_selected: (selected) => update_state((s) => ({ ui_state: { ...s.ui_state, selected } })),
-        set_editing: (editing) => update_state((s) => ({ ui_state: { ...s.ui_state, editing } })),
-        clear_ui_state: () => update_state((s) => ({
-            ui_state: {
-                active_cell_menu: null,
-                active_header_menu: null,
-                selected_cells: [],
-                selected: false,
-                editing: false,
-                header_edit: false,
-                selected_header: false,
-                active_button: null,
-                copy_flash: false
-            }
-        })),
-        set_header_edit: (header_index) => update_state((s) => ({
-            ui_state: {
-                ...s.ui_state,
-                selected_cells: [],
-                selected_header: header_index,
-                header_edit: header_index
-            }
-        })),
-        set_selected_header: (header_index) => update_state((s) => ({
-            ui_state: {
-                ...s.ui_state,
-                selected_header: header_index,
-                selected: false,
-                selected_cells: []
-            }
-        })),
-        handle_header_click: (col, editable) => update_state((s) => ({
-            ui_state: {
-                ...s.ui_state,
-                active_cell_menu: null,
-                active_header_menu: null,
-                selected: false,
-                selected_cells: [],
-                selected_header: col,
-                header_edit: editable ? col : false
-            }
-        })),
-        end_header_edit: (key) => {
-            if (["Escape", "Enter", "Tab"].includes(key)) {
-                update_state((s) => ({
-                    ui_state: { ...s.ui_state, selected: false, header_edit: false }
-                }));
-            }
-        },
-        get_selected_cells: () => get(state).ui_state.selected_cells,
-        get_active_cell_menu: () => get(state).ui_state.active_cell_menu,
-        get_active_button: () => get(state).ui_state.active_button,
-        set_active_button: (button) => update_state((s) => ({
-            ui_state: { ...s.ui_state, active_button: button }
-        })),
-        set_copy_flash: (value) => update_state((s) => ({ ui_state: { ...s.ui_state, copy_flash: value } })),
-        handle_cell_click: (event, row, col) => {
-            event.preventDefault();
-            event.stopPropagation();
-            const s = get(state);
-            if (s.config.show_row_numbers && col === -1)
-                return;
-            let actual_row = row;
-            if (s.current_search_query && context.data) {
-                const filtered_indices = [];
-                context.data.forEach((dataRow, idx) => {
-                    if (dataRow.some((cell) => String(cell?.value)
-                        .toLowerCase()
-                        .includes(s.current_search_query?.toLowerCase() || ""))) {
-                        filtered_indices.push(idx);
-                    }
-                });
-                actual_row = filtered_indices[row] ?? row;
-            }
-            const cells = handle_selection([actual_row, col], s.ui_state.selected_cells, event);
-            update_state((s) => ({
-                ui_state: {
-                    ...s.ui_state,
-                    active_cell_menu: null,
-                    active_header_menu: null,
-                    selected_header: false,
-                    header_edit: false,
-                    selected_cells: cells,
-                    selected: cells[0]
-                }
-            }));
-            if (s.config.editable && cells.length === 1) {
-                update_state((s) => ({
-                    ui_state: { ...s.ui_state, editing: [actual_row, col] }
-                }));
-                tick().then(() => context.els[context.data[actual_row][col].id]?.input?.focus());
-            }
-            else {
-                // ensure parent has focus for keyboard navigation
-                tick().then(() => {
-                    if (context.parent_element) {
-                        context.parent_element.focus();
-                    }
-                });
-            }
-            context.dispatch?.("select", {
-                index: [actual_row, col],
-                col_value: context.get_column(col),
-                row_value: context.get_row(actual_row),
-                value: context.get_data_at(actual_row, col)
-            });
-        },
-        toggle_cell_menu: (event, row, col) => {
-            event.stopPropagation();
-            const current_menu = get(state).ui_state.active_cell_menu;
-            if (current_menu?.row === row && current_menu.col === col) {
-                update_state((s) => ({
-                    ui_state: { ...s.ui_state, active_cell_menu: null }
-                }));
-            }
-            else {
-                const cell = event.target.closest("td");
-                if (cell) {
-                    const rect = cell.getBoundingClientRect();
-                    update_state((s) => ({
-                        ui_state: {
-                            ...s.ui_state,
-                            active_cell_menu: { row, col, x: rect.right, y: rect.bottom }
-                        }
-                    }));
-                }
-            }
-        },
-        toggle_cell_button: (row, col) => {
-            const current_button = get(state).ui_state.active_button;
-            const new_button = current_button?.type === "cell" &&
-                current_button.row === row &&
-                current_button.col === col
-                ? null
-                : { type: "cell", row, col };
-            update_state((s) => ({
-                ui_state: { ...s.ui_state, active_button: new_button }
-            }));
-        },
-        handle_select_column: (col) => {
-            if (!context.data)
-                return;
-            const cells = context.data.map((_, row) => [row, col]);
-            update_state((s) => ({
-                ui_state: {
-                    ...s.ui_state,
-                    selected_cells: cells,
-                    selected: cells[0],
-                    editing: false
-                }
-            }));
-            setTimeout(() => context.parent_element?.focus(), 0);
-        },
-        handle_select_row: (row) => {
-            if (!context.data || !context.data[0])
-                return;
-            const cells = context.data[0].map((_, col) => [row, col]);
-            update_state((s) => ({
-                ui_state: {
-                    ...s.ui_state,
-                    selected_cells: cells,
-                    selected: cells[0],
-                    editing: false
-                }
-            }));
-            setTimeout(() => context.parent_element?.focus(), 0);
-        },
-        get_next_cell_coordinates,
-        get_range_selection,
-        move_cursor
-    };
-}
-export function create_dataframe_context(config) {
-    const state = writable({
-        config,
-        current_search_query: null,
-        sort_state: { sort_columns: [], row_order: [], initial_data: null },
-        filter_state: { filter_columns: [], initial_data: null },
-        ui_state: {
-            active_cell_menu: null,
-            active_header_menu: null,
-            selected_cells: [],
-            selected: false,
-            editing: false,
-            header_edit: false,
-            selected_header: false,
-            active_button: null,
-            copy_flash: false
-        }
-    });
-    const context = { state, actions: null };
-    context.actions = create_actions(state, context);
-    const instance_id = Symbol(`dataframe_${Math.random().toString(36).substring(2)}`);
-    setContext(instance_id, context);
-    setContext(DATAFRAME_KEY, { instance_id, context });
-    return context;
-}
-export function get_dataframe_context() {
-    const ctx = getContext(DATAFRAME_KEY);
-    return ctx?.context ?? getContext(DATAFRAME_KEY);
-}

package/dist/shared/icons/SortArrowDown.svelte

@@ -1,25 +0,0 @@
-<script lang="ts">
-	export let size = 16;
-</script>
-
-<svg
-	width={size}
-	height={size}
-	viewBox="0 0 16 16"
-	fill="none"
-	xmlns="http://www.w3.org/2000/svg"
->
-	<path
-		d="M4 8L8 12L12 8"
-		stroke="currentColor"
-		stroke-width="1.5"
-		stroke-linecap="round"
-		stroke-linejoin="round"
-	/>
-	<path
-		d="M8 12V4"
-		stroke="currentColor"
-		stroke-width="1.5"
-		stroke-linecap="round"
-	/>
-</svg>

package/dist/shared/icons/SortArrowDown.svelte.d.ts

@@ -1,20 +0,0 @@
-interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
-        $$bindings?: Bindings;
-    } & Exports;
-    (internal: unknown, props: Props & {
-        $$events?: Events;
-        $$slots?: Slots;
-    }): Exports & {
-        $set?: any;
-        $on?: any;
-    };
-    z_$$bindings?: Bindings;
-}
-declare const SortArrowDown: $$__sveltets_2_IsomorphicComponent<{
-    size?: number;
-}, {
-    [evt: string]: CustomEvent<any>;
-}, {}, {}, string>;
-type SortArrowDown = InstanceType<typeof SortArrowDown>;
-export default SortArrowDown;

package/dist/shared/icons/SortArrowUp.svelte

@@ -1,25 +0,0 @@
-<script lang="ts">
-	export let size = 16;
-</script>
-
-<svg
-	width={size}
-	height={size}
-	viewBox="0 0 16 16"
-	fill="none"
-	xmlns="http://www.w3.org/2000/svg"
->
-	<path
-		d="M4 8L8 4L12 8"
-		stroke="currentColor"
-		stroke-width="1.5"
-		stroke-linecap="round"
-		stroke-linejoin="round"
-	/>
-	<path
-		d="M8 4V12"
-		stroke="currentColor"
-		stroke-width="1.5"
-		stroke-linecap="round"
-	/>
-</svg>

package/dist/shared/icons/SortArrowUp.svelte.d.ts

@@ -1,20 +0,0 @@
-interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
-        $$bindings?: Bindings;
-    } & Exports;
-    (internal: unknown, props: Props & {
-        $$events?: Events;
-        $$slots?: Slots;
-    }): Exports & {
-        $set?: any;
-        $on?: any;
-    };
-    z_$$bindings?: Bindings;
-}
-declare const SortArrowUp: $$__sveltets_2_IsomorphicComponent<{
-    size?: number;
-}, {
-    [evt: string]: CustomEvent<any>;
-}, {}, {}, string>;
-type SortArrowUp = InstanceType<typeof SortArrowUp>;
-export default SortArrowUp;

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

@@ -1,14 +0,0 @@
-import type { Datatype, Headers, HeadersWithIDs } from "./utils";
-import type { CellValue } from "../types";
-export declare function make_headers(_head: Headers, col_count: [number, "fixed" | "dynamic"], els: Record<string, {
-    cell: null | HTMLTableCellElement;
-    input: null | HTMLTextAreaElement;
-}>, make_id: () => string): HeadersWithIDs;
-export declare function process_data(values: CellValue[][], els: Record<string, {
-    cell: null | HTMLTableCellElement;
-    input: null | HTMLTextAreaElement;
-}>, data_binding: Record<string, any>, make_id: () => string, display_value: string[][] | null | undefined, datatype: Datatype | Datatype[]): {
-    id: string;
-    value: CellValue;
-    display_value?: string;
-}[][];

package/dist/shared/utils/data_processing.js

@@ -1,47 +0,0 @@
-import { cast_value_to_type } from "./utils";
-export function make_headers(_head, col_count, els, make_id) {
-    let _h = _head || [];
-    if (col_count[1] === "fixed" && _h.length < col_count[0]) {
-        const fill = Array(col_count[0] - _h.length)
-            .fill("")
-            .map((_, i) => `${i + _h.length}`);
-        _h = _h.concat(fill);
-    }
-    if (!_h || _h.length === 0) {
-        return Array(col_count[0])
-            .fill(0)
-            .map((_, i) => {
-            const _id = make_id();
-            els[_id] = { cell: null, input: null };
-            return { id: _id, value: JSON.stringify(i + 1) };
-        });
-    }
-    return _h.map((h, i) => {
-        const _id = make_id();
-        els[_id] = { cell: null, input: null };
-        return { id: _id, value: h ?? "" };
-    });
-}
-export function process_data(values, els, data_binding, make_id, display_value = null, datatype) {
-    if (!values || values.length === 0) {
-        return [];
-    }
-    const result = values.map((row, i) => {
-        return row.map((value, j) => {
-            const _id = make_id();
-            els[_id] = { cell: null, input: null };
-            data_binding[_id] = value;
-            let display = display_value?.[i]?.[j];
-            if (display === undefined) {
-                display = String(value);
-            }
-            const dtype = Array.isArray(datatype) ? datatype[j] : datatype;
-            return {
-                id: _id,
-                value: cast_value_to_type(value, dtype),
-                display_value: display
-            };
-        });
-    });
-    return result;
-}

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

@@ -1,15 +0,0 @@
-import type { CellCoordinate } from "../types";
-export type DragState = {
-    is_dragging: boolean;
-    drag_start: CellCoordinate | null;
-    mouse_down_pos: {
-        x: number;
-        y: number;
-    } | null;
-};
-export type DragHandlers = {
-    handle_mouse_down: (event: MouseEvent, row: number, col: number) => void;
-    handle_mouse_move: (event: MouseEvent) => void;
-    handle_mouse_up: (event: MouseEvent) => void;
-};
-export declare function create_drag_handlers(state: DragState, set_is_dragging: (value: boolean) => void, set_selected_cells: (cells: CellCoordinate[]) => void, set_selected: (cell: CellCoordinate | false) => void, handle_cell_click: (event: MouseEvent, row: number, col: number) => void, show_row_numbers: boolean, parent_element?: HTMLElement): DragHandlers;

package/dist/shared/utils/drag_utils.js

@@ -1,67 +0,0 @@
-import { get_range_selection } from "../utils/selection_utils";
-export function create_drag_handlers(state, set_is_dragging, set_selected_cells, set_selected, handle_cell_click, show_row_numbers, parent_element) {
-    const start_drag = (event, row, col) => {
-        const target = event.target;
-        const is_checkbox_click = target.type === "checkbox" ||
-            target.closest('input[type="checkbox"]') ||
-            target.closest(".bool-cell");
-        if (event.target instanceof HTMLAnchorElement ||
-            (show_row_numbers && col === -1) ||
-            is_checkbox_click)
-            return;
-        event.preventDefault();
-        event.stopPropagation();
-        state.mouse_down_pos = { x: event.clientX, y: event.clientY };
-        state.drag_start = [row, col];
-        if (!event.shiftKey && !event.metaKey && !event.ctrlKey) {
-            set_selected_cells([[row, col]]);
-            set_selected([row, col]);
-            handle_cell_click(event, row, col);
-        }
-    };
-    const update_selection = (event) => {
-        const cell = event.target.closest("td");
-        if (!cell)
-            return;
-        const row = parseInt(cell.getAttribute("data-row") || "0");
-        const col = parseInt(cell.getAttribute("data-col") || "0");
-        if (isNaN(row) || isNaN(col))
-            return;
-        const selection_range = get_range_selection(state.drag_start, [row, col]);
-        set_selected_cells(selection_range);
-        set_selected([row, col]);
-    };
-    const end_drag = (event) => {
-        if (!state.is_dragging && state.drag_start) {
-            handle_cell_click(event, state.drag_start[0], state.drag_start[1]);
-        }
-        else if (state.is_dragging && parent_element) {
-            parent_element.focus();
-        }
-        state.is_dragging = false;
-        set_is_dragging(false);
-        state.drag_start = null;
-        state.mouse_down_pos = null;
-    };
-    return {
-        handle_mouse_down: start_drag,
-        handle_mouse_move(event) {
-            if (!state.drag_start || !state.mouse_down_pos)
-                return;
-            if (!(event.buttons & 1)) {
-                end_drag(event);
-                return;
-            }
-            const dx = Math.abs(event.clientX - state.mouse_down_pos.x);
-            const dy = Math.abs(event.clientY - state.mouse_down_pos.y);
-            if (!state.is_dragging && (dx > 3 || dy > 3)) {
-                state.is_dragging = true;
-                set_is_dragging(true);
-            }
-            if (state.is_dragging) {
-                update_selection(event);
-            }
-        },
-        handle_mouse_up: end_drag
-    };
-}

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

@@ -1,29 +0,0 @@
-import type { CellValue } from "../types";
-export type FilterDatatype = "string" | "number";
-export declare function filter_data(data: {
-    id: string;
-    value: CellValue;
-}[][], filter_columns: {
-    col: number;
-    datatype: FilterDatatype;
-    filter: string;
-    value: string;
-}[]): number[];
-export declare function filter_data_and_preserve_selection(data: {
-    id: string;
-    value: CellValue;
-}[][], display_value: string[][] | null, styling: string[][] | null, filter_columns: {
-    col: number;
-    datatype: FilterDatatype;
-    filter: string;
-    value: string;
-}[], selected: [number, number] | false, get_current_indices: (id: string, data: {
-    id: string;
-    value: CellValue;
-}[][]) => [number, number], original_data?: {
-    id: string;
-    value: CellValue;
-}[][], original_display_value?: string[][] | null, original_styling?: string[][] | null): {
-    data: typeof data;
-    selected: [number, number] | false;
-};