@mono-lit/helper 0.0.8 → 0.0.10

package/dist/vue.d.ts

@@ -78,6 +78,7 @@ import type { TableCheckboxEvents } from './src/components/table/mono-table-chec
 import type { TableDetailEvents } from './src/components/table/mono-table-detail-core.js'
 import type { TableEmptyEvents } from './src/components/table/mono-table-empty-core.js'
 import type { TableErrorEvents } from './src/components/table/mono-table-error-core.js'
+import type { TableSearchEvents } from './src/components/table/table-types.js'
 import type { TabsEvents } from './src/components/tabs/tabs-types.js'
 import type { TagInputEvents } from './src/components/tag-input/tag-input-types.js'
 import type { TextareaEvents } from './src/components/textarea/textarea-types.js'
@@ -202,7 +203,7 @@ declare module 'vue' {
     'mono-shadow-table-page-size': MonoElement<TablePageSizeProps>
     'mono-shadow-table-paging': MonoElement<TablePagingProps>
     'mono-shadow-table-paging-group': MonoElement<TablePagingGroupProps>
-    'mono-shadow-table-search': MonoElement<TableSearchProps>
+    'mono-shadow-table-search': MonoElement<TableSearchProps, TableSearchEvents>
     'mono-shadow-table-sort': MonoElement<TableSortProps>
     'mono-shadow-table-summary': MonoElement<TableSummaryProps>
     'mono-shadow-table-th': MonoElement<TableThProps>
@@ -221,7 +222,7 @@ declare module 'vue' {
     'mono-table-page-size': MonoElement<TablePageSizeProps>
     'mono-table-paging': MonoElement<TablePagingProps>
     'mono-table-paging-group': MonoElement<TablePagingGroupProps>
-    'mono-table-search': MonoElement<TableSearchProps>
+    'mono-table-search': MonoElement<TableSearchProps, TableSearchEvents>
     'mono-table-sort': MonoElement<TableSortProps>
     'mono-table-summary': MonoElement<TableSummaryProps>
     'mono-table-th': MonoElement<TableThProps>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mono-lit/helper",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "Lit web components (tables, forms, inputs, dialogs, charts) for Vue and Nuxt, with light-DOM and shadow-DOM builds.",
   "keywords": [
     "lit",
@@ -349,8 +349,8 @@
     "vite-plugin-html-inject": "1.1.2",
     "vue": "3.5.44",
     "yup": "1.7.1",
-    "@mono-lit/devextreme": "0.0.2",
-    "@mono-lit/utility": "0.0.6"
+    "@mono-lit/utility": "0.0.6",
+    "@mono-lit/devextreme": "0.0.2"
   },
   "dependencies": {
     "@lit-labs/ssr": "3.2.2",

package/dist/chip-strip-bNfLn52Z.js

@@ -1,215 +0,0 @@
-//#region src/composables/chip-limits.ts
-const KEBAB = {
-	max: "max",
-	min: "min",
-	maxVisible: "max-visible",
-	minVisible: "min-visible"
-};
-/** A non-negative integer, or undefined for anything that is not one (`''`, null, NaN, -1). */
-function limitNumber(value) {
-	if (value == null || value === "") return void 0;
-	const n = Math.floor(Number(value));
-	return Number.isFinite(n) && n >= 0 ? n : void 0;
-}
-/**
-* Resolve one limit: the `chip` object's key (camel, then kebab) pins, the
-* element's own prop is the fallback. Sanitised through {@link limitNumber}.
-*/
-function resolveChipLimit(chip, key, elementValue) {
-	return limitNumber(chip ? chip[key] ?? chip[KEBAB[key]] : void 0) ?? limitNumber(elementValue);
-}
-/**
-* How many chips to draw before the rest collapse into "+N more" — `Infinity`
-* when there is no cap, when the cap is `0` (uncapped, like before), or while
-* the total sits at or under the collapse floor.
-*/
-function visibleChipCap(total, maxVisible, minVisible) {
-	if (maxVisible === void 0 || maxVisible <= 0) return Infinity;
-	if (minVisible !== void 0 && total <= minVisible) return Infinity;
-	return maxVisible;
-}
-
-//#endregion
-//#region src/composables/chip-strip.ts
-/** Slack (px) absorbing sub-pixel layout noise in the overflow comparisons. */
-const EPSILON = 1;
-var ChipStripController = class {
-	constructor(host, opts) {
-		this._canScrollStart = false;
-		this._canScrollEnd = false;
-		this._observer = null;
-		this._observed = null;
-		this.host = host;
-		this.opts = opts;
-		host.addController(this);
-	}
-	/** True once the strip is scrolled away from its start — render `‹`. */
-	get canScrollStart() {
-		return this._canScrollStart;
-	}
-	/** True while content remains past the right edge — render `›`. */
-	get canScrollEnd() {
-		return this._canScrollEnd;
-	}
-	/** True when either button should show — i.e. the chips overflow the strip. */
-	get overflowing() {
-		return this._canScrollStart || this._canScrollEnd;
-	}
-	hostConnected() {
-		if (this.opts.enabled()) this._attach();
-	}
-	hostDisconnected() {
-		this._teardown();
-	}
-	/**
-	* Only re-target the observer — deliberately does NOT measure. Measuring here
-	* would force a layout on every render of every host, and its `requestUpdate`
-	* would schedule an update from inside `updated()`. `invalidate()` and the
-	* ResizeObserver cover the cases that can actually change the answer.
-	*/
-	hostUpdated() {
-		if (!this.opts.enabled()) {
-			if (this._observed) {
-				this._teardown();
-				this._publish(false, false);
-			}
-			return;
-		}
-		this._attach();
-	}
-	/**
-	* Re-measure because the CONTENT changed — a chip added, removed or relabelled.
-	* The host calls this from `updated()` when such state actually changed, which
-	* is far rarer than "every update".
-	*/
-	invalidate() {
-		this.sync();
-	}
-	/**
-	* Recompute both flags from the live geometry and re-render only when one
-	* actually flipped.
-	*/
-	sync() {
-		if (!this.opts.enabled()) return;
-		const strip = this.opts.strip();
-		let start = false;
-		let end = false;
-		if (strip) {
-			const max = strip.scrollWidth - strip.clientWidth;
-			if (max > EPSILON) {
-				start = strip.scrollLeft > EPSILON;
-				end = strip.scrollLeft < max - EPSILON;
-			}
-		}
-		this._publish(start, end);
-	}
-	/**
-	* Scroll one "page" toward `dir`, aligned to a chip boundary so a chip is
-	* never left half-cut at the leading edge.
-	*
-	* Forward: the first chip whose right edge passes the visible right edge
-	* becomes the new leftmost chip. Backward: the chip that would end at the
-	* current left edge becomes the new leftmost chip. If no chip qualifies
-	* (one chip wider than the strip), fall back to a plain viewport-width step
-	* so the button is never a no-op.
-	*/
-	page(dir) {
-		const strip = this.opts.strip();
-		if (!strip) return;
-		const max = strip.scrollWidth - strip.clientWidth;
-		if (max <= EPSILON) return;
-		const viewLeft = strip.scrollLeft;
-		const viewRight = viewLeft + strip.clientWidth;
-		const stripLeft = strip.getBoundingClientRect().left;
-		const chips = Array.from(strip.children).map((chip) => {
-			const rect = chip.getBoundingClientRect();
-			const left = rect.left - stripLeft + viewLeft;
-			return {
-				left,
-				right: left + rect.width
-			};
-		});
-		let target = null;
-		if (dir === 1) {
-			for (const chip of chips) if (chip.right > viewRight + EPSILON) {
-				target = chip.left;
-				break;
-			}
-		} else for (let i = chips.length - 1; i >= 0; i--) if (chips[i].left < viewLeft - EPSILON) {
-			target = chips[i].right - strip.clientWidth;
-			break;
-		}
-		if (target === null) target = viewLeft + dir * strip.clientWidth;
-		this._scrollTo(strip, target, max);
-	}
-	/** Pin the strip to its end — used after a chip is added, to reveal it. */
-	scrollToEnd() {
-		const strip = this.opts.strip();
-		if (!strip) return;
-		const max = strip.scrollWidth - strip.clientWidth;
-		this._scrollTo(strip, max, max);
-	}
-	/**
-	* Move the strip and republish from the CLAMPED TARGET rather than by reading
-	* `scrollLeft` back.
-	*
-	* Scrolling is instant (no `scroll-behavior: smooth`), so the read would agree
-	* — but not reading avoids a second forced layout, and more importantly the
-	* strip's scroll events are expensive well beyond this controller: the shared
-	* popup controller listens for `scroll` on `window` in the CAPTURE phase, so
-	* every scroll event the strip emits repositions any open dropdown, forcing a
-	* layout and a `getComputedStyle` ancestor walk. One event per click is the
-	* budget; a smooth animation's ~30 was what made the page crawl.
-	*/
-	_scrollTo(strip, target, max) {
-		const clamped = Math.max(0, Math.min(max, target));
-		strip.scrollLeft = clamped;
-		if (max <= EPSILON) {
-			this._publish(false, false);
-			return;
-		}
-		this._publish(clamped > EPSILON, clamped < max - EPSILON);
-	}
-	/**
-	* Store the flags and re-render only on a real change.
-	*
-	* The request is deferred a microtask: `invalidate()` / `scrollToEnd()` are
-	* called from the host's `updated()` (a chip landed, a preset value arrived),
-	* and a synchronous `requestUpdate()` there is Lit's change-in-update warning
-	* on every such edge. The flags are already stored, so the deferred render
-	* reads the same answer — it just doesn't get scheduled from inside the
-	* render that asked for it.
-	*/
-	_publish(start, end) {
-		if (start === this._canScrollStart && end === this._canScrollEnd) return;
-		this._canScrollStart = start;
-		this._canScrollEnd = end;
-		if (typeof queueMicrotask === "function") queueMicrotask(() => this.host.requestUpdate());
-		else this.host.requestUpdate();
-	}
-	/**
-	* Observe the strip so the buttons re-evaluate when the FIELD is resized —
-	* a window resize changes `clientWidth` without any render or scroll event.
-	*
-	* Only the strip is observed, not the chips: a chip add/remove always comes
-	* with a host render, and the host calls `invalidate()` for those.
-	*/
-	_attach() {
-		const strip = this.opts.strip();
-		if (strip === this._observed) return;
-		this._observer?.disconnect();
-		this._observed = strip;
-		if (!strip) return;
-		if (typeof ResizeObserver === "undefined") return;
-		this._observer ??= new ResizeObserver(() => this.sync());
-		this._observer.observe(strip);
-	}
-	_teardown() {
-		this._observer?.disconnect();
-		this._observer = null;
-		this._observed = null;
-	}
-};
-
-//#endregion
-export { resolveChipLimit as n, visibleChipCap as r, ChipStripController as t };

package/dist/data-source-controller-Dx6IQ2CN.js

@@ -1,243 +0,0 @@
-import { n as describeError, o as isCanceled } from "./normalize-error-D93O4q8g.js";
-
-//#region src/composables/data-source-controller.ts
-/**
-* Encapsulates the generic DataSource + incremental-loading logic shared by
-* `mono-select`, `mono-tag-input`, etc. The host owns the rendering and any
-* scroll/height ergonomics; this controller owns binding, event wiring, page
-* accumulation, and array-mode chunking.
-*
-* Every state mutation calls `host.requestUpdate()` so the host re-renders.
-*/
-var DataSourceController = class {
-	constructor(host, opts) {
-		this._dsItems = [];
-		this._dsLoading = false;
-		this._loadingMore = false;
-		this._isLastPage = false;
-		this._error = null;
-		this._hasLoaded = false;
-		this._retrying = false;
-		this._internalLoad = false;
-		this._bound = null;
-		this._onChanged = () => {
-			if (this._internalLoad) return;
-			this._markLoaded();
-			if (this.opts.getLoadMoreMode()) {
-				const ds = this._bound;
-				this._dsItems = ds ? [...ds.items?.() ?? []] : [];
-				this._isLastPage = ds?.isLastPage?.() ?? false;
-				this._dsLoading = ds?.isLoading?.() ?? false;
-				this._changed();
-				return;
-			}
-			this._sync();
-		};
-		this._onLoadingChanged = () => {
-			this._dsLoading = this._bound?.isLoading?.() ?? false;
-			this._changed();
-		};
-		this._onLoadError = (err) => {
-			this._dsLoading = this._bound?.isLoading?.() ?? false;
-			this.setError(err ?? /* @__PURE__ */ new Error("Request failed"));
-		};
-		this.host = host;
-		this.opts = opts;
-		this._visibleCount = opts.getPageSize();
-		host.addController(this);
-	}
-	hostConnected() {
-		const ds = this.opts.getDataSource();
-		if (ds && this._bound !== ds) this.bind(ds);
-	}
-	hostDisconnected() {
-		this._detach();
-	}
-	/** Attach/detach listeners for a (possibly new) DataSource and seed state. */
-	bind(ds) {
-		if (this._bound === ds) return;
-		this._detach();
-		this._bound = ds;
-		this._error = null;
-		this._retrying = false;
-		this._hasLoaded = !!ds && (ds.items?.() ?? []).length > 0;
-		if (!ds) {
-			this._dsItems = [];
-			this._dsLoading = false;
-			this._isLastPage = false;
-			this._changed();
-			return;
-		}
-		ds.on("changed", this._onChanged);
-		ds.on("loadingChanged", this._onLoadingChanged);
-		ds.on("loadError", this._onLoadError);
-		this._sync();
-		this.maybeImmediateLoad();
-	}
-	maybeImmediateLoad() {
-		const ds = this._bound;
-		if (!ds || !this.opts.getImmediate()) return;
-		const hasItems = (ds.items?.() ?? []).length > 0;
-		const loading = ds.isLoading?.() ?? false;
-		if (hasItems || loading) return;
-		this._loadFirstPage();
-	}
-	/** Call when the load-more mode changes; refreshes paging assumptions. */
-	onLoadMoreModeChange() {
-		if (!this.opts.getLoadMoreMode()) return;
-		this._bound?.paginate?.(true);
-		this._isLastPage = this._bound?.isLastPage?.() ?? false;
-		this._changed();
-	}
-	/** Reset array-mode paging to the first chunk. */
-	resetVisible() {
-		this._visibleCount = this.opts.getPageSize();
-		this._changed();
-	}
-	/** Load/reveal the next page and append it to the accumulated list. */
-	async loadMore() {
-		if (!this.opts.getLoadMoreMode() || this.atLastPage) return;
-		if (this.isArrayLoadMore) {
-			this._visibleCount = Math.min(this.opts.getItems().length, this._visibleCount + this.opts.getPageSize());
-			this._changed();
-			return;
-		}
-		const ds = this._bound;
-		if (!ds || this._loadingMore || this._dsLoading) return;
-		if (typeof ds.pageIndex !== "function") return;
-		const current = ds.pageIndex() ?? 0;
-		this._internalLoad = true;
-		this._loadingMore = true;
-		this._changed();
-		try {
-			ds.paginate?.(true);
-			ds.pageIndex(current + 1);
-			await Promise.resolve(ds.load());
-			this._dsItems = [...this._dsItems, ...ds.items?.() ?? []];
-			this._isLastPage = ds.isLastPage?.() ?? false;
-			this._error = null;
-		} catch (err) {
-			ds.pageIndex(current);
-			this.setError(err);
-		} finally {
-			this._loadingMore = false;
-			this._internalLoad = false;
-			this._changed();
-		}
-	}
-	/**
-	* Re-run the request after a failure. Reloads the source as it stands, so a
-	* failed search is retried with the same query. While it runs the field is
-	* {@link busy} again.
-	*
-	* `load` replaces the plain `ds.load()` — a host whose failed request was a
-	* search passes one that clears the query on the source and reloads.
-	*/
-	async retry(load) {
-		if (!this._bound) return;
-		this._error = null;
-		this._retrying = true;
-		this._changed();
-		try {
-			await this._loadFirstPage(load);
-		} finally {
-			this._retrying = false;
-			this._changed();
-		}
-	}
-	/**
-	* Record a failure from a request the host drove itself (e.g. a server
-	* select-all drain). Cancelled loads are ignored.
-	*/
-	setError(raw) {
-		if (isCanceled(raw)) return;
-		this._error = describeError(raw);
-		this._changed();
-	}
-	/** Raw source array: accumulated DataSource items, or the plain `items`. */
-	get sourceItems() {
-		return this._bound ? this._dsItems : this.opts.getItems();
-	}
-	/** Rows to actually render (array-mode reveals a slice; else everything). */
-	get visibleItems() {
-		if (this.isArrayLoadMore) return this.opts.getItems().slice(0, this._visibleCount);
-		return this.sourceItems;
-	}
-	get loading() {
-		return this._dsLoading;
-	}
-	get loadingMore() {
-		return this._loadingMore;
-	}
-	/**
-	* The field must be locked: the FIRST load (or a retry) is in flight. A
-	* search / filter reload after the source has answered once does not count —
-	* the person is typing into the field and it must stay usable.
-	*/
-	get busy() {
-		return !!this._bound && (this._dsLoading && !this._hasLoaded || this._retrying);
-	}
-	/** The last load failure, described for a person; null once a load succeeds. */
-	get error() {
-		return this._error;
-	}
-	/** load-more is driving a plain `items` array (no DataSource bound). */
-	get isArrayLoadMore() {
-		return !this.opts.getDataSource() && !!this.opts.getLoadMoreMode();
-	}
-	/** Whether there's nothing left to load/reveal. */
-	get atLastPage() {
-		if (this.isArrayLoadMore) return this._visibleCount >= this.opts.getItems().length;
-		return this._isLastPage;
-	}
-	/** A load answered: the source is usable and any earlier failure is over. */
-	_markLoaded() {
-		this._hasLoaded = true;
-		this._error = null;
-	}
-	_sync() {
-		const ds = this._bound;
-		this._dsItems = ds ? [...ds.items?.() ?? []] : [];
-		this._dsLoading = ds?.isLoading?.() ?? false;
-		this._isLastPage = ds?.isLastPage?.() ?? false;
-		this._changed();
-	}
-	/** Load the first page, replacing the accumulated list. */
-	async _loadFirstPage(load) {
-		const ds = this._bound;
-		if (!ds) return;
-		this._internalLoad = true;
-		this._dsLoading = true;
-		this._changed();
-		try {
-			if (this.opts.getLoadMoreMode()) {
-				ds.paginate?.(true);
-				ds.pageIndex?.(0);
-			}
-			await Promise.resolve(load ? load() : ds.load());
-			this._dsItems = [...ds.items?.() ?? []];
-			this._isLastPage = ds.isLastPage?.() ?? false;
-			this._markLoaded();
-		} catch (err) {
-			this.setError(err);
-		} finally {
-			this._dsLoading = ds.isLoading?.() ?? false;
-			this._internalLoad = false;
-			this._changed();
-		}
-	}
-	_detach() {
-		const ds = this._bound;
-		if (!ds) return;
-		ds.off("changed", this._onChanged);
-		ds.off("loadingChanged", this._onLoadingChanged);
-		ds.off("loadError", this._onLoadError);
-		this._bound = null;
-	}
-	_changed() {
-		this.host.requestUpdate();
-	}
-};
-
-//#endregion
-export { DataSourceController as t };