@svgrid/grid 3.0.2 → 3.0.4

package/src/editing.ts

@@ -11,7 +11,7 @@ import {
   type TableFeatures,
 } from "./index";
 import "./sv-grid-scrollbar";
-import { getNextActiveCell } from "./keyboard";
+import { getEntryStep } from "./keyboard";
 import {
   getCellKey,
   toValueArray,
@@ -21,14 +21,10 @@ import {
   getColumnBaseValue,
   isGroupRow,
 } from "./cell-values";
+import { pushHistory, nextGroupId, runHistoryGroup, type HistoryStep } from "./history";
+import { hasGridShortcuts, runGridShortcuts } from "./shortcut-registry";
+import { buildCommandContext } from "./command-context";
 
-type HistoryStep = {
-  rowId: string;
-  columnId: string;
-  field: string;
-  before: unknown;
-  after: unknown;
-};
 
 export function createEditing<
   TFeatures extends TableFeatures = TableFeatures,
@@ -132,11 +128,29 @@ export function createEditing<
       rowRef: row.original,
     };
     ctx.setActiveCell(rowIndex, colIndex);
-    ctx.setSelection(rowIndex, colIndex);
+    selectForEdit(rowIndex, colIndex);
     return true;
   }
 
+  /**
+   * The selection an edit starts with. A cell already inside the selection
+   * leaves it standing: typing into the active cell of a selected block
+   * used to collapse the block to that one cell, so Enter could never walk
+   * on inside it. A cell outside the selection becomes the selection.
+   */
+  function selectForEdit(rowIndex: number, colIndex: number) {
+    if (ctx.isCellInSelectedRange(rowIndex, colIndex)) return;
+    ctx.setSelection(rowIndex, colIndex);
+  }
+
   function saveEditingCell() {
+    // One group: a consumer's onCellValueChange may record a step of its own
+    // (a spreadsheet gives "12%" a percent format as it lands), and that
+    // belongs to the same Ctrl+Z as the value.
+    runHistoryGroup(ctx, () => commitEditingCell());
+  }
+
+  function commitEditingCell() {
     if (!ctx.editingCell) return;
     const editing = ctx.editingCell;
     // Resolve the row this edit belongs to. `allRows` is only the current page,
@@ -197,19 +211,7 @@ export function createEditing<
         before:   oldValue,
         after:    finalValue,
       }
-      const truncated = ctx.history.slice(0, ctx.historyPtr + 1)
-      truncated.push(step)
-      // Cap the buffer at UNDO_LIMIT; drop the OLDEST entries so the
-      // pointer stays valid relative to the newest steps.
-      if (truncated.length > ctx.UNDO_LIMIT) {
-        const drop = truncated.length - ctx.UNDO_LIMIT
-        ctx.history = truncated.slice(drop)
-        ctx.historyPtr = ctx.history.length - 1
-      } else {
-        ctx.history = truncated
-        ctx.historyPtr = ctx.history.length - 1
-      }
-      ctx.historyVersion += 1
+      pushHistory(ctx, [step])
     }
     // Notify the consumer AFTER the row has been updated so any callback-
     // driven recompute (cascade totals, server save, undo stack) sees the
@@ -230,6 +232,11 @@ export function createEditing<
   /** Apply an undo / redo step directly to the underlying row, bypassing
    *  the editor pipeline so we don't accidentally re-push to the stack. */
   function applyHistoryStep(step: HistoryStep, direction: 'undo' | 'redo') {
+    if (step.custom) {
+      if (direction === 'undo') step.custom.undo()
+      else step.custom.redo()
+      return
+    }
     const row = ctx.allRows.find((r: any) => r.id === step.rowId)
     const col = ctx.allColumns.find((c: any) => c.id === step.columnId)
     if (!row?.original || !col) return
@@ -261,26 +268,111 @@ export function createEditing<
    * move, Tab committed the edit and then let the browser walk focus out of the
    * grid entirely (#48). Shared by every editor type, including the textarea.
    */
-  function commitAndMoveByTab(shiftKey: boolean) {
+  /**
+   * Commit the edit and step the cursor the way data entry expects: Tab a
+   * column to the right (wrapping at the row's end), Enter a row down, Shift
+   * reversing either. Enter used to commit and stay, so a column of numbers
+   * took a click or an arrow between every value; Excel and every other
+   * sheet move down, and the accessibility page has always said this grid
+   * does too. At the last row or column the cursor stays put.
+   */
+  function commitAndMove(intent: "tabNext" | "tabPrev" | "moveDown" | "moveUp") {
     const active = ctx.activeCell;
     saveEditingCell();
     ctx.gridRootEl?.focus({ preventScroll: true });
     if (!active) return;
-    const next = getNextActiveCell(active, shiftKey ? "tabPrev" : "tabNext", {
+    // The same stepping as Enter and Tab on the grid root: a Tab run's Enter
+    // goes back to the run's first column, and a selected block keeps the
+    // cursor inside it.
+    const step = getEntryStep(active, intent, {
       maxRow: ctx.allRows.length - 1,
       maxCol: ctx.allColumns.length - 1,
+      tabOrigin: ctx.tabRunOrigin,
+      range: ctx.activeRangeRect(),
+      collapsed: {
+        isRowCollapsed: (i: number) => ctx.isRowCollapsed(i) as boolean,
+        isColumnCollapsed: (i: number) => !!ctx.collapsedColumns[ctx.allColumns[i]?.id],
+      },
     });
+    const next = step.cell;
     ctx.setActiveCell(next.rowIndex, next.colIndex);
-    ctx.setSelection(next.rowIndex, next.colIndex);
+    ctx.tabRunOrigin = step.tabOrigin;
+    if (!step.withinRange) ctx.setSelection(next.rowIndex, next.colIndex);
     ctx.scrollActiveCellIntoView(next.rowIndex, next.colIndex);
   }
 
+  function commitAndMoveByTab(shiftKey: boolean) {
+    commitAndMove(shiftKey ? "tabPrev" : "tabNext");
+  }
+
+  /**
+   * Ctrl+Enter: the entry goes into every cell of the selected block and the
+   * cursor stays where it is, as in Excel, where it is how a block is filled
+   * with one value in one go. Each cell takes the same raw entry through the
+   * ordinary commit, so its column's parser, the history and
+   * `onCellValueChange` all see it, and the whole block is one undo. A cell
+   * that cannot be edited is left alone. With nothing but the active cell
+   * selected it is a commit that does not move.
+   */
+  function commitToSelection() {
+    const editing = ctx.editingCell;
+    if (!editing) return;
+    const raw = editing.value;
+    const active = ctx.activeCell;
+    const range = ctx.activeRangeRect();
+    runHistoryGroup(ctx, () => {
+      commitEditingCell();
+      if (!active || !range) return;
+      for (let r = range.minRow; r <= range.maxRow; r += 1) {
+        for (let c = range.minCol; c <= range.maxCol; c += 1) {
+          if (r === active.rowIndex && c === active.colIndex) continue;
+          const row = ctx.allRows[r];
+          const column = ctx.allColumns[c];
+          if (!row || !column || isGroupRow(row) || !isCellEditable(column, row)) continue;
+          ctx.editingCell = {
+            rowId: row.id,
+            columnId: column.id,
+            editorType: (column.columnDef.editorType ?? "text") as CellEditorType,
+            value: raw,
+            rowRef: row.original,
+          };
+          commitEditingCell();
+        }
+      }
+    });
+    ctx.gridRootEl?.focus({ preventScroll: true });
+  }
+
   function onEditorKeyDown(event: KeyboardEvent) {
     event.stopPropagation();
-    if (event.key === "Enter") {
+    // Registered commands get the key first here too, with `editing: true`, so
+    // a handler can claim a combination that only means something mid-edit
+    // (Alt+Enter for a newline, F4 to cycle a reference between relative and
+    // absolute) before the editor's own Enter / Tab / Escape handling runs.
+    if (hasGridShortcuts() && runGridShortcuts(event, buildCommandContext(ctx, true))) {
+      return;
+    }
+    if (event.key === "Enter" && event.altKey) {
+      // A line break, in an editor that can hold one (`editorMultiline`).
+      // In a single-line editor Alt+Enter is just Enter.
+      const el = event.currentTarget;
+      if (el instanceof HTMLTextAreaElement) {
+        event.preventDefault();
+        const start = el.selectionStart ?? el.value.length;
+        const end = el.selectionEnd ?? start;
+        el.value = el.value.slice(0, start) + "\n" + el.value.slice(end);
+        el.selectionStart = el.selectionEnd = start + 1;
+        updateEditingCellValue(el.value);
+        el.dispatchEvent(new Event("input", { bubbles: true }));
+        return;
+      }
+    }
+    if (event.key === "Enter" && (event.ctrlKey || event.metaKey)) {
       event.preventDefault();
-      saveEditingCell();
-      ctx.gridRootEl?.focus({ preventScroll: true });
+      commitToSelection();
+    } else if (event.key === "Enter") {
+      event.preventDefault();
+      commitAndMove(event.shiftKey ? "moveUp" : "moveDown");
     } else if (event.key === "Tab") {
       event.preventDefault();
       commitAndMoveByTab(event.shiftKey);
@@ -356,7 +448,7 @@ export function createEditing<
       rowRef: row.original,
     };
     ctx.setActiveCell(rowIndex, colIndex);
-    ctx.setSelection(rowIndex, colIndex);
+    selectForEdit(rowIndex, colIndex);
   }
 
   async function pasteFromClipboard() {
@@ -366,6 +458,28 @@ export function createEditing<
     // On plain HTTP (a XAMPP/Apache LAN host) `navigator.clipboard` is
     // undefined - there the Ctrl+V keydown handler skips preventDefault and
     // lets the browser deliver a native `paste` event to `onGridPaste`.
+    if (ctx.props.onPasteClipboard && navigator.clipboard?.read) {
+      // Both types, for a handler that reads the HTML.
+      try {
+        const items = await navigator.clipboard.read();
+        let text = "";
+        let html: string | null = null;
+        for (const item of items) {
+          if (item.types.includes("text/html")) html = await (await item.getType("text/html")).text();
+          if (item.types.includes("text/plain")) text = await (await item.getType("text/plain")).text();
+        }
+        if (text || html) applyPastedPayload({ text, html, source: "async" });
+      } catch {
+        // No permission or nothing readable: the text-only read below may still work.
+        if (!navigator.clipboard.readText) return;
+        try {
+          applyPastedPayload({ text: await navigator.clipboard.readText(), html: null, source: "async" });
+        } catch {
+          return;
+        }
+      }
+      return;
+    }
     if (!navigator.clipboard?.readText) return;
     let text: string;
     try {
@@ -376,6 +490,26 @@ export function createEditing<
     applyPastedText(text);
   }
 
+  /**
+   * With `onPasteClipboard` set, Ctrl+V leaves the key to the browser so the
+   * `paste` event arrives with the HTML. A browser that does not deliver
+   * that event to the grid root (Firefox, a non-editable element) would
+   * paste nothing, so the async read is armed to run shortly after unless
+   * the event lands first and disarms it.
+   */
+  let pasteFallback: ReturnType<typeof setTimeout> | null = null;
+  function armPasteFallback() {
+    if (pasteFallback) clearTimeout(pasteFallback);
+    pasteFallback = setTimeout(() => {
+      pasteFallback = null;
+      void pasteFromClipboard();
+    }, 80);
+  }
+  function disarmPasteFallback() {
+    if (pasteFallback) clearTimeout(pasteFallback);
+    pasteFallback = null;
+  }
+
   /**
    * Native `paste` ClipboardEvent fallback (insecure-context path). A real
    * Ctrl/Cmd+V on the focused grid root fires this with `clipboardData`
@@ -390,6 +524,17 @@ export function createEditing<
     // preventDefault the editor's paste and write to the data cell instead,
     // so the edit "wouldn't update".
     if (ctx.editingCell) return;
+    if (ctx.props.onPasteClipboard) {
+      // The event is the preferred path for a handler: it carries the HTML
+      // as the source wrote it, needs no permission, and works over HTTP.
+      disarmPasteFallback();
+      const text = event.clipboardData?.getData("text/plain") ?? "";
+      const html = event.clipboardData?.getData("text/html") || null;
+      if (!text && !html) return;
+      event.preventDefault();
+      applyPastedPayload({ text, html, source: "event" });
+      return;
+    }
     // When the async API is available the keydown handler already pasted via
     // pasteFromClipboard(); ignore the (suppressed) native event so we don't
     // paste twice.
@@ -401,6 +546,22 @@ export function createEditing<
   }
 
   function applyPastedText(text: string) {
+    // One history group for the whole paste, so whatever a consumer's
+    // processCellFromClipboard records alongside the values (a format, via
+    // recordUndo) comes back with them on a single Ctrl+Z.
+    runHistoryGroup(ctx, () => applyPastedCells(text));
+  }
+
+  /** A paste with both types: the handler first, the plain text otherwise. */
+  function applyPastedPayload(payload: { text: string; html: string | null; source: "event" | "async" }) {
+    runHistoryGroup(ctx, () => {
+      const handled = ctx.props.onPasteClipboard?.(payload);
+      if (handled === true) return;
+      if (payload.text) applyPastedCells(payload.text);
+    });
+  }
+
+  function applyPastedCells(text: string) {
     const anchor = ctx.selectionRange.anchor ?? ctx.grid.getState().activeCell;
     if (!anchor) return;
     const focus = ctx.selectionRange.focus ?? anchor;
@@ -429,6 +590,15 @@ export function createEditing<
 
     const next = ctx.internalData.slice() as Array<TData>;
     const dataIndexOf = createDataIndexLookup(next);
+    // Every cell the paste changes: one grouped history entry for the lot,
+    // so Ctrl+Z takes the whole paste back, and one onCellValueChange each,
+    // so a consumer keeping its own model behind the grid (a formula engine)
+    // learns the values. The loop used to swap the rows in and stop, which
+    // left the undo stack blind to a paste and the consumer never told.
+    const changed: Array<{
+      row: TData; rowId: string; rowIndex: number; columnId: string; field: string;
+      before: unknown; after: unknown;
+    }> = [];
     for (let i = 0; i < rowSpan; i += 1) {
       const targetRowIndex = startRow + i;
       const row = ctx.allRows[targetRowIndex];
@@ -445,21 +615,67 @@ export function createEditing<
       const updated: Record<string, unknown> = {
         ...(originalRow as Record<string, unknown>),
       };
+      const rowChanges: typeof changed = [];
+      const record = (column: { id: string; columnDef: { field?: string } }, before: unknown, after: unknown) => {
+        if (before === after) return;
+        rowChanges.push({
+          row: updated as TData, rowId: row.id, rowIndex: dataIndex, columnId: column.id,
+          field: column.columnDef.field as string, before, after,
+        });
+      };
       for (let j = 0; j < colSpan; j += 1) {
         const column = ctx.allColumns[startCol + j];
         if (!column?.columnDef.field) continue;
         if (!isCellEditableAt(targetRowIndex, startCol + j)) continue;
+        const before = updated[column.columnDef.field];
         const editorType = (column.columnDef.editorType ??
           "text") as CellEditorType;
         const raw = fillRange ? lines[0]! : sourceCells?.[j] ?? "";
-        updated[column.columnDef.field] = parseEditorValue(editorType, raw, {
+        const parsedValue = parseEditorValue(editorType, raw, {
           dateOnly: column.columnDef.cellDataType === "dateString",
         });
+        // The inbound half of the clipboard pair. A consumer (or a feature
+        // pack doing paste-special) gets the raw text AND what the grid would
+        // have written, and can return either. `undefined` leaves the cell
+        // alone, which is how "paste values only" skips a formula column.
+        const hook = ctx.props.processCellFromClipboard;
+        if (hook) {
+          const decided = hook({
+            text: raw,
+            parsedValue,
+            row: originalRow as TData,
+            rowIndex: targetRowIndex,
+            columnId: column.id as string,
+          });
+          if (decided === undefined) continue;
+          updated[column.columnDef.field] = decided;
+          record(column, before, decided);
+          continue;
+        }
+        updated[column.columnDef.field] = parsedValue;
+        record(column, before, parsedValue);
       }
+      if (!rowChanges.length) continue;
       next[dataIndex] = updated as TData;
+      changed.push(...rowChanges);
     }
+    if (!changed.length) return;
     ctx.internalData = next;
     ctx.grid.store.setState((prev: any) => ({ ...prev }));
+    pushHistory(
+      ctx,
+      changed.map((c) => ({
+        rowId: c.rowId, columnId: c.columnId, field: c.field, before: c.before, after: c.after,
+      })),
+      nextGroupId(),
+    );
+    if (ctx.props.onCellValueChange) {
+      for (const c of changed) {
+        ctx.props.onCellValueChange({
+          rowIndex: c.rowIndex, columnId: c.columnId, oldValue: c.before, newValue: c.after, row: c.row,
+        });
+      }
+    }
   }
 
   /** Programmatically begin editing a cell (mirrors a double-click). */
@@ -563,14 +779,15 @@ export function createEditing<
     }
     // Record the whole-row change as consecutive history steps.
     if (changed.length) {
-      let hist = ctx.history.slice(0, ctx.historyPtr + 1);
-      for (const c of changed) {
-        hist.push({ rowId: fr.rowId, columnId: c.columnId, field: c.field, before: c.before, after: c.after });
-      }
-      if (hist.length > ctx.UNDO_LIMIT) hist = hist.slice(hist.length - ctx.UNDO_LIMIT);
-      ctx.history = hist;
-      ctx.historyPtr = ctx.history.length - 1;
-      ctx.historyVersion += 1;
+      // One full-row commit is ONE undo, not one per changed column.
+      pushHistory(
+        ctx,
+        changed.map((c) => ({
+          rowId: fr.rowId, columnId: c.columnId, field: c.field,
+          before: c.before, after: c.after,
+        })),
+        nextGroupId(),
+      );
     }
     ctx.grid.store.setState((prev: any) => ({ ...prev }));
     if (ctx.props.onCellValueChange && changed.length) {
@@ -614,5 +831,6 @@ export function createEditing<
     onCellDoubleClick,
     pasteFromClipboard,
     onGridPaste,
+    armPasteFallback,
   };
 }

package/src/fill-patterns.test.ts

@@ -8,6 +8,14 @@ describe('buildFillPattern - numeric', () => {
     expect(buildFillPattern([100, 90, 80], 3)).toEqual([70, 60, 50])
   })
 
+  it('continues an uneven run of numbers along its linear trend, as Excel does', () => {
+    // 1, 2, 4: slope 1.5, intercept -2/3, so the next three are 5.33, 6.83, 8.33.
+    const next = buildFillPattern([1, 2, 4], 3) as number[]
+    expect(next.map((v) => Number(v.toFixed(4)))).toEqual([5.3333, 6.8333, 8.3333])
+    expect((buildFillPattern([10, 20, 40], 2) as number[]).map((v) => Number(v.toFixed(4)))).toEqual([53.3333, 68.3333])
+    expect(buildFillPattern([18200, 4200, 1200], 2)).toEqual([-9133.33333333333, -17633.3333333333])
+  })
+
   it('repeats a single numeric value (Excel default)', () => {
     expect(buildFillPattern([42], 4)).toEqual([42, 42, 42, 42])
   })
@@ -87,7 +95,34 @@ describe('buildFillPattern - fallback cycle', () => {
     ])
   })
 
+  it('repeats a single number held as text, the way a numeric one repeats', () => {
+    // A sheet stores what was typed, so 5 arrives as '5'. It is a number,
+    // not 'Item 5' with an empty prefix: one copy, no 6, 7, 8.
+    expect(buildFillPattern(['5'], 3)).toEqual(['5', '5', '5'])
+    expect(buildFillPattern(['Item 5'], 2)).toEqual(['Item 6', 'Item 7'])
+  })
+
   it('repeats a single non-numeric string', () => {
     expect(buildFillPattern(['hello'], 3)).toEqual(['hello', 'hello', 'hello'])
   })
+
+  it('steps an ISO date by a day, and by the gap two dates set', () => {
+    // Used to read 2024-01-15 as the number 2024 with a suffix and fill
+    // 2025-01-15, 2026-01-15.
+    expect(buildFillPattern(['2024-01-15'], 3)).toEqual(['2024-01-16', '2024-01-17', '2024-01-18'])
+    expect(buildFillPattern(['2024-01-01', '2024-01-08'], 2)).toEqual(['2024-01-15', '2024-01-22'])
+    expect(buildFillPattern(['2024-02-28'], 2)).toEqual(['2024-02-29', '2024-03-01'])
+    expect(buildFillPattern(['2024-03-03', '2024-03-02'], 2)).toEqual(['2024-03-01', '2024-02-29'])
+  })
+
+  it('steps Date objects by the day and keeps them Dates', () => {
+    const out = buildFillPattern([new Date(Date.UTC(2024, 0, 31))], 2)
+    expect(out.every((d) => d instanceof Date)).toBe(true)
+    expect((out as Date[]).map((d) => d.toISOString().slice(0, 10))).toEqual(['2024-02-01', '2024-02-02'])
+  })
+
+  it('still counts a prefixed number that happens to hold digits and dashes', () => {
+    expect(buildFillPattern(['Run-001'], 2)).toEqual(['Run-002', 'Run-003'])
+    expect(buildFillPattern(['2024-1-5'], 1)).not.toEqual(['2024-01-06'])
+  })
 })

package/src/fill-patterns.ts

@@ -164,13 +164,54 @@ function arithmeticStep(nums: ReadonlyArray<number>): number | null {
  * `sourceValues` already in the selection. See module header for the
  * pattern-detection rules.
  */
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/
+
+/**
+ * The sources as day stamps when every one is a date: `Date` objects, or
+ * `YYYY-MM-DD` text (read as UTC so a fill never crosses a day boundary
+ * with the time zone). Anything else means "not a date series".
+ */
+function datesOf(values: ReadonlyArray<unknown>): { stamps: number[]; iso: boolean } | null {
+  if (values.every((v) => v instanceof Date && Number.isFinite(v.getTime()))) {
+    return { stamps: values.map((v) => (v as Date).getTime()), iso: false }
+  }
+  if (values.every((v) => typeof v === 'string' && ISO_DATE.test(v))) {
+    const stamps = values.map((v) => Date.parse(`${v}T00:00:00Z`))
+    return stamps.every((t) => Number.isFinite(t)) ? { stamps, iso: true } : null
+  }
+  return null
+}
+
 export function buildFillPattern(
   sourceValues: ReadonlyArray<unknown>,
   targetCount: number,
 ): unknown[] {
   if (sourceValues.length === 0 || targetCount <= 0) return []
 
-  // -------- 1) Numeric arithmetic progression (2+ values) -----------
+  // -------- 0) Dates step by the day ---------------------------------
+  // Before the numeric rule, since a Date coerces to a finite number of
+  // milliseconds, and before the prefix rule, which read 2024-01-15 as the
+  // number 2024 with a suffix and filled 2025-01-15. Two dates set the step
+  // (a week apart fills weekly); one date steps by a day, as Excel's does.
+  const dates = datesOf(sourceValues)
+  if (dates) {
+    const DAY = 86_400_000
+    const days = dates.stamps.map((t) => Math.round(t / DAY))
+    const step = days.length >= 2 ? arithmeticStep(days) : 1
+    if (step !== null) {
+      const last = days[days.length - 1]!
+      return Array.from({ length: targetCount }, (_, i) => {
+        const stamp = (last + step * (i + 1)) * DAY
+        return dates.iso ? new Date(stamp).toISOString().slice(0, 10) : new Date(stamp)
+      })
+    }
+  }
+
+  // -------- 1) Numbers: the linear trend (2+ values) -----------------
+  // Excel's AutoFill of two or more numbers continues their least-squares
+  // line: 1, 2, 3 goes on 4, 5, 6, and 1, 2, 4 goes on 5.33, 6.83, ...
+  // rather than repeating. An even step is the same line, so the common
+  // case is unchanged.
   const nums = sourceValues.map((v) => Number(v))
   const allNumericLike =
     sourceValues.every((v) => v !== null && v !== '' && v !== undefined) &&
@@ -181,6 +222,17 @@ export function buildFillPattern(
       const last = nums[nums.length - 1]!
       return Array.from({ length: targetCount }, (_, i) => last + step * (i + 1))
     }
+    const n = nums.length
+    const meanX = (n - 1) / 2
+    const meanY = nums.reduce((a, b) => a + b, 0) / n
+    let sxy = 0
+    let sxx = 0
+    for (let i = 0; i < n; i += 1) { sxy += (i - meanX) * (nums[i]! - meanY); sxx += (i - meanX) ** 2 }
+    const slope = sxx === 0 ? 0 : sxy / sxx
+    const intercept = meanY - slope * meanX
+    // Rounded to the precision floating point gives 5.333333333333333, so
+    // 10, 20, 40 fills 50, 60 and not 50.00000000000001.
+    return Array.from({ length: targetCount }, (_, i) => Number((intercept + slope * (n + i)).toPrecision(15)))
   }
 
   // -------- 2) Known string sequence (days / months / quarters) -----
@@ -200,7 +252,9 @@ export function buildFillPattern(
   if (allStrings && sourceValues.length >= 1) {
     const stringSources = sourceValues as string[]
     const split = findPrefixNumberSuffix(stringSources)
-    if (split) {
+    // A bare number as text ('5') is a number, not 'Item 5': one of them
+    // copies, as a numeric 5 does, and two or more were a progression above.
+    if (split && (split.prefix !== '' || split.suffix !== '')) {
       const step = split.numbers.length >= 2
         ? arithmeticStep(split.numbers) ?? 1
         : 1

package/src/grid-messages.ts

@@ -7,11 +7,24 @@
  *
  * This mirrors the editor kit's `resolveMessages` pattern (editor-contract.ts) so
  * chrome and editors share one localization idiom.
+ *
+ * The chart panel's strings are the other half of `GridMessages`
+ * (`GridChartPanelMessages` in chart-panel-messages.ts): same map, same
+ * `localization.text`, but their English defaults load with the panel, not
+ * with every grid.
  */
 import { resolveMessages } from './editor-contract'
+import type { GridChartPanelMessages } from './chart-panel-messages'
+
+/**
+ * Every string `localization.text` accepts: the grid chrome's own
+ * ({@link GridChromeMessages}) and the chart panel's
+ * ({@link GridChartPanelMessages}).
+ */
+export type GridMessages = GridChromeMessages & GridChartPanelMessages
 
 /** Every localizable chrome string, grouped by area in the comments. */
-export type GridMessages = {
+export type GridChromeMessages = {
   // Empty / loading state
   noRows: string
   loading: string
@@ -102,7 +115,7 @@ export type GridMessages = {
 }
 
 /** English defaults - the literal strings the grid shipped before localization. */
-export const defaultGridMessages: GridMessages = {
+export const defaultGridMessages: GridChromeMessages = {
   noRows: 'No rows to display.',
   loading: 'Loading grid data...',
   columns: 'Columns',
@@ -184,6 +197,6 @@ export const defaultGridMessages: GridMessages = {
  * values fall back to the default (via `resolveMessages`), so a partial map only
  * replaces the keys it sets.
  */
-export function resolveGridMessages(overrides?: Partial<GridMessages> | null): GridMessages {
+export function resolveGridMessages(overrides?: Partial<GridMessages> | null): GridChromeMessages {
   return resolveMessages(defaultGridMessages, overrides)
 }