reamkit 0.1.0-alpha.0

package/dist/esm/ooxml/spreadsheet/number-format.js

@@ -0,0 +1,438 @@
+//#region src/ooxml/spreadsheet/number-format.ts
+var BUILTIN = new Map([
+	[0, "General"],
+	[1, "0"],
+	[2, "0.00"],
+	[3, "#,##0"],
+	[4, "#,##0.00"],
+	[9, "0%"],
+	[10, "0.00%"],
+	[11, "0.00E+00"],
+	[37, "#,##0_);(#,##0)"],
+	[38, "#,##0_);[Red](#,##0)"],
+	[39, "#,##0.00_);(#,##0.00)"],
+	[40, "#,##0.00_);[Red](#,##0.00)"],
+	[49, "@"]
+]);
+var BUILTIN_DATE_FORMATS = new Map([
+	[14, "m/d/yyyy"],
+	[15, "d-mmm-yy"],
+	[16, "d-mmm"],
+	[17, "mmm-yy"],
+	[18, "h:mm AM/PM"],
+	[19, "h:mm:ss AM/PM"],
+	[20, "h:mm"],
+	[21, "h:mm:ss"],
+	[22, "m/d/yyyy h:mm"],
+	[45, "mm:ss"],
+	[46, "[h]:mm:ss"],
+	[47, "mm:ss.0"]
+]);
+function applyNumberFormat(rawValue, numFmtId, customFormats, date1904 = false) {
+	if (rawValue.length === 0) return "";
+	if (numFmtId === 0) return defaultNumberRender(rawValue);
+	if (numFmtId === 49) return rawValue;
+	const builtinDate = BUILTIN_DATE_FORMATS.get(numFmtId);
+	if (builtinDate !== void 0) return formatExcelDate(rawValue, builtinDate, date1904);
+	const custom = customFormats.get(numFmtId);
+	if (custom !== void 0 && isDateFormat(custom)) return formatExcelDate(rawValue, custom, date1904);
+	const format = custom ?? BUILTIN.get(numFmtId);
+	if (!format) return defaultNumberRender(rawValue);
+	if (format === "General") return defaultNumberRender(rawValue);
+	return applyFormatString(rawValue, format);
+}
+function excelSerialToDate(serial, date1904) {
+	const ms = serial * 86400 * 1e3;
+	if (date1904) return new Date(Date.UTC(1904, 0, 1) + ms);
+	return new Date(Date.UTC(1899, 11, 30) + ms);
+}
+var MONTH_ABBR = [
+	"Jan",
+	"Feb",
+	"Mar",
+	"Apr",
+	"May",
+	"Jun",
+	"Jul",
+	"Aug",
+	"Sep",
+	"Oct",
+	"Nov",
+	"Dec"
+];
+var MONTH_FULL = [
+	"January",
+	"February",
+	"March",
+	"April",
+	"May",
+	"June",
+	"July",
+	"August",
+	"September",
+	"October",
+	"November",
+	"December"
+];
+var DAY_ABBR = [
+	"Sun",
+	"Mon",
+	"Tue",
+	"Wed",
+	"Thu",
+	"Fri",
+	"Sat"
+];
+var DAY_FULL = [
+	"Sunday",
+	"Monday",
+	"Tuesday",
+	"Wednesday",
+	"Thursday",
+	"Friday",
+	"Saturday"
+];
+function pad2(n) {
+	return String(n).padStart(2, "0");
+}
+function isDateFormat(code) {
+	const cleaned = code.replace(/"[^"]*"/g, "").replace(/\[[^\]]*\]/g, "");
+	return /[dyhs]|m+/i.test(cleaned) && /[dyhs]/i.test(cleaned);
+}
+function tokenizeDateFormat(format) {
+	const tokens = [];
+	let i = 0;
+	while (i < format.length) {
+		const ch = format[i];
+		if (ch === "\"") {
+			let lit = "";
+			i++;
+			while (i < format.length && format[i] !== "\"") {
+				lit += format[i];
+				i++;
+			}
+			i++;
+			tokens.push({
+				kind: "lit",
+				text: lit
+			});
+			continue;
+		}
+		if (ch === "\\" && i + 1 < format.length) {
+			tokens.push({
+				kind: "lit",
+				text: format[i + 1]
+			});
+			i += 2;
+			continue;
+		}
+		if (ch === "[") {
+			let body = "";
+			i++;
+			while (i < format.length && format[i] !== "]") {
+				body += format[i];
+				i++;
+			}
+			i++;
+			if (/^h+$/i.test(body)) tokens.push({
+				kind: "elapsed-h",
+				text: body
+			});
+			continue;
+		}
+		const lower = ch.toLowerCase();
+		if (lower === "y" || lower === "m" || lower === "d" || lower === "h" || lower === "s") {
+			let run = ch;
+			i++;
+			while (i < format.length && format[i].toLowerCase() === lower) {
+				run += format[i];
+				i++;
+			}
+			if (lower === "y") tokens.push({
+				kind: "y",
+				text: run
+			});
+			else if (lower === "d") tokens.push({
+				kind: "d",
+				text: run
+			});
+			else if (lower === "h") tokens.push({
+				kind: "h",
+				text: run
+			});
+			else if (lower === "s") tokens.push({
+				kind: "s",
+				text: run
+			});
+			else tokens.push({
+				kind: "m",
+				text: run
+			});
+			continue;
+		}
+		if (format.startsWith("AM/PM", i) || format.startsWith("A/P", i)) {
+			const len = format.startsWith("AM/PM", i) ? 5 : 3;
+			tokens.push({
+				kind: "ampm",
+				text: format.substring(i, i + len)
+			});
+			i += len;
+			continue;
+		}
+		tokens.push({
+			kind: "lit",
+			text: ch
+		});
+		i++;
+	}
+	return tokens;
+}
+function resolveMonthVsMinute(tokens) {
+	const resolved = tokens.map((t) => ({ ...t }));
+	for (let i = 0; i < resolved.length; i++) {
+		const t = resolved[i];
+		if (t.kind !== "m") continue;
+		let prev = i - 1;
+		while (prev >= 0 && resolved[prev].kind === "lit") prev--;
+		let next = i + 1;
+		while (next < resolved.length && resolved[next].kind === "lit") next++;
+		const prevIsHour = prev >= 0 && resolved[prev].kind === "h";
+		const nextIsSec = next < resolved.length && resolved[next].kind === "s";
+		if (prevIsHour || nextIsSec) continue;
+		resolved[i] = {
+			kind: "M",
+			text: t.text
+		};
+	}
+	return resolved;
+}
+function formatExcelDate(rawValue, format, date1904) {
+	const serial = Number(rawValue);
+	if (!Number.isFinite(serial)) return rawValue;
+	format = splitSections(format)[0] ?? format;
+	const date = excelSerialToDate(serial, date1904);
+	const year = date.getUTCFullYear();
+	const month = date.getUTCMonth() + 1;
+	const day = date.getUTCDate();
+	const weekday = date.getUTCDay();
+	const hour24 = date.getUTCHours();
+	const minute = date.getUTCMinutes();
+	const second = date.getUTCSeconds();
+	const tokens = resolveMonthVsMinute(tokenizeDateFormat(format));
+	const hourValue = tokens.some((t) => t.kind === "ampm") ? hour24 % 12 === 0 ? 12 : hour24 % 12 : hour24;
+	const ampmLabel = (template) => {
+		const isUpper = template[0] === "A";
+		const isShort = template.length <= 3;
+		if (hour24 < 12) return isShort ? isUpper ? "A" : "a" : isUpper ? "AM" : "am";
+		return isShort ? isUpper ? "P" : "p" : isUpper ? "PM" : "pm";
+	};
+	let out = "";
+	for (const t of tokens) switch (t.kind) {
+		case "lit":
+			out += t.text;
+			break;
+		case "y":
+			out += t.text.length <= 2 ? pad2(year % 100) : String(year).padStart(4, "0");
+			break;
+		case "M": {
+			const len = t.text.length;
+			if (len === 5) out += MONTH_FULL[month - 1][0];
+			else if (len === 4) out += MONTH_FULL[month - 1];
+			else if (len === 3) out += MONTH_ABBR[month - 1];
+			else if (len === 2) out += pad2(month);
+			else out += String(month);
+			break;
+		}
+		case "d": {
+			const len = t.text.length;
+			if (len >= 4) out += DAY_FULL[weekday];
+			else if (len === 3) out += DAY_ABBR[weekday];
+			else if (len === 2) out += pad2(day);
+			else out += String(day);
+			break;
+		}
+		case "h":
+			out += t.text.length >= 2 ? pad2(hourValue) : String(hourValue);
+			break;
+		case "elapsed-h":
+			out += String(Math.floor(serial * 24));
+			break;
+		case "m":
+			out += t.text.length >= 2 ? pad2(minute) : String(minute);
+			break;
+		case "s":
+			out += t.text.length >= 2 ? pad2(second) : String(second);
+			break;
+		case "ampm":
+			out += ampmLabel(t.text);
+			break;
+	}
+	return out;
+}
+function defaultNumberRender(rawValue) {
+	const n = Number(rawValue);
+	if (!Number.isFinite(n)) return rawValue;
+	if (Number.isInteger(n)) return String(n);
+	return String(n);
+}
+function applyFormatString(rawValue, format) {
+	const n = Number(rawValue);
+	const sections = splitSections(format);
+	if (!Number.isFinite(n)) {
+		const textSection = sections[3];
+		if (textSection !== void 0) return textSection.replace(/@/g, rawValue);
+		return rawValue;
+	}
+	let sectionIdx;
+	if (n > 0) sectionIdx = 0;
+	else if (n < 0) sectionIdx = sections.length > 1 ? 1 : 0;
+	else sectionIdx = sections.length > 2 ? 2 : 0;
+	return applyNumericSection(n, sections[sectionIdx] ?? sections[0], sectionIdx === 1);
+}
+function splitSections(format) {
+	const out = [];
+	let current = "";
+	let inQuotes = false;
+	let bracketDepth = 0;
+	for (let i = 0; i < format.length; i++) {
+		const ch = format[i];
+		if (ch === "\"") {
+			inQuotes = !inQuotes;
+			current += ch;
+			continue;
+		}
+		if (!inQuotes) {
+			if (ch === "[") bracketDepth++;
+			else if (ch === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+			else if (ch === "\\" && i + 1 < format.length) {
+				current += ch + format[i + 1];
+				i++;
+				continue;
+			} else if (ch === ";" && bracketDepth === 0) {
+				out.push(current);
+				current = "";
+				continue;
+			}
+		}
+		current += ch;
+	}
+	out.push(current);
+	return out;
+}
+function countDigitPlaceholders(s) {
+	let n = 0;
+	for (const c of s) if (c === "0" || c === "#" || c === "?") n++;
+	return n;
+}
+function formatScientific(value, cleaned, negativeSection) {
+	const m = /^(.*?)([eE])([+-])(.*)$/.exec(cleaned);
+	if (!m) return cleaned;
+	const mantissaFmt = m[1];
+	const eChar = m[2];
+	const expSignFmt = m[3];
+	const expFmt = m[4];
+	const dot = mantissaFmt.indexOf(".");
+	const intDigits = Math.max(1, countDigitPlaceholders(dot >= 0 ? mantissaFmt.slice(0, dot) : mantissaFmt));
+	const decimals = dot >= 0 ? countDigitPlaceholders(mantissaFmt.slice(dot + 1)) : 0;
+	let exp = 0;
+	let mant = Math.abs(value);
+	if (mant !== 0) {
+		exp = Math.floor(Math.log10(mant));
+		exp -= (exp % intDigits + intDigits) % intDigits;
+		mant = mant / Math.pow(10, exp);
+		if (Number(mant.toFixed(decimals)) >= Math.pow(10, intDigits)) {
+			exp += intDigits;
+			mant = mant / Math.pow(10, intDigits);
+		}
+	}
+	const mantStr = mant.toFixed(decimals);
+	const expDigits = countDigitPlaceholders(expFmt) || 2;
+	const expStr = String(Math.abs(exp)).padStart(expDigits, "0");
+	return `${value < 0 && !negativeSection ? "-" : ""}${mantStr}${eChar}${exp < 0 ? "-" : expSignFmt === "+" ? "+" : ""}${expStr}`;
+}
+function applyNumericSection(value, format, negativeSection) {
+	const cleaned = format.replace(/\[[^\]]*\]/g, "");
+	if (/[eE][+-]/.test(cleaned)) return formatScientific(value, cleaned, negativeSection);
+	const isPercent = cleaned.includes("%");
+	let magnitude = Math.abs(value);
+	if (isPercent) magnitude *= 100;
+	const { intFormat, decFormat, literalPrefix, literalSuffix } = splitNumberFormat(cleaned);
+	let decimals = 0;
+	for (const c of decFormat) if (c === "0" || c === "#") decimals++;
+	const [intRaw, decRaw] = magnitude.toFixed(decimals).split(".");
+	let numberPart = /,(?=\d)/.test(intFormat) || /[0#],[0#]/.test(intFormat) ? intRaw.replace(/\B(?=(\d{3})+(?!\d))/g, ",") : intRaw;
+	if (decimals > 0) {
+		let dec = decRaw ?? "".padEnd(decimals, "0");
+		if (dec.length < decimals) dec = dec.padEnd(decimals, "0");
+		let kept = "";
+		for (let i = 0; i < decFormat.length; i++) {
+			const placeholder = decFormat[i];
+			const digit = dec[i] ?? "0";
+			if (placeholder === "0") kept += digit;
+			else if (placeholder === "#") {
+				if (digit !== "0" || kept.length > 0) kept += digit;
+			}
+		}
+		if (kept.length > 0) numberPart += "." + kept;
+		else if (decFormat.includes("0")) numberPart += "." + dec;
+	}
+	let signPrefix = "";
+	if (value < 0 && !negativeSection) signPrefix = "-";
+	return `${literalPrefix}${signPrefix}${numberPart}${isPercent ? "%" : ""}${literalSuffix}`;
+}
+function splitNumberFormat(cleaned) {
+	let firstDigit = -1;
+	let lastDigit = -1;
+	for (let i = 0; i < cleaned.length; i++) {
+		const ch = cleaned[i];
+		if (ch === "0" || ch === "#") {
+			if (firstDigit < 0) firstDigit = i;
+			lastDigit = i;
+		}
+	}
+	if (firstDigit < 0) return {
+		literalPrefix: cleaned,
+		intFormat: "",
+		decFormat: "",
+		literalSuffix: ""
+	};
+	const literalPrefix = unquoteLiteral(cleaned.substring(0, firstDigit));
+	const literalSuffix = unquoteLiteral(cleaned.substring(lastDigit + 1));
+	const digitRange = cleaned.substring(firstDigit, lastDigit + 1);
+	const dotIdx = digitRange.indexOf(".");
+	return {
+		literalPrefix,
+		intFormat: dotIdx >= 0 ? digitRange.substring(0, dotIdx) : digitRange,
+		decFormat: dotIdx >= 0 ? digitRange.substring(dotIdx + 1) : "",
+		literalSuffix
+	};
+}
+function unquoteLiteral(s) {
+	let out = "";
+	for (let i = 0; i < s.length; i++) {
+		const ch = s[i];
+		if (ch === "\"") {
+			i++;
+			while (i < s.length && s[i] !== "\"") {
+				out += s[i];
+				i++;
+			}
+			continue;
+		}
+		if (ch === "\\" && i + 1 < s.length) {
+			out += s[i + 1];
+			i++;
+			continue;
+		}
+		if (ch === "_" && i + 1 < s.length) {
+			out += " ";
+			i++;
+			continue;
+		}
+		if (ch === "%") continue;
+		out += ch;
+	}
+	return out;
+}
+//#endregion
+export { applyNumberFormat };

package/dist/esm/ooxml/spreadsheet/shared-strings-parser.d.ts

@@ -0,0 +1 @@
+export declare function parseSharedStrings(data: Uint8Array): Array<string>;

package/dist/esm/ooxml/spreadsheet/shared-strings-parser.js

@@ -0,0 +1,47 @@
+import { XMLParser } from "fast-xml-parser";
+//#region src/ooxml/spreadsheet/shared-strings-parser.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	textNodeName: "#text",
+	parseAttributeValue: false,
+	parseTagValue: false,
+	trimValues: false,
+	removeNSPrefix: true
+});
+var MAX_CELL_CHARS = 32767;
+function capLen(s) {
+	return s.length > MAX_CELL_CHARS ? s.slice(0, MAX_CELL_CHARS) : s;
+}
+function parseSharedStrings(data) {
+	const xml = decoder.decode(data);
+	const sst = parser.parse(xml)["sst"];
+	if (!sst || typeof sst !== "object") return [];
+	const siRaw = sst["si"];
+	return (Array.isArray(siRaw) ? siRaw : siRaw !== void 0 ? [siRaw] : []).map((item) => capLen(extractSiText(item)));
+}
+function extractSiText(si) {
+	if (typeof si === "string") return si;
+	if (typeof si === "number") return String(si);
+	if (!si || typeof si !== "object") return "";
+	const obj = si;
+	const t = obj["t"];
+	const direct = textOf(t);
+	if (direct) return direct;
+	const r = obj["r"];
+	if (Array.isArray(r)) return r.map((rr) => textOf(rr?.["t"])).join("");
+	if (r && typeof r === "object") return textOf(r["t"]);
+	return "";
+}
+function textOf(node) {
+	if (typeof node === "string") return 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 === "number") return String(inner);
+	return "";
+}
+//#endregion
+export { parseSharedStrings };

package/dist/esm/ooxml/spreadsheet/styles-parser.d.ts

@@ -0,0 +1,52 @@
+export interface XlsxFont {
+    readonly sizePt?: number;
+    readonly bold?: boolean;
+    readonly italic?: boolean;
+    readonly underline?: boolean;
+    readonly colorHex?: string;
+    readonly name?: string;
+}
+export interface XlsxFill {
+    readonly patternType?: string;
+    readonly fgColorHex?: string;
+    readonly bgColorHex?: string;
+}
+export type XlsxBorderStyleName = 'none' | 'thin' | 'medium' | 'thick' | 'hair' | 'dashed' | 'dotted' | 'double' | 'mediumDashed' | 'dashDot' | 'mediumDashDot' | 'dashDotDot' | 'mediumDashDotDot' | 'slantDashDot';
+export interface XlsxBorderEdge {
+    readonly style?: XlsxBorderStyleName;
+    readonly colorHex?: string;
+}
+export interface XlsxBorder {
+    readonly top?: XlsxBorderEdge;
+    readonly right?: XlsxBorderEdge;
+    readonly bottom?: XlsxBorderEdge;
+    readonly left?: XlsxBorderEdge;
+}
+export type XlsxHorizontalAlign = 'left' | 'center' | 'right' | 'fill' | 'justify' | 'centerContinuous' | 'distributed';
+export type XlsxVerticalAlign = 'top' | 'center' | 'bottom' | 'justify' | 'distributed';
+export interface XlsxCellAlignment {
+    readonly horizontal?: XlsxHorizontalAlign;
+    readonly vertical?: XlsxVerticalAlign;
+    readonly wrapText?: boolean;
+}
+export interface XlsxCellXf {
+    readonly numFmtId: number;
+    readonly fontId: number;
+    readonly fillId: number;
+    readonly borderId: number;
+    readonly applyNumberFormat?: boolean;
+    readonly applyFont?: boolean;
+    readonly applyFill?: boolean;
+    readonly applyBorder?: boolean;
+    readonly applyAlignment?: boolean;
+    readonly alignment?: XlsxCellAlignment;
+}
+export interface XlsxStyles {
+    readonly numFmts: ReadonlyMap<number, string>;
+    readonly fonts: ReadonlyArray<XlsxFont>;
+    readonly fills: ReadonlyArray<XlsxFill>;
+    readonly borders: ReadonlyArray<XlsxBorder>;
+    readonly cellXfs: ReadonlyArray<XlsxCellXf>;
+}
+export declare const EMPTY_XLSX_STYLES: XlsxStyles;
+export declare function parseXlsxStyles(data: Uint8Array): XlsxStyles;