@calliopelabs/ui 0.14.0 → 0.18.0

package/dist/workbench/pending.js

@@ -0,0 +1,207 @@
+/**
+ * The grid's pending changes, as pure data: cell edits, inserted rows and
+ * deleted rows the person has made but not committed. The grid keeps one of
+ * these; the host's `onCommit` receives it as a `ChangeSet` and does the
+ * writing. Generalized from Loadr's data editor (and Chat Studio's fork,
+ * which turned the same model into SQL: `changeSetToSql`).
+ *
+ * Rows are keyed by their source index (`rows[key]`); an inserted row has a
+ * negative key (-1, -2, ...) so it never collides with a source row.
+ */
+import { sqlLiteral, quoteIdentifier } from "./grid-format.js";
+import { isNumericType } from "./grid-model.js";
+export const NO_CHANGES = { rows: new Map(), inserted: 0 };
+function withRow(changes, key, row) {
+    const rows = new Map(changes.rows);
+    if (row)
+        rows.set(key, row);
+    else
+        rows.delete(key);
+    return { ...changes, rows };
+}
+function differs(row) {
+    return Object.keys(row.values).some((c) => !Object.is(row.values[c], row.original[c]));
+}
+/**
+ * Sets one cell. `source` is the row as read (unused for an inserted row).
+ * An edit back to the original value drops the row's entry.
+ */
+export function editCell(changes, key, column, value, source) {
+    const existing = changes.rows.get(key);
+    if (existing?.state === "deleted")
+        return changes;
+    if (existing) {
+        const next = { ...existing, values: { ...existing.values, [column]: value } };
+        return withRow(changes, key, next.state === "modified" && !differs(next) ? null : next);
+    }
+    if (!source || Object.is(source[column], value))
+        return changes;
+    return withRow(changes, key, {
+        state: "modified",
+        original: { ...source },
+        values: { ...source, [column]: value },
+    });
+}
+/** Inserts a row of NULLs, or a copy of `from` (duplicate). Returns the new row's key. */
+export function addRow(changes, columns, from) {
+    const key = -(changes.inserted + 1);
+    const empty = Object.fromEntries(columns.map((c) => [c, null]));
+    const row = {
+        state: "added",
+        original: empty,
+        values: from ? { ...empty, ...from } : { ...empty },
+    };
+    return { changes: { ...withRow(changes, key, row), inserted: changes.inserted + 1 }, key };
+}
+/** Marks rows deleted; an inserted row is simply dropped. */
+export function deleteRows(changes, keys, sourceOf) {
+    let next = changes;
+    for (const key of keys) {
+        const existing = next.rows.get(key);
+        if (existing?.state === "added") {
+            next = withRow(next, key, null);
+            continue;
+        }
+        const source = existing?.original ?? sourceOf(key);
+        if (!source)
+            continue;
+        next = withRow(next, key, {
+            state: "deleted",
+            original: { ...source },
+            values: existing?.values ?? { ...source },
+        });
+    }
+    return next;
+}
+/** Forgets every change to one row (an inserted row disappears). */
+export function revertRow(changes, key) {
+    return changes.rows.has(key) ? withRow(changes, key, null) : changes;
+}
+/** The value a cell shows: the pending value when there is one. */
+export function pendingValue(changes, key, column, source) {
+    const row = changes.rows.get(key);
+    return row ? row.values[column] : source?.[column];
+}
+/** True when the cell will be written: every cell of an inserted row, the edited cells of a modified one. */
+export function isCellChanged(changes, key, column) {
+    const row = changes.rows.get(key);
+    if (!row || row.state === "deleted")
+        return false;
+    return row.state === "added" || !Object.is(row.values[column], row.original[column]);
+}
+/** The keys of the inserted rows, in the order they were added. */
+export function insertedKeys(changes) {
+    return [...changes.rows.entries()]
+        .filter(([, row]) => row.state === "added")
+        .map(([key]) => key)
+        .sort((a, b) => b - a);
+}
+export function pendingCounts(changes) {
+    let inserts = 0;
+    let updates = 0;
+    let deletes = 0;
+    for (const row of changes.rows.values()) {
+        if (row.state === "added")
+            inserts++;
+        else if (row.state === "deleted")
+            deletes++;
+        else if (differs(row))
+            updates++;
+    }
+    return { inserts, updates, deletes, total: inserts + updates + deletes };
+}
+/**
+ * The pending changes as a batch to write. Updates and deletes are keyed on
+ * `primaryKeys`; without one they cannot name a row, and the grid only
+ * offers inserts.
+ */
+export function toChangeSet(changes, options) {
+    const out = { inserts: [], updates: [], deletes: [] };
+    const entries = [...changes.rows.entries()].sort((a, b) => a[0] < 0 && b[0] < 0 ? b[0] - a[0] : a[0] - b[0]);
+    for (const [key, row] of entries) {
+        if (row.state === "added") {
+            const values = {};
+            for (const column of options.columns) {
+                const value = row.values[column];
+                if (value === undefined || (value === null && row.original[column] === null))
+                    continue;
+                values[column] = value;
+            }
+            out.inserts.push({ key, values });
+            continue;
+        }
+        const primaryKey = Object.fromEntries(options.primaryKeys.map((pk) => [pk, row.original[pk]]));
+        if (row.state === "deleted") {
+            out.deletes.push({ key, primaryKey });
+            continue;
+        }
+        const values = {};
+        const expected = {};
+        for (const column of options.columns) {
+            if (Object.is(row.values[column], row.original[column]))
+                continue;
+            values[column] = row.values[column];
+            const old = row.original[column];
+            if (old === null || typeof old !== "object")
+                expected[column] = old;
+        }
+        if (Object.keys(values).length > 0)
+            out.updates.push({ key, primaryKey, values, expected });
+    }
+    return out;
+}
+/**
+ * A change set as SQL statements, for a host that runs SQL rather than an
+ * apply endpoint: INSERT, UPDATE ... WHERE <primary key>, DELETE ... WHERE
+ * <primary key>. Literals are quoted by `sqlLiteral`; dialect differences
+ * beyond ANSI quoting are the host's.
+ */
+export function changeSetToSql(changeSet, options) {
+    const table = quoteIdentifier(options.table);
+    const where = (primaryKey) => Object.entries(primaryKey)
+        .map(([c, v]) => v === null || v === undefined
+        ? `${quoteIdentifier(c)} IS NULL`
+        : `${quoteIdentifier(c)} = ${sqlLiteral(v)}`)
+        .join(" AND ");
+    const statements = [];
+    for (const insert of changeSet.inserts) {
+        const cols = Object.keys(insert.values);
+        statements.push(cols.length === 0
+            ? `INSERT INTO ${table} DEFAULT VALUES;`
+            : `INSERT INTO ${table} (${cols.map(quoteIdentifier).join(", ")}) VALUES (${cols
+                .map((c) => sqlLiteral(insert.values[c]))
+                .join(", ")});`);
+    }
+    for (const update of changeSet.updates) {
+        const set = Object.entries(update.values)
+            .map(([c, v]) => `${quoteIdentifier(c)} = ${sqlLiteral(v)}`)
+            .join(", ");
+        statements.push(`UPDATE ${table} SET ${set} WHERE ${where(update.primaryKey)};`);
+    }
+    for (const del of changeSet.deletes) {
+        statements.push(`DELETE FROM ${table} WHERE ${where(del.primaryKey)};`);
+    }
+    return statements;
+}
+/**
+ * What a typed cell means: empty or "NULL" is NULL; a number or boolean
+ * column (by its type, or the original value's) keeps its type when the
+ * text parses as one.
+ */
+export function parseCellInput(text, original, type) {
+    if (text === "" || text.toUpperCase() === "NULL")
+        return null;
+    if (typeof original === "number" || (type !== undefined && isNumericType(type))) {
+        const num = Number(text);
+        if (text.trim() !== "" && !Number.isNaN(num))
+            return num;
+    }
+    if (typeof original === "boolean" || type === "boolean") {
+        const lower = text.toLowerCase();
+        if (lower === "true" || text === "1")
+            return true;
+        if (lower === "false" || text === "0")
+            return false;
+    }
+    return text;
+}

package/dist/workbench/selection.d.ts

@@ -0,0 +1,16 @@
+export type SelectMode = "replace" | "toggle" | "range";
+/**
+ * Finder-style selection over an ordered listing: a plain click or arrow
+ * selects one, Cmd or Ctrl toggles, Shift selects the range from the
+ * anchor (the last item chosen without Shift). The set is the host's.
+ */
+export declare function useSelectionModel(order: readonly string[], selection: ReadonlySet<string>, onSelectionChange: (next: Set<string>) => void): {
+    select(path: string, mode: SelectMode): void;
+    selectAll(): void;
+    clear(): void;
+};
+export declare function modeOf(event: {
+    shiftKey: boolean;
+    metaKey: boolean;
+    ctrlKey: boolean;
+}): SelectMode;

package/dist/workbench/selection.js

@@ -0,0 +1,46 @@
+"use client";
+import * as React from "react";
+/**
+ * Finder-style selection over an ordered listing: a plain click or arrow
+ * selects one, Cmd or Ctrl toggles, Shift selects the range from the
+ * anchor (the last item chosen without Shift). The set is the host's.
+ */
+export function useSelectionModel(order, selection, onSelectionChange) {
+    const anchor = React.useRef(null);
+    return React.useMemo(() => ({
+        select(path, mode) {
+            if (mode === "range") {
+                const from = order.indexOf(anchor.current ?? path);
+                const to = order.indexOf(path);
+                const [a, b] = from < 0 ? [to, to] : from < to ? [from, to] : [to, from];
+                onSelectionChange(new Set(order.slice(a, b + 1)));
+                return;
+            }
+            anchor.current = path;
+            if (mode === "toggle") {
+                const next = new Set(selection);
+                if (next.has(path))
+                    next.delete(path);
+                else
+                    next.add(path);
+                onSelectionChange(next);
+            }
+            else
+                onSelectionChange(new Set([path]));
+        },
+        selectAll() {
+            onSelectionChange(new Set(order));
+        },
+        clear() {
+            anchor.current = null;
+            onSelectionChange(new Set());
+        },
+    }), [order, selection, onSelectionChange]);
+}
+export function modeOf(event) {
+    if (event.shiftKey)
+        return "range";
+    if (event.metaKey || event.ctrlKey)
+        return "toggle";
+    return "replace";
+}

package/dist/workbench/sql-completion.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Schema-aware SQL completion, without Monaco: what to suggest at a cursor,
+ * given the text and a host-provided schema. `SqlEditor` turns the result
+ * into Monaco completion items; anything else (a plain textarea, a test) can
+ * use it as it is. Pure.
+ */
+export interface SqlColumn {
+    name: string;
+    type?: string;
+    nullable?: boolean;
+}
+export interface SqlTable {
+    name: string;
+    /** The schema it lives in, when the database has several. */
+    schema?: string;
+    /** Leave out while unknown; the host can load it on `onSchemaRequest`. */
+    columns?: readonly SqlColumn[];
+}
+/** What the editor knows about the database the query runs against. */
+export interface SqlSchema {
+    tables: readonly SqlTable[];
+    /** Schema names on this database, for `schema.` completion. */
+    schemas?: readonly string[];
+    /** Other databases on the same server, for `USE` and `db.` completion. */
+    databases?: readonly string[];
+    /** Tables of other databases, by database name, once the host has them. */
+    otherDatabases?: Readonly<Record<string, readonly SqlTable[]>>;
+}
+/** Something the completion wanted but the schema does not have yet. */
+export type SqlSchemaRequest = {
+    kind: "columns";
+    table: string;
+    schema?: string;
+} | {
+    kind: "database";
+    database: string;
+};
+export type SqlCompletionKind = "keyword" | "function" | "snippet" | "table" | "column" | "schema" | "database";
+export interface SqlCompletion {
+    label: string;
+    kind: SqlCompletionKind;
+    insertText: string;
+    /** `insertText` is a snippet with `${1:placeholder}` stops. */
+    snippet?: boolean;
+    detail?: string;
+    /** Lower sorts first. */
+    sortText: string;
+}
+export declare const SQL_KEYWORDS: readonly ["SELECT", "FROM", "WHERE", "AND", "OR", "NOT", "IN", "BETWEEN", "LIKE", "IS", "NULL", "AS", "ON", "JOIN", "INNER", "LEFT", "RIGHT", "FULL", "OUTER", "CROSS", "GROUP BY", "ORDER BY", "HAVING", "LIMIT", "OFFSET", "UNION", "ALL", "DISTINCT", "INSERT INTO", "VALUES", "UPDATE", "SET", "DELETE", "CREATE TABLE", "ALTER TABLE", "DROP TABLE", "CREATE INDEX", "DROP INDEX", "TRUNCATE", "EXISTS", "CASE", "WHEN", "THEN", "ELSE", "END", "CAST", "COALESCE", "NULLIF", "WITH", "RECURSIVE", "ASC", "DESC", "TRUE", "FALSE", "DEFAULT", "PRIMARY KEY", "FOREIGN KEY", "REFERENCES", "CONSTRAINT", "UNIQUE", "CHECK", "INDEX", "USE", "FETCH FIRST", "ROWS ONLY", "PERCENT", "TOP", "WINDOW"];
+export declare const SQL_FUNCTIONS: readonly ["COUNT", "SUM", "AVG", "MIN", "MAX", "ROUND", "UPPER", "LOWER", "TRIM", "LENGTH", "SUBSTRING", "REPLACE", "CONCAT", "NOW", "CURRENT_TIMESTAMP", "CURRENT_DATE", "DATE", "EXTRACT", "COALESCE", "NULLIF", "CAST", "CONVERT", "ROW_NUMBER", "RANK", "DENSE_RANK", "LAG", "LEAD", "FIRST_VALUE", "LAST_VALUE", "NTILE", "PERCENT_RANK", "CUME_DIST", "NTH_VALUE", "ARRAY_AGG", "STRING_AGG", "JSON_AGG", "JSONB_AGG", "ABS", "CEIL", "FLOOR", "MOD", "POWER", "SQRT", "LOG", "EXP", "LEFT", "RIGHT", "LPAD", "RPAD", "LTRIM", "RTRIM", "REVERSE", "DATE_TRUNC", "DATE_PART", "AGE", "INTERVAL", "TO_CHAR", "TO_DATE", "TO_NUMBER", "TO_TIMESTAMP", "GREATEST", "LEAST", "GENERATE_SERIES"];
+/** Case-insensitive substring match; an empty input matches everything. */
+export declare function sqlMatch(input: string, candidate: string): boolean;
+export type SqlCursorContext = {
+    context: "table" | "column" | "database" | "general";
+} | {
+    context: "dot";
+    prefix: string;
+    word: string;
+};
+/** What the cursor is in, from the text before it: after FROM, after SELECT, after `alias.`. */
+export declare function sqlCursorContext(textBeforeCursor: string): SqlCursorContext;
+/**
+ * The statement around `offset` in a buffer of several. Semicolons inside
+ * string literals and line comments do not split, so aliases resolve against
+ * the statement being written, never an earlier one.
+ */
+export declare function statementAt(text: string, offset: number): string;
+export interface SqlTableRef {
+    /** Lower-cased. */
+    table: string;
+    schema?: string;
+    alias?: string;
+}
+/** The tables a statement's FROM, JOIN, UPDATE and INTO name, with their aliases. */
+export declare function extractTableRefs(statement: string): SqlTableRef[];
+export type SqlDotTarget = {
+    kind: "columns";
+    table: string;
+} | {
+    kind: "schema";
+    schema: string;
+} | {
+    kind: "database";
+    database: string;
+} | {
+    kind: "unknown";
+};
+/**
+ * What `prefix.` refers to: an alias in this statement first, then a table
+ * the statement names, a known table, a known schema, a known database. An
+ * unrecognised prefix is unknown, and nothing should be requested for it.
+ */
+export declare function resolveSqlDot(prefix: string, statement: string, schema: SqlSchema): SqlDotTarget;
+/** Column names that more than one table has, which completion qualifies. */
+export declare function ambiguousColumns(tables: readonly SqlTable[]): Set<string>;
+/** True when a statement changes the schema, so a host's cached schema is stale. */
+export declare function isDdlStatement(sql: string): boolean;
+export interface SqlCompletionResult {
+    items: SqlCompletion[];
+    /** Ask the host for these, so the next keystroke can offer them. */
+    requests: SqlSchemaRequest[];
+}
+/**
+ * The completions at `offset` in `text`, from the schema the host gave.
+ * Never waits for anything: what the schema lacks comes back as `requests`.
+ */
+export declare function sqlCompletions(text: string, offset: number, schema: SqlSchema): SqlCompletionResult;