@dorsk/tsumikit 0.9.0 → 0.9.2

package/dist/query/schema.d.ts

@@ -32,13 +32,24 @@ export interface FieldDef {
     /** Static options, or omit and supply `provider` for async lookups. */
     options?: ValueOption[];
     provider?: ValueProvider;
+    /**
+     * Restrict the operators offered for this field to exactly this set (in
+     * catalogue order). When omitted, all operators legal for the field's `type`
+     * are offered. Use this to mirror a backend registry's per-field whitelist so
+     * the dropdown — and the parser's legal-op check — match what the server
+     * actually accepts.
+     */
+    operators?: OperatorId[];
     /** 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. */
+/** Operators legal for a given field, in catalogue order. When the field
+ *  declares an explicit `operators` whitelist that takes precedence over the
+ *  type-derived set (the whitelist is authoritative); otherwise every operator
+ *  legal for the field's `type` is returned. */
 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;

package/dist/query/schema.js

@@ -19,8 +19,15 @@ export const OPERATORS = [
     { 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. */
+/** Operators legal for a given field, in catalogue order. When the field
+ *  declares an explicit `operators` whitelist that takes precedence over the
+ *  type-derived set (the whitelist is authoritative); otherwise every operator
+ *  legal for the field's `type` is returned. */
 export function operatorsFor(field) {
+    if (field.operators) {
+        const allow = new Set(field.operators);
+        return OPERATORS.filter((op) => allow.has(op.id));
+    }
     return OPERATORS.filter((op) => op.types.includes(field.type));
 }
 /** The default operator picked when a user selects a field (YouTrack-like). */

package/dist/query/suggest.d.ts

@@ -20,7 +20,13 @@ export interface SuggestState {
     span: [number, number];
     items: Suggestion[];
 }
-/** The whitespace-delimited token under the caret (quotes count as non-ws). */
+/**
+ * The token under the caret. Whitespace ends a token EXCEPT inside an open
+ * quote, so a quoted value containing spaces (`album:"ok computer`) stays one
+ * token and keeps the caret in the value step rather than collapsing to an
+ * empty token (which would wrongly re-offer fields). A closed quote followed by
+ * whitespace starts a fresh token (so the next `field:` can be chained).
+ */
 export declare function activeToken(s: string, pos: number): {
     start: number;
     end: number;

package/dist/query/suggest.js

@@ -9,14 +9,49 @@
 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). */
+/**
+ * The token under the caret. Whitespace ends a token EXCEPT inside an open
+ * quote, so a quoted value containing spaces (`album:"ok computer`) stays one
+ * token and keeps the caret in the value step rather than collapsing to an
+ * empty token (which would wrongly re-offer fields). A closed quote followed by
+ * whitespace starts a fresh token (so the next `field:` can be chained).
+ */
 export function activeToken(s, pos) {
-    let start = pos;
-    while (start > 0 && !/\s/.test(s[start - 1]))
-        start--;
+    // Walk from the start so we can track quote state; the last unquoted
+    // whitespace before the caret is the token boundary.
+    let start = 0;
+    let inQuote = false;
+    let q = '';
+    for (let i = 0; i < pos; i++) {
+        const c = s[i];
+        if (inQuote) {
+            if (c === q)
+                inQuote = false;
+        }
+        else if (c === '"' || c === "'") {
+            inQuote = true;
+            q = c;
+        }
+        else if (/\s/.test(c)) {
+            start = i + 1;
+        }
+    }
+    // Extend forward through the rest of the token, still respecting quotes.
     let end = pos;
-    while (end < s.length && !/\s/.test(s[end]))
-        end++;
+    for (let i = pos; i < s.length; i++) {
+        const c = s[i];
+        if (!inQuote && /\s/.test(c))
+            break;
+        if (inQuote) {
+            if (c === q)
+                inQuote = false;
+        }
+        else if (c === '"' || c === "'") {
+            inQuote = true;
+            q = c;
+        }
+        end = i + 1;
+    }
     return { start, end, raw: s.slice(start, end) };
 }
 /** Split a token into field / operator-code / value parts (earliest op wins). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dorsk/tsumikit",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "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",