@dorsk/tsumikit 0.8.1 → 0.9.0

package/dist/query/query.js

@@ -0,0 +1,128 @@
+// ─────────────────────────────────────────────────────────────────────────
+// AST consumers: serialise back to the textual query (for the code editor and
+// the URL), compile to a human-readable SQL-ish WHERE (to prove the filter
+// "properly propagates to backend & database"), and compile to a JS predicate
+// (our fake in-memory backend).
+// ─────────────────────────────────────────────────────────────────────────
+import { filters, freeText } from './ast';
+import { operatorById } from './schema';
+function quoteIfNeeded(v) {
+    return /[\s,()]/.test(v) || v === '' ? `"${v}"` : v;
+}
+/** AST → canonical textual query (round-trips through the parser). */
+export function serialize(q) {
+    const parts = [];
+    for (const f of filters(q))
+        parts.push(serializeFilter(f));
+    const text = freeText(q);
+    if (text)
+        parts.push(text);
+    return parts.join(' ');
+}
+export function serializeFilter(f) {
+    const op = operatorById(f.op);
+    if (!op)
+        return '';
+    if (f.op === 'in')
+        return `${f.field} in (${f.values.map(quoteIfNeeded).join(', ')})`;
+    if (f.op === 'range')
+        return `${f.field}:${quoteIfNeeded(f.values[0])}..${quoteIfNeeded(f.values[1])}`;
+    return `${f.field}${op.code}${quoteIfNeeded(f.values[0] ?? '')}`;
+}
+// ── SQL-ish compiler (illustrative — what the server would emit) ────────────
+const SQL_OP = {
+    eq: '=',
+    ne: '<>',
+    gt: '>',
+    gte: '>=',
+    lt: '<',
+    lte: '<=',
+};
+export function toSql(q, table = 'tracks') {
+    const clauses = [];
+    for (const f of filters(q)) {
+        const col = f.field;
+        const v = (s) => `'${s.replace(/'/g, "''")}'`;
+        switch (f.op) {
+            case 'contains':
+                clauses.push(`${col} ILIKE '%${f.values[0]}%'`);
+                break;
+            case 'not_contains':
+                clauses.push(`${col} NOT ILIKE '%${f.values[0]}%'`);
+                break;
+            case 'in':
+                clauses.push(`${col} IN (${f.values.map(v).join(', ')})`);
+                break;
+            case 'range':
+                clauses.push(`${col} BETWEEN ${v(f.values[0])} AND ${v(f.values[1])}`);
+                break;
+            default:
+                clauses.push(`${col} ${SQL_OP[f.op]} ${v(f.values[0] ?? '')}`);
+        }
+    }
+    const text = freeText(q);
+    if (text)
+        clauses.push(`to_tsvector(title) @@ plainto_tsquery(${`'${text.replace(/'/g, "''")}'`})`);
+    const where = clauses.length ? clauses.join('\n  AND ') : 'TRUE';
+    return `SELECT * FROM ${table}\nWHERE ${where};`;
+}
+function asNumber(v) {
+    if (typeof v === 'number')
+        return v;
+    const s = String(v).trim();
+    // Plain integer/decimal (a year "2000", a play count) — take it literally.
+    // Guard against Date.parse swallowing "2000" as a year-timestamp.
+    if (/^-?\d+(\.\d+)?$/.test(s))
+        return Number(s);
+    const d = Date.parse(s); // real dates like "2021-02-01" compare by epoch ms
+    if (!Number.isNaN(d))
+        return d;
+    return Number(s);
+}
+function matchFilter(f, row) {
+    const cell = row[f.field];
+    const target = f.values[0] ?? '';
+    const cellStr = String(cell ?? '').toLowerCase();
+    switch (f.op) {
+        case 'contains':
+            return cellStr.includes(target.toLowerCase());
+        case 'not_contains':
+            return !cellStr.includes(target.toLowerCase());
+        case 'eq':
+            return cellStr === target.toLowerCase();
+        case 'ne':
+            return cellStr !== target.toLowerCase();
+        case 'in':
+            return f.values.map((x) => x.toLowerCase()).includes(cellStr);
+        case 'range':
+            return asNumber(cell) >= asNumber(f.values[0]) && asNumber(cell) <= asNumber(f.values[1]);
+        case 'gt':
+            return asNumber(cell) > asNumber(target);
+        case 'gte':
+            return asNumber(cell) >= asNumber(target);
+        case 'lt':
+            return asNumber(cell) < asNumber(target);
+        case 'lte':
+            return asNumber(cell) <= asNumber(target);
+        default:
+            return true;
+    }
+}
+export function compilePredicate(q) {
+    const fs = filters(q);
+    const text = freeText(q).toLowerCase();
+    return (row) => {
+        for (const f of fs) {
+            if (f.values.every((v) => v === ''))
+                continue; // ignore incomplete clauses
+            if (!matchFilter(f, row))
+                return false;
+        }
+        if (text) {
+            const hay = Object.values(row).join(' ').toLowerCase();
+            if (!hay.includes(text))
+                return false;
+        }
+        return true;
+    };
+}

package/dist/query/schema.d.ts

@@ -0,0 +1,49 @@
+export type FieldType = 'string' | 'enum' | 'id' | 'date' | 'number' | 'bool';
+/** A comparison operator. `code` is how it serialises in the textual query. */
+export type OperatorId = 'contains' | 'not_contains' | 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'range';
+export interface Operator {
+    id: OperatorId;
+    /** Human label shown in the operator dropdown (YouTrack "一致する" etc.). */
+    label: string;
+    /** Textual form used by the code parser/serialiser, e.g. `>=`, `:`, `!:`. */
+    code: string;
+    /** Types this operator can apply to. */
+    types: FieldType[];
+    /** range/in take two / many values. */
+    arity?: 'one' | 'two' | 'many';
+}
+export declare const OPERATORS: Operator[];
+export interface ValueOption {
+    value: string;
+    label: string;
+    /** Optional secondary line (e.g. an email under a username). */
+    hint?: string;
+}
+/** Resolves candidate values for a field given the user's partial input. */
+export type ValueProvider = (query: string) => ValueOption[] | Promise<ValueOption[]>;
+export interface FieldDef {
+    /** Canonical name, used in the serialised query (e.g. `artist`). */
+    name: string;
+    /** Display label (e.g. `Artist`). */
+    label: string;
+    type: FieldType;
+    /** Alternate spellings accepted by the parser (e.g. `by` → assignee). */
+    aliases?: string[];
+    /** Static options, or omit and supply `provider` for async lookups. */
+    options?: ValueOption[];
+    provider?: ValueProvider;
+    /** Placeholder shown in the value step of the dropdown. */
+    valuePlaceholder?: string;
+}
+export interface Schema {
+    fields: FieldDef[];
+}
+/** Operators legal for a given field, in catalogue order. */
+export declare function operatorsFor(field: FieldDef): Operator[];
+/** The default operator picked when a user selects a field (YouTrack-like). */
+export declare function defaultOperator(field: FieldDef): Operator;
+export declare function findField(schema: Schema, token: string): FieldDef | undefined;
+export declare function operatorByCode(code: string): Operator | undefined;
+export declare function operatorById(id: OperatorId): Operator | undefined;
+/** Resolve a field's value options (sync wrapper that always returns a promise). */
+export declare function resolveValues(field: FieldDef, query: string): Promise<ValueOption[]>;

package/dist/query/schema.js

@@ -0,0 +1,47 @@
+// ─────────────────────────────────────────────────────────────────────────
+// Layer 1 — the schema / field registry.
+//
+// The single source of truth that drives BOTH the autocomplete UI and the
+// backend compiler. For each searchable field we declare its type, aliases,
+// the operators it allows and a value provider (static enum or async lookup).
+// Nothing here is UI: it's plain data a host app supplies.
+// ─────────────────────────────────────────────────────────────────────────
+// The full operator catalogue. The order here is the order shown in dropdowns.
+export const OPERATORS = [
+    { id: 'contains', label: 'includes', code: ':', types: ['string'] },
+    { id: 'not_contains', label: 'does not include', code: '!:', types: ['string'] },
+    { id: 'eq', label: 'is', code: '=', types: ['enum', 'id', 'number', 'bool', 'date'] },
+    { id: 'ne', label: 'is not', code: '!=', types: ['enum', 'id', 'number', 'bool', 'date'] },
+    { id: 'gt', label: 'greater than', code: '>', types: ['number', 'date'] },
+    { id: 'gte', label: 'greater or equal', code: '>=', types: ['number', 'date'] },
+    { id: 'lt', label: 'less than', code: '<', types: ['number', 'date'] },
+    { id: 'lte', label: 'less or equal', code: '<=', types: ['number', 'date'] },
+    { id: 'in', label: 'any of', code: 'in', types: ['enum', 'id'], arity: 'many' },
+    { id: 'range', label: 'in range', code: '..', types: ['date', 'number'], arity: 'two' },
+];
+/** Operators legal for a given field, in catalogue order. */
+export function operatorsFor(field) {
+    return OPERATORS.filter((op) => op.types.includes(field.type));
+}
+/** The default operator picked when a user selects a field (YouTrack-like). */
+export function defaultOperator(field) {
+    return operatorsFor(field)[0];
+}
+export function findField(schema, token) {
+    const t = token.toLowerCase();
+    return schema.fields.find((f) => f.name.toLowerCase() === t || f.aliases?.some((a) => a.toLowerCase() === t));
+}
+export function operatorByCode(code) {
+    return OPERATORS.find((op) => op.code === code);
+}
+export function operatorById(id) {
+    return OPERATORS.find((op) => op.id === id);
+}
+/** Resolve a field's value options (sync wrapper that always returns a promise). */
+export async function resolveValues(field, query) {
+    if (field.provider)
+        return field.provider(query);
+    const opts = field.options ?? [];
+    const q = query.toLowerCase();
+    return q ? opts.filter((o) => o.label.toLowerCase().includes(q)) : opts;
+}

package/dist/query/suggest.d.ts

@@ -0,0 +1,33 @@
+import { type Schema } from './schema';
+export type SuggestKind = 'field' | 'operator' | 'value';
+export interface Suggestion {
+    /** What to show on the row. */
+    label: string;
+    /** Secondary, dimmed line. */
+    hint?: string;
+    /** Right-aligned monospace token (operator code / field name). */
+    code?: string;
+    /** The string to splice into the query when accepted. */
+    insert: string;
+    /** Caret position after the insert (absolute index). */
+    caret: number;
+    /** When true, keep the dropdown open and advance to the next step. */
+    advance?: boolean;
+}
+export interface SuggestState {
+    kind: SuggestKind;
+    /** [start, end) of the token region these suggestions replace. */
+    span: [number, number];
+    items: Suggestion[];
+}
+/** The whitespace-delimited token under the caret (quotes count as non-ws). */
+export declare function activeToken(s: string, pos: number): {
+    start: number;
+    end: number;
+    raw: string;
+};
+/**
+ * Compute the suggestion state for the caret. Value lookups are async (they may
+ * hit the network), so this returns a promise. `null` means "no dropdown".
+ */
+export declare function suggest(schema: Schema, s: string, pos: number): Promise<SuggestState | null>;

package/dist/query/suggest.js

@@ -0,0 +1,125 @@
+// ─────────────────────────────────────────────────────────────────────────
+// Autocomplete engine — the SECOND consumer of the schema (the first is the
+// compiler). Given the raw string + caret position it figures out which of the
+// three YouTrack-style steps we're in (field → operator → value) and produces
+// the suggestion list + the text edit to apply when one is accepted.
+//
+// This is pure logic, deliberately UI-free so the Svelte organism stays dumb.
+// ─────────────────────────────────────────────────────────────────────────
+import { findField, operatorsFor, resolveValues, } from './schema';
+// Longest first so `>=`/`!:` win over `>`/`:`.
+const OP_CODES = ['!:', '!=', '>=', '<=', ':', '=', '>', '<'];
+/** The whitespace-delimited token under the caret (quotes count as non-ws). */
+export function activeToken(s, pos) {
+    let start = pos;
+    while (start > 0 && !/\s/.test(s[start - 1]))
+        start--;
+    let end = pos;
+    while (end < s.length && !/\s/.test(s[end]))
+        end++;
+    return { start, end, raw: s.slice(start, end) };
+}
+/** Split a token into field / operator-code / value parts (earliest op wins). */
+function splitToken(raw) {
+    let best = -1;
+    let bestCode = null;
+    for (const code of OP_CODES) {
+        const idx = raw.indexOf(code);
+        if (idx === -1)
+            continue;
+        // earliest position wins; on a tie the longer code wins (handled by order).
+        if (best === -1 || idx < best) {
+            best = idx;
+            bestCode = code;
+        }
+    }
+    if (bestCode === null)
+        return { field: raw, opCode: null, value: '' };
+    return {
+        field: raw.slice(0, best),
+        opCode: bestCode,
+        value: raw.slice(best + bestCode.length),
+    };
+}
+function unquote(v) {
+    return v.replace(/^["']|["']$/g, '');
+}
+function quoteIfNeeded(v) {
+    return /[\s,()]/.test(v) ? `"${v}"` : v;
+}
+function fieldSuggestions(schema, frag, span) {
+    const q = frag.toLowerCase();
+    const items = schema.fields
+        .filter((f) => !q ||
+        f.name.toLowerCase().includes(q) ||
+        f.label.toLowerCase().includes(q) ||
+        f.aliases?.some((a) => a.toLowerCase().includes(q)))
+        .map((f) => {
+        const op = operatorsFor(f)[0];
+        const insert = `${f.name}${op.code}`;
+        return {
+            label: f.label,
+            hint: f.aliases?.length ? `aka ${f.aliases.join(', ')}` : f.type,
+            code: f.name,
+            insert,
+            caret: span[0] + insert.length,
+            advance: true,
+        };
+    });
+    return { kind: 'field', span, items };
+}
+function operatorSuggestions(field, span) {
+    const items = operatorsFor(field).map((op) => {
+        const insert = `${field.name}${op.code}`;
+        return {
+            label: op.label,
+            code: op.code,
+            insert,
+            caret: span[0] + insert.length,
+            advance: true,
+        };
+    });
+    return { kind: 'operator', span, items };
+}
+function buildValueState(field, opCode, span, options) {
+    const items = options.map((o) => {
+        const insert = `${field.name}${opCode}${quoteIfNeeded(o.value)}`;
+        return {
+            label: o.label,
+            hint: o.hint,
+            insert,
+            caret: span[0] + insert.length,
+        };
+    });
+    return { kind: 'value', span, items };
+}
+/**
+ * Compute the suggestion state for the caret. Value lookups are async (they may
+ * hit the network), so this returns a promise. `null` means "no dropdown".
+ */
+export async function suggest(schema, s, pos) {
+    const { start, end, raw } = activeToken(s, pos);
+    const span = [start, end];
+    // Empty caret position (between tokens or empty input) → offer all fields.
+    if (raw === '')
+        return fieldSuggestions(schema, '', span);
+    const { field: fieldFrag, opCode, value } = splitToken(raw);
+    const field = findField(schema, fieldFrag);
+    // No operator typed yet.
+    if (opCode === null) {
+        // Exact field match → it's time to pick an operator.
+        if (field && fieldFrag.toLowerCase() === field.name.toLowerCase()) {
+            return operatorSuggestions(field, span);
+        }
+        // Otherwise we're still completing the field name.
+        return fieldSuggestions(schema, fieldFrag, span);
+    }
+    // Operator present but field unknown → nothing useful to suggest.
+    if (!field)
+        return null;
+    // Operator present → suggest values (async; filtered by what's typed).
+    const opts = await resolveValues(field, unquote(value));
+    if (opts.length === 0)
+        return null;
+    return buildValueState(field, opCode, span, opts);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dorsk/tsumikit",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "Minimal, dependency-free Svelte 5 + pure-CSS UI kit. Token-driven atoms, molecules & layouts with theming out of the box.",
   "type": "module",
   "license": "MIT",