ooxml.js 6.1.0 → 6.2.0

package/dist/typed/xlsx/conditional-format.js

@@ -0,0 +1,516 @@
+import { parseXml } from "../../xml/parse.js";
+import { buildXml } from "../../xml/build.js";
+import { el, txt } from "../../xml/fragment.js";
+import { encodeXmlText } from "../../xml/entities.js";
+import { attr, childrenWithTag, decodeEntities, textContent } from "../util.js";
+import { readXmlBool, writeXmlBool } from "./util.js";
+import { colorFromElement, readColorRgb } from "./styles.js";
+import { captureResidualAttributes, residualAttributesFor } from "./rule-residue.js";
+import { formatSqref, parseSqref } from "./sqref.js";
+import { colorToRgbHex } from "document-schema.js";
+//#region src/typed/xlsx/conditional-format.ts
+const CF_RULE_MANAGED_ATTRIBUTES = /* @__PURE__ */ new Set([
+	"type",
+	"dxfId",
+	"priority",
+	"stopIfTrue",
+	"operator",
+	"text",
+	"rank",
+	"percent",
+	"bottom",
+	"aboveAverage",
+	"equalAverage",
+	"stdDev",
+	"timePeriod",
+	"iconSet",
+	"reverse",
+	"showValue"
+]);
+function readConditionalFormats(worksheet, dxfs) {
+	const formats = [];
+	const residueElements = [];
+	for (const wrapper of childrenWithTag(worksheet, "conditionalFormatting")) {
+		const ranges = parseSqref(attr(wrapper, "sqref"));
+		for (const cfRule of childrenWithTag(wrapper, "cfRule")) {
+			const promoted = ranges.length === 0 ? void 0 : readCfRule(cfRule, ranges, dxfs);
+			if (promoted === void 0) {
+				residueElements.push({
+					type: "element",
+					tag: "conditionalFormatting",
+					attributes: wrapper.attributes,
+					children: [cfRule]
+				});
+				continue;
+			}
+			formats.push(promoted);
+		}
+	}
+	return {
+		formats,
+		residueElements
+	};
+}
+function readCommonFields(cfRule, ranges) {
+	const result = { ranges: [...ranges] };
+	const priorityRaw = attr(cfRule, "priority");
+	if (priorityRaw !== void 0) {
+		const priority = Number.parseInt(priorityRaw, 10);
+		if (Number.isInteger(priority)) result.priority = priority;
+	}
+	if (readXmlBool(attr(cfRule, "stopIfTrue"))) result.stopIfTrue = true;
+	const source = captureResidualAttributes(cfRule, CF_RULE_MANAGED_ATTRIBUTES);
+	if (source !== void 0) result.source = source;
+	return result;
+}
+function readFormula(cfRule, index) {
+	const formulaEl = childrenWithTag(cfRule, "formula")[index];
+	return formulaEl === void 0 ? void 0 : textContent(formulaEl);
+}
+function isSheetRuleOperator(value) {
+	return value === "between" || value === "notBetween" || value === "equal" || value === "notEqual" || value === "greaterThan" || value === "greaterThanOrEqual" || value === "lessThan" || value === "lessThanOrEqual";
+}
+const TEXT_PREDICATE_TYPES = /* @__PURE__ */ new Set([
+	"containsText",
+	"notContainsText",
+	"beginsWith",
+	"endsWith"
+]);
+function isTextPredicateType(value) {
+	return value !== void 0 && TEXT_PREDICATE_TYPES.has(value);
+}
+const OPERAND_FREE_TYPES = /* @__PURE__ */ new Set([
+	"containsBlanks",
+	"notContainsBlanks",
+	"containsErrors",
+	"notContainsErrors",
+	"uniqueValues",
+	"duplicateValues"
+]);
+function isOperandFreeType(value) {
+	return value !== void 0 && OPERAND_FREE_TYPES.has(value);
+}
+const TIME_PERIODS = /* @__PURE__ */ new Set([
+	"yesterday",
+	"today",
+	"tomorrow",
+	"last7Days",
+	"thisMonth",
+	"lastMonth",
+	"nextMonth",
+	"thisWeek",
+	"lastWeek",
+	"nextWeek"
+]);
+function isTimePeriod(value) {
+	return value !== void 0 && TIME_PERIODS.has(value);
+}
+function isCfvoType(value) {
+	return value === "num" || value === "percent" || value === "max" || value === "min" || value === "formula" || value === "percentile";
+}
+function readCfvo(cfvoEl) {
+	const type = attr(cfvoEl, "type");
+	if (!isCfvoType(type)) return;
+	if (type === "min" || type === "max") return { type };
+	const valRaw = attr(cfvoEl, "val");
+	if (valRaw === void 0) return;
+	return {
+		type,
+		value: decodeEntities(valRaw)
+	};
+}
+function readColorScaleStops(colorScaleEl) {
+	const cfvoEls = childrenWithTag(colorScaleEl, "cfvo");
+	const colorEls = childrenWithTag(colorScaleEl, "color");
+	if (cfvoEls.length !== colorEls.length || cfvoEls.length < 2 || cfvoEls.length > 3) return;
+	const stops = [];
+	for (let index = 0; index < cfvoEls.length; index++) {
+		const cfvoEl = cfvoEls[index];
+		const colorEl = colorEls[index];
+		if (cfvoEl === void 0 || colorEl === void 0) return;
+		const value = readCfvo(cfvoEl);
+		const color = colorFromElement(colorEl);
+		if (value === void 0 || color === void 0) return;
+		stops.push({
+			value,
+			color
+		});
+	}
+	return stops;
+}
+function readDataBar(dataBarEl) {
+	const cfvoEls = childrenWithTag(dataBarEl, "cfvo");
+	const minEl = cfvoEls[0];
+	const maxEl = cfvoEls[1];
+	const min = minEl === void 0 ? void 0 : readCfvo(minEl);
+	const max = maxEl === void 0 ? void 0 : readCfvo(maxEl);
+	const color = colorFromElement(childrenWithTag(dataBarEl, "color")[0]);
+	if (min === void 0 || max === void 0 || color === void 0) return;
+	const result = {
+		min,
+		max,
+		color
+	};
+	const showValueRaw = attr(dataBarEl, "showValue");
+	if (showValueRaw !== void 0 && !readXmlBool(showValueRaw)) result.showValue = false;
+	return result;
+}
+const DEFAULT_ICON_SET_TYPE = "3TrafficLights1";
+function readIconSet(iconSetEl) {
+	const thresholds = [];
+	for (const cfvoEl of childrenWithTag(iconSetEl, "cfvo")) {
+		const value = readCfvo(cfvoEl);
+		if (value === void 0) return;
+		thresholds.push(value);
+	}
+	if (thresholds.length === 0) return;
+	const result = {
+		iconSetType: attr(iconSetEl, "iconSet") ?? DEFAULT_ICON_SET_TYPE,
+		thresholds
+	};
+	if (readXmlBool(attr(iconSetEl, "reverse"))) result.reverse = true;
+	const showValueRaw = attr(iconSetEl, "showValue");
+	if (showValueRaw !== void 0 && !readXmlBool(showValueRaw)) result.showValue = false;
+	return result;
+}
+function styleFromDxf(dxf) {
+	const fontEl = childrenWithTag(dxf, "font")[0];
+	const textColor = fontEl === void 0 ? void 0 : readColorRgb(fontEl, "color");
+	const fillEl = childrenWithTag(dxf, "fill")[0];
+	const patternFillEl = fillEl === void 0 ? void 0 : childrenWithTag(fillEl, "patternFill")[0];
+	const background = patternFillEl === void 0 ? void 0 : readColorRgb(patternFillEl, "bgColor");
+	const residueChildren = dxfResidueChildren(dxf, textColor !== void 0, background !== void 0);
+	const style = {};
+	if (textColor !== void 0) style.textColor = textColor;
+	if (background !== void 0) style.background = background;
+	if (residueChildren.length > 0) style.source = {
+		format: "xlsx",
+		xml: buildXml(residueChildren)
+	};
+	return style.textColor === void 0 && style.background === void 0 && style.source === void 0 ? void 0 : style;
+}
+function withoutChildTag(element, tag) {
+	const remaining = element.children.filter((child) => !(child.type === "element" && child.tag === tag));
+	if (remaining.length === 0 && element.attributes.length === 0) return;
+	return {
+		...element,
+		children: remaining
+	};
+}
+function fillResidue(fillEl) {
+	const patternFillEl = childrenWithTag(fillEl, "patternFill")[0];
+	const otherFillChildren = fillEl.children.filter((child) => !(child.type === "element" && child.tag === "patternFill"));
+	if (patternFillEl === void 0) return otherFillChildren.length === 0 && fillEl.attributes.length === 0 ? void 0 : {
+		...fillEl,
+		children: otherFillChildren
+	};
+	const patternFillResidue = withoutChildTag(patternFillEl, "bgColor");
+	if (patternFillResidue === void 0) return otherFillChildren.length === 0 && fillEl.attributes.length === 0 ? void 0 : {
+		...fillEl,
+		children: otherFillChildren
+	};
+	return {
+		...fillEl,
+		children: [patternFillResidue, ...otherFillChildren]
+	};
+}
+function dxfResidueChildren(dxf, textColorCaptured, backgroundCaptured) {
+	const residue = [];
+	for (const child of dxf.children) {
+		if (child.type !== "element") continue;
+		if (child.tag === "font" && textColorCaptured) {
+			const remainder = withoutChildTag(child, "color");
+			if (remainder !== void 0) residue.push(remainder);
+			continue;
+		}
+		if (child.tag === "fill" && backgroundCaptured) {
+			const remainder = fillResidue(child);
+			if (remainder !== void 0) residue.push(remainder);
+			continue;
+		}
+		residue.push(child);
+	}
+	return residue;
+}
+function resolveStyle(cfRule, dxfs) {
+	const dxfIdRaw = attr(cfRule, "dxfId");
+	if (dxfIdRaw === void 0) return;
+	const dxfId = Number.parseInt(dxfIdRaw, 10);
+	const dxf = Number.isInteger(dxfId) ? dxfs[dxfId] : void 0;
+	return dxf === void 0 ? void 0 : styleFromDxf(dxf);
+}
+function readCfRule(cfRule, ranges, dxfs) {
+	const type = attr(cfRule, "type");
+	const common = readCommonFields(cfRule, ranges);
+	const style = resolveStyle(cfRule, dxfs);
+	const styleField = style === void 0 ? {} : { style };
+	if (type === "cellIs") {
+		const operatorRaw = attr(cfRule, "operator");
+		const formula1 = readFormula(cfRule, 0);
+		if (!isSheetRuleOperator(operatorRaw) || formula1 === void 0) return;
+		const formula2 = operatorRaw === "between" || operatorRaw === "notBetween" ? readFormula(cfRule, 1) : void 0;
+		return {
+			type: "cellIs",
+			...common,
+			operator: operatorRaw,
+			formula1,
+			...formula2 === void 0 ? {} : { formula2 },
+			...styleField
+		};
+	}
+	if (isTextPredicateType(type)) {
+		const text = attr(cfRule, "text");
+		if (text === void 0) return;
+		return {
+			type,
+			...common,
+			text: decodeEntities(text),
+			...styleField
+		};
+	}
+	if (isOperandFreeType(type)) return {
+		type,
+		...common,
+		...styleField
+	};
+	if (type === "top10") {
+		const rankRaw = attr(cfRule, "rank");
+		const rank = rankRaw === void 0 ? void 0 : Number(rankRaw);
+		if (rank === void 0 || !Number.isFinite(rank) || rank <= 0) return;
+		return {
+			type: "top10",
+			...common,
+			rank,
+			...readXmlBool(attr(cfRule, "percent")) ? { percent: true } : {},
+			...readXmlBool(attr(cfRule, "bottom")) ? { bottom: true } : {},
+			...styleField
+		};
+	}
+	if (type === "aboveAverage") {
+		const aboveAverageRaw = attr(cfRule, "aboveAverage");
+		const stdDevRaw = attr(cfRule, "stdDev");
+		const stdDev = stdDevRaw === void 0 ? void 0 : Number.parseInt(stdDevRaw, 10);
+		return {
+			type: "aboveAverage",
+			...common,
+			...aboveAverageRaw !== void 0 && !readXmlBool(aboveAverageRaw) ? { aboveAverage: false } : {},
+			...readXmlBool(attr(cfRule, "equalAverage")) ? { equalAverage: true } : {},
+			...stdDev !== void 0 && Number.isInteger(stdDev) && stdDev > 0 ? { stdDev } : {},
+			...styleField
+		};
+	}
+	if (type === "timePeriod") {
+		const timePeriod = attr(cfRule, "timePeriod");
+		if (!isTimePeriod(timePeriod)) return;
+		return {
+			type: "timePeriod",
+			...common,
+			timePeriod,
+			...styleField
+		};
+	}
+	if (type === "colorScale") {
+		const colorScaleEl = childrenWithTag(cfRule, "colorScale")[0];
+		const stops = colorScaleEl === void 0 ? void 0 : readColorScaleStops(colorScaleEl);
+		if (stops === void 0) return;
+		return {
+			type: "colorScale",
+			...common,
+			stops
+		};
+	}
+	if (type === "dataBar") {
+		const dataBarEl = childrenWithTag(cfRule, "dataBar")[0];
+		const parsed = dataBarEl === void 0 ? void 0 : readDataBar(dataBarEl);
+		if (parsed === void 0) return;
+		return {
+			type: "dataBar",
+			...common,
+			min: parsed.min,
+			max: parsed.max,
+			color: parsed.color,
+			...parsed.showValue === void 0 ? {} : { showValue: parsed.showValue }
+		};
+	}
+	if (type === "iconSet") {
+		const iconSetEl = childrenWithTag(cfRule, "iconSet")[0];
+		const parsed = iconSetEl === void 0 ? void 0 : readIconSet(iconSetEl);
+		if (parsed === void 0) return;
+		return {
+			type: "iconSet",
+			...common,
+			iconSetType: parsed.iconSetType,
+			thresholds: parsed.thresholds,
+			...parsed.reverse === void 0 ? {} : { reverse: parsed.reverse },
+			...parsed.showValue === void 0 ? {} : { showValue: parsed.showValue }
+		};
+	}
+}
+var DxfTable = class {
+	elements = [];
+	intern(style) {
+		const index = this.elements.length;
+		this.elements.push(buildDxfElement(style));
+		return index;
+	}
+	dxfElements() {
+		return this.elements;
+	}
+};
+function attrsRecord(attributes) {
+	const result = {};
+	for (const attribute of attributes) result[attribute.name] = attribute.value;
+	return result;
+}
+function extractResidueElements(source) {
+	if (source?.format !== "xlsx") return [];
+	const elements = [];
+	for (const node of parseXml(source.xml)) if (node.type === "element") elements.push(node);
+	return elements;
+}
+function buildDxfElement(style) {
+	const residueByTag = /* @__PURE__ */ new Map();
+	for (const element of extractResidueElements(style.source)) residueByTag.set(element.tag, element);
+	const children = [];
+	const residualFont = residueByTag.get("font");
+	if (style.textColor !== void 0) {
+		const fontChildren = residualFont === void 0 ? [] : residualFont.children;
+		const fontAttrs = residualFont === void 0 ? {} : attrsRecord(residualFont.attributes);
+		children.push(el("font", fontAttrs, [...fontChildren, el("color", { rgb: `FF${colorToRgbHex(style.textColor)}` })]));
+	} else if (residualFont !== void 0) children.push(residualFont);
+	const residualNumFmt = residueByTag.get("numFmt");
+	if (residualNumFmt !== void 0) children.push(residualNumFmt);
+	const residualFill = residueByTag.get("fill");
+	if (style.background !== void 0) {
+		const residualPatternFill = residualFill === void 0 ? void 0 : childrenWithTag(residualFill, "patternFill")[0];
+		const patternFillChildren = residualPatternFill === void 0 ? [] : residualPatternFill.children;
+		const patternFillAttrs = residualPatternFill === void 0 ? {} : attrsRecord(residualPatternFill.attributes);
+		const otherFillChildren = residualFill === void 0 ? [] : residualFill.children.filter((child) => !(child.type === "element" && child.tag === "patternFill"));
+		children.push(el("fill", residualFill === void 0 ? {} : attrsRecord(residualFill.attributes), [el("patternFill", patternFillAttrs, [...patternFillChildren, el("bgColor", { rgb: `FF${colorToRgbHex(style.background)}` })]), ...otherFillChildren]));
+	} else if (residualFill !== void 0) children.push(residualFill);
+	for (const tag of [
+		"alignment",
+		"border",
+		"protection"
+	]) {
+		const residual = residueByTag.get(tag);
+		if (residual !== void 0) children.push(residual);
+	}
+	return el("dxf", {}, children);
+}
+function rangeSetKey(ranges) {
+	return ranges.map((range) => `${range.startRow}:${range.startColumn}:${range.endRow}:${range.endColumn}`).join("|");
+}
+const TEXT_PREDICATE_OPERATOR = {
+	containsText: "containsText",
+	notContainsText: "notContains",
+	beginsWith: "beginsWith",
+	endsWith: "endsWith"
+};
+function buildCfvoElement(value) {
+	const attrs = { type: value.type };
+	if (value.value !== void 0) attrs.val = encodeXmlText(value.value);
+	return el("cfvo", attrs);
+}
+function buildCfRuleElement(rule, priority, dxfTable) {
+	const attrs = residualAttributesFor(rule.source, "cfRule");
+	attrs.type = rule.type;
+	attrs.priority = String(priority);
+	if (rule.stopIfTrue === true) attrs.stopIfTrue = writeXmlBool(true);
+	const children = [];
+	let style;
+	switch (rule.type) {
+		case "cellIs":
+			attrs.operator = rule.operator;
+			children.push(el("formula", {}, [txt(encodeXmlText(rule.formula1))]));
+			if (rule.formula2 !== void 0) children.push(el("formula", {}, [txt(encodeXmlText(rule.formula2))]));
+			style = rule.style;
+			break;
+		case "containsText":
+		case "notContainsText":
+		case "beginsWith":
+		case "endsWith":
+			attrs.operator = TEXT_PREDICATE_OPERATOR[rule.type];
+			attrs.text = encodeXmlText(rule.text);
+			style = rule.style;
+			break;
+		case "containsBlanks":
+		case "notContainsBlanks":
+		case "containsErrors":
+		case "notContainsErrors":
+		case "uniqueValues":
+		case "duplicateValues":
+			style = rule.style;
+			break;
+		case "top10":
+			attrs.rank = String(rule.rank);
+			if (rule.percent === true) attrs.percent = writeXmlBool(true);
+			if (rule.bottom === true) attrs.bottom = writeXmlBool(true);
+			style = rule.style;
+			break;
+		case "aboveAverage":
+			if (rule.aboveAverage === false) attrs.aboveAverage = writeXmlBool(false);
+			if (rule.equalAverage === true) attrs.equalAverage = writeXmlBool(true);
+			if (rule.stdDev !== void 0) attrs.stdDev = String(rule.stdDev);
+			style = rule.style;
+			break;
+		case "timePeriod":
+			attrs.timePeriod = rule.timePeriod;
+			style = rule.style;
+			break;
+		case "colorScale":
+			children.push(el("colorScale", {}, [...rule.stops.map((stop) => buildCfvoElement(stop.value)), ...rule.stops.map((stop) => el("color", { rgb: `FF${colorToRgbHex(stop.color)}` }))]));
+			break;
+		case "dataBar": {
+			const dataBarChildren = [
+				buildCfvoElement(rule.min),
+				buildCfvoElement(rule.max),
+				el("color", { rgb: `FF${colorToRgbHex(rule.color)}` })
+			];
+			const dataBarAttrs = rule.showValue === false ? { showValue: writeXmlBool(false) } : {};
+			children.push(el("dataBar", dataBarAttrs, dataBarChildren));
+			break;
+		}
+		case "iconSet": {
+			const iconSetAttrs = {};
+			if (rule.iconSetType !== DEFAULT_ICON_SET_TYPE) iconSetAttrs.iconSet = rule.iconSetType;
+			if (rule.reverse === true) iconSetAttrs.reverse = writeXmlBool(true);
+			if (rule.showValue === false) iconSetAttrs.showValue = writeXmlBool(false);
+			children.push(el("iconSet", iconSetAttrs, rule.thresholds.map(buildCfvoElement)));
+			break;
+		}
+	}
+	if (style !== void 0) attrs.dxfId = String(dxfTable.intern(style));
+	return el("cfRule", attrs, children);
+}
+function buildConditionalFormattingElements(formats, dxfTable) {
+	const groupsByKey = /* @__PURE__ */ new Map();
+	const groupOrder = [];
+	for (const format of formats) {
+		const key = rangeSetKey(format.ranges);
+		const existing = groupsByKey.get(key);
+		if (existing === void 0) {
+			const group = {
+				ranges: format.ranges,
+				rules: [format]
+			};
+			groupsByKey.set(key, group);
+			groupOrder.push(group);
+		} else existing.rules.push(format);
+	}
+	const usedPriorities = /* @__PURE__ */ new Set();
+	for (const format of formats) if (format.priority !== void 0) usedPriorities.add(format.priority);
+	let nextPriority = 1;
+	const assignPriority = (explicit) => {
+		if (explicit !== void 0) return explicit;
+		while (usedPriorities.has(nextPriority)) nextPriority++;
+		usedPriorities.add(nextPriority);
+		return nextPriority++;
+	};
+	return groupOrder.map((group) => {
+		const cfRuleElements = group.rules.map((rule) => buildCfRuleElement(rule, assignPriority(rule.priority), dxfTable));
+		return el("conditionalFormatting", { sqref: formatSqref(group.ranges) }, cfRuleElements);
+	});
+}
+//#endregion
+export { DxfTable, buildConditionalFormattingElements, readConditionalFormats };

package/dist/typed/xlsx/content.cjs

@@ -12,6 +12,8 @@ const require_typed_xlsx_serial = require("./serial.cjs");
 const require_typed_xlsx_shared_strings = require("./shared-strings.cjs");
 const require_typed_xlsx_styles = require("./styles.cjs");
 const require_typed_xlsx_comments = require("./comments.cjs");
+const require_typed_xlsx_conditional_format = require("./conditional-format.cjs");
+const require_typed_xlsx_data_validation = require("./data-validation.cjs");
 let document_schema_js = require("document-schema.js");
 //#region src/typed/xlsx/content.ts
 const WORKBOOK_PATH = "xl/workbook.xml";
@@ -320,10 +322,7 @@ function applyCellComments(comments, cells) {
 		byPosition.set(key, materialised);
 	}
 }
-function applyCellResidueRules(worksheet, cells) {
-	const rules = [];
-	for (const container of require_typed_util.childrenWithTag(worksheet, "dataValidations")) rules.push(...require_typed_util.childrenWithTag(container, "dataValidation"));
-	rules.push(...require_typed_util.childrenWithTag(worksheet, "conditionalFormatting"));
+function applyCellResidueRules(cells, rules) {
 	if (rules.length === 0) return;
 	const byPosition = /* @__PURE__ */ new Map();
 	for (const cell of cells) byPosition.set(`${cell.row}:${cell.column}`, cell);
@@ -355,7 +354,7 @@ function applyCellResidueRules(worksheet, cells) {
 		};
 	}
 }
-function readSheet(pkg, entry, sheetIndex, sharedStrings, definedNamesBySheet, context) {
+function readSheet(pkg, entry, sheetIndex, sharedStrings, definedNamesBySheet, context, dxfs) {
 	const worksheet = require_typed_util.rootElement(pkg.parts[entry.path]);
 	if (worksheet === void 0) return {
 		name: entry.name,
@@ -367,7 +366,9 @@ function readSheet(pkg, entry, sheetIndex, sharedStrings, definedNamesBySheet, c
 	};
 	const cells = readCells(worksheet, sharedStrings, context);
 	applyCellComments(require_typed_xlsx_comments.readSheetCellComments(pkg, entry.path), cells);
-	applyCellResidueRules(worksheet, cells);
+	const { validations, residueElements: dataValidationResidue } = require_typed_xlsx_data_validation.readDataValidations(worksheet);
+	const { formats, residueElements: conditionalFormatResidue } = require_typed_xlsx_conditional_format.readConditionalFormats(worksheet, dxfs);
+	applyCellResidueRules(cells, [...dataValidationResidue, ...conditionalFormatResidue]);
 	const drawing = require_typed_xlsx_drawings.readSheetDrawing(pkg, entry.path, worksheet);
 	return {
 		name: entry.name,
@@ -376,6 +377,8 @@ function readSheet(pkg, entry, sheetIndex, sharedStrings, definedNamesBySheet, c
 		rows: readRows(worksheet),
 		images: drawing.images,
 		...drawing.embeddedObjects === void 0 ? {} : { embeddedObjects: drawing.embeddedObjects },
+		...validations.length === 0 ? {} : { dataValidations: validations },
+		...formats.length === 0 ? {} : { conditionalFormats: formats },
 		printSettings: require_typed_xlsx_print_settings.readPrintSettings(worksheet, sheetIndex, definedNamesBySheet)
 	};
 }
@@ -391,7 +394,8 @@ function readXlsxContent(pkg) {
 	const sharedStrings = require_typed_xlsx_shared_strings.loadSharedStrings(pkg);
 	const definedNamesBySheet = require_typed_xlsx_defined_names.readDefinedNamesBySheet(pkg);
 	const context = readCellFormatContext(pkg);
-	const sheets = resolveSheetEntries(pkg).map((entry, sheetIndex) => readSheet(pkg, entry, sheetIndex, sharedStrings, definedNamesBySheet, context));
+	const dxfs = require_typed_xlsx_styles.readDxfElements(pkg);
+	const sheets = resolveSheetEntries(pkg).map((entry, sheetIndex) => readSheet(pkg, entry, sheetIndex, sharedStrings, definedNamesBySheet, context, dxfs));
 	return {
 		kind: "spreadsheet",
 		metadata: require_typed_shared_metadata.readCoreProperties(pkg),

package/dist/typed/xlsx/content.js

@@ -9,8 +9,10 @@ import { columnWidthCharsToPt } from "./units.js";
 import { readSheetDrawing } from "./drawings.js";
 import { readDate1904, serialToIsoDate, serialToIsoDateTime, serialToIsoTime } from "./serial.js";
 import { loadSharedStrings } from "./shared-strings.js";
-import { readCellStyles } from "./styles.js";
+import { readCellStyles, readDxfElements } from "./styles.js";
 import { readSheetCellComments } from "./comments.js";
+import { readConditionalFormats } from "./conditional-format.js";
+import { readDataValidations } from "./data-validation.js";
 import { parseCellReference, parseRangeReference } from "document-schema.js";
 //#region src/typed/xlsx/content.ts
 const WORKBOOK_PATH = "xl/workbook.xml";
@@ -319,10 +321,7 @@ function applyCellComments(comments, cells) {
 		byPosition.set(key, materialised);
 	}
 }
-function applyCellResidueRules(worksheet, cells) {
-	const rules = [];
-	for (const container of childrenWithTag(worksheet, "dataValidations")) rules.push(...childrenWithTag(container, "dataValidation"));
-	rules.push(...childrenWithTag(worksheet, "conditionalFormatting"));
+function applyCellResidueRules(cells, rules) {
 	if (rules.length === 0) return;
 	const byPosition = /* @__PURE__ */ new Map();
 	for (const cell of cells) byPosition.set(`${cell.row}:${cell.column}`, cell);
@@ -354,7 +353,7 @@ function applyCellResidueRules(worksheet, cells) {
 		};
 	}
 }
-function readSheet(pkg, entry, sheetIndex, sharedStrings, definedNamesBySheet, context) {
+function readSheet(pkg, entry, sheetIndex, sharedStrings, definedNamesBySheet, context, dxfs) {
 	const worksheet = rootElement(pkg.parts[entry.path]);
 	if (worksheet === void 0) return {
 		name: entry.name,
@@ -366,7 +365,9 @@ function readSheet(pkg, entry, sheetIndex, sharedStrings, definedNamesBySheet, c
 	};
 	const cells = readCells(worksheet, sharedStrings, context);
 	applyCellComments(readSheetCellComments(pkg, entry.path), cells);
-	applyCellResidueRules(worksheet, cells);
+	const { validations, residueElements: dataValidationResidue } = readDataValidations(worksheet);
+	const { formats, residueElements: conditionalFormatResidue } = readConditionalFormats(worksheet, dxfs);
+	applyCellResidueRules(cells, [...dataValidationResidue, ...conditionalFormatResidue]);
 	const drawing = readSheetDrawing(pkg, entry.path, worksheet);
 	return {
 		name: entry.name,
@@ -375,6 +376,8 @@ function readSheet(pkg, entry, sheetIndex, sharedStrings, definedNamesBySheet, c
 		rows: readRows(worksheet),
 		images: drawing.images,
 		...drawing.embeddedObjects === void 0 ? {} : { embeddedObjects: drawing.embeddedObjects },
+		...validations.length === 0 ? {} : { dataValidations: validations },
+		...formats.length === 0 ? {} : { conditionalFormats: formats },
 		printSettings: readPrintSettings(worksheet, sheetIndex, definedNamesBySheet)
 	};
 }
@@ -390,7 +393,8 @@ function readXlsxContent(pkg) {
 	const sharedStrings = loadSharedStrings(pkg);
 	const definedNamesBySheet = readDefinedNamesBySheet(pkg);
 	const context = readCellFormatContext(pkg);
-	const sheets = resolveSheetEntries(pkg).map((entry, sheetIndex) => readSheet(pkg, entry, sheetIndex, sharedStrings, definedNamesBySheet, context));
+	const dxfs = readDxfElements(pkg);
+	const sheets = resolveSheetEntries(pkg).map((entry, sheetIndex) => readSheet(pkg, entry, sheetIndex, sharedStrings, definedNamesBySheet, context, dxfs));
 	return {
 		kind: "spreadsheet",
 		metadata: readCoreProperties(pkg),