iryx-ui 0.12.0 → 0.13.0

package/dist/composables/cartesian.js

@@ -1,14 +1,13 @@
 import { extent as e, linearScale as t, niceTicks as n } from "./scale.js";
-import r from "node:process";
 //#region src/composables/cartesian.ts
-var i = 6.5, a = 8, o = 20, s = 8;
-function c(r) {
-	let a = r.orientation ?? "vertical", o = a === "horizontal", s = e(r.values), c = s ? n(r.includeZero ? Math.min(0, s[0]) : s[0], r.includeZero ? Math.max(0, s[1]) : s[1], r.tickCount) : n(0, 1, r.tickCount), l = Math.ceil(Math.max(...c.ticks.map((e) => r.formatTick(e).length), 1) * i) + 8, u = o ? Math.ceil(r.longestLabel * i) + 8 : r.showAxis ? l : 0, d = o && !r.showAxis ? 0 : 20, f = o && r.showAxis ? Math.ceil(l / 2) : 0, p = {
+var r = 6.5, i = 8, a = 20, o = 8;
+function s(i) {
+	let a = i.orientation ?? "vertical", o = a === "horizontal", s = e(i.values), c = s ? n(i.includeZero ? Math.min(0, s[0]) : s[0], i.includeZero ? Math.max(0, s[1]) : s[1], i.tickCount) : n(0, 1, i.tickCount), l = Math.ceil(Math.max(...c.ticks.map((e) => i.formatTick(e).length), 1) * r) + 8, u = o ? Math.ceil(i.longestLabel * r) + 8 : i.showAxis ? l : 0, d = o && !i.showAxis ? 0 : 20, f = o && i.showAxis ? Math.ceil(l / 2) : 0, p = {
 		left: u,
 		top: 8,
-		width: Math.max(r.width - u - f, 0),
-		height: Math.max(r.height - 8 - d, 0)
-	}, m = o ? t([c.min, c.max], [p.left, p.left + p.width]) : t([c.min, c.max], [p.top + p.height, p.top]), h = o ? p.height : p.width, g = r.categories ? h / r.categories : 0, _ = o ? p.top : p.left, v = o ? 16 : r.longestLabel * i + 8, y = g ? Math.max(1, Math.ceil(v / g)) : 1;
+		width: Math.max(i.width - u - f, 0),
+		height: Math.max(i.height - 8 - d, 0)
+	}, m = o ? t([c.min, c.max], [p.left, p.left + p.width]) : t([c.min, c.max], [p.top + p.height, p.top]), h = o ? p.height : p.width, g = i.categories ? h / i.categories : 0, _ = o ? p.top : p.left, v = o ? 16 : i.longestLabel * r + 8, y = g ? Math.max(1, Math.ceil(v / g)) : 1;
 	return {
 		orientation: a,
 		ticks: c.ticks,
@@ -20,24 +19,24 @@ function c(r) {
 		bandCentre: (e) => _ + g * (e + .5)
 	};
 }
-var l = 8;
-function u(e) {
+var c = 8;
+function l(e) {
 	return `var(--iryx-chart-${Math.min(Math.max(e, 0), 7) + 1})`;
 }
-function d(e, t) {
+function u(e, t) {
 	return e.slot ?? t;
 }
-var f = !1;
-function p(e) {
-	e <= 8 || f || r.env.NODE_ENV === "production" || (f = !0, console.warn(`[iryx-ui] ${e} chart series exceeds the 8 categorical slots. Colours past the eighth repeat and stop identifying anything — fold the tail into "Other", or use small multiples.`));
+var d = !1;
+function f(e) {
+	e <= 8 || d || process.env.NODE_ENV === "production" || (d = !0, console.warn(`[iryx-ui] ${e} chart series exceeds the 8 categorical slots. Colours past the eighth repeat and stop identifying anything — fold the tail into "Other", or use small multiples.`));
 }
-function m(e, t, n) {
-	let r = g(t);
+function p(e, t, n) {
+	let r = h(t);
 	return n <= r * 2 ? n / 2 : Math.min(Math.max(e, r), Math.max(n - r, r));
 }
-var h = 5.6;
-function g(e) {
-	return (e.length * h + 28) / 2;
+var m = 5.6;
+function h(e) {
+	return (e.length * m + 28) / 2;
 }
 //#endregion
-export { a as AXIS_GAP, o as CATEGORY_HEIGHT, i as CHAR_WIDTH, l as SERIES_SLOTS, s as TOP_PAD, c as cartesianLayout, m as clampTooltip, u as seriesColor, d as slotOf, g as tooltipHalfWidth, p as warnOnSlotOverflow };
+export { i as AXIS_GAP, a as CATEGORY_HEIGHT, r as CHAR_WIDTH, c as SERIES_SLOTS, o as TOP_PAD, s as cartesianLayout, p as clampTooltip, l as seriesColor, u as slotOf, h as tooltipHalfWidth, f as warnOnSlotOverflow };

package/dist/composables/command-palette.d.ts

@@ -0,0 +1,42 @@
+import type { IconLike } from './icon';
+export interface CommandItem {
+    /** What the reader searches for and reads. */
+    label: string;
+    icon?: IconLike;
+    /**
+     * Displayed at the trailing edge, split on spaces into separate keys.
+     * Display only — the palette never binds it, because the shortcut belongs
+     * to the command itself and works whether or not the palette is open.
+     */
+    shortcut?: string;
+    /**
+     * Extra search terms that never appear on screen: synonyms, the old name of
+     * a renamed page, the word a reader would guess.
+     */
+    keywords?: string[];
+    /** Renders the row as a link, so middle-click and open-in-new-tab work. */
+    href?: string;
+    disabled?: boolean;
+    onSelect?: () => void;
+}
+export interface CommandGroup {
+    label: string;
+    items: CommandItem[];
+}
+export type CommandEntry = CommandItem | CommandGroup;
+export declare function isCommandGroup(entry: CommandEntry): entry is CommandGroup;
+/** Normalise to groups, so the template has a single path to render. */
+export declare function toCommandGroups(entries: CommandEntry[] | undefined): CommandGroup[];
+/**
+ * Everything a query should match against: the label, the group it sits in,
+ * and any keywords. Joined rather than tested separately so a query spanning
+ * two of them ("settings members") still matches.
+ */
+export declare function commandHaystack(item: CommandItem, group: string): string;
+/**
+ * Parse a hotkey like `mod+k` into a matcher.
+ *
+ * `mod` is Command on Apple platforms and Control everywhere else — the same
+ * key in muscle memory, a different key on the wire.
+ */
+export declare function matchesHotkey(event: KeyboardEvent, hotkey: string): boolean;

package/dist/composables/command-palette.js

@@ -0,0 +1,32 @@
+import { isApplePlatform as e } from "./kbd.js";
+//#region src/composables/command-palette.ts
+function t(e) {
+	return Array.isArray(e.items);
+}
+function n(e) {
+	let n = [], r;
+	for (let i of e ?? []) {
+		if (t(i)) {
+			n.push(i), r = void 0;
+			continue;
+		}
+		r || (r = [], n.push({
+			label: "",
+			items: r
+		})), r.push(i);
+	}
+	return n;
+}
+function r(e, t) {
+	return [
+		e.label,
+		t,
+		...e.keywords ?? []
+	].join(" ");
+}
+function i(t, n) {
+	let r = n.toLowerCase().split("+").map((e) => e.trim()), i = r.at(-1) ?? "", a = r.includes("mod"), o = r.includes("ctrl") || r.includes("control"), s = r.includes("meta") || r.includes("cmd"), c = r.includes("shift"), l = r.includes("alt") || r.includes("option"), u = e() ? t.metaKey : t.ctrlKey;
+	return a && !u || o && !t.ctrlKey || s && !t.metaKey || c !== t.shiftKey || l !== t.altKey ? !1 : t.key.toLowerCase() === i;
+}
+//#endregion
+export { r as commandHaystack, t as isCommandGroup, i as matchesHotkey, n as toCommandGroups };

package/dist/composables/date.d.ts

@@ -1,5 +1,5 @@
 import type { DateValue } from '@internationalized/date';
-import { CalendarDate } from '@internationalized/date';
+import { CalendarDate, Time } from '@internationalized/date';
 /**
  * Parse an ISO date, or `undefined` if it is absent or malformed.
  *
@@ -17,5 +17,21 @@ export declare function isoToday(): string;
  * so a caller can fall back to a placeholder.
  */
 export declare function formatIsoDate(iso: string | null | undefined, locale?: string, options?: Intl.DateTimeFormatOptions): string;
-export { CalendarDate };
+/**
+ * Parse a `HH:mm` (or `HH:mm:ss`) string, or `undefined` if it is absent or
+ * malformed. Same bargain as {@link toCalendarDate}: bad input means "no
+ * selection" rather than a thrown render.
+ */
+export declare function toTime(value: string | null | undefined): Time | undefined;
+/**
+ * Back to `HH:mm`, or `HH:mm:ss` when there are seconds to keep. Padded, so
+ * the result sorts and compares as a string — which is most of the reason to
+ * hold a time as one.
+ */
+export declare function toIsoTime(time: {
+    hour: number;
+    minute: number;
+    second?: number;
+} | null | undefined): string | null;
+export { CalendarDate, Time };
 export type { DateValue };

package/dist/composables/date.js

@@ -1,22 +1,33 @@
-import { CalendarDate as e, DateFormatter as t, getLocalTimeZone as n, parseDate as r, today as i } from "@internationalized/date";
+import { CalendarDate as e, DateFormatter as t, Time as n, getLocalTimeZone as r, parseDate as i, today as a } from "@internationalized/date";
 //#region src/composables/date.ts
-var a = /^\d{4}-\d{2}-\d{2}$/;
-function o(e) {
-	if (!(!e || !a.test(e))) try {
-		return r(e);
+var o = /^\d{4}-\d{2}-\d{2}$/;
+function s(e) {
+	if (!(!e || !o.test(e))) try {
+		return i(e);
 	} catch {
 		return;
 	}
 }
-function s(e) {
+function c(e) {
 	return e ? `${e.year.toString().padStart(4, "0")}-${e.month.toString().padStart(2, "0")}-${e.day.toString().padStart(2, "0")}` : null;
 }
-function c() {
-	return s(i(n()));
+function l() {
+	return c(a(r()));
+}
+function u(e, n, i = { dateStyle: "medium" }) {
+	let a = s(e);
+	return a ? new t(n ?? "en-US", i).format(a.toDate(r())) : "";
+}
+var d = /^(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d)?$/;
+function f(e) {
+	if (!e || !d.test(e)) return;
+	let [t, r, i] = e.split(":").map(Number);
+	return new n(t, r, i ?? 0);
 }
-function l(e, r, i = { dateStyle: "medium" }) {
-	let a = o(e);
-	return a ? new t(r ?? "en-US", i).format(a.toDate(n())) : "";
+function p(e) {
+	if (!e) return null;
+	let t = (e) => String(e).padStart(2, "0"), n = `${t(e.hour)}:${t(e.minute)}`;
+	return e.second ? `${n}:${t(e.second)}` : n;
 }
 //#endregion
-export { e as CalendarDate, l as formatIsoDate, c as isoToday, o as toCalendarDate, s as toIsoDate };
+export { e as CalendarDate, n as Time, u as formatIsoDate, l as isoToday, s as toCalendarDate, c as toIsoDate, p as toIsoTime, f as toTime };

package/dist/composables/kbd.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Whether the reader is on an Apple platform, resolved **after mount**.
+ *
+ * It cannot be resolved during render: there is no `navigator` on the server,
+ * so server markup would say "Ctrl" and the client would say "⌘" — a
+ * hydration mismatch on every page carrying a shortcut. Starting `false` and
+ * correcting on mount means the worst case is one frame of the wrong glyph
+ * rather than a mismatched tree.
+ */
+export declare function useApplePlatform(): import("vue").Ref<boolean, boolean>;
+/** The same check, for code that already runs in the browser. */
+export declare function isApplePlatform(): boolean;
+export interface KbdKey {
+    /** What is drawn in the chip. */
+    symbol: string;
+    /** What a screen reader says instead. */
+    spoken: string;
+}
+/**
+ * Turn a hotkey into the keys to draw — `mod+k` becomes `⌘` and `K` on a Mac,
+ * `Ctrl` and `K` elsewhere.
+ *
+ * Accepts the same vocabulary as `matchesHotkey`, so the shortcut you bind and
+ * the shortcut you show are written the same way.
+ */
+export declare function parseHotkey(hotkey: string | string[], apple: boolean): KbdKey[];

package/dist/composables/kbd.js

@@ -0,0 +1,161 @@
+import { onMounted as e, ref as t } from "vue";
+//#region src/composables/kbd.ts
+function n() {
+	let n = t(!1);
+	return e(() => {
+		n.value = r();
+	}), n;
+}
+function r() {
+	return typeof navigator > "u" ? !1 : /mac|iphone|ipad|ipod/i.test(navigator.platform || navigator.userAgent);
+}
+var i = {
+	mod: {
+		apple: "⌘",
+		other: "Ctrl",
+		spoken: "Command",
+		spokenOther: "Control"
+	},
+	meta: {
+		apple: "⌘",
+		other: "Win",
+		spoken: "Command",
+		spokenOther: "Windows"
+	},
+	cmd: {
+		apple: "⌘",
+		other: "Ctrl",
+		spoken: "Command",
+		spokenOther: "Control"
+	},
+	ctrl: {
+		apple: "⌃",
+		other: "Ctrl",
+		spoken: "Control"
+	},
+	control: {
+		apple: "⌃",
+		other: "Ctrl",
+		spoken: "Control"
+	},
+	shift: {
+		apple: "⇧",
+		other: "Shift",
+		spoken: "Shift"
+	},
+	alt: {
+		apple: "⌥",
+		other: "Alt",
+		spoken: "Option",
+		spokenOther: "Alt"
+	},
+	option: {
+		apple: "⌥",
+		other: "Alt",
+		spoken: "Option",
+		spokenOther: "Alt"
+	}
+}, a = {
+	enter: {
+		symbol: "↵",
+		spoken: "Enter"
+	},
+	return: {
+		symbol: "↵",
+		spoken: "Return"
+	},
+	escape: {
+		symbol: "Esc",
+		spoken: "Escape"
+	},
+	esc: {
+		symbol: "Esc",
+		spoken: "Escape"
+	},
+	backspace: {
+		symbol: "⌫",
+		spoken: "Backspace"
+	},
+	delete: {
+		symbol: "⌦",
+		spoken: "Delete"
+	},
+	tab: {
+		symbol: "⇥",
+		spoken: "Tab"
+	},
+	space: {
+		symbol: "␣",
+		spoken: "Space"
+	},
+	capslock: {
+		symbol: "⇪",
+		spoken: "Caps lock"
+	},
+	win: {
+		symbol: "⊞",
+		spoken: "Windows"
+	},
+	pageup: {
+		symbol: "⇞",
+		spoken: "Page up"
+	},
+	pagedown: {
+		symbol: "⇟",
+		spoken: "Page down"
+	},
+	home: {
+		symbol: "↖",
+		spoken: "Home"
+	},
+	end: {
+		symbol: "↘",
+		spoken: "End"
+	},
+	up: {
+		symbol: "↑",
+		spoken: "Up arrow"
+	},
+	down: {
+		symbol: "↓",
+		spoken: "Down arrow"
+	},
+	left: {
+		symbol: "←",
+		spoken: "Left arrow"
+	},
+	right: {
+		symbol: "→",
+		spoken: "Right arrow"
+	},
+	arrowup: {
+		symbol: "↑",
+		spoken: "Up arrow"
+	},
+	arrowdown: {
+		symbol: "↓",
+		spoken: "Down arrow"
+	},
+	arrowleft: {
+		symbol: "←",
+		spoken: "Left arrow"
+	},
+	arrowright: {
+		symbol: "→",
+		spoken: "Right arrow"
+	}
+};
+function o(e, t) {
+	return (Array.isArray(e) ? e : e.split("+").map((e) => e.trim()).filter(Boolean)).map((e) => {
+		let n = e.toLowerCase(), r = i[n];
+		return r ? {
+			symbol: t ? r.apple : r.other,
+			spoken: t ? r.spoken : r.spokenOther ?? r.spoken
+		} : a[n] || {
+			symbol: e.length === 1 ? e.toUpperCase() : e,
+			spoken: e.toUpperCase()
+		};
+	});
+}
+//#endregion
+export { r as isApplePlatform, o as parseHotkey, n as useApplePlatform };

package/dist/composables/navigation-menu.d.ts

@@ -0,0 +1,29 @@
+import type { IconLike } from './icon';
+export interface NavigationMenuLinkItem {
+    label: string;
+    /** Renders an `<a>`. Omit to render a `<button>` and handle `onSelect` yourself. */
+    href?: string;
+    /** `target` on the anchor, e.g. `'_blank'`. Ignored without `href`. */
+    target?: string;
+    icon?: IconLike;
+    /** Secondary line under the label. Only shown inside a panel. */
+    description?: string;
+    disabled?: boolean;
+    /** Marks the current page. Reflected as `data-active` and `aria-current`. */
+    active?: boolean;
+    /** Handle navigation yourself, e.g. with a router. */
+    onSelect?: () => void;
+}
+export interface NavigationMenuGroupItem extends NavigationMenuLinkItem {
+    /** Child links. Turns this entry into a panel trigger. */
+    items: NavigationMenuLinkItem[];
+    /** Columns for this entry's panel. Defaults to the menu's `columns`. */
+    columns?: 1 | 2 | 3;
+}
+/**
+ * One top-level entry: a link on its own, or a trigger that opens a panel of
+ * links. Which one it is comes from the presence of `items`, the same rule
+ * `DropdownMenuEntry` uses.
+ */
+export type NavigationMenuEntry = NavigationMenuLinkItem | NavigationMenuGroupItem;
+export declare function isNavigationGroup(entry: NavigationMenuEntry): entry is NavigationMenuGroupItem;

package/dist/composables/navigation-menu.js

@@ -0,0 +1,6 @@
+//#region src/composables/navigation-menu.ts
+function e(e) {
+	return Array.isArray(e.items) && e.items.length > 0;
+}
+//#endregion
+export { e as isNavigationGroup };

package/dist/composables/scroll-fade.d.ts

@@ -0,0 +1,35 @@
+import type { Ref } from 'vue';
+export interface ScrollEdges {
+    /** Nothing is scrolled past — the leading edge needs no fade. */
+    atStart: Ref<boolean>;
+    /** Everything is in view — the trailing edge needs no fade. */
+    atEnd: Ref<boolean>;
+    /** No overflow at all, so neither edge fades. */
+    overflowing: Ref<boolean>;
+    measure: () => void;
+}
+/**
+ * Track whether a scroll container has content past either edge.
+ *
+ * Measured rather than assumed: content arrives late, fonts reflow, and a
+ * panel that fits on a desktop overflows on a phone. A fade painted on a
+ * container that does not actually scroll is a lie about what is there.
+ */
+export declare function useScrollEdges(target: Ref<HTMLElement | undefined>, axis: Ref<'vertical' | 'horizontal'>): ScrollEdges;
+/**
+ * The mask that fades the edges with something past them.
+ *
+ * A mask rather than an overlaid gradient: an overlay has to be painted in the
+ * container's own background colour, which is a guess — put the component on a
+ * card, a muted panel or an image and the guess is visibly wrong. Removing
+ * pixels lets whatever is behind show through, so it is correct everywhere.
+ *
+ * Returns `undefined` when nothing should fade, so the element carries no
+ * `mask-image` at all rather than an identity one.
+ */
+export declare function scrollFadeMask(options: {
+    orientation: 'vertical' | 'horizontal';
+    size: string;
+    fadeStart: boolean;
+    fadeEnd: boolean;
+}): string | undefined;

package/dist/composables/scroll-fade.js

@@ -0,0 +1,36 @@
+import { onBeforeUnmount as e, ref as t, watch as n } from "vue";
+//#region src/composables/scroll-fade.ts
+function r(r, i) {
+	let a = t(!0), o = t(!0), s = t(!1), c, l, u;
+	function d() {
+		if (!u) return;
+		let e = i.value === "vertical", t = e ? u.scrollTop : Math.abs(u.scrollLeft), n = e ? u.clientHeight : u.clientWidth, r = e ? u.scrollHeight : u.scrollWidth;
+		s.value = r - n > 1, a.value = t <= 1, o.value = t + n >= r - 1;
+	}
+	function f() {
+		u?.removeEventListener("scroll", d), c?.disconnect(), l?.disconnect(), c = void 0, l = void 0, u = void 0;
+	}
+	return n(r, (e) => {
+		if (f(), u = e, u) {
+			if (d(), u.addEventListener("scroll", d, { passive: !0 }), typeof ResizeObserver < "u") {
+				c = new ResizeObserver(d), c.observe(u);
+				for (let e of u.children) c.observe(e);
+			}
+			typeof MutationObserver < "u" && (l = new MutationObserver(d), l.observe(u, {
+				childList: !0,
+				subtree: !0
+			}));
+		}
+	}, { immediate: !0 }), n(i, d), e(f), {
+		atStart: a,
+		atEnd: o,
+		overflowing: s,
+		measure: d
+	};
+}
+function i(e) {
+	let { orientation: t, size: n, fadeStart: r, fadeEnd: i } = e;
+	if (!(!r && !i)) return `linear-gradient(${t === "vertical" ? "to bottom" : "to right"}, ${[r ? `transparent 0, black ${n}` : "black 0", i ? `black calc(100% - ${n}), transparent 100%` : "black 100%"].join(", ")})`;
+}
+//#endregion
+export { i as scrollFadeMask, r as useScrollEdges };

package/dist/composables/sidebar.d.ts

@@ -0,0 +1,35 @@
+import type { IconLike } from './icon';
+export interface SidebarLink {
+    label: string;
+    /** Renders an `<a>`. Omit to render a `<button>` and handle `onSelect` yourself. */
+    href?: string;
+    icon?: IconLike;
+    /** Count or status at the trailing edge, e.g. an unread total. */
+    badge?: string | number;
+    disabled?: boolean;
+    /** Marks the current page. Reflected as `data-active` and `aria-current`. */
+    active?: boolean;
+    /** Handle navigation yourself, e.g. with a router. */
+    onSelect?: () => void;
+    /** Child links. Turns this entry into a collapsible group. */
+    items?: SidebarLink[];
+    /** Start the group open. Ignored without `items`. */
+    defaultOpen?: boolean;
+}
+/**
+ * A labelled run of links under a small heading.
+ *
+ * The heading lives under its own `section` key rather than `label`, because a
+ * collapsible group link carries `items` too — with one shared key the two
+ * would be told apart by guessing at which other fields are present, and an
+ * icon-less group would silently become a heading.
+ */
+export interface SidebarSection {
+    section: string;
+    items: SidebarLink[];
+}
+export type SidebarItems = (SidebarLink | SidebarSection)[];
+export declare function isSidebarSection(item: SidebarLink | SidebarSection): item is SidebarSection;
+/** Normalise to sections, so the template has a single path to render. */
+export declare function toSidebarSections(items: SidebarItems | undefined): SidebarSection[];
+export declare function isSidebarGroup(link: SidebarLink): boolean;

package/dist/composables/sidebar.js

@@ -0,0 +1,23 @@
+//#region src/composables/sidebar.ts
+function e(e) {
+	return typeof e.section == "string";
+}
+function t(t) {
+	let n = [], r;
+	for (let i of t ?? []) {
+		if (e(i)) {
+			n.push(i), r = void 0;
+			continue;
+		}
+		r || (r = [], n.push({
+			section: "",
+			items: r
+		})), r.push(i);
+	}
+	return n;
+}
+function n(e) {
+	return Array.isArray(e.items) && e.items.length > 0;
+}
+//#endregion
+export { n as isSidebarGroup, e as isSidebarSection, t as toSidebarSections };

package/dist/composables/signature.d.ts

@@ -0,0 +1,22 @@
+/** One sampled point of a stroke. `t` is what makes the width vary. */
+export interface SignaturePoint {
+    x: number;
+    y: number;
+    /** Milliseconds since the stroke began. */
+    t: number;
+    /** 0–1 where the hardware reports it; 0.5 is what a mouse sends. */
+    pressure: number;
+}
+/** A single continuous mark — one pen-down to pen-up. */
+export type SignatureStroke = SignaturePoint[];
+/**
+ * How wide the pen is between two points.
+ *
+ * A constant width reads as a traced outline rather than handwriting: real
+ * ink thins as the hand speeds up. Speed is measured in pixels per
+ * millisecond and mapped onto a shrinking multiplier, then blended with
+ * pressure where the hardware reports it.
+ */
+export declare function strokeWidth(base: number, from: SignaturePoint, to: SignaturePoint): number;
+/** Whether anything has actually been drawn. A stray tap is not a signature. */
+export declare function hasInk(strokes: SignatureStroke[]): boolean;

package/dist/composables/signature.js

@@ -0,0 +1,13 @@
+//#region src/composables/signature.ts
+function e(e, n, r) {
+	let i = t(1.2 - Math.hypot(r.x - n.x, r.y - n.y) / Math.max(r.t - n.t, 1) * .35, .4, 1.2), a = .7 + r.pressure * .6;
+	return e * i * a;
+}
+function t(e, t, n) {
+	return Math.min(Math.max(e, t), n);
+}
+function n(e) {
+	return e.some((e) => e.length > 1);
+}
+//#endregion
+export { n as hasInk, e as strokeWidth };