@dorsk/tsumikit 0.72.0 → 0.73.0

package/dist/media-time.js

@@ -0,0 +1,25 @@
+/** Seconds as `m:ss`, or `h:mm:ss` once the value (or `ref`) reaches an hour. */
+export function formatMediaTime(seconds, ref = seconds) {
+    if (!Number.isFinite(seconds))
+        return '--:--';
+    const neg = seconds < 0;
+    const total = Math.floor(Math.abs(seconds));
+    const h = Math.floor(total / 3600);
+    const m = Math.floor((total % 3600) / 60);
+    const s = total % 60;
+    const pad = (n) => String(n).padStart(2, '0');
+    const hours = h > 0 || (Number.isFinite(ref) && Math.abs(ref) >= 3600);
+    const body = hours ? `${h}:${pad(m)}:${pad(s)}` : `${m}:${pad(s)}`;
+    return neg ? `-${body}` : body;
+}
+/** True when a duration cannot be scrubbed: unknown, live, or empty. */
+export function isLiveDuration(duration) {
+    return duration == null || !Number.isFinite(duration) || duration <= 0;
+}
+/** Spoken position: "1:02 of 23:45", or just the position when live. */
+export function describeMediaTime(value, duration, format = formatMediaTime) {
+    if (isLiveDuration(duration))
+        return format(value);
+    const d = duration;
+    return `${format(value, d)} of ${format(d, d)}`;
+}

package/dist/query/edit.js

@@ -8,6 +8,7 @@
 // step opens, so spaces land inside the quotes — the already-supported phrase
 // form — without any grammar change. UI-free and framework-agnostic.
 // ─────────────────────────────────────────────────────────────────────────
+import { openQuoteAt } from './quotes';
 import { findField } from './schema';
 // A field name immediately followed by a string operator (`:` contains / `!:`
 // not-contains), anchored at the caret.
@@ -32,22 +33,6 @@ export function autoQuoteEdit(schema, value, pos) {
         return null;
     return { value: `${value.slice(0, pos)}""${value.slice(pos)}`, pos: pos + 1 };
 }
-// Scan from the start tracking quote state (spaces inside quotes are NOT
-// boundaries), so the caret's quote context is correct even for `"star wars"`.
-function openQuoteAt(value, pos) {
-    let quote = null;
-    for (let i = 0; i < pos; i++) {
-        const c = value[i];
-        if (quote) {
-            if (c === quote)
-                quote = null;
-        }
-        else if (isQuote(c)) {
-            quote = c;
-        }
-    }
-    return quote;
-}
 /** True when the caret sits inside an open quote. */
 export function insideQuoteAtCaret(value, pos) {
     return openQuoteAt(value, pos) !== null;

package/dist/query/parser.js

@@ -21,11 +21,16 @@
 //   genre in (house, techno)    → any of
 //   year..2021..2024            → range  (field..a..b)  also  field:a..b
 //   free floating words         → TextNode (full-text)
+//   "daft punk"                 → one TextNode phrase (quotes stripped)
+//
+// `..` only splits a value on fields that accept the range operator, so
+// `cwd:../foo` stays one string. Inside quotes `\"` and `\\` are escapes.
 //
 // Error recovery: unmatched `)` is ignored, a missing `)` closes at end of
 // input, a dangling AND/OR/NOT with no operand collapses to its operand, and an
 // empty group yields nothing. The parser never throws.
 // ─────────────────────────────────────────────────────────────────────────
+import { readQuoted } from './quotes';
 import { findField, operatorByCode, operatorsFor } from './schema';
 const IDENT = /[A-Za-z_][\w-]*/y;
 // Longest operator codes first so `>=` wins over `>`.
@@ -41,18 +46,16 @@ function skipWsInline(sc) {
     while (sc.i < sc.s.length && (sc.s[sc.i] === ' ' || sc.s[sc.i] === '\t'))
         sc.i++;
 }
-/** Read a value token: a "quoted string", or a bare run up to whitespace. */
-function readValue(sc) {
+/**
+ * Read a value token: a "quoted string", or a bare run up to whitespace. With
+ * `range` the bare run also stops at `..` so `a..b` splits into two values.
+ */
+function readValue(sc, range = false) {
     skipWsInline(sc);
     if (sc.s[sc.i] === '"' || sc.s[sc.i] === "'") {
-        const quote = sc.s[sc.i];
-        const start = ++sc.i;
-        while (sc.i < sc.s.length && sc.s[sc.i] !== quote)
-            sc.i++;
-        const value = sc.s.slice(start, sc.i);
-        if (sc.s[sc.i] === quote)
-            sc.i++; // consume closing quote
-        return { value, end: sc.i };
+        const { value, end } = readQuoted(sc.s, sc.i);
+        sc.i = end;
+        return { value, end };
     }
     const start = sc.i;
     while (sc.i < sc.s.length &&
@@ -60,8 +63,7 @@ function readValue(sc) {
         sc.s[sc.i] !== ',' &&
         sc.s[sc.i] !== ')' &&
         sc.s[sc.i] !== '(' &&
-        // stop at a `..` range separator so `a..b` splits into two values
-        !sc.s.startsWith('..', sc.i))
+        !(range && sc.s.startsWith('..', sc.i)))
         sc.i++;
     return { value: sc.s.slice(start, sc.i), end: sc.i };
 }
@@ -99,8 +101,41 @@ function peekKeyword(sc) {
 }
 export function parse(input, schema) {
     const sc = { s: input, i: 0 };
-    const root = parseOr(sc, schema);
-    return { root };
+    const pieces = [];
+    for (;;) {
+        const before = sc.i;
+        const node = parseOr(sc, schema);
+        if (node)
+            pieces.push(node);
+        skipWs(sc);
+        if (sc.i >= sc.s.length)
+            break;
+        if (sc.s[sc.i] === ')')
+            sc.i++;
+        else if (sc.i === before)
+            break;
+    }
+    return { root: joinAnd(pieces) };
+}
+/** AND the top-level pieces left around stray `)` as if the paren were not there. */
+function joinAnd(pieces) {
+    const children = [];
+    for (const piece of pieces) {
+        for (const node of piece.kind === 'and' ? piece.children : [piece]) {
+            const last = children[children.length - 1];
+            if (node.kind === 'text' && last?.kind === 'text') {
+                last.value += ` ${node.value}`;
+                last.span[1] = node.span[1];
+            }
+            else
+                children.push(node);
+        }
+    }
+    if (children.length === 0)
+        return null;
+    if (children.length === 1)
+        return children[0];
+    return { kind: 'and', children };
 }
 // orExpr := andExpr ( OR andExpr )*
 function parseOr(sc, schema) {
@@ -218,8 +253,15 @@ function readLeaf(sc, schema) {
                 return node;
         }
     }
-    // Fallback: consume one word (up to whitespace or a paren) as free text.
+    // Fallback: a "quoted phrase", or one word (up to whitespace or a paren), as free text.
     const wStart = sc.i;
+    if (sc.s[sc.i] === '"') {
+        const { value, end } = readQuoted(sc.s, sc.i);
+        sc.i = end;
+        if (!value)
+            return null;
+        return { kind: 'text', value, span: [wStart, end] };
+    }
     while (sc.i < sc.s.length && !/\s/.test(sc.s[sc.i]) && sc.s[sc.i] !== '(' && sc.s[sc.i] !== ')')
         sc.i++;
     const word = sc.s.slice(wStart, sc.i);
@@ -270,21 +312,19 @@ function readFilter(sc, field, clauseStart, opPos, opMatch, inKeyword) {
         return null;
     }
     sc.i = opPos + opMatch.len;
-    const first = readValue(sc);
+    const rangeOp = legal.find((o) => o.id === 'range');
+    const first = readValue(sc, !!rangeOp);
     // Range form: a..b
-    if (sc.s.startsWith('..', sc.i)) {
+    if (rangeOp && sc.s.startsWith('..', sc.i)) {
         sc.i += 2;
-        const second = readValue(sc);
-        const rangeOp = operatorsFor(field).find((o) => o.id === 'range');
-        if (rangeOp) {
-            return {
-                kind: 'filter',
-                field: field.name,
-                op: 'range',
-                values: [first.value, second.value],
-                span: [clauseStart, sc.i],
-            };
-        }
+        const second = readValue(sc, true);
+        return {
+            kind: 'filter',
+            field: field.name,
+            op: 'range',
+            values: [first.value, second.value],
+            span: [clauseStart, sc.i],
+        };
     }
     return {
         kind: 'filter',

package/dist/query/query.js

@@ -5,9 +5,10 @@
 // (our fake in-memory backend). All three walk the boolean expression tree with
 // correct precedence / grouping / short-circuiting.
 // ─────────────────────────────────────────────────────────────────────────
+import { quote, quoteIfNeeded } from './quotes';
 import { operatorById } from './schema';
-function quoteIfNeeded(v) {
-    return /[\s,()]/.test(v) || v === '' ? `"${v}"` : v;
+function quoteText(v) {
+    return /[()"]|^'/.test(v) ? quote(v) : v;
 }
 // ── Serialiser (AST → canonical textual query, round-trips through parse) ────
 /** Precedence rank: higher binds tighter. Leaves are atomic. */
@@ -33,7 +34,7 @@ function serializeBare(node) {
         case 'filter':
             return serializeFilter(node);
         case 'text':
-            return node.value;
+            return quoteText(node.value);
         case 'not':
             // Child must bind at least as tight as NOT, else parenthesise.
             return `NOT ${serializeNode(node.child, 3)}`;
@@ -70,13 +71,16 @@ const SQL_OP = {
 function sqlLiteral(s) {
     return `'${s.replace(/'/g, "''")}'`;
 }
+function sqlLike(v) {
+    return `${sqlLiteral(`%${v.replace(/[\\%_]/g, '\\$&')}%`)} ESCAPE '\\'`;
+}
 function filterToSql(f) {
     const col = f.field;
     switch (f.op) {
         case 'contains':
-            return `${col} ILIKE '%${f.values[0]}%'`;
+            return `${col} ILIKE ${sqlLike(f.values[0] ?? '')}`;
         case 'not_contains':
-            return `${col} NOT ILIKE '%${f.values[0]}%'`;
+            return `${col} NOT ILIKE ${sqlLike(f.values[0] ?? '')}`;
         case 'in':
             return `${col} IN (${f.values.map(sqlLiteral).join(', ')})`;
         case 'range':

package/dist/query/quotes.d.ts

@@ -0,0 +1,24 @@
+export declare const QUOTES: Set<string>;
+export declare function isBoundary(c: string | undefined): boolean;
+/** True when a quote character at index `i` of `s` opens a quoted string. */
+export declare function quoteOpensAt(s: string, i: number): boolean;
+/**
+ * Walk `s` up to `end` tracking quote state; returns the quote character still
+ * open at `end`, or null. Escaped quotes do not close the string.
+ */
+export declare function openQuoteAt(s: string, end: number): string | null;
+/**
+ * Read a quoted string starting at the opening quote `s[start]`. Returns the
+ * unescaped value and the index just past the closing quote (or the end of
+ * input when it is missing).
+ */
+export declare function readQuoted(s: string, start: number): {
+    value: string;
+    end: number;
+};
+/** Wrap `v` in double quotes, escaping what the reader needs to see escaped. */
+export declare function quote(v: string): string;
+/** Quote a value unless it survives the parser bare. */
+export declare function quoteIfNeeded(v: string): string;
+/** Strip surrounding quotes (a missing closing quote is tolerated) and unescape. */
+export declare function unquote(v: string): string;

package/dist/query/quotes.js

@@ -0,0 +1,78 @@
+// Quoting rules shared by the parser, the serialiser and the editor helpers.
+//
+// A quote opens a string only where a value may start: at the start of a token
+// or right after an operator (`title:"…"`). `"` also opens a free-text phrase at
+// a token start; `'` does not, so `don't` and `'tis` stay plain words. Inside a
+// quoted string `\"` (or `\'` under `'`) and `\\` are escapes; any other
+// backslash is literal, so `"C:\foo"` keeps its backslash.
+export const QUOTES = new Set(['"', "'"]);
+const OP_TAIL = new Set([':', '=', '<', '>']);
+export function isBoundary(c) {
+    return c === undefined || /\s/.test(c) || c === '(' || c === ')' || c === ',';
+}
+/** True when a quote character at index `i` of `s` opens a quoted string. */
+export function quoteOpensAt(s, i) {
+    const c = s[i];
+    if (!QUOTES.has(c))
+        return false;
+    const prev = s[i - 1];
+    if (OP_TAIL.has(prev))
+        return true;
+    return c === '"' && isBoundary(prev);
+}
+/**
+ * Walk `s` up to `end` tracking quote state; returns the quote character still
+ * open at `end`, or null. Escaped quotes do not close the string.
+ */
+export function openQuoteAt(s, end) {
+    let quote = null;
+    for (let i = 0; i < end; i++) {
+        const c = s[i];
+        if (quote) {
+            if (c === '\\' && (s[i + 1] === quote || s[i + 1] === '\\'))
+                i++;
+            else if (c === quote)
+                quote = null;
+        }
+        else if (quoteOpensAt(s, i)) {
+            quote = c;
+        }
+    }
+    return quote;
+}
+/**
+ * Read a quoted string starting at the opening quote `s[start]`. Returns the
+ * unescaped value and the index just past the closing quote (or the end of
+ * input when it is missing).
+ */
+export function readQuoted(s, start) {
+    const quote = s[start];
+    let value = '';
+    let i = start + 1;
+    while (i < s.length && s[i] !== quote) {
+        if (s[i] === '\\' && (s[i + 1] === quote || s[i + 1] === '\\'))
+            i++;
+        value += s[i];
+        i++;
+    }
+    if (s[i] === quote)
+        i++;
+    return { value, end: i };
+}
+/** Wrap `v` in double quotes, escaping what the reader needs to see escaped. */
+export function quote(v) {
+    const full = /\\\\|\\"|\\$/.test(v);
+    const body = (full ? v.replace(/\\/g, '\\\\') : v).replace(/"/g, '\\"');
+    return `"${body}"`;
+}
+const NEEDS_QUOTE = /[\s,()"]|\.\.|^'/;
+/** Quote a value unless it survives the parser bare. */
+export function quoteIfNeeded(v) {
+    return v === '' || NEEDS_QUOTE.test(v) ? quote(v) : v;
+}
+/** Strip surrounding quotes (a missing closing quote is tolerated) and unescape. */
+export function unquote(v) {
+    if (!QUOTES.has(v[0]))
+        return v;
+    return readQuoted(v, 0).value;
+}

package/dist/query/single.js

@@ -4,10 +4,8 @@
 // the field's own provider, and the equivalent query is synthesised only for
 // the `inline` / `below` snippets and the `onchange` AST.
 // ─────────────────────────────────────────────────────────────────────────
+import { quoteIfNeeded } from './quotes';
 import { defaultOperator, findField, resolveValues } from './schema';
-function quoteIfNeeded(v) {
-    return /[\s,()]/.test(v) ? `"${v}"` : v;
-}
 /**
  * The textual query a bare `value` stands for, using `key`'s default operator —
  * `"/srv/my app"` under key `cwd` becomes `cwd:"/srv/my app"`. Empty values (and

package/dist/query/suggest.js

@@ -6,6 +6,7 @@
 //
 // This is pure logic, deliberately UI-free so the Svelte organism stays dumb.
 // ─────────────────────────────────────────────────────────────────────────
+import { quoteIfNeeded, quoteOpensAt, unquote } from './quotes';
 import { findField, operatorsFor, resolveValues, } from './schema';
 // Longest first so `>=`/`!:` win over `>`/`:`.
 const OP_CODES = ['!:', '!=', '>=', '<=', ':', '=', '>', '<'];
@@ -15,46 +16,44 @@ const OP_CODES = ['!:', '!=', '>=', '<=', ':', '=', '>', '<'];
  * (`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). Breaking on parens means `(artist:` offers operators for a clean
- * `artist`, and autocomplete fires at the right spot inside a group.
+ * `artist`, and autocomplete fires at the right spot inside a group. A quote
+ * only opens where a value can start, so `don't` is a plain word.
  */
-function isBoundary(c) {
+function isTokenBoundary(c) {
     return /\s/.test(c) || c === '(' || c === ')';
 }
 export function activeToken(s, pos) {
-    // Walk from the start so we can track quote state; the last unquoted
-    // boundary before the caret is the token start.
     let start = 0;
-    let inQuote = false;
-    let q = '';
-    for (let i = 0; i < pos; i++) {
+    let q = null;
+    const step = (i) => {
         const c = s[i];
-        if (inQuote) {
+        if (q) {
+            if (c === '\\' && (s[i + 1] === q || s[i + 1] === '\\'))
+                return i + 2;
             if (c === q)
-                inQuote = false;
+                q = null;
         }
-        else if (c === '"' || c === "'") {
-            inQuote = true;
+        else if (quoteOpensAt(s, i)) {
             q = c;
         }
-        else if (isBoundary(c)) {
+        else if (isTokenBoundary(c)) {
             start = i + 1;
         }
-    }
+        return i + 1;
+    };
+    // Walk from the start so we can track quote state; the last unquoted
+    // boundary before the caret is the token start.
+    let i = 0;
+    while (i < pos)
+        i = step(i);
     // Extend forward through the rest of the token, still respecting quotes.
     let end = pos;
-    for (let i = pos; i < s.length; i++) {
-        const c = s[i];
-        if (!inQuote && isBoundary(c))
+    i = pos;
+    while (i < s.length) {
+        if (!q && isTokenBoundary(s[i]))
             break;
-        if (inQuote) {
-            if (c === q)
-                inQuote = false;
-        }
-        else if (c === '"' || c === "'") {
-            inQuote = true;
-            q = c;
-        }
-        end = i + 1;
+        i = step(i);
+        end = i;
     }
     return { start, end, raw: s.slice(start, end) };
 }
@@ -83,12 +82,6 @@ function splitToken(raw) {
         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
@@ -125,7 +118,7 @@ function operatorSuggestions(field, span) {
 }
 function buildValueState(field, opCode, span, options) {
     const items = options.map((o) => {
-        const insert = `${field.name}${opCode}${quoteIfNeeded(o.value)}`;
+        const insert = `${field.name}${opCode}${o.value === '' ? '' : quoteIfNeeded(o.value)}`;
         return {
             label: o.label,
             hint: o.hint,

package/dist/stores/fontscale.svelte.js

@@ -1,4 +1,5 @@
 import { browser } from '../env';
+import { readStorage, writeStorage } from './storage';
 // OPT-IN. Most apps don't need this: the kit is rem-based and never resets the
 // root font-size, so the user's browser/OS font-size preference and browser
 // zoom already scale the UI correctly. Reach for this control only in
@@ -28,7 +29,7 @@ class FontScale {
     current = $derived(levelById(this.levelId).value);
     constructor() {
         if (browser) {
-            const raw = localStorage.getItem(KEY);
+            const raw = readStorage(KEY);
             if (raw && SCALE_LEVELS.some((l) => l.id === raw))
                 this.levelId = raw;
             this.apply();
@@ -42,7 +43,7 @@ class FontScale {
     set(id) {
         this.levelId = SCALE_LEVELS.some((l) => l.id === id) ? id : DEFAULT_LEVEL;
         if (browser)
-            localStorage.setItem(KEY, this.levelId);
+            writeStorage(KEY, this.levelId);
         this.apply();
     }
 }

package/dist/stores/storage.d.ts

@@ -0,0 +1,2 @@
+export declare function readStorage(key: string): string | null;
+export declare function writeStorage(key: string, value: string): void;

package/dist/stores/storage.js

@@ -0,0 +1,16 @@
+// localStorage throws SecurityError when site data is blocked (Safari private
+// mode, sandboxed or third-party iframes); callers fall back to their defaults.
+export function readStorage(key) {
+    try {
+        return localStorage.getItem(key);
+    }
+    catch {
+        return null;
+    }
+}
+export function writeStorage(key, value) {
+    try {
+        localStorage.setItem(key, value);
+    }
+    catch { }
+}

package/dist/stores/theme.svelte.js

@@ -1,5 +1,6 @@
 import { browser } from '../env';
 import { AUTO_THEME, chooseTheme, DEFAULT_THEME_PREFERENCE, preferenceFrom, resolveTheme, } from '../theme-mode';
+import { readStorage, writeStorage } from './storage';
 // Theme registry. Built-ins live in THEMES (+ one [data-theme="id"] block in
 // styles/themes.css); consumers append their own with theme.register() and ship
 // the matching block in their own stylesheet. `themeColor` drives the mobile
@@ -87,7 +88,7 @@ class Theme {
                 this.systemDark = e.matches;
                 this.paint();
             });
-            this.saved = localStorage.getItem(KEY);
+            this.saved = readStorage(KEY);
             this.resolve();
         }
     }
@@ -151,12 +152,8 @@ class Theme {
     }
     persist() {
         this.saved = JSON.stringify(this.pref);
-        if (browser) {
-            try {
-                localStorage.setItem(KEY, this.saved);
-            }
-            catch { }
-        }
+        if (browser)
+            writeStorage(KEY, this.saved);
         this.onchange?.(this.pref);
     }
     apply() {

package/package.json

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