@mono-lit/helper 0.0.0-stage → 0.0.1

package/dist/filter-builder-CE4zE0V5.js

@@ -0,0 +1,205 @@
+import { t as createNotifier } from "./notifier-CE4yxMUQ.js";
+import { a as flattenTree, f as coerceValue, h as resolveTexts, i as emptyGroup, l as treeToArray, n as arrayToTree, o as nextId, p as defaultOperator, r as asRootGroup, s as odataStringToArray, t as arrayToODataString } from "./filter-odata-C1vSGZaY.js";
+//#region src/components/filter/filter-builder.ts
+function monoFilterBuilder(opts = {}) {
+	const texts = resolveTexts(opts.texts);
+	const actions = opts.actions !== false;
+	const serialize = opts.toODataString ?? ((f) => arrayToODataString(f));
+	/** Which shape the caller supplied, so `type`-less reads return the same. */
+	const inputType = typeof opts.filter === "string" ? "string" : "array";
+	let warnedUnparseable = false;
+	/**
+	* Normalise either shape into a devextreme expression. A string outside the
+	* parser's subset warns ONCE and yields `null` — an empty builder is safer than
+	* a filter that silently means something else.
+	*/
+	function toExpression(filter) {
+		if (filter === null || filter === void 0 || filter === "") return null;
+		if (typeof filter !== "string") return Array.isArray(filter) ? filter : null;
+		try {
+			return odataStringToArray(filter);
+		} catch (err) {
+			if (!warnedUnparseable) {
+				warnedUnparseable = true;
+				console.warn(`[monoFilterBuilder] could not parse the OData filter string — starting empty. Only the subset this builder emits is supported (comparisons, contains/startswith/endswith, in, and/or/not, parentheses). Reason: ${err.message}`);
+			}
+			return null;
+		}
+	}
+	const originalExpression = toExpression(opts.filter);
+	function buildTree(expr) {
+		const node = arrayToTree(expr);
+		return asRootGroup(node ? flattenTree(node) : null);
+	}
+	let tree = buildTree(originalExpression);
+	const notifier = createNotifier();
+	const notify = notifier.notify;
+	const elementProps = { ...opts.props ?? {} };
+	/**
+	* Explicit `fields` win; a `dataGrid` only contributes columns not already
+	* listed, so a table dialog can pass both and override just what it needs.
+	*/
+	function fields() {
+		const explicit = opts.fields ?? [];
+		const grid = opts.dataGrid;
+		if (!grid) return explicit;
+		const seen = new Set(explicit.map((f) => f.field));
+		const derived = [];
+		for (const col of grid.props?.().th ?? []) {
+			if (!col?.field || seen.has(col.field)) continue;
+			derived.push({
+				field: col.field,
+				caption: col.caption ?? col.field
+			});
+		}
+		return [...explicit, ...derived];
+	}
+	function fieldDef(field) {
+		return fields().find((f) => f.field === field);
+	}
+	function findNode(id, node = tree) {
+		if (node.id === id) return node;
+		if (node.kind !== "group") return null;
+		for (const c of node.children) {
+			const hit = findNode(id, c);
+			if (hit) return hit;
+		}
+		return null;
+	}
+	function findParent(id, node = tree) {
+		for (const c of node.children) {
+			if (c.id === id) return node;
+			if (c.kind === "group") {
+				const hit = findParent(id, c);
+				if (hit) return hit;
+			}
+		}
+		return null;
+	}
+	function groupById(id) {
+		if (!id) return tree;
+		const node = findNode(id);
+		return node && node.kind === "group" ? node : tree;
+	}
+	function newRule() {
+		const first = fields()[0];
+		const dataType = first?.dataType ?? "string";
+		return {
+			kind: "rule",
+			id: nextId("r"),
+			field: first?.field ?? "",
+			operator: defaultOperator(dataType),
+			value: ""
+		};
+	}
+	function read(expr, options) {
+		return (options?.type ?? inputType) === "string" ? serialize(expr) : expr;
+	}
+	const controller = {
+		get tree() {
+			return tree;
+		},
+		get fields() {
+			return fields();
+		},
+		get texts() {
+			return texts;
+		},
+		get actions() {
+			return actions;
+		},
+		props: () => elementProps,
+		/**
+		* Merge, not replace — a partial patch leaves everything else alone, matching
+		* `updateRule`. `undefined` values are passed straight through: `applyProps`
+		* skips them on the write side, so "not declared" can never clobber a value
+		* the template set.
+		*/
+		setProps: (patch) => {
+			if (!patch) return;
+			Object.assign(elementProps, patch);
+			notify();
+		},
+		original: (options) => read(originalExpression, options),
+		changed: (options) => read(treeToArray(tree), options),
+		setFilter: (filter) => {
+			tree = buildTree(toExpression(filter));
+			notify();
+		},
+		reset: () => {
+			tree = buildTree(originalExpression);
+			notify();
+		},
+		clear: () => {
+			tree = emptyGroup(tree.operator);
+			notify();
+		},
+		addRule: (groupId) => {
+			groupById(groupId).children.push(newRule());
+			notify();
+		},
+		addGroup: (groupId) => {
+			const g = emptyGroup("and");
+			g.children.push(newRule());
+			groupById(groupId).children.push(g);
+			notify();
+		},
+		/**
+		* Nest a rule: replace it in place with a group holding it plus a fresh
+		* sibling, which is what the row's nested-rule button means. Nesting a group
+		* just adds a child group to it.
+		*/
+		nest: (nodeId) => {
+			const node = findNode(nodeId);
+			if (!node) return;
+			if (node.kind === "group") {
+				const g = emptyGroup("and");
+				g.children.push(newRule());
+				node.children.push(g);
+				notify();
+				return;
+			}
+			const parent = findParent(nodeId);
+			if (!parent) return;
+			const at = parent.children.indexOf(node);
+			const g = emptyGroup(parent.operator === "or" ? "and" : "or");
+			g.children.push(node, newRule());
+			parent.children.splice(at, 1, g);
+			notify();
+		},
+		remove: (nodeId) => {
+			const parent = findParent(nodeId);
+			if (!parent) return;
+			parent.children = parent.children.filter((c) => c.id !== nodeId);
+			if (!parent.children.length && parent !== tree) controller.remove(parent.id);
+			else notify();
+		},
+		updateRule: (ruleId, patch) => {
+			const node = findNode(ruleId);
+			if (!node || node.kind !== "rule") return;
+			if (patch.field !== void 0 && patch.field !== node.field) {
+				node.field = patch.field;
+				node.operator = defaultOperator(fieldDef(node.field)?.dataType ?? "string");
+				node.value = "";
+			}
+			if (patch.operator !== void 0) node.operator = patch.operator;
+			if (patch.value !== void 0) {
+				const dt = fieldDef(node.field)?.dataType ?? "string";
+				node.value = Array.isArray(patch.value) ? patch.value.map((v) => coerceValue(v, dt)) : coerceValue(patch.value, dt);
+			}
+			notify();
+		},
+		setGroupOperator: (groupId, operator) => {
+			const node = findNode(groupId);
+			if (node?.kind === "group") {
+				node.operator = operator;
+				notify();
+			}
+		},
+		subscribe: (cb) => notifier.subscribe(cb),
+		dispose: () => notifier.clear()
+	};
+	return controller;
+}
+//#endregion
+export { monoFilterBuilder as t };

package/dist/filter-eval-DIfU2EAn.js

@@ -0,0 +1,173 @@
+import { t as getFieldValue } from "./field-path-C92eGLg3.js";
+//#region src/search/filter-eval.ts
+/**
+* Compile a devextreme filter expression (the array form `monoFilterBuilder`
+* emits via `changed({ type: 'array' })`) into a client-side row predicate, so a
+* built filter can narrow an array-backed grid the same way a remote store would
+* narrow from a `$filter`. Remote devextreme stores read the array directly; this
+* is the client-side mirror for sources that only accept a `(row) => boolean`.
+*
+* The grammar handled is exactly the subset `treeToArray` produces: `[field, op,
+* value]` triples, `'and'` / `'or'` joined groups, `['!', expr]` negation, with
+* `between` / `in` / blank checks already expanded to those primitives.
+*/
+function compileFilterPredicate(expr) {
+	if (!Array.isArray(expr) || expr.length === 0) return null;
+	const fn = build(expr);
+	return (row) => !!fn(row);
+}
+/** AND-combine two optional devextreme filter expressions (either may be null). */
+function andFilters(a, b) {
+	if (a == null && b == null) return null;
+	if (a == null) return b;
+	if (b == null) return a;
+	return [
+		a,
+		"and",
+		b
+	];
+}
+/**
+* AND-combine optional row predicates — the array-source twin of `andFilters`.
+*
+* Returns the lone member UNWRAPPED when only one is present, so a caller that
+* compares the result by reference (the grid's compose memo) sees the same
+* function back and does not treat "nothing changed" as a change.
+*/
+function andPredicates(...fns) {
+	const kept = fns.filter((f) => typeof f === "function");
+	if (!kept.length) return null;
+	if (kept.length === 1) return kept[0];
+	return (row, index) => kept.every((f) => f(row, index));
+}
+/**
+* Join expressions with `and` / `or`, dropping nulls and returning a lone member
+* unwrapped — devextreme's filter arrays interleave the join token between
+* members (`[a, 'or', b, 'or', c]`) rather than nesting pairs.
+*/
+function joinFilters(parts, join) {
+	const kept = parts.filter((p) => p != null);
+	if (!kept.length) return null;
+	if (kept.length === 1) return kept[0];
+	const out = [];
+	kept.forEach((p, i) => {
+		if (i) out.push(join);
+		out.push(p);
+	});
+	return out;
+}
+var CMP = new Set([
+	"=",
+	"<>",
+	">",
+	">=",
+	"<",
+	"<=",
+	"==",
+	"!=",
+	"eq",
+	"ne",
+	"gt",
+	"ge",
+	"lt",
+	"le"
+]);
+var STR = new Set([
+	"contains",
+	"notcontains",
+	"startswith",
+	"endswith"
+]);
+/** A triple is `[field, op, value]`; a group starts with an array member. */
+function isTriple(node) {
+	return Array.isArray(node) && node.length === 3 && typeof node[0] === "string" && typeof node[1] === "string" && (CMP.has(node[1]) || STR.has(String(node[1]).toLowerCase()));
+}
+function build(expr) {
+	if (!Array.isArray(expr) || expr.length === 0) return () => true;
+	if (expr.length === 2 && (expr[0] === "!" || expr[0] === "not")) {
+		const inner = build(expr[1]);
+		return (row) => !inner(row);
+	}
+	if (isTriple(expr)) {
+		const [field, op, value] = expr;
+		return (row) => match(getFieldValue(row, field), op, value);
+	}
+	const members = [];
+	const joins = [];
+	for (const part of expr) {
+		const t = typeof part === "string" ? part.toLowerCase() : "";
+		if (t === "and" || t === "&" || t === "or" || t === "|") {
+			joins.push(t === "or" || t === "|" ? "or" : "and");
+			continue;
+		}
+		members.push(part);
+	}
+	const fns = members.map((m) => build(m));
+	if (!fns.length) return () => true;
+	return (row) => {
+		let acc = fns[0](row);
+		for (let i = 0; i < joins.length; i += 1) {
+			const next = fns[i + 1](row);
+			acc = joins[i] === "or" ? acc || next : acc && next;
+		}
+		return acc;
+	};
+}
+/** Coerce two values for ordered comparison: numbers when both parse, else strings. */
+function pair(a, b) {
+	const na = Number(a);
+	const nb = Number(b);
+	if (a !== "" && b !== "" && !Number.isNaN(na) && !Number.isNaN(nb)) return [na, nb];
+	return [String(a ?? ""), String(b ?? "")];
+}
+/** OData keyword → the symbol token the switch below is written against. */
+var OP_ALIAS = {
+	eq: "=",
+	ne: "<>",
+	gt: ">",
+	ge: ">=",
+	lt: "<",
+	le: "<="
+};
+function match(raw, op, value) {
+	const lower = op.toLowerCase();
+	const token = OP_ALIAS[lower] ?? lower;
+	if (value === null || value === void 0) {
+		const blank = raw === null || raw === void 0 || raw === "";
+		return token === "=" || token === "==" ? blank : !blank;
+	}
+	const raws = String(raw ?? "");
+	const vals = String(value ?? "");
+	switch (token) {
+		case "=":
+		case "==": {
+			const [a, b] = pair(raw, value);
+			return a === b;
+		}
+		case "<>":
+		case "!=": {
+			const [a, b] = pair(raw, value);
+			return a !== b;
+		}
+		case ">":
+		case ">=":
+		case "<":
+		case "<=": {
+			const [a, b] = pair(raw, value);
+			if (typeof a === "string" && typeof b === "string") {}
+			switch (token) {
+				case ">": return a > b;
+				case ">=": return a >= b;
+				case "<": return a < b;
+				default: return a <= b;
+			}
+		}
+		case "contains": return raws.toLowerCase().includes(vals.toLowerCase());
+		case "notcontains": return !raws.toLowerCase().includes(vals.toLowerCase());
+		case "startswith": return raws.toLowerCase().startsWith(vals.toLowerCase());
+		case "endswith": return raws.toLowerCase().endsWith(vals.toLowerCase());
+		default: return false;
+	}
+}
+//#endregion
+export { joinFilters as i, andPredicates as n, compileFilterPredicate as r, andFilters as t };