@particle-academy/holy-sheet 2.11.0 → 2.11.2

package/CHANGELOG.md

@@ -10,6 +10,82 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.11.2] - 2026-10-28
+
+### Fixed
+
+`Agent.lint()` now follows Excel's formula semantics in the places below,
+ported from PHP holy-sheet 2.11.1 (plus lazy `IF`, which all three linters
+gain together). What you will notice: **fewer false `#NAME?` and `#DIV/0!`
+reports** on formulas Excel accepts, and **some new true positives** on
+formulas Excel rejects or errors on that the linter used to pass. `lint()`'s
+signature and the issue shape `{sheet, address, formula, error, hint}` are
+unchanged. Nothing to do unless you assert on the exact set of issues a formula
+produces. Error labels and hint texts are byte-identical to PHP and Python.
+
+- **`IF` evaluates only the branch it takes.** `=IF(A2=0,0,1/A2)` with A2 = 0
+  used to lint as `#DIV/0!`; it now lints clean, as does any error in the
+  untaken branch. That branch is still parsed, so a syntax error or an unknown
+  function there is still `#NAME?`. An error in the condition still propagates,
+  after the whole `IF` has been parsed. `IFERROR` is not in the linter's
+  vocabulary and is still `#NAME?`.
+- **`%` is postfix percent.** `=50%` is 0.5 and `=A1%` is A1/100; these used to
+  lint as `#NAME?`. A binary `%` such as `=10%2`, which the linter used to
+  evaluate as `10/100*2`, is now reported, because Excel rejects it.
+- **`^` binds tighter than `*` and `/`.** `=2*3^2` is 18, not 36. It stays
+  left-associative (`=2^3^2` is 64) and below negation (`=-2^2` is 4), as in
+  Excel.
+- **A doubled quote inside text is one quote.** `="a""b"` is the three
+  characters `a"b`; it used to lint as `#NAME?`. A text literal that never
+  closes (`="abc`) is now reported instead of passing.
+- **IF reads its condition as Excel does.** Text is TRUE or FALSE only when it
+  spells one of them, in any case: `"false"` used to count as TRUE. Any other
+  text, `""` included, is now `#VALUE!` (a new true positive; it used to pass).
+  An error in the condition now propagates instead of picking a branch.
+- **Comparisons follow Excel's type order.** Numeric text is text, and Excel
+  sorts text above every number: `="5">9` is TRUE and `="10"=10` is FALSE (both
+  used to compare as numbers). Text compares without regard to case
+  (`="a"="A"` is TRUE), logicals sort above text, and a blank cell equals 0,
+  `""` and FALSE. An error on either side now propagates instead of being
+  compared as text. Text is ordered by code point, as PHP and Python order it.
+- **A `#NAME?` hint says which kind it is.** The label is still `#NAME?`, but
+  every cause used to get one hint, "references an unknown function or has a
+  syntax error". A malformed formula now gets `Syntax error: <what and
+  where>...`; an unknown function gets `Unknown function VLOOKUP. ...`; a
+  `#NAME?` inherited from another cell names that cell; and an exception inside
+  the linter itself says it is a linter defect. Match on the hint's prefix if
+  you need to tell them apart.
+- **An unknown function is `#NAME?` wherever it sits.** `=IF(FALSE, FOO(1), 1)`
+  used to pass, because the error was a value that IF discarded. Excel resolves
+  names first, so it is `#NAME?` there and now here (a new true positive).
+- **`ROUND` rounds the decimal value, half away from zero.** `=ROUND(1.005,2)`
+  was 1, `=ROUND(0.285,2)` 0.28 and `=ROUND(8.325,2)` 8.32, because the digits
+  were shifted in binary, where 1.005 is 1.00499999.... They are now 1.01, 0.29
+  and 8.33, as in Excel, PHP and Python.
+- **The tokenizer uses PHP's ASCII character classes.** A no-break space, or a
+  letter such as `é` outside a text literal, is now a syntax error, as it is in
+  PHP; the no-break space used to be skipped as whitespace.
+
+## [2.11.1] - 2026-10-27
+
+### Fixed
+
+- **An explicit `{value: <string>}` cell is now written as a string, exactly
+  as given**, matching PHP holy-sheet and holy-sheet-py. Numeric-string
+  coercion used to run on the object form too, so `{value: "+1"}` was written
+  as the number 1, `{value: "007"}` as 7 and `{value: "1e5"}` as 100000: a
+  phone prefix, zip code or part number lost its characters with no error.
+  This applies in `rows` and in the sparse `cells` map, under any column type
+  or number format, and to a `set_cell` op's `value`. Unchanged: a BARE string
+  in a row or a `cells` entry is still coerced (`"+1"` is still 1) and a bare
+  `"=..."` is still a formula; an object value that is already a number is
+  still a number; and a string under a `date` / `datetime` display format is
+  still converted to a date serial. `read()` returns such a cell as the same
+  string.
+  **What a consumer must do:** if you relied on `{value: "100"}` becoming a
+  number, pass the number (`{value: 100}`) or the bare string (`"100"`).
+  Otherwise nothing.
+
 ## [2.11.0] - 2026-10-27
 
 ### Added