@mono-lit/helper 0.0.3 → 0.0.5

package/dist/{tooltip-FCMRUSLi.js → control-tooltip-C3rA_nSH.js}

@@ -1,5 +1,7 @@
+import { d as __exportAll } from "./styles-BODNpZV1.js";
 import { n as unwrapReactive, t as resolveMaybeReactive } from "./reactive-Dtd-esHO.js";
-import { a as unregisterPopupLayer, r as registerPopupLayer } from "./popup-stack-De05Y-mJ.js";
+import { i as registerPopupLayer, o as unregisterPopupLayer } from "./popup-stack-C64WCuXq.js";
+import { t as loadFloatingUi } from "./tooltip-loader-Dcp9AUZn.js";
 
 //#region src/components/tooltip/tooltip-config.ts
 const DEFAULT_TOOLTIP_OPTIONS = {
@@ -46,27 +48,16 @@ function resolveTooltipOptions(local, anchor) {
 	return out;
 }
 
-//#endregion
-//#region src/components/tooltip/tooltip-loader.ts
-/**
-* Cached loader for the OPTIONAL `@floating-ui/dom` peer (which itself depends on
-* `@floating-ui/core` — both are the consumer's to install).
-*
-* Loaded on the FIRST show, never at import: registering a tooltip in
-* `<script setup>` costs nothing until somebody actually hovers. Externalized by
-* `NEVER_BUNDLE` in `tsdown.config.ts`, so the consumer's bundler resolves and splits it.
-*/
-let _floatingPromise = null;
-function loadFloatingUi() {
-	_floatingPromise ??= import("@floating-ui/dom").catch((err) => {
-		_floatingPromise = null;
-		throw new Error("[mono-tooltip] needs the optional peer dependencies \"@floating-ui/dom\" and \"@floating-ui/core\". Install them in your app: pnpm add @floating-ui/dom @floating-ui/core" + (err?.message ? ` (original error: ${err.message})` : ""));
-	});
-	return _floatingPromise;
-}
-
 //#endregion
 //#region src/components/tooltip/control-tooltip.ts
+var control_tooltip_exports = /* @__PURE__ */ __exportAll({
+	ANCHOR_ATTR_PREFIX: () => ANCHOR_ATTR_PREFIX,
+	controlMonoTooltip: () => controlMonoTooltip,
+	createTooltipController: () => createTooltipController,
+	destroyAllTooltipControllers: () => destroyAllTooltipControllers,
+	hasLiveDocument: () => hasLiveDocument,
+	monoTooltip: () => monoTooltip
+});
 /** Grace period so an INTERACTIVE tooltip can be reached across the offset gap. */
 const INTERACTIVE_HIDE_GRACE = 120;
 /** Longest the exit transition may take before the element is removed anyway. */
@@ -701,102 +692,4 @@ function destroyAllTooltipControllers() {
 }
 
 //#endregion
-//#region src/components/tooltip/tooltip-declarative.ts
-/** The two text attributes — `message` is an alias of `content`. */
-const TOOLTIP_ATTRIBUTE_SELECTOR = "[mono-tooltip-content], [mono-tooltip-message]";
-let declarative = null;
-/**
-* Per-element options, from `mono-tooltip-<option>` attributes:
-*
-* | attribute | option |
-* | --- | --- |
-* | `mono-tooltip-content` / `-message` | `content` (text) |
-* | `mono-tooltip-placement` / `-variant` / `-color` / `-size` | same name |
-* | `mono-tooltip-trigger` | `"hover focus"`, `"click"`, … |
-* | `mono-tooltip-delay` | `"300"` or `"300 100"` |
-* | `mono-tooltip-offset` / `-padding` | numbers |
-* | `mono-tooltip-max-width` / `-class` | strings |
-* | `mono-tooltip-arrow` / `-flip` / `-shift` / `-interactive` / `-html` / `-disabled` / `-hide-on-click` | booleans — present = on, `"false"` = off |
-*/
-function readTooltipAttributes(el) {
-	const get = (name) => el.getAttribute(`mono-tooltip-${name}`);
-	const str = (name) => get(name)?.trim() || void 0;
-	const bool = (name) => {
-		const v = get(name);
-		return v === null ? void 0 : v.trim() !== "false";
-	};
-	const num = (name) => {
-		const v = str(name);
-		const n = v === void 0 ? NaN : Number(v);
-		return Number.isFinite(n) ? n : void 0;
-	};
-	const list = (name) => str(name)?.split(/[\s,]+/).filter(Boolean);
-	const content = get("content") ?? get("message") ?? void 0;
-	const delay = list("delay")?.map(Number).filter(Number.isFinite);
-	return {
-		content,
-		placement: str("placement"),
-		variant: str("variant"),
-		color: str("color"),
-		size: str("size"),
-		trigger: list("trigger"),
-		delay: delay?.length ? delay.length > 1 ? [delay[0], delay[1]] : delay[0] : void 0,
-		offset: num("offset"),
-		padding: num("padding"),
-		maxWidth: str("max-width"),
-		class: str("class"),
-		arrow: bool("arrow"),
-		flip: bool("flip"),
-		shift: bool("shift"),
-		interactive: bool("interactive"),
-		allowHTML: bool("html"),
-		disabled: bool("disabled"),
-		hideOnClick: bool("hide-on-click")
-	};
-}
-/**
-* Set the app-wide tooltip options AND switch on the `mono-tooltip-*` attributes.
-* Call once — usually in `main.ts`:
-*
-* ```ts
-* app.use(createMonoTooltip({ delay: [300, 0] }))
-* // or simply
-* createMonoTooltip()
-* ```
-*
-* The options WIN over the ones passed to `controlMonoTooltip`; an element's own
-* `mono-tooltip-*` attributes win over them. A later call replaces the previous
-* global options wholesale. `attributes: false` keeps the options but turns the
-* declarative attributes off.
-*/
-function createMonoTooltip(options = {}) {
-	setMonoTooltipGlobal(options);
-	const wantAttributes = options.attributes !== false;
-	if (wantAttributes && !declarative && hasLiveDocument()) declarative = createTooltipController(TOOLTIP_ATTRIBUTE_SELECTOR, {}, readTooltipAttributes);
-	else if (!wantAttributes && declarative) {
-		declarative.destroy();
-		declarative = null;
-	}
-	return {
-		options: { ...options },
-		install() {}
-	};
-}
-/**
-* Close and forget every live tooltip controller — the attribute one included
-* (a later `createMonoTooltip()` turns the attributes back on). For tests and a
-* full app teardown; the global options are kept.
-*/
-function destroyAllMonoTooltips() {
-	destroyAllTooltipControllers();
-	declarative = null;
-}
-/** Drop the global options and turn the attributes off (tests, runtime reconfiguration). */
-function resetMonoTooltip() {
-	setMonoTooltipGlobal(null);
-	declarative?.destroy();
-	declarative = null;
-}
-
-//#endregion
-export { resetMonoTooltip as a, loadFloatingUi as c, resolveTooltipOptions as d, readTooltipAttributes as i, DEFAULT_TOOLTIP_OPTIONS as l, createMonoTooltip as n, controlMonoTooltip as o, destroyAllMonoTooltips as r, monoTooltip as s, TOOLTIP_ATTRIBUTE_SELECTOR as t, getMonoTooltipGlobal as u };
+export { hasLiveDocument as a, getMonoTooltipGlobal as c, destroyAllTooltipControllers as i, resolveTooltipOptions as l, control_tooltip_exports as n, monoTooltip as o, createTooltipController as r, DEFAULT_TOOLTIP_OPTIONS as s, controlMonoTooltip as t, setMonoTooltipGlobal as u };

package/dist/{data-source-controller-Cf_sMxEh.js → data-source-controller-C6C4ej_M.js}

@@ -1,4 +1,4 @@
-import { a as describeError, l as isCanceled } from "./reactive-DFCdZbH9.js";
+import { n as describeError, o as isCanceled } from "./normalize-error-BmLbgANw.js";
 
 //#region src/composables/data-source-controller.ts
 /**

package/dist/{data-source-options-Bk-UoaZV.js → data-source-options-Cz9fVLK8.js}

@@ -1,6 +1,7 @@
 import { n as isPath, r as mergePatch, t as getFieldValue } from "./field-path-BabiMrrA.js";
-import { A as compileFilterPredicate, O as andFilters, h as mergeSearchFields, k as andPredicates, t as resolveMaybeReactive } from "./reactive-DFCdZbH9.js";
-import { i as searchFilterOf, s as flattenLeaves, t as isDataSourceLike } from "./data-source-read-Cuqw3LcP.js";
+import { D as compileFilterPredicate, E as andPredicates, T as andFilters, f as mergeSearchFields } from "./normalize-error-BmLbgANw.js";
+import { i as searchFilterOf, s as flattenLeaves, t as isDataSourceLike } from "./data-source-read-i6CYSUEl.js";
+import { t as resolveMaybeReactive } from "./reactive-Dtd-esHO.js";
 import { s as odataStringToArray, t as arrayToODataString } from "./filter-odata-Bi27XUpQ.js";
 
 //#region src/components/table/array-source.ts

package/dist/{data-source-read-Cuqw3LcP.js → data-source-read-i6CYSUEl.js}

@@ -1,5 +1,6 @@
 import { c as toODataClause, n as isPath, t as getFieldValue } from "./field-path-BabiMrrA.js";
-import { O as andFilters, n as unwrapReactive } from "./reactive-DFCdZbH9.js";
+import { T as andFilters } from "./normalize-error-BmLbgANw.js";
+import { n as unwrapReactive } from "./reactive-Dtd-esHO.js";
 
 //#region src/components/table/grouping.ts
 /**

package/dist/{excel-DtRpxmxs.js → excel-BPdDt06G.js}

@@ -1,4 +1,4 @@
-import { a as flattenInline, i as toExcelStyle, n as combineStyles, r as mergeStyles } from "./styles-D-ergrfR.js";
+import { a as flattenInline, i as toExcelStyle, n as combineStyles, r as mergeStyles } from "./styles-BODNpZV1.js";
 
 //#region src/export/sheet-name.ts
 /**

package/dist/{export-B91P6J1y.js → export-DgomqI_3.js}

@@ -1,6 +1,6 @@
 import { a as stripDirectives, i as escapeCellText, n as parseMarkdown, o as __commonJSMin, r as encodeDirective, s as __toESM } from "./markdown-uGlE_OfJ.js";
-import { n as unwrapReactive } from "./reactive-DFCdZbH9.js";
-import { n as isReadableSource, r as readAllRows } from "./data-source-read-Cuqw3LcP.js";
+import { n as isReadableSource, r as readAllRows } from "./data-source-read-i6CYSUEl.js";
+import { n as unwrapReactive } from "./reactive-Dtd-esHO.js";
 import { t as DEFAULT_STYLES } from "./excel-BXzr3uI1.js";
 
 //#region src/export/download.ts

package/dist/export.js

@@ -1,4 +1,4 @@
-import { c as escapeCellText, d as __toESM, l as stripDirectives, o as parseMarkdown, s as encodeDirective, t as DEFAULT_STYLES, u as __commonJSMin } from "./styles-D-ergrfR.js";
+import { c as escapeCellText, f as __toESM, l as stripDirectives, o as parseMarkdown, s as encodeDirective, t as DEFAULT_STYLES, u as __commonJSMin } from "./styles-BODNpZV1.js";
 import { n as isReadableSource, r as readAllRows } from "./data-source-read-FxqzQkk2.js";
 import { n as unwrapReactive } from "./reactive-Dtd-esHO.js";
 
@@ -2341,7 +2341,7 @@ async function exportTable(options) {
 	}
 	let workbookPromise = null;
 	const workbook = () => {
-		workbookPromise ??= import("./excel-DtRpxmxs.js").then(({ renderExcel }) => renderExcel(parseMarkdown(rendered), {
+		workbookPromise ??= import("./excel-BPdDt06G.js").then(({ renderExcel }) => renderExcel(parseMarkdown(rendered), {
 			...options,
 			back: options.detail?.back,
 			sheets: detailSheets.map((s) => ({

package/dist/{field-icons-FmyBWa0g.js → field-icons-t8rXRCKs.js}

@@ -83,6 +83,55 @@ function refreshIcon() {
     />
   </svg>`;
 }
+/**
+* ⓘ — the label's "more information" affordance (`tooltip` prop). The
+* `mdi:information-outline` path, so the shadow builds draw exactly what the
+* light build's `i-mdi-information-outline` mask paints.
+*/
+function infoIcon() {
+	return html`<svg
+    mono-icon
+    viewBox="0 0 24 24"
+    width="16"
+    height="16"
+    fill="currentColor"
+    aria-hidden="true"
+  >
+    <path
+      d="M11 9h2V7h-2m1 13c-4.41 0-8-3.59-8-8s3.59-8 8-8s8 3.59 8 8s-3.59 8-8 8m0-18A10 10 0 0 0 2 12a10 10 0 0 0 10 10a10 10 0 0 0 10-10A10 10 0 0 0 12 2m-1 15h2v-6h-2z"
+    />
+  </svg>`;
+}
+/** `validation-position="icon"` — mdi alert-circle-outline (invalid / warning). */
+function alertCircleIcon() {
+	return html`<svg
+    mono-icon
+    viewBox="0 0 24 24"
+    width="16"
+    height="16"
+    fill="currentColor"
+    aria-hidden="true"
+  >
+    <path
+      d="M11 15h2v2h-2zm0-8h2v6h-2zm1-5C6.47 2 2 6.5 2 12a10 10 0 0 0 10 10a10 10 0 0 0 10-10A10 10 0 0 0 12 2m0 18a8 8 0 0 1-8-8a8 8 0 0 1 8-8a8 8 0 0 1 8 8a8 8 0 0 1-8 8"
+    />
+  </svg>`;
+}
+/** `validation-position="icon"` — mdi check-circle-outline (valid). */
+function checkCircleIcon() {
+	return html`<svg
+    mono-icon
+    viewBox="0 0 24 24"
+    width="16"
+    height="16"
+    fill="currentColor"
+    aria-hidden="true"
+  >
+    <path
+      d="M12 2C6.5 2 2 6.5 2 12s4.5 10 10 10s10-4.5 10-10S17.5 2 12 2m0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8s8 3.59 8 8s-3.59 8-8 8m4.59-12.42L10 14.17l-2.59-2.58L6 13l4 4l8-8z"
+    />
+  </svg>`;
+}
 
 //#endregion
-export { spinnerIcon as a, refreshIcon as i, chevronIcon as n, closeIcon as r, caretIcon as t };
+export { closeIcon as a, spinnerIcon as c, chevronIcon as i, caretIcon as n, infoIcon as o, checkCircleIcon as r, refreshIcon as s, alertCircleIcon as t };

package/dist/field-tooltip-FyMi9vNM.js

@@ -0,0 +1,266 @@
+import { o as infoIcon } from "./field-icons-t8rXRCKs.js";
+import { html, nothing } from "lit";
+import { ref } from "lit/directives/ref.js";
+
+//#region src/composables/field-bubble.ts
+/** Gap between anchor and bubble, and the bubble's minimum distance to the viewport edge. */
+const GAP = 8;
+const EDGE = 8;
+/** Grace period for moving the pointer from the anchor onto the bubble. */
+const HIDE_DELAY = 120;
+let _uid = 0;
+var FieldBubble = class {
+	constructor(options = {}) {
+		this.id = `mono-field-bubble-${++_uid}`;
+		this._anchor = null;
+		this._bubble = null;
+		this._open = false;
+		this.setAnchor = (el) => {
+			this._anchor = el ?? null;
+		};
+		this.setBubble = (el) => {
+			if ((el ?? null) !== this._bubble) this.hide();
+			this._bubble = el ?? null;
+		};
+		this.show = () => {
+			this.cancelHide();
+			const bubble = this._bubble;
+			if (!bubble || !bubble.isConnected || !this._anchor) return;
+			if (!this._open) {
+				this._open = true;
+				bubble.setAttribute("mono-open", "");
+				try {
+					if (typeof bubble.showPopover === "function" && !bubble.matches(":popover-open")) bubble.showPopover();
+				} catch {}
+				window.addEventListener("scroll", this.place, true);
+				window.addEventListener("resize", this.place);
+			}
+			this.place();
+		};
+		this.hide = () => {
+			this.cancelHide();
+			if (!this._open) return;
+			this._open = false;
+			window.removeEventListener("scroll", this.place, true);
+			window.removeEventListener("resize", this.place);
+			const bubble = this._bubble;
+			if (!bubble) return;
+			bubble.removeAttribute("mono-open");
+			try {
+				if (typeof bubble.hidePopover === "function" && bubble.matches(":popover-open")) bubble.hidePopover();
+			} catch {}
+		};
+		this.scheduleHide = () => {
+			this.cancelHide();
+			this._hideTimer = setTimeout(this.hide, HIDE_DELAY);
+		};
+		this.cancelHide = () => {
+			if (this._hideTimer !== void 0) clearTimeout(this._hideTimer);
+			this._hideTimer = void 0;
+		};
+		this.onPointerLeave = (e) => {
+			if (e.pointerType === "touch") return;
+			this.scheduleHide();
+		};
+		this.onKeydown = (e) => {
+			if (e.key === "Escape" && this._open) {
+				e.stopPropagation();
+				this.hide();
+			}
+		};
+		this.place = () => {
+			const anchor = this._anchor;
+			const bubble = this._bubble;
+			if (!this._open || !anchor || !bubble) return;
+			const r = anchor.getBoundingClientRect();
+			const vw = document.documentElement.clientWidth || window.innerWidth;
+			const vh = window.innerHeight;
+			const bw = bubble.offsetWidth;
+			const bh = bubble.offsetHeight;
+			const above = r.top - GAP - bh;
+			const below = r.bottom + GAP;
+			const fitsAbove = above >= EDGE;
+			const fitsBelow = below + bh <= vh - EDGE;
+			const side = this._side === "top" ? fitsAbove || !fitsBelow ? "top" : "bottom" : fitsBelow || !fitsAbove ? "bottom" : "top";
+			const top = side === "top" ? above : below;
+			const target = this._align === "center" ? r.left + r.width / 2 : r.left + Math.min(16, r.width / 2);
+			const ideal = this._align === "center" ? target - bw / 2 : r.left;
+			const left = Math.min(Math.max(ideal, EDGE), Math.max(EDGE, vw - EDGE - bw));
+			bubble.style.top = `${Math.round(top)}px`;
+			bubble.style.left = `${Math.round(left)}px`;
+			bubble.style.setProperty("--_mono-field-tip-arrow-x", `${Math.round(target - left)}px`);
+			bubble.setAttribute("mono-side", side);
+		};
+		this._side = options.side ?? "top";
+		this._align = options.align ?? "center";
+	}
+	get isOpen() {
+		return this._open;
+	}
+};
+
+//#endregion
+//#region src/composables/field-tooltip.ts
+/** `controlMonoTooltip` once floating-ui is known to load, else `null`. Probed once per page. */
+let _probe = null;
+function probeTooltip() {
+	_probe ??= (async () => {
+		try {
+			const [{ loadFloatingUi }, { controlMonoTooltip }] = await Promise.all([import("./tooltip-loader-Dcp9AUZn.js").then((n) => n.n), import("./control-tooltip-C3rA_nSH.js").then((n) => n.n)]);
+			await loadFloatingUi();
+			return controlMonoTooltip;
+		} catch {
+			return null;
+		}
+	})();
+	return _probe;
+}
+/** `string` → `{ content }`; anything without content → `null` (renders nothing). */
+function normalizeFieldTooltip(value) {
+	if (!value) return null;
+	if (typeof value === "string") return value.trim() ? { content: value } : null;
+	if (typeof value !== "object") return null;
+	const { content } = value;
+	if (content === void 0 || content === null || content === "") return null;
+	return value;
+}
+/** Which bubble a prop value gets: the built-in one, the floating-ui addon, or none. */
+function tooltipMode(value) {
+	if (!normalizeFieldTooltip(value)) return null;
+	return typeof value === "string" ? "simple" : "floating";
+}
+/** A click on the bubble is still inside the `<label>` and the icon: neither should react. */
+const stopBubbleClick = (e) => {
+	e.preventDefault();
+	e.stopPropagation();
+};
+const stopLabelActivation = (e) => {
+	e.preventDefault();
+};
+var FieldTooltipController = class {
+	constructor(host, read) {
+		this.host = host;
+		this.read = read;
+		this._fn = null;
+		this._ctrl = null;
+		this._el = null;
+		this._applied = null;
+		this._raw = null;
+		this._connected = false;
+		this._bubble = new FieldBubble({
+			side: "top",
+			align: "center"
+		});
+		this._setEl = (el) => {
+			if ((el ?? null) !== this._el) this._unbind();
+			this._el = el ?? null;
+			this._bubble.setAnchor(this._el);
+		};
+		this._onIconClick = (e) => {
+			stopLabelActivation(e);
+			this._bubble.show();
+		};
+		host.addController(this);
+	}
+	hostConnected() {
+		this._connected = true;
+	}
+	hostDisconnected() {
+		this._connected = false;
+		this._bubble.hide();
+		this._unbind();
+	}
+	hostUpdated() {
+		if (tooltipMode(this.read()) === "floating") this._ensureProbe();
+		this._sync();
+	}
+	/** The ⓘ for the end of the label row, or `nothing`. */
+	render() {
+		const raw = this.read();
+		const mode = tooltipMode(raw);
+		if (mode === "simple") return this._renderSimple(raw);
+		if (mode !== "floating" || !this._fn) return nothing;
+		return html`<span
+      mono-label-tooltip
+      tabindex="0"
+      role="img"
+      aria-label="More information"
+      @click=${stopLabelActivation}
+      ${ref(this._setEl)}
+    >${this._icon()}</span>`;
+	}
+	/**
+	* Plain text: the icon carries its own bubble. `aria-describedby` reads the
+	* text to screen readers on focus; hover, focus or a tap shows it, Escape
+	* dismisses it, and the pointer may move onto it without it closing.
+	*/
+	_renderSimple(text) {
+		return html`<span
+      mono-label-tooltip
+      tabindex="0"
+      role="img"
+      aria-label="More information"
+      aria-describedby=${this._bubble.id}
+      @click=${this._onIconClick}
+      @pointerenter=${this._bubble.show}
+      @pointerleave=${this._bubble.onPointerLeave}
+      @focus=${this._bubble.show}
+      @blur=${this._bubble.hide}
+      @keydown=${this._bubble.onKeydown}
+      ${ref(this._setEl)}
+    >${this._icon()}<span
+        mono-field-bubble
+        mono-label-tooltip-bubble
+        id=${this._bubble.id}
+        role="tooltip"
+        popover="manual"
+        @pointerenter=${this._bubble.cancelHide}
+        @pointerleave=${this._bubble.onPointerLeave}
+        @click=${stopBubbleClick}
+        ${ref(this._bubble.setBubble)}
+      >${text}</span></span>`;
+	}
+	/**
+	* Light build: the UnoCSS `i-mdi-information-outline` mask (shipped in
+	* `ui/index.css`). Shadow build: the same path inline — the page's icon CSS
+	* cannot reach a shadow root.
+	*/
+	_icon() {
+		if (this.host.renderRoot instanceof ShadowRoot) return infoIcon();
+		return html`<span class="mono-icon i-mdi-information-outline" mono-icon aria-hidden="true"></span>`;
+	}
+	_ensureProbe() {
+		if (this._fn || typeof document === "undefined") return;
+		probeTooltip().then((fn) => {
+			if (!fn || this._fn) return;
+			this._fn = fn;
+			this.host.requestUpdate();
+		});
+	}
+	_sync() {
+		const raw = this.read();
+		if (tooltipMode(raw) !== "floating") return this._unbind();
+		if (this._ctrl && this._raw === raw) return;
+		const options = normalizeFieldTooltip(raw);
+		if (!this._fn || !this._connected || !this._el || !options) return this._unbind();
+		if (this._ctrl) {
+			const blanked = {};
+			for (const key of Object.keys(this._applied ?? {})) blanked[key] = void 0;
+			this._ctrl.update({
+				...blanked,
+				...options
+			});
+		} else this._ctrl = this._fn(this._el, options);
+		this._applied = options;
+		this._raw = raw;
+	}
+	_unbind() {
+		this._ctrl?.destroy();
+		this._ctrl = null;
+		this._applied = null;
+		this._raw = null;
+	}
+};
+
+//#endregion
+export { FieldBubble as n, FieldTooltipController as t };