@bettercms-ai/kit 0.1.1 → 2.0.0

package/dist/controls/table/refs.js

@@ -0,0 +1,79 @@
+import { useKitServices } from "../../context.js";
+import * as React from "react";
+//#region src/controls/table/refs.ts
+/**
+* Reference cells: what a `reference` column's cell may point at, found through the HOST (the kit never fetches).
+*
+* A reference cell stores `{ ref, label?, href? }` (BE table-value.ts TableRef): the id of a page or an entry. Its column's
+* `refTo` narrows the targets ("page", and collections by content-model id or slug); with no `refTo` V2 offers pages. The
+* backend checks the id exists and is a kind `refTo` allows (`reference_target_not_allowed`), so the picker only lists
+* what the same rule accepts: the host answers through POST /content/reference-options with the configs
+* `tableRefConfigs(refTo)` names.
+*
+* Host contract (a KitServices key, provided by src/features/dock-v2 and the /style-guide/kit sandbox):
+*
+*   tableRefSearch(req) → Promise<TableRefOption[]>
+*
+* Absent → the picker says, in words, that this view cannot search pages or entries (stored cells still show).
+*/
+/**
+* The POST /content/reference-options `config` bodies one column's `refTo` needs (the host sends each and merges the
+* answers): pages through `targets: ["page"]`, each collection through `contentModelId`.
+*/
+function tableRefConfigs(refTo) {
+	const to = refTo?.length ? refTo : ["page"];
+	const out = [];
+	if (to.includes("page")) out.push({ targets: ["page"] });
+	for (const id of to) if (id !== "page" && id) out.push({ contentModelId: id });
+	return out;
+}
+/** The words a stored reference shows: what a read resolved onto it, its stored label, else its id. */
+function refLabel(r) {
+	return r.resolved?.title || r.label || r.ref;
+}
+/** Search while `open`, 200ms after the last keystroke; a newer query aborts the older one. */
+function useRefSearch(open, refTo, q) {
+	const search = useKitServices().tableRefSearch;
+	const key = refTo?.join(",") ?? "";
+	const ask = `${key}\u0000${q.trim()}`;
+	const [answer, setAnswer] = React.useState(null);
+	React.useEffect(() => {
+		if (!search || !open) return;
+		const ctl = new AbortController();
+		const t = window.setTimeout(() => {
+			search({
+				refTo: key ? key.split(",") : null,
+				q: q.trim(),
+				signal: ctl.signal
+			}).then((options) => !ctl.signal.aborted && setAnswer({
+				ask,
+				state: {
+					status: "ready",
+					options
+				}
+			}), (e) => !ctl.signal.aborted && setAnswer({
+				ask,
+				state: {
+					status: "error",
+					message: e instanceof Error && e.message ? e.message : "The search did not answer."
+				}
+			}));
+		}, 200);
+		return () => {
+			ctl.abort();
+			window.clearTimeout(t);
+		};
+	}, [
+		search,
+		open,
+		key,
+		q,
+		ask
+	]);
+	if (!search) return { status: "unavailable" };
+	return answer?.ask === ask ? answer.state : { status: "loading" };
+}
+//#endregion
+export { refLabel, tableRefConfigs, useRefSearch };
+
+//# sourceMappingURL=refs.js.map

package/dist/controls/table/refs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refs.js","names":[],"sources":["../../../src/controls/table/refs.ts"],"sourcesContent":["/**\n * Reference cells: what a `reference` column's cell may point at, found through the HOST (the kit never fetches).\n *\n * A reference cell stores `{ ref, label?, href? }` (BE table-value.ts TableRef): the id of a page or an entry. Its column's\n * `refTo` narrows the targets (\"page\", and collections by content-model id or slug); with no `refTo` V2 offers pages. The\n * backend checks the id exists and is a kind `refTo` allows (`reference_target_not_allowed`), so the picker only lists\n * what the same rule accepts: the host answers through POST /content/reference-options with the configs\n * `tableRefConfigs(refTo)` names.\n *\n * Host contract (a KitServices key, provided by src/features/dock-v2 and the /style-guide/kit sandbox):\n *\n *   tableRefSearch(req) → Promise<TableRefOption[]>\n *\n * Absent → the picker says, in words, that this view cannot search pages or entries (stored cells still show).\n */\nimport * as React from \"react\";\nimport { useKitServices } from \"../../context\";\nimport type { TableRef } from \"../../schema/table\";\n\nexport interface TableRefOption {\n  /** page or entry id: what the cell stores as `ref` */\n  id: string;\n  title: string;\n  /** \"Blog post · my-slug\", \"Page\" */\n  subtitle?: string;\n  /** the public path, stored as the cell's `href` so the published table links without a read */\n  href?: string;\n}\nexport interface TableRefSearchRequest {\n  /** the column's `refTo` (null = pages, as V2) */\n  refTo: string[] | null;\n  q: string;\n  signal: AbortSignal;\n}\nexport type TableRefSearch = (req: TableRefSearchRequest) => Promise<TableRefOption[]>;\nexport interface TableKitServices {\n  tableRefSearch?: TableRefSearch;\n}\ndeclare module \"../../context\" {\n  interface KitServices {\n    /** Search pages and entries for a table's reference cells (see above). Absent → the picker names why it can't. */\n    tableRefSearch?: TableRefSearch;\n  }\n}\n\n/**\n * The POST /content/reference-options `config` bodies one column's `refTo` needs (the host sends each and merges the\n * answers): pages through `targets: [\"page\"]`, each collection through `contentModelId`.\n */\nexport function tableRefConfigs(refTo: string[] | null | undefined): Record<string, unknown>[] {\n  const to = refTo?.length ? refTo : [\"page\"];\n  const out: Record<string, unknown>[] = [];\n  if (to.includes(\"page\")) out.push({ targets: [\"page\"] });\n  for (const id of to) if (id !== \"page\" && id) out.push({ contentModelId: id });\n  return out;\n}\n\n/** The words a stored reference shows: what a read resolved onto it, its stored label, else its id. */\nexport function refLabel(r: TableRef & { resolved?: { title?: string } }): string {\n  return r.resolved?.title || r.label || r.ref;\n}\n\nexport type RefSearchState =\n  | { status: \"unavailable\" }\n  | { status: \"loading\" }\n  | { status: \"ready\"; options: TableRefOption[] }\n  | { status: \"error\"; message: string };\n\n/** Search while `open`, 200ms after the last keystroke; a newer query aborts the older one. */\nexport function useRefSearch(open: boolean, refTo: string[] | null, q: string): RefSearchState {\n  const search = useKitServices().tableRefSearch;\n  const key = refTo?.join(\",\") ?? \"\";\n  const ask = `${key}\\u0000${q.trim()}`;\n  // the answer, tagged with the question it answers: a different question reads as loading until its own answer lands\n  const [answer, setAnswer] = React.useState<{ ask: string; state: RefSearchState } | null>(null);\n  React.useEffect(() => {\n    if (!search || !open) return;\n    const ctl = new AbortController();\n    const t = window.setTimeout(() => {\n      search({ refTo: key ? key.split(\",\") : null, q: q.trim(), signal: ctl.signal }).then(\n        (options) => !ctl.signal.aborted && setAnswer({ ask, state: { status: \"ready\", options } }),\n        (e: unknown) => !ctl.signal.aborted && setAnswer({ ask, state: { status: \"error\", message: e instanceof Error && e.message ? e.message : \"The search did not answer.\" } }),\n      );\n    }, 200);\n    return () => {\n      ctl.abort();\n      window.clearTimeout(t);\n    };\n  }, [search, open, key, q, ask]);\n  if (!search) return { status: \"unavailable\" };\n  return answer?.ask === ask ? answer.state : { status: \"loading\" };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAiDA,SAAgB,gBAAgB,OAA+D;CAC7F,MAAM,KAAK,OAAO,SAAS,QAAQ,CAAC,MAAM;CAC1C,MAAM,MAAiC,CAAC;CACxC,IAAI,GAAG,SAAS,MAAM,GAAG,IAAI,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,CAAC;CACvD,KAAK,MAAM,MAAM,IAAI,IAAI,OAAO,UAAU,IAAI,IAAI,KAAK,EAAE,gBAAgB,GAAG,CAAC;CAC7E,OAAO;AACT;;AAGA,SAAgB,SAAS,GAAyD;CAChF,OAAO,EAAE,UAAU,SAAS,EAAE,SAAS,EAAE;AAC3C;;AASA,SAAgB,aAAa,MAAe,OAAwB,GAA2B;CAC7F,MAAM,SAAS,eAAe,CAAC,CAAC;CAChC,MAAM,MAAM,OAAO,KAAK,GAAG,KAAK;CAChC,MAAM,MAAM,GAAG,IAAI,QAAQ,EAAE,KAAK;CAElC,MAAM,CAAC,QAAQ,aAAa,MAAM,SAAwD,IAAI;CAC9F,MAAM,gBAAgB;EACpB,IAAI,CAAC,UAAU,CAAC,MAAM;EACtB,MAAM,MAAM,IAAI,gBAAgB;EAChC,MAAM,IAAI,OAAO,iBAAiB;GAChC,OAAO;IAAE,OAAO,MAAM,IAAI,MAAM,GAAG,IAAI;IAAM,GAAG,EAAE,KAAK;IAAG,QAAQ,IAAI;GAAO,CAAC,CAAC,CAAC,MAC7E,YAAY,CAAC,IAAI,OAAO,WAAW,UAAU;IAAE;IAAK,OAAO;KAAE,QAAQ;KAAS;IAAQ;GAAE,CAAC,IACzF,MAAe,CAAC,IAAI,OAAO,WAAW,UAAU;IAAE;IAAK,OAAO;KAAE,QAAQ;KAAS,SAAS,aAAa,SAAS,EAAE,UAAU,EAAE,UAAU;IAA6B;GAAE,CAAC,CAC3K;EACF,GAAG,GAAG;EACN,aAAa;GACX,IAAI,MAAM;GACV,OAAO,aAAa,CAAC;EACvB;CACF,GAAG;EAAC;EAAQ;EAAM;EAAK;EAAG;CAAG,CAAC;CAC9B,IAAI,CAAC,QAAQ,OAAO,EAAE,QAAQ,cAAc;CAC5C,OAAO,QAAQ,QAAQ,MAAM,OAAO,QAAQ,EAAE,QAAQ,UAAU;AAClE"}

package/dist/controls/table/stored.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The table value as the backend stores it (BE `packages/types/src/table-value.ts`, a `table` field or a `table` prop with
+ * `config.mode: "data"`). The editor works on `normalizeTable(value)`, which fills keys the stored value may not have
+ * (`id`, empty `columnGroups` / `rowGroups` / `footnotes`). Writing those back would change a value nobody edited, so
+ * `storedTable` hands back exactly what the person changed:
+ *
+ *  - keys normalize invented (an `id`, an empty list the stored value did not carry) are dropped again;
+ *  - `undefined` keys (a switch turned off: `highlight`, `sortable`, `notes`…) are removed, as JSON would remove them;
+ *  - a reference cell's `resolved` (what a read writes onto it) is never written back (BE normalizeTableValue drops it too).
+ *
+ * The backend refuses any key it does not know (`table_value_invalid`), so nothing else is added here.
+ */
+import { type TableValue } from "../../schema/table";
+/** `next` as the backend stores it, given the value it was loaded from (`prev`; undefined for a new table). */
+export declare function storedTable(next: TableValue, prev: unknown): TableValue;

package/dist/controls/table/stored.js

@@ -0,0 +1,44 @@
+import { TABLE_COLUMN_TYPES, isTableValue } from "../../schema/table.js";
+//#region src/controls/table/stored.ts
+/**
+* The table value as the backend stores it (BE `packages/types/src/table-value.ts`, a `table` field or a `table` prop with
+* `config.mode: "data"`). The editor works on `normalizeTable(value)`, which fills keys the stored value may not have
+* (`id`, empty `columnGroups` / `rowGroups` / `footnotes`). Writing those back would change a value nobody edited, so
+* `storedTable` hands back exactly what the person changed:
+*
+*  - keys normalize invented (an `id`, an empty list the stored value did not carry) are dropped again;
+*  - `undefined` keys (a switch turned off: `highlight`, `sortable`, `notes`…) are removed, as JSON would remove them;
+*  - a reference cell's `resolved` (what a read writes onto it) is never written back (BE normalizeTableValue drops it too).
+*
+* The backend refuses any key it does not know (`table_value_invalid`), so nothing else is added here.
+*/
+var LISTS = [
+	"columnGroups",
+	"rowGroups",
+	"footnotes"
+];
+/** A JSON copy without `undefined` keys (what the save would send), and without a reference cell's read-only `resolved`. */
+function plain(v) {
+	return JSON.parse(JSON.stringify(v, (k, x) => k === "resolved" ? void 0 : x));
+}
+/** `next` as the backend stores it, given the value it was loaded from (`prev`; undefined for a new table). */
+function storedTable(next, prev) {
+	const out = plain(next);
+	const was = isTableValue(prev) ? prev : null;
+	if (was) {
+		if (!("id" in was) && out.id !== void 0) delete out.id;
+		for (const k of LISTS) if (!(k in was) && Array.isArray(out[k]) && out[k].length === 0) delete out[k];
+		const prevCols = new Map((Array.isArray(was.columns) ? was.columns : []).filter((c) => !!c && typeof c === "object").map((c) => [c._key, c]));
+		for (const col of out.columns) {
+			const p = prevCols.get(col._key);
+			if (!p || col.type !== "text" || TABLE_COLUMN_TYPES.some((t) => t.value === p.type)) continue;
+			if (p.type === void 0) delete col.type;
+			else col.type = p.type;
+		}
+	} else for (const k of LISTS) if (Array.isArray(out[k]) && out[k].length === 0) delete out[k];
+	return out;
+}
+//#endregion
+export { storedTable };
+
+//# sourceMappingURL=stored.js.map

package/dist/controls/table/stored.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored.js","names":[],"sources":["../../../src/controls/table/stored.ts"],"sourcesContent":["/**\n * The table value as the backend stores it (BE `packages/types/src/table-value.ts`, a `table` field or a `table` prop with\n * `config.mode: \"data\"`). The editor works on `normalizeTable(value)`, which fills keys the stored value may not have\n * (`id`, empty `columnGroups` / `rowGroups` / `footnotes`). Writing those back would change a value nobody edited, so\n * `storedTable` hands back exactly what the person changed:\n *\n *  - keys normalize invented (an `id`, an empty list the stored value did not carry) are dropped again;\n *  - `undefined` keys (a switch turned off: `highlight`, `sortable`, `notes`…) are removed, as JSON would remove them;\n *  - a reference cell's `resolved` (what a read writes onto it) is never written back (BE normalizeTableValue drops it too).\n *\n * The backend refuses any key it does not know (`table_value_invalid`), so nothing else is added here.\n */\nimport { TABLE_COLUMN_TYPES, isTableValue, type TableValue } from \"../../schema/table\";\n\nconst LISTS = [\"columnGroups\", \"rowGroups\", \"footnotes\"] as const;\n\n/** A JSON copy without `undefined` keys (what the save would send), and without a reference cell's read-only `resolved`. */\nfunction plain<T>(v: T): T {\n  return JSON.parse(JSON.stringify(v, (k, x) => (k === \"resolved\" ? undefined : x))) as T;\n}\n\n/** `next` as the backend stores it, given the value it was loaded from (`prev`; undefined for a new table). */\nexport function storedTable(next: TableValue, prev: unknown): TableValue {\n  const out = plain(next) as TableValue & Record<string, unknown>;\n  const was = isTableValue(prev) ? (prev as unknown as Record<string, unknown>) : null;\n  if (was) {\n    if (!(\"id\" in was) && out.id !== undefined) delete out.id;\n    for (const k of LISTS) if (!(k in was) && Array.isArray(out[k]) && (out[k] as unknown[]).length === 0) delete out[k];\n    // normalize reads a column type it does not know (or none) as \"text\": unless the person picked another type, the\n    // stored one is written back as it was\n    const prevCols = new Map((Array.isArray(was.columns) ? was.columns : []).filter((c): c is Record<string, unknown> => !!c && typeof c === \"object\").map((c) => [c._key, c] as const));\n    for (const col of out.columns as unknown as Record<string, unknown>[]) {\n      const p = prevCols.get(col._key);\n      if (!p || col.type !== \"text\" || TABLE_COLUMN_TYPES.some((t) => t.value === p.type)) continue;\n      if (p.type === undefined) delete col.type;\n      else col.type = p.type;\n    }\n  } else {\n    for (const k of LISTS) if (Array.isArray(out[k]) && (out[k] as unknown[]).length === 0) delete out[k];\n  }\n  return out;\n}\n"],"mappings":";;;;;;;;;;;;;;AAcA,IAAM,QAAQ;CAAC;CAAgB;CAAa;AAAW;;AAGvD,SAAS,MAAS,GAAS;CACzB,OAAO,KAAK,MAAM,KAAK,UAAU,IAAI,GAAG,MAAO,MAAM,aAAa,KAAA,IAAY,CAAE,CAAC;AACnF;;AAGA,SAAgB,YAAY,MAAkB,MAA2B;CACvE,MAAM,MAAM,MAAM,IAAI;CACtB,MAAM,MAAM,aAAa,IAAI,IAAK,OAA8C;CAChF,IAAI,KAAK;EACP,IAAI,EAAE,QAAQ,QAAQ,IAAI,OAAO,KAAA,GAAW,OAAO,IAAI;EACvD,KAAK,MAAM,KAAK,OAAO,IAAI,EAAE,KAAK,QAAQ,MAAM,QAAQ,IAAI,EAAE,KAAM,IAAI,EAAE,CAAe,WAAW,GAAG,OAAO,IAAI;EAGlH,MAAM,WAAW,IAAI,KAAK,MAAM,QAAQ,IAAI,OAAO,IAAI,IAAI,UAAU,CAAC,EAAA,CAAG,QAAQ,MAAoC,CAAC,CAAC,KAAK,OAAO,MAAM,QAAQ,CAAC,CAAC,KAAK,MAAM,CAAC,EAAE,MAAM,CAAC,CAAU,CAAC;EACnL,KAAK,MAAM,OAAO,IAAI,SAAiD;GACrE,MAAM,IAAI,SAAS,IAAI,IAAI,IAAI;GAC/B,IAAI,CAAC,KAAK,IAAI,SAAS,UAAU,mBAAmB,MAAM,MAAM,EAAE,UAAU,EAAE,IAAI,GAAG;GACrF,IAAI,EAAE,SAAS,KAAA,GAAW,OAAO,IAAI;QAChC,IAAI,OAAO,EAAE;EACpB;CACF,OACE,KAAK,MAAM,KAAK,OAAO,IAAI,MAAM,QAAQ,IAAI,EAAE,KAAM,IAAI,EAAE,CAAe,WAAW,GAAG,OAAO,IAAI;CAErG,OAAO;AACT"}

package/dist/controls/table/table-editor.d.ts

@@ -0,0 +1,103 @@
+/**
+ * TABLE EDITOR (CPO D42, D49, D50, D52; port of V2 src/components/table/table-editor.tsx) — calm by default.
+ *
+ *  Default   nested array UX (D50): Title, Columns (an array list), Rows (nested under their groups, each the kit's own
+ *            array row: first cell, summary, ⋯, ›), Note under the table, then a collapsed Table settings. A row or column
+ *            drills through the kit form's navigation (standard breadcrumb + frame header, TableFrame); outside a form,
+ *            through a local drill with the same trail. A row is one field per column; the column's type picks the
+ *            control; per-cell exceptions (words instead, footnote, clear) sit behind a quiet ⋯ by the cell's label.
+ *  Expanded  the spreadsheet lives ONLY in the expanded-editor modal (D49), opened by ⤢ in the field's label row: click a
+ *            cell and type, Tab / arrows / Enter move, "+" adds a column, grips reorder, ⋯ / Shift+F10 / right-click for
+ *            column, row and cell options.
+ *  Settings  (D52) only presentation and structure, only what `field.table.settings` offers this kind.
+ *
+ * Kit deviations from V2 (no @dnd-kit / Radix in the kit): rows reorder inside their run with the kit's useDragReorder
+ * (pointer + ↑/↓ on the grip); moving a row to another group is the row's ⋯ › Move to group (V2 also allowed dragging it
+ * across). The cell context menu is Base UI's ContextMenu. Toasts come from KitServices (absent → silent). Link cells use
+ * the table's own address editor (table-link.tsx) in the spreadsheet and the global LinkField in a drilled row (as V2); reference cells search through the host (refs.ts).
+ */
+import * as React from "react";
+import type { FieldPath } from "../../schema/types";
+import { type RefResolver, type TableCell, type TableColumn, type TableColumnType, type TableFieldOptions, type TableResponsive, type TableRow, type TableValue } from "../../schema/table";
+export interface TableEditorProps {
+    value: TableValue;
+    onChange: (v: TableValue) => void;
+    readOnly?: boolean;
+    /** Trailing actions on the Title row (Remove table in rich text, V2). */
+    actions?: React.ReactNode;
+    options?: TableFieldOptions;
+    /** Show developer-only settings (hide the title, sticky header, stripes, compact, rich text / reference types). */
+    developer?: boolean;
+    /** Names a reference id the stored cell does not carry a label for (the host's lookup); absent → stored label / id. */
+    resolveRef?: RefResolver;
+    label?: string;
+    /** The page or block name, first crumb of the full-screen breadcrumb ("Competitor comparison › Comparison"). */
+    parentTitle?: string;
+    /** D50: inside a kit form, rows and columns drill through the form's own navigation (standard breadcrumb + frame). */
+    nav?: TableNav;
+    /** Controlled full-screen state, when the host shows the ⤢ button itself (the kit field's label row). */
+    fullScreen?: {
+        open: boolean;
+        onOpenChange: (open: boolean) => void;
+        returnFocus?: () => HTMLElement | null;
+    };
+}
+export interface TableNav {
+    /** stable id of this table field (focus returns to the row that was open) */
+    id: string;
+    /** the table field's path in the form; rows live at [...basePath, "rows", i], columns at [...basePath, "columns", i] */
+    basePath: FieldPath;
+    open: (kind: "rows" | "columns", index: number) => void;
+}
+type IconCmp = React.ComponentType<{
+    className?: string;
+    stroke?: number;
+}>;
+export declare const TYPE_UI: Record<TableColumnType, {
+    label: string;
+    icon: IconCmp;
+    dev?: boolean;
+}>;
+/** What a person typed → the cell. A value that doesn't fit its column (e.g. "Partly" in Yes / No) becomes a text cell. */
+export declare function typedCell(prev: TableCell | undefined, col: TableColumn, row: TableRow, raw: string): TableCell;
+/** Change a column's type; filled cells are re-read as the new type (words that don't fit become a text cell). */
+export declare function retype(t: TableValue, key: string, type: TableColumnType, resolveRef?: RefResolver): TableValue;
+/** Move a row to a displayed position; crossing into another group (or the totals) takes on that place. */
+export declare function moveRowTo(t: TableValue, from: number, to: number): TableValue;
+/** CPO D49: the ONE way into the spreadsheet — opens it in the shared ExpandedEditorModal. Place it next to the title. */
+export declare function TableFullScreenButton({ onOpen, className }: {
+    onOpen: () => void;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function TableEditor(props: TableEditorProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * One row or one column of a table, as the body of a drilled frame (D50). The kit form shows it under the standard
+ * breadcrumb and frame header, exactly like an FAQ item; hosts without a form get the same body from TableEditor.
+ */
+export declare function TableItemEditor({ kind, index, value, onChange, options, developer, resolveRef, readOnly, }: Pick<TableEditorProps, "value" | "onChange" | "options" | "developer" | "resolveRef" | "readOnly"> & {
+    kind: "row" | "column";
+    index: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function offered(options: TableFieldOptions): {
+    headers: boolean;
+    totals: boolean;
+    phones: {
+        value: TableResponsive;
+        label: string;
+    }[];
+    highlight: boolean;
+    sticky: boolean;
+    sort: boolean;
+    search: boolean;
+    jsonLd: ("ItemList" | "Dataset" | "Offers")[];
+    groups: boolean;
+    footnotes: boolean;
+    note: boolean;
+};
+/** Unlink a footnote from one cell; the footnote itself goes when no other cell points at it. */
+export declare function unlinkNote(t: TableValue, rowKey: string, colKey: string): TableValue;
+/** Link a new, empty footnote to one cell. Returns the table and the footnote's key (its input takes focus). */
+export declare function linkNote(t: TableValue, rowKey: string, colKey: string): [TableValue, string];
+/** Totals on: an empty totals row appears at the end of the list. Off: empty totals rows go, filled ones rejoin the body. */
+export declare function setTotals(t: TableValue, on: boolean): TableValue;
+export {};