reamkit 1.14.0 → 1.15.0

package/dist/esm/excel/formula/index.d.ts

@@ -0,0 +1,14 @@
+import { Ast } from './parser.js';
+import { EvalContext } from './context.js';
+import { Shift } from './eval.js';
+export type { EvalContext } from './context.js';
+export type { Shift } from './eval.js';
+export type { Scalar, FValue, Rect, FErr } from './value.js';
+export { num, str, bool, err, BLANK } from './value.js';
+export { serialFromDate, serialToParts, timePeriodMatches } from './dates.js';
+export { NO_SHIFT, evaluate } from './eval.js';
+export interface CompiledFormula {
+    readonly ast: Ast;
+}
+export declare function compileFormula(src: string): CompiledFormula | undefined;
+export declare function evaluateToBool(compiled: CompiledFormula, ctx: EvalContext, shift?: Shift): boolean;

package/dist/esm/excel/formula/index.js

@@ -0,0 +1,17 @@
+import { parse } from "./parser.js";
+import "./dates.js";
+import { toBool } from "./value.js";
+import { NO_SHIFT, evaluate } from "./eval.js";
+//#region src/excel/formula/index.ts
+function compileFormula(src) {
+	try {
+		return { ast: parse(src) };
+	} catch {
+		return;
+	}
+}
+function evaluateToBool(compiled, ctx, shift = NO_SHIFT) {
+	return toBool(evaluate(compiled.ast, ctx, shift), ctx) === true;
+}
+//#endregion
+export { compileFormula, evaluateToBool };

package/dist/esm/excel/formula/lexer.d.ts

@@ -0,0 +1,8 @@
+export type TokenKind = 'num' | 'str' | 'err' | 'word' | 'sheetq' | 'op' | 'eof';
+export interface Token {
+    readonly kind: TokenKind;
+    readonly text: string;
+}
+export declare class LexError extends Error {
+}
+export declare function tokenize(src: string): Array<Token>;

package/dist/esm/excel/formula/lexer.js

@@ -0,0 +1,163 @@
+//#region src/excel/formula/lexer.ts
+var MAX_SOURCE = 8192;
+var KNOWN_ERRORS = new Set([
+	"#NULL!",
+	"#DIV/0!",
+	"#VALUE!",
+	"#REF!",
+	"#NAME?",
+	"#NUM!",
+	"#N/A"
+]);
+var LexError = class extends Error {};
+function isDigit(ch) {
+	return ch >= "0" && ch <= "9";
+}
+function isWordStart(ch) {
+	return ch >= "A" && ch <= "Z" || ch >= "a" && ch <= "z" || ch === "_" || ch === "$";
+}
+function isWordPart(ch) {
+	return isWordStart(ch) || isDigit(ch) || ch === ".";
+}
+function tokenize(src) {
+	if (src.length > MAX_SOURCE) throw new LexError("formula too long");
+	const out = [];
+	let i = 0;
+	const n = src.length;
+	while (i < n) {
+		const ch = src[i];
+		if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+			i++;
+			continue;
+		}
+		if (ch === "'") {
+			let s = "";
+			i++;
+			while (i < n) {
+				if (src[i] === "'") {
+					if (src[i + 1] === "'") {
+						s += "'";
+						i += 2;
+						continue;
+					}
+					i++;
+					break;
+				}
+				s += src[i];
+				i++;
+			}
+			out.push({
+				kind: "sheetq",
+				text: s
+			});
+			continue;
+		}
+		if (ch === "\"") {
+			let s = "";
+			i++;
+			while (i < n) {
+				if (src[i] === "\"") {
+					if (src[i + 1] === "\"") {
+						s += "\"";
+						i += 2;
+						continue;
+					}
+					i++;
+					break;
+				}
+				s += src[i];
+				i++;
+			}
+			out.push({
+				kind: "str",
+				text: s
+			});
+			continue;
+		}
+		if (ch === "#") {
+			let j = i + 1;
+			while (j < n && /[A-Za-z0-9/!?]/.test(src[j])) j++;
+			const lit = src.slice(i, j).toUpperCase();
+			if (!KNOWN_ERRORS.has(lit)) throw new LexError(`bad error literal ${lit}`);
+			out.push({
+				kind: "err",
+				text: lit
+			});
+			i = j;
+			continue;
+		}
+		if (isDigit(ch) || ch === "." && i + 1 < n && isDigit(src[i + 1])) {
+			let j = i;
+			while (j < n && isDigit(src[j])) j++;
+			if (src[j] === ".") {
+				j++;
+				while (j < n && isDigit(src[j])) j++;
+			}
+			if (src[j] === "e" || src[j] === "E") {
+				let k = j + 1;
+				if (src[k] === "+" || src[k] === "-") k++;
+				if (k < n && isDigit(src[k])) {
+					k++;
+					while (k < n && isDigit(src[k])) k++;
+					j = k;
+				}
+			}
+			out.push({
+				kind: "num",
+				text: src.slice(i, j)
+			});
+			i = j;
+			continue;
+		}
+		if (isWordStart(ch)) {
+			let j = i + 1;
+			while (j < n && isWordPart(src[j])) j++;
+			out.push({
+				kind: "word",
+				text: src.slice(i, j)
+			});
+			i = j;
+			continue;
+		}
+		if (ch === "<" && src[i + 1] === "=") {
+			out.push({
+				kind: "op",
+				text: "<="
+			});
+			i += 2;
+			continue;
+		}
+		if (ch === ">" && src[i + 1] === "=") {
+			out.push({
+				kind: "op",
+				text: ">="
+			});
+			i += 2;
+			continue;
+		}
+		if (ch === "<" && src[i + 1] === ">") {
+			out.push({
+				kind: "op",
+				text: "<>"
+			});
+			i += 2;
+			continue;
+		}
+		if ("+-*/^&=<>%:(),!{};".includes(ch)) {
+			out.push({
+				kind: "op",
+				text: ch
+			});
+			i++;
+			continue;
+		}
+		throw new LexError(`unexpected character ${JSON.stringify(ch)}`);
+	}
+	out.push({
+		kind: "eof",
+		text: ""
+	});
+	return out;
+}
+//#endregion
+export { tokenize };

package/dist/esm/excel/formula/parser.d.ts

@@ -0,0 +1,57 @@
+import { FErr } from './value.js';
+export interface Axis {
+    readonly index: number;
+    readonly abs: boolean;
+}
+export interface CellRef {
+    readonly col: Axis;
+    readonly row: Axis;
+}
+export type Ast = {
+    readonly k: 'num';
+    readonly v: number;
+} | {
+    readonly k: 'str';
+    readonly v: string;
+} | {
+    readonly k: 'bool';
+    readonly v: boolean;
+} | {
+    readonly k: 'err';
+    readonly v: FErr;
+} | {
+    readonly k: 'cell';
+    readonly ref: CellRef;
+    readonly sheet?: string;
+} | {
+    readonly k: 'range';
+    readonly a: CellRef;
+    readonly b: CellRef;
+    readonly sheet?: string;
+} | {
+    readonly k: 'name';
+    readonly name: string;
+} | {
+    readonly k: 'array';
+    readonly rows: ReadonlyArray<ReadonlyArray<Ast>>;
+} | {
+    readonly k: 'unary';
+    readonly op: '-' | '+';
+    readonly x: Ast;
+} | {
+    readonly k: 'pct';
+    readonly x: Ast;
+} | {
+    readonly k: 'bin';
+    readonly op: BinOp;
+    readonly a: Ast;
+    readonly b: Ast;
+} | {
+    readonly k: 'call';
+    readonly name: string;
+    readonly args: ReadonlyArray<Ast>;
+};
+export type BinOp = '+' | '-' | '*' | '/' | '^' | '&' | '=' | '<>' | '<' | '>' | '<=' | '>=';
+export declare class ParseError extends Error {
+}
+export declare function parse(src: string): Ast;

package/dist/esm/excel/formula/parser.js

@@ -0,0 +1,274 @@
+import { tokenize } from "./lexer.js";
+//#region src/excel/formula/parser.ts
+var ParseError = class extends Error {};
+var PREC = {
+	"=": 1,
+	"<>": 1,
+	"<": 1,
+	">": 1,
+	"<=": 1,
+	">=": 1,
+	"&": 2,
+	"+": 3,
+	"-": 3,
+	"*": 4,
+	"/": 4,
+	"^": 5
+};
+var RIGHT_ASSOC = new Set(["^"]);
+var MAX_DEPTH = 64;
+var MAX_ARGS = 255;
+var CELL_RE = /^(\$?)([A-Za-z]{1,3})(\$?)([0-9]{1,7})$/;
+var MAX_COL = 16383;
+var MAX_ROW = 1048575;
+function parse(src) {
+	const parser = new Parser(tokenize(src));
+	const ast = parser.parseExpr(0);
+	parser.expectEof();
+	return ast;
+}
+var Parser = class {
+	pos = 0;
+	depth = 0;
+	constructor(toks) {
+		this.toks = toks;
+	}
+	peek() {
+		return this.toks[this.pos];
+	}
+	next() {
+		return this.toks[this.pos++];
+	}
+	expectEof() {
+		if (this.peek().kind !== "eof") throw new ParseError(`trailing tokens at ${this.pos}`);
+	}
+	parseExpr(minBp) {
+		if (++this.depth > MAX_DEPTH) throw new ParseError("expression too deep");
+		let left = this.parseUnary();
+		for (;;) {
+			const t = this.peek();
+			if (t.kind !== "op" || !(t.text in PREC)) break;
+			const op = t.text;
+			const p = PREC[op];
+			if (p < minBp) break;
+			this.next();
+			const right = this.parseExpr(RIGHT_ASSOC.has(op) ? p : p + 1);
+			left = {
+				k: "bin",
+				op,
+				a: left,
+				b: right
+			};
+		}
+		this.depth--;
+		return left;
+	}
+	parseUnary() {
+		const t = this.peek();
+		if (t.kind === "op" && (t.text === "-" || t.text === "+")) {
+			this.next();
+			return {
+				k: "unary",
+				op: t.text,
+				x: this.parseUnary()
+			};
+		}
+		return this.parsePostfix();
+	}
+	parsePostfix() {
+		let x = this.parsePrimary();
+		while (this.peek().kind === "op" && this.peek().text === "%") {
+			this.next();
+			x = {
+				k: "pct",
+				x
+			};
+		}
+		return x;
+	}
+	parsePrimary() {
+		const t = this.next();
+		switch (t.kind) {
+			case "num": {
+				const v = Number(t.text);
+				if (!Number.isFinite(v)) throw new ParseError(`bad number ${t.text}`);
+				return {
+					k: "num",
+					v
+				};
+			}
+			case "str": return {
+				k: "str",
+				v: t.text
+			};
+			case "err": return {
+				k: "err",
+				v: t.text
+			};
+			case "word":
+				if (this.peek().kind === "op" && this.peek().text === "!") {
+					this.next();
+					return this.parseSheetCell(t.text);
+				}
+				return this.parseWord(t.text);
+			case "sheetq":
+				this.expect("!");
+				return this.parseSheetCell(t.text);
+			case "op":
+				if (t.text === "(") {
+					const e = this.parseExpr(0);
+					this.expect(")");
+					return e;
+				}
+				if (t.text === "{") return this.parseArray();
+				throw new ParseError(`unexpected operator ${t.text}`);
+			case "eof": throw new ParseError("unexpected end of formula");
+		}
+	}
+	parseWord(word) {
+		if (this.peek().kind === "op" && this.peek().text === "(") {
+			this.next();
+			const args = this.parseArgs();
+			this.expect(")");
+			return {
+				k: "call",
+				name: word.toUpperCase(),
+				args
+			};
+		}
+		const upper = word.toUpperCase();
+		if (upper === "TRUE") return {
+			k: "bool",
+			v: true
+		};
+		if (upper === "FALSE") return {
+			k: "bool",
+			v: false
+		};
+		const ref = parseCellRef(word);
+		if (ref) {
+			if (this.peek().kind === "op" && this.peek().text === ":") {
+				const save = this.pos;
+				this.next();
+				const rhs = this.peek();
+				if (rhs.kind === "word") {
+					const b = parseCellRef(rhs.text);
+					if (b) {
+						this.next();
+						return {
+							k: "range",
+							a: ref,
+							b
+						};
+					}
+				}
+				this.pos = save;
+			}
+			return {
+				k: "cell",
+				ref
+			};
+		}
+		return {
+			k: "name",
+			name: upper
+		};
+	}
+	parseSheetCell(sheet) {
+		const t = this.next();
+		if (t.kind !== "word") throw new ParseError("expected a cell after !");
+		const a = parseCellRef(t.text);
+		if (!a) throw new ParseError("expected a cell reference after !");
+		if (this.peek().kind === "op" && this.peek().text === ":") {
+			this.next();
+			const rhs = this.next();
+			if (rhs.kind !== "word") throw new ParseError("expected a cell after :");
+			const b = parseCellRef(rhs.text);
+			if (!b) throw new ParseError("bad range end after !");
+			return {
+				k: "range",
+				a,
+				b,
+				sheet
+			};
+		}
+		return {
+			k: "cell",
+			ref: a,
+			sheet
+		};
+	}
+	parseArray() {
+		const rows = [];
+		let row = [];
+		let count = 0;
+		for (;;) {
+			row.push(this.parseExpr(0));
+			if (++count > MAX_ARGS) throw new ParseError("array constant too large");
+			const t = this.peek();
+			if (t.kind === "op" && t.text === ",") {
+				this.next();
+				continue;
+			}
+			if (t.kind === "op" && t.text === ";") {
+				this.next();
+				rows.push(row);
+				row = [];
+				continue;
+			}
+			break;
+		}
+		rows.push(row);
+		this.expect("}");
+		return {
+			k: "array",
+			rows
+		};
+	}
+	parseArgs() {
+		const args = [];
+		if (this.peek().kind === "op" && this.peek().text === ")") return args;
+		for (;;) {
+			args.push(this.parseExpr(0));
+			if (args.length > MAX_ARGS) throw new ParseError("too many arguments");
+			const t = this.peek();
+			if (t.kind === "op" && t.text === ",") {
+				this.next();
+				continue;
+			}
+			break;
+		}
+		return args;
+	}
+	expect(op) {
+		const t = this.next();
+		if (t.kind !== "op" || t.text !== op) throw new ParseError(`expected ${op}`);
+	}
+};
+function parseCellRef(word) {
+	const m = CELL_RE.exec(word);
+	if (!m) return void 0;
+	const colAbs = m[1] === "$";
+	const col = columnToIndex(m[2]);
+	const rowAbs = m[3] === "$";
+	const row = Number(m[4]) - 1;
+	if (col > MAX_COL || row < 0 || row > MAX_ROW) return void 0;
+	return {
+		col: {
+			index: col,
+			abs: colAbs
+		},
+		row: {
+			index: row,
+			abs: rowAbs
+		}
+	};
+}
+function columnToIndex(letters) {
+	let idx = 0;
+	const up = letters.toUpperCase();
+	for (let i = 0; i < up.length; i++) idx = idx * 26 + (up.charCodeAt(i) - 64);
+	return idx - 1;
+}
+//#endregion
+export { parse };

package/dist/esm/excel/formula/value.d.ts

@@ -0,0 +1,52 @@
+import { EvalContext } from './context.js';
+export type FErr = '#NULL!' | '#DIV/0!' | '#VALUE!' | '#REF!' | '#NAME?' | '#NUM!' | '#N/A';
+export interface Rect {
+    readonly r0: number;
+    readonly c0: number;
+    readonly r1: number;
+    readonly c1: number;
+}
+export type Scalar = {
+    readonly t: 'num';
+    readonly v: number;
+} | {
+    readonly t: 'str';
+    readonly v: string;
+} | {
+    readonly t: 'bool';
+    readonly v: boolean;
+} | {
+    readonly t: 'err';
+    readonly v: FErr;
+} | {
+    readonly t: 'blank';
+};
+export type FValue = Scalar | {
+    readonly t: 'ref';
+    readonly rect: Rect;
+    readonly sheet?: number;
+} | {
+    readonly t: 'arr';
+    readonly rows: ReadonlyArray<ReadonlyArray<Scalar>>;
+};
+export declare const BLANK: Scalar;
+export declare const TRUE: Scalar;
+export declare const FALSE: Scalar;
+export declare function num(v: number): Scalar;
+export declare function str(v: string): Scalar;
+export declare function bool(v: boolean): Scalar;
+export declare function err(v: FErr): Scalar;
+export declare function isErr(v: FValue): v is {
+    t: 'err';
+    v: FErr;
+};
+export declare function deref(v: FValue, ctx: EvalContext): Scalar;
+export declare function arrEach(rows: ReadonlyArray<ReadonlyArray<Scalar>>, visit: (value: Scalar) => void): void;
+export declare function refEach(v: {
+    readonly rect: Rect;
+    readonly sheet?: number;
+}, ctx: EvalContext, visit: (row: number, col: number, value: Scalar) => void): void;
+export declare function refGet(sheet: number | undefined, ctx: EvalContext, row: number, col: number): Scalar;
+export declare function toNumber(v: FValue, ctx: EvalContext): number | FErr;
+export declare function toText(v: FValue, ctx: EvalContext): string | FErr;
+export declare function toBool(v: FValue, ctx: EvalContext): boolean | FErr;

package/dist/esm/excel/formula/value.js

@@ -0,0 +1,102 @@
+//#region src/excel/formula/value.ts
+var BLANK = { t: "blank" };
+var TRUE = {
+	t: "bool",
+	v: true
+};
+var FALSE = {
+	t: "bool",
+	v: false
+};
+function num(v) {
+	return Number.isFinite(v) ? {
+		t: "num",
+		v
+	} : {
+		t: "err",
+		v: "#NUM!"
+	};
+}
+function str(v) {
+	return {
+		t: "str",
+		v
+	};
+}
+function bool(v) {
+	return v ? TRUE : FALSE;
+}
+function err(v) {
+	return {
+		t: "err",
+		v
+	};
+}
+function isErr(v) {
+	return v.t === "err";
+}
+function deref(v, ctx) {
+	if (v.t === "arr") return v.rows[0]?.[0] ?? BLANK;
+	if (v.t !== "ref") return v;
+	const { r0, c0, r1, c1 } = v.rect;
+	if (r0 === r1 && c0 === c1) return refGet(v.sheet, ctx, r0, c0);
+	return err("#VALUE!");
+}
+function arrEach(rows, visit) {
+	for (const row of rows) for (const s of row) visit(s);
+}
+function refEach(v, ctx, visit) {
+	if (v.sheet !== void 0) ctx.eachCellOn?.(v.sheet, v.rect, visit);
+	else ctx.eachCell(v.rect, visit);
+}
+function refGet(sheet, ctx, row, col) {
+	return sheet !== void 0 ? ctx.getCellOn?.(sheet, row, col) ?? BLANK : ctx.getCell(row, col);
+}
+function toNumber(v, ctx) {
+	const s = deref(v, ctx);
+	switch (s.t) {
+		case "num": return s.v;
+		case "bool": return s.v ? 1 : 0;
+		case "blank": return 0;
+		case "err": return s.v;
+		case "str": {
+			const trimmed = s.v.trim();
+			if (trimmed === "") return "#VALUE!";
+			const n = Number(trimmed);
+			return Number.isFinite(n) ? n : "#VALUE!";
+		}
+	}
+}
+function toText(v, ctx) {
+	const s = deref(v, ctx);
+	switch (s.t) {
+		case "str": return s.v;
+		case "num": return numToText(s.v);
+		case "bool": return s.v ? "TRUE" : "FALSE";
+		case "blank": return "";
+		case "err": return s.v;
+	}
+}
+function toBool(v, ctx) {
+	const s = deref(v, ctx);
+	switch (s.t) {
+		case "bool": return s.v;
+		case "num": return s.v !== 0;
+		case "blank": return false;
+		case "err": return s.v;
+		case "str": {
+			const u = s.v.trim().toUpperCase();
+			if (u === "TRUE") return true;
+			if (u === "FALSE") return false;
+			const n = Number(s.v.trim());
+			if (s.v.trim() !== "" && Number.isFinite(n)) return n !== 0;
+			return "#VALUE!";
+		}
+	}
+}
+function numToText(n) {
+	if (Number.isInteger(n)) return String(n);
+	return String(n);
+}
+//#endregion
+export { BLANK, arrEach, bool, deref, err, isErr, num, refEach, refGet, str, toBool, toNumber, toText };

package/dist/esm/excel/number-format.d.ts

@@ -1 +1,3 @@
 export declare function applyNumberFormat(rawValue: string, numFmtId: number, customFormats: ReadonlyMap<number, string>, date1904?: boolean): string;
+export declare function excelSerialToDate(serial: number, date1904: boolean): Date;
+export declare function excelSerialFromUtcParts(year: number, month0: number, day: number, date1904: boolean): number;

package/dist/esm/excel/number-format.js

@@ -46,6 +46,10 @@ function excelSerialToDate(serial, date1904) {
 	if (date1904) return new Date(Date.UTC(1904, 0, 1) + ms);
 	return new Date(Date.UTC(1899, 11, 30) + ms);
 }
+function excelSerialFromUtcParts(year, month0, day, date1904) {
+	const epoch = date1904 ? Date.UTC(1904, 0, 1) : Date.UTC(1899, 11, 30);
+	return Math.round((Date.UTC(year, month0, day) - epoch) / 864e5);
+}
 var MONTH_ABBR = [
 	"Jan",
 	"Feb",
@@ -435,4 +439,4 @@ function unquoteLiteral(s) {
 	return out;
 }
 //#endregion
-export { applyNumberFormat };
+export { applyNumberFormat, excelSerialFromUtcParts, excelSerialToDate };