@shbernal/ts-xlsx 3.0.0 → 3.2.0

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

@@ -1,13 +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 { checkedToken, escapeAttr, escapeText, numAttr, textAttr, XML_DECLARATION, } from '../../xml/xml.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',
@@ -28,16 +29,20 @@ 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(sheetCount, tables, commentNumbers, drawingNumbers, printerSettingsNumbers, mediaExtensions, hasSharedStrings, preservedParts, pivots, preservedWorkbookRefs, threadedCommentNumbers, hasPersons) {
-    const extensionDefaults = buildExtensionDefaults(commentNumbers, printerSettingsNumbers, mediaExtensions, preservedParts);
+export function contentTypesXml(inputs) {
+    const extensionDefaults = buildExtensionDefaults(inputs);
     return (XML_DECLARATION +
         `<Types xmlns="${NS.contentTypes}">` +
         contentTypeDefaults(extensionDefaults) +
-        contentTypeOverrides(sheetCount, tables, drawingNumbers, commentNumbers, hasSharedStrings, preservedParts, pivots, preservedWorkbookRefs, extensionDefaults, threadedCommentNumbers, hasPersons) +
+        contentTypeOverrides(inputs, extensionDefaults) +
         '</Types>');
 }
-function buildExtensionDefaults(commentNumbers, printerSettingsNumbers, mediaExtensions, preservedParts) {
+function buildExtensionDefaults(inputs) {
+    const { commentNumbers, printerSettingsNumbers, mediaExtensions, preservedParts } = inputs;
     const defaults = new Map();
     const add = (extension, contentType) => {
         const key = extension.toLowerCase();
@@ -54,25 +59,25 @@ function buildExtensionDefaults(commentNumbers, printerSettingsNumbers, mediaExt
         add(ext, imageContentType(ext));
     for (const part of preservedParts) {
         const ext = extensionOf(part.path);
-        if (ext.toLowerCase() === 'xml')
+        if (ext === 'xml')
             continue;
         add(ext, part.contentType);
     }
     return defaults;
 }
 function isMacroEnabled(preservedWorkbookRefs) {
-    return preservedWorkbookRefs.some((ref) => ref.relType.endsWith('/vbaProject'));
+    return preservedWorkbookRefs.some((ref) => isRelType(ref.relType, 'vbaProject'));
 }
 function contentTypeDefaults(extensionDefaults) {
     return [...extensionDefaults.values()]
         .map(({ extension, contentType }) => defaultType(extension, contentType))
         .join('');
 }
-function contentTypeOverrides(sheetCount, tables, drawingNumbers, commentNumbers, hasSharedStrings, preservedParts, pivots, preservedWorkbookRefs, extensionDefaults, threadedCommentNumbers, hasPersons) {
+function contentTypeOverrides(inputs, extensionDefaults) {
+    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).toLowerCase())?.contentType !==
-        part.contentType)
+        .filter((part) => extensionDefaults.get(extensionOf(part.path))?.contentType !== part.contentType)
         .map((part) => override(part.path, part.contentType));
     return [
         override(WORKBOOK_PART, isMacroEnabled(preservedWorkbookRefs) ? CT.macroEnabledWorkbook : CT.workbook),
@@ -88,37 +93,43 @@ function contentTypeOverrides(sheetCount, tables, drawingNumbers, commentNumbers
         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,
     ].join('');
 }
 function override(partPath, contentType) {
-    return `<Override PartName="/${partPath}" ContentType="${contentType}"/>`;
+    return `<Override PartName="/${escapeAttr(partPath)}" ContentType="${escapeAttr(contentType)}"/>`;
 }
 function defaultType(extension, contentType) {
-    return `<Default Extension="${extension}" ContentType="${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, preservedRels, pivots) {
+export function workbookXml(workbook, plan, pivots) {
+    const preservedRels = plan.preservedWorkbookRels;
     const sheets = workbook.worksheets;
     const entries = sheets
         .map((sheet, i) => {
+        const relId = plan.sheetRelIds[i];
+        if (relId === undefined) {
+            throw new InternalError(`worksheet ${i + 1} of ${sheets.length} has no relationship id: the plan was drawn for ` +
+                `${plan.sheetRelIds.length} sheet(s)`);
+        }
         const state = sheet.state === 'visible'
             ? ''
             : ` state="${checkedToken(sheet.state, isVisibility, 'sheet visibility')}"`;
-        return `<sheet name="${escapeAttr(sheet.name)}" sheetId="${sheet.id}"${state} r:id="rId${i + 1}"/>`;
+        return `<sheet name="${escapeAttr(sheet.name)}" sheetId="${sheet.id}"${state} r:id="${relId}"/>`;
     })
         .join('');
     return (XML_DECLARATION +
         `<workbook xmlns="${NS.main}" xmlns:r="${NS.docRels}">` +
+        workbookPrXml(workbook) +
         workbookProtectionXml(workbook) +
         bookViewsXml(workbook) +
         `<sheets>${entries}</sheets>` +
@@ -129,6 +140,11 @@ export function workbookXml(workbook, preservedRels, pivots) {
         workbookExtLstXml(preservedRels) +
         '</workbook>');
 }
+function workbookPrXml(workbook) {
+    const attrs = (workbook.dateEpoch === 1904 ? ' date1904="1"' : '') +
+        (workbook.codeName === undefined ? '' : ` codeName="${escapeAttr(workbook.codeName)}"`);
+    return attrs === '' ? '' : `<workbookPr${attrs}/>`;
+}
 function bookViewsXml(workbook) {
     const view = workbook.view;
     const activeTab = workbook.activeTabIndex;
@@ -146,23 +162,23 @@ function bookViewsXml(workbook) {
 function externalReferencesXml(preservedRels) {
     const links = preservedRels
         .filter((ref) => ref.externalReferenceIndex !== undefined)
-        .sort((a, b) => a.externalReferenceIndex - b.externalReferenceIndex);
+        .sort((a, b) => (a.externalReferenceIndex ?? 0) - (b.externalReferenceIndex ?? 0));
     if (links.length === 0)
         return '';
     const entries = links.map((ref) => `<externalReference r:id="${ref.relId}"/>`).join('');
     return `<externalReferences>${entries}</externalReferences>`;
 }
 function workbookExtLstXml(preservedRels) {
-    const caches = preservedRels.filter((ref) => ref.relType.endsWith('/slicerCache'));
+    const caches = preservedRels.filter((ref) => isRelType(ref.relType, 'slicerCache'));
     if (caches.length === 0)
         return '';
     const entries = caches.map((ref) => `<x14:slicerCache r:id="${ref.relId}"/>`).join('');
     return `<extLst>${x14Ext(SLICER_CACHES_EXT_URI, `<x14:slicerCaches>${entries}</x14:slicerCaches>`)}</extLst>`;
 }
 function pivotCachesXml(preservedRels, pivots) {
-    const preserved = preservedRels
-        .filter((ref) => ref.pivotCacheId !== undefined)
-        .map((ref) => `<pivotCache cacheId="${escapeAttr(ref.pivotCacheId)}" r:id="${ref.relId}"/>`);
+    const preserved = preservedRels.flatMap((ref) => ref.pivotCacheId === undefined
+        ? []
+        : [`<pivotCache cacheId="${escapeAttr(ref.pivotCacheId)}" r:id="${ref.relId}"/>`]);
     const generated = pivots.map((pivot) => `<pivotCache cacheId="${escapeAttr(pivot.cacheId)}" r:id="${pivot.workbookRelId}"/>`);
     const entries = [...preserved, ...generated];
     if (entries.length === 0)
@@ -193,16 +209,24 @@ const EXCEL_CALC_ID = '171027';
 function calcPrXml(workbook) {
     return workbook.fullCalcOnLoad ? `<calcPr calcId="${EXCEL_CALC_ID}" fullCalcOnLoad="1"/>` : '';
 }
+function localSheetId(sheets, name, scope) {
+    const wanted = scope.toLowerCase();
+    const index = sheets.findIndex((sheet) => sheet.name.toLowerCase() === wanted);
+    if (index === -1) {
+        throw new AuthoringError(`defined name ${quoted(name)} is scoped to worksheet ${quoted(scope)}, which this workbook does not contain`);
+    }
+    return index;
+}
 function definedNamesXml(workbook) {
     const sheets = workbook.worksheets;
     const userEntries = workbook.definedNames.map((name) => {
         const scopeAttr = name.scope === undefined
             ? ''
-            : ` localSheetId="${sheets.findIndex((sheet) => sheet.name === name.scope)}"`;
+            : ` localSheetId="${localSheetId(sheets, name.name, name.scope)}"`;
         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
         ? []
@@ -219,24 +243,6 @@ function filterDatabaseRefersTo(sheetName, range) {
     const absolute = range.replace(/([A-Z]+)(\d+)/g, '$$$1$$$2');
     return `${quoteSheetName(sheetName)}!${absolute}`;
 }
-export const FIXED_WORKBOOK_REL_COUNT = 2;
-export function workbookRelsXml(sheetCount, hasSharedStrings, personsRelId, preservedRels, pivots) {
-    return relationshipsPart([
-        ...Array.from({ length: sheetCount }, (_, i) => relationship(`rId${i + 1}`, REL.worksheet, targetFromWorkbook(worksheetPart(i + 1)))),
-        relationship(`rId${sheetCount + 1}`, REL.styles, 'styles.xml'),
-        relationship(`rId${sheetCount + FIXED_WORKBOOK_REL_COUNT}`, REL.theme, targetFromWorkbook(THEME_PART_PATH)),
-        ...(hasSharedStrings
-            ? [
-                relationship(`rId${sheetCount + FIXED_WORKBOOK_REL_COUNT + 1}`, REL.sharedStrings, targetFromWorkbook(SHARED_STRINGS_PART)),
-            ]
-            : []),
-        ...(personsRelId === null
-            ? []
-            : [relationship(personsRelId, REL.person, targetFromWorkbook(PERSONS_PART))]),
-        ...preservedRels.map((ref) => relationship(ref.relId, ref.relType, escapeAttr(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) {
@@ -248,10 +254,10 @@ export function corePropsXml(properties) {
     if (properties.lastModifiedBy !== undefined) {
         parts.push(`<cp:lastModifiedBy>${escapeText(properties.lastModifiedBy)}</cp:lastModifiedBy>`);
     }
-    if (properties.created) {
+    if (properties.created !== undefined) {
         parts.push(w3cdtf('created', properties.created));
     }
-    if (properties.modified) {
+    if (properties.modified !== undefined) {
         parts.push(w3cdtf('modified', properties.modified));
     }
     return (XML_DECLARATION +
@@ -261,7 +267,9 @@ export function corePropsXml(properties) {
         '</cp:coreProperties>');
 }
 function w3cdtf(element, date) {
-    return `<dcterms:${element} xsi:type="dcterms:W3CDTF">${date.toISOString()}</dcterms:${element}>`;
+    assertWritableDate(date, `the document property ${quoted(element)}`);
+    const stamp = date.toISOString().replace(/\.\d{3}Z$/, 'Z');
+    return `<dcterms:${element} xsi:type="dcterms:W3CDTF">${stamp}</dcterms:${element}>`;
 }
 export function appPropsXml(properties) {
     const company = properties.company === undefined ? '' : `<Company>${escapeText(properties.company)}</Company>`;

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

@@ -1,46 +1,11 @@
-import { type Cell } from '../../core/cell.ts';
-import type { ColumnProperties, RowProperties, Worksheet } from '../../core/worksheet.ts';
+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 { BackgroundPlan, CommentPlan, DrawingPlan, PivotPlan, PreservedReferencePlan, PrinterSettingsPlan, TablePlan, ThreadedCommentPlan } from './package-plan.ts';
-import { type SharedFormulaRole } from './shared-formulas.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';
-/**
- * The used-cell extent of a sheet: the top-left/bottom-right grid bounds that fold into the
- * `<dimension>`. Rows carrying only formatting (a row height, an outline level) do not extend the
- * used range, matching how Excel records `<dimension>`, so {@link add} ignores them. A fresh extent
- * holds the `Infinity`/`-Infinity` sentinels; {@link isEmpty} reports that no used cell has been seen.
- */
-export declare class Extent {
-    top: number;
-    left: number;
-    bottom: number;
-    right: number;
-    constructor(seed?: Extent);
-    /** Whether no used cell has been folded in yet, in which case the dimension is the lone cell `A1`. */
-    get isEmpty(): boolean;
-    /** Fold a rendered row's used-column span into the extent. `minCol` is `Infinity` when the row
-     * carried no cells (only formatting), which extends nothing. */
-    add(row: number, minCol: number, maxCol: number): void;
-}
-/**
- * A worksheet's eagerly-serialised rows: each row's `<row>` XML tagged with its number (so it merges
- * into ascending order with the sheet's remaining live rows, whatever order it was committed in), plus
- * the used-cell {@link Extent} they span. The buffered pass folds that extent into the sheet's dimension.
- */
-export interface FlushedSheet {
-    readonly rows: ReadonlyArray<{
-        readonly number: number;
-        readonly xml: string;
-    }>;
-    readonly extent: Extent;
-    /**
-     * The deepest row outline level among the flushed rows. Carried across the eviction because
-     * `<sheetFormatPr outlineLevelRow>` is derived from every row on the sheet, and a flushed row's
-     * properties are gone from the model by the time the header is serialised.
-     */
-    readonly maxRowOutlineLevel: number;
-}
 export interface SheetReferences {
     readonly drawingRelId: string | null;
     readonly legacyDrawingRelId: string | null;
@@ -49,38 +14,29 @@ export interface SheetReferences {
     readonly legacyDrawingHFRelId: string | null;
     readonly slicerRelIds: readonly string[];
 }
-export declare function worksheetXml(sheet: Worksheet, tables: readonly TablePlan[], styles: StyleRegistry, references: SheetReferences, hyperlinks: readonly HyperlinkPlan[], sharedStrings: SharedStringTable | null, active: boolean, flushed?: FlushedSheet): string;
 /**
- * A column's style facets are defaults its cells inherit unless they override them; the writer
- * composes each cell's full style up front (cell over row over column, per facet) so a cell that
- * overrides one facet still carries the column's others, rather than silently dropping them. Frozen
- * once by the streaming writer at its first flush so every eagerly-rendered row sees the same defaults.
+ * Everything one worksheet part is rendered from: the sheet itself, the parts of the package plan
+ * that belong to it, and the two registries a sheet pass interns into.
+ *
+ * One object for the reason {@link SheetReferences} is one object, applied to the layer above it: a
+ * run of positional arguments carrying two `readonly …[]`s, two nullable references and a bare
+ * boolean is a run whose order the call site cannot be read against. `active:` is the clearest of
+ * them -- as a positional it needed a comment at the call site to say which boolean it was.
  */
-export declare function buildColumnDefaults(sheet: Worksheet): Map<number, ColumnProperties>;
-/** The whole-sheet context a single row needs to serialise: the column defaults it inherits, the
- * style/string tables it interns into, the shared-formula roles its cells play, and the collapsed
- * outline summaries whose toggle it must stamp. The streaming writer supplies empty shared-formula
- * and collapsed-summary sets, since those are whole-sheet derivations a flushed row cannot join. */
-export interface RowRenderContext {
-    readonly columnDefaults: ReadonlyMap<number, ColumnProperties>;
+export interface WorksheetXmlInputs {
+    readonly sheet: Worksheet;
+    readonly tables: readonly TablePlan[];
     readonly styles: StyleRegistry;
+    readonly references: SheetReferences;
+    readonly hyperlinks: readonly HyperlinkPlan[];
     readonly sharedStrings: SharedStringTable | null;
-    readonly sharedRoles: ReadonlyMap<string, SharedFormulaRole>;
-    readonly collapsedSummaries: ReadonlySet<number>;
+    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;
 }
-/**
- * Serialise one row to its `<row>` element, or '' when the row has neither data nor its own
- * formatting. Returns the used-column bounds (`Infinity`/`-Infinity` when nothing was rendered) so a
- * caller can fold them into the sheet dimension. Shared by the buffered sheet pass and the streaming
- * writer's eager flush, so both emit byte-identical rows.
- */
-export declare function renderRow(entry: {
-    readonly number: number;
-    readonly cells: readonly Cell[];
-    readonly properties: RowProperties | undefined;
-}, ctx: RowRenderContext): {
-    xml: string;
-    minCol: number;
-    maxCol: number;
-};
-export declare function worksheetRelsXml(tables: readonly TablePlan[], drawing: DrawingPlan | null, comments: CommentPlan | null, threadedComments: ThreadedCommentPlan | null, printerSettings: PrinterSettingsPlan | null, background: BackgroundPlan | null, hyperlinks: readonly HyperlinkPlan[], preservedReferences: readonly PreservedReferencePlan[], pivots: readonly PivotPlan[]): string;
+export declare function worksheetXml(inputs: WorksheetXmlInputs): string;