@ai-matrx/records-ui 0.93.72 → 0.93.73

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog — @ai-matrx/records-ui
 
+## 0.93.73
+
+Automatic changed-only republish (docs/metadata drift since the last tag — see
+`git diff npm/records-ui/v0.93.72..npm/records-ui/v0.93.73 -- apps/shared/records-ui`).
+No source changes intended and no consumer action required.
+
 ## 0.93.72
 ### Unreleased
 

package/dist/index.cjs

@@ -9596,55 +9596,206 @@ var import_react51 = require("react");
 var import_react52 = require("@ai-matrx/records/react");
 var import_records17 = require("@ai-matrx/records");
 var import_data_table8 = require("@ai-matrx/design-system/data-table");
-var MEASURE_OPS = [
-  { op: "sum", word: "Sum of", additive: true },
-  { op: "avg", word: "Average", additive: false },
-  { op: "min", word: "Lowest", additive: false },
-  { op: "max", word: "Highest", additive: false },
-  { op: "median", word: "Median", additive: false }
-];
-var DIMENSION_KINDS = {
-  select: "choice",
-  checkbox: "boolean",
-  text: "text",
-  datetime: "time"
-};
-function drillDimensionsFor(fields, options) {
-  const out = [];
-  for (const field2 of fields) {
-    const kind = DIMENSION_KINDS[String(editorKindFor(field2))];
-    if (!kind) continue;
-    if (field2.multi) continue;
-    const dim = { key: field2.key, label: fieldName(field2), kind };
-    if (kind === "text") dim.cardinality = "high";
-    if (kind === "choice" && isChoiceField(field2)) {
+var ADDITIVE_OPS = /* @__PURE__ */ new Set(["count", "sum", "filled", "empty"]);
+function drillDimensionsOf(def, labels) {
+  if (!def) return [];
+  return def.dimensions.map((d) => {
+    const dim = { key: d.key, label: d.label, kind: d.kind };
+    if (d.cardinality) dim.cardinality = d.cardinality;
+    if (d.grains) dim.grains = d.grains.filter((g) => g !== "hour");
+    const choices = new Map((d.choices ?? []).map((c) => [c.value, c.label]));
+    if (d.kind === "choice" || d.kind === "relation") {
       dim.labelFor = (value) => {
         if (value === null || value === "") return "No value";
-        return optionFor(options.get(field2.key), value)?.label ?? value;
+        return choices.get(value) ?? labels.get(d.key)?.get(value) ?? value;
       };
     }
-    out.push(dim);
-  }
-  return out;
+    return dim;
+  });
 }
-function drillMeasuresFor(fields) {
-  const out = [{ key: "count", label: "Count", additive: true }];
-  for (const field2 of fields) {
-    const kind = String(editorKindFor(field2));
-    if (kind !== "number" && kind !== "currency" && kind !== "percent") continue;
-    for (const m of MEASURE_OPS) {
-      out.push({ key: `${m.op}_${field2.key}`, label: `${m.word} ${fieldName(field2)}`, additive: m.additive });
-    }
+function drillMeasuresOf(def) {
+  if (!def) return [];
+  return def.measures.map((m) => ({ key: m.key, label: m.label, additive: m.additive ?? ADDITIVE_OPS.has(m.op) }));
+}
+function drillPathsOf(def) {
+  return (def?.paths ?? []).map((p) => p.levels);
+}
+function useDrillDefinition(source) {
+  const client = (0, import_react52.useRecordsClient)();
+  const key = source ? JSON.stringify(source) : null;
+  const [state, setState] = (0, import_react51.useState)({ key: null, def: null, error: null });
+  (0, import_react51.useEffect)(() => {
+    if (!key) return;
+    let cancelled = false;
+    void client.drillDescribe({ source: JSON.parse(key) }).then((got) => {
+      if (cancelled) return;
+      setState(got.ok ? { key, def: got.data ?? null, error: null } : { key, def: null, error: got.error.message || "This table's groupings could not be read." });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [client, key]);
+  return state.key === key ? { def: state.def, error: state.error } : { def: null, error: null };
+}
+function drillWhere(base, trail, booleans) {
+  const where = { ...base ?? {} };
+  for (const w of trail) {
+    const { key, grain } = (0, import_data_table8.parseDimensionRef)(w.dim);
+    if (grain) where[w.dim] = w.value;
+    else if (booleans.has(key) && (w.value === "true" || w.value === "false")) where[key] = w.value === "true";
+    else where[key] = w.value;
   }
-  return out;
+  return where;
 }
-function measureFor(key) {
+function rowOf(row) {
+  const groups = {};
+  for (const [k, v] of Object.entries(row.groups ?? {})) groups[k] = v === null || v === void 0 ? null : String(v);
+  const measures = {};
+  for (const [k, v] of Object.entries(row.measures ?? {})) measures[k] = v === null || v === void 0 ? null : Number(v);
+  return { groups, measures, row_count: Number(row.row_count ?? 0) };
+}
+function storeMeasure(key) {
   if (key === "count") return { op: "count" };
   const at = key.indexOf("_");
   if (at <= 0) return null;
-  const op2 = key.slice(0, at);
-  if (!MEASURE_OPS.some((m) => m.op === op2)) return null;
-  return { op: op2, key: key.slice(at + 1) };
+  return { op: key.slice(0, at), key: key.slice(at + 1) };
+}
+function useDrillAnswers(args) {
+  const client = (0, import_react52.useRecordsClient)();
+  const { source, question, enabled, version } = args;
+  const [answers, setAnswers] = (0, import_react51.useState)({});
+  const [labels, setLabels] = (0, import_react51.useState)(() => /* @__PURE__ */ new Map());
+  const [error, setError] = (0, import_react51.useState)(null);
+  const [says, setSays] = (0, import_react51.useState)([]);
+  const askKey2 = JSON.stringify({
+    source,
+    by: question.by,
+    across: question.across ?? null,
+    show: question.show,
+    where: args.where,
+    rule: args.rule && (0, import_records17.isRuleFilter)(args.rule) ? args.rule : null
+  });
+  (0, import_react51.useEffect)(() => {
+    if (!enabled || !source || question.by.length === 0) return;
+    const asked2 = JSON.parse(askKey2);
+    let cancelled = false;
+    setAnswers({});
+    setError(null);
+    const requests = (0, import_data_table8.drillRequests)({ by: asked2.by, across: asked2.across, show: asked2.show, where: [] });
+    void Promise.all(
+      requests.map(async (request) => {
+        if (asked2.rule && asked2.source.kind === "table") {
+          const time = request.by.find((ref) => (0, import_data_table8.parseDimensionRef)(ref).grain !== null) ?? null;
+          const t = time ? (0, import_data_table8.parseDimensionRef)(time) : null;
+          const measures = asked2.show.map(storeMeasure).filter((m) => m !== null);
+          const got2 = await client.recordAggregate({
+            table_id: asked2.source.id,
+            groupBy: request.by.filter((ref) => ref !== time),
+            measures,
+            bucket: t && t.grain ? { key: t.key, by: t.grain } : null,
+            filter: asked2.rule,
+            limit: 200
+          });
+          if (!got2.ok) return { request, error: got2.error.message };
+          return {
+            request,
+            rows: (got2.data ?? []).map((row) => {
+              const groups = {};
+              for (const ref of request.by) {
+                const k = ref === time && t ? t.key : ref;
+                groups[ref] = row.groups[k] ?? null;
+              }
+              return { groups, measures: row.measures, row_count: row.row_count };
+            }),
+            labels: {},
+            says: []
+          };
+        }
+        const got = await client.drillAsk({
+          source: asked2.source,
+          question: { by: request.by, show: asked2.show, where: asked2.where }
+        });
+        if (!got.ok) return { request, error: got.error.message || "The groups could not be read." };
+        const answer = got.data;
+        const kind = request.by.length === 0 ? "total" : "group";
+        const rows = answer.rows.filter((r) => r.kind === kind && (kind === "group" || !r.groups || Object.keys(r.groups).length === 0)).map(rowOf);
+        const found = {};
+        for (const r of answer.rows) {
+          for (const [dim, text] of Object.entries(r.labels ?? {})) {
+            const value = r.groups?.[dim];
+            if (value === null || value === void 0) continue;
+            (found[dim] ??= {})[String(value)] = text;
+          }
+        }
+        return { request, rows, labels: found, says: answer.says };
+      })
+    ).then((results) => {
+      if (cancelled) return;
+      const failed = results.find((r) => "error" in r);
+      if (failed) {
+        setError(failed.error);
+        return;
+      }
+      const out = {};
+      const nextLabels = /* @__PURE__ */ new Map();
+      const sentences = [];
+      for (const r of results) {
+        if (!("rows" in r)) continue;
+        out[r.request.key] = r.rows;
+        for (const [dim, map] of Object.entries(r.labels ?? {})) {
+          const held = nextLabels.get(dim) ?? /* @__PURE__ */ new Map();
+          for (const [v, t] of Object.entries(map)) held.set(v, t);
+          nextLabels.set(dim, held);
+        }
+        for (const s of r.says ?? []) if (!sentences.includes(s)) sentences.push(s);
+      }
+      setLabels(nextLabels);
+      setSays(sentences);
+      setAnswers(out);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [client, askKey2, enabled, version, question.by.length]);
+  return { answers, labels, error, says };
+}
+function drillQuestionFor(question, def) {
+  if (!def) return question;
+  const known = (ref) => def.dimensions.some((d) => d.key === (0, import_data_table8.parseDimensionRef)(ref).key);
+  const show = question.show.filter((key) => def.measures.some((m) => m.key === key));
+  return {
+    ...question,
+    by: question.by.filter(known),
+    across: question.across && known(question.across) ? question.across : null,
+    show: show.length > 0 ? show : [def.measures[0]?.key ?? "count"],
+    where: question.where.filter((w) => known(w.dim))
+  };
+}
+function useDrill(args) {
+  const enabled = args.enabled ?? true;
+  const { def, error: describeError } = useDrillDefinition(enabled ? args.source : null);
+  const question = (0, import_react51.useMemo)(() => drillQuestionFor(args.question, def), [args.question, def]);
+  const booleans = (0, import_react51.useMemo)(() => new Set((def?.dimensions ?? []).filter((d) => d.kind === "boolean").map((d) => d.key)), [def]);
+  const where = (0, import_react51.useMemo)(() => drillWhere(args.filter, question.where, booleans), [args.filter, question.where, booleans]);
+  const { answers, labels, error } = useDrillAnswers({
+    source: args.source,
+    question,
+    where,
+    rule: args.rule,
+    version: args.version,
+    enabled: enabled && def !== null
+  });
+  const dimensions = (0, import_react51.useMemo)(() => drillDimensionsOf(def, labels), [def, labels]);
+  const measures = (0, import_react51.useMemo)(() => drillMeasuresOf(def), [def]);
+  const paths = (0, import_react51.useMemo)(() => drillPathsOf(def), [def]);
+  const { onQuestionChange } = args;
+  const rowNoun = args.rowNoun ?? "record";
+  const rootLabel = args.rootLabel ?? "All records";
+  const config = (0, import_react51.useMemo)(() => {
+    if (!enabled || !def || dimensions.length === 0) return null;
+    return { dimensions, measures, paths, question, answers, error: describeError ?? error, rowNoun, rootLabel, onQuestionChange };
+  }, [enabled, def, dimensions, measures, paths, question, answers, describeError, error, rowNoun, rootLabel, onQuestionChange]);
+  return { config, def };
 }
 function questionFromGrouping(grouping) {
   if (!grouping) return { by: [], across: null, show: ["count"], where: [] };
@@ -9705,110 +9856,49 @@ function filterWithTrail(fields, base, trail) {
   }
   return { op: "and", args };
 }
-function useDrillAnswers(args) {
-  const client = (0, import_react52.useRecordsClient)();
-  const { tableId, question, enabled, version } = args;
-  const [answers, setAnswers] = (0, import_react51.useState)({});
-  const [error, setError] = (0, import_react51.useState)(null);
-  const askKey2 = JSON.stringify({ by: question.by, across: question.across ?? null, show: question.show, filter: args.filter ?? null });
-  (0, import_react51.useEffect)(() => {
-    if (!enabled || question.by.length === 0) return;
-    const asked2 = JSON.parse(askKey2);
-    const measures = asked2.show.map(measureFor).filter((m) => m !== null);
-    if (!measures.some((m) => m.op === "count")) measures.unshift({ op: "count" });
-    let cancelled = false;
-    setAnswers({});
-    setError(null);
-    const requests = (0, import_data_table8.drillRequests)({ by: asked2.by, across: asked2.across, show: asked2.show, where: [] });
-    void Promise.all(
-      requests.map(async (request) => {
-        const time = request.by.find((ref) => (0, import_data_table8.parseDimensionRef)(ref).grain !== null) ?? null;
-        const plain = request.by.filter((ref) => ref !== time);
-        const grain = time ? (0, import_data_table8.parseDimensionRef)(time) : null;
-        const got = await client.recordAggregate({
-          table_id: tableId,
-          groupBy: plain,
-          measures,
-          bucket: grain && grain.grain ? { key: grain.key, by: grain.grain } : null,
-          ...asked2.filter ? { filter: asked2.filter } : {},
-          limit: 200
-        });
-        if (!got.ok) return { request, error: got.error.message || "The groups could not be read." };
-        const rows = (got.data ?? []).map((row) => {
-          const groups = {};
-          for (const ref of plain) groups[ref] = row.groups[ref] ?? null;
-          if (time && grain) groups[time] = row.groups[grain.key] ?? null;
-          return { groups, measures: row.measures, row_count: row.row_count };
-        });
-        return { request, rows };
-      })
-    ).then((results) => {
-      if (cancelled) return;
-      const failed = results.find((r) => "error" in r);
-      if (failed) {
-        setError(failed.error);
-        return;
-      }
-      const out = {};
-      for (const r of results) if ("rows" in r) out[r.request.key] = r.rows;
-      setAnswers(out);
-    });
-    return () => {
-      cancelled = true;
-    };
-  }, [client, tableId, askKey2, enabled, version, question.by.length]);
-  return { answers, error };
-}
 function useGridDrillQuestion(args) {
-  const { fields, presentation, filter } = args;
-  const choiceKeys = (0, import_react51.useMemo)(() => fields.filter((f) => isChoiceField(f) && !f.multi).map((f) => f.key), [fields]);
-  const options = useChoiceOptions(fields, args.enabled ? choiceKeys : []);
-  const dimensions = (0, import_react51.useMemo)(() => drillDimensionsFor(fields, options), [fields, options]);
-  const measures = (0, import_react51.useMemo)(() => drillMeasuresFor(fields), [fields]);
+  const { tableId, fields, presentation, filter } = args;
+  const source = (0, import_react51.useMemo)(() => ({ kind: "table", id: tableId }), [tableId]);
+  const { def } = useDrillDefinition(args.enabled ? source : null);
   const saved = (0, import_react51.useMemo)(() => questionFromGrouping(presentation.grouping), [presentation.grouping]);
   const url = (0, import_data_table8.useDrillUrlState)({ fallback: saved });
-  const question = (0, import_react51.useMemo)(() => {
-    const known = (ref) => dimensions.some((d) => d.key === (0, import_data_table8.parseDimensionRef)(ref).key);
-    const show = url.question.show.filter((key) => measures.some((m) => m.key === key));
-    return {
-      ...url.question,
-      by: url.question.by.filter(known),
-      across: url.question.across && known(url.question.across) ? url.question.across : null,
-      show: show.length > 0 ? show : ["count"],
-      where: url.question.where.filter((w) => known(w.dim))
-    };
-  }, [url.question, dimensions, measures]);
-  const enabled = args.enabled && dimensions.length > 0;
+  const question = (0, import_react51.useMemo)(() => drillQuestionFor(url.question, def), [url.question, def]);
+  const enabled = args.enabled && def !== null && def.dimensions.length > 0;
   const trailFilter = (0, import_react51.useMemo)(
     () => enabled ? filterWithTrail(fields, filter, question.where) : filter,
     [enabled, fields, filter, question.where]
   );
-  return { enabled, dimensions, measures, question, setQuestion: url.setQuestion, trailFilter };
+  return { enabled, source, def, question, setQuestion: url.setQuestion, filter, trailFilter };
 }
 function useGridDrillConfig(args) {
-  const { tableId, state, presentation, onPresentationChange, version } = args;
-  const { enabled, dimensions, measures, question, setQuestion, trailFilter } = state;
-  const { answers, error } = useDrillAnswers({ tableId, question, filter: trailFilter, version, enabled });
-  return (0, import_react51.useMemo)(() => {
-    if (!enabled) return null;
-    return {
-      dimensions,
-      measures,
-      question,
-      answers,
-      error,
-      rootLabel: "All records",
-      rowNoun: "record",
-      onQuestionChange: (next) => {
-        setQuestion(next);
-        if (onPresentationChange) {
-          const grouping = groupingFromQuestion(next, presentation.grouping);
-          const { grouping: _dropped, ...rest } = presentation;
-          onPresentationChange(grouping ? { ...rest, grouping } : rest);
-        }
+  const { state, presentation, onPresentationChange, version } = args;
+  const { setQuestion } = state;
+  const onQuestionChange = (0, import_react51.useMemo)(
+    () => (next) => {
+      setQuestion(next);
+      if (onPresentationChange) {
+        const grouping = groupingFromQuestion(next, presentation.grouping);
+        const { grouping: _dropped, ...rest } = presentation;
+        onPresentationChange(grouping ? { ...rest, grouping } : rest);
       }
-    };
-  }, [enabled, dimensions, measures, question, answers, error, setQuestion, onPresentationChange, presentation]);
+    },
+    [setQuestion, onPresentationChange, presentation]
+  );
+  const flat = state.filter && !(0, import_records17.isRuleFilter)(state.filter) ? state.filter : void 0;
+  const rule = state.filter && (0, import_records17.isRuleFilter)(state.filter) ? filterWithTrailRuleOnly(state) : void 0;
+  const { config } = useDrill({
+    source: state.source,
+    question: state.question,
+    onQuestionChange,
+    filter: flat,
+    rule,
+    version,
+    enabled: state.enabled
+  });
+  return config;
+}
+function filterWithTrailRuleOnly(state) {
+  return state.trailFilter;
 }
 
 // src/Enrich.tsx
@@ -13554,7 +13644,7 @@ function useGridAssist(args) {
     (ok, message) => ok ? host.notify?.success(message) : host.notify?.error(message),
     [host.notify]
   );
-  const rowOf = (0, import_react71.useCallback)((rowId) => rows.find((r) => r.id === rowId), [rows]);
+  const rowOf2 = (0, import_react71.useCallback)((rowId) => rows.find((r) => r.id === rowId), [rows]);
   const titleOf = (0, import_react71.useCallback)(
     (row) => row ? recordNameIn(table, row.document ?? {}) : "",
     [table]
@@ -13644,18 +13734,18 @@ function useGridAssist(args) {
   );
   const openWhole = (0, import_react71.useCallback)(
     (rowId, key) => {
-      const row = rowOf(rowId);
+      const row = rowOf2(rowId);
       if (!row) return;
       const document2 = row.document ?? {};
       const value = editing.valueFor(row, fieldOf2(key));
       const pointer = typeof document2[key] === "string" ? (0, import_core9.wholeValueOf)(document2, key) : null;
       setWhole({ rowId, key, rowTitle: titleOf(row), value, pointer });
     },
-    [rowOf, fieldOf2, titleOf, editing]
+    [rowOf2, fieldOf2, titleOf, editing]
   );
   const cellItems = (0, import_react71.useCallback)(
     (rowId, columnId) => {
-      const row = rowOf(rowId);
+      const row = rowOf2(rowId);
       const field2 = fieldOf2(columnId);
       if (!row || !field2) return [];
       const items = [];
@@ -13680,11 +13770,11 @@ function useGridAssist(args) {
       items.push(...refItem("cell-reference", "Copy cell reference", refFor.cell(row, field2), "The cell"));
       return items;
     },
-    [rowOf, fieldOf2, openWhole, host.cleanText, editing, args, refItem, refFor]
+    [rowOf2, fieldOf2, openWhole, host.cleanText, editing, args, refItem, refFor]
   );
   const rowItems = (0, import_react71.useCallback)(
     (rowId) => {
-      const row = rowOf(rowId);
+      const row = rowOf2(rowId);
       const askAgent = args.askAgent;
       return [
         ...rowActionMenuItems({
@@ -13699,7 +13789,7 @@ function useGridAssist(args) {
         ...row ? refItem("row-reference", "Copy row reference", refFor.row(row), "The row") : []
       ];
     },
-    [rowOf, args, fields, refItem, refFor]
+    [rowOf2, args, fields, refItem, refFor]
   );
   const tableItems = (0, import_react71.useCallback)(
     () => refItem("table-reference", "Copy table reference", refFor.table(), "The table"),
@@ -14630,6 +14720,7 @@ function Grid({
     [merged, fields.data, filter, query.columnFilters]
   );
   const drillState = useGridDrillQuestion({
+    tableId,
     fields: fields.data ?? NO_DRILL_FIELDS,
     presentation,
     filter: question.filter,