@ai-matrx/records-ui 0.115.70 → 0.115.71

package/dist/helpers.cjs

@@ -0,0 +1,618 @@
+'use strict';
+
+var globalSlot = require('@ai-matrx/kit/global-slot');
+var tableStyle = require('@ai-matrx/design-system/data-table/table-style');
+var records = require('@ai-matrx/records');
+var uuid = require('@ai-matrx/kit/uuid');
+var textCase = require('@ai-matrx/kit/text-case');
+var format = require('@ai-matrx/kit/format');
+var core = require('@ai-matrx/records/core');
+require('@ai-matrx/design-system/field-formats');
+
+// src/dataSource.ts
+function personActor(userId) {
+  return userId ? { actor: "user", user_id: userId } : { actor: "user" };
+}
+var dataSources = globalSlot.globalSlot("ai-matrx.records-ui.data-sources", () => /* @__PURE__ */ new WeakMap());
+function recordsDataSource(client, fallbackSchema = "custom") {
+  let bySchema = dataSources.get(client);
+  if (!bySchema) {
+    bySchema = /* @__PURE__ */ new Map();
+    dataSources.set(client, bySchema);
+  }
+  const held = bySchema.get(fallbackSchema);
+  if (held) return held;
+  const made = makeRecordsDataSource(client, fallbackSchema);
+  bySchema.set(fallbackSchema, made);
+  return made;
+}
+function makeRecordsDataSource(client, fallbackSchema) {
+  const supabase = client;
+  return {
+    // PAGE-BUNDLE: the real adapter opens a table page with one `custom.table_page_bundle` call.
+    opensInOneCall: true,
+    async rpc(fn, args, options) {
+      const schema = options?.schema ?? fallbackSchema;
+      if (schema === "custom" && supabase.auth?.getSession && !await hasSession(supabase.auth.getSession)) {
+        return { data: null, error: SIGNED_OUT };
+      }
+      const on = supabase.schema(schema);
+      return await on.rpc(fn, args);
+    },
+    schema(name) {
+      return supabase.schema(name);
+    }
+  };
+}
+var SIGNED_OUT = {
+  code: "42501",
+  message: "Nobody is signed in, so there is nothing to read.",
+  hint: "Sign in, then try again.",
+  details: null
+};
+async function hasSession(getSession) {
+  try {
+    const answer = await getSession();
+    return Boolean(answer?.data?.session);
+  } catch {
+    return true;
+  }
+}
+var state = globalSlot.globalSlot("ai-matrx.records-ui.person-time-zone", () => ({
+  zone: null,
+  listeners: /* @__PURE__ */ new Set()
+}));
+function valid(z) {
+  if (typeof z !== "string" || !z.trim()) return false;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: z });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function setPersonTimeZone(next) {
+  const clean = valid(next) ? next : null;
+  if (clean === state.zone) return;
+  state.zone = clean;
+  tableStyle.setColorRuleTimeZone(clean);
+  state.listeners.forEach((l) => l());
+}
+function getPersonTimeZone() {
+  return state.zone;
+}
+function subscribePersonTimeZone(listener) {
+  state.listeners.add(listener);
+  return () => {
+    state.listeners.delete(listener);
+  };
+}
+function personWallNow(at = /* @__PURE__ */ new Date()) {
+  const zone = state.zone;
+  if (!zone) return at;
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: zone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hourCycle: "h23"
+  }).formatToParts(at);
+  const n = (t) => Number(parts.find((p) => p.type === t)?.value ?? 0);
+  return new Date(n("year"), n("month") - 1, n("day"), n("hour"), n("minute"), n("second"));
+}
+var LEVEL_WORD = {
+  viewer: "Viewer",
+  commenter: "Commenter",
+  edit_content: "Content editor",
+  editor: "Editor",
+  admin: "Admin"
+};
+var NEEDS = {
+  read: "viewer",
+  // custom.io_comment_write
+  comment: "commenter",
+  // custom.record_update / custom.record_write — `edit_content` changes rows and page content;
+  // columns, views and settings (structure) stay with admin below, and sharing with admin.
+  write: "edit_content",
+  // custom.view_designate / view_declare / migrate_merge / record_restore — all ask `editor`: more than
+  // changing content (`edit_content`), less than changing columns (`admin`).
+  organise: "editor",
+  // custom.record_delete
+  remove: "editor",
+  // custom.share_grant — ONE-LADDER (2026-10-10): Edit may pass View / Comment / Edit on inside the
+  // organization (iam.may_grant_as, knobs access.sharing/*). Which levels, and to whom, is the share
+  // dialog's own question (iam.my_grantable_levels); the Share button only has to open for Edit.
+  share: "editor",
+  // custom.field_declare / field_update / field_retire / table settings
+  structure: "admin"
+};
+var NOT_YET = "Still asking the store what you may do here. Nothing is offered until it has answered.";
+var NOTHING_AT_ALL = "You have not been given this. Ask somebody who administers it to share it with you.";
+function sentenceFor(what, level) {
+  if (level === null) return NOTHING_AT_ALL;
+  const need = LEVEL_WORD[NEEDS[what]];
+  const have = LEVEL_WORD[level];
+  const doing = {
+    read: "open this",
+    comment: "leave a comment",
+    write: "change anything here",
+    organise: "organise this",
+    remove: "delete this",
+    share: "pass this on to somebody else",
+    structure: "change the columns of this table"
+  };
+  return `You are ${have} here, and it takes ${need} to ${doing[what]}. Ask somebody who is Admin on it to move you up.`;
+}
+function whatYouMayDo(level, known = true) {
+  const may = (what) => known && records.atLeast(level, NEEDS[what]);
+  return {
+    level: known ? level : null,
+    known,
+    read: may("read"),
+    comment: may("comment"),
+    write: may("write"),
+    organise: may("organise"),
+    remove: may("remove"),
+    share: may("share"),
+    structure: may("structure"),
+    why: (what) => known ? sentenceFor(what, level) : NOT_YET
+  };
+}
+var NOT_ANSWERED_YET = whatYouMayDo(null, false);
+
+// src/tableRights.ts
+function tableRights(may, overallReason) {
+  return {
+    ...may,
+    admin: may.structure,
+    reason: (may.structure ? "" : may.why("structure"))
+  };
+}
+var NO_RIGHTS = tableRights(NOT_ANSWERED_YET);
+function tableRightsAt(level) {
+  return tableRights(whatYouMayDo(level, true));
+}
+function fieldName(field) {
+  const label = (field.label ?? "").trim();
+  if (label !== "" && label === field.key && /^[a-z0-9]+(?:[_.-][a-z0-9]+)+$/.test(label)) return textCase.humanizeIdentifier(label);
+  if (label !== "") return label;
+  const name = (field.name ?? "").trim();
+  if (name !== "") return name;
+  return textCase.humanizeIdentifier(field.key);
+}
+function tableName(table) {
+  const name = (table.name ?? "").trim();
+  if (name !== "") return name;
+  const singular = (table.label_singular ?? "").trim();
+  if (singular !== "") return singular;
+  return textCase.humanizeIdentifier(table.slug ?? "");
+}
+function recordName(document, titleKey, fallback = "Untitled") {
+  const data = document ?? {};
+  const keys = [titleKey, "title", "name", "label", "full_name", "subject", "summary"].filter(
+    (key) => typeof key === "string" && key !== ""
+  );
+  for (const key of keys) {
+    const value = data[key];
+    if (typeof value === "string" && value.trim() !== "" && !looksLikeId(value.trim())) {
+      return value.trim();
+    }
+    if (typeof value === "number") return String(value);
+  }
+  return fallback;
+}
+function looksLikeId(value) {
+  return typeof value === "string" && uuid.isUuidShape(value.trim());
+}
+function rowName(row, titleKey, fallback = "Untitled") {
+  return recordName(row?.document, titleKey, fallback);
+}
+function recordNameIn(table, document, fallback = "Untitled") {
+  return recordName(document, table?.title_field ?? null, fallback);
+}
+function rowNameIn(table, row, fallback = "Untitled") {
+  return recordName(row?.document, table?.title_field ?? null, fallback);
+}
+var WITHHELD_RECORD_LABEL = "A record you have not been given access to";
+var UNREAD_RECORD_LABEL = "Couldn't load this name";
+function singularNoun(table, fallback = "record") {
+  const word = (table?.label_singular ?? "").trim() || (table?.name ?? "").trim() || fallback;
+  return word.split(/\s+/).map((w) => /^[A-Z][a-z'’-]*$/.test(w) ? w.toLowerCase() : w).join(" ");
+}
+var CONVENTIONAL_TITLE_KEYS = ["title", "name", "label", "full_name", "subject", "summary"];
+function canTitle(field, excluded) {
+  if (excluded.has(field.key)) return false;
+  if (field.type === "boolean") return false;
+  if (field.type === "formula" && (field.config ?? {})["system"]) return false;
+  return true;
+}
+function cardTitleField(fields, titleKey, exclude = []) {
+  const excluded = new Set(exclude.filter((k) => typeof k === "string" && k !== ""));
+  const ordered = [...fields].sort((a, b) => (a.sort ?? 100) - (b.sort ?? 100) || a.key.localeCompare(b.key));
+  const byKey = (key) => ordered.find((f) => f.key === key && canTitle(f, excluded));
+  if (titleKey) {
+    const declared = byKey(titleKey);
+    if (declared) return declared;
+  }
+  for (const key of CONVENTIONAL_TITLE_KEYS) {
+    const found = byKey(key);
+    if (found) return found;
+  }
+  return ordered.find((f) => f.type === "text" && canTitle(f, excluded)) ?? ordered.find((f) => canTitle(f, excluded));
+}
+var SOMEBODY = "somebody in this organization";
+var THE_SYSTEM = "the system";
+function actorWords(actor, resolve) {
+  if (actor.kind === "system") return THE_SYSTEM;
+  const named = actor.name?.trim() || (actor.user_id && resolve ? resolve(actor.user_id)?.trim() : null) || null;
+  if (actor.kind === "agent") {
+    const on = actor.on_behalf_of;
+    const person = on?.name?.trim() || (on?.user_id && resolve ? resolve(on.user_id)?.trim() : null) || SOMEBODY;
+    const approver = actor.approved_by ? actor.approved_by.name?.trim() || (resolve ? resolve(actor.approved_by.user_id)?.trim() : null) || SOMEBODY : null;
+    return `${named ?? "an assistant"}, for ${person}${approver ? `, approved by ${approver}` : ""}`;
+  }
+  return named ?? SOMEBODY;
+}
+function whenWords(at, now = /* @__PURE__ */ new Date()) {
+  const then = new Date(at);
+  const age = now.getTime() - then.getTime();
+  if (!Number.isFinite(age)) return "at an unknown time";
+  if (age < 30 * 864e5) return format.formatRelativeTime(then, { style: "intl", now: now.getTime() });
+  return then.toLocaleDateString();
+}
+var OPERATION_WORDS = {
+  created: "Created",
+  edited: "Edited",
+  deleted: "Archived",
+  archived: "Archived",
+  restored: "Restored",
+  retype: "Column type changed",
+  delete: "Removed",
+  soft_delete: "Archived",
+  insert: "Created",
+  update: "Edited",
+  restore: "Restored"
+};
+function operationWords(label) {
+  const raw = (label ?? "").trim();
+  if (raw === "") return "Changed";
+  const known = OPERATION_WORDS[raw.toLowerCase()];
+  if (known) return known;
+  const words = textCase.humanizeIdentifier(raw).toLowerCase();
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function lastChangeSentence(fieldLabel, entry, resolve) {
+  if (!entry) {
+    return `Nothing is recorded against ${fieldLabel} on this record yet. Press H for the whole history of this column.`;
+  }
+  const verb = operationWords(entry.operation_label).toLowerCase();
+  return `${fieldLabel} \u2014 ${verb} by ${actorWords(entry.actor, resolve)}, ${whenWords(entry.occurred_at)}. Press H for the whole history.`;
+}
+function actorBadge(actor, resolve) {
+  if (actor.kind === "system") return THE_SYSTEM;
+  const words = actorWords(actor, resolve);
+  if (words === SOMEBODY) return "somebody";
+  const first = words.split(",")[0].trim();
+  const at = first.indexOf("@");
+  return at > 0 ? first.slice(0, at) : first;
+}
+
+// src/withheldNotice.ts
+var WITHHELD_WORD = "Withheld";
+function withheldNoticeOf(hidden, key) {
+  const notice = hidden?.[key];
+  return notice && typeof notice === "object" ? notice : null;
+}
+function withheldSentence(field, notice) {
+  const extra = notice;
+  if (typeof extra.says === "string" && extra.says.trim() !== "") return extra.says.trim();
+  const name = fieldName(field);
+  if (typeof extra.part === "string" && extra.part.trim() !== "" && typeof extra.who === "string" && extra.who.trim() !== "") {
+    return `${name} is in ${extra.part.trim()} \u2014 ${extra.who.trim()} see it.`;
+  }
+  const reason = notice.reason ? ` It is ${notice.reason}` : "";
+  const needs = notice.needs ? `${reason ? "," : " It"} and reading it needs ${notice.needs}` : "";
+  const or = notice.or ? `${needs || reason ? ", or" : " It needs"} ${notice.or}` : "";
+  return `${name} is withheld from you.${reason}${needs}${or}${reason || needs || or ? "." : ""}`;
+}
+function displayFormatOf(field) {
+  const raw = field.display_format;
+  if (!raw || typeof raw !== "object") return null;
+  const id = raw.id;
+  if (typeof id !== "string" || id === "") return null;
+  const options = raw.options;
+  return { id, options: options && typeof options === "object" ? options : {} };
+}
+
+// src/docs.ts
+function isSignatureField(field) {
+  return field.type === "text" && (field.format ?? "").toLowerCase() === "signature";
+}
+var LOOK_KINDS = {
+  rating: { plain: "number", look: ({ ratingMax }) => ({ id: "rating", options: { ratingMax } }) },
+  time: { plain: "text", look: () => ({ id: "time" }) }
+};
+function storePublishesKind(kind) {
+  return records.DECLARABLE_FIELD_KINDS.some((row) => row.kind === kind);
+}
+records.DECLARABLE_FIELD_KINDS.some(
+  (row) => row.kind === "entity_reference"
+);
+var SYSTEM_FIELD_KINDS = ["autonumber", "created_time", "modified_time"];
+function isSystemFieldKind(id) {
+  return SYSTEM_FIELD_KINDS.includes(id);
+}
+var FIELD_TYPE_CATALOGUE = [
+  { id: "text", group: "Words", label: "Text", explanation: "A short line of writing \u2014 a name, a reference, a title." },
+  { id: "long_text", group: "Words", label: "Long text", explanation: "Several lines \u2014 a description, notes, an address." },
+  { id: "rich_text", group: "Words", label: "Formatted text", explanation: "Notes with bold, lists and links." },
+  { id: "email", group: "Words", label: "Email address", explanation: "An email address, checked as you type and ready to write to." },
+  { id: "phone", group: "Words", label: "Phone number", explanation: "A phone number, checked as you type." },
+  { id: "url", group: "Words", label: "Link", explanation: "A web address that opens in a new tab when you click it." },
+  { id: "address", group: "Words", label: "Address", explanation: "A street address in parts, opened in maps." },
+  { id: "barcode", group: "Words", label: "Barcode", explanation: "A code a scanner reads, like a wristband or a box." },
+  { id: "button", group: "Words", label: "Button", explanation: "A button on each record that opens a link or runs an action." },
+  { id: "number", group: "Numbers and dates", label: "Number", explanation: "A plain number you can total up and sort by." },
+  { id: "currency", group: "Numbers and dates", label: "Money", explanation: "An amount of money, shown with its currency wherever it appears." },
+  { id: "percent", group: "Numbers and dates", label: "Percentage", explanation: "A number out of a hundred, kept between 0 and 100." },
+  { id: "rating", group: "Numbers and dates", label: "Rating", explanation: "A score in stars, set with one click." },
+  { id: "duration", group: "Numbers and dates", label: "Duration", explanation: "A length of time, typed as 45 min or 1:30." },
+  { id: "time", group: "Numbers and dates", label: "Time", explanation: "A time of day with no date \u2014 a shift start, opening hours." },
+  { id: "datetime", group: "Numbers and dates", label: "Date", explanation: "A day, or a day and a time. Dates are what the calendar view reads." },
+  { id: "select", group: "Choices and people", label: "Choice", explanation: "One answer from a list you write here. Choices are what the board view groups by." },
+  { id: "multi_select", group: "Choices and people", label: "Several choices", explanation: "Any number of answers from a list you write here." },
+  { id: "status", group: "Choices and people", label: "Status", explanation: "Choices grouped into To do, In progress and Done." },
+  { id: "checkbox", group: "Choices and people", label: "Yes / no", explanation: "A box you tick. Left alone it stays unanswered, which is not the same as a no." },
+  { id: "member", group: "Choices and people", label: "Person", explanation: "Somebody in this organization, picked from the people who are in it." },
+  { id: "attachment", group: "Choices and people", label: "File", explanation: "A file or a picture kept with the record." },
+  { id: "signature", group: "Choices and people", label: "Signature", explanation: "Somebody's sign-off on a document made from this record. Nobody types in it \u2014 it fills in when they sign." },
+  { id: "relation", group: "Choices and people", label: "Points at another record", explanation: "A link to records in another of your tables \u2014 the customer a job is for, the lines on an invoice." },
+  {
+    id: "entity_reference",
+    group: "Choices and people",
+    label: "Points at something else on the platform",
+    explanation: "A note, a web site, an agent, a workbook \u2014 anything you keep here that is not one of your tables."
+  },
+  { id: "lookup", group: "Worked out", label: "Borrowed value", explanation: "A value read from a record this one points at, kept in step with it." },
+  { id: "rollup", group: "Worked out", label: "Total of linked records", explanation: "A count or a total worked out from the records this one points at." },
+  { id: "count", group: "Worked out", label: "Count of linked records", explanation: "How many records this one points at." },
+  { id: "formula", group: "Worked out", label: "Worked out from other columns", explanation: "A value this record works out for itself from its own other columns." },
+  { id: "autonumber", group: "Worked out", label: "Record number", explanation: "A number the table gives each record, one after another, never reused. Records already here are numbered in the order they were made." },
+  { id: "created_time", group: "Worked out", label: "Created time", explanation: "When each record was made. Nobody types it." },
+  { id: "modified_time", group: "Worked out", label: "Last changed time", explanation: "When each record last changed. Nobody types it." },
+  { id: "created_by", group: "Worked out", label: "Created by", explanation: "Who made each record. Nobody types it." },
+  { id: "modified_by", group: "Worked out", label: "Last changed by", explanation: "Who last changed each record. Nobody types it." }
+];
+var GATED_KINDS = /* @__PURE__ */ new Set(["entity_reference", ...records.NEWER_FIELD_KINDS]);
+FIELD_TYPE_CATALOGUE.filter(
+  (c) => !GATED_KINDS.has(c.id) || storePublishesKind(c.id) || c.id in LOOK_KINDS
+);
+var BY_ID = new Map(FIELD_TYPE_CATALOGUE.map((c) => [c.id, c]));
+function fieldTypeChoice(id) {
+  return BY_ID.get(id);
+}
+
+// src/parity.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");
+var PARITY_LABEL = {
+  attachment: "Attachment",
+  checkbox: "Yes / no",
+  currency: "Currency",
+  datetime: "Date",
+  email: "Email",
+  formula: "Formula",
+  lookup: "Lookup",
+  member: "Person",
+  multi_select: "Multi-select",
+  percent: "Percent",
+  phone: "Phone",
+  rollup: "Rollup",
+  select: "Select",
+  url: "Link"
+};
+var PARITY_MADE_OF = 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);
+}
+function pickableTypeOf(field) {
+  if (isSignatureField(field)) return "signature";
+  if (records.isButtonField(field)) return "button";
+  const newer = records.newerKindOf(field);
+  if (newer) return newer;
+  const look = displayFormatOf(field)?.id;
+  if (look === "rating" && field.type === "range") return "rating";
+  if (look === "time" && field.type === "text") return "time";
+  const system = field.config?.["system"];
+  if (field.type === "formula" && typeof system === "string" && isSystemFieldKind(system)) return system;
+  const kind = editorKindFor(field);
+  return fieldTypeChoice(kind) ? kind : void 0;
+}
+function fieldTypeLabel(field) {
+  const kind = pickableTypeOf(field) ?? editorKindFor(field);
+  const known = fieldTypeChoice(kind)?.label;
+  if (known) return field.multi && kind !== "multi_select" ? `${known} (many)` : known;
+  const plain = {
+    // `boolean` is the BEHAVIOUR word; `checkbox` is the type a person picks. Both are
+    // written the way a person writes them, never as a raw token.
+    boolean: "Yes / no",
+    date: "Date",
+    json: "Structured data",
+    relation: "Link to a record"
+  };
+  return plain[kind] ?? textCase.humanizeIdentifier(kind);
+}
+
+// src/tablePickerEntries.ts
+var PLATFORM_TABLE_PREFIX = "records_ui_";
+function keptByPlatform(table) {
+  return table.platform_owned === true || table.kept_by_the_app === true;
+}
+function isValueSet(table) {
+  if (table.kept_for === "choices") return true;
+  return table.kept_for == null && table.kind === "list" && keptByPlatform(table);
+}
+function isKeptTable(table) {
+  return keptByPlatform(table) || isValueSet(table) || Boolean(table.work_kind) || (table.slug ?? "").startsWith(PLATFORM_TABLE_PREFIX);
+}
+var CHOICES_SUFFIX = / choices$/i;
+function tablePickerEntries(tables, options = {}) {
+  const byId = new Map(tables.map((t) => [t.id, t]));
+  const lists = tables.filter(isValueSet);
+  const listLabel = (t) => {
+    const column = t.name.replace(CHOICES_SUFFIX, "");
+    if (!t.used_in_table_id || t.used_in_table_id === t.id) {
+      const made = madeOn(t.created_at);
+      return made ? `${column} \u2014 no column \xB7 ${made}` : `${column} \u2014 no column`;
+    }
+    const owner = byId.get(t.used_in_table_id);
+    if (!owner) return t.name;
+    return `${column} \u2014 ${owner.name}`;
+  };
+  const plain = tables.filter((t) => !isKeptTable(t) || t.id === options.keep && !isValueSet(t)).map((t) => ({ table: t, id: t.id, label: t.name, isList: false })).sort((a, b) => a.label.localeCompare(b.label));
+  const shownLists = lists.filter((t) => options.showLists || t.id === options.keep).map((t) => ({ table: t, id: t.id, label: listLabel(t), isList: true })).sort((a, b) => a.label.localeCompare(b.label));
+  const entries = [...plain, ...shownLists];
+  const seen = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const key = entry.label.toLowerCase();
+    const n = (seen.get(key) ?? 0) + 1;
+    seen.set(key, n);
+    if (n > 1) entry.label = `${entry.label} (${n})`;
+  }
+  return { entries, listCount: lists.length };
+}
+function madeOn(stamp) {
+  if (!stamp) return null;
+  const at = new Date(stamp);
+  if (Number.isNaN(at.getTime())) return null;
+  return new Intl.DateTimeFormat(void 0, { month: "short", day: "numeric", year: "numeric" }).format(at);
+}
+function styleFromDecorations(decorations, fields) {
+  if (!decorations) return { version: 1 };
+  const keyOf = (id) => fields.find((f) => f.id === id)?.key;
+  const style = { version: 1 };
+  if (decorations.color_by?.field) {
+    const field = keyOf(decorations.color_by.field);
+    if (field) style.colorBy = { field, target: decorations.color_by.target };
+  }
+  if (Array.isArray(decorations.rules) && decorations.rules.length > 0) {
+    const rules = [];
+    decorations.rules.forEach((rule, index) => {
+      const field = keyOf(rule.field);
+      if (!field) return;
+      rules.push({
+        id: rule.id ?? `decoration:${index}`,
+        field,
+        op: rule.op,
+        color: rule.color,
+        target: rule.target,
+        ...rule.value === void 0 || rule.value === null ? {} : { value: String(rule.value) }
+      });
+    });
+    if (rules.length > 0) style.rules = rules;
+  }
+  if (decorations.rows && Object.keys(decorations.rows).length > 0) {
+    style.rows = { ...decorations.rows };
+  }
+  const columns = {};
+  for (const [id, color] of Object.entries(decorations.columns ?? {})) {
+    const key = keyOf(id);
+    if (key) columns[key] = color;
+  }
+  if (Object.keys(columns).length > 0) style.columns = columns;
+  const cells = {};
+  for (const [rowId, byField] of Object.entries(decorations.cells ?? {})) {
+    for (const [id, color] of Object.entries(byField ?? {})) {
+      const key = keyOf(id);
+      if (!key) continue;
+      (cells[rowId] ??= {})[key] = color;
+    }
+  }
+  if (Object.keys(cells).length > 0) style.cells = cells;
+  return style;
+}
+function resolveTableStyle(decorations, fields, viewStyle) {
+  const base = styleFromDecorations(decorations, fields);
+  if (!viewStyle) return base;
+  const colorBy = viewStyle.colorBy ?? base.colorBy;
+  const rules = viewStyle.rules ?? base.rules;
+  const rows = viewStyle.rows ?? base.rows;
+  const columns = viewStyle.columns ?? base.columns;
+  const cells = viewStyle.cells ?? base.cells;
+  return {
+    version: 1,
+    ...colorBy !== void 0 ? { colorBy } : {},
+    ...rules !== void 0 ? { rules } : {},
+    ...rows !== void 0 ? { rows } : {},
+    ...columns !== void 0 ? { columns } : {},
+    ...cells !== void 0 ? { cells } : {}
+  };
+}
+
+Object.defineProperty(exports, "DEFAULT_FIELDS", {
+  enumerable: true,
+  get: function () { return core.DEFAULT_FIELDS; }
+});
+Object.defineProperty(exports, "addFields", {
+  enumerable: true,
+  get: function () { return core.addFields; }
+});
+Object.defineProperty(exports, "declareTable", {
+  enumerable: true,
+  get: function () { return core.declareTable; }
+});
+Object.defineProperty(exports, "fieldDeclarationFor", {
+  enumerable: true,
+  get: function () { return core.fieldDeclarationFor; }
+});
+Object.defineProperty(exports, "tokenFor", {
+  enumerable: true,
+  get: function () { return core.tokenFor; }
+});
+exports.NO_RIGHTS = NO_RIGHTS;
+exports.PARITY_LABEL = PARITY_LABEL;
+exports.PARITY_MADE_OF = PARITY_MADE_OF;
+exports.SOMEBODY = SOMEBODY;
+exports.THE_SYSTEM = THE_SYSTEM;
+exports.UNREAD_RECORD_LABEL = UNREAD_RECORD_LABEL;
+exports.WITHHELD_RECORD_LABEL = WITHHELD_RECORD_LABEL;
+exports.WITHHELD_WORD = WITHHELD_WORD;
+exports.actorBadge = actorBadge;
+exports.actorWords = actorWords;
+exports.cardTitleField = cardTitleField;
+exports.editorKindFor = editorKindFor;
+exports.fieldName = fieldName;
+exports.fieldTypeLabel = fieldTypeLabel;
+exports.getPersonTimeZone = getPersonTimeZone;
+exports.isKeptTable = isKeptTable;
+exports.isValueSet = isValueSet;
+exports.lastChangeSentence = lastChangeSentence;
+exports.looksLikeId = looksLikeId;
+exports.personActor = personActor;
+exports.personWallNow = personWallNow;
+exports.pickableTypeOf = pickableTypeOf;
+exports.recordName = recordName;
+exports.recordNameIn = recordNameIn;
+exports.recordsDataSource = recordsDataSource;
+exports.resolveTableStyle = resolveTableStyle;
+exports.rowName = rowName;
+exports.rowNameIn = rowNameIn;
+exports.setPersonTimeZone = setPersonTimeZone;
+exports.singularNoun = singularNoun;
+exports.styleFromDecorations = styleFromDecorations;
+exports.subscribePersonTimeZone = subscribePersonTimeZone;
+exports.tableName = tableName;
+exports.tablePickerEntries = tablePickerEntries;
+exports.tableRightsAt = tableRightsAt;
+exports.whenWords = whenWords;
+exports.withheldNoticeOf = withheldNoticeOf;
+exports.withheldSentence = withheldSentence;
+//# sourceMappingURL=helpers.cjs.map
+//# sourceMappingURL=helpers.cjs.map