ooxml.js 6.1.0 → 6.3.0

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

@@ -0,0 +1,519 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_xml_parse = require("../../xml/parse.cjs");
+const require_xml_build = require("../../xml/build.cjs");
+const require_xml_fragment = require("../../xml/fragment.cjs");
+const require_xml_entities = require("../../xml/entities.cjs");
+const require_typed_util = require("../util.cjs");
+const require_typed_xlsx_util = require("./util.cjs");
+const require_typed_xlsx_styles = require("./styles.cjs");
+const require_typed_xlsx_rule_residue = require("./rule-residue.cjs");
+const require_typed_xlsx_sqref = require("./sqref.cjs");
+let document_schema_js = require("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 require_typed_util.childrenWithTag(worksheet, "conditionalFormatting")) {
+		const ranges = require_typed_xlsx_sqref.parseSqref(require_typed_util.attr(wrapper, "sqref"));
+		for (const cfRule of require_typed_util.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 = require_typed_util.attr(cfRule, "priority");
+	if (priorityRaw !== void 0) {
+		const priority = Number.parseInt(priorityRaw, 10);
+		if (Number.isInteger(priority)) result.priority = priority;
+	}
+	if (require_typed_xlsx_util.readXmlBool(require_typed_util.attr(cfRule, "stopIfTrue"))) result.stopIfTrue = true;
+	const source = require_typed_xlsx_rule_residue.captureResidualAttributes(cfRule, CF_RULE_MANAGED_ATTRIBUTES);
+	if (source !== void 0) result.source = source;
+	return result;
+}
+function readFormula(cfRule, index) {
+	const formulaEl = require_typed_util.childrenWithTag(cfRule, "formula")[index];
+	return formulaEl === void 0 ? void 0 : require_typed_util.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 = require_typed_util.attr(cfvoEl, "type");
+	if (!isCfvoType(type)) return;
+	if (type === "min" || type === "max") return { type };
+	const valRaw = require_typed_util.attr(cfvoEl, "val");
+	if (valRaw === void 0) return;
+	return {
+		type,
+		value: require_typed_util.decodeEntities(valRaw)
+	};
+}
+function readColorScaleStops(colorScaleEl) {
+	const cfvoEls = require_typed_util.childrenWithTag(colorScaleEl, "cfvo");
+	const colorEls = require_typed_util.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 = require_typed_xlsx_styles.colorFromElement(colorEl);
+		if (value === void 0 || color === void 0) return;
+		stops.push({
+			value,
+			color
+		});
+	}
+	return stops;
+}
+function readDataBar(dataBarEl) {
+	const cfvoEls = require_typed_util.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 = require_typed_xlsx_styles.colorFromElement(require_typed_util.childrenWithTag(dataBarEl, "color")[0]);
+	if (min === void 0 || max === void 0 || color === void 0) return;
+	const result = {
+		min,
+		max,
+		color
+	};
+	const showValueRaw = require_typed_util.attr(dataBarEl, "showValue");
+	if (showValueRaw !== void 0 && !require_typed_xlsx_util.readXmlBool(showValueRaw)) result.showValue = false;
+	return result;
+}
+const DEFAULT_ICON_SET_TYPE = "3TrafficLights1";
+function readIconSet(iconSetEl) {
+	const thresholds = [];
+	for (const cfvoEl of require_typed_util.childrenWithTag(iconSetEl, "cfvo")) {
+		const value = readCfvo(cfvoEl);
+		if (value === void 0) return;
+		thresholds.push(value);
+	}
+	if (thresholds.length === 0) return;
+	const result = {
+		iconSetType: require_typed_util.attr(iconSetEl, "iconSet") ?? DEFAULT_ICON_SET_TYPE,
+		thresholds
+	};
+	if (require_typed_xlsx_util.readXmlBool(require_typed_util.attr(iconSetEl, "reverse"))) result.reverse = true;
+	const showValueRaw = require_typed_util.attr(iconSetEl, "showValue");
+	if (showValueRaw !== void 0 && !require_typed_xlsx_util.readXmlBool(showValueRaw)) result.showValue = false;
+	return result;
+}
+function styleFromDxf(dxf) {
+	const fontEl = require_typed_util.childrenWithTag(dxf, "font")[0];
+	const textColor = fontEl === void 0 ? void 0 : require_typed_xlsx_styles.readColorRgb(fontEl, "color");
+	const fillEl = require_typed_util.childrenWithTag(dxf, "fill")[0];
+	const patternFillEl = fillEl === void 0 ? void 0 : require_typed_util.childrenWithTag(fillEl, "patternFill")[0];
+	const background = patternFillEl === void 0 ? void 0 : require_typed_xlsx_styles.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: require_xml_build.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 = require_typed_util.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 = require_typed_util.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 = require_typed_util.attr(cfRule, "type");
+	const common = readCommonFields(cfRule, ranges);
+	const style = resolveStyle(cfRule, dxfs);
+	const styleField = style === void 0 ? {} : { style };
+	if (type === "cellIs") {
+		const operatorRaw = require_typed_util.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 = require_typed_util.attr(cfRule, "text");
+		if (text === void 0) return;
+		return {
+			type,
+			...common,
+			text: require_typed_util.decodeEntities(text),
+			...styleField
+		};
+	}
+	if (isOperandFreeType(type)) return {
+		type,
+		...common,
+		...styleField
+	};
+	if (type === "top10") {
+		const rankRaw = require_typed_util.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,
+			...require_typed_xlsx_util.readXmlBool(require_typed_util.attr(cfRule, "percent")) ? { percent: true } : {},
+			...require_typed_xlsx_util.readXmlBool(require_typed_util.attr(cfRule, "bottom")) ? { bottom: true } : {},
+			...styleField
+		};
+	}
+	if (type === "aboveAverage") {
+		const aboveAverageRaw = require_typed_util.attr(cfRule, "aboveAverage");
+		const stdDevRaw = require_typed_util.attr(cfRule, "stdDev");
+		const stdDev = stdDevRaw === void 0 ? void 0 : Number.parseInt(stdDevRaw, 10);
+		return {
+			type: "aboveAverage",
+			...common,
+			...aboveAverageRaw !== void 0 && !require_typed_xlsx_util.readXmlBool(aboveAverageRaw) ? { aboveAverage: false } : {},
+			...require_typed_xlsx_util.readXmlBool(require_typed_util.attr(cfRule, "equalAverage")) ? { equalAverage: true } : {},
+			...stdDev !== void 0 && Number.isInteger(stdDev) && stdDev > 0 ? { stdDev } : {},
+			...styleField
+		};
+	}
+	if (type === "timePeriod") {
+		const timePeriod = require_typed_util.attr(cfRule, "timePeriod");
+		if (!isTimePeriod(timePeriod)) return;
+		return {
+			type: "timePeriod",
+			...common,
+			timePeriod,
+			...styleField
+		};
+	}
+	if (type === "colorScale") {
+		const colorScaleEl = require_typed_util.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 = require_typed_util.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 = require_typed_util.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 require_xml_parse.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(require_xml_fragment.el("font", fontAttrs, [...fontChildren, require_xml_fragment.el("color", { rgb: `FF${(0, document_schema_js.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 : require_typed_util.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(require_xml_fragment.el("fill", residualFill === void 0 ? {} : attrsRecord(residualFill.attributes), [require_xml_fragment.el("patternFill", patternFillAttrs, [...patternFillChildren, require_xml_fragment.el("bgColor", { rgb: `FF${(0, document_schema_js.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 require_xml_fragment.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 = require_xml_entities.encodeXmlText(value.value);
+	return require_xml_fragment.el("cfvo", attrs);
+}
+function buildCfRuleElement(rule, priority, dxfTable) {
+	const attrs = require_typed_xlsx_rule_residue.residualAttributesFor(rule.source, "cfRule");
+	attrs.type = rule.type;
+	attrs.priority = String(priority);
+	if (rule.stopIfTrue === true) attrs.stopIfTrue = require_typed_xlsx_util.writeXmlBool(true);
+	const children = [];
+	let style;
+	switch (rule.type) {
+		case "cellIs":
+			attrs.operator = rule.operator;
+			children.push(require_xml_fragment.el("formula", {}, [require_xml_fragment.txt(require_xml_entities.encodeXmlText(rule.formula1))]));
+			if (rule.formula2 !== void 0) children.push(require_xml_fragment.el("formula", {}, [require_xml_fragment.txt(require_xml_entities.encodeXmlText(rule.formula2))]));
+			style = rule.style;
+			break;
+		case "containsText":
+		case "notContainsText":
+		case "beginsWith":
+		case "endsWith":
+			attrs.operator = TEXT_PREDICATE_OPERATOR[rule.type];
+			attrs.text = require_xml_entities.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 = require_typed_xlsx_util.writeXmlBool(true);
+			if (rule.bottom === true) attrs.bottom = require_typed_xlsx_util.writeXmlBool(true);
+			style = rule.style;
+			break;
+		case "aboveAverage":
+			if (rule.aboveAverage === false) attrs.aboveAverage = require_typed_xlsx_util.writeXmlBool(false);
+			if (rule.equalAverage === true) attrs.equalAverage = require_typed_xlsx_util.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(require_xml_fragment.el("colorScale", {}, [...rule.stops.map((stop) => buildCfvoElement(stop.value)), ...rule.stops.map((stop) => require_xml_fragment.el("color", { rgb: `FF${(0, document_schema_js.colorToRgbHex)(stop.color)}` }))]));
+			break;
+		case "dataBar": {
+			const dataBarChildren = [
+				buildCfvoElement(rule.min),
+				buildCfvoElement(rule.max),
+				require_xml_fragment.el("color", { rgb: `FF${(0, document_schema_js.colorToRgbHex)(rule.color)}` })
+			];
+			const dataBarAttrs = rule.showValue === false ? { showValue: require_typed_xlsx_util.writeXmlBool(false) } : {};
+			children.push(require_xml_fragment.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 = require_typed_xlsx_util.writeXmlBool(true);
+			if (rule.showValue === false) iconSetAttrs.showValue = require_typed_xlsx_util.writeXmlBool(false);
+			children.push(require_xml_fragment.el("iconSet", iconSetAttrs, rule.thresholds.map(buildCfvoElement)));
+			break;
+		}
+	}
+	if (style !== void 0) attrs.dxfId = String(dxfTable.intern(style));
+	return require_xml_fragment.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 require_xml_fragment.el("conditionalFormatting", { sqref: require_typed_xlsx_sqref.formatSqref(group.ranges) }, cfRuleElements);
+	});
+}
+//#endregion
+exports.DxfTable = DxfTable;
+exports.buildConditionalFormattingElements = buildConditionalFormattingElements;
+exports.readConditionalFormats = readConditionalFormats;

package/dist/typed/xlsx/conditional-format.d.cts

@@ -0,0 +1,16 @@
+import { l as XmlElement } from "../../node-B6JX5CRX.cjs";
+import { ContentSheetConditionalFormat, ContentSheetConditionalFormatStyle } from "document-schema.js";
+//#region src/typed/xlsx/conditional-format.d.ts
+interface ConditionalFormatReadResult {
+  formats: ContentSheetConditionalFormat[];
+  residueElements: XmlElement[];
+}
+declare function readConditionalFormats(worksheet: XmlElement, dxfs: readonly XmlElement[]): ConditionalFormatReadResult;
+declare class DxfTable {
+  private readonly elements;
+  intern(style: ContentSheetConditionalFormatStyle): number;
+  dxfElements(): readonly XmlElement[];
+}
+declare function buildConditionalFormattingElements(formats: readonly ContentSheetConditionalFormat[], dxfTable: DxfTable): XmlElement[];
+//#endregion
+export { ConditionalFormatReadResult, DxfTable, buildConditionalFormattingElements, readConditionalFormats };

package/dist/typed/xlsx/conditional-format.d.ts

@@ -0,0 +1,16 @@
+import { l as XmlElement } from "../../node-B6JX5CRX.js";
+import { ContentSheetConditionalFormat, ContentSheetConditionalFormatStyle } from "document-schema.js";
+//#region src/typed/xlsx/conditional-format.d.ts
+interface ConditionalFormatReadResult {
+  formats: ContentSheetConditionalFormat[];
+  residueElements: XmlElement[];
+}
+declare function readConditionalFormats(worksheet: XmlElement, dxfs: readonly XmlElement[]): ConditionalFormatReadResult;
+declare class DxfTable {
+  private readonly elements;
+  intern(style: ContentSheetConditionalFormatStyle): number;
+  dxfElements(): readonly XmlElement[];
+}
+declare function buildConditionalFormattingElements(formats: readonly ContentSheetConditionalFormat[], dxfTable: DxfTable): XmlElement[];
+//#endregion
+export { ConditionalFormatReadResult, DxfTable, buildConditionalFormattingElements, readConditionalFormats };