@svgrid/enterprise 3.0.2 → 3.0.3

package/LICENSE

@@ -1,5 +1,5 @@
 SVGRID ENTERPRISE COMMERCIAL LICENSE
-Version 1.0
+Version 1.1
 
 Copyright (c) 2011-2026 jQWidgets Ltd.
 Author contact: Boyko Markov <boikom@jqwidgets.com>
@@ -13,7 +13,7 @@ This file is a summary of the commercial terms. The full, authoritative
 agreement is the SvGrid End User License Agreement (EULA). In case of any
 conflict, the EULA governs.
 
-  EULA: https://svgrid.com/eula  (also docs/legal/EULA.md in the repo)
+  EULA: https://svgrid.com/docs/legal/EULA/  (also docs/legal/EULA.md in the repo)
 
 ------------------------------------------------------------------------
 1. GRANT (with valid license key)
@@ -30,23 +30,80 @@ non-exclusive, non-transferable, non-sublicensable license to:
       that all copyright notices and license terms are preserved;
   (c) distribute the Software bundled inside the Subscriber's own
       application, provided the Software is not the primary product
-      distributed and remains under this License.
+      distributed, that it remains under this License, and that the
+      distribution is not one of the cases in Section 1A.
 
-Deployment scope is set by the Subscriber's order:
+License scope is set by the Subscriber's order:
 
-  - Single Application Developer License: one (1) deployed production
-    application, plus unlimited internal dev / staging environments.
-  - Multiple Application Developer License: unlimited deployed
-    production applications within the Subscriber's organization.
+  - Grid Developer License: the Software excluding the Spreadsheet
+    Module and the Studio, on unlimited deployed production
+    applications within the Subscriber's organization, plus unlimited
+    internal dev / staging environments.
+  - Suite Developer License: the Software in full, including the
+    Spreadsheet Module and the Studio, on the same unlimited scope.
   - Enterprise / Custom (Site or Org-wide): scope per the negotiated
     order or master agreement.
+  - OEM License: the redistribution cases in Section 1A.
+
+The "Spreadsheet Module" is the workbook, formula engine and
+spreadsheet file-format features: <SvSheet>, the <sv-sheet> element,
+the formula evaluator, and the .xlsx / .xls / .ods / .csv readers and
+writers. The "Studio" is the designer, the code generator and the SQL
+data sources.
+
+Using the Spreadsheet Module or the Studio under a Grid Developer
+License is outside the licensed scope. The Software does not block it:
+the feature runs, and the watermark and the console notice described in
+Section 4 show until the license is upgraded to Suite.
+
+------------------------------------------------------------------------
+1A. OEM AND REDISTRIBUTION
+------------------------------------------------------------------------
+
+Section 1(c) covers the ordinary case, in which the Subscriber ships
+its own application and the Software is one component inside it. An OEM
+License, negotiated separately with the Author, is required where:
+
+  (a) the Subscriber distributes the Software, or any part of it, to
+      third parties as a component, library, SDK, template, or building
+      block those third parties use to build their own applications;
+  (b) the Subscriber's product is a platform, application builder,
+      low-code or no-code tool, or development environment in which the
+      Subscriber's own customers author applications, reports, or
+      workbooks that render through the Software;
+  (c) the Subscriber sublicenses, resells, or white-labels the Software
+      under another name;
+  (d) the Subscriber deploys the Software in a multi-tenant hosted
+      product in which the Spreadsheet Module or the Studio is a
+      material part of what the Subscriber's customers pay for.
+
+An OEM License is priced separately from developer seats, is granted
+for a defined term and a defined product, and may carry a
+redistribution volume or royalty basis recorded in the order. Developer
+seats do not convey these rights, however many are purchased.
+
+For the avoidance of doubt, ordinary business software sold to
+customers is covered by Section 1(c). A SaaS application whose users
+view, edit and export their own data in a grid or a workbook is the
+Subscriber's own application, not redistribution. The test is whether
+third parties receive the Software as something they build with, not
+whether the Subscriber charges for its product.
+
+The evaluation in Section 4 does not pass through an OEM product to its
+users: a product that needs an OEM License may not rely on the
+unlicensed state, an evaluation key or a development key for what it
+delivers to third parties, and only the key an OEM License names may be
+embedded in it.
+
+Requests: sales@jqwidgets.com.
 
 ------------------------------------------------------------------------
 2. SEATS
 ------------------------------------------------------------------------
 
-The Software is licensed per developer. The number of seats is set by
-the Subscriber's order. A "developer" is any individual who writes or
+The Software is licensed per developer. The number of seats and the
+edition, Grid or Suite, are set by the Subscriber's order. All seats on
+one order share one edition. A "developer" is any individual who writes or
 modifies source code that imports `@svgrid/enterprise`. Read-only users
 and end users do not count toward seats and are unlimited. One license
 key activates every grid instance in scope; there is no per-page or
@@ -73,23 +130,32 @@ The Author will not disable working features of a paying or previously
 paying Subscriber.
 
 ------------------------------------------------------------------------
-4. EVALUATION, SOFT-GATE, AND OPEN SOURCE
+4. EVALUATION AND OPEN SOURCE
 ------------------------------------------------------------------------
 
-The Software is soft-gated. Every feature is fully functional without a
-license key for evaluation. While unlicensed, the grid shows a small
-"Unlicensed @svgrid/enterprise" watermark and emits a one-time console
-notice; setting a valid key removes both. There is no time limit and no
-disabled functionality during evaluation. Time-limited evaluation keys
-that remove the watermark are available on request.
+The Author grants a 30-day evaluation period. During it every feature,
+the Spreadsheet Module and the Studio included, may be used without a
+license key to decide whether to buy, on workstations and in internal
+development, staging and demonstration environments; production use
+needs a license key. Without a key the grid and the spreadsheet show a
+small watermark and the Software emits a console notice about the
+Enterprise package; nothing is disabled and nothing stops after the 30
+days, the watermark and the notice stay until a key is set. On request
+the Author issues an evaluation key with a 30-day expiry that removes
+both for staging and demonstration deployments; when it expires the
+Software keeps running, the watermark returns and a console notice names
+the date. Evaluation and development keys are not for production and
+must not be shared or embedded in a product distributed to third
+parties.
 
 Projects that are open source under an OSI-approved license, hosted in a
 public repository, and not a paid product qualify for a free Enterprise
 key with the full feature set and no watermark, renewable annually.
 
-License key validation is performed entirely client-side, signed against
-the Author's public key. No network call is made to validate, and no
-telemetry is sent. Air-gapped deployments are supported.
+License key validation is performed entirely client-side and is not a
+cryptographic check: the Software classifies the key string and nothing
+more. No network call is made to validate, and no telemetry is sent.
+Air-gapped deployments are supported.
 
 ------------------------------------------------------------------------
 5. RESTRICTIONS
@@ -102,16 +168,20 @@ The Subscriber may NOT:
   (b) sublicense, rent, lease, or sell the Software to third parties;
   (c) remove, obscure, or disable the license-key check or any
       copyright or proprietary notices;
-  (d) use the Software to develop a data-grid or table component product
-      that competes with the Software for distribution to third parties;
+  (d) use the Software to develop a data-grid, table, or spreadsheet
+      component product that competes with the Software for
+      distribution to third parties;
   (e) share license keys outside of the developer seats covered by the
-      Subscriber's order.
+      Subscriber's order;
+  (f) ship to production a use of the Spreadsheet Module or the Studio
+      that the Subscriber's edition does not cover, or a
+      redistribution described in Section 1A without an OEM License.
 
 ------------------------------------------------------------------------
 6. TERMINATION
 ------------------------------------------------------------------------
 
-On material breach of Sections 1, 2, or 5, the license terminates
+On material breach of Sections 1, 1A, 2, or 5, the license terminates
 automatically and the Subscriber must cease all use of the Software,
 remove it from development environments, and stop deploying new versions
 of any application that depends on it. Existing deployed copies in

package/README.md

@@ -24,14 +24,18 @@
 
 ## What it adds
 
+- **Server-Side Row Model** - `createServerRowModel` over the free datasource contract: lazy grouping and tree data one level at a time with a block cache per level, aggregates, child counts and grand totals, server-side pivot with the designer in server mode, transactions on loaded rows, paging over the tree, and a selection kept as a rule so select-all reaches rows the grid never loaded, with a bulk edit by rule. Flat paging and infinite scroll stay free in `@svgrid/grid`.
 - **Data export** - Excel (`.xlsx`), PDF, styled HTML and XML, with theme-matched styling, headers/footers, and image support. CSV, TSV and JSON export (and copy-to-clipboard) are free in `@svgrid/grid`; Enterprise adds the paid formats and a single `exportGrid()` entry point over all of them.
 - **Data import** - read Excel / CSV / TSV / JSON into typed rows with column auto-mapping, type inference, and per-row validation, plus a ready-made `SvImportDialog`.
 - **Paginated print** - opens a clean, paginated, printable view of the grid with title and page breaks.
 - **Pivot tables** - drag-and-drop pivot Designer with row/column/value fields, aggregation, drill-through to source rows, and pivot-to-chart.
+- **Kanban board view** - `enableBoardView()` lets `<SvGrid board={...}>` render the rows as cards in lanes, with drag-and-drop, swimlanes, WIP limits and a card drawer.
 - **Scheduler / calendar view** - a Month/Week/Day/Agenda calendar rendered as a view of the grid: `enableSchedulerView()` lets `<SvGrid scheduler={...}>` show events with resources, recurrence, and drag/resize.
 - **Staged editing** - collect edits into a reviewable change set before committing.
 - **Scheduling automation** - a client-side cron / one-off scheduler (`createScheduler`, `parseCron`, `CRON_PRESETS`) to drive recurring exports and alerts with no backend.
-- **SvGrid Studio** - a schema-driven data-app layer: `EntitySchema`, memory / SQL / Supabase / REST data sources, a SvelteKit adapter, edit panels, master/detail, schema charts + KPI dashboards, and the project model + codegen behind the visual designer. See [`@svgrid/studio`](https://www.npmjs.com/package/@svgrid/studio).
+- **Spreadsheet** (Suite) - `<SvSheet>` and the `<sv-sheet>` custom element over a built-in formula engine: around 185 functions, cross-sheet references, named ranges, absolute and relative refs, dynamic arrays with spill, iterative calculation with convergence, circular-reference detection, volatile-function tracking, and dependency-graph recalculation. In-house, with no runtime dependency.
+- **Spreadsheet file formats** (Suite) - read and write `.xlsx`, `.xls` (BIFF8) and `.ods`, plus `.csv`. Formulas, tables, named ranges, merges, frozen panes, sparklines, charts and images survive an `.xlsx` round trip. Pivot tables round-trip as their computed cells, not as live PivotTable parts, and `.xls` keeps the BIFF8 row and column ceilings.
+- **SvGrid Studio** (Suite) - a schema-driven data-app layer: `EntitySchema`, memory / SQL / Supabase / REST data sources, a SvelteKit adapter, edit panels, master/detail, schema charts + KPI dashboards, and the project model + codegen behind the visual designer. See [`@svgrid/studio`](https://www.npmjs.com/package/@svgrid/studio).
 
 ## Install
 
@@ -76,13 +80,41 @@ built in and free in [`@svgrid/grid`](https://www.npmjs.com/package/@svgrid/grid
 Installing Enterprise only adds the Excel/PDF export engine that
 AI-planned exports write through.
 
-`installEnterprise` returns the same grid API with the enterprise methods (`exportData`, `copyExport`, `print`, `importData`, `pivot.*`) added on top, so the rest of your integration is unchanged. It also registers the Kanban board and scheduler / calendar views, so `<SvGrid board={...}>` and `<SvGrid scheduler={...}>` render.
+`installEnterprise` returns the same grid API with the enterprise methods (`exportData`, `copyExport`, `print`, `importData`, `pivot.*`) added on top, so the rest of your integration is unchanged. It also registers the Kanban board, scheduler / calendar and Gantt views, so `<SvGrid board={...}>`, `<SvGrid scheduler={...}>` and `<SvGrid gantt={...}>` render.
 
 ## Licensing
 
-Commercial. A valid Enterprise key is required at runtime; calls throw without one. Purchase a key at [svgrid.com/pricing](https://svgrid.com/pricing/).
+Commercial, in two editions, both covering unlimited production apps:
 
-OSS projects under an [OSI-approved license](https://opensource.org/licenses) qualify for a **free Enterprise key**.
+| Edition   | Covers                                                            |
+| --------- | ----------------------------------------------------------------- |
+| **Grid**  | Everything above except the spreadsheet, the file formats and Studio |
+| **Suite** | All of it                                                         |
+
+Purchase a key at [svgrid.com/pricing](https://svgrid.com/pricing/).
+
+**The gate is soft.** Every feature runs without a key, and under a key whose edition does not cover
+it. You get a small watermark on the grid and a one-time console notice; nothing throws and nothing
+is disabled, so you can evaluate any of this in your own app before buying. A key is only rejected
+when it is malformed or revoked.
+
+```ts
+import { setLicenseKey, licenseCovers } from '@svgrid/enterprise'
+
+setLicenseKey(import.meta.env.VITE_SVPRO_KEY)
+licenseCovers('spreadsheet') // false on a Grid key, true on Suite
+```
+
+Keys carry their edition: `SVENTERPRISE-GRID-...` or `SVENTERPRISE-SUITE-...`. A key issued before
+editions existed carries neither and reads as Suite, so nothing you already ship changes.
+
+**OEM and redistribution.** A developer seat covers your own application, including a SaaS product
+your customers pay for. It does not cover shipping this package to third parties as a component, an
+SDK, or an app builder they build with. That needs an OEM license, priced separately from seats.
+Section 4A of the [EULA](https://github.com/sv-grid/sv-grid/blob/main/docs/legal/EULA.md) has the
+exact test; `sales@jqwidgets.com` will tell you which side you are on.
+
+OSS projects under an [OSI-approved license](https://opensource.org/licenses) qualify for a **free Suite key**.
 
 The source in this package is published for evaluation and for paying customers; visibility does not grant a license. See [LICENSE](./LICENSE).
 

package/dist/SvAdvancedFilter.svelte

@@ -72,7 +72,7 @@
     (untrack(() => api.getAdvancedFilter()) as PredicateExpr | null) ?? null,
   )
   /** What the editor is editing. Not pushed until Apply. */
-  let draft = $state<PredicateExpr>(applied ?? EMPTY)
+  let draft = $state<PredicateExpr>(untrack(() => applied ?? EMPTY))
 
   const isDirty = $derived(JSON.stringify(draft) !== JSON.stringify(applied ?? EMPTY))
   const canClear = $derived(applied != null)

package/dist/SvAlertsManager.svelte

@@ -5,6 +5,7 @@
    * Operates through an AlertRulesManager (persistence) and emits the updated
    * list so the running engine can re-sync.
    */
+  import { untrack } from 'svelte'
   import { SvModal, SvSwitchButton, toast } from '@svgrid/grid'
   import SvAlertRuleEditor from './SvAlertRuleEditor.svelte'
   import { stringifyPredicate } from './expressions/parse'
@@ -23,7 +24,7 @@
 
   let { open = $bindable(false), manager, columns, rows = [], onChange, onClose }: Props = $props()
 
-  let rules = $state<AlertRule[]>(manager.list())
+  let rules = $state<AlertRule[]>(untrack(() => manager.list()))
   let editing = $state<AlertRule | null>(null)
   let editorOpen = $state(false)
   let fileInput = $state<HTMLInputElement | null>(null)

package/dist/SvBoard.svelte

@@ -116,7 +116,8 @@
       </header>
       <div class="sv-board__cards">
         {#each cards as r (String(r[idField]))}
-          <!-- svelte-ignore a11y_no_static_element_interactions a11y_no_noninteractive_tabindex -->
+          <!-- svelte-ignore a11y_no_noninteractive_tabindex -->
+          <!-- svelte-ignore a11y_no_static_element_interactions -->
           <article
             class="sv-board__card"
             class:is-dragging={dragId === String(r[idField])}

package/dist/SvExportMenu.svelte

@@ -12,6 +12,8 @@
    *
    * Minimal, unopinionated styling via a few overridable classes / CSS vars.
    */
+  import { untrack } from 'svelte'
+
   import type { RowData, TableFeatures } from '@svgrid/grid'
   import type { ConditionalFormat } from '@svgrid/grid/format'
   import type { EnterpriseGridApi } from './install'
@@ -77,7 +79,7 @@
   ]
 
   let open = $state(false)
-  let currentScope = $state<Extract<ExportRowSource<TData>, string>>(scope)
+  let currentScope = $state<Extract<ExportRowSource<TData>, string>>(untrack(() => scope))
   let busy = $state(false)
   let progress = $state(0)
   let error = $state<string | null>(null)
@@ -265,6 +267,7 @@
     <div
       class="sv-export-menu"
       role="menu"
+      tabindex="-1"
       aria-label="Export options"
       bind:this={menuEl}
       onkeydown={onMenuKeydown}

package/dist/SvExportMenu.svelte.d.ts

@@ -1,16 +1,3 @@
-/**
-   * SvExportMenu - a drop-in export button + menu for a licensed grid. Wraps
-   * `api.exportData` / `api.copyExport` / `api.print` so consumers don't
-   * hand-roll a toolbar in every app:
-   *   - a sectioned format picker with per-format icons + descriptions,
-   *   - a row-scope toggle (current view / selected / all rows),
-   *   - a per-column include picker,
-   *   - copy-to-clipboard + optional print actions,
-   *   - a progress bar + Cancel for large exports (via AbortController),
-   *   - inline error surface when a peer dep is missing or the grid is empty.
-   *
-   * Minimal, unopinionated styling via a few overridable classes / CSS vars.
-   */
 import type { RowData, TableFeatures } from '@svgrid/grid';
 import type { ConditionalFormat } from '@svgrid/grid/format';
 import type { EnterpriseGridApi } from './install.js';

package/dist/SvExpressionEditor.svelte

@@ -60,13 +60,13 @@
   // The conversion itself lives in expressions/builder-tree.ts, so the round
   // trip can be tested without mounting this component.
 
-  const initial = toBuilderTree(value, columns)
-  let root = $state<BuilderGroup>(initial ?? freshGroup(columns))
+  const initial = untrack(() => toBuilderTree(value, columns))
+  let root = $state<BuilderGroup>(initial ?? untrack(() => freshGroup(columns)))
   // If the incoming value cannot be shown as a tree, start in text mode so
   // nothing is lost.
   if (!initial && mode === 'builder') mode = 'text'
 
-  let text = $state(stringifyPredicate(value, columns))
+  let text = $state(untrack(() => stringifyPredicate(value, columns)))
   let textError = $state<string | null>(null)
 
   /**

package/dist/SvFormulaBar.svelte

@@ -11,6 +11,7 @@
    * through props and reports edits through `onCommit`, so it works over a
    * `<SvGrid>`, a plain array, or a workbook with several sheets.
    */
+  import { useSheetText } from './sheet-text'
   import {
     suggestFunctions,
     applySuggestion,
@@ -45,6 +46,13 @@
      */
     label?: string | null
     onSelectName?: (name: string) => void
+    /** A name typed that is neither an address nor a name yet: Excel defines
+     *  it for the selection. Without a handler the entry is dropped. */
+    onDefineName?: (name: string) => void
+    /** A range or a sheet-qualified address typed into the Name Box, B2:D4 or
+     *  Orders!C3: the consumer selects it and answers true, or false when the
+     *  text is not a reference, which the bar then defines as a name. */
+    onSelectReference?: (text: string) => boolean
     /** The fx button: Excel's Insert Function. Without a handler the button
      *  is not drawn, since a button that does nothing is worse than none. */
     onInsertFunction?: () => void
@@ -72,6 +80,8 @@
     names = [],
     label = null,
     onSelectName,
+    onDefineName,
+    onSelectReference,
     onInsertFunction,
     onDraft,
     highlight,
@@ -79,6 +89,7 @@
     autocomplete = true,
     disabled = false,
   }: Props = $props()
+  const t = useSheetText()
 
   let draft = $state('')
   let editing = $state(false)
@@ -118,8 +129,36 @@
    */
   let expanded = $state(false)
   const lines = $derived(draft.split('\n').length)
-  const rows = $derived(expanded ? Math.min(6, Math.max(2, lines)) : 1)
+  /**
+   * The lines the draft takes at the bar's width once it wraps, which is
+   * what the expanded bar is for: a long formula is one line of text and
+   * six lines on screen, and counting its line breaks gave it two rows with
+   * the rest cut off under `overflow: hidden`, so the chevron showed an
+   * empty second row and nothing more. Measured from the textarea at one
+   * row, where its scroll height is the text's rather than the box's.
+   */
+  let wrapped = $state(1)
+  /** The scrollbar's width once the bar scrolls, so the mirror wraps where the text does. */
+  let gutter = $state(0)
+  let mirror = $state<HTMLDivElement | null>(null)
+  $effect(() => {
+    void draft
+    if (!expanded || !input) { wrapped = 1; gutter = 0; return }
+    const el = input
+    const style = getComputedStyle(el)
+    const line = parseFloat(style.lineHeight) || 18
+    const pad = (parseFloat(style.paddingTop) || 0) + (parseFloat(style.paddingBottom) || 0)
+    const was = el.rows
+    el.rows = 1
+    wrapped = Math.max(1, Math.round((el.scrollHeight - pad) / line))
+    el.rows = was
+    // Read after the rows settle: the gutter is there only past six lines.
+    requestAnimationFrame(() => { gutter = el.offsetWidth - el.clientWidth })
+  })
+  const rows = $derived(expanded ? Math.min(6, Math.max(2, lines, wrapped)) : 1)
   let nameBoxText = $state('')
+  /** True while the Name Box has focus, which is when it shows a draft. */
+  let nameBoxTyping = $state(false)
 
   // Follow the active cell while the user is not mid-edit. Clobbering the
   // draft on every selection change would throw away half-typed formulas.
@@ -245,14 +284,26 @@
       nameBoxText = ''
       return
     }
-    if (names.some((n) => n.name.toUpperCase() === nameBoxText.trim().toUpperCase())) {
-      onSelectName?.(nameBoxText.trim())
+    const typed = nameBoxText.trim()
+    if (names.some((n) => n.name.toUpperCase() === typed.toUpperCase())) {
+      onSelectName?.(typed)
+      nameBoxText = ''
+      return
+    }
+    // A range, or an address on another sheet, is a place to go.
+    if (typed && onSelectReference?.(typed)) {
+      nameBoxText = ''
+      return
+    }
+    // Neither an address nor a name: Excel defines it for the selection.
+    if (typed) {
+      onDefineName?.(typed)
       nameBoxText = ''
     }
   }
 </script>
 
-<div class="sv-formula-bar" role="group" aria-label="Formula bar">
+<div class="sv-formula-bar" role="group" aria-label={t('formulaBar')}>
   {#if showNameBox}
     <!--
       Excel's Name Box: one field that takes an address and, behind its arrow,
@@ -263,13 +314,23 @@
     <div class="name-box">
       <input
         type="text"
-        aria-label="Name box"
+        aria-label={t('nameBox')}
         placeholder={label ?? address}
-        value={nameBoxText}
+        value={nameBoxTyping ? nameBoxText : (label ?? address)}
         {disabled}
         oninput={(e) => (nameBoxText = e.currentTarget.value)}
         onkeydown={onNameBoxKey}
-        onblur={() => (nameBoxText = '')}
+        onfocus={(e) => {
+          // The address is the field's VALUE, not a placeholder: a placeholder
+          // is a hint, so a screen reader on the Name Box would say "blank"
+          // where Excel says B3. It is selected on focus, so typing over it
+          // still replaces it in one go.
+          nameBoxTyping = true
+          nameBoxText = label ?? address
+          const el = e.currentTarget
+          queueMicrotask(() => el.select())
+        }}
+        onblur={() => { nameBoxTyping = false; nameBoxText = '' }}
       />
       <span class="caret" class:idle={names.length === 0} aria-hidden="true">
         <svg viewBox="0 0 10 10" width="10" height="10"><path d="M2 3.5l3 3 3-3" fill="none" stroke="currentColor" stroke-width="1.3" stroke-linecap="round" stroke-linejoin="round" /></svg>
@@ -277,7 +338,7 @@
       {#if names.length > 0}
         <select
           class="names"
-          aria-label="Defined names"
+          aria-label={t('definedNames')}
           {disabled}
           onchange={(e) => {
             const picked = e.currentTarget.value
@@ -285,7 +346,7 @@
             e.currentTarget.selectedIndex = 0
           }}
         >
-          <option value="">Names</option>
+          <option value="">{t('namesHeading')}</option>
           {#each names as entry (entry.name)}
             <option value={entry.name}>{entry.name}</option>
           {/each}
@@ -299,8 +360,8 @@
     <button
       type="button"
       class="action"
-      title="Cancel"
-      aria-label="Cancel"
+      title={t('formulaBarCancel')}
+      aria-label={t('formulaBarCancel')}
       disabled={!editing}
       onmousedown={(e) => e.preventDefault()}
       onclick={cancel}
@@ -308,8 +369,8 @@
     <button
       type="button"
       class="action"
-      title="Enter"
-      aria-label="Enter"
+      title={t('formulaBarEnter')}
+      aria-label={t('formulaBarEnter')}
       disabled={!editing}
       onmousedown={(e) => e.preventDefault()}
       onclick={() => commit()}
@@ -318,8 +379,8 @@
       <button
         type="button"
         class="action fx"
-        title="Insert Function (Shift+F3)"
-        aria-label="Insert Function"
+        title={`${t('insertFunction')} (Shift+F3)`}
+        aria-label={t('insertFunction')}
         {disabled}
         onclick={() => onInsertFunction?.()}
       >fx</button>
@@ -333,15 +394,18 @@
          typed with Alt+Enter holds, and would commit "twolines" for a cell
          showing two lines. One row until there are breaks to show. -->
     {#if runs.length > 0}
-      <div class="formula mirror" aria-hidden="true">{#each runs as run, i (i)}{#if run.colour}<span style:color={run.colour}>{run.text}</span>{:else}{run.text}{/if}{/each}</div>
+      <div class="formula mirror" class:line={!expanded} bind:this={mirror} style:padding-right={gutter ? `${6 + gutter}px` : undefined} aria-hidden="true">{#each runs as run, i (i)}{#if run.colour}<span style:color={run.colour}>{run.text}</span>{:else}{run.text}{/if}{/each}</div>
     {/if}
     <textarea
       bind:this={input}
       class="formula"
       class:coloured={runs.length > 0}
-      aria-label="Formula"
+      class:tall={expanded}
+      class:line={!expanded}
+      aria-label={t('formula')}
       autocomplete="off"
       spellcheck="false"
+      wrap={expanded ? 'soft' : 'off'}
       {rows}
       value={draft}
       disabled={disabled || active === null}
@@ -354,6 +418,7 @@
       }}
       onkeyup={syncCaret}
       onclick={syncCaret}
+      onscroll={(e) => { if (mirror) { mirror.scrollTop = e.currentTarget.scrollTop; mirror.scrollLeft = e.currentTarget.scrollLeft } }}
       onfocus={startEditing}
       onblur={() => { if (editing) commit('blur') }}
       onkeydown={onKeyDown}
@@ -362,8 +427,8 @@
       type="button"
       class="expand"
       class:on={expanded}
-      title={expanded ? 'Collapse the formula bar' : 'Expand the formula bar'}
-      aria-label={expanded ? 'Collapse the formula bar' : 'Expand the formula bar'}
+      title={expanded ? t('collapseFormulaBar') : t('expandFormulaBar')}
+      aria-label={expanded ? t('collapseFormulaBar') : t('expandFormulaBar')}
       aria-expanded={expanded}
       onclick={() => (expanded = !expanded)}
     ><svg viewBox="0 0 12 12" width="10" height="10" aria-hidden="true"><path d="M2 4l4 4 4-4" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" /></svg></button>
@@ -373,7 +438,7 @@
     {/if}
 
     {#if suggestions.length > 0}
-      <ul class="suggestions" role="listbox" aria-label="Function suggestions">
+      <ul class="suggestions" role="listbox" aria-label={t('functionSuggestions')}>
         {#each suggestions as suggestion, i (suggestion.name)}
           <li role="option" aria-selected={i === highlighted}>
             <button
@@ -522,6 +587,15 @@
     overflow: hidden;
     white-space: pre-wrap;
   }
+  /* Expanded, the bar shows up to six lines and scrolls past them, as
+     Excel's does; the mirror follows the scroll from the textarea's
+     onscroll. Collapsed, it stays one line with no scrollbar of its own. */
+  .formula.tall { overflow-y: auto; }
+  /* Collapsed, the line does not wrap: Excel's one-line bar is cut off at
+     the right and scrolls sideways with the caret, rather than folding a
+     long entry onto a second row that the one-row box then hides. The
+     mirror follows the scroll the same way. */
+  .formula.line { white-space: pre; overflow-x: hidden; }
   .formula:focus-visible {
     outline: 2px solid var(--sg-focus-ring, var(--sg-accent, #107c41));
     outline-offset: -2px;

package/dist/SvFormulaBar.svelte.d.ts

@@ -35,6 +35,13 @@ type Props = {
      */
     label?: string | null;
     onSelectName?: (name: string) => void;
+    /** A name typed that is neither an address nor a name yet: Excel defines
+     *  it for the selection. Without a handler the entry is dropped. */
+    onDefineName?: (name: string) => void;
+    /** A range or a sheet-qualified address typed into the Name Box, B2:D4 or
+     *  Orders!C3: the consumer selects it and answers true, or false when the
+     *  text is not a reference, which the bar then defines as a name. */
+    onSelectReference?: (text: string) => boolean;
     /** The fx button: Excel's Insert Function. Without a handler the button
      *  is not drawn, since a button that does nothing is worse than none. */
     onInsertFunction?: () => void;