@aliou/obsdx-base-engine 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1159 @@
+import { parseExpression } from "@aliou/obsdx-base-ast";
+//#region src/math.ts
+function numericValues(values) {
+	return values.filter((value) => typeof value === "number" && Number.isFinite(value));
+}
+function sumNumbers(values) {
+	return numericValues(values).reduce((total, value) => total + value, 0);
+}
+function meanNumbers(values) {
+	const numbers = numericValues(values);
+	return numbers.length > 0 ? sumNumbers(numbers) / numbers.length : null;
+}
+function minNumber(values) {
+	const numbers = numericValues(values);
+	return numbers.length > 0 ? Math.min(...numbers) : null;
+}
+function maxNumber(values) {
+	const numbers = numericValues(values);
+	return numbers.length > 0 ? Math.max(...numbers) : null;
+}
+function medianNumbers(values) {
+	const numbers = numericValues(values).sort((left, right) => left - right);
+	if (numbers.length === 0) return null;
+	const middle = Math.floor(numbers.length / 2);
+	if (numbers.length % 2 === 1) return numbers[middle] ?? null;
+	return ((numbers[middle - 1] ?? 0) + (numbers[middle] ?? 0)) / 2;
+}
+function stddevNumbers(values) {
+	const numbers = numericValues(values);
+	const average = meanNumbers(numbers);
+	if (average === null) return null;
+	return Math.sqrt(numbers.reduce((total, value) => total + (value - average) ** 2, 0) / numbers.length);
+}
+//#endregion
+//#region src/expressions/evaluator.ts
+var BaseEngineError = class extends Error {
+	code;
+	details;
+	constructor(code, message, details = {}) {
+		super(message);
+		this.code = code;
+		this.details = details;
+		this.name = "BaseEngineError";
+	}
+};
+function evaluateExpression(expr, context) {
+	switch (expr.kind) {
+		case "literal": return expr.value;
+		case "regex": return new RegExp(expr.pattern, expr.flags);
+		case "array": return expr.elements.map((element) => evaluateExpression(element, context));
+		case "identifier": return readIdentifier(expr.name, context);
+		case "member": return readMember(evaluateExpression(expr.object, context), expr.property, context);
+		case "index": return readIndex(evaluateExpression(expr.object, context), evaluateExpression(expr.index, context));
+		case "call":
+			if (expr.callee.kind === "member" && expr.callee.property === "filter") {
+				const source = listValue(evaluateExpression(expr.callee.object, context));
+				const predicate = expr.args[0];
+				return predicate ? source.filter((value) => truthy(evaluateExpression(predicate, {
+					...context,
+					value
+				}))) : source;
+			}
+			if (expr.callee.kind === "member" && expr.callee.property === "map") {
+				const source = listValue(evaluateExpression(expr.callee.object, context));
+				const mapper = expr.args[0];
+				return mapper ? source.map((value) => evaluateExpression(mapper, {
+					...context,
+					value
+				})) : source;
+			}
+			if (expr.callee.kind === "member" && expr.callee.property === "reduce") {
+				const source = listValue(evaluateExpression(expr.callee.object, context));
+				const reducer = expr.args[0];
+				if (!reducer) return null;
+				let acc = expr.args.length > 1 ? evaluateExpression(expr.args[1], context) : source[0];
+				const values = expr.args.length > 1 ? source : source.slice(1);
+				for (const value of values) acc = evaluateExpression(reducer, {
+					...context,
+					acc,
+					value
+				});
+				return acc;
+			}
+			if (expr.callee.kind === "member" && expr.callee.property === "matches") {
+				if (typeof evaluateExpression(expr.callee.object, context) === "string") throw new BaseEngineError("FORMULA_EVAL_ERROR", "Cannot find function \"matches\" on type String");
+			}
+			if (expr.callee.kind === "identifier") return callValue(readFunctionIdentifier(expr.callee.name, context) ?? evaluateExpression(expr.callee, context), expr.args.map((arg) => evaluateExpression(arg, context)));
+			return callValue(evaluateExpression(expr.callee, context), expr.args.map((arg) => evaluateExpression(arg, context)));
+		case "unary": {
+			const value = evaluateExpression(expr.right, context);
+			return expr.operator === "!" ? !truthy(value) : -numberValue(value);
+		}
+		case "binary": return evaluateBinary(expr.operator, evaluateExpression(expr.left, context), evaluateExpression(expr.right, context));
+	}
+}
+function readIdentifier(name, context) {
+	if (name === "file") return fileObject(context.row, context);
+	if (name === "note") return noteObject(context.row);
+	if (name === "property") return null;
+	if (name === "formula") return context.formulas;
+	if (name === "this") return context.context ? thisObject(context.context, context) : null;
+	if (name === "value") return context.value ?? null;
+	if (name === "acc") return context.acc ?? null;
+	if (name === "values") return context.values ?? null;
+	const property = readProperty(context.row, name);
+	if (property !== null) return property;
+	return null;
+}
+function readFunctionIdentifier(name, context) {
+	if (name === "list") return callable((args) => {
+		if (args.length > 1) throw new BaseEngineError("FORMULA_EVAL_ERROR", "Cannot call function \"list\", too many arguments.");
+		return args.flatMap((arg) => listValue(arg));
+	});
+	if (name === "link") return callable((args) => {
+		const target = String(args[0] ?? "");
+		const display = args[1];
+		const unwrapped = target.replace(/^\[\[/u, "").replace(/\]\]$/u, "");
+		if (display !== void 0 && display !== null) return `[[${unwrapped}|${String(display)}]]`;
+		return `[[${unwrapped}]]`;
+	});
+	if (name === "if") return callable((args) => truthy(args[0]) ? args[1] : args[2] ?? null);
+	if (name === "now") return callable(() => /* @__PURE__ */ new Date());
+	if (name === "today") return callable(() => {
+		const d = /* @__PURE__ */ new Date();
+		return new Date(d.getFullYear(), d.getMonth(), d.getDate());
+	});
+	if (name === "date") return callable((args) => dateValue(args[0]));
+	if (name === "duration") return callable((args) => {
+		if (typeof args[0] === "string") return parseDuration(args[0]) ?? null;
+		if (typeof args[0] === "number") return durationValue(args[0]);
+		return null;
+	});
+	if (name === "number") return callable((args) => {
+		const val = args[0];
+		if (typeof val === "boolean") return val ? 1 : 0;
+		const result = numberValue(val);
+		if (typeof val === "string" && val.trim() !== "" && !Number.isFinite(Number(val))) throw new BaseEngineError("FORMULA_EVAL_ERROR", `Unable to parse "${val}" as a number.`);
+		return result;
+	});
+	if (name === "file") return callable((args) => {
+		const target = String(args[0] ?? "");
+		const inspection = context.byPath.get(target) ?? context.byBasename.get(normalizeComparable$1(target));
+		return inspection ? fileObject(inspection, context) : null;
+	});
+	if (name === "min") return callable((args) => Math.min(...args.map((a) => numberValue(a))));
+	if (name === "max") return callable((args) => Math.max(...args.map((a) => numberValue(a))));
+	if (name === "escapeHTML") return callable((args) => escapeHtml(String(args[0] ?? "")));
+	if (name === "html") return callable((args) => String(args[0] ?? ""));
+	if (name === "image") return callable((args) => `![](${String(args[0] ?? "")})`);
+	if (name === "icon") return callable((args) => String(args[0] ?? ""));
+	if (name === "random") return callable(() => Math.random());
+	return null;
+}
+function readMember(value, property, context) {
+	if (value === null || value === void 0) {
+		if (property === "isEmpty") return callable(() => true);
+		if (property === "contains" || property === "containsAny") return callable(() => false);
+		if (property === "asLink" || property === "asFile" || property === "hasLink" || property === "hasProperty" || property === "hasTag" || property === "inFolder") return callable(() => null);
+		if (property === "round" || property === "floor" || property === "ceil") return callable(() => null);
+		if (property === "toFixed") return callable(() => null);
+		if (property === "toString") return callable(() => "");
+		if (property === "matches") return callable(() => false);
+		if (property === "join" || property === "sort" || property === "map") return callable(() => []);
+		if (property === "containsAll") return callable(() => false);
+		if (property === "format") return callable(() => null);
+		if (property === "keys" || property === "values") return callable(() => []);
+		if (property === "length") return 0;
+		return null;
+	}
+	if (isDuration(value) && property in value) return value[property];
+	if (value instanceof RegExp) {
+		if (property === "matches") return callable((args) => value.test(String(args[0] ?? "")));
+	}
+	if (Array.isArray(value)) {
+		if (property === "length") return value.length;
+		if (property === "contains") return callable((args) => value.some((item) => sameComparable(item, args[0])));
+		if (property === "containsAny") return callable((args) => value.some((item) => args.flatMap((arg) => listValue(arg)).some((arg) => sameComparable(item, arg))));
+		if (property === "isEmpty") return callable(() => value.length === 0);
+		if (property === "unique") return callable(() => uniqueValues(value));
+		if (property === "sum") return callable(() => sumNumbers(value));
+		if (property === "mean" || property === "average") return callable(() => meanNumbers(value));
+		if (property === "min") return callable(() => minNumber(value));
+		if (property === "max") return callable(() => maxNumber(value));
+		if (property === "median") return callable(() => medianNumbers(value));
+		if (property === "stddev") return callable(() => stddevNumbers(value));
+		if (property === "filter") return callable((args) => {
+			const predicate = args[0];
+			return typeof predicate === "function" ? value.filter((item) => Boolean(predicate(item))) : value;
+		});
+		if (property === "containsAll") return callable((args) => {
+			return args.flatMap((arg) => listValue(arg)).every((item) => value.some((v) => sameComparable(v, item)));
+		});
+		if (property === "join") return callable((args) => value.join(String(args[0] ?? ", ")));
+		if (property === "sort") return callable(() => [...value].sort(compareValuesForSort));
+		if (property === "map") return callable((args) => {
+			const fn = args[0];
+			return typeof fn === "function" ? value.map((item) => fn(item)) : value;
+		});
+		if (property === "reduce") return callable(() => null);
+		if (property === "flat") return callable(() => value.flat(Number.POSITIVE_INFINITY));
+		if (property === "reverse") return callable(() => [...value].reverse());
+		if (property === "slice") return callable((args) => {
+			const start = numberValue(args[0]);
+			const end = args[1] !== void 0 ? numberValue(args[1]) : void 0;
+			return value.slice(start, end);
+		});
+	}
+	if (typeof value === "string") {
+		if (property === "length") return value.length;
+		if (property === "contains") return callable((args) => normalizeComparable$1(value).includes(normalizeComparable$1(args[0])));
+		if (property === "containsAny") return callable((args) => args.flatMap((arg) => listValue(arg)).some((arg) => normalizeComparable$1(value).includes(normalizeComparable$1(arg))));
+		if (property === "isEmpty") return callable(() => value.length === 0);
+		if (property === "toString") return callable(() => value);
+		if (property === "asFile") return callable(() => lookupFile(value, context));
+		if (property === "linksTo") return callable((args) => {
+			const source = lookupFile(value, context);
+			const target = linkTarget(args[0]);
+			return Boolean(source && sameComparable(isRecord$1(source) && isRecord$1(source.file) ? source.file.path : source.path, target));
+		});
+		if (property === "lower") return callable(() => value.toLowerCase());
+		if (property === "title") return callable(() => value.replace(/\b\w/gu, (char) => char.toUpperCase()));
+		if (property === "trim") return callable(() => value.trim());
+		if (property === "startsWith") return callable((args) => value.startsWith(String(args[0] ?? "")));
+		if (property === "endsWith") return callable((args) => value.endsWith(String(args[0] ?? "")));
+		if (property === "replace") return callable((args) => {
+			const pattern = String(args[0] ?? "");
+			const replacement = String(args[1] ?? "");
+			return value.split(pattern).join(replacement);
+		});
+		if (property === "repeat") return callable((args) => value.repeat(numberValue(args[0])));
+		if (property === "reverse") return callable(() => [...value].reverse().join(""));
+		if (property === "slice") return callable((args) => {
+			const start = numberValue(args[0]);
+			const end = args[1] !== void 0 ? numberValue(args[1]) : void 0;
+			return value.slice(start, end);
+		});
+		if (property === "split") return callable((args) => value.split(String(args[0] ?? "")));
+		if (property === "relative") {
+			const d = dateValue(value);
+			if (d) return callable(() => relativeTime(d));
+		}
+		if (property === "date") {
+			const d = dateValue(value);
+			if (d) return callable(() => new Date(d.getFullYear(), d.getMonth(), d.getDate()));
+		}
+		if (property === "time") {
+			const d = dateValue(value);
+			if (d) return callable(() => {
+				const pad = (n) => String(n).padStart(2, "0");
+				return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+			});
+		}
+		if (property === "format") {
+			const d = dateValue(value);
+			if (d) return callable((args) => {
+				return formatDate(d, String(args[0] ?? "YYYY-MM-DD"));
+			});
+		}
+	}
+	if (typeof value === "number") {
+		if (property === "round") return callable((args) => {
+			const digits = args[0];
+			if (digits === void 0 || digits === null) return Math.round(value);
+			const factor = 10 ** numberValue(digits);
+			return Math.round(value * factor) / factor;
+		});
+		if (property === "floor") return callable(() => Math.floor(value));
+		if (property === "ceil") return callable(() => Math.ceil(value));
+		if (property === "abs") return callable(() => Math.abs(value));
+		if (property === "toFixed") return callable((args) => value.toFixed(numberValue(args[0])));
+		if (property === "isEmpty") return callable(() => false);
+	}
+	if (value instanceof Date) {
+		if (property === "year") return value.getFullYear();
+		if (property === "month") return value.getMonth() + 1;
+		if (property === "day") return value.getDate();
+		if (property === "hour") return value.getHours();
+		if (property === "minute") return value.getMinutes();
+		if (property === "second") return value.getSeconds();
+		if (property === "millisecond") return value.getMilliseconds();
+		if (property === "date") return callable(() => new Date(value.getFullYear(), value.getMonth(), value.getDate()));
+		if (property === "time") return callable(() => {
+			const pad = (n) => String(n).padStart(2, "0");
+			return `${pad(value.getHours())}:${pad(value.getMinutes())}:${pad(value.getSeconds())}`;
+		});
+		if (property === "relative") return callable(() => relativeTime(value));
+		if (property === "isEmpty") return callable(() => false);
+		if (property === "toString") return callable(() => formatDateTimeForOutput(value));
+		if (property === "format") return callable((args) => {
+			return formatDate(value, String(args[0] ?? "YYYY-MM-DD"));
+		});
+	}
+	if (property === "isTruthy") return callable(() => truthy(value));
+	if (property === "isType") return callable((args) => {
+		const expected = String(args[0] ?? "");
+		if (expected === "number") return typeof value === "number";
+		if (expected === "string") return typeof value === "string";
+		if (expected === "boolean") return typeof value === "boolean";
+		if (expected === "null") return value === null;
+		if (expected === "date") return value instanceof Date;
+		if (expected === "list") return Array.isArray(value);
+		if (expected === "object") return isRecord$1(value);
+		return false;
+	});
+	if (property === "toString") return callable(() => String(value ?? ""));
+	if (property === "isEmpty") return callable(() => isEmpty(value));
+	if (isRecord$1(value)) {
+		if (property === "keys") return callable(() => Object.keys(value));
+		if (property === "values") return callable(() => Object.values(value));
+		const direct = value[property];
+		if (direct !== void 0) return direct;
+		if (property in value) return value[property];
+		const normalized = normalizeName(property);
+		for (const [key, item] of Object.entries(value)) if (normalizeName(key) === normalized) return item;
+	}
+	return null;
+}
+function readIndex(value, index) {
+	if (isRecord$1(value) && typeof index === "string") {
+		if (index in value) return value[index];
+		const normalized = normalizeName(index);
+		for (const [key, item] of Object.entries(value)) if (normalizeName(key) === normalized) return item;
+		return null;
+	}
+	if (!Array.isArray(value)) return null;
+	return value[numberValue(index)] ?? null;
+}
+function callValue(callee, args) {
+	if (isCallable(callee)) return callee.call(args);
+	throw new BaseEngineError("FORMULA_EVAL_ERROR", "Expression value is not callable");
+}
+function evaluateBinary(operator, left, right) {
+	switch (operator) {
+		case "&&": return truthy(left) && truthy(right);
+		case "||": return truthy(left) || truthy(right);
+		case "==": return equalValues(left, right);
+		case "!=": return !equalValues(left, right);
+		case "<": return comparableNumber(left) < comparableNumber(right);
+		case "<=": return comparableNumber(left) <= comparableNumber(right);
+		case ">": return comparableNumber(left) > comparableNumber(right);
+		case ">=": return comparableNumber(left) >= comparableNumber(right);
+		case "+": return addValues(left, right);
+		case "-": return subtractValues(left, right);
+		case "*": return multiplyValues(left, right);
+		case "/": return numberValue(left) / numberValue(right);
+		case "%": return numberValue(left) % numberValue(right);
+		default: throw new BaseEngineError("UNSUPPORTED_FORMULA", `Unsupported operator: ${operator}`, { operator });
+	}
+}
+function addValues(left, right) {
+	const leftDate = dateValue(left);
+	if (leftDate && typeof right === "string") {
+		const duration = parseDuration(right);
+		if (duration) return addDurationToDate(leftDate, duration, 1);
+	}
+	if (typeof left === "string" || typeof right === "string") return String(left ?? "") + String(right ?? "");
+	return numberValue(left) + numberValue(right);
+}
+function subtractValues(left, right) {
+	const leftDate = dateValue(left);
+	const rightDate = dateValue(right);
+	if (leftDate && isEmpty(right) || rightDate && isEmpty(left)) return null;
+	if (leftDate && rightDate) return durationValue(leftDate.valueOf() - rightDate.valueOf());
+	if (leftDate && typeof right === "string") {
+		const duration = parseDuration(right);
+		if (duration) return addDurationToDate(leftDate, duration, -1);
+	}
+	return numberValue(left) - numberValue(right);
+}
+function multiplyValues(left, right) {
+	if (isDuration(left)) {
+		const scalar = numberValue(right);
+		return durationValue(left.milliseconds * scalar);
+	}
+	if (isDuration(right)) {
+		const scalar = numberValue(left);
+		return durationValue(right.milliseconds * scalar);
+	}
+	return numberValue(left) * numberValue(right);
+}
+function fileObject(inspection, _context) {
+	const file = fileReference(inspection);
+	return {
+		...file,
+		file,
+		tags: inspection.tags.map((tag) => `#${tag.tag.replace(/^#/, "")}`),
+		links: inspection.links.flatMap((link) => link.resolvedPath ?? []),
+		backlinks: inspection.backlinks,
+		embeds: inspection.embeds.map((link) => link.resolvedPath ?? link.targetText),
+		properties: noteObject(inspection),
+		asLink: callable(() => `[[${inspection.file.path}]]`),
+		inFolder: callable((args) => inspection.file.folder === String(args[0] ?? "") || inspection.file.folder.startsWith(`${String(args[0] ?? "")}/`)),
+		hasTag: callable((args) => inspection.tags.some((tag) => args.some((arg) => tagMatches(tag.tag, arg)))),
+		hasLink: callable((args) => {
+			const target = linkTarget(args[0]);
+			return inspection.links.some((link) => sameComparable(link.resolvedPath ?? link.targetText, target));
+		}),
+		hasProperty: callable((args) => inspection.properties.some((property) => sameComparable(property.name, args[0])))
+	};
+}
+function thisObject(inspection, context) {
+	return {
+		file: fileObject(inspection, context),
+		asLink: callable(() => `[[${inspection.file.path}]]`),
+		...noteObject(inspection)
+	};
+}
+function fileReference(inspection) {
+	return {
+		name: inspection.file.basename,
+		basename: inspection.file.basename,
+		path: inspection.file.path,
+		folder: inspection.file.folder,
+		ext: inspection.file.ext,
+		size: inspection.file.size,
+		ctime: dateTimeString(inspection.file.ctime),
+		mtime: dateTimeString(inspection.file.mtime)
+	};
+}
+function noteObject(inspection) {
+	return Object.fromEntries(inspection.properties.map((property) => [property.name, property.value]));
+}
+function readProperty(inspection, name) {
+	const property = inspection.properties.find((candidate) => normalizeName(candidate.name) === normalizeName(name));
+	if (!property) return null;
+	if (property.name === "tags" && Array.isArray(property.value)) return property.value.map((tag) => `#${String(tag).replace(/^#/, "")}`);
+	return property.value;
+}
+function linkTarget(value) {
+	if (isRecord$1(value) && typeof value.path === "string") return value.path;
+	if (isRecord$1(value) && isRecord$1(value.file) && typeof value.file.path === "string") return value.file.path;
+	return value;
+}
+function lookupFile(value, context) {
+	const target = normalizeComparable$1(value);
+	const inspection = context.byPath.get(String(value)) ?? context.byBasename.get(target);
+	return inspection ? fileObject(inspection, context) : null;
+}
+function callable(call) {
+	return { call };
+}
+function isCallable(value) {
+	return isRecord$1(value) && typeof value.call === "function";
+}
+function listValue(value) {
+	if (Array.isArray(value)) return value;
+	if (value === null || value === void 0 || value === "") return [];
+	return [value];
+}
+function truthy(value) {
+	if (Array.isArray(value)) return value.length > 0;
+	return Boolean(value);
+}
+function isEmpty(value) {
+	if (value === null || value === void 0 || value === "") return true;
+	if (Array.isArray(value)) return value.length === 0;
+	return false;
+}
+function numberValue(value) {
+	if (typeof value === "number") return value;
+	if (value instanceof Date) return value.valueOf();
+	if (typeof value === "boolean") return value ? 1 : 0;
+	if (typeof value === "string") {
+		const parsed = Number(value);
+		return Number.isFinite(parsed) ? parsed : 0;
+	}
+	if (isDuration(value)) return value.milliseconds;
+	return 0;
+}
+function comparableNumber(value) {
+	const date = dateValue(value);
+	return date ? date.valueOf() : numberValue(value);
+}
+function dateValue(value) {
+	if (value instanceof Date) return value;
+	if (typeof value !== "string" || value.trim() === "") return null;
+	const trimmed = value.trim();
+	const dateOnly = trimmed.match(/^(\d{4})-(\d{2})-(\d{2})$/u);
+	if (dateOnly) return new Date(Number(dateOnly[1]), Number(dateOnly[2]) - 1, Number(dateOnly[3]));
+	const dateTime = trimmed.match(/^(\d{4})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?)$/u);
+	if (dateTime) return new Date(Number(dateTime[1]), Number(dateTime[2]) - 1, Number(dateTime[3]), Number(dateTime[4] ?? 0), Number(dateTime[5] ?? 0), Number(dateTime[6] ?? 0), Number((dateTime[7] ?? "0").padEnd(3, "0")));
+	const parsed = new Date(value);
+	return Number.isNaN(parsed.valueOf()) ? null : parsed;
+}
+const DURATION_UNITS = [
+	{
+		pattern: "d",
+		toDays: 1,
+		field: "days"
+	},
+	{
+		pattern: "w",
+		toDays: 7,
+		field: "days"
+	},
+	{
+		pattern: "M",
+		toDays: 31,
+		field: "months"
+	},
+	{
+		pattern: "y",
+		toDays: 365,
+		field: "years"
+	},
+	{
+		pattern: "h",
+		toDays: 1 / 24,
+		field: "hours"
+	},
+	{
+		pattern: "m",
+		toDays: 1 / 1440,
+		field: "minutes"
+	},
+	{
+		pattern: "s",
+		toDays: 1 / 86400,
+		field: "seconds"
+	},
+	{
+		pattern: "day",
+		toDays: 1,
+		field: "days"
+	},
+	{
+		pattern: "days",
+		toDays: 1,
+		field: "days"
+	},
+	{
+		pattern: "week",
+		toDays: 7,
+		field: "days"
+	},
+	{
+		pattern: "weeks",
+		toDays: 7,
+		field: "days"
+	},
+	{
+		pattern: "month",
+		toDays: 31,
+		field: "months"
+	},
+	{
+		pattern: "months",
+		toDays: 31,
+		field: "months"
+	},
+	{
+		pattern: "year",
+		toDays: 365,
+		field: "years"
+	},
+	{
+		pattern: "years",
+		toDays: 365,
+		field: "years"
+	},
+	{
+		pattern: "hour",
+		toDays: 1 / 24,
+		field: "hours"
+	},
+	{
+		pattern: "hours",
+		toDays: 1 / 24,
+		field: "hours"
+	},
+	{
+		pattern: "minute",
+		toDays: 1 / 1440,
+		field: "minutes"
+	},
+	{
+		pattern: "minutes",
+		toDays: 1 / 1440,
+		field: "minutes"
+	},
+	{
+		pattern: "second",
+		toDays: 1 / 86400,
+		field: "seconds"
+	},
+	{
+		pattern: "seconds",
+		toDays: 1 / 86400,
+		field: "seconds"
+	}
+];
+function parseDuration(value) {
+	const shortMatch = value.match(/^(\d+)([dwMmyhs])$/u);
+	if (shortMatch) {
+		const amount = Number(shortMatch[1]);
+		const unit = shortMatch[2];
+		const unitDef = DURATION_UNITS.find((u) => u.pattern === unit);
+		if (unitDef) return durationValue(amount * unitDef.toDays * 864e5, unitDef.field === "years" ? amount : 0, unitDef.field === "months" ? amount : 0, unitDef.field === "days" ? amount * unitDef.toDays : 0);
+	}
+	const namedMatch = value.match(/^(\d+)\s+(\S+)$/u);
+	if (namedMatch) {
+		const amount = Number(namedMatch[1]);
+		const unitName = namedMatch[2];
+		const unitDef = DURATION_UNITS.find((u) => u.pattern === unitName);
+		if (unitDef) return durationValue(amount * unitDef.toDays * 864e5, unitDef.field === "years" ? amount : 0, unitDef.field === "months" ? amount : 0, unitDef.field === "days" ? amount * unitDef.toDays : 0);
+	}
+	return null;
+}
+function durationValue(milliseconds, calendarYears = 0, calendarMonths = 0, calendarDays = 0) {
+	return {
+		milliseconds,
+		days: nearInteger(milliseconds / 864e5),
+		hours: nearInteger(milliseconds / 36e5),
+		minutes: nearInteger(milliseconds / 6e4),
+		seconds: nearInteger(milliseconds / 1e3),
+		months: nearInteger(milliseconds / (365.28478589915085 * 864e5 / 12)),
+		years: nearInteger(milliseconds / (365.28478589915085 * 864e5)),
+		calendarYears,
+		calendarMonths,
+		calendarDays
+	};
+}
+function nearInteger(value) {
+	const rounded = Math.round(value);
+	return Math.abs(value - rounded) < 1e-9 ? rounded : value;
+}
+function addDurationToDate(date, duration, direction) {
+	const next = new Date(date.valueOf());
+	const calendarYears = duration.calendarYears ?? 0;
+	const calendarMonths = duration.calendarMonths ?? 0;
+	const calendarDays = duration.calendarDays ?? 0;
+	if (calendarYears !== 0) next.setFullYear(next.getFullYear() + direction * calendarYears);
+	if (calendarMonths !== 0) next.setMonth(next.getMonth() + direction * calendarMonths);
+	if (calendarDays !== 0) next.setDate(next.getDate() + direction * calendarDays);
+	const calendarMilliseconds = calendarYears * 365 * 864e5 + calendarMonths * 31 * 864e5 + calendarDays * 864e5;
+	const clockMilliseconds = duration.milliseconds - calendarMilliseconds;
+	if (clockMilliseconds !== 0) next.setTime(next.valueOf() + direction * clockMilliseconds);
+	return next;
+}
+function dateTimeString(value) {
+	if (!value) return;
+	const date = new Date(value);
+	if (Number.isNaN(date.valueOf())) return value;
+	return formatDateTimeForOutput(date);
+}
+function formatDateTimeForOutput(date) {
+	const pad = (part) => String(part).padStart(2, "0");
+	const datePart = `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+	if (date.getHours() === 0 && date.getMinutes() === 0 && date.getSeconds() === 0 && date.getMilliseconds() === 0) return datePart;
+	return `${datePart}T${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+function relativeTime(date) {
+	const diff = Date.now() - date.valueOf();
+	const absDiff = Math.abs(diff);
+	const isPast = diff > 0;
+	const seconds = Math.floor(absDiff / 1e3);
+	const minutes = Math.floor(absDiff / 6e4);
+	const hours = Math.floor(absDiff / 36e5);
+	const days = Math.floor(absDiff / 864e5);
+	const months = Math.floor(absDiff / (31 * 864e5));
+	const years = Math.floor(absDiff / (365 * 864e5));
+	const suffix = isPast ? "ago" : "from now";
+	if (years > 0) return `${years} year${years > 1 ? "s" : ""} ${suffix}`;
+	if (months > 0) return `${months} month${months > 1 ? "s" : ""} ${suffix}`;
+	if (days > 0) return `${days} day${days > 1 ? "s" : ""} ${suffix}`;
+	if (hours > 0) return `${hours} hour${hours > 1 ? "s" : ""} ${suffix}`;
+	if (minutes > 0) return `${minutes} minute${minutes > 1 ? "s" : ""} ${suffix}`;
+	if (seconds > 0) return `${seconds} second${seconds > 1 ? "s" : ""} ${suffix}`;
+	return "just now";
+}
+function uniqueValues(values) {
+	const seen = /* @__PURE__ */ new Set();
+	return values.filter((value) => {
+		const key = normalizeComparable$1(value);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+function sameComparable(left, right) {
+	return normalizeComparable$1(left) === normalizeComparable$1(right);
+}
+function equalValues(left, right) {
+	if (typeof left === "string" && typeof right === "string") return left === right;
+	return sameComparable(left, right);
+}
+function normalizeComparable$1(value) {
+	if (isRecord$1(value) && typeof value.path === "string") return normalizeComparable$1(value.path);
+	if (isRecord$1(value) && isRecord$1(value.file) && typeof value.file.path === "string") return normalizeComparable$1(value.file.path);
+	return String(value).replace(/^#/u, "").replace(/^\[\[/u, "").replace(/\]\]$/u, "").replace(/\.md$/u, "").split("/").at(-1)?.toLowerCase() ?? "";
+}
+function tagMatches(tag, value) {
+	const normalizedTag = normalizeComparable$1(tag);
+	const normalizedValue = normalizeComparable$1(value);
+	return normalizedTag === normalizedValue || normalizedTag.startsWith(`${normalizedValue}/`);
+}
+function normalizeName(name) {
+	return name.replace(/-/gu, "").toLowerCase();
+}
+function isDuration(value) {
+	return isRecord$1(value) && typeof value.milliseconds === "number" && typeof value.days === "number";
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function formatDate(date, pattern) {
+	const pad = (n, width = 2) => String(n).padStart(width, "0");
+	const dayNames = [
+		"Sunday",
+		"Monday",
+		"Tuesday",
+		"Wednesday",
+		"Thursday",
+		"Friday",
+		"Saturday"
+	];
+	const dayNamesShort = [
+		"Sun",
+		"Mon",
+		"Tue",
+		"Wed",
+		"Thu",
+		"Fri",
+		"Sat"
+	];
+	const monthNames = [
+		"January",
+		"February",
+		"March",
+		"April",
+		"May",
+		"June",
+		"July",
+		"August",
+		"September",
+		"October",
+		"November",
+		"December"
+	];
+	const monthNamesShort = [
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec"
+	];
+	const day = date.getDate();
+	const ordinal = (n) => {
+		const suffix = [
+			"th",
+			"st",
+			"nd",
+			"rd"
+		];
+		const v = n % 100;
+		return n + (suffix[(v - 20) % 10] ?? suffix[v] ?? suffix[0]);
+	};
+	return pattern.replace(/dddd/gu, dayNames[date.getDay()] ?? "").replace(/ddd/gu, dayNamesShort[date.getDay()] ?? "").replace(/DD/gu, pad(date.getDate())).replace(/Do/gu, ordinal(day)).replace(/MMMM/gu, monthNames[date.getMonth()] ?? "").replace(/MMM/gu, monthNamesShort[date.getMonth()] ?? "").replace(/MM/gu, pad(date.getMonth() + 1)).replace(/YYYY/gu, String(date.getFullYear())).replace(/YY/gu, String(date.getFullYear()).slice(-2)).replace(/HH/gu, pad(date.getHours())).replace(/mm/gu, pad(date.getMinutes())).replace(/ss/gu, pad(date.getSeconds()));
+}
+function compareValuesForSort(a, b) {
+	if (typeof a === "number" && typeof b === "number") return a - b;
+	return String(a ?? "").localeCompare(String(b ?? ""));
+}
+function escapeHtml(value) {
+	return value.replace(/&/gu, "&amp;").replace(/</gu, "&lt;").replace(/>/gu, "&gt;").replace(/"/gu, "&quot;").replace(/'/gu, "&#39;");
+}
+//#endregion
+//#region src/query.ts
+function queryBase(base, inspections, options = {}) {
+	const byPath = new Map(inspections.map((inspection) => [inspection.file.path, inspection]));
+	const byBasename = new Map(inspections.map((inspection) => [normalizeComparable(inspection.file.basename), inspection]));
+	const context = options.context ? byPath.get(options.context) : void 0;
+	const view = selectView(base, options.view);
+	const columns = buildColumns(base, view);
+	const rows = [];
+	for (const inspection of inspections) {
+		const formulas = evaluateFormulas(base, inspection, {
+			row: inspection,
+			context,
+			formulas: {},
+			byPath,
+			byBasename
+		});
+		const evalContext = {
+			row: inspection,
+			context,
+			formulas,
+			byPath,
+			byBasename
+		};
+		if (inspection.file.kind !== "markdown" || !evaluateFilters(base.filters, evalContext) || !evaluateFilters(view?.filters, evalContext)) continue;
+		rows.push({
+			file: sanitizeRowFile(inspection.file),
+			values: Object.fromEntries(columns.map((column) => [column.id, readColumnValue(column.id, evalContext)])),
+			formulas,
+			sortValues: Object.fromEntries((view?.sort ?? []).map((item) => [item.property, readColumnValue(item.property, evalContext)]))
+		});
+	}
+	rows.sort((left, right) => compareRows(left, right, view?.sort, columns));
+	const limitedRows = view?.limit && view.limit > 0 ? rows.slice(0, view.limit) : rows;
+	const resolvedColumns = resolveColumnTypes(columns, limitedRows, inspections);
+	return {
+		base: base.path,
+		view: view?.name,
+		context: options.context,
+		meta: buildMeta(view),
+		columns: resolvedColumns,
+		rows: limitedRows.map((row) => projectRow(row, resolvedColumns)),
+		groups: buildGroups(limitedRows, view),
+		summaries: buildSummaries(limitedRows, view, base)
+	};
+}
+function evaluateFormulas(base, _inspection, context) {
+	const formulas = {};
+	const evalContext = {
+		...context,
+		formulas
+	};
+	const evaluating = /* @__PURE__ */ new Set();
+	const evaluateFormula = (name) => {
+		if (Object.hasOwn(formulas, name)) return formulas[name];
+		const source = base.formulas[name];
+		if (source === void 0) return null;
+		if (evaluating.has(name)) throw new BaseEngineError("FORMULA_EVAL_ERROR", `Circular formula reference: ${name}`, { formula: name });
+		evaluating.add(name);
+		try {
+			formulas[name] = evaluateExpression(parseExpression(source), {
+				...evalContext,
+				formulas: new Proxy(formulas, { get: (target, property) => typeof property === "string" ? evaluateFormula(property) : Reflect.get(target, property) })
+			});
+		} catch (error) {
+			formulas[name] = error instanceof BaseEngineError ? error : new BaseEngineError("FORMULA_EVAL_ERROR", error instanceof Error ? error.message : String(error), { formula: name });
+		}
+		evaluating.delete(name);
+		return formulas[name];
+	};
+	for (const name of Object.keys(base.formulas)) evaluateFormula(name);
+	return formulas;
+}
+function evaluateFilters(filters, context) {
+	if (!filters) return true;
+	if (typeof filters === "string") return Boolean(evaluateExpression(parseExpression(filters), context));
+	if (Array.isArray(filters)) return filters.every((filter) => evaluateFilters(filter, context));
+	if (!isRecord(filters)) return true;
+	if (Array.isArray(filters.and)) return filters.and.every((filter) => evaluateFilters(filter, context));
+	if (Array.isArray(filters.or)) return filters.or.some((filter) => evaluateFilters(filter, context));
+	if (Array.isArray(filters.not)) return !filters.not.some((filter) => evaluateFilters(filter, context));
+	return true;
+}
+function readColumnValue(id, context) {
+	const value = evaluateExpression(parseExpression(id), context);
+	if (value !== null) return value;
+	for (const qualified of [`note.${id}`, `file.${id}`]) {
+		const resolved = evaluateExpression(parseExpression(qualified), context);
+		if (resolved !== null) return resolved;
+	}
+	return null;
+}
+function selectView(base, requested) {
+	if (!requested) return base.views[0];
+	const view = base.views.find((v) => v.name === requested);
+	if (!view) throw new BaseEngineError("BASE_VIEW_NOT_FOUND", `View not found: ${requested}`, {
+		requested,
+		availableViews: base.views.map((v) => v.name)
+	});
+	return view;
+}
+function buildColumns(base, view) {
+	return (view?.order && view.order.length > 0 ? view.order : Object.keys(base.properties)).map((id) => {
+		const property = findPropertyConfig(base.properties, id);
+		return {
+			id,
+			displayName: property?.displayName ?? defaultDisplayName(id),
+			type: valueType(property)
+		};
+	});
+}
+function defaultDisplayName(id) {
+	if (id === "file.name") return "name";
+	if (id === "file.mtime") return "modified time";
+	if (id === "file.ctime") return "created time";
+	if (id === "file.ext") return "extension";
+	if (id === "file.path") return "path";
+	return id.startsWith("formula.") ? id.slice(8) : id;
+}
+function findPropertyConfig(properties, id) {
+	return properties[id] ?? properties[`note.${id}`] ?? properties[`file.${id}`];
+}
+function valueType(_property) {
+	return "any";
+}
+function buildMeta(view) {
+	return {
+		type: view?.type,
+		name: view?.name,
+		filters: view?.filters,
+		order: view?.order ?? [],
+		sort: view?.sort,
+		limit: view?.limit,
+		groupBy: view?.groupBy,
+		summaries: view?.summaries
+	};
+}
+function projectRow(row, columns) {
+	const data = Object.fromEntries(columns.map((column) => [column.id, Object.hasOwn(row.values, column.id) ? row.values[column.id] : null]));
+	const file = {
+		path: row.file.path,
+		name: row.file.name
+	};
+	Object.defineProperties(file, {
+		basename: {
+			value: row.file.basename,
+			enumerable: false
+		},
+		ext: {
+			value: row.file.ext,
+			enumerable: false
+		},
+		folder: {
+			value: row.file.folder,
+			enumerable: false
+		},
+		size: {
+			value: row.file.size,
+			enumerable: false
+		},
+		ctime: {
+			value: row.file.ctime,
+			enumerable: false
+		},
+		mtime: {
+			value: row.file.mtime,
+			enumerable: false
+		}
+	});
+	const projected = {
+		file,
+		data
+	};
+	Object.defineProperties(projected, {
+		values: {
+			value: row.values,
+			enumerable: false
+		},
+		formulas: {
+			value: row.formulas,
+			enumerable: false
+		},
+		sortValues: {
+			value: row.sortValues,
+			enumerable: false
+		}
+	});
+	return projected;
+}
+function resolveColumnTypes(columns, rows, inspections) {
+	return columns.map((column) => ({
+		...column,
+		type: resolveColumnType(column.id, rows, inspections)
+	}));
+}
+function resolveColumnType(id, rows, inspections) {
+	const propertyName = id.replace(/^note\./u, "");
+	for (const inspection of inspections) {
+		const property = inspection.properties.find((candidate) => candidate.name === propertyName);
+		if (property?.valueType) return normalizeColumnType(property.valueType);
+	}
+	if (id === "file.name" || id === "file.basename" || id === "file.path" || id === "file.folder" || id === "file.ext") return "text";
+	if (id === "file.size") return "number";
+	if (id === "file.ctime" || id === "file.mtime") return "datetime";
+	for (const row of rows) {
+		const value = row.values[id];
+		if (value !== null && value !== void 0) return inferColumnType(value);
+	}
+	return "empty";
+}
+function normalizeColumnType(type) {
+	if (type === "checkbox") return "boolean";
+	if (type === "multitext" || type === "aliases" || type === "tags") return "list";
+	if (type === "string") return "text";
+	return type;
+}
+function inferColumnType(value) {
+	if (value instanceof Date) return isMidnight(value) ? "date" : "datetime";
+	if (Array.isArray(value)) return "list";
+	if (value instanceof Error) return "error";
+	if (typeof value === "string") {
+		if (/^\d{4}-\d{2}-\d{2}$/u.test(value)) return "date";
+		if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/u.test(value)) return "datetime";
+		if (/^\[\[.*\]\]$/u.test(value)) return "link";
+		return "text";
+	}
+	if (typeof value === "number") return "number";
+	if (typeof value === "boolean") return "boolean";
+	if (value && typeof value === "object") return "object";
+	return "empty";
+}
+function isMidnight(date) {
+	return date.getHours() === 0 && date.getMinutes() === 0 && date.getSeconds() === 0 && date.getMilliseconds() === 0;
+}
+function compareRows(left, right, sort, columns = []) {
+	for (const item of sort ?? []) {
+		const result = compareValues(left.sortValues[item.property] ?? left.values[item.property] ?? left.formulas[formulaName(item.property)], right.sortValues[item.property] ?? right.values[item.property] ?? right.formulas[formulaName(item.property)]);
+		if (result !== 0) return item.direction === "DESC" ? -result : result;
+	}
+	const direction = sort?.length ? sort[sort.length - 1]?.direction : void 0;
+	for (const column of columns) {
+		const leftValue = left.values[column.id];
+		const rightValue = right.values[column.id];
+		const result = compareValues(leftValue, rightValue);
+		if (result !== 0) return direction === "DESC" ? -result : result;
+	}
+	return compareValues(left.file.basename, right.file.basename);
+}
+function buildGroups(rows, view) {
+	const groupBy = view?.groupBy;
+	return (groupBy ? [groupBy.property] : []).map((id) => {
+		const buckets = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			const value = row.values[id] ?? row.formulas[formulaName(id)] ?? null;
+			const key = comparableKey(value);
+			const bucket = buckets.get(key) ?? {
+				value,
+				rows: []
+			};
+			bucket.rows.push(row);
+			buckets.set(key, bucket);
+		}
+		const direction = groupBy?.property === id ? groupBy.direction : "ASC";
+		return {
+			property: id,
+			direction,
+			buckets: [...buckets.values()].sort((left, right) => {
+				const result = compareValues(left.value, right.value);
+				return direction === "DESC" ? -result : result;
+			}).map((bucket) => ({
+				value: bucket.value,
+				count: bucket.rows.length,
+				rows: bucket.rows.map((row) => row.file.path)
+			}))
+		};
+	});
+}
+function buildSummaries(rows, view, base) {
+	const summaries = { count: rows.length };
+	for (const [key, requestedSummary] of Object.entries(view?.summaries ?? {})) summaries[key] = summarizeValues(rows.map((row) => row.values[key] ?? row.formulas[formulaName(key)] ?? null), typeof requestedSummary === "string" ? requestedSummary : String(requestedSummary), base);
+	return summaries;
+}
+function summarizeValues(values, requestedSummary, base) {
+	const custom = base.summaries?.[requestedSummary];
+	if (custom) return evaluateExpression(parseExpression(custom), {
+		row: emptySummaryInspection(),
+		formulas: {},
+		byPath: /* @__PURE__ */ new Map(),
+		byBasename: /* @__PURE__ */ new Map(),
+		values
+	});
+	const normalized = requestedSummary.toLowerCase();
+	const numbers = numericValues(values);
+	const dates = values.map(dateFromValue).filter((value) => value instanceof Date);
+	if (normalized === "sum") return sumNumbers(numbers);
+	if (normalized === "average" || normalized === "mean") return meanNumbers(numbers);
+	if (normalized === "min") return minNumber(numbers);
+	if (normalized === "max") return maxNumber(numbers);
+	if (normalized === "median") return medianNumbers(numbers);
+	if (normalized === "stddev") return stddevNumbers(numbers);
+	if (normalized === "checked") return values.filter((value) => value === true).length;
+	if (normalized === "unchecked") return values.filter((value) => value === false).length;
+	if (normalized === "empty") return values.filter(isEmptySummaryValue).length;
+	if (normalized === "filled") return values.filter((value) => !isEmptySummaryValue(value)).length;
+	if (normalized === "unique") return new Set(values.map(comparableKey)).size;
+	if (normalized === "earliest") return dateSummary(minDate(dates));
+	if (normalized === "latest") return dateSummary(maxDate(dates));
+	if (normalized === "range") {
+		if (numbers.length > 0) return Math.max(...numbers) - Math.min(...numbers);
+		const earliest = minDate(dates);
+		const latest = maxDate(dates);
+		return earliest && latest ? latest.getTime() - earliest.getTime() : null;
+	}
+	return {
+		count: numbers.length,
+		sum: sumNumbers(numbers),
+		average: meanNumbers(numbers)
+	};
+}
+function emptySummaryInspection() {
+	return {
+		file: {
+			path: "",
+			name: "",
+			basename: "",
+			ext: "",
+			folder: "",
+			kind: "markdown"
+		},
+		properties: [],
+		tags: [],
+		links: [],
+		backlinks: [],
+		embeds: []
+	};
+}
+function dateFromValue(value) {
+	if (value instanceof Date && !Number.isNaN(value.getTime())) return value;
+	if (typeof value !== "string") return null;
+	const date = new Date(value);
+	return Number.isNaN(date.getTime()) ? null : date;
+}
+function minDate(values) {
+	return values.length > 0 ? new Date(Math.min(...values.map((value) => value.getTime()))) : null;
+}
+function maxDate(values) {
+	return values.length > 0 ? new Date(Math.max(...values.map((value) => value.getTime()))) : null;
+}
+function dateSummary(value) {
+	return value ? value.toISOString() : null;
+}
+function isEmptySummaryValue(value) {
+	return value === null || value === void 0 || value === "" || Array.isArray(value) && value.length === 0;
+}
+function comparableKey(value) {
+	return JSON.stringify(value) ?? String(value);
+}
+function sanitizeRowFile(file) {
+	return {
+		path: file.path,
+		name: file.basename,
+		basename: file.basename,
+		ext: file.ext,
+		folder: file.folder,
+		size: file.size,
+		ctime: file.ctime,
+		mtime: file.mtime
+	};
+}
+function compareValues(left, right) {
+	if (typeof left === "number" && typeof right === "number") return left - right;
+	return String(left ?? "").localeCompare(String(right ?? ""));
+}
+function formulaName(id) {
+	return id.startsWith("formula.") ? id.slice(8) : id;
+}
+function normalizeComparable(value) {
+	return String(value).replace(/^\[\[/u, "").replace(/\]\]$/u, "").replace(/\.md$/u, "").toLowerCase();
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+export { BaseEngineError, evaluateExpression, queryBase };
+
+//# sourceMappingURL=index.mjs.map