@nivaro/react 0.3.41 → 0.3.43

package/dist/shared/lib/config-sentences.js

@@ -0,0 +1,418 @@
+import { choiceLabel as F, titleCase as y } from "./utils.js";
+import { formulaInputs as P } from "./write-formula.js";
+const R = /* @__PURE__ */ new Set(["integer", "bigInteger", "float", "decimal", "number"]);
+function v(e, n = {}) {
+  var t, s, c;
+  const o = (t = n.fields) == null ? void 0 : t[e];
+  if (o != null && o.trim()) return o.trim();
+  if (e.includes(".")) {
+    const r = e.split(".");
+    return [((c = (s = n.fields) == null ? void 0 : s[r[0]]) == null ? void 0 : c.trim()) || y(r[0]), ...r.slice(1).map((u) => y(u))].join("’s ");
+  }
+  return y(e);
+}
+function N(e, n = {}) {
+  var t;
+  const o = (t = n.collections) == null ? void 0 : t[e];
+  return o != null && o.trim() ? o.trim() : y(e);
+}
+function w(e, n, o) {
+  var s, c;
+  const t = (c = (s = o.relatedFields) == null ? void 0 : s[e]) == null ? void 0 : c[n];
+  return t != null && t.trim() ? t.trim() : y(n);
+}
+const b = (e) => e == null || e === "" || Array.isArray(e) && e.length === 0;
+function z(e, n) {
+  return n === "money" ? `${e < 0 ? "-" : ""}$${Math.abs(e).toLocaleString("en-US", { maximumFractionDigits: 2 })}` : n === "percent" ? `${e.toLocaleString("en-US", { maximumFractionDigits: 2 })}%` : e.toLocaleString("en-US", { maximumFractionDigits: 6 });
+}
+function S(e, n, o = {}) {
+  var u, l, h, f, a, d, m;
+  if (b(n)) return "empty";
+  const t = String(n), s = (l = (u = o.choices) == null ? void 0 : u[e]) == null ? void 0 : l[t];
+  if (s != null) return F(s);
+  const c = (f = (h = o.records) == null ? void 0 : h[e]) == null ? void 0 : f[t];
+  if (c != null) return c;
+  if (typeof n == "boolean" || ((a = o.types) == null ? void 0 : a[e]) === "boolean") {
+    if (n === !0 || t === "true" || t === "1") return "Yes";
+    if (n === !1 || t === "false" || t === "0") return "No";
+  }
+  const r = (d = o.formats) == null ? void 0 : d[e];
+  return (typeof n == "number" || /^\s*-?\d+(\.\d+)?\s*$/.test(t)) && (r || R.has(((m = o.types) == null ? void 0 : m[e]) ?? "")) ? z(Number(t), r) : typeof n == "object" ? JSON.stringify(n) : F(t);
+}
+function _(e) {
+  return e.length <= 1 ? e[0] ?? "" : `${e.slice(0, -1).join(", ")} or ${e[e.length - 1]}`;
+}
+function T(e) {
+  return e.length <= 1 ? e[0] ?? "" : `${e.slice(0, -1).join(", ")} and ${e[e.length - 1]}`;
+}
+function B(e) {
+  if (Array.isArray(e)) return e.map((o) => String(o));
+  if (e == null) return null;
+  const n = String(e).trim();
+  if (!n) return null;
+  if (n.startsWith("["))
+    try {
+      const o = JSON.parse(n);
+      return Array.isArray(o) ? o.map((t) => String(t)) : null;
+    } catch {
+      return null;
+    }
+  return n.split(",").map((o) => o.trim()).filter(Boolean);
+}
+const C = (e) => e && e[0].toUpperCase() + e.slice(1);
+function A(e, n, o, t = {}) {
+  if (!e) return null;
+  const s = v(e, t), c = n ?? "eq";
+  switch (c) {
+    case "null":
+      return `${s} is empty`;
+    case "nnull":
+      return `${s} is set`;
+    case "eq":
+      return b(o) ? `${s} is empty` : `${s} is ${S(e, o, t)}`;
+    case "neq":
+      return b(o) ? `${s} is set` : `${s} is not ${S(e, o, t)} (or is empty)`;
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte": {
+      if (b(o)) return null;
+      const r = { gt: "is over", gte: "is at least", lt: "is under", lte: "is at most" }[c];
+      return `${s} ${r} ${S(e, o, t)}`;
+    }
+    case "contains":
+      return b(o) ? null : `${s} contains “${String(o)}”`;
+    case "in": {
+      const r = B(o);
+      return r != null && r.length ? `${s} is ${_(r.map((i) => S(e, i, t)))}` : null;
+    }
+    default:
+      return null;
+  }
+}
+function U(e, n = {}) {
+  if (!Array.isArray(e) || e.length === 0) return null;
+  const o = [];
+  for (const t of e) {
+    if (!t || typeof t != "object" || !t.field) continue;
+    const s = A(t.field, t.op, t.value, n);
+    if (!s) return null;
+    o.push(s);
+  }
+  return o.length ? o.join(" and ") : null;
+}
+const I = {
+  _eq: "eq",
+  _neq: "neq",
+  _gt: "gt",
+  _gte: "gte",
+  _lt: "lt",
+  _lte: "lte",
+  _in: "in",
+  _contains: "contains"
+};
+function O(e, n = {}, o = "") {
+  if (!e || typeof e != "object" || Array.isArray(e)) return null;
+  const t = [];
+  for (const [s, c] of Object.entries(e)) {
+    if (s === "_and" || s === "_or") {
+      if (!Array.isArray(c) || c.length === 0) return null;
+      const l = c.map((h) => O(h, n, o));
+      if (l.some((h) => !h)) return null;
+      t.push(
+        s === "_and" ? l.join(" and ") : `either ${_(l)}`
+      );
+      continue;
+    }
+    if (s.startsWith("_")) return null;
+    const r = o ? `${o}.${s}` : s;
+    if (c === null || typeof c != "object" || Array.isArray(c)) {
+      const l = A(r, Array.isArray(c) ? "in" : "eq", c, n);
+      if (!l) return null;
+      t.push(l);
+      continue;
+    }
+    const i = Object.entries(c);
+    if (i.length === 0) return null;
+    if (!i.every(([l]) => l.startsWith("_"))) {
+      const l = O(c, n, r);
+      if (!l) return null;
+      t.push(l);
+      continue;
+    }
+    for (const [l, h] of i) {
+      let f;
+      if (l === "_null" ? f = A(r, h === !1 ? "nnull" : "null", null, n) : l === "_nnull" ? f = A(r, h === !1 ? "null" : "nnull", null, n) : I[l] ? f = A(r, I[l], h, n) : f = null, !f) return null;
+      t.push(f);
+    }
+  }
+  return t.length ? t.join(" and ") : null;
+}
+function k(e) {
+  if (!e) return null;
+  if (typeof e == "object" && !Array.isArray(e)) return e;
+  if (typeof e != "string") return null;
+  try {
+    const n = JSON.parse(e);
+    return n && typeof n == "object" && !Array.isArray(n) ? n : null;
+  } catch {
+    return null;
+  }
+}
+function H(e, n, o = {}) {
+  var d, m;
+  const t = (d = e.parent_field) == null ? void 0 : d.trim(), s = (m = e.filter_column) == null ? void 0 : m.trim();
+  if (!t || !s || !n.field) return null;
+  const c = v(n.field, o), r = v(t, o), i = n.relatedCollection ?? null, u = i ? N(i, o) : "records", l = i ? s.split(".").map((p, $) => $ === 0 ? w(i, p, o) : y(p)).join("’s ") : y(s), f = e.value_map && Object.keys(e.value_map).length > 0 ? `whose ${l} is mapped from this record’s ${r}` : e.filter_is_m2m ? `whose ${l} is one of this record’s ${r}` : `whose ${l} is this record’s ${r}`, a = [`${c} only offers ${u} ${f}.`];
+  return e.clear_on_parent_change !== !1 && a.push(`Changing ${r} clears ${c}.`), e.clear_on_unavailable && a.push(`A ${c} that no longer fits is cleared.`), a.push(
+    e.show_all_if_no_parent === !1 ? `${c} stays locked until ${r} is picked.` : `With no ${r} picked, it offers every one.`
+  ), e.upstream && a.push(`Picking a ${c} fills ${r} from it.`), a;
+}
+function D(e) {
+  return [e.first_name, e.last_name].filter(Boolean).join(" ").trim() || e.email || "someone";
+}
+function j(e) {
+  if (e == null || e === "") return [];
+  if (Array.isArray(e)) return e;
+  try {
+    const n = JSON.parse(e);
+    return Array.isArray(n) ? n : null;
+  } catch {
+    return null;
+  }
+}
+const M = /* @__PURE__ */ new Set(["eq", "neq", "gt", "gte", "lt", "lte", "in"]);
+function K(e, n, o = {}) {
+  const t = j(e.filters);
+  if (!t) return null;
+  const s = [
+    ...(e.users ?? []).map(D),
+    ...(e.teams ?? []).map((l) => l.name ? `the ${l.name} team` : "a team")
+  ], c = s.length ? s.length > 4 ? `${s.slice(0, 3).join(", ")} and ${s.length - 3} others` : T(s) : "nobody", r = s.length === 1 && !(e.teams ?? []).length ? "owns" : "own", i = n.stateLabel ? `${n.stateLabel}` : "this step";
+  if (e.is_default) return `When no other group matches, ${c} ${r} ${i}.`;
+  if (t.length === 0 || t.some((l) => !M.has(l.op ?? "eq"))) return null;
+  const u = U(
+    t.map((l) => ({ field: l.field, op: l.op ?? "eq", value: l.value })),
+    o
+  );
+  return u ? `When ${u}, ${c} ${r} ${i}.` : null;
+}
+function Q(e, n = {}) {
+  var a, d, m;
+  const o = ((a = e.to_states) != null && a.length ? e.to_states : e.to_state ? [e.to_state] : []).map(
+    (p) => {
+      var $;
+      return (($ = n.states) == null ? void 0 : $[p]) ?? p;
+    }
+  );
+  if (!o.length) return null;
+  const t = e.from_state ? ((d = n.states) == null ? void 0 : d[e.from_state]) ?? e.from_state : null, s = j(e.required_roles), c = j(e.condition_rules), r = j(e.requirements);
+  if (!s || !c || !r) return null;
+  const i = c.length ? U(c, n) : null;
+  if (c.length && !i) return null;
+  let u;
+  if (s.length) {
+    const p = s.map(($) => {
+      var g;
+      return (g = n.roles) == null ? void 0 : g[$];
+    }).filter(($) => !!$);
+    u = p.length === s.length ? _(p) : `people in ${s.length === 1 ? "one chosen role" : `one of ${s.length} chosen roles`}`;
+  } else u = "anyone who can edit the record";
+  e.require_owner && (u = e.allow_creator ? `the step’s owner or the record’s creator${s.length ? ` (in ${u})` : ""}` : `the step’s owner${s.length ? ` (in ${u})` : ""}`);
+  const l = e.to_previous ? `back to the step it came from (${_(o)} when that is not known)` : `to ${_(o)}`, h = `move it ${t ? `from ${t} ` : "from any step "}${l}`, f = [];
+  e.auto_trigger ? f.push(
+    C(`${i ? `when ${i}, ` : ""}it moves by itself ${t ? `from ${t} ` : ""}${l}.`)
+  ) : f.push(C(`${i ? `when ${i}, ` : ""}${u} can ${h}.`));
+  for (const p of r) {
+    if ((p == null ? void 0 : p.type) !== "child_fields" || !p.collection || !((m = p.fields) != null && m.length)) return null;
+    const $ = p.fields.map(
+      (g) => {
+        var W;
+        return ((W = p.labels) == null ? void 0 : W[g]) ?? w(p.collection, g, n);
+      }
+    );
+    f.push(
+      `Before it moves, every ${N(p.collection, n)} line needs ${T($)}.`
+    );
+  }
+  return e.comment_mode === "required" && f.push("A comment is required."), f;
+}
+const q = {
+  sum: "Sum of",
+  count: "Number of",
+  avg: "Average of",
+  min: "Smallest",
+  max: "Largest",
+  median: "Median of",
+  distinct_count: "Number of different",
+  weighted_avg: "Weighted average of"
+};
+function E(e, n) {
+  return e.replace(/\{\{\s*([A-Za-z_][A-Za-z0-9_.]*)\s*\}\}/g, (o, t) => n(t)).replace(/\bitem\.([A-Za-z_][A-Za-z0-9_]*)/g, (o, t) => n(t)).replace(/\s*\*\s*/g, " × ").replace(/\s*\/\s*/g, " ÷ ").replace(/\s+/g, " ").trim();
+}
+function Z(e, n) {
+  var f, a;
+  const o = typeof e.related_collection == "string" ? e.related_collection : null, t = typeof e.aggregate == "string" ? e.aggregate : null;
+  if (!o || !t || !q[t]) return null;
+  const s = N(o, n), c = (d) => w(o, d, n), r = [];
+  let i;
+  if (t === "count")
+    i = `${s} records`;
+  else {
+    const d = typeof e.value_formula == "string" ? e.value_formula.trim() : "", m = typeof e.value_field == "string" ? e.value_field : "";
+    if (d)
+      i = `(${E(d, c)})`, r.push(...P(d).map(c));
+    else if (m)
+      i = c(m), r.push(i);
+    else return null;
+    if (t === "weighted_avg") {
+      const p = typeof e.weight_field == "string" ? e.weight_field : "";
+      if (!p) return null;
+      i = `${i} weighted by ${c(p)}`, r.push(c(p));
+    }
+    i = `${i} on ${s}`;
+  }
+  const u = t === "distinct_count" ? `${q[t]} ${i}` : `${q[t]} ${i}`;
+  let l = "";
+  if (e.filter && typeof e.filter == "object" && Object.keys(e.filter).length > 0) {
+    const d = {
+      fields: ((f = n.relatedFields) == null ? void 0 : f[o]) ?? {},
+      choices: ((a = n.relatedChoices) == null ? void 0 : a[o]) ?? {},
+      collections: n.collections,
+      relatedFields: n.relatedFields
+    }, m = O(e.filter, d);
+    if (!m) return null;
+    l = ` where ${m}`;
+  }
+  const h = e.recursive ? ", counting every level below" : "";
+  return { text: `${u}${l}${h}`, inputs: r };
+}
+function X(e, n = {}, o = []) {
+  var c;
+  const t = (r) => v(r, n), s = e.computed_store === !0 || e.computed_store === 1;
+  switch (e.computed_type) {
+    case "rollup": {
+      const r = k(e.computed_formula);
+      if (!r) return null;
+      const u = (Array.isArray(r.sources) ? r.sources : [r]).map((a) => Z(a, n));
+      if (!u.length || u.some((a) => !a)) return null;
+      const l = u, h = [];
+      l.length > 1 && h.push("The figures above are added together.");
+      const f = r.parent_filter;
+      if (f && typeof f == "object" && Object.keys(f).length > 0) {
+        const a = O(f, n);
+        if (!a) return null;
+        h.push(`Only for records where ${a}; on other records it is typed in by hand.`);
+      }
+      return e.computed_store != null && h.push(
+        s ? "Saved on the record and recalculated when one of those records changes." : "Worked out each time the record is read."
+      ), {
+        sentence: `${l.map((a) => a.text).join(", plus ")}.`,
+        notes: h,
+        inputs: [...new Set(l.flatMap((a) => a.inputs))]
+      };
+    }
+    case "lookup": {
+      const r = k(e.computed_formula), i = typeof (r == null ? void 0 : r.fk_field) == "string" ? r.fk_field : null, u = typeof (r == null ? void 0 : r.source_field) == "string" ? r.source_field : null;
+      if (!i || !u) return null;
+      const l = (c = n.links) == null ? void 0 : c[i], h = l ? w(l, u, n) : y(u);
+      return {
+        sentence: `Copied from the ${t(i)}’s ${h} when ${t(i)} is set.`,
+        notes: [
+          `It keeps the value it copied, even if the ${t(i)} changes later; clearing ${t(i)} clears it.`
+        ],
+        inputs: [t(i)]
+      };
+    }
+    case "read":
+    case "write": {
+      const r = String(e.computed_formula ?? "").trim();
+      if (!r) return null;
+      const i = P(r).map(t);
+      return {
+        sentence: `Worked out as ${E(r, t)}.`,
+        notes: [
+          e.computed_type === "read" ? "Worked out each time the record is read; it is never saved." : `Saved on the record; worked out again when ${i.length ? _(i) : "an input"} changes.`
+        ],
+        inputs: i
+      };
+    }
+  }
+  for (const { field: r, config: i } of o) {
+    const u = k(i), l = k(u == null ? void 0 : u.field_map), h = typeof (u == null ? void 0 : u.source_collection) == "string" ? u.source_collection : null;
+    if (!l || !h) continue;
+    const f = l[e.field];
+    if (typeof f != "string" || !f.trim()) continue;
+    const a = typeof (u == null ? void 0 : u.source_fk_field) == "string" ? u.source_fk_field : r, d = f.split("||").map((g) => g.trim()).filter(Boolean), m = d.map(
+      (g) => g === "id" ? `the picked ${t(a)} itself` : w(h, g, n)
+    ), p = m.length === 1 ? d[0] === "id" ? m[0] : `the ${t(a)}’s ${m[0]}` : `the ${t(a)}’s ${m[0]} (or ${_(m.slice(1))} when that is empty)`, $ = (u == null ? void 0 : u.on_write) === !1 ? "picked on the form" : "set, on the form or through the API";
+    return {
+      sentence: `Filled from ${p} when ${t(a)} is ${$}.`,
+      notes: ["You can change it afterwards; a value someone typed is never overwritten."],
+      inputs: [t(a)]
+    };
+  }
+  return null;
+}
+const J = (e, n, o = `${n}s`) => `${e.toLocaleString("en-US")} ${e === 1 ? n : o}`;
+function G(e) {
+  if (e.length === 0) return "";
+  const n = e.slice(0, 3).map((t) => `“${t}”`), o = e.length - n.length;
+  return `${J(e.length, "form")} (${n.join(", ")}${o > 0 ? ` and ${o} more` : ""})`;
+}
+function L(e, n = [], o, t = {}) {
+  var c;
+  const s = {
+    ...t,
+    fields: { ...t.fields ?? {} },
+    types: { ...t.types ?? {} },
+    choices: { ...t.choices ?? {} },
+    links: { ...t.links ?? {} }
+  };
+  for (const r of e) {
+    (c = r.label) != null && c.trim() && (s.fields[r.field] = r.label.trim()), r.type && (s.types[r.field] = r.type);
+    let i = r.options;
+    if (typeof i == "string")
+      try {
+        i = JSON.parse(i);
+      } catch {
+        i = null;
+      }
+    const u = Array.isArray(i) ? i : i && typeof i == "object" ? i.choices : null;
+    if (!Array.isArray(u)) continue;
+    const l = {};
+    for (const h of u) {
+      if (!h || typeof h != "object") continue;
+      const { value: f, text: a } = h;
+      f != null && (l[String(f)] = F(a == null ? String(f) : String(a)));
+    }
+    Object.keys(l).length && (s.choices[r.field] = l);
+  }
+  for (const r of n)
+    (!o || r.many_collection === o) && r.many_field && r.one_collection && !r.junction_field && (s.links[r.many_field] = r.one_collection);
+  return s;
+}
+function x(e) {
+  var t;
+  const n = [];
+  e.forms.length && n.push(`It is on ${G(e.forms)}`);
+  const o = ((t = e.records) == null ? void 0 : t.with_value) ?? 0;
+  return e.records && o > 0 && n.push(`${J(o, "record")} ${o === 1 ? "has" : "have"} a ${e.fieldLabel}`), n.length ? `${n.join(" and ")}.` : null;
+}
+export {
+  T as andList,
+  N as collectionLabelOf,
+  H as describeCascadeFilter,
+  A as describeCondition,
+  U as describeConditionList,
+  x as describeFieldReach,
+  X as describeFieldSource,
+  O as describeFilterObject,
+  K as describeOwnerGroup,
+  Q as describeTransition,
+  v as fieldLabelOf,
+  E as formulaInWords,
+  _ as orList,
+  L as sentenceLabelsFromFields,
+  S as valueTextOf
+};

package/dist/shared/lib/core-glossary.js

@@ -0,0 +1,229 @@
+const d = [
+  {
+    slug: "collection",
+    term: "Collection",
+    hint: "A kind of record — one database table, such as Purchase Orders or Vendors.",
+    aliases: ["collections"]
+  },
+  {
+    slug: "field",
+    term: "Field",
+    hint: "One piece of information on a record, such as Status or Amount."
+  },
+  {
+    slug: "relation",
+    term: "Relation",
+    hint: "A link between two collections, such as a PO pointing at its Vendor.",
+    aliases: ["relations"]
+  },
+  {
+    slug: "junction",
+    term: "Junction",
+    hint: "A hidden table that links many records to many records (M2M)."
+  },
+  {
+    slug: "pipeline",
+    term: "Pipeline",
+    hint: "The steps a record moves through (states and the moves between them), with who owns each step.",
+    aliases: ["pipelines"]
+  },
+  {
+    slug: "state",
+    term: "State",
+    hint: "One step of a pipeline, such as Draft, Review or Approved.",
+    aliases: ["states"]
+  },
+  {
+    slug: "transition",
+    term: "Transition",
+    hint: "A move from one pipeline state to another, such as Submit or Approve.",
+    aliases: ["transitions"]
+  },
+  {
+    slug: "owner-group",
+    term: "Owner group",
+    hint: "The people who own a pipeline step for records that match its filters.",
+    aliases: ["owner groups"]
+  },
+  {
+    slug: "owner-matrix",
+    term: "Owner matrix",
+    hint: "The grid of owner groups per state and dimension — the most specific match owns the record."
+  },
+  {
+    slug: "dimension",
+    term: "Dimension",
+    hint: "A field the owner matrix splits ownership by, such as Zone or Category.",
+    aliases: ["dimensions"]
+  },
+  {
+    slug: "layout",
+    term: "Layout",
+    hint: "How a record form is arranged: its sections, fields and rules. Each record gets the best-matching form.",
+    aliases: ["layouts", "form layout"]
+  },
+  {
+    slug: "section",
+    term: "Section",
+    hint: "A titled block of fields on a form layout.",
+    aliases: ["sections"]
+  },
+  {
+    slug: "queue",
+    term: "Queue",
+    hint: "A worklist of records from one or more collections, split into My items, No owners and All items.",
+    aliases: ["queues", "worklist"]
+  },
+  {
+    slug: "scope",
+    term: "User Scope",
+    hint: "A person's own limits, such as their Zones: they only see records that belong to them.",
+    aliases: ["user scopes", "scope", "scopes"]
+  },
+  {
+    slug: "row-filter",
+    term: "Row filter",
+    hint: "A rule on a role that limits which records it can see or change, such as Status is Approved.",
+    aliases: ["row filters", "row rule", "row rules", "row-level security"]
+  },
+  {
+    slug: "policy",
+    term: "Policy",
+    hint: "What a role may do on one collection: see, add, edit or delete, and which fields.",
+    aliases: ["policies"]
+  },
+  {
+    slug: "role",
+    term: "Role",
+    hint: "A set of policies people share. Everyone has exactly one role.",
+    aliases: ["roles"]
+  },
+  {
+    slug: "rollup",
+    term: "Rollup",
+    hint: "A figure worked out from related records, such as the total of all lines on a PO.",
+    aliases: ["rollups"]
+  },
+  {
+    slug: "computed-field",
+    term: "Computed field",
+    hint: "A field whose value is calculated from other fields instead of typed in.",
+    aliases: ["computed fields", "formula field"]
+  },
+  {
+    slug: "addendum",
+    term: "Addendum",
+    hint: "A change request attached to a record, approved on its own before it changes the record.",
+    aliases: ["addendums", "amendment"]
+  },
+  {
+    slug: "picker",
+    term: "Picker",
+    hint: "The dropdown that chooses a related record, such as the Vendor picker on a PO.",
+    aliases: ["pickers"]
+  },
+  {
+    slug: "hidden-from-pickers",
+    term: "Hidden from pickers",
+    hint: "Never offered in any dropdown, but still in lists, search, reports and the API.",
+    aliases: ["hide from pickers"]
+  },
+  {
+    slug: "cascade",
+    term: "Cascade",
+    hint: "A picker narrowed by another field, such as Sites only for the chosen Zone.",
+    aliases: ["cascades", "cascading picker"]
+  },
+  {
+    slug: "display-template",
+    term: "Display template",
+    hint: "How a related record is named in lists and pickers, such as {{number}} — {{vendor}}."
+  },
+  {
+    slug: "flow",
+    term: "Flow",
+    hint: "An automation: when something happens, run steps such as send mail or update a record.",
+    aliases: ["flows"]
+  },
+  {
+    slug: "sla",
+    term: "SLA",
+    hint: "A deadline for a record in a state; it turns at risk, then breached, as time runs out.",
+    aliases: ["deadline", "deadlines"]
+  },
+  {
+    slug: "field-rule",
+    term: "Field rule",
+    hint: "A rule that fills, shows, hides or locks a field depending on other values.",
+    aliases: ["field rules"]
+  },
+  {
+    slug: "edit-lock",
+    term: "Edit lock",
+    hint: "While someone is editing a record, others can read it but not save over them."
+  },
+  {
+    slug: "workspace",
+    term: "Workspace",
+    hint: "A separate set of collections and roles inside one instance.",
+    aliases: ["workspaces"]
+  },
+  {
+    slug: "custom-query",
+    term: "Custom query",
+    hint: "Saved SQL that dashboards, reports and pickers can use.",
+    aliases: ["custom queries"]
+  },
+  {
+    slug: "record-template",
+    term: "Record template",
+    hint: "Saved values that pre-fill a new record.",
+    aliases: ["record templates"]
+  },
+  {
+    slug: "bulk-action",
+    term: "Bulk action",
+    hint: "One change applied to many selected records at once.",
+    aliases: ["bulk actions"]
+  }
+], c = d.map((e, i) => ({
+  id: -(i + 1),
+  term: e.term,
+  slug: e.slug,
+  aliases: e.aliases ?? [],
+  definition: e.hint,
+  ui_hint: e.hint,
+  query_slug: null,
+  query_note: null,
+  collection: null,
+  updated_at: null,
+  builtin: !0
+}));
+function u(e) {
+  var r, s;
+  const i = (r = e.ui_hint) == null ? void 0 : r.trim();
+  if (i) return i;
+  const o = (e.definition ?? "").trim().replace(/\s+/g, " "), t = ((s = o.match(/^.+?[.!?](?=\s|$)/)) == null ? void 0 : s[0]) ?? o;
+  return t.length > 160 ? `${t.slice(0, 157).trimEnd()}…` : t;
+}
+const a = (e) => e.trim().toLowerCase();
+function h(e, i) {
+  const o = /* @__PURE__ */ new Map();
+  for (const s of e) for (const n of [s.slug, s.term, ...s.aliases]) o.set(a(n), s);
+  const t = /* @__PURE__ */ new Map(), r = [];
+  for (const s of i) {
+    const n = [s.slug, s.term, ...s.aliases ?? []].map((l) => o.get(a(l))).find((l) => !!l);
+    n && !t.has(n.slug) ? t.set(n.slug, { ...s, overrides: n.slug }) : r.push(s);
+  }
+  return [...e.map((s) => t.get(s.slug) ?? s), ...r];
+}
+function m(e, i) {
+  const o = a(i);
+  return e.find((t) => a(t.slug) === o || t.overrides && a(t.overrides) === o) ?? e.find((t) => a(t.term) === o || t.aliases.some((r) => a(r) === o)) ?? null;
+}
+export {
+  c as CORE_GLOSSARY,
+  m as findGlossaryTerm,
+  h as mergeGlossary,
+  u as uiHint
+};