@shbernal/ts-xlsx 1.0.3 → 1.2.0

package/dist/core/row-input.js

@@ -0,0 +1,29 @@
+import { AuthoringError } from '../errors.js';
+import { Cell } from './cell.js';
+export function rowPlacements(values, columns) {
+    if (Array.isArray(values)) {
+        const placements = [];
+        values.forEach((value, index) => {
+            if (value !== undefined)
+                placements.push([index + 1, value]);
+        });
+        return placements;
+    }
+    return Object.entries(values).map(([key, value]) => [columnIndexByKey(columns, key), value]);
+}
+export function buildRowCells(number, values, columns) {
+    const row = new Map();
+    for (const [col, value] of rowPlacements(values, columns)) {
+        const cell = new Cell(number, col);
+        cell.value = value;
+        row.set(col, cell);
+    }
+    return row;
+}
+export function columnIndexByKey(columns, key) {
+    for (const [index, properties] of columns) {
+        if (properties.key === key)
+            return index;
+    }
+    throw new AuthoringError(`no column is keyed ${JSON.stringify(key)} — set getColumn(n).key first`);
+}

package/dist/core/row.d.ts

@@ -15,7 +15,15 @@ export declare class Row {
      * formatted, and they create the record on first write.
      */
     get properties(): Readonly<RowProperties> | undefined;
-    /** Row height in points; `undefined` leaves the sheet default in force. */
+    /**
+     * Row height in points; `undefined` leaves the sheet default in force.
+     *
+     * Not bounded here, deliberately: {@link MAX_ROW_HEIGHT} is what Excel accepts *being set*, but
+     * the schema puts no ceiling on `ht` and this setter is also how the reader loads a foreign
+     * file, so refusing a taller row would mean refusing a file Excel opens clean. Check against the
+     * constant when authoring — Excel silently clamps a taller row on read, so a height above it is
+     * one you state and do not get.
+     */
     get height(): number | undefined;
     set height(height: number | undefined);
     /** Whether the row is hidden. */

package/dist/core/row.js

@@ -1,24 +1,8 @@
-// A handle on one row of a worksheet: its formatting and its cells, reached by row number.
-//
-// A handle, not a record. `Worksheet` keeps the authoritative stores — the cell grid and the sparse
-// map of per-row formatting — and a `Row` reads and writes straight through to them, so two handles
-// on the same number always agree and neither can hold a stale copy. That is the whole reason this
-// is not a snapshot: a row object that copied its cells out would be the shape of the merge-loss
-// class of bug the model contract exists to prevent.
-//
-// Position is fixed at construction, exactly as `Cell` fixes `(row, col)`. `sheet.getRow(3)` means
-// "row 3" and keeps meaning row 3 — a splice that moves content past it does not carry the handle
-// along, any more than it re-points a `Cell`.
-//
-// Formatting is created on write, never on read. Asking for `sheet.getRow(500)` costs nothing and
-// does not extend the used range; assigning `height` is what materialises the record.
 import { columnToNumber, encodeAddress } from './address.js';
 import { INTERNAL } from './internal.js';
 export class Row {
     #sheet;
-    /** 1-based row number. Fixed for this handle's lifetime. */
     number;
-    /** @throws {RangeError} if the number is not a positive integer. */
     constructor(sheet, number) {
         if (!Number.isInteger(number) || number < 1) {
             throw new RangeError(`row ${number} is out of bounds — rows start at 1`);
@@ -26,83 +10,46 @@ export class Row {
         this.#sheet = sheet;
         this.number = number;
     }
-    /**
-     * The row's format record if it has one, else `undefined` — a read that never fabricates, so a
-     * serializer can ask every row it visits whether there are attributes to emit without giving each
-     * one an empty record. Read-only on purpose: {@link height} and its siblings are how a row is
-     * formatted, and they create the record on first write.
-     */
     get properties() {
         return this.#sheet[INTERNAL].rowPropertiesOf(this.number);
     }
-    /** Row height in points; `undefined` leaves the sheet default in force. */
     get height() {
         return this.#read('height');
     }
     set height(height) {
         this.#write('height', height);
     }
-    /** Whether the row is hidden. */
     get hidden() {
         return this.#read('hidden');
     }
     set hidden(hidden) {
         this.#write('hidden', hidden);
     }
-    /** Outline (grouping) depth; 0 or `undefined` means ungrouped. */
     get outlineLevel() {
         return this.#read('outlineLevel');
     }
     set outlineLevel(outlineLevel) {
         this.#write('outlineLevel', outlineLevel);
     }
-    /** Whether this row is the collapsed summary of an outline group. */
     get collapsed() {
         return this.#read('collapsed');
     }
     set collapsed(collapsed) {
         this.#write('collapsed', collapsed);
     }
-    /** Background fill for the row's cells that carry no fill of their own. */
     get fill() {
         return this.#read('fill');
     }
     set fill(fill) {
         this.#write('fill', fill);
     }
-    /**
-     * The cell at a column in this row, creating it on first access. The column is a 1-based index
-     * (`row.getCell(2)`) or its letters (`row.getCell('B')`).
-     *
-     * Resolves through merges exactly as {@link Worksheet.getCell} does: addressing a cell covered by
-     * a merged region yields that region's master.
-     *
-     * @throws {RangeError} if the column is not a positive integer.
-     * @throws {SyntaxError} if the column letters do not name a column.
-     */
     getCell(column) {
         const index = typeof column === 'number' ? column : columnToNumber(column);
         return this.#sheet.getCell(encodeAddress(index, this.number));
     }
-    /**
-     * The row's materialised cells in ascending column order. Sparse: a column never written to has
-     * no cell here, and the array is a fresh snapshot of *which* cells exist — the cells themselves
-     * are the live ones.
-     */
     get cells() {
         return this.#sheet[INTERNAL].rowCells(this.number);
     }
-    /**
-     * The row's values by position, index 0 being column A. Sparse in the same way {@link cells} is:
-     * a column with no cell is a hole, which is what distinguishes "never written" from a cell
-     * holding `null`.
-     *
-     * Assigning places each value it names and leaves every other column untouched — a hole or an
-     * explicit `undefined` skips that column, and a shorter array does not clear the tail. These are
-     * {@link Worksheet.addRow}'s rules, deliberately: `values` is that same row shape addressed by
-     * number rather than appended. To *replace* a row, including clearing what it held, splice it —
-     * `sheet.spliceRows(n, 1, values)`.
-     */
     get values() {
         const values = [];
         for (const cell of this.cells)
@@ -118,11 +65,6 @@ export class Row {
     #read(key) {
         return this.#sheet[INTERNAL].rowPropertiesOf(this.number)?.[key];
     }
-    // `undefined` clears rather than stores: `RowProperties` is declared with optional fields under
-    // `exactOptionalPropertyTypes`, so a present-but-undefined key is not the same shape as an absent
-    // one — and it would make a formatting-free row look formatted to anything reading `properties`.
-    // Clearing a row that has no record at all is a no-op, so a write of `undefined` never
-    // materialises one.
     #write(key, value) {
         if (value === undefined) {
             const properties = this.#sheet[INTERNAL].rowPropertiesOf(this.number);

package/dist/core/style.js

@@ -1,8 +1,3 @@
-// Cell style primitives.
-//
-// Styles are a large surface in OOXML (fonts, fills, borders, alignment, number
-// formats, protection). The rewrite grows them corpus-first; this module models the
-// facets landed so far — colours, fills, borders, fonts, alignment, and protection.
 const NAMED_UNDERLINE_STYLES = new Set([
     'none',
     'single',
@@ -10,7 +5,6 @@ const NAMED_UNDERLINE_STYLES = new Set([
     'singleAccounting',
     'doubleAccounting',
 ]);
-/** Narrow a raw `<u val>` token to a named {@link UnderlineStyle} (the non-boolean members). */
 export function isNamedUnderlineStyle(value) {
     return NAMED_UNDERLINE_STYLES.has(value);
 }
@@ -35,7 +29,6 @@ const FILL_PATTERN_TYPES = new Set([
     'lightGrid',
     'lightTrellis',
 ]);
-/** Narrow a raw `<patternFill patternType>` token to a known {@link FillPatternType}. */
 export function isFillPatternType(value) {
     return FILL_PATTERN_TYPES.has(value);
 }
@@ -54,15 +47,12 @@ const BORDER_STYLES = new Set([
     'mediumDashDotDot',
     'slantDashDot',
 ]);
-/** Narrow a raw border-edge `style` attribute to a known {@link BorderStyle}. */
 export function isBorderStyle(value) {
     return BORDER_STYLES.has(value);
 }
-/** Narrow a raw `<vertAlign val>` token to a known {@link FontVerticalAlignment}. */
 export function isFontVerticalAlignment(value) {
     return value === 'superscript' || value === 'subscript';
 }
-/** Narrow a raw `<scheme val>` token to a known {@link FontScheme}. */
 export function isFontScheme(value) {
     return value === 'minor' || value === 'major' || value === 'none';
 }
@@ -76,7 +66,6 @@ const HORIZONTAL_ALIGNMENTS = new Set([
     'centerContinuous',
     'distributed',
 ]);
-/** Narrow a raw `<alignment horizontal>` token to a known {@link HorizontalAlignment}. */
 export function isHorizontalAlignment(value) {
     return HORIZONTAL_ALIGNMENTS.has(value);
 }
@@ -87,13 +76,9 @@ const VERTICAL_ALIGNMENTS = new Set([
     'justify',
     'distributed',
 ]);
-/** Narrow a raw `<alignment vertical>` token to a known {@link VerticalAlignment}. */
 export function isVerticalAlignment(value) {
     return VERTICAL_ALIGNMENTS.has(value);
 }
-// One entry per facet, as a Record rather than a bare list so the compiler rejects it the moment a
-// facet is added to CellStyle and forgotten here — which would otherwise let the facet-list-driven
-// copies below (assignStyleFacets) silently skip the new facet, a merge-loss.
 const CELL_STYLE_FACET_KEYS = {
     fill: true,
     numFmt: true,
@@ -102,22 +87,11 @@ const CELL_STYLE_FACET_KEYS = {
     alignment: true,
     protection: true,
 };
-/** The names of the {@link CellStyle} facets, for helpers that copy the tuple facet-by-facet. */
 export const CELL_STYLE_FACETS = Object.keys(CELL_STYLE_FACET_KEYS);
-/**
- * Copy each present facet of `source` onto `target`, leaving facets `source` omits untouched — the
- * plain-record counterpart to a cell's `applyCellStyle`, for the {@link CellStyle}-shaped targets a
- * `Cell`'s setters don't reach (a column's cell-defaults, a named style being assembled on read).
- * Driven by {@link CELL_STYLE_FACETS}, so a facet added to the tuple reaches these paths the moment
- * it joins — the same single-point-of-change the cell path gets.
- */
 export function assignStyleFacets(target, source) {
     for (const facet of CELL_STYLE_FACETS)
         copyFacet(target, source, facet);
 }
-// A single facet key at a time, so the write's key type is one member (not the whole union) and
-// `target[key] = source[key]` typechecks without a cast — the correlated-key access TS can't verify
-// when the key is a union.
 function copyFacet(target, source, key) {
     const value = source[key];
     if (value !== undefined)

package/dist/core/table-style.js

@@ -1,20 +1,4 @@
-// A custom table style: the named, reusable look a table (or a pivot) applies to itself by name.
-//
-// A table style is a list of *elements*, each naming one region of the table — the whole table, the
-// header row, the first row stripe — and the differential formatting to lay over it. Excel's built-in
-// gallery ("TableStyleMedium2" and its sixty siblings) is exactly this shape; a workbook that declares
-// its own joins the gallery for that file, and a table reaches it by name through
-// `TableStyleInfo.name`.
 import { AuthoringError } from '../errors.js';
-/**
- * The regions a table style can format (`ST_TableStyleType`).
- *
- * The first thirteen apply to a **table**; the rest style a **pivot table**, which has regions a
- * table does not have (subtotal rows, page-field labels, subheadings). Both live in the same
- * enumeration and the same `<tableStyle>` element — what decides which regions a consumer honours is
- * the style's own `table`/`pivot` flags, not the element names — so the type carries all of them
- * rather than splitting into two enumerations that a caller would have to choose between up front.
- */
 export const TABLE_STYLE_ELEMENT_TYPES = [
     'wholeTable',
     'headerRow',
@@ -45,7 +29,6 @@ export const TABLE_STYLE_ELEMENT_TYPES = [
     'pageFieldLabels',
     'pageFieldValues',
 ];
-/** The four element types banded across several rows or columns — the only ones {@link TableStyleElement.size} means anything on. */
 export const STRIPE_ELEMENT_TYPES = new Set([
     'firstRowStripe',
     'secondRowStripe',
@@ -55,17 +38,6 @@ export const STRIPE_ELEMENT_TYPES = new Set([
 export function isTableStyleElementType(value) {
     return TABLE_STYLE_ELEMENT_TYPES.includes(value);
 }
-/**
- * Reject a table style the writer would otherwise emit as valid-but-inert XML.
- *
- * Both failures here are of the same kind: Excel accepts the file and quietly does nothing with the
- * part the caller cared about. An empty name means no table can ever reference the style, and a
- * `size` outside a stripe is ignored — neither shows up as a repair prompt or a schema error, so the
- * only place to catch them is the call that made them.
- *
- * @throws {AuthoringError} if the name is empty, or a non-stripe element carries a `size`, or a `size` is not
- *   a positive integer.
- */
 export function checkTableStyle(style) {
     if (style.name === '') {
         throw new AuthoringError('a table style needs a name: a table references its style by name');

package/dist/core/table.js

@@ -1,20 +1,5 @@
-// A worksheet table (OOXML `<table>`): a named, structured range with typed columns,
-// an optional header row, and an optional totals row.
-//
-// The model stores the anchor and the column/row counts, not a pre-baked range string —
-// the occupied geometry is derived, so it stays correct as an empty table (header row
-// only), a headerless table (data rows only), or a totals-bearing table. The writer is
-// the OOXML gatekeeper for serialization; this model owns the invariants Excel enforces
-// on the *shape* itself: a legal name, at least one column, and at least one row.
 import { AuthoringError } from '../errors.js';
 import { decodeAddress, encodeAddress } from './address.js';
-/** Copy a style, keeping only its defined fields off the literal so `exactOptionalPropertyTypes`
- * never sees a fabricated `key: undefined` — an absent attribute must stay absent across a copy.
- *
- * The sentinel name `"None"` (Excel's table-style gallery entry for *no* style) is normalised to an
- * absent name: OOXML expresses "unstyled" as a `<tableStyleInfo>` with no `name` attribute, so a
- * literal `name="None"` would reference a style that does not exist and make the file suspect. The
- * banding flags set alongside it are untouched. */
 function cloneStyleInfo(style) {
     const clone = {};
     if (style.name !== undefined && style.name !== 'None')
@@ -29,16 +14,6 @@ function cloneStyleInfo(style) {
         clone.showColumnStripes = style.showColumnStripes;
     return clone;
 }
-/**
- * OOXML's totals-row function names (`ST_TotalsRowFunction`) to the `SUBTOTAL` first-argument code
- * Excel writes into a materialised totals cell. The `10x` band ignores manually hidden rows — the
- * behaviour Excel's totals row uses. The one inversion trap: `count` is COUNTA (103, non-empty) while
- * `countNums` is COUNT (102, numbers only). `none` (no aggregate) has no built-in code, so a column
- * carrying it is absent here and its totals cell is left unmaterialised — Excel accepts the blank
- * cell. `custom` is likewise absent: its aggregate is not a `SUBTOTAL` but the arbitrary formula
- * stored in {@link TableColumn.totalsRowFormula}, which the reader/writer round-trip and the
- * materialiser writes into the cell verbatim.
- */
 export const TOTALS_ROW_SUBTOTAL_CODE = {
     average: 101,
     countNums: 102,
@@ -61,24 +36,10 @@ const TOTALS_ROW_FUNCTIONS = new Set([
     'custom',
     'none',
 ]);
-/** Narrow a raw `totalsRowFunction` attribute to a known {@link TotalsRowFunction}. */
 export function isTotalsRowFunction(value) {
     return TOTALS_ROW_FUNCTIONS.has(value);
 }
-// Excel's table-name grammar: start with a letter, underscore, or backslash; every later
-// character a letter, digit, period, or underscore. Unicode letters/digits are allowed.
-// Excel additionally forbids a name that *is* a cell reference (`A1`, `R1C1`); we defer
-// that rule deliberately — the regression corpus treats cell-reference-shaped names like
-// `T1` as valid table names, so enforcing the collision rule here would reject a fixture
-// the contract accepts.
 const IDENTIFIER = /^[\p{L}\\_][\p{L}\p{N}._]*$/u;
-/**
- * Return copies of `columns` with every name made unique (case-insensitively): the first occurrence
- * keeps its name; a later clash gains the smallest numeric suffix that resolves it (`foo`, `foo2`,
- * `foo3`, …). OOXML requires unique column names within a table — Excel treats a collision as
- * corruption — so this is applied both when a table is authored and when one is read from a file,
- * keeping the two paths identical rather than rejecting a name list the reader would accept.
- */
 export function disambiguateColumnNames(columns) {
     const seen = new Set();
     return columns.map((column) => {
@@ -107,17 +68,10 @@ export class Table {
     totalsRowShown;
     autoFilter;
     style;
-    // The anchor and data-row count move when a row/column splice shifts or resizes the table, so
-    // they are mutable behind the class's controlled `shiftRows`/`shiftColumns` methods.
     #anchorCol;
     #anchorRow;
     #dataRowCount;
-    // Set by the worksheet that registers this table so an appended row can be written into the grid.
-    // A table constructed standalone (a unit test, a bare model) has none — appending values then
-    // throws rather than silently dropping them.
     #writeCell;
-    // Supplied alongside #writeCell by the registering worksheet. A totals-row table appends by
-    // inserting a grid row above the totals; a standalone table has neither hook.
     #insertRow;
     constructor(options, writeCell, insertRow) {
         validateTableName(options.name);
@@ -138,8 +92,6 @@ export class Table {
         this.totalsRow = options.totalsRow ?? false;
         this.totalsRowShown = options.totalsRowShown;
         this.style = options.style === undefined ? undefined : cloneStyleInfo(options.style);
-        // A header table gains an autoFilter by default (Excel's behaviour when a table is inserted);
-        // a headerless table can never carry one — an autoFilter has no header row to anchor to.
         this.autoFilter = this.headerRow && (options.autoFilter ?? true);
         this.#anchorCol = col;
         this.#anchorRow = row;
@@ -153,34 +105,18 @@ export class Table {
     get columnCount() {
         return this.columns.length;
     }
-    /** The number of data rows (excludes the header and totals rows). Always defined — a table loaded
-     * from a file derives it from the stored range, so reading the height never throws. */
     get rowCount() {
         return this.#dataRowCount;
     }
-    /**
-     * Append a data row to the bottom of the table, growing its range by one row and writing `values`
-     * left-to-right across its columns. A loaded table exposes its rows the same as a freshly-authored
-     * one, so this works identically whether the table was built in memory or read from a file.
-     *
-     * A table carrying a totals row appends above it: the new data row lands where the totals row sat,
-     * and the totals row (with any sheet content below) shifts down by one — exactly what inserting a
-     * worksheet row does. That relocation lives in the grid, so a totals-row table not attached to a
-     * worksheet throws, as does passing `values` on any detached table — there is nowhere to put them.
-     */
     addRow(values = []) {
         if (values.length > this.columnCount) {
             throw new RangeError(`row has ${values.length} values but table "${this.name}" has ${this.columnCount} columns`);
         }
-        // The append point is the row directly below the last data row: the totals row when one exists,
-        // otherwise the first free row under the table.
         const target = this.#anchorRow + (this.headerRow ? 1 : 0) + this.#dataRowCount;
         if (this.totalsRow) {
             if (this.#insertRow === undefined) {
                 throw new AuthoringError(`table "${this.name}" is not attached to a worksheet — cannot relocate its totals row to append a data row`);
             }
-            // Opening a grid slot at the totals row shifts the totals down and grows this table by one
-            // through the sheet's own table re-pinning, so #dataRowCount is not bumped again here.
             this.#insertRow(target);
             values.forEach((value, index) => {
                 this.#writeCell?.(target, this.#anchorCol + index, value, this.columns[index]?.style);
@@ -197,15 +133,7 @@ export class Table {
         }
         this.#dataRowCount += 1;
     }
-    /**
-     * Re-pin the table through a row splice: `count` rows removed at the 1-based `start`, then rows
-     * inserted so surviving rows below shift by `delta`. A splice entirely above the table moves its
-     * whole range by `delta`; one landing inside grows or shrinks the data rows to absorb the change;
-     * one that deletes the table's every row removes it. Returns `false` when the table no longer has
-     * a row to occupy (the caller drops it), `true` when it survives.
-     */
     shiftRows(start, count, delta) {
-        // A table whose every row lies within the deleted span has nothing left to occupy.
         if (this.#anchorRow >= start && this.#bottom < start + count)
             return false;
         const shift = (v) => (v < start ? v : v >= start + count ? v + delta : start);
@@ -220,23 +148,11 @@ export class Table {
         this.#dataRowCount = dataRows;
         return true;
     }
-    /**
-     * Re-pin the table through a column splice. A splice entirely to the table's left moves its anchor
-     * by `delta`; one to its right leaves it untouched. A splice landing inside the table's columns is
-     * structural surgery on named columns with no unambiguous answer, so the table's columns are left
-     * as-is (anchor unchanged) rather than fabricated or dropped. Always returns `true`.
-     */
     shiftColumns(start, count, delta) {
         if (this.#anchorCol >= start + count)
             this.#anchorCol += delta;
         return true;
     }
-    /**
-     * The options that reconstruct this table — the anchor as a single-cell ref (not the derived
-     * full range), the columns, and the data-row count with the header/totals flags. Feeding this
-     * back to the constructor yields an equivalent table, so a worksheet model can carry a table
-     * losslessly across an export/import round-trip.
-     */
     get options() {
         const options = {
             name: this.name,
@@ -248,34 +164,21 @@ export class Table {
             totalsRow: this.totalsRow,
             autoFilter: this.autoFilter,
         };
-        // Kept off the literal so `undefined` (attribute absent) stays absent, not an explicit
-        // `totalsRowShown: undefined` — the round-trip must not fabricate the flag.
         if (this.totalsRowShown !== undefined)
             options.totalsRowShown = this.totalsRowShown;
         if (this.style !== undefined)
             options.style = cloneStyleInfo(this.style);
         return options;
     }
-    /** The full A1 range the table occupies: header (if any) + data rows + totals (if any). Distinct
-     * from {@link TableOptions.ref} (and {@link options}'s own `ref`), which is only the single-cell
-     * anchor a table is constructed from — this is the anchor plus the columns/rows it has grown to
-     * cover. */
     get range() {
         return `${encodeAddress(this.#anchorCol, this.#anchorRow)}:${encodeAddress(this.#right, this.#bottom)}`;
     }
-    /**
-     * The autoFilter range — the header row plus the data rows, never the totals row — or
-     * `undefined` when the table has no autoFilter: either it is headerless (an autoFilter has
-     * nothing to anchor to and Excel treats its presence as corruption) or its {@link autoFilter}
-     * flag is off (a table read without one must not gain one on round-trip).
-     */
     get autoFilterRef() {
         if (!this.autoFilter)
             return undefined;
         const bottom = this.#anchorRow + this.#dataRowCount;
         return `${encodeAddress(this.#anchorCol, this.#anchorRow)}:${encodeAddress(this.#right, bottom)}`;
     }
-    /** The occupied rectangle, for conflict checks such as overlapping merges. */
     get region() {
         return { top: this.#anchorRow, left: this.#anchorCol, bottom: this.#bottom, right: this.#right };
     }

package/dist/core/text-metrics.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The number of lines `text` occupies when wrapped at `width` character units - the width unit a
+ * column states, so `estimateWrappedLines(cell, sheet.getColumn(2).width ?? 8.43)` is the shape of
+ * the call.
+ *
+ * A hard break opens a line of its own and what follows wraps independently, matching how Excel
+ * lays a wrapped cell out. The empty string is one line, not zero: a cell always occupies its row.
+ *
+ * An estimate, and only ever that. It counts characters, so it is exact for a monospaced face that
+ * wraps mid-word and approximate for every other - a run of `W`s wraps sooner on screen than this
+ * predicts, a run of `i`s later. Against Excel it reads a shade *low*, because Excel breaks at word
+ * boundaries and its usable width is about 0.64 character units under the stated one: measured at
+ * 5 lines where Excel laid out 6, 25 where Excel laid out 26. This exists so that a writer can
+ * state *a* height rather than leave one to the application that opens the file, and being within a
+ * line of the truth is what that needs.
+ *
+ * @throws {RangeError} if `width` is not a positive finite number - a column of zero width wraps
+ *   nothing, and silently answering `Infinity` or `NaN` would put that straight into a row height.
+ */
+export declare function estimateWrappedLines(text: string, width: number): number;

package/dist/core/text-metrics.js

@@ -0,0 +1,10 @@
+export function estimateWrappedLines(text, width) {
+    if (!Number.isFinite(width) || width <= 0) {
+        throw new RangeError(`wrap width ${width} is not a positive finite number of character units`);
+    }
+    let lines = 0;
+    for (const segment of text.split(/\r\n?|\n/)) {
+        lines += Math.max(1, Math.ceil(segment.length / width));
+    }
+    return lines;
+}