@mono-lit/helper 0.0.0-stage → 0.0.1

package/dist/data-source-read-CUX-lgrQ.js

@@ -0,0 +1,216 @@
+import { c as toODataClause, n as isPath, t as getFieldValue } from "./field-path-C92eGLg3.js";
+import { n as unwrapReactive, y as andFilters } from "./reactive-BHsqVjRh.js";
+//#region src/components/table/grouping.ts
+/**
+* Client-side grouping helpers shared by {@link monoArraySource} and
+* {@link monoDataGrid}. Dependency-free so @mono-lit/helper stays standalone; the
+* tree shape mirrors what a devextreme DataSource produces for `group`, so a
+* consumer can read `row.key` / `row.items[i].key` / … exactly as before.
+*/
+/** Duck-type a grouped node: `{ key, items: [...] }`. */
+function isGroupNode(x) {
+	return !!x && typeof x === "object" && "key" in x && Array.isArray(x.items);
+}
+/**
+* Recursively collect the leaf records from a possibly-grouped array. Already
+* flat rows pass straight through, so this safely normalises both a grouped
+* payload (devextreme `type:'data'` with `group`) and a plain array.
+*/
+function flattenLeaves(rows) {
+	const out = [];
+	for (const row of rows) if (isGroupNode(row)) out.push(...flattenLeaves(row.items));
+	else out.push(row);
+	return out;
+}
+/**
+* Bucket flat leaf records into the nested {@link MonoGroupNode} tree by
+* `fields` (in order). Group order follows first appearance in `rows` — the
+* source group-orders the rows, so a paged slice renders contiguous headers.
+*
+* @param rows     Flat leaf records (already group-ordered for nice paging).
+* @param fields   Group-by field names, outermost first.
+* @param collapsed Set of collapsed `path`s; matching nodes get `collapsed:true`.
+*/
+function buildGroups(rows, fields, collapsed = /* @__PURE__ */ new Set()) {
+	const build = (items, level, parentPath) => {
+		const field = fields[level];
+		const buckets = /* @__PURE__ */ new Map();
+		for (const row of items) {
+			const key = isPath(field) ? getFieldValue(row, field) : row?.[field];
+			const keyStr = String(key);
+			let bucket = buckets.get(keyStr);
+			if (!bucket) {
+				bucket = {
+					key,
+					rows: []
+				};
+				buckets.set(keyStr, bucket);
+			}
+			bucket.rows.push(row);
+		}
+		const nodes = [];
+		for (const [keyStr, bucket] of buckets) {
+			const path = parentPath ? `${parentPath}/${keyStr}` : keyStr;
+			const isLast = level >= fields.length - 1;
+			nodes.push({
+				key: bucket.key,
+				items: isLast ? bucket.rows : build(bucket.rows, level + 1, path),
+				count: bucket.rows.length,
+				level,
+				path,
+				collapsed: collapsed.has(path)
+			});
+		}
+		return nodes;
+	};
+	return fields.length ? build(rows, 0, "") : [];
+}
+/** Collect every group node's `path` from a built tree (for collapse-all). */
+function collectGroupPaths(nodes) {
+	const out = [];
+	const walk = (list) => {
+		for (const node of list) {
+			out.push(node.path);
+			const children = node.items;
+			if (children.length && isGroupNode(children[0])) walk(children);
+		}
+	};
+	walk(nodes);
+	return out;
+}
+//#endregion
+//#region src/utils/data-source-read.ts
+/**
+* Draining a devextreme DataSource (or store) to a flat array.
+*
+* The single place that knows how to read *everything* out of a source, shared
+* by `monoDataGrid.getData()` and the report engine's `data` resolver. Kept
+* duck-typed and dependency-free — @mono-lit/helper never imports devextreme, and a
+* real DataSource satisfies these shapes structurally.
+*
+* The hard part isn't the loop, it's reading a source **without disturbing it**:
+* the same DataSource is usually bound to a live grid, so paging state must
+* either be left alone (the store path) or restored exactly (the array path).
+*/
+/** Stop runaway loops if a backend keeps returning full chunks forever. */
+var MAX_SKIP = 1e7;
+/** A devextreme DataSource: it both loads and holds a current page. */
+function isDataSourceLike(value) {
+	const v = value;
+	return !!v && typeof v === "object" && typeof v.load === "function" && typeof v.items === "function";
+}
+/** A bare store (ODataStore / CustomStore / ArrayStore) — loads, but has no page. */
+function isStoreLike(value) {
+	const v = value;
+	return !!v && typeof v === "object" && typeof v.load === "function" && typeof v.items !== "function" && (typeof v.key === "function" || typeof v.byKey === "function");
+}
+/** Anything this module can drain into an array. */
+function isReadableSource(value) {
+	return isDataSourceLike(value) || isStoreLike(value);
+}
+/** devextreme `store.load` resolves to either an array or `{ data, … }`. */
+function rowsOf(res) {
+	return Array.isArray(res) ? res : res?.data ?? [];
+}
+/**
+* Build a devextreme filter expression for a DataSource's **active search**.
+*
+* This is the subtle one. `searchValue` / `searchExpr` are DataSource-level
+* options: the DataSource folds them into the request it sends to its store.
+* Reading the store directly bypasses them entirely — so an export would
+* silently include rows the user filtered away with `<mono-table-search>`.
+* Reconstructing the filter here keeps the store path faithful to the grid.
+*/
+function searchFilterOf(source) {
+	const value = source.searchValue?.();
+	const search = value == null || value === "" ? null : String(value);
+	if (!search) return void 0;
+	const expr = source.searchExpr?.();
+	const cols = Array.isArray(expr) ? expr : expr ? [expr] : [];
+	if (!cols.length) return void 0;
+	const op = source.searchOperation?.() || "contains";
+	const clauses = cols.map((c) => toODataClause(c, op, search)).filter((c) => c != null);
+	if (!clauses.length) return void 0;
+	if (clauses.length === 1) return clauses[0];
+	const out = [];
+	clauses.forEach((c, i) => {
+		if (i) out.push("or");
+		out.push(c);
+	});
+	return out;
+}
+/**
+* Read every row a source can produce, in chunks.
+*
+* A plain array passes straight through, so callers can accept
+* "array or DataSource" without branching.
+*/
+async function readAllRows(source, options = {}) {
+	const src = unwrapReactive(source);
+	if (Array.isArray(src)) return flattenLeaves(src);
+	if (!src) return [];
+	const chunkSize = Math.max(1, Math.floor(options.chunkSize ?? 100));
+	if (isDataSourceLike(src)) {
+		const store = src.store?.();
+		if (store && typeof store.load === "function") {
+			const filter = andFilters(andFilters(src.filter?.() ?? null, searchFilterOf(src) ?? null), options.filter ?? null);
+			const sort = options.sort ?? src.sort?.() ?? null;
+			const select = options.select ?? src.select?.() ?? null;
+			return drainStore(store, {
+				chunkSize,
+				...select ? { select } : {},
+				...filter ? { filter } : {},
+				...sort ? { sort } : {},
+				...options.loadOptions ? { loadOptions: options.loadOptions } : {}
+			});
+		}
+		return readArrayDataSource(src);
+	}
+	if (isStoreLike(src)) return drainStore(src, {
+		chunkSize,
+		select: options.select,
+		sort: options.sort,
+		...options.filter ? { filter: options.filter } : {},
+		...options.loadOptions ? { loadOptions: options.loadOptions } : {}
+	});
+	return [];
+}
+/** Loop `store.load` until a short chunk comes back. */
+async function drainStore(store, opts) {
+	const acc = [];
+	for (let skip = 0;; skip += opts.chunkSize) {
+		const rows = rowsOf(await store.load({
+			...opts.loadOptions ?? {},
+			...opts.filter ? { filter: opts.filter } : {},
+			...opts.sort ? { sort: opts.sort } : {},
+			...opts.select ? { select: opts.select } : {},
+			skip,
+			take: opts.chunkSize,
+			requireTotalCount: false
+		}));
+		acc.push(...flattenLeaves(rows));
+		if (rows.length < opts.chunkSize) break;
+		if (skip > MAX_SKIP) break;
+	}
+	return acc;
+}
+/**
+* An array-backed DataSource has no separate read channel, so its paging has to
+* be switched off, read, and put back exactly as it was — subscribers must not
+* observe the detour.
+*/
+async function readArrayDataSource(src) {
+	const paginate = src.paginate?.();
+	const pageIndex = src.pageIndex?.();
+	try {
+		src.paginate?.(false);
+		await src.load();
+		return flattenLeaves([...src.items?.() ?? []]);
+	} finally {
+		if (typeof paginate === "boolean") src.paginate?.(paginate);
+		if (typeof pageIndex === "number") src.pageIndex?.(pageIndex);
+		await src.load();
+	}
+}
+//#endregion
+export { buildGroups as a, isGroupNode as c, searchFilterOf as i, isReadableSource as n, collectGroupPaths as o, readAllRows as r, flattenLeaves as s, isDataSourceLike as t };

package/dist/data-source-read-DL88aH8t.js

@@ -0,0 +1,217 @@
+import { c as toODataClause, n as isPath, t as getFieldValue } from "./field-path-C92eGLg3.js";
+import { t as andFilters } from "./filter-eval-DIfU2EAn.js";
+import { n as unwrapReactive } from "./reactive-D3EERqgO.js";
+//#region src/components/table/grouping.ts
+/**
+* Client-side grouping helpers shared by {@link monoArraySource} and
+* {@link monoDataGrid}. Dependency-free so @mono-lit/helper stays standalone; the
+* tree shape mirrors what a devextreme DataSource produces for `group`, so a
+* consumer can read `row.key` / `row.items[i].key` / … exactly as before.
+*/
+/** Duck-type a grouped node: `{ key, items: [...] }`. */
+function isGroupNode(x) {
+	return !!x && typeof x === "object" && "key" in x && Array.isArray(x.items);
+}
+/**
+* Recursively collect the leaf records from a possibly-grouped array. Already
+* flat rows pass straight through, so this safely normalises both a grouped
+* payload (devextreme `type:'data'` with `group`) and a plain array.
+*/
+function flattenLeaves(rows) {
+	const out = [];
+	for (const row of rows) if (isGroupNode(row)) out.push(...flattenLeaves(row.items));
+	else out.push(row);
+	return out;
+}
+/**
+* Bucket flat leaf records into the nested {@link MonoGroupNode} tree by
+* `fields` (in order). Group order follows first appearance in `rows` — the
+* source group-orders the rows, so a paged slice renders contiguous headers.
+*
+* @param rows     Flat leaf records (already group-ordered for nice paging).
+* @param fields   Group-by field names, outermost first.
+* @param collapsed Set of collapsed `path`s; matching nodes get `collapsed:true`.
+*/
+function buildGroups(rows, fields, collapsed = /* @__PURE__ */ new Set()) {
+	const build = (items, level, parentPath) => {
+		const field = fields[level];
+		const buckets = /* @__PURE__ */ new Map();
+		for (const row of items) {
+			const key = isPath(field) ? getFieldValue(row, field) : row?.[field];
+			const keyStr = String(key);
+			let bucket = buckets.get(keyStr);
+			if (!bucket) {
+				bucket = {
+					key,
+					rows: []
+				};
+				buckets.set(keyStr, bucket);
+			}
+			bucket.rows.push(row);
+		}
+		const nodes = [];
+		for (const [keyStr, bucket] of buckets) {
+			const path = parentPath ? `${parentPath}/${keyStr}` : keyStr;
+			const isLast = level >= fields.length - 1;
+			nodes.push({
+				key: bucket.key,
+				items: isLast ? bucket.rows : build(bucket.rows, level + 1, path),
+				count: bucket.rows.length,
+				level,
+				path,
+				collapsed: collapsed.has(path)
+			});
+		}
+		return nodes;
+	};
+	return fields.length ? build(rows, 0, "") : [];
+}
+/** Collect every group node's `path` from a built tree (for collapse-all). */
+function collectGroupPaths(nodes) {
+	const out = [];
+	const walk = (list) => {
+		for (const node of list) {
+			out.push(node.path);
+			const children = node.items;
+			if (children.length && isGroupNode(children[0])) walk(children);
+		}
+	};
+	walk(nodes);
+	return out;
+}
+//#endregion
+//#region src/utils/data-source-read.ts
+/**
+* Draining a devextreme DataSource (or store) to a flat array.
+*
+* The single place that knows how to read *everything* out of a source, shared
+* by `monoDataGrid.getData()` and the report engine's `data` resolver. Kept
+* duck-typed and dependency-free — @mono-lit/helper never imports devextreme, and a
+* real DataSource satisfies these shapes structurally.
+*
+* The hard part isn't the loop, it's reading a source **without disturbing it**:
+* the same DataSource is usually bound to a live grid, so paging state must
+* either be left alone (the store path) or restored exactly (the array path).
+*/
+/** Stop runaway loops if a backend keeps returning full chunks forever. */
+var MAX_SKIP = 1e7;
+/** A devextreme DataSource: it both loads and holds a current page. */
+function isDataSourceLike(value) {
+	const v = value;
+	return !!v && typeof v === "object" && typeof v.load === "function" && typeof v.items === "function";
+}
+/** A bare store (ODataStore / CustomStore / ArrayStore) — loads, but has no page. */
+function isStoreLike(value) {
+	const v = value;
+	return !!v && typeof v === "object" && typeof v.load === "function" && typeof v.items !== "function" && (typeof v.key === "function" || typeof v.byKey === "function");
+}
+/** Anything this module can drain into an array. */
+function isReadableSource(value) {
+	return isDataSourceLike(value) || isStoreLike(value);
+}
+/** devextreme `store.load` resolves to either an array or `{ data, … }`. */
+function rowsOf(res) {
+	return Array.isArray(res) ? res : res?.data ?? [];
+}
+/**
+* Build a devextreme filter expression for a DataSource's **active search**.
+*
+* This is the subtle one. `searchValue` / `searchExpr` are DataSource-level
+* options: the DataSource folds them into the request it sends to its store.
+* Reading the store directly bypasses them entirely — so an export would
+* silently include rows the user filtered away with `<mono-table-search>`.
+* Reconstructing the filter here keeps the store path faithful to the grid.
+*/
+function searchFilterOf(source) {
+	const value = source.searchValue?.();
+	const search = value == null || value === "" ? null : String(value);
+	if (!search) return void 0;
+	const expr = source.searchExpr?.();
+	const cols = Array.isArray(expr) ? expr : expr ? [expr] : [];
+	if (!cols.length) return void 0;
+	const op = source.searchOperation?.() || "contains";
+	const clauses = cols.map((c) => toODataClause(c, op, search)).filter((c) => c != null);
+	if (!clauses.length) return void 0;
+	if (clauses.length === 1) return clauses[0];
+	const out = [];
+	clauses.forEach((c, i) => {
+		if (i) out.push("or");
+		out.push(c);
+	});
+	return out;
+}
+/**
+* Read every row a source can produce, in chunks.
+*
+* A plain array passes straight through, so callers can accept
+* "array or DataSource" without branching.
+*/
+async function readAllRows(source, options = {}) {
+	const src = unwrapReactive(source);
+	if (Array.isArray(src)) return flattenLeaves(src);
+	if (!src) return [];
+	const chunkSize = Math.max(1, Math.floor(options.chunkSize ?? 100));
+	if (isDataSourceLike(src)) {
+		const store = src.store?.();
+		if (store && typeof store.load === "function") {
+			const filter = andFilters(andFilters(src.filter?.() ?? null, searchFilterOf(src) ?? null), options.filter ?? null);
+			const sort = options.sort ?? src.sort?.() ?? null;
+			const select = options.select ?? src.select?.() ?? null;
+			return drainStore(store, {
+				chunkSize,
+				...select ? { select } : {},
+				...filter ? { filter } : {},
+				...sort ? { sort } : {},
+				...options.loadOptions ? { loadOptions: options.loadOptions } : {}
+			});
+		}
+		return readArrayDataSource(src);
+	}
+	if (isStoreLike(src)) return drainStore(src, {
+		chunkSize,
+		select: options.select,
+		sort: options.sort,
+		...options.filter ? { filter: options.filter } : {},
+		...options.loadOptions ? { loadOptions: options.loadOptions } : {}
+	});
+	return [];
+}
+/** Loop `store.load` until a short chunk comes back. */
+async function drainStore(store, opts) {
+	const acc = [];
+	for (let skip = 0;; skip += opts.chunkSize) {
+		const rows = rowsOf(await store.load({
+			...opts.loadOptions ?? {},
+			...opts.filter ? { filter: opts.filter } : {},
+			...opts.sort ? { sort: opts.sort } : {},
+			...opts.select ? { select: opts.select } : {},
+			skip,
+			take: opts.chunkSize,
+			requireTotalCount: false
+		}));
+		acc.push(...flattenLeaves(rows));
+		if (rows.length < opts.chunkSize) break;
+		if (skip > MAX_SKIP) break;
+	}
+	return acc;
+}
+/**
+* An array-backed DataSource has no separate read channel, so its paging has to
+* be switched off, read, and put back exactly as it was — subscribers must not
+* observe the detour.
+*/
+async function readArrayDataSource(src) {
+	const paginate = src.paginate?.();
+	const pageIndex = src.pageIndex?.();
+	try {
+		src.paginate?.(false);
+		await src.load();
+		return flattenLeaves([...src.items?.() ?? []]);
+	} finally {
+		if (typeof paginate === "boolean") src.paginate?.(paginate);
+		if (typeof pageIndex === "number") src.pageIndex?.(pageIndex);
+		await src.load();
+	}
+}
+//#endregion
+export { buildGroups as a, isGroupNode as c, searchFilterOf as i, isReadableSource as n, collectGroupPaths as o, readAllRows as r, flattenLeaves as s, isDataSourceLike as t };

package/dist/decorate-DEXtNagw.js

@@ -0,0 +1,141 @@
+//#region src/composables/hybird-prop.ts
+function toKebabCase(value) {
+	return value.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}
+function toLowerCaseProp(value) {
+	return value.toLowerCase();
+}
+function defineHybridPropAliases(target, props) {
+	for (const prop of props) {
+		const kebabProp = toKebabCase(prop);
+		const lowerProp = toLowerCaseProp(prop);
+		defineAlias(target, kebabProp, prop);
+		if (lowerProp !== prop && lowerProp !== kebabProp) defineAlias(target, lowerProp, prop);
+	}
+}
+/**
+* Register a cross-name alias for a controller-binding prop — e.g.
+* `defineHybridPropAlias(el, 'controlTable', 'dataGrid')` makes `controlTable`,
+* `control-table` and `controltable` all read/write the canonical reactive
+* `dataGrid` property (so `.controlTable = …` still triggers Lit's update
+* cycle). Used to rename the controller props without a breaking change: the
+* new `control-*` spellings land here while the old `data-*` ones keep working.
+*/
+function defineHybridPropAlias(target, aliasCamel, realProp) {
+	const kebab = toKebabCase(aliasCamel);
+	const lower = toLowerCaseProp(aliasCamel);
+	defineAlias(target, aliasCamel, realProp);
+	defineAlias(target, kebab, realProp);
+	if (lower !== aliasCamel && lower !== kebab) defineAlias(target, lower, realProp);
+}
+function defineAlias(target, alias, realProp) {
+	if (Object.prototype.hasOwnProperty.call(target, alias)) return;
+	Object.defineProperty(target, alias, {
+		get() {
+			return this[realProp];
+		},
+		set(value) {
+			this[realProp] = value;
+		},
+		configurable: true,
+		enumerable: false
+	});
+}
+/**
+* Lit `hasChanged` for an array prop.
+*
+* **Load-bearing**, for exactly the reason `rateLimitHasChanged` is (see
+* `composables/rate-limit.ts`): `:items="[...]"` in a template allocates a NEW array
+* on every parent re-render. Under Lit's default `!==` the element sees a change
+* each time, so anything gated on `changed.has('items')` — resetting an
+* infinite-scroll page, invalidating a search memo, rebuilding a cache — runs on
+* renders where nothing about the data actually moved.
+*
+* Element-wise identity rather than a deep compare: rows are normally stable objects
+* owned by a store, so this catches the re-created-wrapper case cheaply. If the
+* consumer also rebuilds each row object the arrays are reported as different, which
+* is the safe direction.
+*
+* **Why this needs no "repair" step, unlike `mono-button-dropdown`.** That element
+* compares entries by CONTENT and deliberately ignores function fields, so it reports
+* "same" for entries that really were rebuilt — leaving cached listener state pointing
+* at the previous array (hence `_retargetItemParts()`). `arrayHasChanged` says "same"
+* only when the array holds literally the same objects in the same order, so nothing
+* item-related can have moved and there is nothing to retarget. Reach for the deeper
+* compare only where the callbacks are resolved late, and prove it.
+*
+* **Do NOT add this (or any `hasChanged`) to these — they hang real work off the
+* update cycle, so suppressing an update silently drops it:**
+*   - `chart-core.ts` — `updated()` IS the chart pipeline; its last step `_applyData()`
+*     is the only place chart.js is redrawn. A skipped update freezes the canvas.
+*   - `date-core.ts` — `updated()` drives `_rebuild()` / `_applyModelValue()`, so
+*     flatpickr would be stranded on stale config.
+*   - every `mono-table-*` element — `table-controller-core.ts` overrides `update()` to
+*     pull each element's slice of `monoDataGrid({ props })`.
+*   - every `monoForm`-bound control and `filter-builder-core.ts` — same `update()` hook
+*     (`form-control-core.ts`), used for form binding and visibility.
+*
+* Surveyed 2026-08-17 across all 26 component directories; the guarded props are
+* `select`/`tag-input` `items`, `tag-input` `modelValue`/`value`, `menu` +
+* `mono-menu-list` `items`, `tabs` `items`, both `breadcrumb` `items`, and
+* `file-upload` `modelValue`.
+*/
+function arrayHasChanged(value, old) {
+	if (value === old) return false;
+	if (!Array.isArray(value) || !Array.isArray(old)) return true;
+	if (value.length !== old.length) return true;
+	for (let i = 0; i < value.length; i++) if (value[i] !== old[i]) return true;
+	return false;
+}
+var booleanStringConverter = {
+	fromAttribute(value) {
+		if (value === null || value === void 0) return false;
+		if (typeof value === "boolean") return value;
+		const normalized = String(value).toLowerCase().trim();
+		return normalized === "" || normalized === "true";
+	},
+	toAttribute(value) {
+		return value ? "" : null;
+	}
+};
+var numberStringConverter = {
+	fromAttribute(value) {
+		if (value === null || value === "") return 0;
+		const parsed = Number(value);
+		return Number.isFinite(parsed) ? parsed : 0;
+	},
+	toAttribute(value) {
+		if (value === void 0 || value === null) return null;
+		return String(value);
+	}
+};
+/**
+* Like {@link numberStringConverter}, but an absent/blank attribute stays
+* `undefined` instead of collapsing to `0`.
+*
+* Needed wherever 0 is a meaningful value AND "not set" has to mean "fall back to
+* whatever the component computes" — e.g. `mono-modal` / `mono-drawer`'s `z-index`,
+* where 0 is a legal stacking level and unset means "let the popup stack decide".
+* Using the plain number converter there would pin every dialog to `z-index: 0`.
+*/
+var optionalNumberConverter = {
+	fromAttribute(value) {
+		if (value === null || value === "") return void 0;
+		const parsed = Number(value);
+		return Number.isFinite(parsed) ? parsed : void 0;
+	},
+	toAttribute(value) {
+		if (value === void 0 || value === null) return null;
+		return String(value);
+	}
+};
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+export { defineHybridPropAliases as a, defineHybridPropAlias as i, arrayHasChanged as n, numberStringConverter as o, booleanStringConverter as r, optionalNumberConverter as s, __decorate as t };

package/dist/element-props-CLB6yvbm.js

@@ -0,0 +1,114 @@
+//#region src/composables/element-props.ts
+/**
+* Whether `key` can actually be assigned on `obj` — a plain expando, or an
+* accessor/data property that isn't read-only.
+*
+* This matters because a controller's `props` object legitimately carries keys
+* that are NOT element props: `monoDataGrid`'s `th[].summary` includes `prefix`
+* and `precision`, which the controller consumes for formatting. `prefix`
+* collides with the read-only native `Element.prefix`, and assigning it throws —
+* which took down the whole docs page render until this check existed.
+*/
+function isSettable(obj, key) {
+	let o = obj;
+	while (o) {
+		const d = Object.getOwnPropertyDescriptor(o, key);
+		if (d) return !!(d.set || d.writable);
+		o = Object.getPrototypeOf(o);
+	}
+	return true;
+}
+var HANDLER_KEY = /^on[A-Z]/;
+/** Whether a props key names an event handler (`onClick`, `onLoadingChange`). */
+function isEventHandlerKey(key) {
+	return HANDLER_KEY.test(key);
+}
+/**
+* `onClick` → `click`, `onLoadingChange` → `loading-change`, `onMnoChange` →
+* `mno-change` — the same rule Vue applies to an `on*` listener prop, so a key
+* that works in a template works here.
+*/
+function eventNameFromHandlerKey(key) {
+	const rest = key.slice(2);
+	return rest.charAt(0).toLowerCase() + rest.slice(1).replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+}
+/** Per element: event name → the handler currently attached through `props`. */
+var attached = /* @__PURE__ */ new WeakMap();
+function applyHandler(el, key, value) {
+	if (typeof value !== "function" && value !== null) return;
+	const target = el;
+	if (typeof target.addEventListener !== "function") return;
+	const name = eventNameFromHandlerKey(key);
+	let map = attached.get(el);
+	const current = map?.get(name);
+	if (value === null) {
+		if (current) {
+			target.removeEventListener(name, current.listener);
+			map.delete(name);
+		}
+		return;
+	}
+	const fn = value;
+	if (current?.fn === fn) return;
+	if (current) target.removeEventListener(name, current.listener);
+	const listener = (event) => {
+		fn(event);
+	};
+	target.addEventListener(name, listener);
+	if (!map) {
+		map = /* @__PURE__ */ new Map();
+		attached.set(el, map);
+	}
+	map.set(name, {
+		fn,
+		listener
+	});
+}
+/**
+* Remove every handler `applyProps` attached to `el`. Call it where an element
+* leaves its controller (an unbind, a re-bind to a different one) so the old
+* controller's handlers do not keep firing beside the new one's.
+*/
+function detachEventHandlers(el) {
+	const map = attached.get(el);
+	if (!map) return;
+	const target = el;
+	for (const [name, { listener }] of map) target.removeEventListener(name, listener);
+	attached.delete(el);
+}
+/**
+* Write a controller's props onto an element.
+*
+* Two guards, both load-bearing:
+* - `undefined` values are skipped, so "not declared" never clobbers a value the
+*   template set;
+* - each write is equality-checked, so a sync can't schedule another update and
+*   loop.
+*
+* Handler keys (`onClick`, `onToggle`, …) become event listeners — see the
+* block above — never properties.
+*
+* Shared by `table-controller-core` (`monoDataGrid`/`monoDataDropdown` elements)
+* and `form-control-core` (`monoForm` controls) — the write loop is identical
+* and its failure modes are subtle enough to be worth having in one place.
+*/
+function applyProps(el, patch) {
+	if (!patch) return false;
+	const self = el;
+	let changed = false;
+	for (const [k, v] of Object.entries(patch)) {
+		if (v === void 0) continue;
+		if (isEventHandlerKey(k)) {
+			applyHandler(el, k, v);
+			continue;
+		}
+		if (!isSettable(self, k)) continue;
+		if (!Object.is(self[k], v)) {
+			self[k] = v;
+			changed = true;
+		}
+	}
+	return changed;
+}
+//#endregion
+export { detachEventHandlers as n, applyProps as t };