@shbernal/ts-xlsx 3.1.0 → 3.2.0

package/dist/io/xlsx/threaded-comments.js

@@ -1,5 +1,6 @@
 import { encodeAddress, tryDecodeCellRef } from '../../core/address.js';
 import { MENTION_OFFSET_MAX, } from '../../core/comment-thread.js';
+import { AuthoringError, quoted } from '../../errors.js';
 import { decodeSpreadsheetText, numInteger } from '../../xml/xml-attrs.js';
 import { parseXml, TextCapture } from '../../xml/xml-read.js';
 import { boolStrict, localName } from '../../xml/xml-scan.js';
@@ -132,8 +133,7 @@ function commentFrom(message, personById) {
         id: message.id,
         text: message.text,
         mentions: message.mentions.map((mention) => mentionOf(mention, personById)),
-        ...(author !== undefined ? { author } : {}),
-        ...(message.personId !== undefined ? { personId: message.personId } : {}),
+        ...(author !== undefined ? { author, personId: author.id } : {}),
         ...(message.date !== undefined ? { date: message.date } : {}),
     };
 }
@@ -147,27 +147,34 @@ function mentionOf(mention, personById) {
         ...(mention.mentionId !== undefined ? { mentionId: mention.mentionId } : {}),
     };
 }
-export function threadedCommentsXml(threads) {
+export function threadedCommentsXml(threads, personById) {
     const messages = threads.flatMap((thread) => {
         const [head, ...replies] = thread.comments;
         if (head === undefined)
             return [];
         return [
-            threadedCommentXml(thread.ref, head, thread.resolved ? ' done="1"' : ''),
-            ...replies.map((reply) => threadedCommentXml(thread.ref, reply, ` parentId="${escapeAttr(head.id)}"`)),
+            threadedCommentXml(thread.ref, head, thread.resolved ? ' done="1"' : '', personById),
+            ...replies.map((reply) => threadedCommentXml(thread.ref, reply, ` parentId="${escapeAttr(head.id)}"`, personById)),
         ];
     });
     return (XML_DECLARATION +
         `<ThreadedComments xmlns="${THREADED_COMMENTS_NS}">${messages.join('')}</ThreadedComments>`);
 }
-function threadedCommentXml(ref, comment, tail) {
+function threadedCommentXml(ref, comment, tail, personById) {
     const date = textAttr('dT', comment.date);
-    const person = textAttr('personId', comment.personId);
+    const personId = comment.personId ?? UNKNOWN_AUTHOR;
+    if (personId !== UNKNOWN_AUTHOR && personById(personId) === undefined) {
+        throw new AuthoringError(`cannot write the threaded comment ${quoted(comment.id)}: its author ${quoted(personId)} is not ` +
+            'a registered person. Register it with Workbook.addPerson, or leave personId out for a ' +
+            'comment with no recorded author');
+    }
+    const person = textAttr('personId', personId);
     return (`<threadedComment ref="${escapeAttr(ref)}"${date}${person} id="${escapeAttr(comment.id)}"${tail}>` +
         `<text>${escapeSpreadsheetText(comment.text)}</text>` +
         mentionsXml(comment.mentions) +
         '</threadedComment>');
 }
+const UNKNOWN_AUTHOR = '{00000000-0000-0000-0000-000000000000}';
 function mentionsXml(mentions) {
     const entries = mentions.flatMap(({ personId, mentionId, startIndex, length }) => {
         if (mentionId === undefined)

package/dist/io/xlsx/workbook-xml.d.ts

@@ -1,26 +1,24 @@
 import type { Workbook, WorkbookProperties } from '../../core/workbook.ts';
-import type { PivotPlan, PreservedPartPlan, PreservedRootReferencePlan, PreservedWorkbookReferencePlan, TablePlan } from './package-plan.ts';
+import type { PivotPlan, PlannedRelationship, PreservedPartPlan, PreservedWorkbookReferencePlan, TablePlan } from './package-plan.ts';
 export type PreservedWorkbookRel = PreservedWorkbookReferencePlan & {
     readonly relId: string;
 };
 /**
- * The workbook part's relationship ids, drawn once by the writer's `assignWorkbookRelIds` and handed
- * to every consumer rather than re-derived by any of them.
+ * The workbook part's relationships, recorded once by the writer's `planWorkbookRelationships`, with
+ * the ids the workbook body cites picked out of them.
  *
- * Declared here because both consumers are here: the rels part wires the ids, and the workbook body
- * *references* them from `<sheet r:id>`. The body used to spell that reference `rId${i + 1}`, which
- * agreed with the allocator only because sheets happen to be the first ids it hands out. Anything
- * laid ahead of them would have re-pointed every sheet at the wrong part, and the package would have
- * stayed schema-valid while doing it -- a class of corruption no validator catches and no round-trip
- * through this library notices, because the reader resolves the same wrong ids consistently.
+ * Declared here because the body is the consumer of the ids: it references them from `<sheet r:id>`.
+ * The body used to spell that reference `rId${i + 1}`, which agreed with the allocator only because
+ * sheets happen to be the first ids it hands out. Anything laid ahead of them would have re-pointed
+ * every sheet at the wrong part, and the package would have stayed schema-valid while doing it -- a
+ * class of corruption no validator catches and no round-trip through this library notices, because
+ * the reader resolves the same wrong ids consistently.
  */
 export interface WorkbookRelPlan {
     readonly sheetRelIds: readonly string[];
-    readonly stylesRelId: string;
-    readonly themeRelId: string;
-    readonly sharedStringsRelId: string | null;
-    readonly personsRelId: string | null;
     readonly preservedWorkbookRels: readonly PreservedWorkbookRel[];
+    /** Every relationship the workbook's `.rels` part declares, in id order. */
+    readonly relationships: readonly PlannedRelationship[];
 }
 /**
  * What `[Content_Types].xml` needs to know about a package: every part family it declares.
@@ -44,19 +42,10 @@ export interface ContentTypeInputs {
     readonly preservedWorkbookRefs: readonly PreservedWorkbookReferencePlan[];
     readonly threadedCommentNumbers: readonly number[];
     readonly hasPersons: boolean;
+    readonly hasCellMetadata: boolean;
+    readonly hasRichValues: boolean;
 }
 export declare function contentTypesXml(inputs: ContentTypeInputs): string;
-export declare function rootRelsXml(rootRefs: readonly PreservedRootReferencePlan[]): string;
 export declare function workbookXml(workbook: Workbook, plan: WorkbookRelPlan, pivots: readonly PivotPlan[]): string;
-/**
- * The workbook part's `.rels`, rendered from the ids the planner drew.
- *
- * Every id arrives in `plan`; none is computed here. It used to re-derive the styles, theme and
- * shared-strings ids from the sheet count and a shared constant while `write.ts` independently summed
- * the same inputs to place everything after them, so one sequence was spelled in two files and only
- * its fixed part was shared. The relationship *order* is still stated here, because that is what this
- * function is; the numbering is not, because two numberings of one sequence is how they drift apart.
- */
-export declare function workbookRelsXml(plan: WorkbookRelPlan, pivots: readonly PivotPlan[]): string;
 export declare function corePropsXml(properties: WorkbookProperties): string;
 export declare function appPropsXml(properties: WorkbookProperties): string;

package/dist/io/xlsx/workbook-xml.js

@@ -1,15 +1,14 @@
-import { mangleFormula, quoteSheetName } from '../../core/formula.js';
+import { formulaNamesInScope, mangleFormula, quoteSheetName } from '../../core/formula.js';
 import { WORKBOOK_PROTECTION_CREDENTIAL_ATTRS } from '../../core/workbook-protection.js';
 import { isVisibility } from '../../core/worksheet.js';
 import { AuthoringError, InternalError, quoted } from '../../errors.js';
 import { isRelType } from '../../rel-type.js';
 import { assertWritableDate, checkedToken, escapeAttr, escapeText, numAttr, textAttr, XML_DECLARATION, } from '../../xml/xml.js';
 import { extensionOf, THEME_PART_PATH } from '../opc/part-paths.js';
-import { relationship, relationshipsPart } from '../opc/rels.js';
 import { imageContentType } from './images.js';
 import { SLICER_CACHES_EXT_URI } from './namespaces.js';
-import { APP_PROPS_PART, commentsPart, CORE_PROPS_PART, drawingPart, PERSONS_PART, pivotCacheDefinitionPart, pivotCacheRecordsPart, pivotTablePart, SHARED_STRINGS_PART, STYLES_PART, tablePart, targetFromWorkbook, threadedCommentsPart, WORKBOOK_PART, worksheetPart, } from './part-names.js';
-import { NS, REL } from './relationships.js';
+import { APP_PROPS_PART, commentsPart, CORE_PROPS_PART, drawingPart, METADATA_PART, PERSONS_PART, pivotCacheDefinitionPart, pivotCacheRecordsPart, pivotTablePart, RICH_VALUE_STRUCTURES_PART, RICH_VALUES_PART, SHARED_STRINGS_PART, STYLES_PART, tablePart, threadedCommentsPart, WORKBOOK_PART, worksheetPart, } from './part-names.js';
+import { NS } from './relationships.js';
 import { x14Ext } from './x14-ext.js';
 const CT = {
     workbook: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml',
@@ -30,6 +29,9 @@ const CT = {
     pivotCacheRecords: 'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml',
     threadedComments: 'application/vnd.ms-excel.threadedcomments+xml',
     person: 'application/vnd.ms-excel.person+xml',
+    sheetMetadata: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheetMetadata+xml',
+    richValues: 'application/vnd.ms-excel.rdrichvalue+xml',
+    richValueStructures: 'application/vnd.ms-excel.rdrichvaluestructure+xml',
 };
 export function contentTypesXml(inputs) {
     const extensionDefaults = buildExtensionDefaults(inputs);
@@ -72,7 +74,7 @@ function contentTypeDefaults(extensionDefaults) {
         .join('');
 }
 function contentTypeOverrides(inputs, extensionDefaults) {
-    const { sheetCount, tables, drawingNumbers, commentNumbers, threadedCommentNumbers, pivots, hasSharedStrings, hasPersons, preservedParts, preservedWorkbookRefs, } = inputs;
+    const { sheetCount, tables, drawingNumbers, commentNumbers, threadedCommentNumbers, pivots, hasSharedStrings, hasPersons, hasCellMetadata, hasRichValues, preservedParts, preservedWorkbookRefs, } = inputs;
     const preservedOverrides = preservedParts
         .filter((part) => part.path !== THEME_PART_PATH)
         .filter((part) => extensionDefaults.get(extensionOf(part.path))?.contentType !== part.contentType)
@@ -91,6 +93,13 @@ function contentTypeOverrides(inputs, extensionDefaults) {
         override(STYLES_PART, CT.styles),
         ...(hasSharedStrings ? [override(SHARED_STRINGS_PART, CT.sharedStrings)] : []),
         ...(hasPersons ? [override(PERSONS_PART, CT.person)] : []),
+        ...(hasCellMetadata ? [override(METADATA_PART, CT.sheetMetadata)] : []),
+        ...(hasRichValues
+            ? [
+                override(RICH_VALUES_PART, CT.richValues),
+                override(RICH_VALUE_STRUCTURES_PART, CT.richValueStructures),
+            ]
+            : []),
         override(CORE_PROPS_PART, CT.core),
         override(APP_PROPS_PART, CT.app),
         ...preservedOverrides,
@@ -102,14 +111,6 @@ function override(partPath, contentType) {
 function defaultType(extension, contentType) {
     return `<Default Extension="${escapeAttr(extension)}" ContentType="${escapeAttr(contentType)}"/>`;
 }
-export function rootRelsXml(rootRefs) {
-    return relationshipsPart([
-        relationship('rId1', REL.officeDocument, WORKBOOK_PART),
-        relationship('rId2', REL.coreProps, CORE_PROPS_PART),
-        relationship('rId3', REL.extProps, APP_PROPS_PART),
-        ...rootRefs.map((ref, i) => relationship(`rId${4 + i}`, ref.relType, ref.entryPath)),
-    ]);
-}
 export function workbookXml(workbook, plan, pivots) {
     const preservedRels = plan.preservedWorkbookRels;
     const sheets = workbook.worksheets;
@@ -225,7 +226,7 @@ function definedNamesXml(workbook) {
         const commentAttr = textAttr('comment', name.comment);
         const hiddenAttr = name.hidden ? ' hidden="1"' : '';
         return (`<definedName name="${escapeAttr(name.name)}"${scopeAttr}${commentAttr}${hiddenAttr}>` +
-            `${escapeText(mangleFormula(name.refersTo))}</definedName>`);
+            `${escapeText(mangleFormula(name.refersTo, formulaNamesInScope(workbook.definedNames, name.scope)))}</definedName>`);
     });
     const filterEntries = sheets.flatMap((sheet, index) => sheet.autoFilter === undefined
         ? []
@@ -242,25 +243,6 @@ function filterDatabaseRefersTo(sheetName, range) {
     const absolute = range.replace(/([A-Z]+)(\d+)/g, '$$$1$$$2');
     return `${quoteSheetName(sheetName)}!${absolute}`;
 }
-export function workbookRelsXml(plan, pivots) {
-    const { personsRelId } = plan;
-    const preservedRels = plan.preservedWorkbookRels;
-    return relationshipsPart([
-        ...plan.sheetRelIds.map((relId, i) => relationship(relId, REL.worksheet, targetFromWorkbook(worksheetPart(i + 1)))),
-        relationship(plan.stylesRelId, REL.styles, targetFromWorkbook(STYLES_PART)),
-        relationship(plan.themeRelId, REL.theme, targetFromWorkbook(THEME_PART_PATH)),
-        ...(plan.sharedStringsRelId === null
-            ? []
-            : [
-                relationship(plan.sharedStringsRelId, REL.sharedStrings, targetFromWorkbook(SHARED_STRINGS_PART)),
-            ]),
-        ...(personsRelId === null
-            ? []
-            : [relationship(personsRelId, REL.person, targetFromWorkbook(PERSONS_PART))]),
-        ...preservedRels.map((ref) => relationship(ref.relId, ref.relType, targetFromWorkbook(ref.entryPath))),
-        ...pivots.map((pivot) => relationship(pivot.workbookRelId, REL.pivotCacheDefinition, targetFromWorkbook(pivotCacheDefinitionPart(pivot.number)))),
-    ]);
-}
 export function corePropsXml(properties) {
     const parts = [];
     if (properties.title !== undefined) {

package/dist/io/xlsx/worksheet-xml.d.ts

@@ -1,7 +1,8 @@
 import type { DateEpoch } from '../../core/date.ts';
 import type { Worksheet } from '../../core/worksheet.ts';
+import type { WorkbookMetadataTable } from './cell-metadata.ts';
 import { type HyperlinkPlan } from './hyperlinks.ts';
-import type { SheetPlan, TablePlan } from './package-plan.ts';
+import type { TablePlan } from './package-plan.ts';
 import { type FlushedSheet } from './row-xml.ts';
 import type { SharedStringTable } from './shared-strings.ts';
 import type { StyleRegistry } from './styles.ts';
@@ -29,11 +30,13 @@ export interface WorksheetXmlInputs {
     readonly references: SheetReferences;
     readonly hyperlinks: readonly HyperlinkPlan[];
     readonly sharedStrings: SharedStringTable | null;
+    readonly cellMetadata: WorkbookMetadataTable;
     readonly dateEpoch: DateEpoch;
+    /** The defined names a bare name in this sheet's formulas resolves to; see `formulaNamesInScope`. */
+    readonly formulaNames: ReadonlySet<string>;
     /** Whether this is the workbook's one selected sheet. */
     readonly active: boolean;
     /** The rows the streaming writer already serialised and evicted, absent on the buffered path. */
     readonly flushed?: FlushedSheet | undefined;
 }
 export declare function worksheetXml(inputs: WorksheetXmlInputs): string;
-export declare function worksheetRelsXml(plan: SheetPlan): string;

package/dist/io/xlsx/worksheet-xml.js

@@ -1,24 +1,25 @@
-import { decodeRange, encodeRect } from '../../core/address.js';
+import { encodeRect } from '../../core/address.js';
+import { arrayRangeConflicts, formulaPlacement } from '../../core/array-formula-ranges.js';
+import { mergesOverlappingTables } from '../../core/merge.js';
 import { pickStyleFacets } from '../../core/style.js';
 import { AuthoringError, InternalError, quoted } from '../../errors.js';
 import { escapeAttr, numberText, XML_DECLARATION } from '../../xml/xml.js';
-import { relationship, relationshipsPart } from '../opc/rels.js';
-import { conditionalFormattingsExtXml, conditionalFormattingsXml, dataBarExtLinks, } from './conditional-formatting.js';
+import { conditionalFormattingsExtXml, conditionalFormattingsXml, planConditionalFormatting, } from './conditional-formatting.js';
 import { dataValidationsExtXml, dataValidationsXml } from './data-validation.js';
-import { hyperlinksXml, isExternalHyperlink } from './hyperlinks.js';
+import { hyperlinksXml } from './hyperlinks.js';
 import { SLICER_LIST_EXT_URI } from './namespaces.js';
-import { commentsPart, drawingPart, mediaPart, pivotTablePart, printerSettingsPart, tablePart, targetFromWorksheet, threadedCommentsPart, vmlDrawingPart, } from './part-names.js';
-import { NS, REL } from './relationships.js';
+import { NS } from './relationships.js';
 import { assertWritableLevel, buildColumnDefaults, Extent, outlineAttr, renderRow, rowOpenTag, } from './row-xml.js';
 import { planSharedFormulas } from './shared-formulas.js';
 import { autoFilterXml, headerFooterXml, pageBreaksXml, pageMarginsXml, pageSetupXml, printOptionsXml, sheetProtectionXml, sheetPrXml, sheetViewsXml, } from './sheet-properties.js';
 import { x14Ext } from './x14-ext.js';
 export function worksheetXml(inputs) {
-    const { sheet, tables, styles, references, hyperlinks, sharedStrings, dateEpoch, active, flushed } = inputs;
+    const { sheet, tables, styles, references, hyperlinks, sharedStrings, cellMetadata, dateEpoch, formulaNames, active, flushed, } = inputs;
     validateMerges(sheet);
+    validateArrayRanges(sheet, flushed);
     const columnDefaults = buildColumnDefaults(sheet);
     const sharedRoles = planSharedFormulas(sheet);
-    const extLinks = dataBarExtLinks(sheet.conditionalFormattings);
+    const formattingPlan = planConditionalFormatting(sheet.conditionalFormattings);
     const rowOutline = scanRowOutline(sheet, flushed);
     const collapsedSummaries = rowOutline.collapsedSummaries;
     const context = {
@@ -28,6 +29,8 @@ export function worksheetXml(inputs) {
         sharedRoles,
         collapsedSummaries,
         dateEpoch,
+        formulaNames,
+        cellMetadata,
     };
     const liveRows = [];
     const extent = new Extent(flushed?.extent);
@@ -58,8 +61,8 @@ export function worksheetXml(inputs) {
         sheetProtectionXml(sheet.protection) +
         autoFilterXml(sheet.autoFilter) +
         mergeCellsXml(sheet.merges) +
-        conditionalFormattingsXml(sheet.conditionalFormattings, styles, extLinks) +
-        dataValidationsXml(sheet.dataValidations) +
+        conditionalFormattingsXml(sheet.conditionalFormattings, styles, formattingPlan, formulaNames) +
+        dataValidationsXml(sheet.dataValidations, formulaNames) +
         hyperlinksXml(hyperlinks) +
         printOptionsXml(sheet.printOptions) +
         pageMarginsXml(sheet.pageMargins) +
@@ -72,13 +75,13 @@ export function worksheetXml(inputs) {
         refElement('legacyDrawingHF', references.legacyDrawingHFRelId) +
         refElement('picture', references.backgroundRelId) +
         tablePartsXml(tables) +
-        worksheetExtLstXml(sheet, references.slicerRelIds, extLinks) +
+        worksheetExtLstXml(sheet, styles, references.slicerRelIds, formattingPlan, formulaNames) +
         '</worksheet>');
 }
-function worksheetExtLstXml(sheet, slicerRelIds, extLinks) {
+function worksheetExtLstXml(sheet, styles, slicerRelIds, formattingPlan, formulaNames) {
     const exts = [
-        conditionalFormattingsExtXml(sheet.conditionalFormattings, extLinks),
-        dataValidationsExtXml(sheet.dataValidations),
+        conditionalFormattingsExtXml(sheet.conditionalFormattings, styles, formattingPlan, formulaNames),
+        dataValidationsExtXml(sheet.dataValidations, formulaNames),
         slicerListExtXml(slicerRelIds),
     ].filter((ext) => ext !== '');
     return exts.length === 0 ? '' : `<extLst>${exts.join('')}</extLst>`;
@@ -90,30 +93,33 @@ function slicerListExtXml(slicerRelIds) {
     return x14Ext(SLICER_LIST_EXT_URI, `<x14:slicerList>${slicers}</x14:slicerList>`);
 }
 function validateMerges(sheet) {
-    if (sheet.merges.length === 0 || sheet.tables.length === 0)
+    const [conflict] = mergesOverlappingTables(sheet.merges, sheet.tables);
+    if (conflict === undefined)
         return;
-    for (const merge of sheet.merges) {
-        const { left, right, top, bottom } = decodeRange(merge);
-        if (left === undefined || right === undefined || top === undefined || bottom === undefined)
-            continue;
-        for (const table of sheet.tables) {
-            const region = table.region;
-            const overlaps = left <= region.right &&
-                right >= region.left &&
-                top <= region.bottom &&
-                bottom >= region.top;
-            if (overlaps) {
-                throw new AuthoringError(`merged range ${merge} overlaps table ${quoted(table.name)} (${table.range}): Excel forbids a merge inside a table`);
-            }
+    const { merge, table } = conflict;
+    throw new AuthoringError(`merged range ${merge} overlaps table ${quoted(table.name)} (${table.range}): Excel forbids a merge inside a table`);
+}
+function validateArrayRanges(sheet, flushed) {
+    const placements = [...(flushed?.formulas ?? [])];
+    for (const { cells } of sheet.rows()) {
+        for (const cell of cells) {
+            const placement = formulaPlacement(cell.address, cell.col, cell.row, cell.value);
+            if (placement !== undefined)
+                placements.push(placement);
         }
     }
+    const [conflict] = arrayRangeConflicts(placements);
+    if (conflict === undefined)
+        return;
+    const { array, other, kind } = conflict;
+    throw new AuthoringError(kind === 'formula-inside'
+        ? `the array formula in ${array.address} fills ${quoted(array.arrayRef ?? '')}, which holds the formula in ${other}: Excel repairs a package with a formula inside another array formula's range`
+        : `the array formula in ${array.address} fills ${quoted(array.arrayRef ?? '')}, which shares cells with the range of the array formula in ${other}: Excel repairs a package whose array formula ranges overlap`);
 }
 function mergeCellsXml(merges) {
     if (merges.length === 0)
         return '';
-    const cells = merges
-        .map((range) => `<mergeCell ref="${escapeAttr(decodeRange(range).dimensions)}"/>`)
-        .join('');
+    const cells = merges.map((range) => `<mergeCell ref="${escapeAttr(range)}"/>`).join('');
     return `<mergeCells count="${merges.length}">${cells}</mergeCells>`;
 }
 function refElement(tag, relId) {
@@ -125,44 +131,6 @@ function tablePartsXml(tables) {
     const parts = tables.map(({ relId }) => `<tablePart r:id="${relId}"/>`).join('');
     return `<tableParts count="${tables.length}">${parts}</tableParts>`;
 }
-export function worksheetRelsXml(plan) {
-    const { tables, drawing, comments, threadedComments, printerSettings, background, hyperlinks, preservedRefs: preservedReferences, pivots, } = plan;
-    const rels = [
-        ...tables.map(({ relId, number }) => relationship(relId, REL.table, targetFromWorksheet(tablePart(number)))),
-        ...pivots.map((pivot) => relationship(pivot.sheetRelId, REL.pivotTable, targetFromWorksheet(pivotTablePart(pivot.number)))),
-        ...(drawing === null
-            ? []
-            : [
-                relationship(drawing.relId, REL.drawing, targetFromWorksheet(drawingPart(drawing.number))),
-            ]),
-        ...(comments === null
-            ? []
-            : [
-                relationship(comments.vmlRelId, REL.vmlDrawing, targetFromWorksheet(vmlDrawingPart(comments.number))),
-                relationship(comments.commentsRelId, REL.comments, targetFromWorksheet(commentsPart(comments.number))),
-            ]),
-        ...(threadedComments === null
-            ? []
-            : [
-                relationship(threadedComments.relId, REL.threadedComment, targetFromWorksheet(threadedCommentsPart(threadedComments.number))),
-            ]),
-        ...(printerSettings === null
-            ? []
-            : [
-                relationship(printerSettings.relId, REL.printerSettings, targetFromWorksheet(printerSettingsPart(printerSettings.number))),
-            ]),
-        ...(background === null
-            ? []
-            : [
-                relationship(background.relId, REL.image, targetFromWorksheet(mediaPart(background.mediaNumber, background.extension))),
-            ]),
-        ...preservedReferences.map((reference) => relationship(reference.relId, reference.relType, targetFromWorksheet(reference.entryPath))),
-        ...hyperlinks
-            .filter(isExternalHyperlink)
-            .map((link) => relationship(link.relId, REL.hyperlink, link.target, { external: true })),
-    ];
-    return relationshipsPart(rels);
-}
 const DEFAULT_ROW_HEIGHT = 15;
 function sheetFormatPr(properties, outlineLevel) {
     const rowHeight = properties.defaultRowHeight ?? DEFAULT_ROW_HEIGHT;

package/dist/io/xlsx/write-stream.d.ts

@@ -4,12 +4,14 @@ import type { Cell } from '../../core/cell.ts';
 import type { ConditionalFormatting } from '../../core/conditional-formatting.ts';
 import type { DataValidation } from '../../core/data-validation.ts';
 import type { DateEpoch } from '../../core/date.ts';
+import type { Hyperlink } from '../../core/hyperlink.ts';
 import type { AnchorPoint } from '../../core/image.ts';
 import { INTERNAL } from '../../core/internal.ts';
 import type { SheetProtectionOptions } from '../../core/protection.ts';
 import { type CellValue } from '../../core/value.ts';
-import { type AddImageOptions, type AddWorksheetOptions, Workbook } from '../../core/workbook.ts';
+import { type AddImageOptions, type AddWorksheetOptions, type DefinedName, Workbook } from '../../core/workbook.ts';
 import type { Worksheet } from '../../core/worksheet.ts';
+import { WorkbookMetadataTable } from './cell-metadata.ts';
 import { type FlushedSheet } from './row-xml.ts';
 import type { StyleRegistry } from './styles.ts';
 /** Calculation settings applied to the streamed workbook. Mirrors the {@link Workbook} flags. */
@@ -63,13 +65,25 @@ export type WorkbookStreamWriterOptions = SinkOptions & {
  */
 export declare class StreamedRow {
     #private;
-    constructor(cells: readonly Cell[], sheet: WorksheetStreamWriter | null, number: number);
-    /** The cells this row materialised, for styling before it is committed. */
+    private constructor();
+    /** The sheet writer's construction channel, keyed like its own; see `core/internal.ts`. */
+    static readonly [INTERNAL]: StreamedRowFactory;
+    /** The cells `addRow` materialised, for styling before it is committed. A cell added to the row
+     * through {@link WorksheetStreamWriter.getCell} is not among them, and is committed all the same. */
     get cells(): readonly Cell[];
     /** Finalise the row: an eager writer serialises it now and releases its cells; otherwise a no-op.
      * Committing twice is harmless: the second call does nothing rather than re-emitting the row. */
     commit(): void;
 }
+/**
+ * How a {@link StreamedRow} comes into being. A row belongs to the sheet writer that numbered it, and
+ * only that writer knows which number is still open. `sheet` is `null` for a writer that keeps every
+ * row live until the workbook commits, where committing a row has nothing to do. Reached as
+ * `StreamedRow[INTERNAL]`.
+ */
+export interface StreamedRowFactory {
+    create(cells: readonly Cell[], sheet: WorksheetStreamWriter | null, number: number): StreamedRow;
+}
 /**
  * A worksheet being written incrementally. Append rows with {@link addRow}/{@link addRows}, style
  * cells through {@link getCell}, then {@link commit} to freeze it, after which any further mutation
@@ -110,6 +124,12 @@ export declare class WorksheetStreamWriter {
     addDataValidation(sqref: string, rule: DataValidation, options?: {
         extended?: boolean;
     }): void;
+    /**
+     * Put a hyperlink on a cell or a rectangle of cells before the sheet is committed; mirrors
+     * {@link Worksheet.addHyperlink}. A link lives beside the grid rather than in a row, so it may cover
+     * cells of a row that is already committed.
+     */
+    addHyperlink(link: Hyperlink): void;
     /**
      * Attach a conditional formatting to a range before the sheet is committed. Like every other block,
      * it lands in its schema-mandated slot, after `<mergeCells>` and before `<dataValidations>` and
@@ -153,7 +173,7 @@ export declare class WorksheetStreamWriter {
  * {@link WorkbookStreamWriter.addWorksheet}. Reached as `WorksheetStreamWriter[INTERNAL]`.
  */
 export interface WorksheetStreamWriterFactory {
-    create(sheet: Worksheet, eager: boolean, styles: StyleRegistry, dateEpoch: DateEpoch): WorksheetStreamWriter;
+    create(sheet: Worksheet, eager: boolean, styles: StyleRegistry, cellMetadata: WorkbookMetadataTable, dateEpoch: DateEpoch, definedNames: readonly DefinedName[]): WorksheetStreamWriter;
 }
 /**
  * What the streaming writer's own machinery may do to a sheet writer that a caller may not, the same
@@ -170,13 +190,15 @@ export interface WorksheetStreamWriterInternals {
     /**
      * Serialise an eagerly-committed row and release its cells from the model. Called by
      * {@link StreamedRow.commit}; the row's `<row>` XML is retained (interned into the workbook's live
-     * style registry so its ids stay valid) and the cell graph is dropped, bounding peak memory.
+     * style registry so its ids stay valid) and the cell graph is dropped, bounding peak memory. The
+     * row is rendered from every cell the model holds for it, including any `getCell` added after
+     * `addRow` returned.
      *
      * @throws {AuthoringError} if the row carries a shared-formula cell: a finished row cannot join the
      *   whole-sheet formula planning, so shared formulas must be authored through
      *   {@link WorksheetStreamWriter.getCell}.
      */
-    flushRow(number: number, cells: readonly Cell[]): void;
+    flushRow(number: number): void;
     /** The rows this writer flushed, or undefined if none. Handed to `buildPackageParts` at commit. */
     flushedSheet(): FlushedSheet | undefined;
 }