reamkit 1.15.3 → 1.16.0

package/dist/esm/excel/printer-settings.d.ts

@@ -0,0 +1,16 @@
+/** The paper size and orientation a DEVMODE records, when it records them. */
+export interface PrinterPageSetup {
+    /** `dmPaperSize` — the same §18.3.1.63 enumeration `<pageSetup paperSize>` uses. */
+    readonly paperSize?: number;
+    readonly orientation?: 'portrait' | 'landscape';
+}
+/**
+ * Read the paper size and orientation out of a `printerSettings#.bin` part.
+ *
+ * Returns an empty record for anything that does not look like a DEVMODE — the
+ * part is opaque binary from an arbitrary printer driver, so nothing here may
+ * assume more than the fixed header it is required to start with.
+ *
+ * @param data The raw part bytes.
+ */
+export declare function parsePrinterSettings(data: Uint8Array): PrinterPageSetup;

package/dist/esm/excel/printer-settings.js

@@ -0,0 +1,36 @@
+//#region src/excel/printer-settings.ts
+var DEVICE_NAME_BYTES = 64;
+var OFFSET_SIZE = DEVICE_NAME_BYTES + 4;
+var OFFSET_ORIENTATION = DEVICE_NAME_BYTES + 12;
+var OFFSET_PAPER_SIZE = DEVICE_NAME_BYTES + 14;
+var DM_ORIENTATION = 1;
+var DM_PAPERSIZE = 2;
+/**
+* Read the paper size and orientation out of a `printerSettings#.bin` part.
+*
+* Returns an empty record for anything that does not look like a DEVMODE — the
+* part is opaque binary from an arbitrary printer driver, so nothing here may
+* assume more than the fixed header it is required to start with.
+*
+* @param data The raw part bytes.
+*/
+function parsePrinterSettings(data) {
+	if (data.byteLength < OFFSET_PAPER_SIZE + 2) return {};
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const dmSize = view.getUint16(OFFSET_SIZE, true);
+	if (dmSize < OFFSET_PAPER_SIZE + 2 || dmSize > data.byteLength) return {};
+	const fields = view.getUint32(DEVICE_NAME_BYTES + 8, true);
+	const out = {};
+	if (fields & DM_PAPERSIZE) {
+		const paper = view.getInt16(OFFSET_PAPER_SIZE, true);
+		if (paper > 0) out.paperSize = paper;
+	}
+	if (fields & DM_ORIENTATION) {
+		const orientation = view.getInt16(OFFSET_ORIENTATION, true);
+		if (orientation === 1) out.orientation = "portrait";
+		else if (orientation === 2) out.orientation = "landscape";
+	}
+	return out;
+}
+//#endregion
+export { parsePrinterSettings };

package/dist/esm/excel/rich-value.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Build the `vm` → display-text map for a workbook's rich values.
+ *
+ * All three parts are optional and any of them being absent, malformed or of a
+ * structure this understands nothing about simply yields no entry for that
+ * index — the caller then keeps whatever the cell's `<v>` said.
+ *
+ * @param metadata   `xl/metadata.xml`, or undefined when the package has none.
+ * @param structures `xl/richData/rdrichvaluestructure.xml`.
+ * @param values     `xl/richData/rdrichvalue.xml`.
+ * @returns A map from a cell's 1-based `vm` index to the text to render.
+ */
+export declare function parseRichValueText(metadata: Uint8Array | undefined, structures: Uint8Array | undefined, values: Uint8Array | undefined): ReadonlyMap<number, string>;

package/dist/esm/excel/rich-value.js

@@ -0,0 +1,120 @@
+import { XMLParser } from "fast-xml-parser";
+//#region src/excel/rich-value.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	textNodeName: "#text",
+	parseAttributeValue: false,
+	parseTagValue: false,
+	trimValues: true,
+	removeNSPrefix: true
+});
+/** The metadata type whose future blocks point into the rich-value table. */
+var RICH_VALUE_TYPE = "XLRICHVALUE";
+/**
+* The `_error` structure's `errorType` codes, and only the ones a real document
+* has corroborated. `Spill.xlsx` writes 8 alongside `subType="1"` and
+* `rwOffset="3"`, and the cell three rows down is the one holding the text that
+* blocks the spill — which names the error beyond doubt. The rest of the
+* enumeration is not written down anywhere this code can check, and a wrong
+* error is worse than the stand-in the file already provides, so an unmapped
+* code resolves to nothing.
+*/
+var ERROR_TYPES = new Map([[8, "#SPILL!"]]);
+function nodes(parent, name) {
+	if (typeof parent !== "object" || parent === null) return [];
+	const child = parent[name];
+	if (child === void 0) return [];
+	return (Array.isArray(child) ? child : [child]).filter((n) => typeof n === "object" && n !== null);
+}
+function attr(node, name) {
+	const value = node?.[`@_${name}`];
+	return typeof value === "string" ? value : void 0;
+}
+function intAttr(node, name) {
+	const raw = attr(node, name);
+	if (raw === void 0) return void 0;
+	const n = Number(raw);
+	return Number.isInteger(n) ? n : void 0;
+}
+function textValues(node) {
+	const out = [];
+	const v = node["v"];
+	for (const item of Array.isArray(v) ? v : [v]) if (typeof item === "string") out.push(item);
+	else if (typeof item === "number") out.push(String(item));
+	else if (typeof item === "object" && item !== null) {
+		const text = item["#text"];
+		out.push(typeof text === "string" ? text : "");
+	}
+	return out;
+}
+/**
+* Build the `vm` → display-text map for a workbook's rich values.
+*
+* All three parts are optional and any of them being absent, malformed or of a
+* structure this understands nothing about simply yields no entry for that
+* index — the caller then keeps whatever the cell's `<v>` said.
+*
+* @param metadata   `xl/metadata.xml`, or undefined when the package has none.
+* @param structures `xl/richData/rdrichvaluestructure.xml`.
+* @param values     `xl/richData/rdrichvalue.xml`.
+* @returns A map from a cell's 1-based `vm` index to the text to render.
+*/
+function parseRichValueText(metadata, structures, values) {
+	const out = /* @__PURE__ */ new Map();
+	if (!metadata || !structures || !values) return out;
+	const structureList = parseStructures(structures);
+	if (structureList.length === 0) return out;
+	const richValues = parseValues(values);
+	if (richValues.length === 0) return out;
+	const root = nodes(parser.parse(decoder.decode(metadata)), "metadata")[0];
+	if (!root) return out;
+	const typeNames = nodes(root, "metadataTypes").flatMap((t) => nodes(t, "metadataType")).map((t) => attr(t, "name") ?? "");
+	const futureByType = /* @__PURE__ */ new Map();
+	for (const fm of nodes(root, "futureMetadata")) {
+		const name = attr(fm, "name");
+		if (name === void 0) continue;
+		futureByType.set(name, nodes(fm, "bk").map((bk) => {
+			const rvb = nodes(bk, "extLst").flatMap((ext) => nodes(ext, "ext")).flatMap((ext) => nodes(ext, "rvb"))[0];
+			return intAttr(rvb, "i");
+		}));
+	}
+	const valueMetadata = nodes(root, "valueMetadata").flatMap((vm) => nodes(vm, "bk"));
+	for (const [index, bk] of valueMetadata.entries()) {
+		const rc = nodes(bk, "rc")[0];
+		const typeIndex = intAttr(rc, "t");
+		const blockIndex = intAttr(rc, "v");
+		if (typeIndex === void 0 || blockIndex === void 0) continue;
+		if (typeNames[typeIndex - 1] !== RICH_VALUE_TYPE) continue;
+		const richIndex = futureByType.get(RICH_VALUE_TYPE)?.[blockIndex];
+		if (richIndex === void 0) continue;
+		const text = displayText(richValues[richIndex], structureList);
+		if (text !== void 0) out.set(index + 1, text);
+	}
+	return out;
+}
+/** What one rich value renders as, or undefined when nothing here understands it. */
+function displayText(value, structures) {
+	if (!value) return void 0;
+	const structure = structures[value.structureIndex];
+	if (structure?.type !== "_error") return void 0;
+	const at = structure.keys.indexOf("errorType");
+	if (at < 0) return void 0;
+	const code = Number(value.values[at]);
+	return Number.isInteger(code) ? ERROR_TYPES.get(code) : void 0;
+}
+function parseStructures(part) {
+	return nodes(parser.parse(decoder.decode(part)), "rvStructures").flatMap((r) => nodes(r, "s")).map((s) => ({
+		type: attr(s, "t") ?? "",
+		keys: nodes(s, "k").map((k) => attr(k, "n") ?? "")
+	}));
+}
+function parseValues(part) {
+	return nodes(parser.parse(decoder.decode(part)), "rvData").flatMap((r) => nodes(r, "rv")).map((rv) => ({
+		structureIndex: intAttr(rv, "s") ?? 0,
+		values: textValues(rv)
+	}));
+}
+//#endregion
+export { parseRichValueText };

package/dist/esm/excel/shared-strings-parser.js

@@ -1,7 +1,10 @@
+import { resolveInternalEntities } from "../core/opc/xml-entities.js";
+import { decodeXstring } from "./escaped-text.js";
 import { XMLParser } from "fast-xml-parser";
 //#region src/excel/shared-strings-parser.ts
 var decoder = new TextDecoder("utf-8");
 var parser = new XMLParser({
+	htmlEntities: true,
 	ignoreAttributes: false,
 	attributeNamePrefix: "@_",
 	textNodeName: "#text",
@@ -20,13 +23,13 @@ function capLen(s) {
 * cell limit (32 767 chars).
 */
 function parseSharedStrings(data) {
-	const xml = decoder.decode(data);
+	const xml = resolveInternalEntities(decoder.decode(data));
 	const sst = parser.parse(xml)["sst"];
 	if (!sst || typeof sst !== "object") return {
 		texts: [],
 		runs: []
 	};
-	const siRaw = sst["si"];
+	const siRaw = sst["si"] ?? sst["sstItem"];
 	const items = Array.isArray(siRaw) ? siRaw : siRaw !== void 0 ? [siRaw] : [];
 	const texts = [];
 	const runs = [];
@@ -84,9 +87,10 @@ function richRun(text, rPr) {
 	const p = rPr && typeof rPr === "object" ? rPr : void 0;
 	if (!p) return { text };
 	const out = { text };
-	if (has(p, "b")) out.bold = true;
-	if (has(p, "i")) out.italic = true;
-	if (has(p, "u")) out.underline = true;
+	out.bold = has(p, "b");
+	out.italic = has(p, "i");
+	if (has(p, "u") && attrStr(p["u"], "val") !== "none") out.underline = true;
+	out.strike = has(p, "strike");
 	const color = colorRgb(p["color"]);
 	if (color) out.colorHex = color;
 	const sz = attrNum(p["sz"], "val");
@@ -119,11 +123,11 @@ function colorRgb(node) {
 	return /^[0-9A-Fa-f]{6}$/.test(hex) ? hex.toUpperCase() : void 0;
 }
 function textOf(node) {
-	if (typeof node === "string") return node;
+	if (typeof node === "string") return decodeXstring(node);
 	if (typeof node === "number") return String(node);
 	if (!node || typeof node !== "object") return "";
 	const inner = node["#text"];
-	if (typeof inner === "string") return inner;
+	if (typeof inner === "string") return decodeXstring(inner);
 	if (typeof inner === "number") return String(inner);
 	return "";
 }

package/dist/esm/excel/sheet-drawing.d.ts

@@ -9,6 +9,14 @@ export interface SheetChartRef {
     readonly chartPartPath: string;
     readonly widthPt: number;
     readonly heightPt: number;
+    /**
+     * Where the anchor puts the frame, in points from the grid's top-left. A
+     * chart is anchored over the sheet like any other drawing; placed in the flow
+     * instead it lands at the left margin, below everything, and on whatever page
+     * that turns out to be.
+     */
+    readonly xPt: number;
+    readonly yPt: number;
     /** Anchor top row (0-based) — used only to order charts on the sheet. */
     readonly anchorRow: number;
 }
@@ -21,6 +29,9 @@ export interface SheetPicture {
     readonly imagePartPath: string;
     readonly widthPt: number;
     readonly heightPt: number;
+    /** Where the anchor puts it, in points from the grid's top-left. */
+    readonly xPt: number;
+    readonly yPt: number;
     /** Anchor top row (0-based) — used only to order pictures on the sheet. */
     readonly anchorRow: number;
 }

package/dist/esm/excel/sheet-drawing.js

@@ -1,9 +1,10 @@
 import { emuToPt } from "../core/ir/units.js";
-import "./print-model.js";
+import { columnTwips } from "./print-model.js";
 import { XMLParser } from "fast-xml-parser";
 //#region src/excel/sheet-drawing.ts
 var CHART_URI = "http://schemas.openxmlformats.org/drawingml/2006/chart";
 var parser = new XMLParser({
+	htmlEntities: true,
 	ignoreAttributes: false,
 	attributeNamePrefix: "@_",
 	removeNSPrefix: true,
@@ -47,6 +48,7 @@ function parseSheetDrawing(drawingXml, drawingPartPath, pkg, worksheet) {
 		const chartRelId = chartRelIdOf(a);
 		const picRelId = chartRelId ? void 0 : picRelIdOf(a);
 		if (!chartRelId && !picRelId) continue;
+		if (isHiddenDrawing(a, chartRelId ? "graphicFrame" : "pic")) continue;
 		const from = cellMarker(a["from"]);
 		let widthPt = 0;
 		let heightPt = 0;
@@ -64,12 +66,18 @@ function parseSheetDrawing(drawingXml, drawingPartPath, pkg, worksheet) {
 		}
 		if (widthPt <= 0 || heightPt <= 0) continue;
 		const anchorRow = from?.row ?? 0;
+		const posRaw = kind === "absoluteAnchor" ? a["pos"] : void 0;
+		const posNode = posRaw && typeof posRaw === "object" ? posRaw : void 0;
+		const xPt = posNode ? emuToPt(num(posNode["@_x"]) ?? 0) : from ? spanPt(0, 0, from.col, from.colOffPt, colWidthPt) : 0;
+		const yPt = posNode ? emuToPt(num(posNode["@_y"]) ?? 0) : from ? spanPt(0, 0, from.row, from.rowOffPt, rowHeightPt) : 0;
 		if (chartRelId) {
 			const path = partPathOf(chartRelId);
 			if (path) charts.push({
 				chartPartPath: path,
 				widthPt,
 				heightPt,
+				xPt,
+				yPt,
 				anchorRow
 			});
 		} else if (picRelId) {
@@ -78,6 +86,8 @@ function parseSheetDrawing(drawingXml, drawingPartPath, pkg, worksheet) {
 				imagePartPath: path,
 				widthPt,
 				heightPt,
+				xPt,
+				yPt,
 				anchorRow
 			});
 		}
@@ -89,6 +99,16 @@ function parseSheetDrawing(drawingXml, drawingPartPath, pkg, worksheet) {
 		pictures
 	};
 }
+function isHiddenDrawing(anchor, kind) {
+	const node = anchor[kind];
+	if (!node || typeof node !== "object") return false;
+	const nv = node[kind === "pic" ? "nvPicPr" : "nvGraphicFramePr"];
+	if (!nv || typeof nv !== "object") return false;
+	const cNvPr = nv["cNvPr"];
+	if (!cNvPr || typeof cNvPr !== "object") return false;
+	const hidden = cNvPr["@_hidden"];
+	return hidden === "1" || hidden === "true" || hidden === true;
+}
 function picRelIdOf(anchor) {
 	const pic = anchor["pic"];
 	if (!pic || typeof pic !== "object") return void 0;
@@ -138,8 +158,11 @@ function spanPt(from, fromOffPt, to, toOffPt, trackPt) {
 * track geometry.
 */
 function makeColWidthPt(ws) {
+	const widthPt = (chars) => columnTwips(chars, 105) / TWIPS_PER_PT;
 	return (col) => {
-		for (const c of ws.columns) if (col >= c.min - 1 && col <= c.max - 1) return c.widthChars * 105 / TWIPS_PER_PT;
+		for (const c of ws.columns) if (col >= c.min - 1 && col <= c.max - 1) return widthPt(c.widthChars);
+		if (ws.defaultColWidthChars !== void 0) return widthPt(ws.defaultColWidthChars);
+		if (ws.baseColWidthChars !== void 0) return (columnTwips(ws.baseColWidthChars, 105) + 75) / TWIPS_PER_PT;
 		return 960 / TWIPS_PER_PT;
 	};
 }
@@ -150,7 +173,7 @@ function makeColWidthPt(ws) {
 function makeRowHeightPt(ws) {
 	return (row) => {
 		for (const r of ws.rowHeights) if (r.row === row) return r.heightPt;
-		return 300 / TWIPS_PER_PT;
+		return ws.defaultRowHeightPt ?? 300 / TWIPS_PER_PT;
 	};
 }
 function num(v) {

package/dist/esm/excel/sheet-shape-parser.d.ts

@@ -1,6 +1,7 @@
 import { ShapeBlock } from '../core/document-model/index.js';
 import { ColorResolver } from '../core/drawingml/colors.js';
 import { ParsedWorksheet } from '../core/spreadsheet-model/index.js';
+import { PoNode } from '../core/po-helpers.js';
 /**
  * Parse a drawing's `xdr:sp` shape anchors (§20.5.2.30) into anchor-ordered
  * {@link ShapeBlock}s (E-SHEET W2), reusing the shared DrawingML geometry / fill /
@@ -12,5 +13,56 @@ import { ParsedWorksheet } from '../core/spreadsheet-model/index.js';
  *                   preserveOrder tree the shape readers expect).
  * @param worksheet  The host worksheet, for the column/row track geometry.
  * @param colors     The theme colour resolver threaded into fill/line parsing.
+ * @param themeLineWidths The theme's `a:lnStyleLst` widths in points, which an
+ *                   `<a:lnRef idx>` indexes for a gallery-styled outline.
+ * @param themeFillStyles The theme's `a:fillStyleLst` nodes, which an
+ *                   `<a:fillRef idx>` indexes for a gallery-styled fill.
+ * @param themeEffectStyles The theme's `a:effectStyleLst` nodes, which an
+ *                   `<a:effectRef idx>` indexes for a gallery-styled shadow.
  */
-export declare function parseSheetShapes(drawingXml: Uint8Array, worksheet: ParsedWorksheet, colors: ColorResolver): Array<ShapeBlock>;
+export declare function parseSheetShapes(drawingXml: Uint8Array, worksheet: ParsedWorksheet, colors: ColorResolver, themeLineWidths?: ReadonlyArray<number>, themeFillStyles?: ReadonlyArray<PoNode>, themeEffectStyles?: ReadonlyArray<PoNode>): Array<ShapeBlock>;
+/**
+ * The boxes the diagram frames of a drawing occupy, in document order.
+ *
+ * §20.5.2.16 `xdr:graphicFrame` is how a sheet hosts a diagram: the frame is
+ * anchored like any other drawing and the diagram itself lives in its own
+ * parts. The frame gives the corner its fallback shapes are laid out from —
+ * see {@link parseDiagramShapes}.
+ *
+ * @param drawingXml The drawing part bytes.
+ * @param worksheet  The host worksheet, for the column/row track geometry.
+ * @returns One box per diagram frame, in the order the drawing writes them.
+ */
+export declare function parseDiagramFrames(drawingXml: Uint8Array, worksheet: ParsedWorksheet): Array<AnchorBox>;
+/**
+ * Parse the fallback drawing of a SmartArt diagram (§ MS-ODRAWXML 2.1
+ * `dsp:drawing`) into the shapes it lays out.
+ *
+ * A diagram is FOUR parts of description — data, layout, quick style, colours —
+ * that a renderer is meant to lay out itself, and nobody outside Office does.
+ * The producer therefore also writes what it drew: a plain DrawingML picture of
+ * the result, under `dsp:`, reachable from the drawing part by a
+ * `diagramDrawing` relationship. Reading it is the difference between a diagram
+ * and a blank space — tdf83671_SmartArt_import.xlsx draws three nested circles
+ * where we drew nothing between its "start" and its "end".
+ *
+ * The shapes' `a:xfrm` offsets are relative to the frame the diagram sits in,
+ * so the frame's own corner is all that has to be added.
+ *
+ * @param diagramXml The `dsp:drawing` part bytes.
+ * @param frame      The box the graphic frame occupies on the page.
+ * @param colors     The theme colour resolver.
+ * @param themeLineWidths   `a:lnStyleLst` widths, indexed by `<a:lnRef idx>`.
+ * @param themeFillStyles   `a:fillStyleLst` nodes, indexed by `<a:fillRef idx>`.
+ * @param themeEffectStyles `a:effectStyleLst` nodes, indexed by `<a:effectRef idx>`.
+ * @returns The shapes, in the order the diagram stacks them.
+ */
+export declare function parseDiagramShapes(diagramXml: Uint8Array, frame: AnchorBox, colors: ColorResolver, themeLineWidths?: ReadonlyArray<number>, themeFillStyles?: ReadonlyArray<PoNode>, themeEffectStyles?: ReadonlyArray<PoNode>): Array<ShapeBlock>;
+export interface AnchorBox {
+    readonly widthPt: number;
+    readonly heightPt: number;
+    readonly anchorRow: number;
+    /** Distance from the sheet's top-left corner to the shape's, in points. */
+    readonly xPt: number;
+    readonly yPt: number;
+}