ooxml.js 2.6.19 → 2.8.0

package/dist/typed/xlsx/styles.cjs

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_typed_util = require("../util.cjs");
 const require_typed_xlsx_number_format = require("./number-format.cjs");
+let document_schema_js = require("document-schema.js");
 //#region src/typed/xlsx/styles.ts
 const STYLES_PATH = "xl/styles.xml";
 const GENERAL_NUM_FMT_ID = 0;
@@ -17,37 +18,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 = require_typed_util.childrenWithTag(container, colorTag)[0];
+	if (colorEl === void 0) return;
+	const raw = require_typed_util.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 (0, document_schema_js.rgbHexToColor)(hex);
+	} catch {
+		return;
+	}
+}
+function readFillBackground(fill) {
+	const patternFill = require_typed_util.childrenWithTag(fill, "patternFill")[0];
+	if (patternFill === void 0 || require_typed_util.attr(patternFill, "patternType") !== "solid") return;
+	return readColorRgb(patternFill, "fgColor") ?? readColorRgb(patternFill, "bgColor");
+}
+function readFills(styleSheet) {
+	const fillsEl = require_typed_util.childrenWithTag(styleSheet, "fills")[0];
+	if (fillsEl === void 0) return [];
+	return require_typed_util.childrenWithTag(fillsEl, "fill").map(readFillBackground);
+}
+function readBorderEdge(border, edge) {
+	const edgeEl = require_typed_util.childrenWithTag(border, edge)[0];
+	if (edgeEl === void 0) return;
+	const styleToken = require_typed_util.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 = require_typed_util.childrenWithTag(styleSheet, "borders")[0];
+	if (bordersEl === void 0) return [];
+	return require_typed_util.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 = require_typed_util.attr(alignment, "horizontal");
+	if (value === "left" || value === "center" || value === "right" || value === "justify") return value;
+}
+function readVerticalAlignment(alignment) {
+	const value = require_typed_util.attr(alignment, "vertical");
+	if (value === "top") return "top";
+	if (value === "center") return "middle";
+}
+function readAlignment(xf) {
+	const alignment = require_typed_util.childrenWithTag(xf, "alignment")[0];
+	if (alignment === void 0) return {};
+	return {
+		alignment: readHorizontalAlignment(alignment),
+		verticalAlignment: readVerticalAlignment(alignment)
+	};
+}
+function readCellStyles(pkg) {
 	const styleSheet = require_typed_util.rootElement(pkg.parts[STYLES_PATH]);
 	if (styleSheet === void 0) return [];
 	const cellXfsEl = require_typed_util.childrenWithTag(styleSheet, "cellXfs")[0];
 	if (cellXfsEl === void 0) return [];
 	const codes = readNumberFormatCodesById(styleSheet);
+	const fills = readFills(styleSheet);
+	const borders = readBorders(styleSheet);
 	return require_typed_util.childrenWithTag(cellXfsEl, "xf").map((xf) => {
-		const raw = require_typed_util.attr(xf, "numFmtId");
-		const id = raw === void 0 ? 0 : Number.parseInt(raw, 10);
-		return Number.isInteger(id) ? codes.get(id) : void 0;
+		const numFmtRaw = require_typed_util.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(require_typed_util.attr(xf, "fillId"));
+		if (fillId !== void 0) entry.background = fills[fillId];
+		const borderId = parseChildIndex(require_typed_util.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:${(0, document_schema_js.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"}:${(0, document_schema_js.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;
 	}
@@ -55,9 +268,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,
@@ -65,9 +287,60 @@ var CellFormatTable = class {
 		});
 		return id;
 	}
+	internFill(background) {
+		const rgb = (0, document_schema_js.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 = (0, document_schema_js.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
 exports.CellFormatTable = CellFormatTable;
 exports.DEFAULT_CELL_FORMAT_INDEX = DEFAULT_CELL_FORMAT_INDEX;
 exports.GENERAL_NUM_FMT_ID = GENERAL_NUM_FMT_ID;
+exports.RESERVED_BORDER_INDICES = RESERVED_BORDER_INDICES;
+exports.RESERVED_FILL_INDICES = RESERVED_FILL_INDICES;
 exports.readCellFormatCodes = readCellFormatCodes;
+exports.readCellStyles = readCellStyles;

package/dist/typed/xlsx/styles.d.cts

@@ -1,21 +1,87 @@
 import { r as Package } from "../../package-L24lkba-.cjs";
 import { CellNumberFormat } from "./number-format.cjs";
+import { Alignment, Color, ContentCellBorders } from "document-schema.js";
 //#region src/typed/xlsx/styles.d.ts
 declare const GENERAL_NUM_FMT_ID = 0;
+interface CellStyleEntry {
+  numberFormatCode?: string;
+  background?: Color;
+  borders?: ContentCellBorders;
+  alignment?: Alignment;
+  verticalAlignment?: 'top' | 'middle' | 'bottom';
+}
+declare function readCellStyles(pkg: Package): readonly CellStyleEntry[];
 declare function readCellFormatCodes(pkg: Package): readonly (string | undefined)[];
 declare const DEFAULT_CELL_FORMAT_INDEX = 0;
 interface DeclaredNumberFormat {
   id: number;
   code: string;
 }
+interface CellFormatDecoration {
+  background?: Color;
+  borders?: ContentCellBorders;
+  alignment?: Alignment;
+  verticalAlignment?: 'top' | 'middle' | 'bottom';
+}
+interface DeclaredFill {
+  patternType: 'none' | 'gray125' | 'solid';
+  rgb?: string;
+}
+interface DeclaredBorder {
+  edges: {
+    left?: {
+      style: string;
+      rgb: string;
+    };
+    right?: {
+      style: string;
+      rgb: string;
+    };
+    top?: {
+      style: string;
+      rgb: string;
+    };
+    bottom?: {
+      style: string;
+      rgb: string;
+    };
+  };
+}
+interface CellFormatRecord {
+  numFmtId: number;
+  fillId: number;
+  borderId: number;
+  alignment?: {
+    horizontal?: Alignment;
+    vertical?: 'top' | 'middle' | 'bottom';
+  };
+}
 declare class CellFormatTable {
   private readonly indexBySignature;
-  private readonly numFmtIdByIndex;
+  private readonly records;
   private readonly declared;
-  intern(format: CellNumberFormat): number;
+  private readonly fillIndexByRgb;
+  private readonly fills;
+  private readonly borderIndexBySignature;
+  private readonly borders;
+  intern(format: CellNumberFormat, decoration?: CellFormatDecoration): number;
   declarations(): readonly DeclaredNumberFormat[];
   cellFormats(): readonly number[];
-  private declare;
+  cellFormatRecords(): readonly CellFormatRecord[];
+  fillDeclarations(): readonly DeclaredFill[];
+  borderDeclarations(): readonly DeclaredBorder[];
+  private declareNumberFormat;
+  private internFill;
+  private internBorder;
 }
+declare const RESERVED_FILL_INDICES: {
+  readonly none: 0;
+  readonly gray125: 1;
+  readonly firstReal: 2;
+};
+declare const RESERVED_BORDER_INDICES: {
+  readonly empty: 0;
+  readonly firstReal: 1;
+};
 //#endregion
-export { CellFormatTable, DEFAULT_CELL_FORMAT_INDEX, DeclaredNumberFormat, GENERAL_NUM_FMT_ID, readCellFormatCodes };
+export { CellFormatDecoration, CellFormatRecord, CellFormatTable, CellStyleEntry, DEFAULT_CELL_FORMAT_INDEX, DeclaredBorder, DeclaredFill, DeclaredNumberFormat, GENERAL_NUM_FMT_ID, RESERVED_BORDER_INDICES, RESERVED_FILL_INDICES, readCellFormatCodes, readCellStyles };

package/dist/typed/xlsx/styles.d.ts

@@ -1,21 +1,87 @@
 import { r as Package } from "../../package-BUojjTXf.js";
 import { CellNumberFormat } from "./number-format.js";
+import { Alignment, Color, ContentCellBorders } from "document-schema.js";
 //#region src/typed/xlsx/styles.d.ts
 declare const GENERAL_NUM_FMT_ID = 0;
+interface CellStyleEntry {
+  numberFormatCode?: string;
+  background?: Color;
+  borders?: ContentCellBorders;
+  alignment?: Alignment;
+  verticalAlignment?: 'top' | 'middle' | 'bottom';
+}
+declare function readCellStyles(pkg: Package): readonly CellStyleEntry[];
 declare function readCellFormatCodes(pkg: Package): readonly (string | undefined)[];
 declare const DEFAULT_CELL_FORMAT_INDEX = 0;
 interface DeclaredNumberFormat {
   id: number;
   code: string;
 }
+interface CellFormatDecoration {
+  background?: Color;
+  borders?: ContentCellBorders;
+  alignment?: Alignment;
+  verticalAlignment?: 'top' | 'middle' | 'bottom';
+}
+interface DeclaredFill {
+  patternType: 'none' | 'gray125' | 'solid';
+  rgb?: string;
+}
+interface DeclaredBorder {
+  edges: {
+    left?: {
+      style: string;
+      rgb: string;
+    };
+    right?: {
+      style: string;
+      rgb: string;
+    };
+    top?: {
+      style: string;
+      rgb: string;
+    };
+    bottom?: {
+      style: string;
+      rgb: string;
+    };
+  };
+}
+interface CellFormatRecord {
+  numFmtId: number;
+  fillId: number;
+  borderId: number;
+  alignment?: {
+    horizontal?: Alignment;
+    vertical?: 'top' | 'middle' | 'bottom';
+  };
+}
 declare class CellFormatTable {
   private readonly indexBySignature;
-  private readonly numFmtIdByIndex;
+  private readonly records;
   private readonly declared;
-  intern(format: CellNumberFormat): number;
+  private readonly fillIndexByRgb;
+  private readonly fills;
+  private readonly borderIndexBySignature;
+  private readonly borders;
+  intern(format: CellNumberFormat, decoration?: CellFormatDecoration): number;
   declarations(): readonly DeclaredNumberFormat[];
   cellFormats(): readonly number[];
-  private declare;
+  cellFormatRecords(): readonly CellFormatRecord[];
+  fillDeclarations(): readonly DeclaredFill[];
+  borderDeclarations(): readonly DeclaredBorder[];
+  private declareNumberFormat;
+  private internFill;
+  private internBorder;
 }
+declare const RESERVED_FILL_INDICES: {
+  readonly none: 0;
+  readonly gray125: 1;
+  readonly firstReal: 2;
+};
+declare const RESERVED_BORDER_INDICES: {
+  readonly empty: 0;
+  readonly firstReal: 1;
+};
 //#endregion
-export { CellFormatTable, DEFAULT_CELL_FORMAT_INDEX, DeclaredNumberFormat, GENERAL_NUM_FMT_ID, readCellFormatCodes };
+export { CellFormatDecoration, CellFormatRecord, CellFormatTable, CellStyleEntry, DEFAULT_CELL_FORMAT_INDEX, DeclaredBorder, DeclaredFill, DeclaredNumberFormat, GENERAL_NUM_FMT_ID, RESERVED_BORDER_INDICES, RESERVED_FILL_INDICES, readCellFormatCodes, readCellStyles };