@gabvdl/ui 0.0.14

package/dist/lib/highlight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"highlight.d.ts","sourceRoot":"","sources":["../../src/lib/highlight.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAuBvC;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,SAAS,CAa1F;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EACpC,MAAM,SAAM,GACX,SAAS,CAsBX"}

package/dist/lib/highlight.js

@@ -0,0 +1,39 @@
+import { jsx as d } from "react/jsx-runtime";
+function g(n, i = 1) {
+  const c = n.filter(([r, t]) => t - r >= i).sort((r, t) => r[0] - t[0]), o = [];
+  for (const [r, t] of c) {
+    const s = o[o.length - 1];
+    s && r <= s[1] ? s[1] = Math.max(s[1], t) : o.push([r, t]);
+  }
+  return o;
+}
+function m(n, i) {
+  return /* @__PURE__ */ d("mark", { className: "rounded-sm bg-primary/25 px-0.5 text-foreground", children: n }, i);
+}
+function b(n, i) {
+  const c = g(i.map(([s, e]) => [s, e + 1]), 2);
+  if (c.length === 0) return n;
+  const o = [];
+  let r = 0, t = 0;
+  for (const [s, e] of c)
+    s > r && o.push(n.slice(r, s)), o.push(m(n.slice(s, e), t++)), r = e;
+  return r < n.length && o.push(n.slice(r)), o;
+}
+function j(n, i, c = 260) {
+  var a;
+  const o = g(i.map(([f, l]) => [f, l + 1]), 2), r = ((a = o[0]) == null ? void 0 : a[0]) ?? 0, t = Math.max(0, r - 60), s = Math.min(n.length, t + c), e = [];
+  t > 0 && e.push("… ");
+  let h = t, k = 0;
+  for (const [f, l] of o) {
+    if (l <= t) continue;
+    if (f >= s) break;
+    const u = Math.max(f, t), p = Math.min(l, s);
+    u > h && e.push(n.slice(h, u)), e.push(m(n.slice(u, p), k++)), h = p;
+  }
+  return h < s && e.push(n.slice(h, s)), s < n.length && e.push(" …"), e;
+}
+export {
+  b as highlightAll,
+  j as highlightSnippet
+};
+//# sourceMappingURL=highlight.js.map

package/dist/lib/highlight.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"highlight.js","sources":["../../src/lib/highlight.tsx"],"sourcesContent":["import type { ReactNode } from 'react';\n\n/** Merge overlapping/adjacent [start,end) ranges, dropping any shorter than\n * `minLen` (so single fuzzy-char hits don't produce noisy highlights). */\nfunction mergeRanges(ranges: [number, number][], minLen = 1): [number, number][] {\n  const kept = ranges.filter(([s, e]) => e - s >= minLen).sort((a, b) => a[0] - b[0]);\n  const out: [number, number][] = [];\n  for (const [s, e] of kept) {\n    const last = out[out.length - 1];\n    if (last && s <= last[1]) last[1] = Math.max(last[1], e);\n    else out.push([s, e]);\n  }\n  return out;\n}\n\nfunction mark(text: string, key: number): ReactNode {\n  return (\n    <mark key={key} className=\"rounded-sm bg-primary/25 px-0.5 text-foreground\">\n      {text}\n    </mark>\n  );\n}\n\n/**\n * Wrap the matched ranges of `text` in `<mark>`, highlighting the whole string\n * (no windowing). `indices` are Fuse.js match indices — inclusive `[start, end]`\n * pairs.\n */\nexport function highlightAll(text: string, indices: readonly [number, number][]): ReactNode {\n  const ranges = mergeRanges(indices.map(([s, e]) => [s, e + 1] as [number, number]), 2);\n  if (ranges.length === 0) return text;\n  const parts: ReactNode[] = [];\n  let cursor = 0;\n  let k = 0;\n  for (const [s, e] of ranges) {\n    if (s > cursor) parts.push(text.slice(cursor, s));\n    parts.push(mark(text.slice(s, e), k++));\n    cursor = e;\n  }\n  if (cursor < text.length) parts.push(text.slice(cursor));\n  return parts;\n}\n\n/**\n * Build a compact snippet of `text` centered on the first match, with the\n * matched ranges wrapped in `<mark>` and ellipses at any trimmed edge. Good for\n * long fields (message bodies, descriptions) where you only want the hit in\n * context. `indices` are Fuse.js match indices — inclusive `[start, end]` pairs.\n */\nexport function highlightSnippet(\n  text: string,\n  indices: readonly [number, number][],\n  window = 260,\n): ReactNode {\n  const ranges = mergeRanges(indices.map(([s, e]) => [s, e + 1] as [number, number]), 2);\n  const first = ranges[0]?.[0] ?? 0;\n  const start = Math.max(0, first - 60);\n  const end = Math.min(text.length, start + window);\n\n  const parts: ReactNode[] = [];\n  if (start > 0) parts.push('… ');\n  let cursor = start;\n  let k = 0;\n  for (const [rs, re] of ranges) {\n    if (re <= start) continue;\n    if (rs >= end) break;\n    const s = Math.max(rs, start);\n    const e = Math.min(re, end);\n    if (s > cursor) parts.push(text.slice(cursor, s));\n    parts.push(mark(text.slice(s, e), k++));\n    cursor = e;\n  }\n  if (cursor < end) parts.push(text.slice(cursor, end));\n  if (end < text.length) parts.push(' …');\n  return parts;\n}\n"],"names":["mergeRanges","ranges","minLen","kept","s","e","a","b","out","last","mark","text","key","jsx","highlightAll","indices","parts","cursor","k","highlightSnippet","window","first","_a","start","end","rs","re"],"mappings":";AAIA,SAASA,EAAYC,GAA4BC,IAAS,GAAuB;AAC/E,QAAMC,IAAOF,EAAO,OAAO,CAAC,CAACG,GAAGC,CAAC,MAAMA,IAAID,KAAKF,CAAM,EAAE,KAAK,CAACI,GAAGC,MAAMD,EAAE,CAAC,IAAIC,EAAE,CAAC,CAAC,GAC5EC,IAA0B,CAAA;AAChC,aAAW,CAACJ,GAAGC,CAAC,KAAKF,GAAM;AACzB,UAAMM,IAAOD,EAAIA,EAAI,SAAS,CAAC;AAC/B,IAAIC,KAAQL,KAAKK,EAAK,CAAC,IAAGA,EAAK,CAAC,IAAI,KAAK,IAAIA,EAAK,CAAC,GAAGJ,CAAC,IAClDG,EAAI,KAAK,CAACJ,GAAGC,CAAC,CAAC;AAAA,EACtB;AACA,SAAOG;AACT;AAEA,SAASE,EAAKC,GAAcC,GAAwB;AAClD,SACE,gBAAAC,EAAC,QAAA,EAAe,WAAU,mDACvB,eADQD,CAEX;AAEJ;AAOO,SAASE,EAAaH,GAAcI,GAAiD;AAC1F,QAAMd,IAASD,EAAYe,EAAQ,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAqB,GAAG,CAAC;AACrF,MAAId,EAAO,WAAW,EAAG,QAAOU;AAChC,QAAMK,IAAqB,CAAA;AAC3B,MAAIC,IAAS,GACTC,IAAI;AACR,aAAW,CAAC,GAAG,CAAC,KAAKjB;AACnB,IAAI,IAAIgB,KAAQD,EAAM,KAAKL,EAAK,MAAMM,GAAQ,CAAC,CAAC,GAChDD,EAAM,KAAKN,EAAKC,EAAK,MAAM,GAAG,CAAC,GAAGO,GAAG,CAAC,GACtCD,IAAS;AAEX,SAAIA,IAASN,EAAK,UAAQK,EAAM,KAAKL,EAAK,MAAMM,CAAM,CAAC,GAChDD;AACT;AAQO,SAASG,EACdR,GACAI,GACAK,IAAS,KACE;;AACX,QAAMnB,IAASD,EAAYe,EAAQ,IAAI,CAAC,CAACX,GAAGC,CAAC,MAAM,CAACD,GAAGC,IAAI,CAAC,CAAqB,GAAG,CAAC,GAC/EgB,MAAQC,IAAArB,EAAO,CAAC,MAAR,gBAAAqB,EAAY,OAAM,GAC1BC,IAAQ,KAAK,IAAI,GAAGF,IAAQ,EAAE,GAC9BG,IAAM,KAAK,IAAIb,EAAK,QAAQY,IAAQH,CAAM,GAE1CJ,IAAqB,CAAA;AAC3B,EAAIO,IAAQ,KAAGP,EAAM,KAAK,IAAI;AAC9B,MAAIC,IAASM,GACT,IAAI;AACR,aAAW,CAACE,GAAIC,CAAE,KAAKzB,GAAQ;AAC7B,QAAIyB,KAAMH,EAAO;AACjB,QAAIE,KAAMD,EAAK;AACf,UAAMpB,IAAI,KAAK,IAAIqB,GAAIF,CAAK,GACtBlB,IAAI,KAAK,IAAIqB,GAAIF,CAAG;AAC1B,IAAIpB,IAAIa,KAAQD,EAAM,KAAKL,EAAK,MAAMM,GAAQb,CAAC,CAAC,GAChDY,EAAM,KAAKN,EAAKC,EAAK,MAAMP,GAAGC,CAAC,GAAG,GAAG,CAAC,GACtCY,IAASZ;AAAA,EACX;AACA,SAAIY,IAASO,KAAKR,EAAM,KAAKL,EAAK,MAAMM,GAAQO,CAAG,CAAC,GAChDA,IAAMb,EAAK,UAAQK,EAAM,KAAK,IAAI,GAC/BA;AACT;"}

package/dist/lib/search.d.ts

@@ -0,0 +1,40 @@
+import { default as Fuse, FuseOptionKey, FuseResultMatch } from 'fuse.js';
+/** One row of {@link runSearch} output — mirrors a Fuse result, but the matches
+ * may be a mix of fuzzy hits (from Fuse) and exact-phrase hits (computed here). */
+export interface SearchResult<T> {
+    item: T;
+    refIndex: number;
+    matches: readonly FuseResultMatch[];
+}
+interface ParsedQuery {
+    /** Double-quoted segments — matched as exact, case-insensitive substrings. */
+    phrases: string[];
+    /** Everything outside quotes — matched fuzzily by Fuse. */
+    rest: string;
+}
+/**
+ * Split a raw query into exact `"quoted"` phrases and the leftover fuzzy text:
+ * `foo "bar baz" qux` → `{ phrases: ['bar baz'], rest: 'foo qux' }`.
+ *
+ * An unterminated quote is treated as literal text (it stays in `rest`), so a
+ * query that is mid-typing (`foo "ba`) keeps fuzzy-searching instead of
+ * suddenly matching nothing.
+ */
+export declare function parseQuery(query: string): ParsedQuery;
+/**
+ * Search `items` with quote-aware semantics:
+ *
+ * - A bare query is fuzzy-matched by Fuse (unchanged behaviour).
+ * - Any `"double-quoted"` segment must appear **exactly** (case-insensitive
+ *   substring) in one of the searched keys — great for pinning down an exact
+ *   name/id when the fuzzy ranking would otherwise bury it.
+ * - The two can mix: `parser "utils.ts"` fuzzy-matches `parser` and then keeps
+ *   only items whose fields contain the literal `utils.ts`.
+ *
+ * Returns results in Fuse relevance order when there is fuzzy text, otherwise in
+ * input order. Exact-phrase and fuzzy match indices are merged so the caller's
+ * highlighter marks both.
+ */
+export declare function runSearch<T>(fuse: Fuse<T>, items: T[], keys: FuseOptionKey<T>[], rawQuery: string, limit?: number): SearchResult<T>[];
+export {};
+//# sourceMappingURL=search.d.ts.map

package/dist/lib/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/lib/search.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAE,KAAK,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,SAAS,CAAC;AAEzE;mFACmF;AACnF,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,IAAI,EAAE,CAAC,CAAC;IACR,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;CACrC;AAED,UAAU,WAAW;IACnB,8EAA8E;IAC9E,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAiBrD;AAkFD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EACb,KAAK,EAAE,CAAC,EAAE,EACV,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,EACxB,QAAQ,EAAE,MAAM,EAChB,KAAK,CAAC,EAAE,MAAM,GACb,YAAY,CAAC,CAAC,CAAC,EAAE,CAwCnB"}

package/dist/lib/search.js

@@ -0,0 +1,91 @@
+import "fuse.js";
+function g(t) {
+  const r = [];
+  let e = "", s = 0;
+  const o = /"([^"]*)"/g;
+  let c;
+  for (; (c = o.exec(t)) !== null; ) {
+    e += t.slice(s, c.index);
+    const u = c[1].trim();
+    u && r.push(u), s = o.lastIndex;
+  }
+  return e += t.slice(s), { phrases: r, rest: e.replace(/"/g, " ").replace(/\s+/g, " ").trim() };
+}
+function x(t) {
+  if (typeof t == "string") return t;
+  if (Array.isArray(t)) return t.join(".");
+  const r = t.name;
+  return Array.isArray(r) ? r.join(".") : r;
+}
+function d(t, r) {
+  let e = t;
+  for (const s of r.split(".")) {
+    if (e == null || typeof e != "object") return "";
+    e = e[s];
+  }
+  return e == null ? "" : String(e);
+}
+function y(t, r, e) {
+  const s = /* @__PURE__ */ new Map(), o = e.map(() => !1);
+  for (const a of r) {
+    const h = d(t, a);
+    if (!h) continue;
+    const m = h.toLowerCase();
+    e.forEach((l, n) => {
+      const i = l.toLowerCase();
+      let f = m.indexOf(i);
+      if (f === -1) return;
+      o[n] = !0;
+      const p = s.get(a) ?? [];
+      for (; f !== -1; )
+        p.push([f, f + i.length - 1]), f = m.indexOf(i, f + i.length);
+      s.set(a, p);
+    });
+  }
+  const c = o.every(Boolean), u = c ? [...s.entries()].map(
+    ([a, h]) => ({ key: a, value: d(t, a), indices: h })
+  ) : [];
+  return { ok: c, matches: u };
+}
+function v(t, r) {
+  const e = /* @__PURE__ */ new Map();
+  for (const s of [...t, ...r]) {
+    const o = s.key ?? "", c = e.get(o);
+    c ? e.set(o, {
+      ...c,
+      indices: [...c.indices ?? [], ...s.indices ?? []]
+    }) : e.set(o, s);
+  }
+  return [...e.values()];
+}
+function w(t, r, e, s, o) {
+  const c = s.trim();
+  if (!c) return r.map((n, i) => ({ item: n, refIndex: i, matches: [] }));
+  const { phrases: u, rest: a } = g(c);
+  if (u.length === 0)
+    return t.search(a || c, o ? { limit: o } : void 0).map((n) => ({
+      item: n.item,
+      refIndex: n.refIndex,
+      matches: n.matches ?? []
+    }));
+  const h = e.map(x), m = a ? t.search(a).map((n) => ({
+    item: n.item,
+    refIndex: n.refIndex,
+    matches: [...n.matches ?? []]
+  })) : r.map((n, i) => ({ item: n, refIndex: i, matches: [] })), l = [];
+  for (const n of m) {
+    const { ok: i, matches: f } = y(n.item, h, u);
+    if (i && (l.push({
+      item: n.item,
+      refIndex: n.refIndex,
+      matches: v(n.matches, f)
+    }), o && l.length >= o))
+      break;
+  }
+  return l;
+}
+export {
+  g as parseQuery,
+  w as runSearch
+};
+//# sourceMappingURL=search.js.map

package/dist/lib/search.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.js","sources":["../../src/lib/search.ts"],"sourcesContent":["import Fuse, { type FuseOptionKey, type FuseResultMatch } from 'fuse.js';\n\n/** One row of {@link runSearch} output — mirrors a Fuse result, but the matches\n * may be a mix of fuzzy hits (from Fuse) and exact-phrase hits (computed here). */\nexport interface SearchResult<T> {\n  item: T;\n  refIndex: number;\n  matches: readonly FuseResultMatch[];\n}\n\ninterface ParsedQuery {\n  /** Double-quoted segments — matched as exact, case-insensitive substrings. */\n  phrases: string[];\n  /** Everything outside quotes — matched fuzzily by Fuse. */\n  rest: string;\n}\n\n/**\n * Split a raw query into exact `\"quoted\"` phrases and the leftover fuzzy text:\n * `foo \"bar baz\" qux` → `{ phrases: ['bar baz'], rest: 'foo qux' }`.\n *\n * An unterminated quote is treated as literal text (it stays in `rest`), so a\n * query that is mid-typing (`foo \"ba`) keeps fuzzy-searching instead of\n * suddenly matching nothing.\n */\nexport function parseQuery(query: string): ParsedQuery {\n  const phrases: string[] = [];\n  let rest = '';\n  let last = 0;\n  const re = /\"([^\"]*)\"/g;\n  let m: RegExpExecArray | null;\n  while ((m = re.exec(query)) !== null) {\n    rest += query.slice(last, m.index);\n    const phrase = m[1].trim();\n    if (phrase) phrases.push(phrase);\n    last = re.lastIndex;\n  }\n  rest += query.slice(last);\n  // Any `\"` left in `rest` is an unbalanced quote from a mid-typed query — drop\n  // it so the leftover text still fuzzy-searches instead of the literal quote\n  // poisoning the match.\n  return { phrases, rest: rest.replace(/\"/g, ' ').replace(/\\s+/g, ' ').trim() };\n}\n\n/** Normalise a Fuse key (string, path array, or weighted object) to a dotted path. */\nfunction keyToPath<T>(key: FuseOptionKey<T>): string {\n  if (typeof key === 'string') return key;\n  if (Array.isArray(key)) return key.join('.');\n  const name = (key as { name: string | string[] }).name;\n  return Array.isArray(name) ? name.join('.') : name;\n}\n\n/** Read a dotted path off an object as a string — same coercion the highlighter\n * uses (arrays via `String`, i.e. comma-joined) so match indices line up. */\nfunction valueAt(obj: unknown, path: string): string {\n  let cur: unknown = obj;\n  for (const seg of path.split('.')) {\n    if (cur == null || typeof cur !== 'object') return '';\n    cur = (cur as Record<string, unknown>)[seg];\n  }\n  return cur == null ? '' : String(cur);\n}\n\n/** Test one item against every quoted phrase and, if all are present, collect\n * the `<mark>`-ready match indices per key. An item passes only when EVERY\n * phrase appears (case-insensitively) in at least one searched key. */\nfunction exactMatch<T>(\n  item: T,\n  keyPaths: string[],\n  phrases: string[],\n): { ok: boolean; matches: FuseResultMatch[] } {\n  const indicesByKey = new Map<string, [number, number][]>();\n  const found = phrases.map(() => false);\n\n  for (const path of keyPaths) {\n    const value = valueAt(item, path);\n    if (!value) continue;\n    const hay = value.toLowerCase();\n    phrases.forEach((phrase, pi) => {\n      const needle = phrase.toLowerCase();\n      let at = hay.indexOf(needle);\n      if (at === -1) return;\n      found[pi] = true;\n      const arr = indicesByKey.get(path) ?? [];\n      while (at !== -1) {\n        arr.push([at, at + needle.length - 1]);\n        at = hay.indexOf(needle, at + needle.length);\n      }\n      indicesByKey.set(path, arr);\n    });\n  }\n\n  const ok = found.every(Boolean);\n  const matches: FuseResultMatch[] = ok\n    ? [...indicesByKey.entries()].map(\n        ([key, indices]) =>\n          ({ key, value: valueAt(item, key), indices } as unknown as FuseResultMatch),\n      )\n    : [];\n  return { ok, matches };\n}\n\n/** Merge two match lists, consolidating by key so the highlighter (which looks\n * matches up by key) sees a single entry per field with all its ranges. */\nfunction mergeMatches(\n  a: readonly FuseResultMatch[],\n  b: readonly FuseResultMatch[],\n): FuseResultMatch[] {\n  const byKey = new Map<string, FuseResultMatch>();\n  for (const m of [...a, ...b]) {\n    const key = m.key ?? '';\n    const prev = byKey.get(key);\n    if (prev) {\n      byKey.set(key, {\n        ...prev,\n        indices: [...(prev.indices ?? []), ...(m.indices ?? [])],\n      } as FuseResultMatch);\n    } else {\n      byKey.set(key, m);\n    }\n  }\n  return [...byKey.values()];\n}\n\n/**\n * Search `items` with quote-aware semantics:\n *\n * - A bare query is fuzzy-matched by Fuse (unchanged behaviour).\n * - Any `\"double-quoted\"` segment must appear **exactly** (case-insensitive\n *   substring) in one of the searched keys — great for pinning down an exact\n *   name/id when the fuzzy ranking would otherwise bury it.\n * - The two can mix: `parser \"utils.ts\"` fuzzy-matches `parser` and then keeps\n *   only items whose fields contain the literal `utils.ts`.\n *\n * Returns results in Fuse relevance order when there is fuzzy text, otherwise in\n * input order. Exact-phrase and fuzzy match indices are merged so the caller's\n * highlighter marks both.\n */\nexport function runSearch<T>(\n  fuse: Fuse<T>,\n  items: T[],\n  keys: FuseOptionKey<T>[],\n  rawQuery: string,\n  limit?: number,\n): SearchResult<T>[] {\n  const query = rawQuery.trim();\n  if (!query) return items.map((item, refIndex) => ({ item, refIndex, matches: [] }));\n\n  const { phrases, rest } = parseQuery(query);\n\n  // No quoted phrase → plain fuzzy, exactly as before.\n  if (phrases.length === 0) {\n    return fuse.search(rest || query, limit ? { limit } : undefined).map((r) => ({\n      item: r.item,\n      refIndex: r.refIndex,\n      matches: (r.matches ?? []) as readonly FuseResultMatch[],\n    }));\n  }\n\n  const keyPaths = keys.map(keyToPath);\n\n  // Candidate pool: when there's fuzzy text, rank/narrow by it first (no limit\n  // yet — the exact filter still has to run); otherwise consider every item and\n  // keep input order. `limit` is applied after the exact filter below.\n  const pool: SearchResult<T>[] = rest\n    ? fuse.search(rest).map((r) => ({\n        item: r.item,\n        refIndex: r.refIndex,\n        matches: [...(r.matches ?? [])] as FuseResultMatch[],\n      }))\n    : items.map((item, refIndex) => ({ item, refIndex, matches: [] as FuseResultMatch[] }));\n\n  const out: SearchResult<T>[] = [];\n  for (const cand of pool) {\n    const { ok, matches } = exactMatch(cand.item, keyPaths, phrases);\n    if (!ok) continue;\n    out.push({\n      item: cand.item,\n      refIndex: cand.refIndex,\n      matches: mergeMatches(cand.matches, matches),\n    });\n    if (limit && out.length >= limit) break;\n  }\n  return out;\n}\n"],"names":["parseQuery","query","phrases","rest","last","re","m","phrase","keyToPath","key","name","valueAt","obj","path","cur","seg","exactMatch","item","keyPaths","indicesByKey","found","value","hay","pi","needle","at","arr","ok","matches","indices","mergeMatches","a","b","byKey","prev","runSearch","fuse","items","keys","rawQuery","limit","refIndex","r","pool","out","cand"],"mappings":"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"}

package/dist/lib/utils.d.ts

@@ -0,0 +1,4 @@
+import { ClassValue } from 'clsx';
+/** Merge Tailwind class names, resolving conflicts (last wins). */
+export declare function cn(...inputs: ClassValue[]): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,UAAU,EAAE,MAAM,MAAM,CAAC;AAG7C,mEAAmE;AACnE,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,UAEzC"}

package/dist/lib/utils.js

@@ -0,0 +1,9 @@
+import { clsx as o } from "clsx";
+import { twMerge as t } from "tailwind-merge";
+function n(...r) {
+  return t(o(r));
+}
+export {
+  n as cn
+};
+//# sourceMappingURL=utils.js.map

package/dist/lib/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../src/lib/utils.ts"],"sourcesContent":["import { clsx, type ClassValue } from 'clsx';\nimport { twMerge } from 'tailwind-merge';\n\n/** Merge Tailwind class names, resolving conflicts (last wins). */\nexport function cn(...inputs: ClassValue[]) {\n  return twMerge(clsx(inputs));\n}\n"],"names":["cn","inputs","twMerge","clsx"],"mappings":";;AAIO,SAASA,KAAMC,GAAsB;AAC1C,SAAOC,EAAQC,EAAKF,CAAM,CAAC;AAC7B;"}

package/dist/overlay.css

@@ -0,0 +1,78 @@
+/*
+ * Motion for <Modal> and the toast stack.
+ *
+ * Plain CSS — no Tailwind directives — so the animations work whether or not
+ * the consumer's Tailwind config scans this package. Everything is under
+ * `prefers-reduced-motion`, so the overlays simply appear when motion is off.
+ */
+
+@keyframes ds-fade-in {
+  from {
+    opacity: 0;
+  }
+}
+
+@keyframes ds-scrim-in {
+  from {
+    opacity: 0;
+    backdrop-filter: blur(0);
+  }
+}
+
+@keyframes ds-panel-in {
+  from {
+    opacity: 0;
+    transform: translateY(12px) scale(0.97);
+  }
+}
+
+@keyframes ds-panel-in-sheet {
+  from {
+    transform: translateY(100%);
+  }
+}
+
+@keyframes ds-toast-in-bottom {
+  from {
+    opacity: 0;
+    transform: translateY(14px) scale(0.97);
+  }
+}
+
+@keyframes ds-toast-in-top {
+  from {
+    opacity: 0;
+    transform: translateY(-14px) scale(0.97);
+  }
+}
+
+.ds-modal-scrim {
+  animation: ds-scrim-in 160ms ease-out;
+}
+
+/* On phones the modal is a bottom sheet, so it rises from the edge it sits on. */
+.ds-modal-panel {
+  animation: ds-panel-in-sheet 260ms cubic-bezier(0.22, 1, 0.36, 1);
+}
+
+@media (min-width: 640px) {
+  .ds-modal-panel {
+    animation: ds-panel-in 180ms cubic-bezier(0.22, 1, 0.36, 1);
+  }
+}
+
+.ds-toast--bottom {
+  animation: ds-toast-in-bottom 220ms cubic-bezier(0.22, 1, 0.36, 1);
+}
+
+.ds-toast--top {
+  animation: ds-toast-in-top 220ms cubic-bezier(0.22, 1, 0.36, 1);
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .ds-modal-scrim,
+  .ds-modal-panel,
+  .ds-toast {
+    animation: ds-fade-in 1ms linear;
+  }
+}

package/dist/styles.css

@@ -0,0 +1,6 @@
+/* Convenience barrel: design tokens + the image-viewer overlay styling. */
+@import "./theme.css";
+@import "./image-viewer.css";
+@import "./virtual-list.css";
+@import "./overlay.css";
+@import "./tooltip.css";

package/dist/theme.css

@@ -0,0 +1,81 @@
+/*
+ * @gabvdl/ui design tokens.
+ *
+ * Import this into your Tailwind v4 entry, after `@import "tailwindcss"`, so the
+ * `@theme inline` block below wires the tokens into utilities (`bg-card`,
+ * `text-muted-foreground`, `border-border`, …). Light values live on :root; add
+ * the `.dark` class to any ancestor to switch. Override any custom property to
+ * retheme without touching component code.
+ */
+
+:root {
+  --background: #ffffff;
+  --foreground: #1c1917;
+  --card: #ffffff;
+  --card-foreground: #1c1917;
+  --popover: #ffffff;
+  --popover-foreground: #1c1917;
+  --primary: #1c1917;
+  --primary-foreground: #fafaf9;
+  --secondary: #f5f5f4;
+  --secondary-foreground: #1c1917;
+  --muted: #f5f5f4;
+  --muted-foreground: #78716c;
+  --accent: #f5f5f4;
+  --accent-foreground: #1c1917;
+  --destructive: #dc2626;
+  --destructive-foreground: #fafaf9;
+  --border: #e7e5e4;
+  --input: #e7e5e4;
+  --ring: #a8a29e;
+  --radius: 0.625rem;
+}
+
+.dark {
+  --background: #0c0a09;
+  --foreground: #fafaf9;
+  --card: #1c1917;
+  --card-foreground: #fafaf9;
+  --popover: #1c1917;
+  --popover-foreground: #fafaf9;
+  --primary: #fafaf9;
+  --primary-foreground: #1c1917;
+  --secondary: #292524;
+  --secondary-foreground: #fafaf9;
+  --muted: #292524;
+  --muted-foreground: #a8a29e;
+  --accent: #292524;
+  --accent-foreground: #fafaf9;
+  --destructive: #ef4444;
+  --destructive-foreground: #fafaf9;
+  --border: #292524;
+  --input: #292524;
+  --ring: #57534e;
+}
+
+@theme inline {
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --color-card: var(--card);
+  --color-card-foreground: var(--card-foreground);
+  --color-popover: var(--popover);
+  --color-popover-foreground: var(--popover-foreground);
+  --color-primary: var(--primary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-secondary: var(--secondary);
+  --color-secondary-foreground: var(--secondary-foreground);
+  --color-muted: var(--muted);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-accent: var(--accent);
+  --color-accent-foreground: var(--accent-foreground);
+  --color-destructive: var(--destructive);
+  --color-destructive-foreground: var(--destructive-foreground);
+  --color-border: var(--border);
+  --color-input: var(--input);
+  --color-ring: var(--ring);
+
+  --radius-sm: calc(var(--radius) - 4px);
+  --radius-md: calc(var(--radius) - 2px);
+  --radius-lg: var(--radius);
+  --radius-xl: calc(var(--radius) + 4px);
+}

package/dist/tooltip.css

@@ -0,0 +1,53 @@
+/*
+ * Styling for the tooltip attached to <Button tooltip="…">.
+ *
+ * Plain CSS — no Tailwind directives — so the bubble is visible whether or not
+ * the consumer's Tailwind scans this package. Every value reads from a
+ * `--ds-tooltip-*` custom property, so it can be rethemed from the outside.
+ *
+ * The anchor is what gets positioned (fixed, at the trigger's edge, then pulled
+ * onto the right side with a transform); the bubble inside it is free to run its
+ * own entrance animation without fighting that transform.
+ */
+
+:root {
+  --ds-tooltip-bg: var(--popover, #1c1917);
+  --ds-tooltip-fg: var(--popover-foreground, #fafaf9);
+  --ds-tooltip-border: var(--border, rgba(255, 255, 255, 0.12));
+  --ds-tooltip-radius: 6px;
+  --ds-tooltip-z: 300;
+}
+
+.ds-tooltip-anchor {
+  position: fixed;
+  z-index: var(--ds-tooltip-z);
+  pointer-events: none;
+}
+
+.ds-tooltip {
+  display: block;
+  max-width: 16rem;
+  padding: 0.25rem 0.5rem;
+  border: 1px solid var(--ds-tooltip-border);
+  border-radius: var(--ds-tooltip-radius);
+  background: var(--ds-tooltip-bg);
+  color: var(--ds-tooltip-fg);
+  box-shadow: 0 6px 18px -6px rgba(0, 0, 0, 0.4);
+  font-size: 0.75rem;
+  line-height: 1.1rem;
+  white-space: nowrap;
+  animation: ds-tooltip-in 90ms ease-out;
+}
+
+@keyframes ds-tooltip-in {
+  from {
+    opacity: 0;
+    transform: scale(0.96);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .ds-tooltip {
+    animation: none;
+  }
+}

package/dist/virtual-list.css

@@ -0,0 +1,29 @@
+/*
+ * Smooth-reorder animation for <VirtualList smooth>.
+ *
+ * Plain CSS — no Tailwind directives — so it works whether or not the consumer
+ * uses Tailwind. Each virtualized row is absolutely positioned and moved with a
+ * `transform: translateY(...)`; when the underlying list is re-sorted (e.g. an
+ * auto-sort by "updated" date whose value changed), a row's target offset
+ * changes and this transition glides it to its new slot instead of teleporting,
+ * so the reorder reads clearly instead of flashing.
+ *
+ * The component only adds `--smooth` while the list is idle (not actively being
+ * scrolled), so scroll and lazy height-measurement never animate — only genuine
+ * reorders do. Honors `prefers-reduced-motion`.
+ */
+.ds-virtual-row {
+  /* base marker class — no styling on its own */
+}
+
+.ds-virtual-row--smooth {
+  transition: transform var(--ds-virtual-row-duration, 320ms)
+    var(--ds-virtual-row-ease, cubic-bezier(0.22, 1, 0.36, 1));
+  will-change: transform;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .ds-virtual-row--smooth {
+    transition: none;
+  }
+}

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@gabvdl/ui",
+  "version": "0.0.14",
+  "description": "Gabriel Vidal's personal design system — tree-shakeable React components built on shadcn primitives. Flagship: a full-screen image viewer with zoom, pan and swipe.",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GabrielVidal1/design-system.git",
+    "directory": "packages/ui"
+  },
+  "homepage": "https://ui.gabvdl.xyz",
+  "bugs": {
+    "url": "https://github.com/GabrielVidal1/design-system/issues"
+  },
+  "keywords": [
+    "react",
+    "components",
+    "design-system",
+    "shadcn",
+    "tailwind",
+    "image-viewer"
+  ],
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./styles.css": "./dist/styles.css",
+    "./theme.css": "./dist/theme.css",
+    "./image-viewer.css": "./dist/image-viewer.css",
+    "./virtual-list.css": "./dist/virtual-list.css",
+    "./overlay.css": "./dist/overlay.css",
+    "./tooltip.css": "./dist/tooltip.css",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "vite build && node scripts/copy-css.mjs",
+    "dev": "vite build --watch",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "react-dom": ">=18"
+  },
+  "dependencies": {
+    "@tanstack/react-virtual": "^3.14.5",
+    "clsx": "^2.1.1",
+    "fuse.js": "^7.1.0",
+    "lucide-react": "^0.469.0",
+    "react-resizable-panels": "^2.1.9",
+    "tailwind-merge": "^3.6.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.1.2",
+    "@types/react-dom": "^19.1.2",
+    "@vitejs/plugin-react": "^4.4.1",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "typescript": "~5.8.3",
+    "vite": "^6.3.1",
+    "vite-plugin-dts": "^4.5.0"
+  }
+}