@updog/data-editor 0.1.85 → 0.1.86

package/{errors-QjijTHhG.js → errors-B6IWsH_J.js}

@@ -1,6 +1,6 @@
 import { detect as e } from "chardet";
 //#region src/core/encoding/cleanCell.ts
-var t = /[\u200B-\u200D\uFEFF\u2060]/g, n = /[\u00A0\u202F]/g, r = (e) => e.replace(t, "").replace(n, " ").normalize("NFC").trim(), i = (e) => e.length >= 4 && e[0] === 255 && e[1] === 254 && e[2] === 0 && e[3] === 0 ? {
+var t = /[\u200B-\u200F\uFEFF\u2060]/g, n = /[\u00A0\u202F]/g, r = (e) => e.replace(t, "").replace(n, " ").normalize("NFC").trim(), i = (e) => e.length >= 4 && e[0] === 255 && e[1] === 254 && e[2] === 0 && e[3] === 0 ? {
 	encoding: "utf-32le",
 	bomLength: 4
 } : e.length >= 3 && e[0] === 239 && e[1] === 187 && e[2] === 191 ? {

package/index.d.ts

@@ -575,6 +575,58 @@ declare var export_default = {
 
 type PluralSuffixes = "_zero" | "_one" | "_two" | "_few" | "_many" | "_other";
 
+/**
+ * Strips plural suffixes from a key to get the base form.
+ * e.g. "createRows_one" → "createRows", "createRows_other" → "createRows"
+ */
+type StripPluralSuffix<K extends string> =
+  K extends `${infer Base}${PluralSuffixes}` ? Base : K;
+
+/**
+ * Recursively derives dot-separated keys from a nested object type.
+ * - Plural keys (e.g. `createRows_one`, `createRows_other`) are collapsed to their base (`createRows`).
+ * - `Record<string, string>` leaf nodes (like `calendar.months`) are treated as terminal.
+ */
+type NestedKeyOf<T, Prefix extends string = ""> =
+  T extends Record<string, unknown>
+    ? string extends keyof T
+      ? Prefix extends ""
+        ? never
+        : Prefix
+      : {
+          [K in keyof T & string]: T[K] extends Record<string, unknown>
+            ? string extends keyof T[K]
+              ?
+                  | (Prefix extends ""
+                      ? StripPluralSuffix<K>
+                      : `${Prefix}.${StripPluralSuffix<K>}`)
+                  | NestedKeyOf<
+                      T[K],
+                      Prefix extends ""
+                        ? StripPluralSuffix<K>
+                        : `${Prefix}.${StripPluralSuffix<K>}`
+                    >
+              : NestedKeyOf<
+                  T[K],
+                  Prefix extends ""
+                    ? StripPluralSuffix<K>
+                    : `${Prefix}.${StripPluralSuffix<K>}`
+                >
+            : Prefix extends ""
+              ? StripPluralSuffix<K>
+              : `${Prefix}.${StripPluralSuffix<K>}`;
+        }[keyof T & string]
+    : never;
+
+/** Union of all valid translation keys derived from the English locale. */
+type TranslationKeys = NestedKeyOf<typeof export_default>;
+
+/** Typed translation function. Accepts typed keys with autocomplete, and dynamic strings as fallback. */
+type TFunction = (
+  key: TranslationKeys | (string & {}),
+  options?: Record<string, unknown>,
+) => string;
+
 /** Makes all properties optional recursively. */
 type DeepPartial<T> = {
   [P in keyof T]?: T[P] extends Record<string, unknown>
@@ -806,8 +858,21 @@ type DataEditorColumn = {
     /** Format the display value without changing stored data. E.g. add `$` prefix. */
     formatter?: (value: string) => string;
     /**
-     * Transform a value before it enters the store. Runs when rows are uploaded
-     * to the data editor.
+     * Transform a value on its way into the store. Runs on every value arriving
+     * from outside the editor, so `loadData`, a file import, a remote source, a
+     * custom format, and a paste of text from another app all call it. A value
+     * moving inside the grid is left alone, so a manual edit, a fill, a paste of
+     * cells copied from the grid itself, undo, and redo never call it.
+     *
+     * The value arrives in the shape the cell is stored in. Numbers and dates
+     * canonicalize first, and a `select` value resolves through value matching
+     * first, so the transformer sees the option the user confirmed. On a
+     * `multiselect` column it runs once per token, the way `formatter` already
+     * reads that column. A token it empties leaves the list, and two tokens it
+     * makes equal collapse into one.
+     *
+     * It runs before validation, so a transformer that moves a value outside
+     * `editor.options` makes its own column fail a `oneOf` rule.
      */
     transformer?: (value: unknown) => unknown;
     /** How the cell is edited. Defaults to text input. */
@@ -1140,6 +1205,54 @@ declare class ErrorHandler {
     handleError(error: UpdogError): void;
 }
 
+/**
+ * The parts of a column every cell type reads. Both `DataEditorColumn` and
+ * `NormalizedColumn` satisfy it, so core and the UI pass the column they hold.
+ */
+type TypedColumn = Pick<DataEditorColumn, "id" | "editor" | "formatter">;
+type ColumnFormat = {
+    readonly typeId: string;
+    readonly candidateId: string;
+};
+
+type FormatScope = string;
+type FormatField = {
+    key: string;
+    column: TypedColumn;
+};
+type AmbiguousColumn = {
+    field: string;
+    applied: ColumnFormat;
+    candidates: readonly ColumnFormat[];
+    samples: readonly string[];
+};
+type FormatBatch = {
+    reader(key: string): (value: unknown) => unknown;
+    ambiguous: readonly AmbiguousColumn[];
+};
+/**
+ * The one door every reading of raw text goes through. The verdict lives on
+ * the pair of scope and column, so a column is never read by its neighbour's
+ * verdict and a neighbouring source starts its own vote.
+ *
+ * The locale fallback needs no branch of its own: a tie falls to the first
+ * candidate in declared order, and the lists are ordered so the reader's own
+ * locale sits first among its peers.
+ */
+declare class FormatGate {
+    private deps;
+    private memory;
+    constructor(deps: {
+        columns: () => readonly TypedColumn[];
+        i18n: () => {
+            locale: string;
+            t: TFunction;
+        } | null;
+    });
+    prepare(scope: FormatScope, rows: readonly Record<string, unknown>[], fields?: readonly FormatField[]): FormatBatch;
+    forget(scope?: FormatScope): void;
+}
+
 type FormulaCellContext = {
     value: unknown;
     field: string;
@@ -1848,6 +1961,8 @@ declare class DataStore<TRow extends DataEditorRow = DataEditorRow> {
     readonly formulaRegistry: FormulaRegistry;
     private _isLoading;
     private sourceManager;
+    /** The format verdict of every source and column pair that has one. */
+    readonly formats: FormatGate;
     readonly sourceLifecycle: SourceLifecycle<TRow>;
     private dirtyTracker;
     private filterEngine;
@@ -1887,10 +2002,15 @@ declare class DataStore<TRow extends DataEditorRow = DataEditorRow> {
     private filterRowReader;
     private bulkMutationHost;
     private orchestrator;
+    private i18n;
     constructor(errorHandler?: ErrorHandler);
     getRowId(index: number): TRowId | undefined;
     getLocalRowCount(): number;
     setValidator(validator: IValidator<TRow>): void;
+    setI18n(i18n: {
+        t: TFunction;
+        locale: string;
+    }): void;
     isColumnLocked(field: string): boolean;
     isColumnPreLocked(field: string): boolean;
     lockColumn(field: string, mode?: ColumnLockMode): void;
@@ -2006,9 +2126,50 @@ declare class DataStore<TRow extends DataEditorRow = DataEditorRow> {
      * has already normalised through buildImportRow — never transforms twice.
      */
     appendClientRows(sourceId: DataSourceId, newRows: TRow[]): TRowId[];
+    private formatContext;
+    /**
+     * A column nothing separated is a signal to whoever integrated the SDK, so
+     * it goes out in English through `onError` rather than to the person at the
+     * screen. The wizard could ask which shape instead; the seam is here and
+     * the dialog is out of scope (spec section 10).
+     */
+    private reportAmbiguity;
+    /**
+     * The column's reader with no verdict behind it. A formula result is one
+     * value, so there is nothing to vote on; the reader is here to give the
+     * column's storage shape, which for a number means digits rather than an
+     * exponent or a JS number.
+     */
+    private fieldReader;
+    /**
+     * The column's own reader over values an assistant produced. There is no
+     * column of file text to vote on here, so the reader runs without a verdict,
+     * the same way a formula result is read: it gives the value the shape its
+     * column stores rather than a JS number or an exponent. A value that reads
+     * back onto what the cell already holds leaves the delta, so an untouched
+     * cell stays untouched.
+     */
+    private readChatDeltas;
     private normalizeClientRows;
     appendRows(sourceId: DataSourceId, newRows: TRow[], rowIdMap?: Map<number, TRowId>): TRowId[];
-    seedInitialChanges(assignedRowIds: TRowId[], currentRows: TRow[], changes: InitialRowChange<TRow>[]): void;
+    /**
+     * The declared transformers, resolved once so a per-row loop never rescans
+     * the column list.
+     */
+    private collectTransformers;
+    /**
+     * Runs the column transformers over a partial row the client states as a
+     * baseline, so it is compared against the stored row in the same shape the
+     * stored row was written in.
+     */
+    private transformClientValues;
+    /**
+     * Reads a stated original the way the row itself was read, then transforms
+     * it. The verdict is already in the gate's memory from the append that put
+     * these rows in, so an empty batch reuses it rather than voting again.
+     */
+    private normalizeClientValues;
+    seedInitialChanges(sourceId: DataSourceId, assignedRowIds: TRowId[], currentRows: TRow[], changes: InitialRowChange<TRow>[]): void;
     upsertRows(sourceId: DataSourceId, newRows: TRow[], options?: UpsertOptions): UpsertResult<TRow>;
     private getAnchorMap;
     private clearAnchorMapCache;