blessing-ui 0.1.0

package/dist/components/tree.d.ts

@@ -0,0 +1,10 @@
+export interface BlessTreeNode {
+    label: string;
+    /** stable id; defaults to label path */
+    id?: string;
+    href?: string;
+    icon?: string;
+    children?: BlessTreeNode[];
+    open?: boolean;
+    disabled?: boolean;
+}

package/dist/composables/date.d.ts

@@ -0,0 +1,7 @@
+/** ISO date helpers (YYYY-MM-DD strings, local time, no library) */
+export declare const toISO: (d: Date) => string;
+export declare const fromISO: (s: string) => Date;
+export declare const addDays: (d: Date, n: number) => Date;
+export declare const addMonths: (d: Date, n: number) => Date;
+export declare const sameDay: (a: Date, b: Date) => boolean;
+export declare const isoToday: () => string;

package/dist/composables/date.js

@@ -0,0 +1,7 @@
+//#region src/composables/date.ts
+var e = (e) => `${e.getFullYear()}-${String(e.getMonth() + 1).padStart(2, "0")}-${String(e.getDate()).padStart(2, "0")}`, t = (e) => {
+	let [t, n, r] = e.split("-").map(Number);
+	return new Date(t, (n ?? 1) - 1, r ?? 1);
+}, n = (e, t) => new Date(e.getFullYear(), e.getMonth(), e.getDate() + t), r = (e, t) => new Date(e.getFullYear(), e.getMonth() + t, 1), i = () => e(/* @__PURE__ */ new Date());
+//#endregion
+export { n as addDays, r as addMonths, t as fromISO, i as isoToday, e as toISO };

package/dist/composables/rtl.d.ts

@@ -0,0 +1,5 @@
+/**
+ * ArrowLeft / ArrowRight swapped when the event's target renders right-to-left, so "next" keeps
+ * following the reading direction. Every other key passes through.
+ */
+export declare function logicalKey(e: KeyboardEvent): string;

package/dist/composables/rtl.js

@@ -0,0 +1,8 @@
+//#region src/composables/rtl.ts
+function e(e) {
+	if (e.key !== "ArrowLeft" && e.key !== "ArrowRight") return e.key;
+	let t = e.currentTarget ?? e.target;
+	return t && getComputedStyle(t).direction === "rtl" ? e.key === "ArrowLeft" ? "ArrowRight" : "ArrowLeft" : e.key;
+}
+//#endregion
+export { e as logicalKey };

package/dist/composables/useAnimateOnScroll.d.ts

@@ -0,0 +1,13 @@
+import { Ref } from 'vue';
+/**
+ * `visible` flips when `el` enters the viewport; pair with a CSS transition on
+ * `[data-visible]` or bind the ref to a class. `once` keeps it true after the first entry.
+ * Under `prefers-reduced-motion: reduce` it is true from mount — content appears, nothing moves.
+ */
+export declare function useAnimateOnScroll(el: Ref<HTMLElement | undefined | null>, opts?: {
+    threshold?: number;
+    rootMargin?: string;
+    once?: boolean;
+}): {
+    visible: Ref<boolean, boolean>;
+};

package/dist/composables/useAnimateOnScroll.js

@@ -0,0 +1,17 @@
+import { reducedMotion as e } from "./useMedia.js";
+import { onBeforeUnmount as t, onMounted as n, ref as r } from "vue";
+//#region src/composables/useAnimateOnScroll.ts
+function i(i, a = {}) {
+	let o = r(!1), s;
+	return n(() => {
+		if (e() || !i.value || typeof IntersectionObserver > "u") return void (o.value = !0);
+		s = new IntersectionObserver(([e]) => {
+			e && (e.isIntersecting ? (o.value = !0, (a.once ?? !0) && s?.disconnect()) : (a.once ?? !0) || (o.value = !1));
+		}, {
+			threshold: a.threshold ?? .15,
+			rootMargin: a.rootMargin
+		}), s.observe(i.value);
+	}), t(() => s?.disconnect()), { visible: o };
+}
+//#endregion
+export { i as useAnimateOnScroll };

package/dist/composables/useBrowser.d.ts

@@ -0,0 +1,23 @@
+import { Ref } from 'vue';
+/** element size via ResizeObserver */
+export declare function useResizeObserver(el: Ref<HTMLElement | null | undefined>): {
+    width: Ref<number, number>;
+    height: Ref<number, number>;
+};
+/** Fullscreen API on an element (or the document) */
+export declare function useFullscreen(el?: Ref<HTMLElement | null | undefined>): {
+    active: Ref<boolean, boolean>;
+    enter: () => Promise<void>;
+    exit: () => Promise<void> | null;
+    toggle: () => Promise<void> | null;
+};
+/** document.visibilityState as a ref */
+export declare function useVisibility(): {
+    visible: Ref<boolean, boolean>;
+};
+/** scroll position + direction of the window or an element */
+export declare function useScroll(el?: Ref<HTMLElement | null | undefined>): {
+    x: Ref<number, number>;
+    y: Ref<number, number>;
+    direction: Ref<"up" | "down" | null, "up" | "down" | null>;
+};

package/dist/composables/useBrowser.js

@@ -0,0 +1,41 @@
+import { onBeforeUnmount as e, onMounted as t, ref as n } from "vue";
+//#region src/composables/useBrowser.ts
+function r(r) {
+	let i = n(0), a = n(0), o;
+	return t(() => {
+		r.value && typeof ResizeObserver < "u" && (o = new ResizeObserver(([e]) => {
+			e && (i.value = e.contentRect.width, a.value = e.contentRect.height);
+		}), o.observe(r.value));
+	}), e(() => o?.disconnect()), {
+		width: i,
+		height: a
+	};
+}
+function i(r) {
+	let i = n(!1), a = () => i.value = !!document.fullscreenElement;
+	t(() => (a(), document.addEventListener("fullscreenchange", a))), e(() => document.removeEventListener("fullscreenchange", a));
+	let o = () => (r?.value ?? document.documentElement).requestFullscreen?.(), s = () => document.fullscreenElement && document.exitFullscreen();
+	return {
+		active: i,
+		enter: o,
+		exit: s,
+		toggle: () => i.value ? s() : o()
+	};
+}
+function a() {
+	let r = n(!0), i = () => r.value = document.visibilityState === "visible";
+	return t(() => (i(), document.addEventListener("visibilitychange", i))), e(() => document.removeEventListener("visibilitychange", i)), { visible: r };
+}
+function o(r) {
+	let i = n(0), a = n(0), o = n(null), s = 0, c = () => r?.value ?? window, l = () => {
+		let e = r?.value;
+		i.value = e ? e.scrollLeft : window.scrollX, a.value = e ? e.scrollTop : window.scrollY, o.value = a.value > s ? "down" : a.value < s ? "up" : o.value, s = a.value;
+	};
+	return t(() => (l(), c().addEventListener("scroll", l, { passive: !0 }))), e(() => c().removeEventListener("scroll", l)), {
+		x: i,
+		y: a,
+		direction: o
+	};
+}
+//#endregion
+export { i as useFullscreen, r as useResizeObserver, o as useScroll, a as useVisibility };

package/dist/composables/useDataTable.d.ts

@@ -0,0 +1,46 @@
+import { Ref } from 'vue';
+export interface DataTableState {
+    sortKey: string | null;
+    sortDir: "asc" | "desc";
+    page: number;
+    pageSize: number;
+    query: string;
+    selected: Set<string | number>;
+    hidden: Set<string>;
+}
+/**
+ * Headless sort / filter / paginate / select.
+ * Client mode (default): works over the in-memory row array.
+ * Server mode (`server: true`): the rows you pass are *already* the current page; sort, query and
+ * page live in `state` for you to send to the API, and `total` (a ref / number) drives the page count.
+ */
+export declare function useDataTable<T extends Record<string, unknown>>(rows: Ref<T[]> | T[], opts: {
+    rowKey: keyof T & string;
+    pageSize?: number;
+    searchKeys?: (keyof T & string)[];
+    server?: boolean;
+    /** server mode: total row count across all pages */
+    total?: Ref<number> | number;
+}): {
+    state: {
+        sortKey: string | null;
+        sortDir: "asc" | "desc";
+        page: number;
+        pageSize: number;
+        query: string;
+        selected: Set<string | number> & Omit<Set<string | number>, keyof Set<any>>;
+        hidden: Set<string> & Omit<Set<string>, keyof Set<any>>;
+    };
+    filtered: import('vue').ComputedRef<T[]>;
+    sorted: import('vue').ComputedRef<T[]>;
+    pageRows: import('vue').ComputedRef<T[]>;
+    pageCount: import('vue').ComputedRef<number>;
+    keyOf: (r: T) => string | number;
+    sortBy: (key: string) => void;
+    toggle: (r: T) => void;
+    togglePage: () => void;
+    allPageSelected: import('vue').ComputedRef<boolean>;
+    somePageSelected: import('vue').ComputedRef<boolean>;
+    selectedRows: import('vue').ComputedRef<T[]>;
+    toggleColumn: (key: string) => boolean | (Set<string> & Omit<Set<string>, keyof Set<any>>);
+};

package/dist/composables/useDataTable.js

@@ -0,0 +1,60 @@
+import { computed as e, reactive as t, unref as n } from "vue";
+//#region src/composables/useDataTable.ts
+function r(r, i) {
+	let a = t({
+		sortKey: null,
+		sortDir: "asc",
+		page: 1,
+		pageSize: i.pageSize ?? 10,
+		query: "",
+		selected: /* @__PURE__ */ new Set(),
+		hidden: /* @__PURE__ */ new Set()
+	}), o = e(() => {
+		let e = n(r);
+		if (i.server) return e;
+		let t = a.query.trim().toLowerCase();
+		if (!t) return e;
+		let o = i.searchKeys ?? Object.keys(e[0] ?? {});
+		return e.filter((e) => o.some((n) => String(e[n] ?? "").toLowerCase().includes(t)));
+	}), s = e(() => {
+		if (i.server || !a.sortKey) return o.value;
+		let e = a.sortKey, t = a.sortDir === "asc" ? 1 : -1;
+		return [...o.value].sort((n, r) => {
+			let i = n[e], a = r[e];
+			return i == null ? 1 : a == null ? -1 : (typeof i == "number" && typeof a == "number" ? i - a : String(i).localeCompare(String(a), void 0, { numeric: !0 })) * t;
+		});
+	}), c = e(() => Math.max(1, Math.ceil((i.server ? n(i.total) ?? s.value.length : s.value.length) / a.pageSize))), l = e(() => {
+		if (i.server) return s.value;
+		let e = Math.min(a.page, c.value);
+		return s.value.slice((e - 1) * a.pageSize, e * a.pageSize);
+	}), u = (e) => e[i.rowKey];
+	function d(e) {
+		a.sortKey === e ? a.sortDir = a.sortDir === "asc" ? "desc" : "asc" : (a.sortKey = e, a.sortDir = "asc");
+	}
+	function f(e) {
+		let t = u(e);
+		a.selected.has(t) ? a.selected.delete(t) : a.selected.add(t);
+	}
+	let p = e(() => l.value.length > 0 && l.value.every((e) => a.selected.has(u(e)))), m = e(() => l.value.some((e) => a.selected.has(u(e))));
+	function h() {
+		let e = !p.value;
+		for (let t of l.value) e ? a.selected.add(u(t)) : a.selected.delete(u(t));
+	}
+	return {
+		state: a,
+		filtered: o,
+		sorted: s,
+		pageRows: l,
+		pageCount: c,
+		keyOf: u,
+		sortBy: d,
+		toggle: f,
+		togglePage: h,
+		allPageSelected: p,
+		somePageSelected: m,
+		selectedRows: e(() => n(r).filter((e) => a.selected.has(u(e)))),
+		toggleColumn: (e) => a.hidden.has(e) ? a.hidden.delete(e) : a.hidden.add(e)
+	};
+}
+//#endregion
+export { r as useDataTable };

package/dist/composables/useDialog.d.ts

@@ -0,0 +1,26 @@
+import { Component } from 'vue';
+export interface BlessDialogOptions<P = Record<string, unknown>> {
+    title?: string;
+    /** rendered inside the modal body; receives `props` plus a `close(result)` prop */
+    component?: Component;
+    props?: P;
+    /** plain text body when no component */
+    text?: string;
+    size?: "sm" | "md" | "lg" | "full";
+    dismissible?: boolean;
+}
+export interface BlessDialogEntry extends BlessDialogOptions {
+    id: number;
+    component?: Component;
+    open: boolean;
+    resolve: (result: unknown) => void;
+}
+/** Programmatic modals; mount <BlessDialogHost /> once. `open()` resolves with whatever `close(result)` gets. */
+export declare function useDialog(): {
+    open: <R = unknown, P = Record<string, unknown>>(opts: BlessDialogOptions<P>) => Promise<R | undefined>;
+    close: (id: number, result?: unknown) => void;
+    items: BlessDialogEntry[];
+};
+export declare const dialogState: {
+    items: BlessDialogEntry[];
+};

package/dist/composables/useDialog.js

@@ -0,0 +1,31 @@
+import { markRaw as e, reactive as t, shallowReactive as n } from "vue";
+//#region src/composables/useDialog.ts
+var r = t({ items: n([]) }), i = 0;
+function a() {
+	function t(t) {
+		return new Promise((n) => {
+			let a = {
+				...t,
+				component: t.component ? e(t.component) : void 0,
+				id: ++i,
+				open: !0,
+				resolve: n
+			};
+			r.items.push(a);
+		});
+	}
+	function n(e, t) {
+		let n = r.items.findIndex((t) => t.id === e);
+		if (n < 0) return;
+		let [i] = r.items.splice(n, 1);
+		i.resolve(t);
+	}
+	return {
+		open: t,
+		close: n,
+		items: r.items
+	};
+}
+var o = r;
+//#endregion
+export { o as dialogState, a as useDialog };

package/dist/composables/useFieldId.d.ts

@@ -0,0 +1,28 @@
+import { Ref } from 'vue';
+/** BlessField: hand the label's `for` id and the error/description wiring to the control inside */
+export declare function provideField(id: string, invalid: Ref<boolean>, describedby: Ref<string | undefined>): void;
+/**
+ * Controls: `id` prop → id of the enclosing BlessField (first control only, so the label points at
+ * one element) → generated. Returns a getter because the prop is reactive.
+ */
+export declare function useFieldId(props: {
+    id?: string;
+}): () => string;
+/**
+ * Controls: the enclosing BlessField's validity and description ids (inert outside a field).
+ * `labelledby` is the field label's id, for controls a `<label for>` can't name (role=listbox…).
+ */
+export declare function useFieldState(): {
+    /** inside a BlessField: its label names the control, so skip a default aria-label */
+    inField: boolean;
+    labelledby: string | undefined;
+    invalid: Ref<boolean, boolean>;
+    describedby: Ref<string | undefined, string | undefined>;
+};
+/**
+ * Label wrappers (FloatLabel): the id their `for` points at. Inside a BlessField it is the
+ * field's id, so both labels name the same control; otherwise a fresh one is provided for it.
+ */
+export declare function useLabelFor(explicit?: string): string;
+/** aria-describedby from any number of ids (a control's own line, its error, the field's, one passed in) */
+export declare const joinIds: (...ids: (string | false | undefined | null)[]) => string | undefined;

package/dist/composables/useFieldId.js

@@ -0,0 +1,36 @@
+import { inject as e, provide as t, ref as n, useId as r } from "vue";
+//#region src/composables/useFieldId.ts
+var i = Symbol("bless-field");
+function a(e, n, r) {
+	t(i, {
+		id: e,
+		claimed: !1,
+		invalid: n,
+		describedby: r
+	});
+}
+function o(t) {
+	let n = r(), a = e(i, void 0), o = a && !a.claimed ? (a.claimed = !0, a.id) : void 0;
+	return () => t.id ?? o ?? n;
+}
+function s() {
+	let t = e(i, void 0);
+	return {
+		inField: !!t,
+		labelledby: t ? `${t.id}-label` : void 0,
+		invalid: t?.invalid ?? n(!1),
+		describedby: t?.describedby ?? n(void 0)
+	};
+}
+function c(a) {
+	let o = e(i, void 0), s = r(), c = a ?? o?.id ?? s;
+	return o || t(i, {
+		id: c,
+		claimed: !1,
+		invalid: n(!1),
+		describedby: n(void 0)
+	}), c;
+}
+var l = (...e) => e.filter(Boolean).join(" ") || void 0;
+//#endregion
+export { l as joinIds, a as provideField, o as useFieldId, s as useFieldState, c as useLabelFor };

package/dist/composables/useFloating.d.ts

@@ -0,0 +1,25 @@
+import { Ref } from 'vue';
+export type Placement = "top" | "bottom" | "left" | "right" | `${"top" | "bottom" | "left" | "right"}-${"start" | "end"}`;
+export interface FloatingOptions {
+    placement?: Placement;
+    offset?: number;
+    /** keep inside viewport by this padding */
+    padding?: number;
+    /** clamp inside this element's box instead of the viewport */
+    boundary?: HTMLElement | null;
+    /** size of the arrow element (px); enables arrowX / arrowY */
+    arrow?: number;
+}
+/**
+ * Minimal fixed-position floating: places `floating` next to `anchor`,
+ * flips to the opposite side when it would overflow, shifts along the
+ * cross axis to stay in the viewport. Recomputes on scroll/resize while `active`.
+ */
+export declare function useFloating(anchor: Ref<HTMLElement | null | undefined>, floating: Ref<HTMLElement | null | undefined>, active: Ref<boolean>, options?: FloatingOptions | (() => FloatingOptions)): {
+    x: Ref<number, number>;
+    y: Ref<number, number>;
+    side: Ref<"bottom" | "left" | "right" | "top", "bottom" | "left" | "right" | "top">;
+    arrowX: Ref<number, number>;
+    arrowY: Ref<number, number>;
+    update: () => void;
+};

package/dist/composables/useFloating.js

@@ -0,0 +1,42 @@
+import { onBeforeUnmount as e, ref as t, watch as n } from "vue";
+//#region src/composables/useFloating.ts
+function r(r, i, a, o = {}) {
+	let s = () => typeof o == "function" ? o() : o, c = t(0), l = t(0), u = t("bottom"), d = t(0), f = t(0);
+	function p() {
+		let e = r.value, t = i.value;
+		if (!e || !t) return;
+		let [n, a = "center"] = (s().placement ?? "bottom").split("-"), o = s().offset ?? 8, p = s().padding ?? 8, m = e.getBoundingClientRect(), h = t.offsetWidth, g = t.offsetHeight, _ = s().boundary?.getBoundingClientRect(), v = (_?.left ?? 0) + p, y = (_?.right ?? window.innerWidth) - p, b = (_?.top ?? 0) + p, x = (_?.bottom ?? window.innerHeight) - p;
+		window.innerWidth, window.innerHeight;
+		let S = (e) => e === "top" ? m.top - o - g >= b : e === "bottom" ? m.bottom + o + g <= x : e === "left" ? m.left - o - h >= v : m.right + o + h <= y, C = {
+			top: "bottom",
+			bottom: "top",
+			left: "right",
+			right: "left"
+		}, w = S(n) || !S(C[n]) ? n : C[n];
+		u.value = w;
+		let T, E;
+		w === "top" || w === "bottom" ? (E = w === "top" ? m.top - o - g : m.bottom + o, T = a === "start" ? m.left : a === "end" ? m.right - h : m.left + m.width / 2 - h / 2, T = Math.min(Math.max(v, T), y - h)) : (T = w === "left" ? m.left - o - h : m.right + o, E = a === "start" ? m.top : a === "end" ? m.bottom - g : m.top + m.height / 2 - g / 2, E = Math.min(Math.max(b, E), x - g)), c.value = Math.round(T), l.value = Math.round(E);
+		let D = s().arrow ?? 0;
+		D && (d.value = Math.round(Math.min(Math.max(D, m.left + m.width / 2 - T), h - D)), f.value = Math.round(Math.min(Math.max(D, m.top + m.height / 2 - E), g - D)));
+	}
+	let m, h = (e) => {
+		if (typeof window > "u") return;
+		let t = e ? addEventListener : removeEventListener;
+		t("scroll", p, !0), t("resize", p), m?.disconnect(), m = void 0, e && i.value && typeof ResizeObserver < "u" && (m = new ResizeObserver(() => p()), m.observe(i.value));
+	};
+	return n(a, (e) => {
+		h(e), e && requestAnimationFrame(p);
+	}, {
+		flush: "post",
+		immediate: !0
+	}), e(() => (h(!1), m?.disconnect())), {
+		x: c,
+		y: l,
+		side: u,
+		arrowX: d,
+		arrowY: f,
+		update: p
+	};
+}
+//#endregion
+export { r as useFloating };

package/dist/composables/useGesture.d.ts

@@ -0,0 +1,34 @@
+import { Ref } from 'vue';
+type El = Ref<HTMLElement | null | undefined>;
+export type SwipeDirection = "left" | "right" | "up" | "down";
+export interface PanEvent {
+    dx: number;
+    dy: number;
+    /** start | move | end | cancel */
+    phase: "start" | "move" | "end" | "cancel";
+    event: PointerEvent;
+}
+/** Pointer-event pan: dx/dy from the press point, with pointer capture. Set `touch-action` on the element yourself. */
+export declare function usePan(el: El, onPan: (e: PanEvent) => void, opts?: {
+    pointerTypes?: PointerEvent["pointerType"][];
+}): void;
+/** Fires once per gesture when the release exceeds `threshold` px along the dominant axis. */
+export declare function useSwipe(el: El, onSwipe: (dir: SwipeDirection, e: PanEvent) => void, opts?: {
+    threshold?: number;
+    axis?: "x" | "y" | "both";
+}): {
+    direction: Ref<SwipeDirection | undefined, SwipeDirection | undefined>;
+};
+/** Press and hold for `ms` without moving more than `tolerance` px. */
+export declare function useLongPress(el: El, onHold: (e: PointerEvent) => void, opts?: {
+    ms?: number;
+    tolerance?: number;
+}): {
+    pressing: Ref<boolean, boolean>;
+};
+/** Fire `onRepeat` while held: once after `delay`, then every `interval`. For ± steppers. */
+export declare function useTouchRepeat(el: El, onRepeat: () => void, opts?: {
+    delay?: number;
+    interval?: number;
+}): void;
+export {};

package/dist/composables/useGesture.js

@@ -0,0 +1,57 @@
+import { onBeforeUnmount as e, onMounted as t, ref as n } from "vue";
+//#region src/composables/useGesture.ts
+function r(n, r, i = {}) {
+	let a = null, o = (e) => !i.pointerTypes || i.pointerTypes.includes(e.pointerType), s = (e) => {
+		o(e) && !e.button && (a = {
+			x: e.clientX,
+			y: e.clientY,
+			id: e.pointerId
+		}, e.currentTarget.setPointerCapture?.(e.pointerId), r({
+			dx: 0,
+			dy: 0,
+			phase: "start",
+			event: e
+		}));
+	}, c = (e) => a && e.pointerId === a.id && r({
+		dx: e.clientX - a.x,
+		dy: e.clientY - a.y,
+		phase: "move",
+		event: e
+	}), l = (e) => (t) => {
+		a && t.pointerId === a.id && (r({
+			dx: t.clientX - a.x,
+			dy: t.clientY - a.y,
+			phase: e,
+			event: t
+		}), a = null);
+	}, u = l("end"), d = l("cancel");
+	t(() => {
+		let e = n.value;
+		e && (e.addEventListener("pointerdown", s), e.addEventListener("pointermove", c), e.addEventListener("pointerup", u), e.addEventListener("pointercancel", d));
+	}), e(() => {
+		let e = n.value;
+		e?.removeEventListener("pointerdown", s), e?.removeEventListener("pointermove", c), e?.removeEventListener("pointerup", u), e?.removeEventListener("pointercancel", d);
+	});
+}
+function i(e, t, i = {}) {
+	let a = n(), o = i.threshold ?? 40;
+	return r(e, (e) => {
+		if (e.phase !== "end") return;
+		let n = Math.abs(e.dx), r = Math.abs(e.dy), s = n >= r;
+		i.axis === "x" && !s || i.axis === "y" && s || Math.max(n, r) < o || (a.value = s ? e.dx > 0 ? "right" : "left" : e.dy > 0 ? "down" : "up", t(a.value, e));
+	}), { direction: a };
+}
+function a(t, i, a = {}) {
+	let o = n(!1), s;
+	return r(t, (e) => {
+		e.phase === "start" ? (o.value = !0, s = setTimeout(() => (o.value && i(e.event), o.value = !1), a.ms ?? 500)) : e.phase === "move" ? Math.hypot(e.dx, e.dy) > (a.tolerance ?? 8) && (o.value = !1, clearTimeout(s)) : (o.value = !1, clearTimeout(s));
+	}), e(() => clearTimeout(s)), { pressing: o };
+}
+function o(t, n, i = {}) {
+	let a, o, s = () => (clearTimeout(a), clearInterval(o));
+	r(t, (e) => {
+		e.phase === "start" ? (n(), a = setTimeout(() => o = setInterval(n, i.interval ?? 100), i.delay ?? 400)) : e.phase !== "move" && s();
+	}), e(s);
+}
+//#endregion
+export { a as useLongPress, r as usePan, i as useSwipe, o as useTouchRepeat };

package/dist/composables/useHash.d.ts

@@ -0,0 +1,2 @@
+/** reactive location.hash (without '#') */
+export declare function useHash(): import('vue').Ref<string, string>;

package/dist/composables/useHash.js

@@ -0,0 +1,12 @@
+import { onBeforeUnmount as e, onMounted as t, ref as n } from "vue";
+//#region src/composables/useHash.ts
+function r() {
+	let r = n(""), i = () => {
+		r.value = decodeURIComponent(location.hash.slice(1));
+	};
+	return t(() => {
+		i(), addEventListener("hashchange", i);
+	}), e(() => removeEventListener("hashchange", i)), r;
+}
+//#endregion
+export { r as useHash };

package/dist/composables/useLink.d.ts

@@ -0,0 +1,16 @@
+import { Component, InjectionKey } from 'vue';
+/**
+ * Provide your router's link component once and every anchor-rendering component
+ * (SidebarNav, Button, Card, ListItem, Breadcrumb, Pagination, menus, tabs, tree) renders it
+ * for in-app paths — `app.provide(blessLinkKey, RouterLink)` (Nuxt: `resolveComponent("NuxtLink")`).
+ * Nothing is imported from any router; without a provider everything stays a plain <a>.
+ */
+export declare const blessLinkKey: InjectionKey<Component>;
+/** true for a same-app path the router should handle: starts with "/" or is a bare relative path */
+export declare const isRouterHref: (href: string) => boolean;
+export type BlessLinkTag = {
+    is: string | Component;
+    attrs: Record<string, unknown>;
+};
+/** resolves what to render for an href: the provided link component with `to`, or <a href> */
+export declare function useLink(): (href: string | undefined, external?: boolean, fallback?: string) => BlessLinkTag;

package/dist/composables/useLink.js

@@ -0,0 +1,22 @@
+import { inject as e } from "vue";
+//#region src/composables/useLink.ts
+var t = Symbol("bless-link"), n = (e) => !/^(?:[a-z][a-z0-9+.-]*:|\/\/|#)/i.test(e);
+function r() {
+	let r = e(t, null);
+	return (e, t, i = "a") => e ? r && !t && n(e) ? {
+		is: r,
+		attrs: { to: e }
+	} : {
+		is: "a",
+		attrs: {
+			href: e,
+			target: t ? "_blank" : void 0,
+			rel: t ? "noopener" : void 0
+		}
+	} : {
+		is: i,
+		attrs: {}
+	};
+}
+//#endregion
+export { t as blessLinkKey, n as isRouterHref, r as useLink };

package/dist/composables/useLoadingBar.d.ts

@@ -0,0 +1,15 @@
+/** Top-of-page progress bar (Quasar LoadingBar / nprogress style). Mount <BlessLoadingBar /> once. */
+export declare function useLoadingBar(): {
+    start: () => void;
+    stop: () => void;
+    set: (p: number) => void;
+    track: <T>(p: Promise<T>) => Promise<T>;
+    state: {
+        active: boolean;
+        progress: number;
+    };
+};
+export declare const loadingBarState: {
+    active: boolean;
+    progress: number;
+};

package/dist/composables/useLoadingBar.js

@@ -0,0 +1,37 @@
+import { reactive as e } from "vue";
+//#region src/composables/useLoadingBar.ts
+var t = e({
+	active: !1,
+	progress: 0
+}), n, r, i = 0;
+function a() {
+	function e() {
+		i++, r &&= (clearTimeout(r), void 0), !(t.active && n) && (t.active = !0, t.progress = 8, n = setInterval(() => t.progress = Math.min(90, t.progress + (90 - t.progress) * .1), 250));
+	}
+	function a() {
+		i = Math.max(0, i - 1), !i && (clearInterval(n), n = void 0, t.progress = 100, r = setTimeout(() => {
+			r = void 0, !i && (t.active = !1, t.progress = 0);
+		}, 300));
+	}
+	function o(e) {
+		t.progress = Math.max(0, Math.min(100, e));
+	}
+	async function s(t) {
+		e();
+		try {
+			return await t;
+		} finally {
+			a();
+		}
+	}
+	return {
+		start: e,
+		stop: a,
+		set: o,
+		track: s,
+		state: t
+	};
+}
+var o = t;
+//#endregion
+export { o as loadingBarState, a as useLoadingBar };

package/dist/composables/useMedia.d.ts

@@ -0,0 +1,6 @@
+/** reactive matchMedia; defaults to the single Blessing breakpoint */
+export declare function useMedia(query?: string): import('vue').Ref<boolean, boolean>;
+/** true when the user asked for reduced motion (false outside a browser) */
+export declare const reducedMotion: () => boolean;
+/** "smooth" unless the user asked for reduced motion */
+export declare const scrollBehavior: (b?: ScrollBehavior) => ScrollBehavior;