|
|
import { getContext, setContext } from "svelte"; |
|
|
import { dequal } from "dequal"; |
|
|
import { writable, get } from "svelte/store"; |
|
|
import { sort_table_data } from "../utils/table_utils"; |
|
|
import type { CellValue } from "../types"; |
|
|
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"); |
|
|
|
|
|
export type SortDirection = "asc" | "desc"; |
|
|
export type FilterDatatype = "string" | "number"; |
|
|
export type CellCoordinate = [number, number]; |
|
|
|
|
|
interface DataFrameState { |
|
|
config: { |
|
|
show_fullscreen_button: boolean; |
|
|
show_copy_button: boolean; |
|
|
show_search: "none" | "search" | "filter"; |
|
|
show_row_numbers: boolean; |
|
|
editable: boolean; |
|
|
pinned_columns: number; |
|
|
show_label: boolean; |
|
|
line_breaks: boolean; |
|
|
wrap: boolean; |
|
|
max_height: number; |
|
|
column_widths: string[]; |
|
|
max_chars?: number; |
|
|
static_columns?: CellValue[]; |
|
|
}; |
|
|
current_search_query: string | null; |
|
|
sort_state: { |
|
|
sort_columns: { col: number; direction: SortDirection }[]; |
|
|
row_order: number[]; |
|
|
initial_data: { |
|
|
data: { id: string; value: CellValue }[][]; |
|
|
display_value: string[][] | null; |
|
|
styling: string[][] | null; |
|
|
} | null; |
|
|
}; |
|
|
filter_state: { |
|
|
filter_columns: { |
|
|
col: number; |
|
|
datatype: FilterDatatype; |
|
|
filter: string; |
|
|
value: string; |
|
|
}[]; |
|
|
initial_data: { |
|
|
data: { id: string; value: CellValue }[][]; |
|
|
display_value: string[][] | null; |
|
|
styling: string[][] | null; |
|
|
} | null; |
|
|
}; |
|
|
ui_state: { |
|
|
active_cell_menu: { row: number; col: number; x: number; y: number } | null; |
|
|
active_header_menu: { col: number; x: number; y: number } | null; |
|
|
selected_cells: CellCoordinate[]; |
|
|
selected: CellCoordinate | false; |
|
|
editing: CellCoordinate | false; |
|
|
header_edit: number | false; |
|
|
selected_header: number | false; |
|
|
active_button: { |
|
|
type: "header" | "cell"; |
|
|
row?: number; |
|
|
col: number; |
|
|
} | null; |
|
|
copy_flash: boolean; |
|
|
}; |
|
|
} |
|
|
|
|
|
interface DataFrameActions { |
|
|
handle_search: (query: string | null) => void; |
|
|
handle_sort: (col: number, direction: SortDirection) => void; |
|
|
handle_filter: ( |
|
|
col: number, |
|
|
datatype: FilterDatatype, |
|
|
filter: string, |
|
|
value: string |
|
|
) => void; |
|
|
get_sort_status: (name: string, headers: string[]) => "none" | "asc" | "desc"; |
|
|
sort_data: ( |
|
|
data: any[][], |
|
|
display_value: string[][] | null, |
|
|
styling: string[][] | null |
|
|
) => void; |
|
|
update_row_order: (data: any[][]) => void; |
|
|
filter_data: (data: any[][]) => any[][]; |
|
|
add_row: (data: any[][], make_id: () => string, index?: number) => any[][]; |
|
|
add_col: ( |
|
|
data: any[][], |
|
|
headers: string[], |
|
|
make_id: () => string, |
|
|
index?: number |
|
|
) => { data: any[][]; headers: string[] }; |
|
|
add_row_at: ( |
|
|
data: any[][], |
|
|
index: number, |
|
|
position: "above" | "below", |
|
|
make_id: () => string |
|
|
) => any[][]; |
|
|
add_col_at: ( |
|
|
data: any[][], |
|
|
headers: string[], |
|
|
index: number, |
|
|
position: "left" | "right", |
|
|
make_id: () => string |
|
|
) => { data: any[][]; headers: string[] }; |
|
|
delete_row: (data: any[][], index: number) => any[][]; |
|
|
delete_col: ( |
|
|
data: any[][], |
|
|
headers: string[], |
|
|
index: number |
|
|
) => { data: any[][]; headers: string[] }; |
|
|
delete_row_at: (data: any[][], index: number) => any[][]; |
|
|
delete_col_at: ( |
|
|
data: any[][], |
|
|
headers: string[], |
|
|
index: number |
|
|
) => { data: any[][]; headers: string[] }; |
|
|
trigger_change: ( |
|
|
data: any[][], |
|
|
headers: any[], |
|
|
previous_data: any[][], |
|
|
previous_headers: string[], |
|
|
value_is_output: boolean, |
|
|
dispatch: (e: "change" | "input" | "edit", detail?: any) => void |
|
|
) => Promise<void>; |
|
|
reset_sort_state: () => void; |
|
|
reset_filter_state: () => void; |
|
|
set_active_cell_menu: ( |
|
|
menu: { row: number; col: number; x: number; y: number } | null |
|
|
) => void; |
|
|
set_active_header_menu: ( |
|
|
menu: { col: number; x: number; y: number } | null |
|
|
) => void; |
|
|
set_selected_cells: (cells: CellCoordinate[]) => void; |
|
|
set_selected: (selected: CellCoordinate | false) => void; |
|
|
set_editing: (editing: CellCoordinate | false) => void; |
|
|
clear_ui_state: () => void; |
|
|
set_header_edit: (header_index: number | false) => void; |
|
|
set_selected_header: (header_index: number | false) => void; |
|
|
handle_header_click: (col: number, editable: boolean) => void; |
|
|
end_header_edit: (key: string) => void; |
|
|
get_selected_cells: () => CellCoordinate[]; |
|
|
get_active_cell_menu: () => { |
|
|
row: number; |
|
|
col: number; |
|
|
x: number; |
|
|
y: number; |
|
|
} | null; |
|
|
get_active_button: () => { |
|
|
type: "header" | "cell"; |
|
|
row?: number; |
|
|
col: number; |
|
|
} | null; |
|
|
set_active_button: ( |
|
|
button: { type: "header" | "cell"; row?: number; col: number } | null |
|
|
) => void; |
|
|
set_copy_flash: (value: boolean) => void; |
|
|
handle_cell_click: (event: MouseEvent, row: number, col: number) => void; |
|
|
toggle_cell_menu: (event: MouseEvent, row: number, col: number) => void; |
|
|
toggle_cell_button: (row: number, col: number) => void; |
|
|
handle_select_column: (col: number) => void; |
|
|
handle_select_row: (row: number) => void; |
|
|
get_next_cell_coordinates: typeof get_next_cell_coordinates; |
|
|
get_range_selection: typeof get_range_selection; |
|
|
move_cursor: typeof move_cursor; |
|
|
} |
|
|
|
|
|
export interface DataFrameContext { |
|
|
state: ReturnType<typeof writable<DataFrameState>>; |
|
|
actions: DataFrameActions; |
|
|
data?: any[][]; |
|
|
headers?: { id: string; value: string }[]; |
|
|
display_value?: string[][] | null; |
|
|
styling?: string[][] | null; |
|
|
els?: Record< |
|
|
string, |
|
|
{ cell: HTMLTableCellElement | null; input: HTMLTextAreaElement | null } |
|
|
>; |
|
|
parent_element?: HTMLElement; |
|
|
get_data_at?: (row: number, col: number) => CellValue; |
|
|
get_column?: (col: number) => CellValue[]; |
|
|
get_row?: (row: number) => CellValue[]; |
|
|
dispatch?: (e: "change" | "select" | "search" | "edit", detail?: any) => void; |
|
|
} |
|
|
|
|
|
function create_actions( |
|
|
state: ReturnType<typeof writable<DataFrameState>>, |
|
|
context: DataFrameContext |
|
|
): DataFrameActions { |
|
|
const update_state = ( |
|
|
updater: (s: DataFrameState) => Partial<DataFrameState> |
|
|
): void => state.update((s) => ({ ...s, ...updater(s) })); |
|
|
|
|
|
const add_row = ( |
|
|
data: any[][], |
|
|
make_id: () => string, |
|
|
index?: number |
|
|
): any[][] => { |
|
|
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: any[][], |
|
|
headers: string[], |
|
|
make_id: () => string, |
|
|
index?: number |
|
|
): { data: any[][]; headers: string[] } => { |
|
|
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: { id: string; value: CellValue }[][] | string[][] | null, |
|
|
target: any[] | null | undefined |
|
|
): void => { |
|
|
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: number[] = []; |
|
|
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 { |
|
|
|
|
|
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 as HTMLElement).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" as const, 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] as CellCoordinate); |
|
|
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] as CellCoordinate |
|
|
); |
|
|
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: DataFrameState["config"] |
|
|
): DataFrameContext { |
|
|
const state = writable<DataFrameState>({ |
|
|
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: DataFrameContext = { state, actions: null as any }; |
|
|
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(): DataFrameContext { |
|
|
const ctx = getContext<{ instance_id: symbol; context: DataFrameContext }>( |
|
|
DATAFRAME_KEY |
|
|
); |
|
|
return ctx?.context ?? getContext<DataFrameContext>(DATAFRAME_KEY); |
|
|
} |
|
|
|
