@mono-lit/helper 0.0.0-stage → 0.0.1

package/dist/field-icons-BoOG6KrL.js

@@ -0,0 +1,51 @@
+import { html } from "lit";
+//#region src/composables/field-icons.ts
+/** Downward caret — the "this opens a panel" affordance. */
+function caretIcon() {
+	return html`<svg
+    mono-icon
+    viewBox="0 0 20 20"
+    width="16"
+    height="16"
+    fill="currentColor"
+    aria-hidden="true"
+  >
+    <path
+      fill-rule="evenodd"
+      d="M5.23 7.21a.75.75 0 0 1 1.06.02L10 10.94l3.71-3.71a.75.75 0 1 1 1.06 1.06l-4.24 4.24a.75.75 0 0 1-1.06 0L5.25 8.29a.75.75 0 0 1-.02-1.08z"
+      clip-rule="evenodd"
+    />
+  </svg>`;
+}
+/** The ✕ a clear button and a chip's remove button draw, at the caret's weight. */
+function closeIcon() {
+	return html`<svg
+    mono-icon
+    viewBox="0 0 20 20"
+    width="16"
+    height="16"
+    fill="currentColor"
+    aria-hidden="true"
+  >
+    <path
+      fill-rule="evenodd"
+      d="M4.293 4.293a1 1 0 0 1 1.414 0L10 8.586l4.293-4.293a1 1 0 1 1 1.414 1.414L11.414 10l4.293 4.293a1 1 0 0 1-1.414 1.414L10 11.414l-4.293 4.293a1 1 0 0 1-1.414-1.414L8.586 10 4.293 5.707a1 1 0 0 1 0-1.414z"
+      clip-rule="evenodd"
+    />
+  </svg>`;
+}
+/** Left (`-1`) or right (`1`) chevron, matching {@link caretIcon}'s weight. */
+function chevronIcon(dir) {
+	return html`<svg
+    mono-icon
+    viewBox="0 0 20 20"
+    width="16"
+    height="16"
+    fill="currentColor"
+    aria-hidden="true"
+  >
+    <path fill-rule="evenodd" d=${dir === -1 ? "M12.79 5.23a.75.75 0 0 1-.02 1.06L9.06 10l3.71 3.71a.75.75 0 1 1-1.06 1.06l-4.24-4.24a.75.75 0 0 1 0-1.06l4.24-4.24a.75.75 0 0 1 1.08 0z" : "M7.21 14.77a.75.75 0 0 1 .02-1.06L10.94 10 7.23 6.29a.75.75 0 1 1 1.06-1.06l4.24 4.24a.75.75 0 0 1 0 1.06l-4.24 4.24a.75.75 0 0 1-1.08 0z"} clip-rule="evenodd" />
+  </svg>`;
+}
+//#endregion
+export { chevronIcon as n, closeIcon as r, caretIcon as t };

package/dist/field-path-C92eGLg3.js

@@ -0,0 +1,251 @@
+//#region src/search/field-path.ts
+/** Whether `field` is a path expression (contains `.` or `[`) vs a plain key. */
+function isPath(field) {
+	return typeof field === "string" && /[.[]/.test(field);
+}
+var parseCache = /* @__PURE__ */ new Map();
+/** Parse a path field into ordered segments (cached). Plain keys → one `key` segment. */
+function parseFieldPath(field) {
+	const cached = parseCache.get(field);
+	if (cached) return cached;
+	const segments = [];
+	let hasWildcard = false;
+	for (const token of field.split(".")) {
+		if (token === "") continue;
+		if (token === "[*]") {
+			segments.push({ kind: "wildcard" });
+			hasWildcard = true;
+		} else {
+			const m = /^\[(\d+)\]$/.exec(token);
+			if (m) segments.push({
+				kind: "index",
+				index: Number(m[1])
+			});
+			else segments.push({
+				kind: "key",
+				name: token
+			});
+		}
+	}
+	const parsed = {
+		segments,
+		hasWildcard,
+		raw: field
+	};
+	parseCache.set(field, parsed);
+	return parsed;
+}
+/**
+* Resolve a path field against a row. Returns a **scalar** when the path has no
+* wildcard, or a flattened **array** of matches when it does (`User.[*].Name` →
+* `string[]`). Missing links yield `undefined` (scalar) / are skipped (wildcard).
+*/
+function getFieldValue(row, field) {
+	const { segments, hasWildcard } = parseFieldPath(field);
+	let current = [row];
+	for (const seg of segments) {
+		const next = [];
+		for (const v of current) {
+			if (v == null) continue;
+			if (seg.kind === "key") next.push(v[seg.name]);
+			else if (seg.kind === "index") {
+				if (Array.isArray(v)) next.push(v[seg.index]);
+			} else if (Array.isArray(v)) for (const el of v) next.push(el);
+		}
+		current = next;
+	}
+	if (hasWildcard) return current.filter((v) => v !== void 0);
+	return current[0];
+}
+/**
+* Write `value` into `obj` at a dot/index path, creating intermediate `{}`/`[]`
+* as needed. Wildcard paths are ambiguous to write — a `console.warn` + no-op.
+*/
+function setFieldValue(obj, field, value) {
+	const { segments, hasWildcard } = parseFieldPath(field);
+	if (hasWildcard) {
+		console.warn(`[@mono-lit/helper] setFieldValue: cannot write a wildcard path "${field}" — skipped.`);
+		return;
+	}
+	if (!segments.length) return;
+	let cursor = obj;
+	for (let i = 0; i < segments.length - 1; i++) {
+		const seg = segments[i];
+		const wantArray = segments[i + 1].kind === "index";
+		const at = seg.kind === "index" ? seg.index : seg.name;
+		let child = cursor[at];
+		if (child == null || typeof child !== "object") {
+			child = wantArray ? [] : {};
+			cursor[at] = child;
+		}
+		cursor = child;
+	}
+	const last = segments[segments.length - 1];
+	const at = last.kind === "index" ? last.index : last.name;
+	cursor[at] = value;
+}
+/**
+* Project a row down to the given key paths, **rebuilding the nested shape**.
+*
+* This is what `<mono-table-checkbox>`'s `key-value` produces, so a selection can
+* be handed to an API in the shape the API expects rather than as flat values:
+*
+* ```ts
+* projectFields(row, ['Id'])                            // { Id: 8 }
+* projectFields(row, ['Company.Name'])                  // { Company: { Name: 'Hey' } }
+* projectFields(row, ['Transaction.[*].Id'])            // { Transaction: [{ Id: 4 }] }
+* projectFields(row, ['Company.Name', 'Transaction.[*].Id'])
+* //                → { Company: { Name: 'Hey' }, Transaction: [{ Id: 4 }] }
+* ```
+*
+* Separate from {@link setFieldValue}, which deliberately refuses wildcard paths
+* (there is no single place to write to). Here a wildcard is not ambiguous at all:
+* it MAPS over the source array, emitting one projected element per entry — so the
+* result mirrors the source's own cardinality. Several paths merge into one object,
+* and an empty key list means "the row itself".
+*/
+function projectFields(row, keys) {
+	if (!keys.length) return row;
+	const out = {};
+	for (const key of keys) {
+		const { segments } = parseFieldPath(key);
+		if (segments.length) assign(out, row, segments);
+	}
+	return out;
+}
+/**
+* Copy the value `source` holds at `segments` into `target`, creating only the
+* containers the path needs. Recursive rather than iterative because a wildcard
+* forks into N independent sub-writes.
+*/
+function assign(target, source, segments) {
+	const [seg, ...rest] = segments;
+	if (source == null || seg.kind !== "key") return;
+	const name = seg.name;
+	const value = source[name];
+	if (!rest.length) {
+		target[name] = value;
+		return;
+	}
+	if (rest[0].kind === "wildcard" || rest[0].kind === "index") {
+		if (!Array.isArray(value)) return;
+		const tail = rest.slice(1);
+		const list = Array.isArray(target[name]) ? target[name] : [];
+		target[name] = list;
+		const indices = rest[0].kind === "index" ? [rest[0].index] : value.map((_, i) => i);
+		for (const i of indices) {
+			if (i < 0 || i >= value.length) continue;
+			list[i] ??= {};
+			if (tail.length) assign(list[i], value[i], tail);
+		}
+		return;
+	}
+	const child = target[name] ?? {};
+	target[name] = child;
+	assign(child, value, rest);
+}
+/**
+* Merge a staged `patch` (keys may be path fields) into a **clone** of `row`.
+* Path keys nest via {@link setFieldValue}; plain keys are set directly. The
+* original row is never mutated. Used by the client (array/optimistic) save path.
+*/
+function mergePatch(row, patch) {
+	const clone = typeof structuredClone === "function" ? structuredClone(row) : JSON.parse(JSON.stringify(row));
+	for (const [field, value] of Object.entries(patch)) if (isPath(field)) setFieldValue(clone, field, value);
+	else clone[field] = value;
+	return clone;
+}
+/**
+* OData selector for `$orderby` / `$select` / nav column filters — dotted path
+* with `.` → `/` (`Job.Name` → `Job/Name`). Returns `null` when the path has any
+* index/wildcard segment (not expressible as a plain selector); the caller warns
+* and skips.
+*/
+function toODataSelector(field) {
+	const { segments } = parseFieldPath(field);
+	const parts = [];
+	for (const seg of segments) {
+		if (seg.kind !== "key") return null;
+		parts.push(seg.name);
+	}
+	return parts.join("/");
+}
+/**
+* Quote/serialize a value as an OData literal (numbers/bools bare, strings quoted
+* with `''` escaping). Exported so `mono-filter-builder` shares one set of quoting
+* rules instead of restating them.
+*/
+function odataLiteral(value) {
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return `'${String(value ?? "").replace(/'/g, "''")}'`;
+}
+/** Map a devextreme operator token to its OData comparison keyword. */
+function odataComparison(op) {
+	switch (op) {
+		case "=":
+		case "eq": return "eq";
+		case "<>":
+		case "!=":
+		case "ne": return "ne";
+		case ">":
+		case "gt": return "gt";
+		case ">=":
+		case "ge": return "ge";
+		case "<":
+		case "lt": return "lt";
+		case "<=":
+		case "le": return "le";
+		default: return null;
+	}
+}
+/**
+* Build a devextreme filter clause for a (possibly path) field.
+*
+* - plain / dotted-nav → a `[selector, op, value]` triple (`['Job/Name','contains','x']`),
+*   which devextreme serializes to a nav filter.
+* - wildcard → a single wrapped raw lambda clause
+*   (`["User/any(d: contains(d/Name,'x'))"]`) — the raw-string passthrough devextreme
+*   filter arrays honor. Slots into OR/AND groups as one group member.
+*
+* Returns `null` when the field can't be expressed (a second wildcard, or an
+* index segment mixed into a remote path); the caller warns + skips.
+*/
+function toODataClause(field, op, value) {
+	if (!isPath(field)) return [
+		field,
+		op,
+		value
+	];
+	const { segments, hasWildcard } = parseFieldPath(field);
+	if (!hasWildcard) {
+		const selector = toODataSelector(field);
+		return selector ? [
+			selector,
+			op,
+			value
+		] : null;
+	}
+	const wildAt = segments.findIndex((s) => s.kind === "wildcard");
+	const before = segments.slice(0, wildAt);
+	const after = segments.slice(wildAt + 1);
+	if (before.some((s) => s.kind !== "key") || after.some((s) => s.kind !== "key")) {
+		console.warn(`[@mono-lit/helper] toODataClause: unsupported path "${field}" (index or 2nd wildcard).`);
+		return null;
+	}
+	const coll = before.map((s) => s.name).join("/");
+	const inner = "d/" + after.map((s) => s.name).join("/");
+	const lit = odataLiteral(value);
+	let body;
+	if (op === "contains" || op === "startswith" || op === "endswith") body = `${op}(${inner},${lit})`;
+	else {
+		const cmp = odataComparison(op);
+		if (!cmp) {
+			console.warn(`[@mono-lit/helper] toODataClause: unsupported operator "${op}" for wildcard "${field}".`);
+			return null;
+		}
+		body = `${inner} ${cmp} ${lit}`;
+	}
+	return [`${coll}/any(d: ${body})`];
+}
+//#endregion
+export { parseFieldPath as a, toODataClause as c, odataLiteral as i, toODataSelector as l, isPath as n, projectFields as o, mergePatch as r, setFieldValue as s, getFieldValue as t };

package/dist/filter-builder-Bke3qOgJ.js

@@ -0,0 +1,205 @@
+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";
+import { t as createNotifier } from "./notifier-CE4yxMUQ.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 };