@adecore/database 0.0.1 → 0.16.0-beta.0

package/dist/grid/display.js

@@ -0,0 +1,81 @@
+import { formatBytes, formatNumeral } from '@adecore/ui/format';
+/* A cell never draws more than this, however long the text: the DOM stays small and the cell is one line anyway. */
+export const DISPLAY_LIMIT = 200;
+/* How many bytes of a binary value the cell spells out. */
+export const BINARY_PREVIEW_BYTES = 8;
+const NUMERIC_KINDS = new Set(['integer', 'decimal', 'float']);
+/* Whether the cells of a column of this kind sit against the end of their cell, as numbers do. */
+export const isNumericKind = (kind) => NUMERIC_KINDS.has(kind);
+const ELLIPSIS = '…';
+const isObject = (cell) => cell !== null && typeof cell === 'object';
+/* Whether a cell is only the start of its value, so editing it needs the whole value first. */
+export const isPreview = (cell) => {
+    if (!isObject(cell)) {
+        return false;
+    }
+    if (cell.kind === 'longText') {
+        return true;
+    }
+    return cell.kind === 'binary' && cell.hex.length < cell.length * 2;
+};
+/* A numeral in the notation asked for; text that is no numeral stays as it is. */
+export const numeralText = (numeral, notation) => {
+    if (notation === 'database') {
+        return String(numeral);
+    }
+    const formatted = formatNumeral(numeral);
+    return formatted === String(numeral).trim() ? String(numeral) : formatted;
+};
+const cut = (text) => (text.length > DISPLAY_LIMIT ? `${text.slice(0, DISPLAY_LIMIT)}${ELLIPSIS}` : text);
+export const cellView = (cell, kind, notation = 'database') => {
+    const numeric = isNumericKind(kind);
+    const align = numeric ? 'end' : 'start';
+    if (cell === null) {
+        return { text: 'NULL', tone: 'null', align };
+    }
+    if (typeof cell === 'boolean') {
+        return { text: cell ? 'true' : 'false', tone: 'value', align };
+    }
+    if (typeof cell === 'number') {
+        return { text: numeric ? numeralText(cell, notation) : String(cell), tone: 'value', align };
+    }
+    if (typeof cell === 'string') {
+        return { text: cut(numeric ? numeralText(cell, notation) : cell), tone: 'value', align };
+    }
+    switch (cell.kind) {
+        case 'default':
+            return { text: 'DEFAULT', tone: 'default', align };
+        case 'longText':
+            return { text: `${cut(cell.preview)}${cell.preview.length <= DISPLAY_LIMIT ? ELLIPSIS : ''}`, tone: 'value', align: 'start' };
+        case 'binary': {
+            const shown = cell.hex.slice(0, BINARY_PREVIEW_BYTES * 2);
+            const truncated = shown.length < cell.length * 2;
+            return { text: `0x${shown}${truncated ? ELLIPSIS : ''}`, tone: 'value', align: 'start', suffix: formatBytes(cell.length) };
+        }
+    }
+};
+/* The text a copy puts on the clipboard: the value as the cell has it, a preview as far as it goes. */
+export const copyTextOf = (cell) => {
+    if (cell === null) {
+        return 'NULL';
+    }
+    if (typeof cell !== 'object') {
+        return String(cell);
+    }
+    switch (cell.kind) {
+        case 'default':
+            return 'DEFAULT';
+        case 'longText':
+            return cell.preview;
+        case 'binary':
+            return `0x${cell.hex}`;
+    }
+};
+/* An edit as a cell, so the grid draws a pending value the way it draws a loaded one. */
+export const shownOfEdit = (value) => {
+    if (value !== null && typeof value === 'object' && value.kind === 'binary') {
+        const binary = value;
+        return { kind: 'binary', hex: binary.hex, length: binary.hex.length / 2 };
+    }
+    return value;
+};

package/dist/grid/edit-value.d.ts

@@ -0,0 +1,5 @@
+import type { Cell, EditValue, Value, ValueKind } from '../protocol/index.ts';
+export declare const draftOf: (value: Cell | Value | {
+    readonly kind: 'default';
+}) => string;
+export declare const parseDraft: (text: string, kind: ValueKind) => EditValue;

package/dist/grid/edit-value.js

@@ -0,0 +1,55 @@
+/* An empty field means NULL where an empty string cannot be a value of the column. */
+const EMPTY_IS_NULL = new Set(['integer', 'decimal', 'float', 'boolean', 'date', 'time', 'datetime', 'binary']);
+const INTEGER = /^[+-]?\d+$/;
+const HEX = /^0x([0-9a-f]*)$/i;
+/* The text an editor starts with for a value that is whole (a preview has to be loaded first). */
+export const draftOf = (value) => {
+    if (value === null) {
+        return '';
+    }
+    if (typeof value !== 'object') {
+        return String(value);
+    }
+    if (value.kind === 'binary') {
+        return `0x${value.hex}`;
+    }
+    if (value.kind === 'longText') {
+        return value.preview;
+    }
+    return '';
+};
+/* What a person typed, as the value to send. A number the text spells exactly stays a number; anything else goes as text and the server decides. */
+export const parseDraft = (text, kind) => {
+    const trimmed = text.trim();
+    if (trimmed === '' && EMPTY_IS_NULL.has(kind)) {
+        return null;
+    }
+    switch (kind) {
+        case 'integer': {
+            const number = Number(trimmed);
+            return INTEGER.test(trimmed) && Number.isSafeInteger(number) ? number : trimmed;
+        }
+        case 'float': {
+            const number = Number(trimmed);
+            return Number.isFinite(number) ? number : trimmed;
+        }
+        case 'boolean': {
+            const lower = trimmed.toLowerCase();
+            if (lower === 'true' || lower === '1') {
+                return true;
+            }
+            return lower === 'false' || lower === '0' ? false : trimmed;
+        }
+        case 'binary': {
+            const match = HEX.exec(trimmed);
+            return match !== null && match[1].length % 2 === 0 ? { kind: 'binary', hex: match[1].toLowerCase() } : trimmed;
+        }
+        case 'decimal':
+        case 'date':
+        case 'time':
+        case 'datetime':
+            return trimmed;
+        default:
+            return text;
+    }
+};

package/dist/grid/enum-type.d.ts

@@ -0,0 +1,7 @@
+export interface EnumType {
+    readonly kind: 'enum' | 'set';
+    readonly values: readonly string[];
+}
+export declare const parseEnumType: (type: string) => EnumType | null;
+export declare const membersOf: (value: string) => string[];
+export declare const joinMembers: (type: EnumType, members: ReadonlySet<string>) => string;

package/dist/grid/enum-type.js

@@ -0,0 +1,52 @@
+const DECLARATION = /^(enum|set)\s*\(/i;
+/*
+ * The values of a MySQL `enum('a','b')` or `set('a','b')` column type, or `null` for any other type
+ * or a list that does not parse. A quote inside a value is written doubled (`'it''s'`).
+ */
+export const parseEnumType = (type) => {
+    const head = DECLARATION.exec(type.trim());
+    if (head === null) {
+        return null;
+    }
+    const source = type.trim().slice(head[0].length);
+    const values = [];
+    let position = 0;
+    while (position < source.length) {
+        if (source[position] !== "'") {
+            return null;
+        }
+        position++;
+        let value = '';
+        for (;;) {
+            if (position >= source.length) {
+                return null;
+            }
+            if (source[position] === "'") {
+                if (source[position + 1] === "'") {
+                    value += "'";
+                    position += 2;
+                    continue;
+                }
+                position++;
+                break;
+            }
+            value += source[position];
+            position++;
+        }
+        values.push(value);
+        const next = source[position];
+        if (next === ')') {
+            return source.slice(position + 1).trim() === '' ? tidy(head[1], values) : null;
+        }
+        if (next !== ',') {
+            return null;
+        }
+        position++;
+    }
+    return null;
+};
+const tidy = (kind, values) => values.length === 0 ? null : { kind: kind.toLowerCase() === 'set' ? 'set' : 'enum', values };
+/* The members a SET value holds: the text split on commas, empty for the empty set. */
+export const membersOf = (value) => (value === '' ? [] : value.split(','));
+/* A SET value in the order of the column's values, which is the order the server writes it in. */
+export const joinMembers = (type, members) => type.values.filter((value) => members.has(value)).join(',');

package/dist/grid/focused-value.d.ts

@@ -0,0 +1,4 @@
+import { type Value } from '../protocol/index.ts';
+import type { Shown } from './display.ts';
+export declare const wholeValueOf: (cell: Shown) => Value | undefined;
+export declare const previewValueOf: (cell: Shown) => Value;

package/dist/grid/focused-value.js

@@ -0,0 +1,19 @@
+import { valueOfCell } from '../protocol/index.js';
+/* The whole value of a cell, or `undefined` when it is only a preview (or a pending DEFAULT, which holds no value). */
+export const wholeValueOf = (cell) => cell !== null && typeof cell === 'object' && cell.kind === 'default' ? undefined : valueOfCell(cell);
+/* What a cell holds as far as it goes: the whole value, or the preview of a long text or a binary value. */
+export const previewValueOf = (cell) => {
+    const whole = wholeValueOf(cell);
+    if (whole !== undefined) {
+        return whole;
+    }
+    if (cell !== null && typeof cell === 'object') {
+        if (cell.kind === 'longText') {
+            return cell.preview;
+        }
+        if (cell.kind === 'binary') {
+            return { kind: 'binary', hex: cell.hex };
+        }
+    }
+    return null;
+};

package/dist/grid/layout.d.ts

@@ -0,0 +1,22 @@
+export declare const ROW_HEIGHT = 28;
+export declare const HEADER_HEIGHT = 32;
+export declare const MIN_COLUMN_WIDTH = 64;
+export declare const MAX_COLUMN_WIDTH = 320;
+export declare const MAX_RESIZED_WIDTH = 1200;
+export declare const MAX_FIT_WIDTH = 640;
+export declare const OVERSCAN_ROWS = 6;
+export declare const DOUBLE_CLICK_MS = 350;
+export declare const FALLBACK_VIEWPORT_HEIGHT = 600;
+export interface VisibleRange {
+    readonly start: number;
+    readonly end: number;
+}
+export declare const visibleRange: (top: number, height: number, rowHeight: number, count: number, overscan: number) => VisibleRange;
+export declare const scrollToReveal: (start: number, size: number, scroll: number, viewport: number, leading: number) => number;
+export declare const columnOffsets: (widths: readonly number[]) => number[];
+export declare const gutterWidth: (rowCount: number) => number;
+export declare const clampColumnWidth: (width: number) => number;
+export declare const estimateColumnWidth: (header: string, samples: readonly string[], keyed: boolean) => number;
+export declare const fitColumnWidth: (header: string, texts: readonly string[], keyed: boolean) => number;
+export declare const isDoubleClick: (previous: number | null, now: number) => boolean;
+export declare const growWidths: (previous: readonly number[], next: readonly number[]) => number[];

package/dist/grid/layout.js

@@ -0,0 +1,74 @@
+/* The measures of the grid, in whole pixels. Row and header heights are steps of the 4px spacing scale. */
+export const ROW_HEIGHT = 28;
+export const HEADER_HEIGHT = 32;
+export const MIN_COLUMN_WIDTH = 64;
+export const MAX_COLUMN_WIDTH = 320;
+/* How far a drag may widen a column; the estimate stops at `MAX_COLUMN_WIDTH`, a person may go further. */
+export const MAX_RESIZED_WIDTH = 1200;
+/* How wide fitting a column to its content may make it. */
+export const MAX_FIT_WIDTH = 640;
+export const OVERSCAN_ROWS = 6;
+/* Two presses on a resize handle this close are a double click. */
+export const DOUBLE_CLICK_MS = 350;
+/* What a viewport is taken to be until it is measured, so a first paint already holds rows. */
+export const FALLBACK_VIEWPORT_HEIGHT = 600;
+/* A glyph of the 13px mono face is 7.8px wide; a whole pixel on the safe side. */
+const CHARACTER_WIDTH = 8;
+const CELL_PADDING = 24;
+const KEY_ICON_ROOM = 18;
+const GUTTER_MIN_WIDTH = 40;
+const SAMPLE_ROWS = 50;
+/* The arrow and the position number a sorted header carries after its name. */
+const SORT_ROOM = 24;
+/* The rows that touch a viewport of `height` pixels starting `top` pixels into the rows, plus `overscan` rows on both sides. */
+export const visibleRange = (top, height, rowHeight, count, overscan) => {
+    if (count <= 0 || height <= 0) {
+        return { start: 0, end: 0 };
+    }
+    const first = Math.floor(Math.max(0, top) / rowHeight);
+    const last = Math.ceil(Math.max(0, top + height) / rowHeight);
+    return { start: Math.max(0, Math.min(first, count) - overscan), end: Math.min(count, last + overscan) };
+};
+/*
+ * Where to scroll so that an item at `start` that is `size` long is in view. `leading` is the part of
+ * the viewport a sticky header or gutter covers. Returns `scroll` itself when the item is already visible.
+ */
+export const scrollToReveal = (start, size, scroll, viewport, leading) => {
+    if (start < scroll + leading) {
+        return Math.max(0, start - leading);
+    }
+    if (start + size > scroll + viewport) {
+        return Math.max(0, start + size - viewport);
+    }
+    return scroll;
+};
+/* The left edge of every column, counted from the first one. */
+export const columnOffsets = (widths) => {
+    let offset = 0;
+    return widths.map((width) => {
+        const left = offset;
+        offset += width;
+        return left;
+    });
+};
+/* Wide enough for the largest row number, never narrower than `GUTTER_MIN_WIDTH`. */
+export const gutterWidth = (rowCount) => Math.max(GUTTER_MIN_WIDTH, String(Math.max(rowCount, 1)).length * CHARACTER_WIDTH + CELL_PADDING);
+export const clampColumnWidth = (width) => Math.max(MIN_COLUMN_WIDTH, Math.min(Math.ceil(width), MAX_COLUMN_WIDTH));
+/* From the longest text among the header and the first rows. `keyed` makes room for the key icon in front of the name. */
+export const estimateColumnWidth = (header, samples, keyed) => {
+    const body = samples.slice(0, SAMPLE_ROWS).reduce((longest, text) => Math.max(longest, text.length), 0);
+    const named = header.length * CHARACTER_WIDTH + (keyed ? KEY_ICON_ROOM : 0) + SORT_ROOM;
+    return clampColumnWidth(Math.max(body * CHARACTER_WIDTH, named) + CELL_PADDING);
+};
+/* Wide enough for the header and every text of the column, up to `MAX_FIT_WIDTH`. */
+export const fitColumnWidth = (header, texts, keyed) => {
+    const body = texts.reduce((longest, text) => Math.max(longest, text.length), 0) * CHARACTER_WIDTH;
+    const named = header.length * CHARACTER_WIDTH + (keyed ? KEY_ICON_ROOM : 0) + SORT_ROOM;
+    return Math.max(MIN_COLUMN_WIDTH, Math.min(Math.ceil(Math.max(body, named) + CELL_PADDING), MAX_FIT_WIDTH));
+};
+export const isDoubleClick = (previous, now) => previous !== null && now - previous <= DOUBLE_CLICK_MS;
+/*
+ * The estimated widths of a new page, never narrower than they were. A page with longer content widens
+ * a column; a page with shorter content leaves it, so a sort does not make columns jump.
+ */
+export const growWidths = (previous, next) => next.map((width, index) => Math.max(width, previous[index] ?? 0));

package/dist/grid/navigation.d.ts

@@ -0,0 +1,15 @@
+export interface CellPosition {
+    readonly row: number;
+    readonly column: number;
+}
+export interface GridSize {
+    readonly rows: number;
+    readonly columns: number;
+    readonly page: number;
+}
+export interface NavigationKey {
+    readonly key: string;
+    readonly shiftKey: boolean;
+    readonly mod: boolean;
+}
+export declare const moveFocus: (from: CellPosition | null, input: NavigationKey, size: GridSize) => CellPosition | null;

package/dist/grid/navigation.js

@@ -0,0 +1,52 @@
+/* Keys that, with no cell focused yet, only put the focus on the first one. */
+const ENTERING_KEYS = new Set(['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight', 'PageUp', 'PageDown', 'Tab']);
+const clamp = (value, max) => Math.max(0, Math.min(value, max - 1));
+/*
+ * Where a navigation key takes the focus, or `null` when the key moves nothing and the browser should
+ * keep it: that is also how Tab leaves the grid at its first and last cell.
+ */
+export const moveFocus = (from, input, size) => {
+    if (size.rows === 0 || size.columns === 0) {
+        return null;
+    }
+    if (from === null && ENTERING_KEYS.has(input.key)) {
+        return { row: 0, column: 0 };
+    }
+    const lastRow = size.rows - 1;
+    const lastColumn = size.columns - 1;
+    const start = from ?? { row: 0, column: 0 };
+    const row = clamp(start.row, size.rows);
+    const column = clamp(start.column, size.columns);
+    switch (input.key) {
+        case 'ArrowUp':
+            return { row: clamp(row - 1, size.rows), column };
+        case 'ArrowDown':
+            return { row: clamp(row + 1, size.rows), column };
+        case 'ArrowLeft':
+            return { row, column: clamp(column - 1, size.columns) };
+        case 'ArrowRight':
+            return { row, column: clamp(column + 1, size.columns) };
+        case 'PageUp':
+            return { row: clamp(row - size.page, size.rows), column };
+        case 'PageDown':
+            return { row: clamp(row + size.page, size.rows), column };
+        case 'Home':
+            return { row: input.mod ? 0 : row, column: 0 };
+        case 'End':
+            return { row: input.mod ? lastRow : row, column: lastColumn };
+        case 'Tab': {
+            if (input.shiftKey) {
+                if (column > 0) {
+                    return { row, column: column - 1 };
+                }
+                return row > 0 ? { row: row - 1, column: lastColumn } : null;
+            }
+            if (column < lastColumn) {
+                return { row, column: column + 1 };
+            }
+            return row < lastRow ? { row: row + 1, column: 0 } : null;
+        }
+        default:
+            return null;
+    }
+};

package/dist/grid/row-selection.d.ts

@@ -0,0 +1,9 @@
+export interface RowSelection {
+    readonly selected: ReadonlySet<string>;
+    readonly anchor: number;
+}
+export interface RowClick {
+    readonly shiftKey: boolean;
+    readonly mod: boolean;
+}
+export declare const selectRow: (keys: readonly string[], current: ReadonlySet<string>, anchor: number, index: number, click: RowClick) => RowSelection;

package/dist/grid/row-selection.js

@@ -0,0 +1,24 @@
+/*
+ * The selection after a click on the gutter of `index`: a plain click selects that row alone, Mod
+ * toggles it, and Shift selects everything from the anchor to it.
+ */
+export const selectRow = (keys, current, anchor, index, click) => {
+    const key = keys[index];
+    if (key === undefined) {
+        return { selected: current, anchor };
+    }
+    if (click.shiftKey && anchor >= 0 && anchor < keys.length) {
+        const from = Math.min(anchor, index);
+        const to = Math.max(anchor, index);
+        const range = keys.slice(from, to + 1);
+        return { selected: new Set(click.mod ? [...current, ...range] : range), anchor };
+    }
+    if (click.mod) {
+        const next = new Set(current);
+        if (!next.delete(key)) {
+            next.add(key);
+        }
+        return { selected: next, anchor: index };
+    }
+    return { selected: new Set([key]), anchor: index };
+};

package/dist/grid/sort.d.ts

@@ -0,0 +1,7 @@
+import type { ColumnSort, SortDirection } from '../sql.ts';
+export type GridSort = ColumnSort;
+export declare const sortOnly: (column: string, direction: SortDirection) => GridSort[];
+export declare const sortStateOf: (sorts: readonly GridSort[], column: string) => {
+    direction: SortDirection;
+    position: number;
+} | null;

package/dist/grid/sort.js

@@ -0,0 +1,7 @@
+/* The column as the only sort, in a direction a menu picked. */
+export const sortOnly = (column, direction) => [{ column, direction }];
+/* The sort of a column and its place among the sorts counted from one, or `null` when it is not sorted. */
+export const sortStateOf = (sorts, column) => {
+    const index = sorts.findIndex((sort) => sort.column === column);
+    return index < 0 ? null : { direction: sorts[index].direction, position: index + 1 };
+};

package/dist/grid/types.d.ts

@@ -0,0 +1,30 @@
+import type { ColumnInfo, ResultColumn } from '../protocol/index.ts';
+import type { Shown } from './display.ts';
+export interface GridColumn extends ResultColumn {
+    readonly primaryKey?: boolean;
+    readonly nullable?: boolean;
+    readonly readOnly?: boolean;
+    readonly defaultValue?: string | null;
+    readonly autoIncrement?: boolean;
+}
+export type GridRowState = 'inserted' | 'deleted';
+export interface GridRow {
+    readonly key: string;
+    readonly number: number | null;
+    readonly cells: readonly Shown[];
+    readonly state?: GridRowState;
+    readonly edited?: ReadonlySet<number>;
+    readonly locked?: boolean;
+}
+export declare const gridColumnOf: (column: ResultColumn, info: ColumnInfo | undefined, primaryKey: readonly string[]) => GridColumn;
+export interface FocusedCell {
+    readonly rowKey: string;
+    readonly column: number;
+}
+export interface GridMenuContext {
+    readonly rowKeys: readonly string[];
+    readonly cell: FocusedCell | null;
+}
+export interface ColumnRequest {
+    readonly column: number;
+}

package/dist/grid/types.js

@@ -0,0 +1,9 @@
+/* Builds the column of a table from the result column and the structure's column of the same name. */
+export const gridColumnOf = (column, info, primaryKey) => ({
+    ...column,
+    primaryKey: primaryKey.includes(column.name),
+    nullable: info?.nullable,
+    readOnly: info?.generated === true,
+    defaultValue: info?.defaultValue,
+    autoIncrement: info?.autoIncrement
+});

package/dist/host/helper-path.d.ts

@@ -0,0 +1,7 @@
+export interface HelperPathOptions {
+    readonly platform?: string;
+    readonly arch?: string;
+    readonly resolve?: (specifier: string) => string;
+    readonly exists?: (path: string) => boolean;
+}
+export declare const helperPath: ({ platform, arch, resolve, exists }?: HelperPathOptions) => string | null;

package/dist/host/helper-path.js

@@ -0,0 +1,15 @@
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join, sep } from 'node:path';
+export const helperPath = ({ platform = process.platform, arch = process.arch, resolve = (specifier) => createRequire(import.meta.url).resolve(specifier), exists = existsSync } = {}) => {
+    let manifest;
+    try {
+        manifest = resolve(`@adecore/database-${platform}-${arch}/package.json`);
+    }
+    catch {
+        return null;
+    }
+    const binary = join(dirname(manifest), 'bin', platform === 'win32' ? 'adecore-database.exe' : 'adecore-database');
+    const unpacked = binary.replace(`.asar${sep}`, `.asar.unpacked${sep}`);
+    return exists(unpacked) ? unpacked : null;
+};

package/dist/host/host.d.ts

@@ -0,0 +1,2 @@
+import type { DatabaseHost, DatabaseHostOptions } from './types.ts';
+export declare const createDatabaseHost: (options: DatabaseHostOptions) => DatabaseHost;