@rowsncolumns/toolkit 24.4.1

package/dist/cjs/exporter/xlsx/threaded-comments-builder.d.ts

@@ -0,0 +1,58 @@
+import type { CommentThread } from "@rowsncolumns/common-types";
+export declare const THREADED_COMMENT_REL_TYPE = "http://schemas.microsoft.com/office/2017/10/relationships/threadedComment";
+export declare const PERSON_REL_TYPE = "http://schemas.microsoft.com/office/2017/10/relationships/person";
+export declare const THREADED_COMMENTS_CONTENT_TYPE = "application/vnd.ms-excel.threadedcomments+xml";
+export declare const PERSON_CONTENT_TYPE = "application/vnd.ms-excel.person+xml";
+/**
+ * Deterministic, RFC-4122-shaped GUID (braced + uppercase, the form Excel
+ * writes) derived purely from `seed`. Same seed → same GUID, so exports are
+ * reproducible. Not cryptographically random — collision-safe enough for
+ * scoping author/comment ids within a single workbook.
+ */
+export declare const deterministicGuid: (seed: string) => string;
+/**
+ * Workbook-scoped author registry. Shared across every sheet's collector so
+ * an author who comments on multiple sheets maps to a single `person` entry
+ * (and a single, stable `personId`).
+ */
+export declare class PersonRegistry {
+    private readonly byKey;
+    /** Register an author, returning its braced personId GUID. */
+    register(authorId: string | undefined, displayName: string | undefined): string;
+    isEmpty(): boolean;
+    toXml(): string | undefined;
+}
+/**
+ * Per-sheet collector. Resolves a cell's `commentThreadId` against the
+ * workbook's thread list (the "getter by thread id"), then emits the
+ * threaded-comment XML plus the legacy mirror entries for that sheet.
+ */
+export declare class ThreadedCommentsCollector {
+    private readonly persons;
+    private readonly threadById;
+    private readonly placed;
+    constructor(threads: CommentThread[] | undefined, persons: PersonRegistry);
+    /** Anchor a thread to a cell. No-op if the id is unknown or empty. */
+    addCell(address: string, threadId: string | number | null | undefined): void;
+    isEmpty(): boolean;
+    /** Braced root GUID for a thread — used as both the root `id` and `tc=`. */
+    private rootGuid;
+    /**
+     * Legacy `xl/comments{N}.xml` mirror entries. Feed these into the existing
+     * notes `CommentsCollector` so the comments part + VML + relationships are
+     * reused. Author is the `tc={rootGuid}` sentinel that links the note to its
+     * threaded comment.
+     */
+    legacyEntries(): {
+        address: string;
+        text: string;
+        author: string;
+    }[];
+    /**
+     * The `xl/threadedComments/threadedComment{N}.xml` body. Registers each
+     * message's author with the shared {@link PersonRegistry} as a side effect,
+     * so call this before serializing `person.xml`.
+     */
+    toXml(): string | undefined;
+}
+//# sourceMappingURL=threaded-comments-builder.d.ts.map

package/dist/cjs/exporter/xlsx/threaded-comments-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"threaded-comments-builder.d.ts","sourceRoot":"","sources":["../../../../exporter/xlsx/threaded-comments-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAyBhE,eAAO,MAAM,yBAAyB,8EACuC,CAAC;AAC9E,eAAO,MAAM,eAAe,qEACwC,CAAC;AACrE,eAAO,MAAM,8BAA8B,kDACM,CAAC;AAClD,eAAO,MAAM,mBAAmB,wCAAwC,CAAC;AAsBzE;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,KAAG,MAiBhD,CAAC;AAEF;;;;GAIG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAGlB;IAEJ,8DAA8D;IAC9D,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,WAAW,EAAE,MAAM,GAAG,SAAS;IAWtE,OAAO;IAIP,KAAK;CAYN;AAQD;;;;GAIG;AACH,qBAAa,yBAAyB;IAMlC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAL1B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IACxD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;gBAG3C,OAAO,EAAE,aAAa,EAAE,GAAG,SAAS,EACnB,OAAO,EAAE,cAAc;IAO1C,sEAAsE;IACtE,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS;IAQrE,OAAO;IAIP,4EAA4E;IAC5E,OAAO,CAAC,QAAQ;IAIhB;;;;;OAKG;IACH,aAAa,IAAI;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE;IAcpE;;;;OAIG;IACH,KAAK,IAAI,MAAM,GAAG,SAAS;CA+B5B"}

package/dist/cjs/exporter/xlsx/threaded-comments-builder.js

@@ -0,0 +1,189 @@
+/**
+ * Modern threaded comments (Excel's "Comments" sidebar, as opposed to the
+ * legacy yellow "Notes"). The OOXML shape is three coordinated parts:
+ *
+ *   1. `xl/threadedComments/threadedComment{N}.xml` — one per sheet, holds
+ *      the ordered messages of every thread anchored on that sheet. The
+ *      first message is the root; replies carry `parentId` = the root's id.
+ *   2. `xl/persons/person.xml` — workbook-level author list. Each
+ *      `threadedComment` references an author by `personId`.
+ *   3. A down-level mirror in the legacy `xl/comments{N}.xml` part: every
+ *      threaded comment MUST have a matching legacy `<comment>` whose author
+ *      is the sentinel string `tc={rootGuid}`. Excel uses that `tc=` author
+ *      to (a) associate the legacy note with its threaded comment and
+ *      (b) suppress it as a separate note. Older Excel reads the mirror;
+ *      newer Excel reads the threaded part. See {@link legacyEntries}.
+ *
+ * All GUIDs are derived deterministically from the source ids so repeated
+ * exports of the same workbook are byte-stable (and tests are stable).
+ */
+var THREADED_COMMENTS_NS = "http://schemas.microsoft.com/office/spreadsheetml/2018/threadedcomments";
+export var THREADED_COMMENT_REL_TYPE = "http://schemas.microsoft.com/office/2017/10/relationships/threadedComment";
+export var PERSON_REL_TYPE = "http://schemas.microsoft.com/office/2017/10/relationships/person";
+export var THREADED_COMMENTS_CONTENT_TYPE = "application/vnd.ms-excel.threadedcomments+xml";
+export var PERSON_CONTENT_TYPE = "application/vnd.ms-excel.person+xml";
+var XML_DECLARATION = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
+var escapeXml = function (value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+};
+/** FNV-1a 32-bit hash, seeded so we can derive four independent words. */
+var fnv1a = function (str, seed) {
+    var h = seed >>> 0;
+    for (var i = 0; i < str.length; i++) {
+        h ^= str.charCodeAt(i);
+        h = Math.imul(h, 0x01000193) >>> 0;
+    }
+    return h >>> 0;
+};
+/**
+ * Deterministic, RFC-4122-shaped GUID (braced + uppercase, the form Excel
+ * writes) derived purely from `seed`. Same seed → same GUID, so exports are
+ * reproducible. Not cryptographically random — collision-safe enough for
+ * scoping author/comment ids within a single workbook.
+ */
+export var deterministicGuid = function (seed) {
+    var hex = function (n) { return n.toString(16).padStart(8, "0"); };
+    var all = (hex(fnv1a(seed, 0x811c9dc5)) +
+        hex(fnv1a("".concat(seed, "|b"), 0x811c9dc5)) +
+        hex(fnv1a("".concat(seed, "|c"), 0x811c9dc5)) +
+        hex(fnv1a("".concat(seed, "|d"), 0x811c9dc5))).toUpperCase();
+    var p1 = all.slice(0, 8);
+    var p2 = all.slice(8, 12);
+    var p3 = "4".concat(all.slice(13, 16)); // version 4
+    var variant = ((parseInt(all.slice(16, 17), 16) & 0x3) | 0x8)
+        .toString(16)
+        .toUpperCase();
+    var p4 = "".concat(variant).concat(all.slice(17, 20));
+    var p5 = all.slice(20, 32);
+    return "{".concat(p1, "-").concat(p2, "-").concat(p3, "-").concat(p4, "-").concat(p5, "}");
+};
+/**
+ * Workbook-scoped author registry. Shared across every sheet's collector so
+ * an author who comments on multiple sheets maps to a single `person` entry
+ * (and a single, stable `personId`).
+ */
+var PersonRegistry = /** @class */ (function () {
+    function PersonRegistry() {
+        this.byKey = new Map();
+    }
+    /** Register an author, returning its braced personId GUID. */
+    PersonRegistry.prototype.register = function (authorId, displayName) {
+        var userId = (authorId !== null && authorId !== void 0 ? authorId : "").trim();
+        var name = (displayName !== null && displayName !== void 0 ? displayName : "").trim() || "Unknown";
+        var key = userId || name;
+        var existing = this.byKey.get(key);
+        if (existing)
+            return existing.guid;
+        var guid = deterministicGuid("person:".concat(key));
+        this.byKey.set(key, { guid: guid, displayName: name, userId: userId });
+        return guid;
+    };
+    PersonRegistry.prototype.isEmpty = function () {
+        return this.byKey.size === 0;
+    };
+    PersonRegistry.prototype.toXml = function () {
+        if (this.byKey.size === 0)
+            return undefined;
+        var people = Array.from(this.byKey.values())
+            .map(function (p) {
+            return "<person displayName=\"".concat(escapeXml(p.displayName), "\" id=\"").concat(p.guid, "\" userId=\"").concat(escapeXml(p.userId || p.displayName), "\" providerId=\"None\"/>");
+        })
+            .join("");
+        return "".concat(XML_DECLARATION, "<personList xmlns=\"").concat(THREADED_COMMENTS_NS, "\" xmlns:x=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\">").concat(people, "</personList>");
+    };
+    return PersonRegistry;
+}());
+export { PersonRegistry };
+/** The standard down-level boilerplate Excel writes for the legacy mirror. */
+var LEGACY_PREAMBLE = "[Threaded comment]\n\nYour version of Excel allows you to read this threaded comment; however, any edits to it will get removed if the file is opened in a newer version of Excel. Learn more: https://go.microsoft.com/fwlink/?linkid=870924";
+/**
+ * Per-sheet collector. Resolves a cell's `commentThreadId` against the
+ * workbook's thread list (the "getter by thread id"), then emits the
+ * threaded-comment XML plus the legacy mirror entries for that sheet.
+ */
+var ThreadedCommentsCollector = /** @class */ (function () {
+    function ThreadedCommentsCollector(threads, persons) {
+        this.persons = persons;
+        this.placed = [];
+        this.threadById = new Map((threads !== null && threads !== void 0 ? threads : []).map(function (t) { return [String(t.id), t]; }));
+    }
+    /** Anchor a thread to a cell. No-op if the id is unknown or empty. */
+    ThreadedCommentsCollector.prototype.addCell = function (address, threadId) {
+        var _a;
+        if (threadId == null)
+            return;
+        var thread = this.threadById.get(String(threadId));
+        if (thread && ((_a = thread.messages) === null || _a === void 0 ? void 0 : _a.length)) {
+            this.placed.push({ address: address, thread: thread });
+        }
+    };
+    ThreadedCommentsCollector.prototype.isEmpty = function () {
+        return this.placed.length === 0;
+    };
+    /** Braced root GUID for a thread — used as both the root `id` and `tc=`. */
+    ThreadedCommentsCollector.prototype.rootGuid = function (thread) {
+        return deterministicGuid("tc:".concat(thread.id));
+    };
+    /**
+     * Legacy `xl/comments{N}.xml` mirror entries. Feed these into the existing
+     * notes `CommentsCollector` so the comments part + VML + relationships are
+     * reused. Author is the `tc={rootGuid}` sentinel that links the note to its
+     * threaded comment.
+     */
+    ThreadedCommentsCollector.prototype.legacyEntries = function () {
+        var _this = this;
+        return this.placed.map(function (_a) {
+            var address = _a.address, thread = _a.thread;
+            var lines = thread.messages.map(function (m, i) {
+                var label = i === 0 ? "Comment" : "Reply";
+                return "".concat(label, ":\n    ").concat(m.text);
+            });
+            return {
+                address: address,
+                text: "".concat(LEGACY_PREAMBLE, "\n\n").concat(lines.join("\n\n")),
+                author: "tc=".concat(_this.rootGuid(thread)),
+            };
+        });
+    };
+    /**
+     * The `xl/threadedComments/threadedComment{N}.xml` body. Registers each
+     * message's author with the shared {@link PersonRegistry} as a side effect,
+     * so call this before serializing `person.xml`.
+     */
+    ThreadedCommentsCollector.prototype.toXml = function () {
+        var _this = this;
+        if (!this.placed.length)
+            return undefined;
+        var comments = this.placed
+            .map(function (_a) {
+            var address = _a.address, thread = _a.thread;
+            var root = _this.rootGuid(thread);
+            return thread.messages
+                .map(function (msg, index) {
+                var _a;
+                var personId = _this.persons.register(msg.authorId, msg.authorName);
+                var id = index === 0
+                    ? root
+                    : deterministicGuid("c:".concat(thread.id, ":").concat(msg.id));
+                var parent = index === 0 ? "" : " parentId=\"".concat(root, "\"");
+                // Resolved state rides on the root as `done="1"` (MS-XLSX);
+                // replies never carry it.
+                var done = index === 0 && thread.resolved ? " done=\"1\"" : "";
+                var dt = msg.createdAtISO
+                    ? " dT=\"".concat(escapeXml(msg.createdAtISO), "\"")
+                    : "";
+                return "<threadedComment ref=\"".concat(address, "\"").concat(dt, " personId=\"").concat(personId, "\" id=\"").concat(id, "\"").concat(parent).concat(done, "><text>").concat(escapeXml((_a = msg.text) !== null && _a !== void 0 ? _a : ""), "</text></threadedComment>");
+            })
+                .join("");
+        })
+            .join("");
+        return "".concat(XML_DECLARATION, "<ThreadedComments xmlns=\"").concat(THREADED_COMMENTS_NS, "\">").concat(comments, "</ThreadedComments>");
+    };
+    return ThreadedCommentsCollector;
+}());
+export { ThreadedCommentsCollector };

package/dist/cjs/exporter/xlsx/xlsx-export.d.ts

@@ -0,0 +1,121 @@
+import type { CellData, Citation, CommentThread, DataValidationRuleRecord, IterativeCalculationOptions, SheetData, TextFormat } from "@rowsncolumns/common-types";
+import type { Color, ConditionalFormatRule, EmbeddedChart, EmbeddedObject, NamedRange, PivotTable, Sheet, Slicer, SpreadsheetTheme, TableView } from "@rowsncolumns/spreadsheet";
+import type { CellXfs, SharedStrings as SharedStringsType } from "@rowsncolumns/spreadsheet-state";
+import type { PowerQueryParts } from "../../power-query";
+import type { ExternalLink, WorkbookProperties } from "../../excel-parser/types";
+export type ExportExcelProps<S extends Sheet, T extends CellData, C extends Citation> = {
+    sheets: S[];
+    sheetData: SheetData<T>;
+    sharedStrings?: SharedStringsType;
+    tables?: TableView[];
+    conditionalFormats?: ConditionalFormatRule[];
+    dataValidations?: DataValidationRuleRecord[];
+    cellXfs?: CellXfs | null;
+    theme?: SpreadsheetTheme;
+    /**
+     * Workbook default font (source styles.xml fonts[0]). When set, font id 0
+     * is seeded from it instead of the hardcoded Calibri 11, so cells without
+     * an explicit font keep the source workbook's default.
+     */
+    defaultFont?: TextFormat | null;
+    embeds?: EmbeddedObject[];
+    charts?: EmbeddedChart[];
+    slicers?: Slicer[];
+    /**
+     * Phase D2 — pivot tables. Each entry becomes a
+     * pivotTable<N>.xml + pivotCacheDefinition<N>.xml pair plus
+     * worksheet / workbook relationships. We deliberately don't
+     * emit `pivotCacheRecords<N>.xml` — `refreshOnLoad="1"` makes
+     * Excel pull from the live source range instead, avoiding any
+     * stale-cache drift.
+     */
+    pivotTables?: PivotTable[];
+    externalLinks?: ExternalLink[];
+    namedRanges?: NamedRange[];
+    /**
+     * Workbook-wide named cell styles to round-trip into the
+     * `<cellStyles>` block of styles.xml. Parsed by the importer as
+     * `workbook.workbookStyles.namedCellStyles`; consumers that hold on
+     * to that list can forward it here to preserve the OOXML
+     * Heading 1 / Accent 1 / Total / Good-Bad-Neutral gallery on
+     * round-trip. When omitted, only the default "Normal" entry is
+     * emitted (existing behavior).
+     */
+    namedCellStyles?: Array<{
+        name: string;
+        xfId: number;
+        builtinId?: number;
+        iLevel?: number;
+        hidden?: boolean;
+        customBuiltin?: boolean;
+    }>;
+    /**
+     * Workbook-wide user-authored table styles to round-trip into the
+     * `<tableStyles>` block of styles.xml. Importer surfaces these via
+     * `workbook.workbookStyles.getCustomTableStyleExports()`; hosts can
+     * forward the returned list back here. Each element's formatting
+     * is re-registered as a dxf so the original Banding colors / font
+     * overrides survive a save.
+     *
+     * The built-in `TableStyleMedium2` / `PivotStyleLight16` defaults
+     * are emitted regardless — Excel needs them as the fallback when a
+     * table doesn't pick a custom style.
+     */
+    customTableStyles?: Array<{
+        name: string;
+        pivot?: boolean;
+        elements: Array<{
+            type: string;
+            size?: number;
+            backgroundColor?: Color;
+            textColor?: Color;
+            bold?: boolean;
+            italic?: boolean;
+        }>;
+    }>;
+    iterativeCalculationOptions?: IterativeCalculationOptions;
+    ignoreFormulaPatterns?: RegExp | RegExp[];
+    citations?: Citation[];
+    /**
+     * Cell comment threads, exported as modern XLSX threaded comments
+     * (Excel's "Comments" pane). Each thread is anchored to the cell whose
+     * `commentThreadId` equals the thread's `id`; placement is resolved from
+     * the cells, not from this list. Threads with no matching cell are
+     * ignored. A down-level note mirror is also written for older Excel.
+     */
+    comments?: CommentThread[];
+    password?: string;
+    /**
+     * Locale for formula-cell number-format derivation at export time.
+     * When omitted, defaults are used (matches the renderer's behavior).
+     */
+    locale?: string;
+    /**
+     * Emit `<workbookPr date1904="1"/>`. When true, every date serial is
+     * interpreted relative to the 1904 epoch (1462 days after the 1900
+     * epoch). Default is the 1900 epoch — Excel's own default.
+     */
+    use1904?: boolean;
+    /**
+     * Preserved Power Query machinery from an imported workbook (the parser's `getPowerQuery()`):
+     * DataMashup customXml items, `xl/connections.xml`, and per-table queryTable parts — all
+     * verbatim XML. Re-emitted by `applyPowerQueryParts` so a round-tripped file keeps its
+     * queries; a renamed/reshaped table degrades to a plain table while the query survives.
+     */
+    powerQuery?: PowerQueryParts;
+    /**
+     * Workbook metadata written to docProps/core.xml + docProps/app.xml.
+     * When omitted, generic defaults are emitted (matches prior behavior).
+     */
+    properties?: WorkbookProperties;
+};
+export declare const createExcelFile: <S extends Sheet, T extends CellData, C extends Citation>({ conditionalFormats: _conditionalFormats, dataValidations: _dataValidations, sheets, sheetData, sharedStrings: sourceSharedStrings, tables: _tables, cellXfs, theme, defaultFont, embeds, charts, slicers, pivotTables, externalLinks, namedRanges, namedCellStyles, customTableStyles, iterativeCalculationOptions, ignoreFormulaPatterns, citations, comments, password, locale, use1904, properties, powerQuery, }: ExportExcelProps<S, T, C>) => Promise<Uint8Array<ArrayBufferLike>>;
+/**
+ * Normalize a dataValidation sqref list: collapse degenerate ranges
+ * (`C7:C7` → `C7`), drop exact duplicates, and drop members fully contained
+ * in another member. The collector receives both range-form refs and
+ * per-cell addresses for the same rule, which otherwise emits noisy
+ * `sqref="C7:C7 C8:C8 C7 C8"` lists.
+ */
+export declare const normalizeSqrefMembers: (refs: string[]) => string[];
+//# sourceMappingURL=xlsx-export.d.ts.map

package/dist/cjs/exporter/xlsx/xlsx-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xlsx-export.d.ts","sourceRoot":"","sources":["../../../../exporter/xlsx/xlsx-export.ts"],"names":[],"mappings":"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"}