@ai-matrx/records-ui 0.107.5 → 0.109.1

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog — @ai-matrx/records-ui
 
+## 0.109.1
+
+Release of 0.109.0's SSR-ROWS work (its publish gate stopped at the new test's untyped `jsdom` import; the test now types the one constructor it uses). No source change.
+
+**Consumer action:** none.
+
+## 0.109.0
+### Archive record from the row menu works
+
+- The grid's row menu "Archive record" opens its confirm once the menu has closed (`afterMenuLayerCloses`, exported from `gridControls`); opened inside the menu's select callback, the closing menu dismissed it at once (always inside a contenteditable host such as a Space), so the press did nothing. A row the page no longer holds says so. No consumer action.
+
+### SSR-ROWS: the table page arrives with its rows
+
+- NEW in `@ai-matrx/records-ui/first-page`: `askTablePageSeed({ dataSource, organizationId, tableId, actor, recordId?, rows?, embedded?, pageSize? })` — a host's server asks, AS THE PERSON, the table's bundle, the grid's exact first page (`firstGridPageRequest`) and on a record page the record's bundle, and gets a `RecordsSeed`. Mount `<RecordsSeedProvider seed>` (`@ai-matrx/records/react`) above `TablePage` and the page is drawn — rows included — in the server's HTML, then hydrates with no mismatch and no page read. `embedded: true` asks the embedded table's page size (`EMBEDDED_PAGE_SIZE`, now declared here).
+- `first-page` is built WITHOUT the package's "use client" banner (its own tsup entry), so a server component can call it; `presentation.ts` reads `parseTableStyle` from `@ai-matrx/design-system/data-table/table-style` (client-free) for the same reason.
+- `TablePage` starts from the seed's saved views and looks (`useSeededAnswer`), so it knows its face in the first pass instead of drawing its skeleton until two effects land; `ViewBar` takes `initialViews` and skips its mount read. Without a seed both read exactly as before.
+
+**Consumer action:** none (additive). Spaces: ask `askTablePageSeed({ …, embedded: true })` in the route and wrap the inline table in `<RecordsSeedProvider>`.
+
+## 0.108.0
+### PAGE-BUNDLE-2: the grid's first page, asked before the grid exists
+
+NEW ENTRY `@ai-matrx/records-ui/first-page` (server-safe, no React): `firstGridPageRequest(client, tableId)` and the pure `firstGridPageArgs({ tableId, table, fields, shown })` build the EXACT `custom.read_records_page` arguments the table page's grid sends on open (the bar's default view with the person's look over it, the view's sort else the table's `default_sort`, page size 100). Null for a grouped, drilled, filtered, hand-ordered, Rule or non-grid view. A test renders the grid and holds the two byte-equal.
+
+**Consumer action:** none (additive). A server-rendered host seeds the first page by door name + these arguments.
+
 ## 0.107.5
 
 TYPEFORM-2: no keystroke is lost while the store works out a branching form's route. Keys typed after Enter are held and land in the next question (appended to a text answer, replayed as keys on a choice so a letter picks). Walk: type straight on after Enter.

package/dist/first-page.cjs

@@ -0,0 +1,435 @@
+'use strict';
+
+var core = require('@ai-matrx/records/core');
+var records = require('@ai-matrx/records');
+require('@ai-matrx/kit/text-case');
+require('@ai-matrx/design-system/data-table');
+var tableStyle = require('@ai-matrx/design-system/data-table/table-style');
+require('@ai-matrx/design-system/field-formats');
+
+// src/firstPage.ts
+var kernelId = (name) => records.KERNEL_TABLES.find((t) => t.name === name)?.id ?? "";
+var KERNEL_FILE_TABLE = kernelId("File");
+var KERNEL_PERSON_TABLE = kernelId("Person");
+Object.fromEntries(
+  records.PARITY_FIELD_TYPES.map((p) => [p.parity_type, p.made_of])
+);
+var KERNEL = { file: KERNEL_FILE_TABLE, person: KERNEL_PERSON_TABLE };
+function editorKindFor(field) {
+  return records.fieldKindFor(field, KERNEL);
+}
+
+// src/gridLook.ts
+function defaultSortOf(table, fields) {
+  const raw = table?.default_sort ?? null;
+  const first = Array.isArray(raw) ? raw[0] : raw;
+  let name = null;
+  let direction = "asc";
+  if (typeof first === "string") {
+    const trimmed = first.trim();
+    if (trimmed === "") return null;
+    if (trimmed.startsWith("-")) {
+      name = trimmed.slice(1).trim();
+      direction = "desc";
+    } else {
+      const [head, tail] = trimmed.split(/\s+/);
+      name = head ?? null;
+      if (tail && tail.toLowerCase() === "desc") direction = "desc";
+    }
+  } else if (first && typeof first === "object") {
+    const entry = first;
+    const named = entry["field"] ?? entry["key"] ?? entry["id"];
+    name = typeof named === "string" ? named : null;
+    if (String(entry["direction"] ?? "").toLowerCase() === "desc") direction = "desc";
+  }
+  if (!name) return null;
+  const field = fields.find((f) => f.key === name) ?? fields.find((f) => f.id === name);
+  return field ? { id: field.key, direction } : null;
+}
+function holdsNumbers(field) {
+  const kind = String(editorKindFor(field));
+  if (kind === "number" || kind === "currency" || kind === "percent") return true;
+  return String((field.config ?? {})["system"] ?? "") === "autonumber";
+}
+function sortAsFor(field) {
+  const kind = String(editorKindFor(field));
+  if (holdsNumbers(field)) return "number";
+  if (kind === "datetime") return "date";
+  return "text";
+}
+function pageSortFor(fields, sort) {
+  if (!sort) return [];
+  const field = fields.find((f) => f.key === sort.id);
+  if (!field) return [];
+  return [{ field: field.key, direction: sort.direction === "desc" ? "desc" : "asc", as: sortAsFor(field) }];
+}
+var MIN_ROW_HEIGHT = 24;
+var MAX_ROW_HEIGHT = 96;
+var AGGREGATE_KINDS = [
+  "count",
+  "sum",
+  "average",
+  "min",
+  "max",
+  "empty",
+  "filled",
+  "unique",
+  "checked",
+  "unchecked",
+  "percentFilled"
+];
+var GROUP_ORDERS = [
+  "value-asc",
+  "value-desc",
+  "count-desc",
+  "first-seen"
+];
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function parseGridPresentation(raw) {
+  let value = raw;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "") return {};
+    try {
+      value = JSON.parse(trimmed);
+    } catch {
+      return {};
+    }
+  }
+  if (!isRecord(value)) return {};
+  const out = {};
+  const style = tableStyle.parseTableStyle(value["style"]);
+  if (!tableStyle.tableStyleIsEmpty(style)) out.style = style;
+  if (isRecord(value["formats"])) {
+    const formats = {};
+    for (const [key, cfg] of Object.entries(value["formats"])) {
+      if (!isRecord(cfg)) continue;
+      const id = cfg["id"];
+      if (typeof id !== "string") continue;
+      const options = cfg["options"];
+      formats[key] = isRecord(options) ? {
+        id,
+        options
+      } : { id };
+    }
+    if (Object.keys(formats).length > 0) out.formats = formats;
+  }
+  if (Array.isArray(value["frozen"])) {
+    const frozen = value["frozen"].filter((k) => typeof k === "string");
+    if (frozen.length > 0) out.frozen = frozen;
+  }
+  const grouping = parseGrouping(value["grouping"]);
+  if (grouping) out.grouping = grouping;
+  if (isRecord(value["widths"])) {
+    const widths = {};
+    for (const [key, raw2] of Object.entries(value["widths"])) {
+      if (typeof raw2 !== "number" || !Number.isFinite(raw2) || raw2 <= 0) continue;
+      widths[key] = Math.round(raw2);
+    }
+    if (Object.keys(widths).length > 0) out.widths = widths;
+  }
+  const rowHeight = value["rowHeight"];
+  if (typeof rowHeight === "number" && Number.isFinite(rowHeight) && rowHeight >= MIN_ROW_HEIGHT && rowHeight <= MAX_ROW_HEIGHT) {
+    out.rowHeight = Math.round(rowHeight);
+  }
+  if (Array.isArray(value["hiddenFields"])) {
+    const hiddenFields = value["hiddenFields"].filter((k) => typeof k === "string");
+    if (hiddenFields.length > 0) out.hiddenFields = hiddenFields;
+  }
+  if (Array.isArray(value["cardHidden"])) {
+    out.cardHidden = value["cardHidden"].filter((k) => typeof k === "string");
+  }
+  if (Array.isArray(value["columnOrder"])) {
+    const columnOrder = value["columnOrder"].filter((k) => typeof k === "string");
+    if (columnOrder.length > 0) out.columnOrder = columnOrder;
+  }
+  const gallerySize = value["gallerySize"];
+  if (gallerySize === "small" || gallerySize === "medium" || gallerySize === "large") {
+    out.gallerySize = gallerySize;
+  }
+  if (typeof value["wrap"] === "boolean") out.wrap = value["wrap"];
+  if (Array.isArray(value["wrapColumns"])) {
+    const wrapColumns = value["wrapColumns"].filter((k) => typeof k === "string");
+    if (wrapColumns.length > 0) out.wrapColumns = wrapColumns;
+  }
+  const fit = value["fit"];
+  if (fit === "auto" || fit === "fit" || fit === "scroll") out.fit = fit;
+  if (typeof value["freezeFirst"] === "boolean") out.freezeFirst = value["freezeFirst"];
+  const footer = value["footer"];
+  if (footer === "sticky" || footer === "inline") out.footer = footer;
+  if (isRecord(value["summaries"])) {
+    const summaries = {};
+    for (const [key, op] of Object.entries(value["summaries"])) {
+      if (typeof op === "string" && op.trim() !== "") summaries[key] = op;
+    }
+    if (Object.keys(summaries).length > 0) out.summaries = summaries;
+  }
+  return out;
+}
+function parseGrouping(raw) {
+  if (!isRecord(raw)) return void 0;
+  const field = raw["field"];
+  if (typeof field !== "string" || field.trim() === "") return void 0;
+  const out = { field };
+  if (isRecord(raw["aggregates"])) {
+    const aggregates = {};
+    for (const [key, spec] of Object.entries(raw["aggregates"])) {
+      if (!isRecord(spec)) continue;
+      const kind = spec["kind"];
+      if (typeof kind !== "string") continue;
+      if (!AGGREGATE_KINDS.includes(kind)) continue;
+      const label = spec["label"];
+      aggregates[key] = typeof label === "string" ? { kind, label } : { kind };
+    }
+    if (Object.keys(aggregates).length > 0) out.aggregates = aggregates;
+  }
+  const order = raw["order"];
+  if (typeof order === "string" && GROUP_ORDERS.includes(order)) {
+    out.order = order;
+  }
+  if (Array.isArray(raw["collapsed"])) {
+    const collapsed = raw["collapsed"].filter((k) => typeof k === "string");
+    if (collapsed.length > 0) out.collapsed = collapsed;
+  }
+  if (raw["showColumn"] === true) out.showColumn = true;
+  if (Array.isArray(raw["then"])) {
+    const then = [];
+    for (const level of raw["then"]) {
+      if (!isRecord(level)) continue;
+      const sub = level["field"];
+      if (typeof sub !== "string" || sub.trim() === "") continue;
+      const subOrder = level["order"];
+      const subGrain = level["grain"];
+      then.push({
+        field: sub,
+        ...typeof subOrder === "string" && GROUP_ORDERS.includes(subOrder) ? { order: subOrder } : {},
+        ...typeof subGrain === "string" && subGrain !== "" ? { grain: subGrain } : {}
+      });
+    }
+    if (then.length > 0) out.then = then.slice(0, 2);
+  }
+  const grain = raw["grain"];
+  if (typeof grain === "string" && grain !== "") out.grain = grain;
+  const across = raw["across"];
+  if (typeof across === "string" && across.trim() !== "") out.across = across;
+  if (Array.isArray(raw["show"])) {
+    const show = raw["show"].filter((k) => typeof k === "string" && k !== "");
+    if (show.length > 0) out.show = show;
+  }
+  if (Array.isArray(raw["trail"])) {
+    const trail = [];
+    for (const step of raw["trail"]) {
+      if (!isRecord(step) || typeof step["dim"] !== "string" || step["dim"] === "") continue;
+      const value = step["value"];
+      if (value !== null && typeof value !== "string") continue;
+      trail.push({ dim: step["dim"], value });
+    }
+    if (trail.length > 0) out.trail = trail;
+  }
+  return out;
+}
+var STORE_KEPT_LAYOUTS = ["grid", "kanban", "calendar", "gallery", ...["timeline"] , "list"];
+var KINDS = STORE_KEPT_LAYOUTS;
+function viewSettings(definition, rowFilters) {
+  const data = definition ?? {};
+  const text = (key) => {
+    const v = data[key];
+    return typeof v === "string" && v !== "" ? v : null;
+  };
+  const layout = String(data["layout"] ?? "grid");
+  const flat = rowFilters ?? (isObject(data["filters"]) ? data["filters"] : null);
+  const moved = data["moved_from"];
+  return {
+    layout: KINDS.includes(layout) ? layout : "grid",
+    filters: flat && Object.keys(flat).length > 0 ? flat : null,
+    where: isRule(data["where"]) ? data["where"] : null,
+    groupField: text("group_field"),
+    swimlaneField: text("swimlane_field"),
+    collapsedColumns: Array.isArray(data["collapsed_columns"]) ? data["collapsed_columns"].filter((v) => ["string", "number", "boolean"].includes(typeof v)).map(String) : [],
+    measure: text("measure"),
+    dateField: text("date_field"),
+    startField: text("start_field"),
+    endField: text("end_field"),
+    imageField: text("image_field"),
+    sorts: parseSorts(data["sorts"]),
+    ruleId: text("rule_id"),
+    isDefault: data["is_default"] === true || data["is_default"] === "true",
+    presentation: parseGridPresentation(data["presentation"]),
+    movedFrom: isObject(moved) ? moved : null
+  };
+}
+function isObject(raw) {
+  return Boolean(raw) && typeof raw === "object" && !Array.isArray(raw);
+}
+function isRule(raw) {
+  if (!isObject(raw)) return false;
+  const node = raw;
+  return typeof node.op === "string" && Array.isArray(node.args);
+}
+function parseSorts(raw) {
+  let list = raw;
+  if (typeof raw === "string") {
+    try {
+      list = raw.trim() === "" ? [] : JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+  if (!Array.isArray(list)) return [];
+  return list.filter((s) => isObject(s) && typeof s.field === "string").map((s) => ({ field: s.field, direction: s.direction === "desc" ? "desc" : "asc" }));
+}
+
+// src/views.ts
+var VIEW_LAYOUTS = ["grid", "kanban", "calendar", "gallery", "timeline", "list"];
+function viewOrderOf(definition) {
+  const raw = definition?.["order"];
+  return raw === "manual" ? "manual" : raw === "sorted" ? "sorted" : null;
+}
+function defaultViewOf(views) {
+  return views.find((v) => v.isDefault);
+}
+function viewFromRow(row) {
+  const data = row.definition ?? {};
+  const k = viewSettings(data, row.filters && Object.keys(row.filters).length > 0 ? row.filters : null);
+  const tableFromDefinition = typeof data["table_id"] === "string" && data["table_id"] !== "" ? data["table_id"] : null;
+  return {
+    id: row.view_id,
+    name: row.name || "Untitled view",
+    subject: row.table_id ?? tableFromDefinition ?? "",
+    layout: k.layout,
+    groupField: k.groupField,
+    swimlaneField: k.swimlaneField,
+    collapsedColumns: k.collapsedColumns,
+    measure: k.measure,
+    dateField: k.dateField,
+    startField: k.startField,
+    endField: k.endField,
+    imageField: k.imageField,
+    sorts: k.sorts,
+    order: viewOrderOf(data),
+    ruleId: k.ruleId,
+    ...k.filters ? { filters: k.filters } : {},
+    where: k.where,
+    // The older table's own default view, carried in by the mover, IS this table's default —
+    // the mover wrote the row's column, which `custom.views` does not return. Read as anything
+    // else, the page would seed a second "All records" beside it and open on that.
+    isDefault: k.isDefault || k.movedFrom?.["kind"] === "default_view",
+    presentation: k.presentation,
+    movedFrom: k.movedFrom
+  };
+}
+
+// src/viewLook.ts
+function lookFromDocument(doc) {
+  const data = doc ?? {};
+  const read = viewSettings(data);
+  const out = {};
+  const has = (key) => Object.prototype.hasOwnProperty.call(data, key);
+  if (has("layout") && VIEW_LAYOUTS.includes(String(data["layout"]))) {
+    out.layout = data["layout"];
+  }
+  if (has("group_field")) out.groupField = read.groupField;
+  if (has("swimlane_field")) out.swimlaneField = read.swimlaneField;
+  if (has("collapsed_columns")) out.collapsedColumns = read.collapsedColumns;
+  if (has("measure")) out.measure = read.measure;
+  if (has("date_field")) out.dateField = read.dateField;
+  if (has("start_field")) out.startField = read.startField;
+  if (has("end_field")) out.endField = read.endField;
+  if (has("image_field")) out.imageField = read.imageField;
+  if (has("sorts")) out.sorts = read.sorts;
+  if (has("where")) out.where = read.where;
+  if (has("presentation")) out.presentation = parseGridPresentation(data["presentation"]);
+  return out;
+}
+function applyLook(view, look) {
+  if (!look) return view;
+  return { ...view, ...look };
+}
+async function readLooks(client, tableId) {
+  const answered = await client.viewLookRead({ table_id: tableId });
+  if (!answered.ok) return answered;
+  const out = {};
+  for (const [viewId, row] of Object.entries(answered.data ?? {})) {
+    out[viewId] = lookFromDocument(row?.look ?? null);
+  }
+  return { ok: true, data: out };
+}
+
+// src/firstPage.ts
+var TABLE_PAGE_SIZE = 100;
+var EMBEDDED_PAGE_SIZE = 50;
+function firstGridPageArgs(input) {
+  const { shown, fields } = input;
+  if (!shown) return null;
+  if ((shown.layout ?? "grid") !== "grid") return null;
+  if (shown.ruleId) return null;
+  if (shown.order === "manual") return null;
+  if (shown.filters && Object.keys(shown.filters).length > 0) return null;
+  if (shown.presentation?.grouping) return null;
+  const first = (shown.sorts ?? [])[0];
+  const viewSort = first && fields.some((f) => f.key === first.field) ? { id: first.field, direction: first.direction } : null;
+  const opening = viewSort ?? defaultSortOf(input.table, fields);
+  return {
+    p_table_id: input.tableId,
+    p_filter: {},
+    p_search: null,
+    p_sort: pageSortFor(fields, opening),
+    p_view_id: null,
+    p_limit: input.pageSize ?? TABLE_PAGE_SIZE,
+    p_offset: 0
+  };
+}
+async function firstGridPageRequest(client, tableId, options = {}) {
+  const [table, fields, views, looks] = await Promise.all([
+    client.tableRead({ table_id: tableId }),
+    client.fields({ table_id: tableId }),
+    client.views({ table_id: tableId }),
+    readLooks(client, tableId)
+  ]);
+  if (!table.ok || !fields.ok || !views.ok || !looks.ok) return null;
+  const mine = views.data.map(viewFromRow).filter((v) => v.subject === tableId);
+  const view = defaultViewOf(mine) ?? mine[0] ?? null;
+  const shown = view ? applyLook(view, looks.data[view.id]) : null;
+  return firstGridPageArgs({ tableId, table: table.data, fields: fields.data, shown, ...options.pageSize ? { pageSize: options.pageSize } : {} });
+}
+async function askTablePageSeed(input) {
+  const recording = core.recordingDataSource(core.asRecordsDataSource(input.dataSource));
+  const client = core.createRecordsClient({
+    dataSource: recording.source,
+    organizationId: input.organizationId,
+    actor: input.actor,
+    onError: () => {
+    }
+  });
+  const record = input.recordId ? Promise.resolve(
+    recording.source.rpc("record_page_bundle", { p_organization_id: input.organizationId, p_record_id: input.recordId }, { schema: "custom" })
+  ).catch(() => null) : null;
+  try {
+    const pageSize = input.pageSize ?? (input.embedded ? EMBEDDED_PAGE_SIZE : TABLE_PAGE_SIZE);
+    const args = await firstGridPageRequest(client, input.tableId, { pageSize });
+    if (args && input.rows !== false) {
+      await client.listPage({
+        table_id: args.p_table_id,
+        filter: args.p_filter,
+        search: args.p_search,
+        sort: args.p_sort,
+        view_id: args.p_view_id,
+        limit: args.p_limit,
+        offset: args.p_offset
+      });
+    }
+  } catch {
+  }
+  if (record) await record;
+  return recording.seed();
+}
+
+exports.EMBEDDED_PAGE_SIZE = EMBEDDED_PAGE_SIZE;
+exports.TABLE_PAGE_SIZE = TABLE_PAGE_SIZE;
+exports.askTablePageSeed = askTablePageSeed;
+exports.firstGridPageArgs = firstGridPageArgs;
+exports.firstGridPageRequest = firstGridPageRequest;
+//# sourceMappingURL=first-page.cjs.map
+//# sourceMappingURL=first-page.cjs.map