ooxml.js 2.6.19 → 2.8.0

package/dist/typed/xlsx/styles.js

@@ -1,5 +1,6 @@
 import { attr, childrenWithTag, decodeEntities, rootElement } from "../util.js";
 import { BUILTIN_NUMBER_FORMATS } from "./number-format.js";
+import { colorToRgbHex, rgbHexToColor } from "document-schema.js";
 //#region src/typed/xlsx/styles.ts
 const STYLES_PATH = "xl/styles.xml";
 const GENERAL_NUM_FMT_ID = 0;
@@ -16,37 +17,249 @@ function readNumberFormatCodesById(styleSheet) {
 	}
 	return codes;
 }
-function readCellFormatCodes(pkg) {
+const BORDER_WIDTH_PT = {
+	hair: .5,
+	thin: .75,
+	medium: 1.5,
+	thick: 2.25
+};
+const XLSX_BORDER_STYLE = {
+	thin: {
+		weight: "thin",
+		pattern: "solid"
+	},
+	medium: {
+		weight: "medium",
+		pattern: "solid"
+	},
+	thick: {
+		weight: "thick",
+		pattern: "solid"
+	},
+	hair: {
+		weight: "hair",
+		pattern: "solid"
+	},
+	dashed: {
+		weight: "thin",
+		pattern: "dashed"
+	},
+	dotted: {
+		weight: "thin",
+		pattern: "dotted"
+	},
+	double: {
+		weight: "thin",
+		pattern: "double"
+	},
+	mediumDashed: {
+		weight: "medium",
+		pattern: "dashed"
+	},
+	dashDot: {
+		weight: "thin",
+		pattern: "dashed"
+	},
+	mediumDashDot: {
+		weight: "medium",
+		pattern: "dashed"
+	},
+	dashDotDot: {
+		weight: "thin",
+		pattern: "dashed"
+	},
+	mediumDashDotDot: {
+		weight: "medium",
+		pattern: "dashed"
+	},
+	slantDashDot: {
+		weight: "medium",
+		pattern: "dashed"
+	}
+};
+const BORDER_WEIGHT_UPPER_PT = {
+	hair: .625,
+	thin: 1.125,
+	medium: 1.875
+};
+function readColorRgb(container, colorTag) {
+	const colorEl = childrenWithTag(container, colorTag)[0];
+	if (colorEl === void 0) return;
+	const raw = attr(colorEl, "rgb");
+	if (raw === void 0) return;
+	const hex = raw.length >= 6 ? raw.slice(-6) : raw;
+	if (!/^[0-9a-fA-F]{6}$/.test(hex)) return;
+	try {
+		return rgbHexToColor(hex);
+	} catch {
+		return;
+	}
+}
+function readFillBackground(fill) {
+	const patternFill = childrenWithTag(fill, "patternFill")[0];
+	if (patternFill === void 0 || attr(patternFill, "patternType") !== "solid") return;
+	return readColorRgb(patternFill, "fgColor") ?? readColorRgb(patternFill, "bgColor");
+}
+function readFills(styleSheet) {
+	const fillsEl = childrenWithTag(styleSheet, "fills")[0];
+	if (fillsEl === void 0) return [];
+	return childrenWithTag(fillsEl, "fill").map(readFillBackground);
+}
+function readBorderEdge(border, edge) {
+	const edgeEl = childrenWithTag(border, edge)[0];
+	if (edgeEl === void 0) return;
+	const styleToken = attr(edgeEl, "style");
+	if (styleToken === void 0 || styleToken === "none") return;
+	const resolved = XLSX_BORDER_STYLE[styleToken];
+	if (resolved === void 0) return;
+	const color = readColorRgb(edgeEl, "color");
+	if (color === void 0) return;
+	const result = {
+		color,
+		widthPt: BORDER_WIDTH_PT[resolved.weight]
+	};
+	if (resolved.pattern !== "solid") result.style = resolved.pattern;
+	return result;
+}
+function readBorders(styleSheet) {
+	const bordersEl = childrenWithTag(styleSheet, "borders")[0];
+	if (bordersEl === void 0) return [];
+	return childrenWithTag(bordersEl, "border").map((border) => {
+		const left = readBorderEdge(border, "left");
+		const right = readBorderEdge(border, "right");
+		const top = readBorderEdge(border, "top");
+		const bottom = readBorderEdge(border, "bottom");
+		if (left === void 0 && right === void 0 && top === void 0 && bottom === void 0) return;
+		const result = {};
+		if (left !== void 0) result.left = left;
+		if (right !== void 0) result.right = right;
+		if (top !== void 0) result.top = top;
+		if (bottom !== void 0) result.bottom = bottom;
+		return result;
+	});
+}
+function readHorizontalAlignment(alignment) {
+	const value = attr(alignment, "horizontal");
+	if (value === "left" || value === "center" || value === "right" || value === "justify") return value;
+}
+function readVerticalAlignment(alignment) {
+	const value = attr(alignment, "vertical");
+	if (value === "top") return "top";
+	if (value === "center") return "middle";
+}
+function readAlignment(xf) {
+	const alignment = childrenWithTag(xf, "alignment")[0];
+	if (alignment === void 0) return {};
+	return {
+		alignment: readHorizontalAlignment(alignment),
+		verticalAlignment: readVerticalAlignment(alignment)
+	};
+}
+function readCellStyles(pkg) {
 	const styleSheet = rootElement(pkg.parts[STYLES_PATH]);
 	if (styleSheet === void 0) return [];
 	const cellXfsEl = childrenWithTag(styleSheet, "cellXfs")[0];
 	if (cellXfsEl === void 0) return [];
 	const codes = readNumberFormatCodesById(styleSheet);
+	const fills = readFills(styleSheet);
+	const borders = readBorders(styleSheet);
 	return childrenWithTag(cellXfsEl, "xf").map((xf) => {
-		const raw = attr(xf, "numFmtId");
-		const id = raw === void 0 ? 0 : Number.parseInt(raw, 10);
-		return Number.isInteger(id) ? codes.get(id) : void 0;
+		const numFmtRaw = attr(xf, "numFmtId");
+		const numFmtId = numFmtRaw === void 0 ? 0 : Number.parseInt(numFmtRaw, 10);
+		const entry = {};
+		if (Number.isInteger(numFmtId)) {
+			const code = codes.get(numFmtId);
+			if (code !== void 0) entry.numberFormatCode = code;
+		}
+		const fillId = parseChildIndex(attr(xf, "fillId"));
+		if (fillId !== void 0) entry.background = fills[fillId];
+		const borderId = parseChildIndex(attr(xf, "borderId"));
+		if (borderId !== void 0) entry.borders = borders[borderId];
+		const { alignment, verticalAlignment } = readAlignment(xf);
+		if (alignment !== void 0) entry.alignment = alignment;
+		if (verticalAlignment !== void 0) entry.verticalAlignment = verticalAlignment;
+		return entry;
 	});
 }
+function parseChildIndex(value) {
+	if (value === void 0) return;
+	const n = Number.parseInt(value, 10);
+	return Number.isInteger(n) ? n : void 0;
+}
+function readCellFormatCodes(pkg) {
+	return readCellStyles(pkg).map((entry) => entry.numberFormatCode);
+}
 const FIRST_CUSTOM_NUM_FMT_ID = 164;
 const DEFAULT_CELL_FORMAT_INDEX = 0;
-function signatureOf(format) {
+const NONE_FILL_INDEX = 0;
+const GRAY125_FILL_INDEX = 1;
+const FIRST_REAL_FILL_INDEX = 2;
+const EMPTY_BORDER_INDEX = 0;
+const FIRST_REAL_BORDER_INDEX = 1;
+function signatureOfNumberFormat(format) {
 	return format.kind === "builtin" ? `builtin:${format.id}` : `custom:${format.code}`;
 }
+const EMPTY_DECORATION = {};
+function signatureOfDecoration(decoration) {
+	let sig = "";
+	if (decoration.background !== void 0) sig += `|bg:${colorToRgbHex(decoration.background)}`;
+	const borders = decoration.borders;
+	if (borders !== void 0) for (const edge of [
+		"left",
+		"right",
+		"top",
+		"bottom"
+	]) {
+		const border = borders[edge];
+		if (border !== void 0) sig += `|${edge}:${border.style ?? "solid"}:${colorToRgbHex(border.color)}:${border.widthPt.toFixed(4)}`;
+	}
+	if (decoration.alignment !== void 0) sig += `|h:${decoration.alignment}`;
+	if (decoration.verticalAlignment !== void 0) sig += `|v:${decoration.verticalAlignment}`;
+	return sig;
+}
+function borderToXlsxStyle(border) {
+	switch (border.style) {
+		case "double": return "double";
+		case "dotted": return "dotted";
+		case "dashed": return border.widthPt >= BORDER_WEIGHT_UPPER_PT.thin ? "mediumDashed" : "dashed";
+		case "solid":
+		case void 0:
+			if (border.widthPt < BORDER_WEIGHT_UPPER_PT.hair) return "hair";
+			if (border.widthPt < BORDER_WEIGHT_UPPER_PT.thin) return "thin";
+			if (border.widthPt < BORDER_WEIGHT_UPPER_PT.medium) return "medium";
+			return "thick";
+	}
+}
 var CellFormatTable = class {
-	indexBySignature = /* @__PURE__ */ new Map([[signatureOf({
+	indexBySignature = /* @__PURE__ */ new Map([[signatureOfNumberFormat({
 		kind: "builtin",
 		id: 0
-	}), 0]]);
-	numFmtIdByIndex = [0];
+	}) + signatureOfDecoration(EMPTY_DECORATION), 0]]);
+	records = [{
+		numFmtId: 0,
+		fillId: NONE_FILL_INDEX,
+		borderId: EMPTY_BORDER_INDEX
+	}];
 	declared = [];
-	intern(format) {
-		const signature = signatureOf(format);
+	fillIndexByRgb = /* @__PURE__ */ new Map();
+	fills = [{ patternType: "none" }, { patternType: "gray125" }];
+	borderIndexBySignature = /* @__PURE__ */ new Map();
+	borders = [{ edges: {} }];
+	intern(format, decoration = EMPTY_DECORATION) {
+		const signature = signatureOfNumberFormat(format) + signatureOfDecoration(decoration);
 		const existing = this.indexBySignature.get(signature);
 		if (existing !== void 0) return existing;
-		const numFmtId = format.kind === "builtin" ? format.id : this.declare(format.code);
-		const index = this.numFmtIdByIndex.length;
-		this.numFmtIdByIndex.push(numFmtId);
+		const record = {
+			numFmtId: format.kind === "builtin" ? format.id : this.declareNumberFormat(format.code),
+			fillId: decoration.background === void 0 ? NONE_FILL_INDEX : this.internFill(decoration.background),
+			borderId: decoration.borders === void 0 ? EMPTY_BORDER_INDEX : this.internBorder(decoration.borders)
+		};
+		if (decoration.alignment !== void 0 || decoration.verticalAlignment !== void 0) record.alignment = {
+			horizontal: decoration.alignment,
+			vertical: decoration.verticalAlignment
+		};
+		const index = this.records.length;
+		this.records.push(record);
 		this.indexBySignature.set(signature, index);
 		return index;
 	}
@@ -54,9 +267,18 @@ var CellFormatTable = class {
 		return this.declared;
 	}
 	cellFormats() {
-		return this.numFmtIdByIndex;
+		return this.records.map((record) => record.numFmtId);
 	}
-	declare(code) {
+	cellFormatRecords() {
+		return this.records;
+	}
+	fillDeclarations() {
+		return this.fills;
+	}
+	borderDeclarations() {
+		return this.borders;
+	}
+	declareNumberFormat(code) {
 		const id = FIRST_CUSTOM_NUM_FMT_ID + this.declared.length;
 		this.declared.push({
 			id,
@@ -64,6 +286,54 @@ var CellFormatTable = class {
 		});
 		return id;
 	}
+	internFill(background) {
+		const rgb = colorToRgbHex(background);
+		const existing = this.fillIndexByRgb.get(rgb);
+		if (existing !== void 0) return existing;
+		const index = this.fills.length;
+		this.fills.push({
+			patternType: "solid",
+			rgb
+		});
+		this.fillIndexByRgb.set(rgb, index);
+		return index;
+	}
+	internBorder(borders) {
+		const edges = {};
+		let signature = "";
+		for (const edge of [
+			"left",
+			"right",
+			"top",
+			"bottom"
+		]) {
+			const border = borders[edge];
+			if (border !== void 0) {
+				const style = borderToXlsxStyle(border);
+				const rgb = colorToRgbHex(border.color);
+				edges[edge] = {
+					style,
+					rgb
+				};
+				signature += `|${edge}:${style}:${rgb}`;
+			}
+		}
+		const existing = this.borderIndexBySignature.get(signature);
+		if (existing !== void 0) return existing;
+		const index = this.borders.length;
+		this.borders.push({ edges });
+		this.borderIndexBySignature.set(signature, index);
+		return index;
+	}
+};
+const RESERVED_FILL_INDICES = {
+	none: NONE_FILL_INDEX,
+	gray125: GRAY125_FILL_INDEX,
+	firstReal: FIRST_REAL_FILL_INDEX
+};
+const RESERVED_BORDER_INDICES = {
+	empty: EMPTY_BORDER_INDEX,
+	firstReal: FIRST_REAL_BORDER_INDEX
 };
 //#endregion
-export { CellFormatTable, DEFAULT_CELL_FORMAT_INDEX, GENERAL_NUM_FMT_ID, readCellFormatCodes };
+export { CellFormatTable, DEFAULT_CELL_FORMAT_INDEX, GENERAL_NUM_FMT_ID, RESERVED_BORDER_INDICES, RESERVED_FILL_INDICES, readCellFormatCodes, readCellStyles };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ooxml.js",
-  "version": "2.6.19",
+  "version": "2.8.0",
   "description": "Type-safe, lossless round-trip conversion between OOXML packages (docx, pptx, xlsx) and JSON, built on Zod 4 codecs.",
   "type": "module",
   "repository": {