@adecore/database 0.38.0 → 0.40.0

package/src/table/TableView.tsx

@@ -29,6 +29,7 @@ import { RecordView } from '../grid/RecordView.tsx';
 import { ValueDock } from '../grid/ValueDock.tsx';
 import { valueOfCell, type EditValue, type RowChange, type TableStructure, type Value } from '../protocol/index.ts';
 import type { SqlTarget } from '../sql.ts';
+import { parseStoredSize } from '../stored-size.ts';
 import { useSchemaChange } from '../use-schema-change.ts';
 import { useStableCallback } from '../use-stable-callback.ts';
 import {
@@ -78,15 +79,6 @@ import { useTableTransfer, type TransferNotice } from './useTableTransfer.ts';
 export const RECORD_WIDTH_KEY = 'database:record-view';
 const RECORD_WIDTH = 360;
 
-const parseRecordWidth = (raw: string | null | undefined): number | null => {
-    try {
-        const value: unknown = JSON.parse(raw ?? 'null');
-        return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.round(value) : null;
-    } catch {
-        return null;
-    }
-};
-
 export interface TableViewProps {
     connection: Connection;
     schema: string;
@@ -113,12 +105,15 @@ const readOnlyReasonOf = (connection: Connection, structure: TableStructure | nu
     if (connection.config.readOnly === true) {
         return t('table.readOnly.connection');
     }
+
     if (structure?.kind === 'view') {
         return t('table.readOnly.view');
     }
+
     if (structure !== null && structure.rowKey === null) {
         return t('table.readOnly.noKey');
     }
+
     return null;
 };
 
@@ -178,6 +173,7 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
     const counter = useRef<AbortController | null>(null);
     const insertedBefore = useRef(0);
     const engine = connection.config.engine;
+
     const [chips, setChips] = useState<Chip[]>(() =>
         chipsFromQuery(engine, {
             where: defaultWhere ?? stored?.where ?? '',
@@ -185,6 +181,7 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
             remembered: defaultWhere === undefined ? stored?.filters : undefined
         })
     );
+
     const [offset, setOffset] = useState(0);
     const [pageSize, setPageSize] = useState(stored?.pageSize ?? DEFAULT_PAGE_SIZE);
     const [pending, setPending] = useState<PendingChanges>(emptyPending);
@@ -197,7 +194,7 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
     const [discard, setDiscard] = useState<{ run(): void } | null>(null);
     const [focus, setFocus] = useState<FocusedCell | null>(null);
     const [recordOpen, setRecordOpen] = useState(false);
-    const [recordWidth, setRecordWidth] = useState(() => parseRecordWidth(storage?.get(RECORD_WIDTH_KEY)));
+    const [recordWidth, setRecordWidth] = useState(() => parseStoredSize(storage?.get(RECORD_WIDTH_KEY), Number.MIN_VALUE));
     const [focusRequest, setFocusRequest] = useState<FocusRequest | null>(null);
     const [columnRequest, setColumnRequest] = useState<ColumnRequest | null>(null);
     const [range, setRange] = useState<RangeBlock | null>(null);
@@ -205,6 +202,7 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
     const applied = useMemo((): Filters => ({ where: chipsToWhere(chips), orderBy: chipsToOrderBy(engine, chips) }), [chips, engine]);
     const target = `${connection.id}|${schema}|${table}`;
     const structureLoad = useLoaded((signal) => session.structure(schema, table, { signal }), target);
+
     // The offset travels with the page it belongs to, since the page on screen lags behind the one asked for.
     const rowsLoad = useLoaded(
         async (signal) => ({
@@ -218,6 +216,7 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
         }),
         JSON.stringify([target, applied, offset, pageSize])
     );
+
     const structure = structureLoad.value;
     const loaded = rowsLoad.value?.result ?? null;
     const loadedOffset = rowsLoad.value?.offset ?? 0;
@@ -226,10 +225,12 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
     const editable = readOnlyReason === null && structure !== null && loaded !== null && !rowsLoad.loading;
 
     const columns = useMemo(() => (loaded === null ? [] : buildGridColumns(loaded, structure)), [loaded, structure]);
+
     const rows = useMemo(
         () => (loaded === null ? [] : buildGridRows({ structure, loaded, pending, offset: loadedOffset })),
         [loaded, structure, pending, loadedOffset]
     );
+
     const transfer = useTableTransfer({
         client,
         session,
@@ -257,6 +258,7 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
                               : { tone: 'success', title: transferText(found, t) }
                       )
     });
+
     const changeCount = pendingCount(pending);
     const dirty = changeCount > 0;
     const reportDirty = useRef(onDirtyChange);
@@ -267,6 +269,7 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
     // The record view shows the row of the focused cell, or the first row before a cell has the focus.
     const focusedIndex = focus === null ? -1 : rows.findIndex((row) => row.key === focus.rowKey);
     const recordIndex = focusedIndex >= 0 ? focusedIndex : rows.length > 0 ? 0 : -1;
+
     const selectionFigures = useMemo(
         () =>
             range === null || blockSize(range) < 2
@@ -281,6 +284,7 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
                   },
         [range, rows, columns]
     );
+
     const sqlTarget = useMemo((): SqlTarget => ({ engine, schema, table }), [engine, schema, table]);
 
     useSchemaChange(connection.id, schema, () => {
@@ -307,6 +311,7 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
     useEffect(() => {
         const controller = new AbortController();
         lifetime.current = controller;
+
         return () => {
             controller.abort();
             counter.current?.abort();
@@ -317,6 +322,7 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
         if (pending.inserts.length > insertedBefore.current && grid.current !== null) {
             grid.current.scrollTop = grid.current.scrollHeight;
         }
+
         insertedBefore.current = pending.inserts.length;
     }, [pending.inserts.length]);
 
@@ -350,11 +356,14 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
         const where = chipsToWhere(next);
         const orderBy = chipsToOrderBy(engine, next);
         const filters = next.filter((chip): chip is FilterChip => chip.kind === 'filter').map(({ text, sql }) => ({ text, sql }));
+
         if (where === applied.where && orderBy === applied.orderBy) {
             remember({ filters });
             setChips([...next]);
+
             return;
         }
+
         guard(() => {
             remember({ where, orderBy, filters });
             counter.current?.abort();
@@ -375,11 +384,13 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
         const row = parseRowKey(cell.rowKey);
         const column = loaded?.columns[cell.column];
         const value = loaded === null || row.kind !== 'loaded' ? undefined : valueOfCell(loaded.rows[row.index]?.[cell.column] ?? null);
+
         return column === undefined || value === undefined ? null : cellChip(engine, column.name, value, column.kind, exclude);
     };
 
     const sortByColumn = (cell: FocusedCell): void => {
         const name = columns[cell.column]?.name;
+
         if (name !== undefined) {
             applyChips(toggleSort(chips, name));
         }
@@ -387,6 +398,7 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
 
     const jumpToColumn = (name: string): void => {
         const index = columns.findIndex((column) => column.name === name);
+
         if (index >= 0) {
             setRecordOpen(false);
             setColumnRequest({ column: index });
@@ -423,10 +435,13 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
         counter.current?.abort();
         counter.current = controller;
         setCounting(true);
+
         try {
             const total = await session.count(schema, table, applied.where || undefined, { signal: controller.signal });
+
             if (!controller.signal.aborted) {
                 setCounted(total);
+
                 return total;
             }
         } catch (error) {
@@ -438,11 +453,13 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
                 setCounting(false);
             }
         }
+
         return null;
     };
 
     const goToLast = async (): Promise<void> => {
         const total = counted ?? (await countRows());
+
         if (total !== null) {
             goToPage(lastPageOffset(total, pageSize));
         }
@@ -451,9 +468,11 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
     const commit = (rowKey: string, column: number, value: EditValue): void => {
         const name = loaded?.columns[column]?.name;
         const row = parseRowKey(rowKey);
+
         if (loaded === null || name === undefined) {
             return;
         }
+
         if (row.kind === 'inserted') {
             setPending((now) => setInsertValue(now, row.id, name, value));
         } else {
@@ -465,13 +484,16 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
         const row = parseRowKey(rowKey);
         const name = loaded?.columns[column]?.name;
         const key = row.kind === 'loaded' && structure !== null && loaded !== null ? rowKeyOf(structure, loaded, row.index) : null;
+
         if (key === null || name === undefined) {
             return undefined;
         }
+
         try {
             return await session.cell(schema, table, key, name, { signal: lifetime.current?.signal });
         } catch (error) {
             setFailure(messageOf(error));
+
             return undefined;
         }
     });
@@ -479,14 +501,17 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
     const refsOf = (keys: Iterable<string>): RowSelectionRefs => {
         const loadedRows: number[] = [];
         const inserted: number[] = [];
+
         for (const key of keys) {
             const row = parseRowKey(key);
+
             if (row.kind === 'inserted') {
                 inserted.push(row.id);
             } else {
                 loadedRows.push(row.index);
             }
         }
+
         return { loaded: loadedRows, inserted };
     };
 
@@ -494,11 +519,13 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
         setPending((now) => {
             const refs = refsOf(keys);
             const next = refs.inserted.reduce(removeInsert, now);
+
             return markDeleted(
                 next,
                 refs.loaded.filter((index) => loaded !== null && structure !== null && rowKeyOf(structure, loaded, index) !== null)
             );
         });
+
         setSelected(NO_KEYS);
     };
 
@@ -520,16 +547,19 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
         const column = columns[cell.column];
         const key = column === undefined || structure === null ? undefined : foreignKeyOf(structure.foreignKeys, column.name);
         const row = rowByKey.get(cell.rowKey);
+
         return key === undefined || row === undefined ? null : referenceOf(engine, key, columns, row.cells);
     };
 
     const isReferenceColumn = (column: number): boolean => {
         const name = columns[column]?.name;
+
         return name !== undefined && structure !== null && foreignKeyOf(structure.foreignKeys, name) !== undefined;
     };
 
     const follow = (cell: FocusedCell): void => {
         const reference = referenceAt(cell);
+
         if (reference !== null) {
             onAction?.({
                 kind: 'open-table',
@@ -552,6 +582,7 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
 
     const changeRecordIndex = (index: number): void => {
         const row = rows[index];
+
         if (row !== undefined) {
             followInGrid({ rowKey: row.key, column: focus?.column ?? 0 });
         }
@@ -560,11 +591,14 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
     const queryMenu = (context: GridMenuContext): ReactNode => {
         const cell = context.cell;
         const name = cell === null ? undefined : columns[cell.column]?.name;
+
         if (cell === null || name === undefined) {
             return null;
         }
+
         const include = cellChipAt(cell, false);
         const exclude = cellChipAt(cell, true);
+
         return (
             <>
                 <ContextMenu.Item disabled={include === null} onClick={() => include !== null && applyChips(addChip(chips, include))}>
@@ -591,6 +625,7 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
 
     const gridMenu = (context: GridMenuContext): ReactNode => {
         const count = context.rowKeys.length;
+
         return (
             <>
                 <ContextMenu.Item disabled={!editable} onClick={() => cloneRows(context.rowKeys)}>
@@ -615,9 +650,11 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
 
     const conflictMessage = (error: DatabaseRequestError, changes: readonly RowChange[]): string => {
         const change = error.change === undefined ? undefined : changes[error.change];
+
         if (error.change === undefined || change === undefined || change.kind === 'insert') {
             return error.message;
         }
+
         return t('table.conflict', { number: formatNumber(error.change + 1), row: describeKey(change.key) });
     };
 
@@ -625,9 +662,11 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
         if (structure === null || loaded === null) {
             return;
         }
+
         const changes = toRowChanges(structure, loaded, pending);
         setSubmitting(true);
         setFailure(null);
+
         try {
             await session.apply(schema, table, changes);
             discardPending();
@@ -834,6 +873,7 @@ interface TransferBannerProps {
 
 function TransferBanner({ notice, onCancel, onDismiss }: TransferBannerProps) {
     const { t } = useTranslation('database');
+
     return (
         <Banner
             icon={notice.kind === 'failed' ? CircleAlert : notice.kind === 'exporting' ? Download : Check}

package/src/table/command-field.ts

@@ -56,6 +56,7 @@ const PATTERN = /^((?:NOT\s+)?(?:LIKE|ILIKE|GLOB|REGEXP|RLIKE))\s+([\s\S]+)$/i;
 const MEMBER = /^((?:NOT\s+)?IN)\s*(\([\s\S]+\))$/i;
 const BETWEEN = /^((?:NOT\s+)?BETWEEN)\s+([\s\S]+?)\s+AND\s+([\s\S]+)$/i;
 const IS_TEST = /^IS\s+(?:NOT\s+)?(?:NULL|TRUE|FALSE)$/i;
+
 /* A name being typed, or one that opened a quote. Whitespace after it means an operator is coming. */
 const NAME_BEING_TYPED = /^\s*(?:[\w$]*|[`"][^`"]*[`"]?)$/;
 
@@ -76,9 +77,11 @@ export const chipsToWhere = (chips: readonly Chip[]): string => {
         .filter(isFilter)
         .map((chip) => chip.sql.trim())
         .filter((sql) => sql !== '');
+
     if (conditions.length < 2) {
         return conditions[0] ?? '';
     }
+
     return conditions.map((sql) => (OR.test(sql) ? `(${sql})` : sql)).join(' AND ');
 };
 
@@ -89,6 +92,7 @@ export const chipsToOrderBy = (engine: Engine, chips: readonly Chip[]): string =
             if (chip.kind === 'sort') {
                 return [orderByClause(engine, [chip])];
             }
+
             return chip.kind === 'order' ? [chip.text.trim()] : [];
         })
         .filter((part) => part !== '')
@@ -104,6 +108,7 @@ export const toggleSort = (chips: readonly Chip[], column: string): Chip[] => {
     if (!chips.some((chip) => isSort(chip) && chip.column === column)) {
         return [...chips, { kind: 'sort', column, direction: 'asc' }];
     }
+
     return chips.map((chip) => (isSort(chip) && chip.column === column ? { ...chip, direction: chip.direction === 'asc' ? 'desc' : 'asc' } : chip));
 };
 
@@ -116,6 +121,7 @@ export const removeChipAt = (chips: readonly Chip[], index: number): Chip[] => c
 /* Puts the chip where another stood, dropping it if an equal one is already elsewhere in the list. */
 export const replaceChipAt = (chips: readonly Chip[], index: number, chip: Chip): Chip[] => {
     const duplicate = chips.some((other, at) => at !== index && chipKey(other) === chipKey(chip));
+
     return duplicate ? removeChipAt(chips, index) : chips.map((other, at) => (at === index ? chip : other));
 };
 
@@ -124,20 +130,26 @@ const rawFilter = (text: string): FilterChip => ({ kind: 'filter', text, sql: te
 /* The WHERE of a layout or of a jump as chips: the remembered ones when they still say that text, else the text as one raw chip. */
 export const filterChipsOf = (where: string, remembered: readonly StoredFilter[] = []): Chip[] => {
     const text = where.trim();
+
     if (text === '') {
         return [];
     }
+
     const kept = remembered.map((filter): FilterChip => ({ kind: 'filter', text: filter.text, sql: filter.sql }));
+
     return chipsToWhere(kept) === text ? kept : [rawFilter(text)];
 };
 
 /* A plain list of columns becomes sort chips; anything else is one chip that keeps the text. */
 export const sortChipsOf = (engine: Engine, orderBy: string): Chip[] => {
     const text = orderBy.trim();
+
     if (text === '') {
         return [];
     }
+
     const sorts = parseOrderByLoose(engine, text);
+
     return sorts === null ? [{ kind: 'order', text }] : sorts.map(sortChip);
 };
 
@@ -156,6 +168,7 @@ export const chipsFromQuery = (engine: Engine, { where, orderBy, remembered }: C
 const isClosed = (operand: string): boolean => {
     let quote: string | null = null;
     let depth = 0;
+
     for (const character of operand) {
         if (quote !== null) {
             quote = character === quote ? null : quote;
@@ -165,11 +178,13 @@ const isClosed = (operand: string): boolean => {
             depth++;
         } else if (character === ')') {
             depth--;
+
             if (depth < 0) {
                 return false;
             }
         }
     }
+
     return quote === null && depth === 0;
 };
 
@@ -178,20 +193,27 @@ const upper = (keyword: string): string => keyword.replace(/\s+/g, ' ').toUpperC
 /* The operator and operands of a condition in the form the chip shows, or `null` when the text does not read as one. */
 const readOperation = (rest: string): string | null => {
     const compare = COMPARE.exec(rest);
+
     if (compare !== null) {
         const operator = compare[1] === '==' ? '=' : compare[1] === '!=' ? '<>' : compare[1];
+
         return isClosed(compare[2]!) ? `${operator} ${compare[2]}` : null;
     }
+
     for (const form of [PATTERN, MEMBER]) {
         const found = form.exec(rest);
+
         if (found !== null) {
             return isClosed(found[2]!) ? `${upper(found[1]!)} ${found[2]}` : null;
         }
     }
+
     const between = BETWEEN.exec(rest);
+
     if (between !== null) {
         return isClosed(between[2]!) && isClosed(between[3]!) ? `${upper(between[1]!)} ${between[2]} AND ${between[3]}` : null;
     }
+
     return IS_TEST.test(rest) ? upper(rest) : null;
 };
 
@@ -201,14 +223,18 @@ const readOperation = (rest: string): string | null => {
  */
 export const parseCondition = (engine: Engine, text: string, columns: readonly string[]): FilterChip | null => {
     const match = WORD.exec(text.trim());
+
     if (match === null) {
         return null;
     }
+
     const column = findColumn(engine, match[1]!, columns);
     const operation = column === undefined ? null : readOperation(match[2]!.trim());
+
     if (column === undefined || operation === null) {
         return null;
     }
+
     return { kind: 'filter', text: `${match[1]} ${operation}`, sql: `${quoteIdentifier(engine, column)} ${operation}` };
 };
 
@@ -216,6 +242,7 @@ export const parseCondition = (engine: Engine, text: string, columns: readonly s
 export const cellChip = (engine: Engine, column: string, value: LiteralValue, kind: ValueKind | undefined, exclude: boolean): FilterChip => {
     const name = identifierText(column);
     const text = value === null ? `${name} IS ${exclude ? 'NOT ' : ''}NULL` : `${name} ${exclude ? '<>' : '='} ${sqlLiteral(engine, value, kind)}`;
+
     return { kind: 'filter', text, sql: exclude ? notEqualsCondition(engine, column, value, kind) : equalsCondition(engine, column, value, kind) };
 };
 
@@ -225,24 +252,30 @@ export const shorten = (text: string, limit: number): string => (text.length > l
 /* How well a name matches what is typed: 0 is the name itself, then its start, a word of it, anywhere in it; `null` is no match. */
 const rankOf = (name: string, token: string): number | null => {
     const lower = name.toLowerCase();
+
     if (lower === token) {
         return 0;
     }
+
     if (lower.startsWith(token)) {
         return 1;
     }
+
     if (lower.split(/[\s_.-]+/).some((word) => word.startsWith(token))) {
         return 2;
     }
+
     return lower.includes(token) ? 3 : null;
 };
 
 /* The columns that match a typed name, the closest first and in table order among equals. */
 export const matchColumns = (columns: readonly CommandColumn[], typed: string, limit = SUGGESTED_COLUMNS): CommandColumn[] => {
     const token = typed.trim().replace(/^[`"]/, '').replace(/[`"]$/, '').toLowerCase();
+
     if (token === '') {
         return [];
     }
+
     return columns
         .map((column, order) => ({ column, order, rank: rankOf(column.name, token) }))
         .filter((entry): entry is { column: CommandColumn; order: number; rank: number } => entry.rank !== null)
@@ -257,24 +290,31 @@ export const matchColumns = (columns: readonly CommandColumn[], typed: string, l
  */
 export const suggest = (engine: Engine, text: string, columns: readonly CommandColumn[], limit = SUGGESTED_COLUMNS): Suggestion[] => {
     const typed = text.trim();
+
     if (typed === '') {
         return [];
     }
+
     const suggestions: Suggestion[] = [];
+
     const condition = parseCondition(
         engine,
         typed,
         columns.map((column) => column.name)
     );
+
     if (condition !== null) {
         suggestions.push({ kind: 'condition', chip: condition });
     }
+
     if (NAME_BEING_TYPED.test(text)) {
         for (const column of matchColumns(columns, typed, limit)) {
             suggestions.push({ kind: 'filter', column }, { kind: 'sort', column }, { kind: 'jump', column });
         }
     }
+
     suggestions.push({ kind: 'sql', chip: rawFilter(typed) });
+
     return suggestions;
 };
 

package/src/table/grid-rows.ts

@@ -15,7 +15,9 @@ export const parseRowKey = (key: string): RowRef =>
 
 export const buildGridColumns = (loaded: Pick<RowsResult, 'columns'>, structure: TableStructure | null): GridColumn[] => {
     const keys = { primaryKey: structure?.primaryKey ?? [], foreignKey: structure?.foreignKeys.flatMap((key) => key.columns) ?? [] };
+
     const infoOf = (name: string) => structure?.columns.find((info) => info.name === name);
+
     return loaded.columns.map((column) => gridColumnOf(column, infoOf(column.name), keys));
 };
 
@@ -32,14 +34,19 @@ export const buildGridRows = ({ structure, loaded, pending, offset }: GridRowsIn
     const rows = loaded.rows.map((cells, index): GridRow => {
         const edits = pending.edits[index];
         const edited = new Set<number>();
+
         const shown = cells.map((cell, column): Shown => {
             const edit = edits?.[loaded.columns[column]!.name];
+
             if (edit === undefined) {
                 return cell;
             }
+
             edited.add(column);
+
             return shownOfEdit(edit);
         });
+
         return {
             key: loadedRowKey(index),
             number: offset + index + 1,
@@ -49,15 +56,18 @@ export const buildGridRows = ({ structure, loaded, pending, offset }: GridRowsIn
             locked: structure === null || rowKeyOf(structure, loaded, index) === null
         };
     });
+
     const inserted = pending.inserts.map((row): GridRow => ({
         key: insertedRowKey(row.id),
         number: null,
         cells: loaded.columns.map((column): Shown => {
             const value = row.values[column.name];
+
             return value === undefined ? { kind: 'default' } : shownOfEdit(value);
         }),
         state: 'inserted'
     }));
+
     return [...rows, ...inserted];
 };
 
@@ -67,11 +77,14 @@ export const buildGridRows = ({ structure, loaded, pending, offset }: GridRowsIn
  */
 export const cloneValues = (columns: readonly GridColumn[], cells: readonly Shown[]): Record<string, EditValue> => {
     const values: Record<string, EditValue> = {};
+
     columns.forEach((column, index) => {
         const value = column.autoIncrement === true || column.readOnly === true ? undefined : wholeValueOf(cells[index] ?? null);
+
         if (value !== undefined) {
             values[column.name] = value;
         }
     });
+
     return values;
 };

package/src/table/import-mapping.ts

@@ -17,14 +17,19 @@ export const matchColumns = (fileColumns: readonly string[], tableColumns: reado
     if (!header) {
         return fileColumns.map((_, index) => tableColumns[index] ?? null);
     }
+
     const taken = new Set<string>();
+
     return fileColumns.map((name) => {
         const wanted = name.trim().toLowerCase();
         const match = tableColumns.find((column) => !taken.has(column) && column.toLowerCase() === wanted);
+
         if (match === undefined) {
             return null;
         }
+
         taken.add(match);
+
         return match;
     });
 };

package/src/table/layout-store.ts

@@ -35,16 +35,21 @@ export const parseStoredLayout = (text: string | null): StoredLayout | null => {
     if (text === null) {
         return null;
     }
+
     let data: unknown;
+
     try {
         data = JSON.parse(text);
     } catch {
         return null;
     }
+
     if (!isRecord(data) || data.version !== LAYOUT_VERSION) {
         return null;
     }
+
     const widths: Record<string, number> = {};
+
     if (isRecord(data.widths)) {
         for (const [name, width] of Object.entries(data.widths)) {
             if (typeof width === 'number' && Number.isFinite(width) && width > 0) {
@@ -52,7 +57,9 @@ export const parseStoredLayout = (text: string | null): StoredLayout | null => {
             }
         }
     }
+
     const pageSize = PAGE_SIZES.find((size) => size === data.pageSize) ?? null;
+
     return {
         widths,
         hidden: isStringList(data.hidden) ? data.hidden : [],

package/src/table/paging.ts

@@ -19,6 +19,7 @@ export interface PageBounds {
 export const pageBounds = (offset: number, rowCount: number, hasMore: boolean, counted: number | null): PageBounds => {
     const exact = counted !== null || !hasMore;
     const total = counted ?? (hasMore ? offset + rowCount + 1 : offset + rowCount);
+
     return {
         from: rowCount === 0 ? 0 : offset + 1,
         to: offset + rowCount,