@crewlethq/ui 0.17.1 → 0.19.0

package/dist/chunk-YYZRLLLY.js

@@ -0,0 +1,822 @@
+import { PRESENCE_LABELS } from './chunk-S35G6PNC.js';
+import { isNodeHue } from './chunk-AYKXMIOR.js';
+
+// src/SheetModel/types.ts
+var SHEET_COLUMN_TYPES = [
+  "text",
+  "longtext",
+  "number",
+  "checkbox",
+  "select",
+  "multiselect",
+  "status",
+  "person",
+  "date",
+  "url",
+  "rating"
+];
+var isSheetColumnType = (value) => typeof value === "string" && SHEET_COLUMN_TYPES.includes(value);
+
+// src/SheetModel/labels.ts
+var TYPE_NAMES = {
+  text: "Text",
+  longtext: "Long text",
+  number: "Number",
+  checkbox: "Checkbox",
+  select: "Select",
+  multiselect: "Multi-select",
+  status: "Status",
+  person: "Person",
+  date: "Date",
+  url: "URL",
+  rating: "Rating"
+};
+var changes = (count) => count === 1 ? "1 change" : `${count} changes`;
+var SHEET_LABELS = {
+  rowHeader: "Row",
+  addRow: "Add row",
+  empty: "Empty",
+  checked: "Checked",
+  unchecked: "Not checked",
+  rating: (value, max) => `${value} of ${max} stars`,
+  archived: (label) => `Archived: ${label}`,
+  unknownPerson: "Unknown person",
+  types: TYPE_NAMES,
+  saving: "Saving",
+  forbidden: "You can view this sheet but not edit it.",
+  couldNotSave: "Could not save this change.",
+  notANumber: (column) => `${column} must be a number.`,
+  belowMin: (column, min) => `${column} must be at least ${min}.`,
+  aboveMax: (column, max) => `${column} must be at most ${max}.`,
+  tooLong: (column, max) => `${column} must be at most ${max} characters.`,
+  required: (column) => `${column} is required.`,
+  notAnOption: (column) => `${column} must be one of its options.`,
+  tooManyItems: (column, max) => `${column} holds at most ${max} options.`,
+  notAPerson: (column) => `${column} must be a person or an agent in this company.`,
+  notADate: (column) => `${column} must be a date.`,
+  notAUrl: (column) => `${column} must be a web address starting with https:// or http://.`,
+  notARating: (column, max) => `${column} must be a whole number from 1 to ${max}.`,
+  notABoolean: (column) => `${column} must be checked or not checked.`,
+  readOnly: (column) => `${column} is read only.`,
+  conflict: (writer, value) => `${writer} changed this to ${value} while you were editing.`,
+  keepMine: "Keep yours",
+  useTheirs: (writer) => `Use ${writer}'s`,
+  someone: "Someone",
+  changed: (by, at, previous) => `Changed by ${by}, ${at}.${previous === null ? "" : ` Was ${previous}.`}`,
+  history: "Cell history",
+  sync: (state) => {
+    if (state.offline) {
+      return state.saving === 0 ? "Offline." : `Offline. ${changes(state.saving)} will sync when you reconnect.`;
+    }
+    if (state.failed !== void 0 && state.failed > 0) return "Could not save.";
+    if (state.saving > 0) return `Saving ${changes(state.saving)}`;
+    return "Saved";
+  },
+  retry: "Retry",
+  filter: "Filter options",
+  noOptions: "No matching options",
+  clear: "Clear",
+  keyboardHelp: "Arrow keys move between cells. Enter or F2 edits a cell, Escape cancels, and typing replaces its value. Space toggles a checkbox. Control or Command with C and V copies and pastes. Control or Command with Alt and H opens the history of a cell.",
+  sortBy: (column) => `Sort by ${column}`
+};
+function sheetLabels(overrides) {
+  return { ...SHEET_LABELS, ...overrides, types: { ...SHEET_LABELS.types, ...overrides?.types } };
+}
+
+// src/SheetModel/options.ts
+var HUE_ALIASES = {
+  violet: "purple",
+  indigo: "purple",
+  teal: "cyan",
+  sky: "cyan",
+  emerald: "green",
+  lime: "green",
+  yellow: "amber",
+  orange: "amber",
+  red: "rose",
+  pink: "rose"
+};
+function optionHue(color) {
+  if (color === void 0) return "neutral";
+  const name = color.trim().toLowerCase();
+  if (isNodeHue(name)) return name;
+  return HUE_ALIASES[name] ?? "neutral";
+}
+var TONES = ["neutral", "info", "success", "warning", "danger"];
+var TONE_OF_HUE = {
+  green: "success",
+  amber: "warning",
+  rose: "danger",
+  blue: "info",
+  cyan: "info",
+  purple: "neutral"
+};
+var TONE_OF_CATEGORY = {
+  todo: "neutral",
+  in_progress: "info",
+  done: "success",
+  blocked: "danger"
+};
+function statusTone(option) {
+  const name = option.color?.trim().toLowerCase();
+  if (name !== void 0 && TONES.includes(name)) return name;
+  if (name !== void 0) {
+    const hue = optionHue(name);
+    if (hue !== "neutral") return TONE_OF_HUE[hue];
+  }
+  return option.category ? TONE_OF_CATEGORY[option.category] : "neutral";
+}
+function findOption(column, id) {
+  return column.options?.find((option) => option.id === id);
+}
+function liveOptions(column) {
+  return (column.options ?? []).filter((option) => !option.archived);
+}
+function parseOptionList(text) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const part of text.split(",")) {
+    const [rawLabel = "", rawColor] = part.split(":");
+    const label = rawLabel.trim();
+    if (label === "") continue;
+    let id = label.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+    if (id === "") id = `option_${out.length + 1}`;
+    while (seen.has(id)) id = `${id}_`;
+    seen.add(id);
+    const color = rawColor?.trim();
+    out.push(color ? { id, label, color } : { id, label });
+  }
+  return out;
+}
+
+// src/SheetModel/values.ts
+var TEXT_MAX_DEFAULT = 1e3;
+var LONGTEXT_MAX_DEFAULT = 2e4;
+var URL_MAX = 2048;
+var RATING_MAX_DEFAULT = 5;
+var RATING_MAX_CEILING = 10;
+var YEAR_MIN = 1900;
+var YEAR_MAX = 2200;
+function ratingMax(column) {
+  const max = column.max ?? RATING_MAX_DEFAULT;
+  return Number.isInteger(max) && max >= 1 ? Math.min(max, RATING_MAX_CEILING) : RATING_MAX_DEFAULT;
+}
+function textMax(column) {
+  return column.maxLength ?? (column.type === "longtext" ? LONGTEXT_MAX_DEFAULT : TEXT_MAX_DEFAULT);
+}
+var isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+function normalizeValue(column, raw) {
+  if (raw === void 0 || raw === null) return column.type === "checkbox" ? false : column.type === "multiselect" ? [] : null;
+  switch (column.type) {
+    case "checkbox":
+      return raw === true;
+    case "number": {
+      const value = typeof raw === "number" ? raw : typeof raw === "string" && raw.trim() !== "" ? Number(raw) : Number.NaN;
+      return Number.isFinite(value) ? value : null;
+    }
+    case "rating":
+      return typeof raw === "number" && Number.isInteger(raw) && raw >= 1 ? raw : null;
+    case "multiselect":
+      return isStringArray(raw) ? raw : [];
+    case "text":
+    case "longtext":
+    case "url":
+    case "date":
+      return typeof raw === "string" ? raw : typeof raw === "number" || typeof raw === "boolean" ? String(raw) : null;
+    case "select":
+    case "status":
+    case "person":
+      return typeof raw === "string" ? raw : null;
+  }
+}
+function isEmptyValue(value) {
+  return value === null || value === "" || Array.isArray(value) && value.length === 0;
+}
+function sameValue(a, b) {
+  if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((item, index) => item === b[index]);
+  return a === b;
+}
+function findPerson(people, id) {
+  return people?.find((person) => person.id === id);
+}
+function numberFormat(column, locale) {
+  const digits = column.precision;
+  const fraction = digits === void 0 ? { maximumFractionDigits: 10 } : { minimumFractionDigits: digits, maximumFractionDigits: digits };
+  if (column.numberStyle === "percent") return new Intl.NumberFormat(locale, { style: "percent", ...fraction });
+  if (column.numberStyle === "currency" && column.currency) {
+    return new Intl.NumberFormat(locale, { style: "currency", currency: column.currency, ...fraction });
+  }
+  return new Intl.NumberFormat(locale, fraction);
+}
+var DATE_ONLY = /^(\d{4})-(\d{2})-(\d{2})$/;
+function calendarDate(text) {
+  const match = DATE_ONLY.exec(text);
+  if (!match) return null;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const at = new Date(Date.UTC(year, month - 1, day));
+  if (at.getUTCFullYear() !== year || at.getUTCMonth() !== month - 1 || at.getUTCDate() !== day) return null;
+  if (year < YEAR_MIN || year > YEAR_MAX) return null;
+  return { year, month, day };
+}
+function displayText(column, value, context) {
+  const { labels, locale } = context;
+  if (column.type === "checkbox") return value === true ? labels.checked : labels.unchecked;
+  if (isEmptyValue(value)) return "";
+  switch (column.type) {
+    case "number":
+      return typeof value === "number" ? numberFormat(column, locale).format(value) : "";
+    case "rating":
+      return typeof value === "number" ? labels.rating(value, ratingMax(column)) : "";
+    case "select":
+    case "status": {
+      const option = findOption(column, String(value));
+      if (!option) return String(value);
+      return option.archived ? labels.archived(option.label) : option.label;
+    }
+    case "multiselect":
+      return value.map((id) => {
+        const option = findOption(column, id);
+        if (!option) return id;
+        return option.archived ? labels.archived(option.label) : option.label;
+      }).join(", ");
+    case "person":
+      return findPerson(context.people, String(value))?.name ?? labels.unknownPerson;
+    case "date": {
+      const text = String(value);
+      if (calendarDate(text)) {
+        return new Intl.DateTimeFormat(locale, { dateStyle: "medium", timeZone: "UTC" }).format(/* @__PURE__ */ new Date(`${text}T00:00:00Z`));
+      }
+      const at = Date.parse(text);
+      return Number.isNaN(at) ? text : new Intl.DateTimeFormat(locale, { dateStyle: "medium", timeStyle: "short" }).format(at);
+    }
+    default:
+      return String(value);
+  }
+}
+function spokenText(column, value, context) {
+  if (column.type !== "checkbox" && isEmptyValue(value)) return context.labels.empty;
+  return displayText(column, value, context);
+}
+function editText(column, value, context) {
+  if (column.type === "checkbox") return value === true ? "TRUE" : "FALSE";
+  if (isEmptyValue(value)) return "";
+  switch (column.type) {
+    case "number":
+      if (typeof value !== "number") return "";
+      return column.numberStyle === "percent" ? `${roundTo(value * 100, 10)}%` : String(value);
+    case "select":
+    case "status":
+      return findOption(column, String(value))?.label ?? String(value);
+    case "multiselect":
+      return value.map((id) => findOption(column, id)?.label ?? id).join(", ");
+    case "person":
+      return findPerson(context.people, String(value))?.name ?? String(value);
+    default:
+      return String(value);
+  }
+}
+function roundTo(value, digits) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+var refuse = (error) => ({ ok: false, error });
+function matchOption(column, text) {
+  const wanted = text.trim().toLowerCase();
+  const options = liveOptions(column);
+  const hit = options.find((option) => option.id === text.trim()) ?? options.find((option) => option.label.toLowerCase() === wanted);
+  return hit ? hit.id : null;
+}
+function matchPerson(people, text) {
+  const wanted = text.trim().toLowerCase();
+  if (!people || wanted === "") return null;
+  const exact = people.find((person) => person.id === text.trim() || person.name.toLowerCase() === wanted);
+  if (exact) return exact.id;
+  const prefixed = people.filter((person) => person.name.toLowerCase().startsWith(wanted));
+  return prefixed.length === 1 ? prefixed[0].id : null;
+}
+var TRUE_WORDS = /* @__PURE__ */ new Set(["true", "yes", "y", "1", "x", "checked", "on", "\u2713", "\u2714"]);
+var FALSE_WORDS = /* @__PURE__ */ new Set(["false", "no", "n", "0", "", "unchecked", "off"]);
+function parseNumber(column, text, labels) {
+  let source = text.trim().replace(/\s+/g, "");
+  const percent = source.endsWith("%");
+  if (percent) source = source.slice(0, -1);
+  source = source.replace(/^[$€£¥]|[$€£¥]$/g, "");
+  if (/^-?\d{1,3}(,\d{3})+(\.\d+)?$/.test(source)) source = source.replaceAll(",", "");
+  if (!/^[-+]?(\d+\.?\d*|\.\d+)(e[-+]?\d+)?$/i.test(source)) return refuse(labels.notANumber(column.label));
+  let value = Number(source);
+  if (percent || column.numberStyle === "percent") value /= 100;
+  if (!Number.isFinite(value)) return refuse(labels.notANumber(column.label));
+  if (column.precision !== void 0) value = roundTo(value, column.precision);
+  const show = (bound) => column.numberStyle === "percent" ? `${roundTo(bound * 100, 10)}%` : String(bound);
+  if (column.min !== void 0 && value < column.min) return refuse(labels.belowMin(column.label, show(column.min)));
+  if (column.max !== void 0 && value > column.max) return refuse(labels.aboveMax(column.label, show(column.max)));
+  return { ok: true, value };
+}
+function parseDate(column, text, labels) {
+  const source = text.trim();
+  if (!column.time) {
+    const day = calendarDate(source.slice(0, 10));
+    if (day && (source.length === 10 || source[10] === "T" || source[10] === " ")) return { ok: true, value: source.slice(0, 10) };
+    return refuse(labels.notADate(column.label));
+  }
+  const at = Date.parse(source);
+  if (Number.isNaN(at)) return refuse(labels.notADate(column.label));
+  const year = new Date(at).getUTCFullYear();
+  if (year < YEAR_MIN || year > YEAR_MAX) return refuse(labels.notADate(column.label));
+  return { ok: true, value: new Date(at).toISOString().replace(/\.000Z$/, "Z") };
+}
+function parseUrl(column, text, labels) {
+  let source = text.trim();
+  if (!/^[a-z][a-z0-9+.-]*:/i.test(source) && /^[^\s/]+\.[^\s/]+/.test(source)) source = `https://${source}`;
+  let url;
+  try {
+    url = new URL(source);
+  } catch {
+    return refuse(labels.notAUrl(column.label));
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:" || source.length > URL_MAX || url.host === "") {
+    return refuse(labels.notAUrl(column.label));
+  }
+  return { ok: true, value: source };
+}
+function parseText(column, text, context) {
+  const { labels } = context;
+  const blank = text.trim() === "";
+  if (blank && column.type !== "checkbox") {
+    if (column.required) return refuse(labels.required(column.label));
+    return { ok: true, value: column.type === "multiselect" ? [] : null };
+  }
+  switch (column.type) {
+    case "checkbox": {
+      const word = text.trim().toLowerCase();
+      if (TRUE_WORDS.has(word)) return { ok: true, value: true };
+      if (FALSE_WORDS.has(word)) return { ok: true, value: false };
+      return refuse(labels.notABoolean(column.label));
+    }
+    case "number":
+      return parseNumber(column, text, labels);
+    case "rating": {
+      const max = ratingMax(column);
+      const source = text.trim();
+      const stars = /^★+$/.test(source) ? source.length : Number(source);
+      if (stars === 0) return column.required ? refuse(labels.required(column.label)) : { ok: true, value: null };
+      if (!Number.isInteger(stars) || stars < 1 || stars > max) return refuse(labels.notARating(column.label, max));
+      return { ok: true, value: stars };
+    }
+    case "text": {
+      const value = text.replace(/\s*[\r\n]+\s*/g, " ");
+      if (value.length > textMax(column)) return refuse(labels.tooLong(column.label, textMax(column)));
+      return { ok: true, value };
+    }
+    case "longtext":
+      if (text.length > textMax(column)) return refuse(labels.tooLong(column.label, textMax(column)));
+      return { ok: true, value: text };
+    case "select":
+    case "status": {
+      const id = matchOption(column, text);
+      return id === null ? refuse(labels.notAnOption(column.label)) : { ok: true, value: id };
+    }
+    case "multiselect": {
+      const ids = [];
+      for (const part of text.split(/[,;\n]/)) {
+        if (part.trim() === "") continue;
+        const id = matchOption(column, part);
+        if (id === null) return refuse(labels.notAnOption(column.label));
+        if (!ids.includes(id)) ids.push(id);
+      }
+      if (column.maxItems !== void 0 && ids.length > column.maxItems) return refuse(labels.tooManyItems(column.label, column.maxItems));
+      return { ok: true, value: ids };
+    }
+    case "person": {
+      const id = matchPerson(context.people, text);
+      return id === null ? refuse(labels.notAPerson(column.label)) : { ok: true, value: id };
+    }
+    case "date":
+      return parseDate(column, text, labels);
+    case "url":
+      return parseUrl(column, text, labels);
+  }
+}
+function checkValue(column, value, context) {
+  const { labels } = context;
+  if (column.required && column.type !== "checkbox" && isEmptyValue(value)) return labels.required(column.label);
+  if (isEmptyValue(value)) return null;
+  switch (column.type) {
+    case "checkbox":
+      return typeof value === "boolean" ? null : labels.notABoolean(column.label);
+    case "select":
+    case "status":
+      return typeof value === "string" && liveOptions(column).some((option) => option.id === value) ? null : labels.notAnOption(column.label);
+    case "multiselect": {
+      if (!Array.isArray(value)) return labels.notAnOption(column.label);
+      const live = new Set(liveOptions(column).map((option) => option.id));
+      if (!value.every((id) => live.has(id) || findOption(column, id)?.archived)) return labels.notAnOption(column.label);
+      if (column.maxItems !== void 0 && value.length > column.maxItems) return labels.tooManyItems(column.label, column.maxItems);
+      return null;
+    }
+    case "person":
+      return typeof value === "string" && findPerson(context.people, value) ? null : labels.notAPerson(column.label);
+    case "rating":
+      return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= ratingMax(column) ? null : labels.notARating(column.label, ratingMax(column));
+    default: {
+      const parsed = parseText(column, editText(column, value, context), context);
+      return parsed.ok ? null : parsed.error;
+    }
+  }
+}
+function compareValues(column, a, b, context) {
+  const emptyA = column.type !== "checkbox" && isEmptyValue(a);
+  const emptyB = column.type !== "checkbox" && isEmptyValue(b);
+  if (emptyA || emptyB) return emptyA === emptyB ? 0 : emptyA ? 1 : -1;
+  switch (column.type) {
+    case "number":
+    case "rating":
+      return a - b;
+    case "checkbox":
+      return Number(a === true) - Number(b === true);
+    case "select":
+    case "status": {
+      const order = (id) => (column.options ?? []).findIndex((option) => option.id === id);
+      return order(a) - order(b);
+    }
+    default:
+      return displayText(column, a, context).localeCompare(displayText(column, b, context), context.locale, { numeric: true });
+  }
+}
+
+// src/SheetModel/navigation.ts
+var isMod = (key2) => Boolean(key2.ctrlKey || key2.metaKey);
+var clamp = (value, low, high) => Math.min(Math.max(value, low), high);
+function moveFrom(at, key2, bounds) {
+  const lastRow = bounds.rows - 1;
+  const lastCol = bounds.cols - 1;
+  if (bounds.cols === 0) return null;
+  const mod = isMod(key2);
+  switch (key2.key) {
+    case "ArrowUp":
+      return { row: mod ? at.row < 0 ? -1 : 0 : Math.max(at.row - 1, -1), col: at.col };
+    case "ArrowDown":
+      if (lastRow < 0) return at;
+      return { row: mod ? lastRow : clamp(at.row + 1, -1, lastRow), col: at.col };
+    case "ArrowLeft":
+      return { row: at.row, col: mod ? 0 : Math.max(at.col - 1, 0) };
+    case "ArrowRight":
+      return { row: at.row, col: mod ? lastCol : Math.min(at.col + 1, lastCol) };
+    case "Home":
+      return mod ? { row: lastRow < 0 ? -1 : 0, col: 0 } : { row: at.row, col: 0 };
+    case "End":
+      return mod ? { row: Math.max(lastRow, -1), col: lastCol } : { row: at.row, col: lastCol };
+    case "PageUp":
+      return { row: at.row < 0 ? -1 : Math.max(at.row - bounds.page, 0), col: at.col };
+    case "PageDown":
+      if (lastRow < 0) return at;
+      return { row: clamp(at.row + bounds.page, 0, lastRow), col: at.col };
+    default:
+      return null;
+  }
+}
+function rangeOf(anchor, active) {
+  const a = Math.max(anchor.row, 0);
+  const b = Math.max(active.row, 0);
+  return { top: Math.min(a, b), bottom: Math.max(a, b), left: Math.min(anchor.col, active.col), right: Math.max(anchor.col, active.col) };
+}
+var inRange = (range, row, col) => row >= range.top && row <= range.bottom && col >= range.left && col <= range.right;
+var isMultiCell = (range) => range.top !== range.bottom || range.left !== range.right;
+function visibleRows(scrollTop, viewport, rowHeight, rows, overscan = 8) {
+  if (rows === 0) return [0, -1];
+  const height = viewport > 0 ? viewport : rowHeight * 40;
+  const first = Math.max(0, Math.floor(scrollTop / rowHeight) - overscan);
+  const last = Math.min(rows - 1, Math.ceil((scrollTop + height) / rowHeight) + overscan);
+  return [first, last];
+}
+function scrollToRow(row, scrollTop, viewport, rowHeight, header) {
+  const top = row * rowHeight;
+  const bottom = top + rowHeight;
+  const visibleTop = scrollTop;
+  const visibleBottom = scrollTop + Math.max(viewport - header, rowHeight);
+  if (top < visibleTop) return top;
+  if (bottom > visibleBottom) return bottom - Math.max(viewport - header, rowHeight);
+  return scrollTop;
+}
+function editorSide(cellTop, cellBottom, viewTop, viewBottom, panelHeight) {
+  const below = viewBottom - cellBottom;
+  const above = cellTop - viewTop;
+  return below >= panelHeight || below >= above ? "below" : "above";
+}
+var SHEET_COLUMN_WIDTHS = {
+  text: 200,
+  longtext: 260,
+  number: 112,
+  checkbox: 104,
+  select: 144,
+  multiselect: 208,
+  status: 144,
+  person: 176,
+  date: 136,
+  url: 208,
+  rating: 128
+};
+var SHEET_ROW_NUMBER_WIDTH = 52;
+var SHEET_ROW_HEIGHT = 32;
+var columnWidth = (column) => column.width !== void 0 && column.width > 0 ? column.width : SHEET_COLUMN_WIDTHS[column.type];
+function columnOffsets(columns) {
+  const offsets = [];
+  let at = SHEET_ROW_NUMBER_WIDTH;
+  for (const column of columns) {
+    offsets.push(at);
+    at += columnWidth(column);
+  }
+  return offsets;
+}
+function drawnColumns(columns) {
+  return [...columns.filter((column) => column.frozen), ...columns.filter((column) => !column.frozen)];
+}
+var isTypingKey = (key2) => key2.key.length === 1 && !isMod(key2) && !key2.altKey;
+
+// src/SheetModel/clipboard.ts
+function quote(field) {
+  return /[\t\n\r"]/.test(field) ? `"${field.replaceAll('"', '""')}"` : field;
+}
+function toTSV(columns, rows, range, context) {
+  const lines = [];
+  for (let row = range.top; row <= range.bottom; row += 1) {
+    const record = rows[row];
+    if (!record) continue;
+    const fields = [];
+    for (let col = range.left; col <= range.right; col += 1) {
+      const column = columns[col];
+      if (!column) continue;
+      fields.push(quote(editText(column, normalizeValue(column, record.values[column.field]), context)));
+    }
+    lines.push(fields.join("	"));
+  }
+  return lines.join("\n");
+}
+function parseTSV(text) {
+  const rows = [];
+  let row = [];
+  let field = "";
+  let quoted = false;
+  let at = 0;
+  const source = text.replace(/\r\n?/g, "\n");
+  while (at < source.length) {
+    const char = source[at];
+    if (quoted) {
+      if (char === '"' && source[at + 1] === '"') {
+        field += '"';
+        at += 2;
+        continue;
+      }
+      if (char === '"') {
+        quoted = false;
+        at += 1;
+        continue;
+      }
+      field += char;
+      at += 1;
+      continue;
+    }
+    if (char === '"' && field === "") {
+      quoted = true;
+    } else if (char === "	") {
+      row.push(field);
+      field = "";
+    } else if (char === "\n") {
+      row.push(field);
+      rows.push(row);
+      row = [];
+      field = "";
+    } else {
+      field += char;
+    }
+    at += 1;
+  }
+  if (field !== "" || row.length > 0) {
+    row.push(field);
+    rows.push(row);
+  }
+  return rows;
+}
+function planPaste(columns, rows, target, block, context) {
+  const plan = { edits: [], refused: [] };
+  if (block.length === 0) return plan;
+  const single = block.length === 1 && block[0].length === 1;
+  const height = single ? target.bottom - target.top + 1 : block.length;
+  const width = single ? target.right - target.left + 1 : Math.max(...block.map((line) => line.length));
+  for (let r = 0; r < height; r += 1) {
+    const row = rows[target.top + r];
+    if (!row) break;
+    for (let c = 0; c < width; c += 1) {
+      const column = columns[target.left + c];
+      if (!column) break;
+      if (column.readOnly) continue;
+      const text = single ? block[0][0] : block[r]?.[c];
+      if (text === void 0) continue;
+      const parsed = parseText(column, text, context);
+      if (!parsed.ok) {
+        plan.refused.push({ rowId: row.id, field: column.field, error: parsed.error });
+        continue;
+      }
+      if (sameValue(parsed.value, normalizeValue(column, row.values[column.field]))) continue;
+      plan.edits.push({ rowId: row.id, field: column.field, value: parsed.value });
+    }
+  }
+  return plan;
+}
+function planClear(columns, rows, range, context) {
+  const plan = { edits: [], refused: [] };
+  for (let r = range.top; r <= range.bottom; r += 1) {
+    const row = rows[r];
+    if (!row) continue;
+    for (let c = range.left; c <= range.right; c += 1) {
+      const column = columns[c];
+      if (!column || column.readOnly) continue;
+      const empty = column.type === "checkbox" ? false : column.type === "multiselect" ? [] : null;
+      if (sameValue(normalizeValue(column, row.values[column.field]), empty)) continue;
+      if (column.required && column.type !== "checkbox") {
+        plan.refused.push({ rowId: row.id, field: column.field, error: context.labels.required(column.label) });
+        continue;
+      }
+      plan.edits.push({ rowId: row.id, field: column.field, value: empty });
+    }
+  }
+  return plan;
+}
+
+// src/SheetModel/edits.ts
+function refusalText(code, detail, labels) {
+  if (code === "forbidden" || code === "capability_not_declared") return labels.forbidden;
+  const said = detail?.trim();
+  return said ? said : labels.couldNotSave;
+}
+var key = (rowId, field) => `${rowId}\0${field}`;
+var SheetPendingEdits = class {
+  waiting = /* @__PURE__ */ new Map();
+  refusals = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  failed = 0;
+  /** Marks a cell pending, and hands back the one function that settles this edit. Calling it twice does nothing. */
+  begin(rowId, field) {
+    const at = key(rowId, field);
+    this.refusals.delete(at);
+    this.waiting.set(at, (this.waiting.get(at) ?? 0) + 1);
+    this.emit();
+    let settled = false;
+    return (outcome) => {
+      if (settled) return;
+      settled = true;
+      const left = (this.waiting.get(at) ?? 1) - 1;
+      if (left <= 0) this.waiting.delete(at);
+      else this.waiting.set(at, left);
+      if (!outcome.ok) {
+        this.refusals.set(at, outcome.message);
+        this.failed += 1;
+      }
+      this.emit();
+    };
+  }
+  isPending(rowId, field) {
+    return this.waiting.has(key(rowId, field));
+  }
+  refusal(rowId, field) {
+    return this.refusals.get(key(rowId, field));
+  }
+  /** Clears a cell's refusal, once its reason has been read or acted on. */
+  dismiss(rowId, field) {
+    if (this.refusals.delete(key(rowId, field))) this.emit();
+  }
+  /** Edits sent and not yet settled, for the sync strip. */
+  get saving() {
+    let count = 0;
+    for (const value of this.waiting.values()) count += value;
+    return count;
+  }
+  /** The sync strip's state. Refusals are said on their cells, so they do not count as failures to retry. */
+  sync(offline = false) {
+    return { saving: this.saving, offline };
+  }
+  /** Every refusal since the last `resetFailures`, for a host that reports them. */
+  get failures() {
+    return this.failed;
+  }
+  resetFailures() {
+    this.failed = 0;
+  }
+  /** The host's rows with each one's pending and refused cells attached. */
+  decorate(rows) {
+    if (this.waiting.size === 0 && this.refusals.size === 0) return [...rows];
+    return rows.map((row) => {
+      const pending = [];
+      const refused = {};
+      for (const at of this.waiting.keys()) {
+        const [rowId, field] = at.split("\0");
+        if (rowId === row.id) pending.push(field);
+      }
+      for (const [at, message] of this.refusals) {
+        const [rowId, field] = at.split("\0");
+        if (rowId === row.id) refused[field] = message;
+      }
+      if (pending.length === 0 && Object.keys(refused).length === 0) return row;
+      return {
+        ...row,
+        pending: [...row.pending ?? [], ...pending],
+        refused: { ...row.refused, ...refused }
+      };
+    });
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => void this.listeners.delete(listener);
+  }
+  emit() {
+    for (const listener of this.listeners) listener();
+  }
+};
+function changeTime(at, locale) {
+  const when = at instanceof Date ? at : new Date(at);
+  if (Number.isNaN(when.getTime())) return "";
+  return new Intl.DateTimeFormat(locale, { hour: "2-digit", minute: "2-digit" }).format(when);
+}
+function changeText(change, labels, previous, locale) {
+  return labels.changed(change.by, changeTime(change.at, locale), previous);
+}
+var hasPrevious = (change) => change.previous !== void 0;
+
+// src/SheetModel/view.ts
+function sortRows(columns, rows, sort, context) {
+  if (!sort) return [...rows];
+  const column = columns.find((candidate) => candidate.field === sort.field);
+  if (!column) return [...rows];
+  const sign = sort.direction === "descending" ? -1 : 1;
+  return rows.map((row, index) => ({ row, index, value: normalizeValue(column, row.values[column.field]) })).sort((a, b) => {
+    const empty = (value) => value === null || value === "" || Array.isArray(value) && value.length === 0;
+    if (column.type !== "checkbox" && (empty(a.value) || empty(b.value))) {
+      return empty(a.value) === empty(b.value) ? a.index - b.index : empty(a.value) ? 1 : -1;
+    }
+    return sign * compareValues(column, a.value, b.value, context) || a.index - b.index;
+  }).map(({ row }) => row);
+}
+function nextSort(current, field) {
+  if (!current || current.field !== field) return { field, direction: "ascending" };
+  return current.direction === "ascending" ? { field, direction: "descending" } : null;
+}
+var cellKey = (rowId, field) => `${rowId}\0${field}`;
+function presenceByCell(presence) {
+  const out = /* @__PURE__ */ new Map();
+  for (const entry of presence ?? []) {
+    const at = cellKey(entry.rowId, entry.field);
+    const list = out.get(at);
+    if (list) list.push(entry);
+    else out.set(at, [entry]);
+  }
+  for (const list of out.values()) list.sort((a, b) => Number(Boolean(b.editing)) - Number(Boolean(a.editing)));
+  return out;
+}
+function presenceByRow(presence) {
+  const out = /* @__PURE__ */ new Map();
+  for (const entry of presence ?? []) if (!out.has(entry.rowId)) out.set(entry.rowId, entry);
+  return out;
+}
+function presenceByColumn(presence, max = 2) {
+  const out = /* @__PURE__ */ new Map();
+  for (const entry of presence ?? []) {
+    const list = out.get(entry.field) ?? [];
+    if (list.length < max && !list.some((other) => other.id === entry.id)) list.push(entry);
+    out.set(entry.field, list);
+  }
+  return out;
+}
+function flagText(entries) {
+  return entries.map((entry) => entry.name).join(", ");
+}
+function cellDescription(column, row, others, context, presenceLabels = PRESENCE_LABELS) {
+  const { labels } = context;
+  const parts = [`${column.label}.`];
+  if (column.readOnly) parts.push(labels.readOnly(column.label));
+  if (row.pending?.includes(column.field)) parts.push(`${labels.saving}.`);
+  const refused = row.refused?.[column.field];
+  if (refused) parts.push(refused);
+  const names = others.map((entry) => entry.name);
+  if (names.length > 0) parts.push(presenceLabels.alsoHere(names));
+  const change = row.changed?.[column.field];
+  if (change) {
+    const previous = hasPrevious(change) ? displayText(column, normalizeValue(column, change.previous), context) || null : null;
+    parts.push(changeText(change, labels, previous, context.locale));
+  }
+  return parts.join(" ");
+}
+function rowName(columns, row, index, context) {
+  const primary = columns.find((column) => column.type === "text");
+  if (primary) {
+    const text = displayText(primary, normalizeValue(primary, row.values[primary.field]), context);
+    if (text) return text;
+  }
+  return String(index + 1);
+}
+function cellSpeech(column, row, context) {
+  return spokenText(column, normalizeValue(column, row.values[column.field]), context);
+}
+
+export { LONGTEXT_MAX_DEFAULT, RATING_MAX_CEILING, RATING_MAX_DEFAULT, SHEET_COLUMN_TYPES, SHEET_COLUMN_WIDTHS, SHEET_LABELS, SHEET_ROW_HEIGHT, SHEET_ROW_NUMBER_WIDTH, SheetPendingEdits, TEXT_MAX_DEFAULT, URL_MAX, cellDescription, cellKey, cellSpeech, changeText, changeTime, checkValue, columnOffsets, columnWidth, compareValues, displayText, drawnColumns, editText, editorSide, findOption, findPerson, flagText, hasPrevious, inRange, isEmptyValue, isMod, isMultiCell, isSheetColumnType, isTypingKey, liveOptions, moveFrom, nextSort, normalizeValue, optionHue, parseOptionList, parseTSV, parseText, planClear, planPaste, presenceByCell, presenceByColumn, presenceByRow, rangeOf, ratingMax, refusalText, rowName, sameValue, scrollToRow, sheetLabels, sortRows, spokenText, statusTone, textMax, toTSV, visibleRows };