@wral/studio.ui.search-filter 0.1.0

package/dist/index.mjs

@@ -0,0 +1,17 @@
+import { S as O } from "./search-filter-B-aiJCKp.js";
+import { DATE_OPS as a, DEFAULT_BOOLEANS as t, DEFAULT_OPERATORS as l, NUM_OPS as o, TEXT_OPS as E, URL_OPS as P, VIDEO_OPS as _, createQueryModel as T, equivalent as i, publicationPreset as A, resolveLabels as L, validateSyntax as s } from "./model.mjs";
+export {
+  a as DATE_OPS,
+  t as DEFAULT_BOOLEANS,
+  l as DEFAULT_OPERATORS,
+  o as NUM_OPS,
+  O as SearchFilter,
+  E as TEXT_OPS,
+  P as URL_OPS,
+  _ as VIDEO_OPS,
+  T as createQueryModel,
+  i as equivalent,
+  A as publicationPreset,
+  L as resolveLabels,
+  s as validateSyntax
+};

package/dist/model.mjs

@@ -0,0 +1,582 @@
+const C = {
+  fields: {
+    tag: {
+      label: "Tag",
+      path: "tags.name",
+      type: "text",
+      hint: "e.g. UNC sports"
+    },
+    title: {
+      label: "Headline",
+      path: "metadata.title",
+      type: "text",
+      hint: "e.g. hurricane"
+    },
+    body: {
+      label: "Summary",
+      path: "metadata.description",
+      type: "text",
+      hint: "e.g. storm damage"
+    },
+    author: {
+      label: "Author",
+      path: "metadata.author",
+      type: "text",
+      hint: "e.g. Brian Murphy"
+    },
+    uri: {
+      label: "Article URL",
+      path: "uri",
+      type: "url",
+      hint: "e.g. https://www.wral.com/sports/"
+    },
+    site: {
+      label: "Site",
+      path: "site",
+      type: "text",
+      hint: "e.g. highschoolot.com"
+    },
+    date: {
+      label: "Published",
+      path: "metadata.articlePublishedTime",
+      type: "date"
+    },
+    updated: {
+      label: "Updated",
+      path: "metadata.articleModifiedTime",
+      type: "date"
+    },
+    // combined hero-video field: "has a video" tests
+    // _exists_:metadata.ogVideo, the duration ops filter
+    // metadata.ogVideoDuration (seconds).
+    video: {
+      label: "Has hero video",
+      path: "metadata.ogVideo",
+      type: "video",
+      durationPath: "metadata.ogVideoDuration",
+      hint: "duration in seconds, e.g. 60"
+    },
+    // the default search field: a bare term with no `field:` prefix,
+    // matching the backend's full-text default. Used for legacy
+    // bare-phrase queries.
+    any: {
+      label: "Any field",
+      path: "",
+      type: "text",
+      hint: "e.g. hurricane"
+    }
+  },
+  defaults: {
+    field: "title",
+    conditional: {
+      if: { field: "tag", op: "term" },
+      then: { field: "uri", op: "under", negate: !0 },
+      else: { field: "uri", op: "under" }
+    }
+  },
+  labels: {
+    itemNoun: "story",
+    itemNounPlural: "stories"
+  }
+}, Y = [
+  { id: "phrase", label: "contains the phrase" },
+  { id: "term", label: "matches the word" },
+  { id: "starts", label: "starts with" },
+  { id: "fuzzy", label: "sounds like (fuzzy)" },
+  { id: "exists", label: "has any value" }
+], ee = [
+  { id: "is", label: "is exactly" },
+  { id: "under", label: "is anywhere under" }
+], te = [
+  { id: "after", label: "is on or after" },
+  { id: "before", label: "is on or before" },
+  { id: "between", label: "is between" }
+], ne = [
+  { id: "gte", label: "is at least" },
+  { id: "lte", label: "is at most" },
+  { id: "between", label: "is between" }
+], ie = [
+  { id: "exists", label: "has a video" },
+  { id: "longer", label: "is longer than (sec)" },
+  { id: "shorter", label: "is shorter than (sec)" },
+  { id: "between", label: "duration between (sec)" }
+], P = {
+  text: Y,
+  url: ee,
+  date: te,
+  number: ne,
+  video: ie
+}, H = [
+  { id: "AND", label: "all" },
+  { id: "OR", label: "any" }
+], w = (t) => {
+  throw new Error(`search-filter: ${t}`);
+};
+function V(t, i, e) {
+  const r = new Set(P[i].map((o) => o.id));
+  return (!Array.isArray(t) || !t.length) && w(`${e} must be a non-empty array of { id, label }`), t.map((o) => ((!o || !r.has(o.id)) && w(`${e} has unknown ${i} operator id "${o && o.id}" (known: ${[...r].join(", ")})`), { id: o.id, label: o.label || o.id }));
+}
+function oe(t, i = {}) {
+  const e = Object.keys(t || {});
+  e.length || w("the fields catalog is empty");
+  const r = {};
+  for (const o of e) {
+    const l = t[o] || {}, a = l.type || "text";
+    P[a] || w(`field "${o}" has unknown type "${a}" (known: ${Object.keys(P).join(", ")})`), typeof l.path != "string" && w(`field "${o}" needs a string path ('' targets the backend's default field)`), a === "video" && !l.durationPath && w(`field "${o}" is type video and needs a durationPath`);
+    const c = l.ops ? V(l.ops, a, `field "${o}" ops`) : i[a] ? V(i[a], a, `operators.${a}`) : P[a];
+    r[o] = {
+      label: l.label || o,
+      path: l.path,
+      type: a,
+      hint: l.hint || "",
+      durationPath: l.durationPath || "",
+      ops: c
+    };
+  }
+  return r;
+}
+function re(t) {
+  if (t == null) return H;
+  const i = new Set(H.map((e) => e.id));
+  return (!Array.isArray(t) || !t.length) && w("booleans must be a non-empty array of { id, label }"), t.map((e) => ((!e || !i.has(e.id)) && w(`unknown boolean operator "${e && e.id}" (known: AND, OR)`), { id: e.id, label: e.label || e.id }));
+}
+let le = 0;
+const A = () => "n" + ++le, S = (t) => String(t).replace(/(["\\])/g, "\\$1"), U = (t) => S(t).replace(/\s+/g, "\\ ");
+function L(t) {
+  const i = [];
+  let e = 0;
+  const r = t.length;
+  for (; e < r; ) {
+    const o = t[e];
+    if (o === " " || o === "	" || o === `
+`) {
+      e++;
+      continue;
+    }
+    if (o === "(" || o === ")") {
+      i.push(o), e++;
+      continue;
+    }
+    let l = "";
+    for (; e < r; ) {
+      const a = t[e];
+      if (a === "\\" && e + 1 < r) {
+        l += a + t[e + 1], e += 2;
+        continue;
+      }
+      if (a === " " || a === "(" || a === ")") break;
+      if (a === '"') {
+        for (l += a, e++; e < r; ) {
+          if (l += t[e], t[e] === '"' && t[e - 1] !== "\\") {
+            e++;
+            break;
+          }
+          e++;
+        }
+        continue;
+      }
+      if (a === "[") {
+        for (l += a, e++; e < r; ) {
+          if (l += t[e], t[e] === "]") {
+            e++;
+            break;
+          }
+          e++;
+        }
+        continue;
+      }
+      l += a, e++;
+    }
+    l === "AND" || l === "OR" || l === "NOT" ? i.push(l) : l === "&&" ? i.push("AND") : l === "||" ? i.push("OR") : i.push({ term: l });
+  }
+  return i;
+}
+function z(t, i) {
+  if (t.startsWith("[")) {
+    const l = t.match(/^\[(.+) TO (.+)\]$/) || [null, "*", "*"], a = l[1], c = l[2];
+    return a === "*" ? { op: i === "number" ? "lte" : "before", value: c } : c === "*" ? { op: i === "number" ? "gte" : "after", value: a } : { op: "between", value: a, value2: c };
+  }
+  if (t.startsWith('"'))
+    return {
+      op: i === "url" ? "under" : "phrase",
+      value: t.slice(1, -1).replace(/\\(.)/g, "$1")
+    };
+  let e = t, r = "";
+  return e.endsWith("*") ? (r = "*", e = e.slice(0, -1)) : e.endsWith("~") && (r = "~", e = e.slice(0, -1)), e = e.replace(/\\ /g, " ").replace(/\\(.)/g, "$1"), { op: i === "url" ? "under" : r === "*" ? "starts" : r === "~" ? "fuzzy" : "term", value: e };
+}
+function se(t, i) {
+  let e = 0;
+  const r = () => t[e], o = () => t[e++];
+  function l() {
+    let $ = !1;
+    for (; r() === "NOT"; )
+      $ = !$, o();
+    let h;
+    if (r() === "(")
+      o(), h = c(), r() === ")" && o();
+    else {
+      const g = o();
+      if (!g || typeof g == "string")
+        throw new Error("Unexpected token");
+      h = i(g);
+    }
+    return $ && (h.negate = !h.negate), h;
+  }
+  function a() {
+    const $ = l(), h = [$];
+    for (; ; ) {
+      const g = r();
+      if (g === "AND")
+        o(), h.push(l());
+      else if (g !== void 0 && g !== ")" && g !== "OR") h.push(l());
+      else break;
+    }
+    return h.length === 1 ? $ : {
+      id: A(),
+      kind: "group",
+      op: "AND",
+      negate: !1,
+      children: h
+    };
+  }
+  function c() {
+    const $ = a(), h = [$];
+    for (; r() === "OR"; )
+      o(), h.push(a());
+    return h.length === 1 ? $ : {
+      id: A(),
+      kind: "group",
+      op: "OR",
+      negate: !1,
+      children: h
+    };
+  }
+  const v = c();
+  if (e < t.length) throw new Error("Unexpected trailing tokens");
+  return v;
+}
+function ae(t, i) {
+  let e = "", r = t;
+  return r.startsWith("-") && (e = "-", r = r.slice(1)), M.has(r) || /^[A-Za-z_][\w.$]*:/.test(r) ? t : e + i + ":" + r;
+}
+function E(t) {
+  const i = (r) => r && typeof r == "object", e = [];
+  for (let r = 0; r < t.length; r++) {
+    const o = t[r], l = i(o) && /^(-?)([A-Za-z_][\w.$]*):$/.exec(o.term);
+    if (l && t[r + 1] === "(") {
+      let a = 0, c = r + 1;
+      for (; c < t.length; c++)
+        if (t[c] === "(") a++;
+        else if (t[c] === ")" && --a === 0) break;
+      if (c < t.length) {
+        l[1] === "-" && e.push("NOT"), e.push("(");
+        for (const v of E(t.slice(r + 2, c)))
+          e.push(i(v) ? { term: ae(v.term, l[2]) } : v);
+        e.push(")"), r = c;
+        continue;
+      }
+    }
+    e.push(o);
+  }
+  return e;
+}
+function me(t) {
+  let i = 0, e = 0;
+  for (const r of t)
+    if (r === "(" ? i++ : r === ")" ? i-- : r === '"' && e++, i < 0) break;
+  return i !== 0 ? "Unbalanced parentheses." : e % 2 !== 0 ? "Unbalanced quotes." : "";
+}
+const M = /* @__PURE__ */ new Set(["AND", "OR", "NOT"]);
+function ue(t) {
+  const i = t.indexOf(":");
+  return i < 0 ? null : { field: t.slice(0, i), value: t.slice(i + 1) };
+}
+function de(t) {
+  const i = ue(t);
+  if (!i) return t;
+  let e = i.value;
+  if (e.length > 1 && e.startsWith('"') && e.endsWith('"')) {
+    const r = e.slice(1, -1);
+    r && !/\s/.test(r) && (e = r);
+  }
+  return i.field + ":" + e;
+}
+function fe(t) {
+  let i = t.slice();
+  for (let e = !0; e; ) {
+    e = !1;
+    for (let r = 0; r + 2 < i.length; r++)
+      if (i[r] === "(" && i[r + 2] === ")" && i[r + 1] !== "(" && i[r + 1] !== ")") {
+        i.splice(r, 3, i[r + 1]), e = !0;
+        break;
+      }
+    if (!e && i.length >= 2 && i[0] === "(" && i[i.length - 1] === ")") {
+      let r = 0, o = !0;
+      for (let l = 0; l < i.length; l++)
+        if (i[l] === "(") r++;
+        else if (i[l] === ")" && --r === 0 && l !== i.length - 1) {
+          o = !1;
+          break;
+        }
+      o && (i = i.slice(1, -1), e = !0);
+    }
+  }
+  return i;
+}
+function ce(t) {
+  return t[0] === "!" ? "-" + t.slice(1) : t;
+}
+function D(t) {
+  const i = E(L(t)).map((o) => typeof o == "string" ? o : o.term).map(ce), e = [];
+  for (let o = 0; o < i.length; o++) {
+    const l = i[o];
+    if (l === "NOT" && o + 1 < i.length && i[o + 1] !== "(" && !M.has(i[o + 1])) {
+      const a = i[++o];
+      e.push(a.startsWith("-") ? a.slice(1) : "-" + a);
+    } else
+      e.push(l);
+  }
+  return fe(
+    e.filter((o) => o !== "AND").map(de)
+  ).join(" ");
+}
+function pe(t) {
+  const i = (o) => o === "AND" || o === "OR" || o === "NOT", e = (o) => o === ")" || !i(o) && o !== "(", r = (o) => o === "(" || !i(o) && o !== ")" && o[0] !== "-" && o[0] !== "!" && o[0] !== "+";
+  for (let o = 0; o + 1 < t.length; o++)
+    if (e(t[o]) && r(t[o + 1])) return !0;
+  return !1;
+}
+function ge(t, i) {
+  if (t === i) return !0;
+  try {
+    return D(t || "") === D(i || "");
+  } catch {
+    return !1;
+  }
+}
+function $e(t = {}) {
+  const i = t.fields == null, e = oe(
+    t.fields ?? C.fields,
+    t.operators
+  ), r = re(t.booleans), o = new Set(r.map((n) => n.id)), l = t.defaults ?? (i ? C.defaults : null), a = Object.keys(e), c = (n) => a.find((s) => e[s].path === n), v = (n, s) => e[n].ops.some((u) => u.id === s), $ = (n, s) => {
+    n && (e[n.field] || w(`${s} names unknown field "${n.field}"`), n.op && !v(n.field, n.op) && w(`${s} uses operator "${n.op}" not offered for field "${n.field}"`));
+  };
+  l?.field && !e[l.field] && w(`defaults.field names unknown field "${l.field}"`), $(l?.conditional?.if, "defaults.conditional.if"), $(l?.conditional?.then, "defaults.conditional.then"), $(l?.conditional?.else, "defaults.conditional.else");
+  const h = l?.field || a[0], g = (n = h, s = {}) => ({
+    id: A(),
+    kind: "rule",
+    field: n,
+    op: e[n].ops[0].id,
+    value: "",
+    value2: "",
+    negate: !1,
+    boost: "",
+    ...s
+  }), O = (n = r[0].id, s = null) => ({
+    id: A(),
+    kind: "group",
+    op: n,
+    negate: !1,
+    children: s || [g()]
+  }), R = (n) => n ? g(n.field, {
+    ...n.op ? { op: n.op } : {},
+    ...n.negate ? { negate: !0 } : {}
+  }) : g(), Q = () => ({
+    id: A(),
+    kind: "conditional",
+    cond: O("AND", [R(l?.conditional?.if)]),
+    then: O("AND", [R(l?.conditional?.then)]),
+    els: O("AND", [R(l?.conditional?.else)])
+  }), G = () => O("AND", [R(l?.conditional?.else)]);
+  function j(n) {
+    const s = e[n.field], u = s.path;
+    if (s.type === "video") {
+      let m = "";
+      if (n.op === "exists")
+        m = `_exists_:${u}`;
+      else {
+        const y = (n.value || "").trim(), k = (n.value2 || "").trim();
+        n.op === "longer" ? m = y && `${s.durationPath}:[${y} TO *]` : n.op === "shorter" ? m = y && `${s.durationPath}:[* TO ${y}]` : n.op === "between" && (m = y && k && `${s.durationPath}:[${y} TO ${k}]`);
+      }
+      return m ? n.negate ? "-" + m : m : "";
+    }
+    const d = u ? `${u}:` : "", f = (n.value || "").trim(), x = (n.value2 || "").trim();
+    let p = "";
+    if (s.type === "url") {
+      if (!f) return "";
+      p = n.op === "is" ? `${u}.keyword:"${S(f)}"` : `${d}"${S(f)}"`;
+    } else if (s.type === "date" || s.type === "number")
+      if (n.op === "between") {
+        if (!f || !x) return "";
+        p = `${d}[${f} TO ${x}]`;
+      } else if (n.op === "after" || n.op === "gte") {
+        if (!f) return "";
+        p = `${d}[${f} TO *]`;
+      } else {
+        if (!f) return "";
+        p = `${d}[* TO ${f}]`;
+      }
+    else if (n.op === "exists") {
+      if (!u) return "";
+      p = `_exists_:${u}`;
+    } else {
+      if (!f) return "";
+      n.op === "phrase" ? p = `${d}"${S(f)}"` : n.op === "term" ? p = `${d}${U(f)}` : n.op === "starts" ? p = `${d}${U(f)}*` : n.op === "fuzzy" && (p = `${d}${U(f)}~`);
+    }
+    return p ? (n.boost && Number(n.boost) > 0 && n.op !== "exists" && (p += `^${n.boost}`), n.negate && (p = "-" + p), p) : "";
+  }
+  function Z(n) {
+    return n.kind === "rule" ? j(n) : n.kind === "conditional" ? I(n) : T(n);
+  }
+  function T(n, s = !1) {
+    const u = n.children.map(Z).filter(Boolean);
+    if (u.length === 0) return "";
+    const d = u.join(` ${n.op} `);
+    let f = u.length > 1 && !s ? `(${d})` : d;
+    return n.negate && (f = u.length > 1 ? `NOT (${d})` : `NOT ${d}`), f;
+  }
+  function I(n) {
+    const s = T(n.cond), u = T(n.then), d = n.els ? T(n.els) : "";
+    if (!s) return u || "";
+    const f = u ? `(${s} AND ${u})` : `(${s})`;
+    return d ? `(${f} OR (NOT (${s}) AND ${d}))` : f;
+  }
+  function W(n) {
+    return T(n, !0) || "";
+  }
+  function N(n, s) {
+    if (s.op && !v(n, s.op))
+      throw new Error(`Unsupported operator for ${n}: ${s.op}`);
+    return g(n, s);
+  }
+  function J(n) {
+    let s = n.term, u = !1;
+    s[0] === "-" || s[0] === "!" ? (u = !0, s = s.slice(1)) : s[0] === "+" && (s = s.slice(1));
+    let d = "";
+    const f = s.match(/\^(\d+(?:\.\d+)?)$/);
+    f && (d = f[1], s = s.slice(0, -f[0].length));
+    const x = s.indexOf(":");
+    if (x < 0) {
+      const b = c("");
+      if (!b) throw new Error(`No default field for bare term: ${s}`);
+      return N(b, {
+        ...z(s, e[b].type),
+        negate: u,
+        boost: d
+      });
+    }
+    const p = s.slice(0, x), m = s.slice(x + 1);
+    if (p === "_exists_") {
+      const b = c(m.replace(/^"(.*)"$/, "$1"));
+      if (!b) throw new Error(`Unknown field: ${m}`);
+      return N(b, { op: "exists", negate: u });
+    }
+    const y = a.find((b) => e[b].type === "video" && e[b].durationPath === p);
+    if (y && m.startsWith("[")) {
+      const { op: b, value: X, value2: q } = z(m, "number");
+      return N(y, { op: b === "gte" ? "longer" : b === "lte" ? "shorter" : "between", value: X, value2: q || "", negate: u });
+    }
+    const k = a.find((b) => e[b].type === "url" && p === e[b].path + ".keyword");
+    if (k) {
+      const b = m.startsWith('"') ? m.slice(1, -1).replace(/\\(.)/g, "$1") : m;
+      return N(k, { op: "is", value: b, negate: u });
+    }
+    const _ = c(p);
+    if (!_) throw new Error(`Unknown field: ${p}`);
+    return N(_, {
+      ...z(m, e[_].type),
+      negate: u,
+      boost: d
+    });
+  }
+  function B(n) {
+    if (!n || !n.trim()) return O(void 0, []);
+    const s = se(E(L(n)), J);
+    return s.kind === "group" ? s : O(void 0, [s]);
+  }
+  const F = (n) => n.kind !== "group" || o.has(n.op) && n.children.every(F);
+  function K(n) {
+    if (!n || !n.trim()) return !0;
+    try {
+      const s = E(L(n)).map((d) => typeof d == "string" ? d : d.term);
+      if (pe(s)) return !1;
+      const u = B(n);
+      return F(u) ? D(W(u)) === D(n) : !1;
+    } catch {
+      return !1;
+    }
+  }
+  return {
+    fields: e,
+    fieldKeys: a,
+    groupOps: r,
+    defaultField: h,
+    // conditionals desugar to OR-of-ANDs, so they're only on offer
+    // when both joiners are
+    supportsConditionals: o.has("AND") && o.has("OR"),
+    newRule: g,
+    newGroup: O,
+    newConditional: Q,
+    newElse: G,
+    ruleToLucene: j,
+    groupToLucene: T,
+    condToLucene: I,
+    toLucene: W,
+    parseLucene: B,
+    roundTrips: K
+  };
+}
+const he = (t) => t && t[0].toUpperCase() + t.slice(1);
+function we(t = {}) {
+  const i = t.itemNoun || "story", e = t.itemNounPlural || (t.itemNoun ? t.itemNoun + "s" : "stories");
+  return {
+    itemNoun: i,
+    itemNounPlural: e,
+    intro: `Describe the ${e} you want in plain language — the query writes itself.`,
+    rawUnsupported: "This query uses syntax the visual editor can't represent, so it's shown as raw text.",
+    rawButton: "Raw Query",
+    visualButton: "Query Builder",
+    rawSynced: "Synced.",
+    rawSaved: "Saved as raw text — the visual builder can't represent this query. Adjust it to a supported form to switch back.",
+    matchPrefix: `${he(e)} must match`,
+    matchSuffix: "of these rules",
+    empty: `No rules yet, so every ${i} can appear. Add a rule to narrow the collection.`,
+    addRule: "Rule",
+    addRuleTip: 'Add one condition, like Title contains "storm".',
+    addConditional: "If/then",
+    addConditionalTip: `Apply conditions only to ${e} that match a test first.`,
+    actsHelpRule: "adds a single condition",
+    actsHelpConditional: `applies conditions only to certain ${e}`,
+    conditionalTitle: "IF / THEN",
+    conditionalIf: `If a ${i} matches`,
+    conditionalThen: "then include only when",
+    conditionalElse: "otherwise include only when",
+    removeElse: "remove",
+    addElse: "Otherwise branch",
+    addSubRule: "Rule",
+    addSubRuleTip: "Add another condition to this list.",
+    include: "Include",
+    exclude: "Exclude",
+    ruleTag: "Rule",
+    between: "and",
+    // sic: "a values." matches the original builder's rendered string
+    // (`…a value${plural ? 's' : ''}.`) byte-for-byte
+    pendingOne: "Ignored until you enter a value.",
+    pendingBoth: "Ignored until you enter a values.",
+    ...t
+  };
+}
+export {
+  te as DATE_OPS,
+  H as DEFAULT_BOOLEANS,
+  P as DEFAULT_OPERATORS,
+  ne as NUM_OPS,
+  Y as TEXT_OPS,
+  ee as URL_OPS,
+  ie as VIDEO_OPS,
+  $e as createQueryModel,
+  ge as equivalent,
+  C as publicationPreset,
+  we as resolveLabels,
+  me as validateSyntax
+};