Hacktoberfest 2026: le issue che i maintainer hanno segnato per ottobre, aperte e adatte ai principianti. Sfoglia le issue Hacktoberfest

[Bug]: Array formula spill cells serialize as literal values, so rebuildAndRecalculate() produces #SPILL!

Aperta Adatta ai principianti
  • Qualcosa non va?
#1,745 0 commenti 0 reazioni 0 assegnatari Vedi su GitHub

I maintainer di solito rispondono entro 1 giorno

Nessuno ha ancora preso questa issue.

Valutazione

Difficoltà
2/5
Tempo stimato
1-3 ore
Idoneità per principianti
84/100
Tipo di issue
Bug
Chiarezza
Specificata chiaramente
Stato di attività
Tranquilla
Stack tecnologico
typescript
Ambito
backend

Direzione di ricerca

Inizia in src/Serialization.ts, in particolare con getCellSerialized() e getCellFormula(), quindi esegui la riproduzione autonoma Node dell’issue. Verifica che le celle di spill dell’array che non sono celle di ancoraggio vengano serializzate senza i relativi valori calcolati e che getSheetSerialized() e rebuildAndRecalculate() preservino il risultato della formula dell’array senza produrre #SPILL!.

Scritto dal modello di indicizzazione a partire dal testo della issue.

Descrizione

Bug
Description

A cell holding an array formula such as ={1,2} calculates correctly and spills across A1 and B1. Calling rebuildAndRecalculate() turns it into #SPILL!.

The cause is in serialization, not in the rebuild itself.

rebuildAndRecalculate() does not rebuild from the stored formulas. It serializes every sheet, then builds a new engine from that serialized content:

// src/HyperFormula.ts — rebuildWithConfig()
const serializedSheets = this._serialization.withNewConfig(configNewLanguage, this._namedExpressions).getAllSheetsSerialized()

The serializer then writes out the computed spill value for B1 as if it were cell content:

// src/Serialization.ts:64
public getCellSerialized(address: SimpleCellAddress, targetAddress?: SimpleCellAddress): RawCellContent {
  return this.getCellFormula(address, targetAddress) ?? this.getRawValue(address)
}

getCellFormula() deliberately returns undefined for a cell that belongs to an array but is not that array's anchor cell (src/Serialization.ts:48-52). The ?? then falls through to getRawValue(), which returns the spilled value.

For B1 in the example above:

call result
isCellPartOfArray(B1) true
getCellFormula(B1) undefined
getCellSerialized(B1) 2

So the sheet serializes to [["={1,2}", 2]]. B1 now holds a hard-coded 2. The new engine builds from that, ={1,2} has no room to spill into B1, and A1 becomes #SPILL!.

The serialize-then-rebuild round trip is not idempotent for array formulas. The spilled value is baked in as real content, and then blocks its own formula.

Steps to reproduce
import { HyperFormula } from 'hyperformula';

const hf = HyperFormula.buildFromArray([['={1,2}', null]], { licenseKey: 'gpl-v3' });

console.log(hf.getSheetValues(0));      // [[1, 2]]                        correct
console.log(hf.getSheetSerialized(0));  // [["={1,2}", 2]]                 already wrong

hf.rebuildAndRecalculate();

console.log(hf.getSheetValues(0));      // [[#SPILL!, 2]]                  bug
Expected behavior

rebuildAndRecalculate() preserves the array formula result: [[1, 2]].

A cell that is part of an array but is not the array's anchor has no content of its own, so it should serialize to nothing.

Notes

This is not limited to rebuildAndRecalculate(). getSheetSerialized() returns [["={1,2}", 2]] before any rebuild happens. Any save-and-restore flow that round-trips through serialization corrupts array formulas the same way. rebuildAndRecalculate() is just the most visible trigger, because it performs that round trip internally.

Vertical spills fail identically. ={1;2} in A1 serializes as [["={1;2}"], [2]] and yields #SPILL! after a rebuild.

Ordinary formulas are unaffected. =A1+B1 survives a rebuild correctly, so the problem is specific to array formulas.

Reported downstream. This surfaced as handsontable/handsontable#11141. The Handsontable Formulas plugin also calls rebuildAndRecalculate() on its own, on the sheetAdded and sheetRemoved events, so Handsontable users can hit this without ever calling the API themselves — attaching a second grid to a shared engine breaks every array formula in the first grid.

Possibly related: #1287, which covers #SPILL! not clearing when the blocking area is freed. Same area, different defect.

Suggested fix

In getCellSerialized(), return undefined when the address belongs to an array vertex but is not that array's anchor cell, instead of falling through to getRawValue(). That makes the round trip idempotent for array formulas and fixes the save/restore case at the same time.

Demo

Reproduces in Node with no sandbox needed — the snippet under "Steps to reproduce" is complete and self-contained.

The original downstream report has a browser demo: https://stackblitz.com/edit/6sjfmr-eszi6u?file=index.js

HyperFormula version

Every version tested reproduces it: 2.4.0, 2.7.1, 3.0.0, 3.3.0, and 3.4.0 (latest).

Your framework

None — plain HyperFormula.

Your environment

Node.js 24 on macOS. Also reported in Chrome by the downstream reporter.

Lingua principale
TypeScript
Stelle
2.8k
Fork
174
Merge medio
2g 16h
PR unite (30g)
9

Preparare l'ambiente

Come iniziare

  1. Leggi tutta la issue e poi la guida ai contributi del progetto.
  2. Commenta sulla issue per dire che te ne occupi tu — evita che due persone facciano lo stesso lavoro.
  3. Fai un fork del repository e lavora su un branch.
  4. Apri una pull request che faccia riferimento al numero della issue.

Altre issue di handsontable/hyperformula

Tutte le issue di handsontable/hyperformula

Issue simili

Altre issue su TypeScript

Ricevi le nuove issue nella tua casella

Un breve riepilogo di issue GitHub adatte ai principianti.