RubyGems - stimulus_plumbers - Versions diffs - 0.2.2 → 0.2.7 - Mend

stimulus_plumbers 0.2.2 → 0.2.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

checksums.yaml +4 -4
data/app/assets/javascripts/stimulus-plumbers/stimulus-plumbers-controllers.es.js +1142 -0
data/app/assets/javascripts/stimulus-plumbers/stimulus-plumbers-controllers.umd.js +1 -0
data/lib/stimulus_plumbers/version.rb +1 -1
metadata +5 -6

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1abfd2ca5a0c575652d0d6c650acbde79e656b9b806a76b8f922e682cf2f7526
-  data.tar.gz: 621aa551f6fb7b9f3a90c3313e4dedb6c901f475cb96f6631a9fc54edccf5bac
+  metadata.gz: c89886ba431e3857285faa6f16e80f5f54cb4b2bf9fb69582be6f8c1395ddd67
+  data.tar.gz: 66f92918cfcb2c729047555955b17570a94574bc7512d1ba65e68515e447163a
 SHA512:
-  metadata.gz: e45e2a0ea994b0e8d22edc2098974d6f15c43bb552a92dc7c5baf2dc0700b9a8f22ef570ffa913c0cae84d6bc64ecbe6b6e09613e4b73ccaccc1613d93d898d3
-  data.tar.gz: 1be1501a2b77cad35780730e84803bdb5506e6def24699c46cc1797196780aec94dfe7a451a0b4774b748258132a7b0eb3d6bae16c71c22bc7c733bf24c45f1c
+  metadata.gz: d1ae00ceb5a566aff19e6ac1cc81232fff4783dfe2729174b8ba19e578f90b324c09882101cd55bd380053f1f5498e05829d457b3aea1d52cb8cc31bb0fc6298
+  data.tar.gz: 0b8ce29fe76ee4bf93ba709ec1714c0cd191dab7352136123b807c03b1ba50d355d6475d88274694c2e05e17ef56255da6ea1eb09cafac4b4f014c759f290c6f

data/app/assets/javascripts/stimulus-plumbers/stimulus-plumbers-controllers.es.js ADDED Viewed

@@ -0,0 +1,1142 @@
+import { Controller as e } from "@hotwired/stimulus";
+//#region src/focus.js
+var t = [
+	"a[href]",
+	"area[href]",
+	"button:not([disabled])",
+	"input:not([disabled])",
+	"select:not([disabled])",
+	"textarea:not([disabled])",
+	"[tabindex]:not([tabindex=\"-1\"])",
+	"audio[controls]",
+	"video[controls]",
+	"[contenteditable]:not([contenteditable=\"false\"])"
+].join(",");
+function n(e) {
+	return Array.from(e.querySelectorAll(t)).filter((e) => r(e));
+}
+function r(e) {
+	return !!(e.offsetWidth || e.offsetHeight || e.getClientRects().length);
+}
+function i(e) {
+	let t = n(e);
+	return t.length > 0 ? (t[0].focus(), !0) : !1;
+}
+var a = class {
+	constructor(e, t = {}) {
+		this.container = e, this.previouslyFocused = null, this.options = t, this.isActive = !1;
+	}
+	activate() {
+		this.isActive || (this.previouslyFocused = document.activeElement, this.isActive = !0, this.options.initialFocus ? this.options.initialFocus.focus() : i(this.container), this.container.addEventListener("keydown", this.handleKeyDown));
+	}
+	deactivate() {
+		if (!this.isActive) return;
+		this.isActive = !1, this.container.removeEventListener("keydown", this.handleKeyDown);
+		let e = this.options.returnFocus || this.previouslyFocused;
+		e && r(e) && e.focus();
+	}
+	handleKeyDown = (e) => {
+		if (e.key === "Escape" && this.options.escapeDeactivates) {
+			e.preventDefault(), this.deactivate();
+			return;
+		}
+		if (e.key !== "Tab") return;
+		let t = n(this.container);
+		if (t.length === 0) return;
+		let r = t[0], i = t[t.length - 1];
+		e.shiftKey && document.activeElement === r ? (e.preventDefault(), i.focus()) : !e.shiftKey && document.activeElement === i && (e.preventDefault(), r.focus());
+	};
+}, o = class {
+	constructor() {
+		this.savedElement = null;
+	}
+	save() {
+		this.savedElement = document.activeElement;
+	}
+	restore() {
+		this.savedElement && r(this.savedElement) && (this.savedElement.focus(), this.savedElement = null);
+	}
+};
+//#endregion
+//#region src/keyboard.js
+function s(e, t) {
+	return e.key === t;
+}
+function c(e) {
+	return e.key === "Enter" || e.key === " ";
+}
+function l(e) {
+	return [
+		"ArrowUp",
+		"ArrowDown",
+		"ArrowLeft",
+		"ArrowRight"
+	].includes(e.key);
+}
+function u(e) {
+	e.preventDefault(), e.stopPropagation();
+}
+var d = class {
+	constructor(e, t = 0) {
+		this.items = e, this.currentIndex = t, this.updateTabIndex();
+	}
+	handleKeyDown(e) {
+		let t;
+		switch (e.key) {
+			case "ArrowDown":
+			case "ArrowRight":
+				e.preventDefault(), t = (this.currentIndex + 1) % this.items.length;
+				break;
+			case "ArrowUp":
+			case "ArrowLeft":
+				e.preventDefault(), t = this.currentIndex === 0 ? this.items.length - 1 : this.currentIndex - 1;
+				break;
+			case "Home":
+				e.preventDefault(), t = 0;
+				break;
+			case "End":
+				e.preventDefault(), t = this.items.length - 1;
+				break;
+			default: return;
+		}
+		this.setCurrentIndex(t);
+	}
+	setCurrentIndex(e) {
+		e >= 0 && e < this.items.length && (this.currentIndex = e, this.updateTabIndex(), this.items[e].focus());
+	}
+	updateTabIndex() {
+		this.items.forEach((e, t) => {
+			e.tabIndex = t === this.currentIndex ? 0 : -1;
+		});
+	}
+	updateItems(e) {
+		this.items = e, this.currentIndex = Math.min(this.currentIndex, e.length - 1), this.updateTabIndex();
+	}
+}, f = (e, t, n) => {
+	let r = document.querySelector(`[data-live-region="${e}"]`);
+	return r || (r = document.createElement("div"), r.className = "sr-only", r.dataset.liveRegion = e, r.setAttribute("aria-live", e), r.setAttribute("aria-atomic", t.toString()), r.setAttribute("aria-relevant", n), document.body.appendChild(r)), r;
+};
+function p(e, t = {}) {
+	let { politeness: n = "polite", atomic: r = !0, relevant: i = "additions text" } = t, a = f(n, r, i);
+	a.textContent = "", setTimeout(() => {
+		a.textContent = e;
+	}, 100);
+}
+var m = (e = "a11y") => `${e}-${Math.random().toString(36).substr(2, 9)}`, h = (e, t = "element") => e.id ||= m(t), g = (e, t, n) => {
+	e.setAttribute(t, n.toString());
+}, _ = (e, t) => g(e, "aria-expanded", t), v = (e, t) => g(e, "aria-pressed", t), y = (e, t) => g(e, "aria-checked", t);
+function ee(e, t) {
+	g(e, "aria-disabled", t), t ? e.setAttribute("tabindex", "-1") : e.removeAttribute("tabindex");
+}
+var b = {
+	menu: "menu",
+	listbox: "listbox",
+	tree: "tree",
+	grid: "grid",
+	dialog: "dialog"
+}, x = (e, t, n) => {
+	Object.entries(t).forEach(([t, r]) => {
+		e.setAttribute(t, r), n[t] = r;
+	});
+}, S = (e, t, n) => n || !e.hasAttribute(t);
+function C({ trigger: e, target: t, role: n = null, override: r = !1 }) {
+	let i = {
+		trigger: {},
+		target: {}
+	};
+	if (!e || !t) return i;
+	let a = {}, o = {};
+	if (n && S(t, "role", r) && (o.role = n), t.id && (S(e, "aria-controls", r) && (a["aria-controls"] = t.id), n === "tooltip" && S(e, "aria-describedby", r) && (a["aria-describedby"] = t.id)), n && S(e, "aria-haspopup", r)) {
+		let e = b[n] || "true";
+		e && (a["aria-haspopup"] = e);
+	}
+	return x(t, o, i.target), x(e, a, i.trigger), i;
+}
+var w = (e, t) => {
+	t.forEach((t) => {
+		e.hasAttribute(t) && e.removeAttribute(t);
+	});
+};
+function T({ trigger: e, target: t, attributes: n = null }) {
+	!e || !t || (w(e, n || [
+		"aria-controls",
+		"aria-haspopup",
+		"aria-describedby"
+	]), (!n || n.includes("role")) && w(t, ["role"]));
+}
+//#endregion
+//#region src/plumbers/plumber/support.js
+var E = {
+	get visibleOnly() {
+		return !0;
+	},
+	hiddenClass: null
+}, D = {
+	get top() {
+		return "bottom";
+	},
+	get bottom() {
+		return "top";
+	},
+	get left() {
+		return "right";
+	},
+	get right() {
+		return "left";
+	}
+};
+function O({ x: e, y: t, width: n, height: r }) {
+	return {
+		x: e,
+		y: t,
+		width: n,
+		height: r,
+		left: e,
+		right: e + n,
+		top: t,
+		bottom: t + r
+	};
+}
+function k() {
+	return O({
+		x: 0,
+		y: 0,
+		width: window.innerWidth || document.documentElement.clientWidth,
+		height: window.innerHeight || document.documentElement.clientHeight
+	});
+}
+function A(e) {
+	if (!(e instanceof HTMLElement)) return !1;
+	let t = k(), n = e.getBoundingClientRect(), r = n.top <= t.height && n.top + n.height > 0, i = n.left <= t.width && n.left + n.width > 0;
+	return r && i;
+}
+function j(e) {
+	return e instanceof Date && !isNaN(e);
+}
+function M(...e) {
+	if (e.length === 0) throw "Missing values to parse as date";
+	if (e.length === 1) {
+		let t = new Date(e[0]);
+		if (e[0] && j(t)) return t;
+	} else {
+		let t = new Date(...e);
+		if (j(t)) return t;
+	}
+}
+//#endregion
+//#region src/plumbers/plumber/index.js
+var N = {
+	element: null,
+	visible: null,
+	dispatch: !0,
+	prefix: ""
+}, P = class {
+	constructor(e, t = {}) {
+		this.controller = e;
+		let { element: n, visible: r, dispatch: i, prefix: a } = Object.assign({}, N, t);
+		this.element = n || e.element, this.visibleOnly = typeof r == "boolean" ? r : E.visibleOnly, this.visibleCallback = typeof r == "string" ? r : null, this.notify = !!i, this.prefix = typeof a == "string" && a ? a : e.identifier;
+	}
+	get visible() {
+		return this.element instanceof HTMLElement ? this.visibleOnly ? A(this.element) && this.isVisible(this.element) : !0 : !1;
+	}
+	isVisible(e) {
+		if (this.visibleCallback) {
+			let t = this.findCallback(this.visibleCallback);
+			if (typeof t == "function") return t(e);
+		}
+		return e instanceof HTMLElement ? !e.hasAttribute("hidden") : !1;
+	}
+	dispatch(e, { target: t = null, prefix: n = null, detail: r = null } = {}) {
+		if (this.notify) return this.controller.dispatch(e, {
+			target: t || this.element,
+			prefix: n || this.prefix,
+			detail: r
+		});
+	}
+	findCallback(e) {
+		if (typeof e != "string") return;
+		let t = this, n = e.split(".").reduce((e, t) => e && e[t], t.controller);
+		if (typeof n == "function") return n.bind(t.controller);
+		let r = e.split(".").reduce((e, t) => e && e[t], t);
+		if (typeof r == "function") return r.bind(t);
+	}
+	async awaitCallback(e, ...t) {
+		if (typeof e == "string" && (e = this.findCallback(e)), typeof e == "function") {
+			let n = e(...t);
+			return n instanceof Promise ? await n : n;
+		}
+	}
+}, F = 7, I = {
+	locales: ["default"],
+	today: "",
+	day: null,
+	month: null,
+	year: null,
+	since: null,
+	till: null,
+	disabledDates: [],
+	disabledWeekdays: [],
+	disabledDays: [],
+	disabledMonths: [],
+	disabledYears: [],
+	firstDayOfWeek: 0,
+	onNavigated: "navigated"
+}, L = class extends P {
+	constructor(e, t = {}) {
+		super(e, t);
+		let n = Object.assign({}, I, t), { onNavigated: r, since: i, till: a, firstDayOfWeek: o } = n;
+		this.onNavigated = r, this.since = M(i), this.till = M(a), this.firstDayOfWeek = 0 <= o && o < 7 ? o : I.firstDayOfWeek;
+		let { disabledDates: s, disabledWeekdays: c, disabledDays: l, disabledMonths: u, disabledYears: d } = n;
+		this.disabledDates = Array.isArray(s) ? s : [], this.disabledWeekdays = Array.isArray(c) ? c : [], this.disabledDays = Array.isArray(l) ? l : [], this.disabledMonths = Array.isArray(u) ? u : [], this.disabledYears = Array.isArray(d) ? d : [];
+		let { today: f, day: p, month: m, year: h } = n;
+		this.now = M(f) || /* @__PURE__ */ new Date(), typeof h == "number" && typeof m == "number" && typeof p == "number" ? this.current = M(h, m, p) : this.current = this.now, this.build(), this.enhance();
+	}
+	build() {
+		this.daysOfWeek = this.buildDaysOfWeek(), this.daysOfMonth = this.buildDaysOfMonth(), this.monthsOfYear = this.buildMonthsOfYear();
+	}
+	buildDaysOfWeek() {
+		let e = new Intl.DateTimeFormat(this.localesValue, { weekday: "long" }), t = new Intl.DateTimeFormat(this.localesValue, { weekday: "short" }), n = /* @__PURE__ */ new Date("2024-10-06"), r = [];
+		for (let i = this.firstDayOfWeek, a = i + 7; i < a; i++) {
+			let a = new Date(n);
+			a.setDate(n.getDate() + i), r.push({
+				date: a,
+				value: a.getDay(),
+				long: e.format(a),
+				short: t.format(a)
+			});
+		}
+		return r;
+	}
+	buildDaysOfMonth() {
+		let e = this.month, t = this.year, n = [], r = (e) => ({
+			current: this.month === e.getMonth() && this.year === e.getFullYear(),
+			date: e,
+			value: e.getDate(),
+			month: e.getMonth(),
+			year: e.getFullYear(),
+			iso: e.toISOString()
+		}), i = new Date(t, e).getDay(), a = this.firstDayOfWeek - i;
+		for (let i = a > 0 ? a - 7 : a; i < 0; i++) {
+			let a = new Date(t, e, i + 1);
+			n.push(r(a));
+		}
+		let o = new Date(t, e + 1, 0).getDate();
+		for (let i = 1; i <= o; i++) {
+			let a = new Date(t, e, i);
+			n.push(r(a));
+		}
+		let s = n.length % F, c = s === 0 ? 0 : F - s;
+		for (let i = 1; i <= c; i++) {
+			let a = new Date(t, e + 1, i);
+			n.push(r(a));
+		}
+		return n;
+	}
+	buildMonthsOfYear() {
+		let e = new Intl.DateTimeFormat(this.localesValue, { month: "long" }), t = new Intl.DateTimeFormat(this.localesValue, { month: "short" }), n = new Intl.DateTimeFormat(this.localesValue, { month: "numeric" }), r = [];
+		for (let i = 0; i < 12; i++) {
+			let a = new Date(this.year, i);
+			r.push({
+				date: a,
+				value: a.getMonth(),
+				long: e.format(a),
+				short: t.format(a),
+				numeric: n.format(a)
+			});
+		}
+		return r;
+	}
+	get today() {
+		return this.now;
+	}
+	set today(e) {
+		if (!j(e)) return;
+		let t = this.month ? this.month : e.getMonth(), n = this.year ? this.year : e.getFullYear(), r = t == e.getMonth() && n == e.getFullYear(), i = this.hasDayValue ? this.day : r ? e.getDate() : 1;
+		this.now = new Date(n, t, i).toISOString();
+	}
+	get current() {
+		return typeof this.year == "number" && typeof this.month == "number" && typeof this.day == "number" ? M(this.year, this.month, this.day) : null;
+	}
+	set current(e) {
+		j(e) && (this.day = e.getDate(), this.month = e.getMonth(), this.year = e.getFullYear());
+	}
+	navigate = async (e) => {
+		if (!j(e)) return;
+		let t = this.current, n = e.toISOString(), r = t.toISOString();
+		this.dispatch("navigate", { detail: {
+			from: r,
+			to: n
+		} }), this.current = e, this.build(), await this.awaitCallback(this.onNavigated, {
+			from: r,
+			to: n
+		}), this.dispatch("navigated", { detail: {
+			from: r,
+			to: n
+		} });
+	};
+	step = async (e, t) => {
+		if (t === 0) return;
+		let n = this.current;
+		switch (e) {
+			case "year":
+				n.setFullYear(n.getFullYear() + t);
+				break;
+			case "month":
+				n.setMonth(n.getMonth() + t);
+				break;
+			case "day":
+				n.setDate(n.getDate() + t);
+				break;
+			default: return;
+		}
+		await this.navigate(n);
+	};
+	isDisabled = (e) => {
+		if (!j(e)) return !1;
+		if (this.disabledDates.length) {
+			let t = e.getTime();
+			for (let e of this.disabledDates) if (t === new Date(e).getTime()) return !0;
+		}
+		if (this.disabledWeekdays.length) {
+			let t = e.getDay(), n = this.daysOfWeek, r = n.findIndex((e) => e.value === t);
+			if (r >= 0) {
+				let e = n[r];
+				for (let t of this.disabledWeekdays) if (e.value == t || e.short === t || e.long === t) return !0;
+			}
+		}
+		if (this.disabledDays.length) {
+			let t = e.getDate();
+			for (let e of this.disabledDays) if (t == e) return !0;
+		}
+		if (this.disabledMonths.length) {
+			let t = e.getMonth(), n = this.monthsOfYear, r = n.findIndex((e) => e.value === t);
+			if (r >= 0) {
+				let e = n[r];
+				for (let t of this.disabledMonths) if (e.value == t || e.short === t || e.long === t) return !0;
+			}
+		}
+		if (this.disabledYears.length) {
+			let t = e.getFullYear();
+			for (let e of this.disabledYears) if (t == e) return !0;
+		}
+		return !1;
+	};
+	isWithinRange = (e) => {
+		if (!j(e)) return !1;
+		let t = !0;
+		return this.since && (t &&= e >= this.since), this.till && (t &&= e <= this.till), t;
+	};
+	enhance() {
+		let e = this;
+		Object.assign(this.controller, { get calendar() {
+			return {
+				get today() {
+					return e.today;
+				},
+				get current() {
+					return e.current;
+				},
+				get day() {
+					return e.day;
+				},
+				get month() {
+					return e.month;
+				},
+				get year() {
+					return e.year;
+				},
+				get since() {
+					return e.since;
+				},
+				get till() {
+					return e.till;
+				},
+				get firstDayOfWeek() {
+					return e.firstDayOfWeek;
+				},
+				get disabledDates() {
+					return e.disabledDates;
+				},
+				get disabledWeekdays() {
+					return e.disabledWeekdays;
+				},
+				get disabledDays() {
+					return e.disabledDays;
+				},
+				get disabledMonths() {
+					return e.disabledMonths;
+				},
+				get disabledYears() {
+					return e.disabledYears;
+				},
+				get daysOfWeek() {
+					return e.daysOfWeek;
+				},
+				get daysOfMonth() {
+					return e.daysOfMonth;
+				},
+				get monthsOfYear() {
+					return e.monthsOfYear;
+				},
+				navigate: async (t) => await e.navigate(t),
+				step: async (t, n) => await e.step(t, n),
+				isDisabled: (t) => e.isDisabled(t),
+				isWithinRange: (t) => e.isWithinRange(t)
+			};
+		} });
+	}
+}, R = (e, t) => new L(e, t), z = {
+	content: null,
+	url: "",
+	reload: "never",
+	stale: 3600,
+	onLoad: "contentLoad",
+	onLoading: "contentLoading",
+	onLoaded: "contentLoaded"
+}, B = class extends P {
+	constructor(e, t = {}) {
+		super(e, t);
+		let n = Object.assign({}, z, t), { content: r, url: i, reload: a, stale: o } = n;
+		this.content = r, this.url = i, this.reload = typeof a == "string" ? a : z.reload, this.stale = typeof o == "number" ? o : z.stale;
+		let { onLoad: s, onLoading: c, onLoaded: l } = n;
+		this.onLoad = s, this.onLoading = c, this.onLoaded = l, this.enhance();
+	}
+	get reloadable() {
+		switch (this.reload) {
+			case "never": return !1;
+			case "always": return !0;
+			default: {
+				let e = M(this.loadedAt);
+				return e && /* @__PURE__ */ new Date() - e > this.stale * 1e3;
+			}
+		}
+	}
+	contentLoadable = ({ url: e }) => !!e;
+	contentLoading = async ({ url: e }) => e ? await this.remoteContentLoader(e) : await this.contentLoader();
+	contentLoader = async () => "";
+	remoteContentLoader = async (e) => (await fetch(e)).text();
+	load = async () => {
+		if (this.loadedAt && !this.reloadable) return;
+		let e = this.findCallback(this.onLoad), t = await this.awaitCallback(e || this.contentLoadable, { url: this.url });
+		if (this.dispatch("load", { detail: { url: this.url } }), !t) return;
+		let n = this.url ? await this.remoteContentLoader(this.url) : await this.contentLoader();
+		this.dispatch("loading", { detail: { url: this.url } }), n && (await this.awaitCallback(this.onLoaded, {
+			url: this.url,
+			content: n
+		}), this.loadedAt = (/* @__PURE__ */ new Date()).getTime(), this.dispatch("loaded", { detail: {
+			url: this.url,
+			content: n
+		} }));
+	};
+	enhance() {
+		let e = this;
+		Object.assign(this.controller, { load: e.load.bind(e) });
+	}
+}, V = (e, t) => new B(e, t), H = {
+	trigger: null,
+	events: ["click"],
+	onDismissed: "dismissed"
+}, U = class extends P {
+	constructor(e, t = {}) {
+		super(e, t);
+		let { trigger: n, events: r, onDismissed: i } = Object.assign({}, H, t);
+		this.onDismissed = i, this.trigger = n || this.element, this.events = r, this.enhance(), this.observe();
+	}
+	dismiss = async (e) => {
+		let { target: t } = e;
+		t instanceof HTMLElement && (this.element.contains(t) || this.visible && (this.dispatch("dismiss"), await this.awaitCallback(this.onDismissed, { target: this.trigger }), this.dispatch("dismissed")));
+	};
+	observe() {
+		this.events.forEach((e) => {
+			window.addEventListener(e, this.dismiss, !0);
+		});
+	}
+	unobserve() {
+		this.events.forEach((e) => {
+			window.removeEventListener(e, this.dismiss, !0);
+		});
+	}
+	enhance() {
+		let e = this, t = e.controller.disconnect.bind(e.controller);
+		Object.assign(this.controller, { disconnect: () => {
+			e.unobserve(), t();
+		} });
+	}
+}, W = (e, t) => new U(e, t), G = {
+	anchor: null,
+	events: ["click"],
+	placement: "bottom",
+	alignment: "start",
+	onFlipped: "flipped",
+	ariaRole: null,
+	respectMotion: !0
+}, K = class extends P {
+	constructor(e, t = {}) {
+		super(e, t);
+		let { anchor: n, events: r, placement: i, alignment: a, onFlipped: o, ariaRole: s, respectMotion: c } = Object.assign({}, G, t);
+		this.anchor = n, this.events = r, this.placement = i, this.alignment = a, this.onFlipped = o, this.ariaRole = s, this.respectMotion = c, this.prefersReducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches, this.anchor && this.element && C({
+			trigger: this.anchor,
+			target: this.element,
+			role: this.ariaRole
+		}), this.enhance(), this.observe();
+	}
+	flip = async () => {
+		if (!this.visible) return;
+		this.dispatch("flip"), window.getComputedStyle(this.element).position != "absolute" && (this.element.style.position = "absolute");
+		let e = this.flippedRect(this.anchor.getBoundingClientRect(), this.element.getBoundingClientRect());
+		this.element.style.transition = this.respectMotion && this.prefersReducedMotion ? "none" : "";
+		for (let [t, n] of Object.entries(e)) this.element.style[t] = n;
+		await this.awaitCallback(this.onFlipped, {
+			target: this.element,
+			placement: e
+		}), this.dispatch("flipped", { detail: { placement: e } });
+	};
+	flippedRect(e, t) {
+		let n = this.quadrumRect(e, k()), r = [this.placement, D[this.placement]], i = {};
+		for (; !Object.keys(i).length && r.length > 0;) {
+			let a = r.shift();
+			if (!this.biggerRectThan(n[a], t)) continue;
+			let o = this.quadrumPlacement(e, a, t), s = this.quadrumAlignment(e, a, o);
+			i.top = `${s.top + window.scrollY}px`, i.left = `${s.left + window.scrollX}px`;
+		}
+		return Object.keys(i).length || (i.top = "", i.left = ""), i;
+	}
+	quadrumRect(e, t) {
+		return {
+			left: O({
+				x: t.x,
+				y: t.y,
+				width: e.x - t.x,
+				height: t.height
+			}),
+			right: O({
+				x: e.x + e.width,
+				y: t.y,
+				width: t.width - (e.x + e.width),
+				height: t.height
+			}),
+			top: O({
+				x: t.x,
+				y: t.y,
+				width: t.width,
+				height: e.y - t.y
+			}),
+			bottom: O({
+				x: t.x,
+				y: e.y + e.height,
+				width: t.width,
+				height: t.height - (e.y + e.height)
+			})
+		};
+	}
+	quadrumPlacement(e, t, n) {
+		switch (t) {
+			case "top": return O({
+				x: n.x,
+				y: e.y - n.height,
+				width: n.width,
+				height: n.height
+			});
+			case "bottom": return O({
+				x: n.x,
+				y: e.y + e.height,
+				width: n.width,
+				height: n.height
+			});
+			case "left": return O({
+				x: e.x - n.width,
+				y: n.y,
+				width: n.width,
+				height: n.height
+			});
+			case "right": return O({
+				x: e.x + e.width,
+				y: n.y,
+				width: n.width,
+				height: n.height
+			});
+			default: throw `Unable place at the quadrum, ${t}`;
+		}
+	}
+	quadrumAlignment(e, t, n) {
+		switch (t) {
+			case "top":
+			case "bottom": {
+				let t = e.x;
+				return this.alignment === "center" ? t = e.x + e.width / 2 - n.width / 2 : this.alignment === "end" && (t = e.x + e.width - n.width), O({
+					x: t,
+					y: n.y,
+					width: n.width,
+					height: n.height
+				});
+			}
+			case "left":
+			case "right": {
+				let t = e.y;
+				return this.alignment === "center" ? t = e.y + e.height / 2 - n.height / 2 : this.alignment === "end" && (t = e.y + e.height - n.height), O({
+					x: n.x,
+					y: t,
+					width: n.width,
+					height: n.height
+				});
+			}
+			default: throw `Unable align at the quadrum, ${t}`;
+		}
+	}
+	biggerRectThan(e, t) {
+		return e.height >= t.height && e.width >= t.width;
+	}
+	observe() {
+		this.events.forEach((e) => {
+			window.addEventListener(e, this.flip, !0);
+		});
+	}
+	unobserve() {
+		this.events.forEach((e) => {
+			window.removeEventListener(e, this.flip, !0);
+		});
+	}
+	enhance() {
+		let e = this, t = e.controller.disconnect.bind(e.controller);
+		Object.assign(this.controller, {
+			disconnect: () => {
+				e.unobserve(), t();
+			},
+			flip: e.flip.bind(e)
+		});
+	}
+}, q = (e, t) => new K(e, t), J = {
+	events: ["resize"],
+	boundaries: [
+		"top",
+		"left",
+		"right"
+	],
+	onShifted: "shifted",
+	respectMotion: !0
+}, Y = class extends P {
+	constructor(e, t = {}) {
+		super(e, t);
+		let { onShifted: n, events: r, boundaries: i, respectMotion: a } = Object.assign({}, J, t);
+		this.onShifted = n, this.events = r, this.boundaries = i, this.respectMotion = a, this.prefersReducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches, this.enhance(), this.observe();
+	}
+	shift = async () => {
+		if (!this.visible) return;
+		this.dispatch("shift");
+		let e = this.overflowRect(this.element.getBoundingClientRect(), this.elementTranslations(this.element)), t = e.left || e.right || 0, n = e.top || e.bottom || 0;
+		this.element.style.transition = this.respectMotion && this.prefersReducedMotion ? "none" : "", this.element.style.transform = `translate(${t}px, ${n}px)`, await this.awaitCallback(this.onShifted, e), this.dispatch("shifted", { detail: e });
+	};
+	overflowRect(e, t) {
+		let n = {}, r = k(), i = O({
+			x: e.x - t.x,
+			y: e.y - t.y,
+			width: e.width,
+			height: e.height
+		});
+		for (let e of this.boundaries) {
+			let t = this.directionDistance(i, e, r), a = D[e];
+			t < 0 ? i[a] + t >= r[a] && !n[a] && (n[e] = t) : n[e] = "";
+		}
+		return n;
+	}
+	directionDistance(e, t, n) {
+		switch (t) {
+			case "top":
+			case "left": return e[t] - n[t];
+			case "bottom":
+			case "right": return n[t] - e[t];
+			default: throw `Invalid direction to calcuate distance, ${t}`;
+		}
+	}
+	elementTranslations(e) {
+		let t = window.getComputedStyle(e), n = t.transform || t.webkitTransform || t.mozTransform;
+		if (n === "none" || n === void 0) return {
+			x: 0,
+			y: 0
+		};
+		let r = n.includes("3d") ? "3d" : "2d", i = n.match(/matrix.*\((.+)\)/)[1].split(", ");
+		return r === "2d" ? {
+			x: Number(i[4]),
+			y: Number(i[5])
+		} : {
+			x: 0,
+			y: 0
+		};
+	}
+	observe() {
+		this.events.forEach((e) => {
+			window.addEventListener(e, this.shift, !0);
+		});
+	}
+	unobserve() {
+		this.events.forEach((e) => {
+			window.removeEventListener(e, this.shift, !0);
+		});
+	}
+	enhance() {
+		let e = this, t = e.controller.disconnect.bind(e.controller);
+		Object.assign(this.controller, {
+			disconnect: () => {
+				e.unobserve(), t();
+			},
+			shift: e.shift.bind(e)
+		});
+	}
+}, X = (e, t) => new Y(e, t), Z = {
+	visibility: "visibility",
+	onShown: "shown",
+	onHidden: "hidden"
+}, Q = class extends P {
+	constructor(e, t = {}) {
+		let { visibility: n, onShown: r, onHidden: i, activator: a } = Object.assign({}, Z, t), o = typeof n == "string" ? n : Z.namespace, s = typeof t.visible == "string" ? t.visible : "isVisible";
+		(typeof t.visible != "boolean" || t.visible) && (t.visible = `${o}.${s}`), super(e, t), this.visibility = o, this.visibilityResolver = s, this.onShown = r, this.onHidden = i, this.activator = a instanceof HTMLElement ? a : null, this.enhance(), this.element instanceof HTMLElement && this.activate(this.isVisible(this.element));
+	}
+	isVisible(e) {
+		if (!(e instanceof HTMLElement)) return !1;
+		let t = E.hiddenClass;
+		return t ? !e.classList.contains(t) : !e.hasAttribute("hidden");
+	}
+	toggle(e, t) {
+		if (!(e instanceof HTMLElement)) return;
+		let n = E.hiddenClass;
+		n ? t ? e.classList.remove(n) : e.classList.add(n) : t ? e.removeAttribute("hidden") : e.setAttribute("hidden", !0);
+	}
+	activate(e) {
+		this.activator && this.activator.setAttribute("aria-expanded", e ? "true" : "false");
+	}
+	async show() {
+		!(this.element instanceof HTMLElement) || this.isVisible(this.element) || (this.dispatch("show"), this.toggle(this.element, !0), this.activate(!0), await this.awaitCallback(this.onShown, { target: this.element }), this.dispatch("shown"));
+	}
+	async hide() {
+		!(this.element instanceof HTMLElement) || !this.isVisible(this.element) || (this.dispatch("hide"), this.toggle(this.element, !1), this.activate(!1), await this.awaitCallback(this.onHidden, { target: this.element }), this.dispatch("hidden"));
+	}
+	enhance() {
+		let e = this, t = {
+			show: e.show.bind(e),
+			hide: e.hide.bind(e)
+		};
+		Object.defineProperty(t, "visible", { get() {
+			return e.isVisible(e.element);
+		} }), Object.defineProperty(t, this.visibilityResolver, { value: e.isVisible.bind(e) }), Object.defineProperty(this.controller, this.visibility, { get() {
+			return t;
+		} });
+	}
+}, $ = (e, t) => new Q(e, t), te = class extends e {
+	static targets = ["modal", "overlay"];
+	connect() {
+		if (!this.hasModalTarget) {
+			console.error("ModalController requires a modal target. Add data-modal-target=\"modal\" to your element.");
+			return;
+		}
+		this.isNativeDialog = this.modalTarget instanceof HTMLDialogElement, this.isNativeDialog ? (this.modalTarget.addEventListener("cancel", this.close), this.modalTarget.addEventListener("click", this.handleBackdropClick)) : (this.focusTrap = new a(this.modalTarget, { escapeDeactivates: !0 }), W(this, { element: this.modalTarget }));
+	}
+	dismissed = () => {
+		this.close();
+	};
+	disconnect() {
+		this.isNativeDialog && (this.modalTarget.removeEventListener("cancel", this.close), this.modalTarget.removeEventListener("click", this.handleBackdropClick));
+	}
+	open(e) {
+		if (e && e.preventDefault(), this.hasModalTarget) {
+			if (this.isNativeDialog) this.previouslyFocused = document.activeElement, this.modalTarget.showModal();
+			else {
+				let e = this.hasOverlayTarget ? this.overlayTarget : this.modalTarget;
+				e.hidden = !1, document.body.style.overflow = "hidden", this.focusTrap && this.focusTrap.activate();
+			}
+			p("Modal opened");
+		}
+	}
+	close(e) {
+		if (e && e.preventDefault(), this.hasModalTarget) {
+			if (this.isNativeDialog) this.modalTarget.close(), this.previouslyFocused && this.previouslyFocused.isConnected && setTimeout(() => {
+				this.previouslyFocused.focus();
+			}, 0);
+			else {
+				let e = this.hasOverlayTarget ? this.overlayTarget : this.modalTarget;
+				e.hidden = !0, document.body.style.overflow = "", this.focusTrap && this.focusTrap.deactivate();
+			}
+			p("Modal closed");
+		}
+	}
+	handleBackdropClick = (e) => {
+		let t = this.modalTarget.getBoundingClientRect();
+		(e.clientY < t.top || e.clientY > t.bottom || e.clientX < t.left || e.clientX > t.right) && this.close();
+	};
+}, ne = class extends e {
+	static targets = ["trigger"];
+	connect() {
+		W(this, { trigger: this.hasTriggerTarget ? this.triggerTarget : null });
+	}
+}, re = class extends e {
+	static targets = ["anchor", "reference"];
+	static values = {
+		placement: {
+			type: String,
+			default: "bottom"
+		},
+		alignment: {
+			type: String,
+			default: "start"
+		},
+		role: {
+			type: String,
+			default: "tooltip"
+		}
+	};
+	connect() {
+		if (!this.hasReferenceTarget) {
+			console.error("FlipperController requires a reference target. Add data-flipper-target=\"reference\" to your element.");
+			return;
+		}
+		if (!this.hasAnchorTarget) {
+			console.error("FlipperController requires an anchor target. Add data-flipper-target=\"anchor\" to your element.");
+			return;
+		}
+		q(this, {
+			element: this.referenceTarget,
+			anchor: this.anchorTarget,
+			placement: this.placementValue,
+			alignment: this.alignmentValue,
+			ariaRole: this.roleValue
+		});
+	}
+}, ie = class extends e {
+	static targets = [
+		"content",
+		"template",
+		"loader",
+		"activator"
+	];
+	static classes = ["hidden"];
+	static values = {
+		url: String,
+		loadedAt: String,
+		reload: {
+			type: String,
+			default: "never"
+		},
+		staleAfter: {
+			type: Number,
+			default: 3600
+		}
+	};
+	connect() {
+		V(this, {
+			element: this.hasContentTarget ? this.contentTarget : null,
+			url: this.hasUrlValue ? this.urlValue : null
+		}), this.hasContentTarget && $(this, {
+			element: this.contentTarget,
+			activator: this.hasActivatorTarget ? this.activatorTarget : null
+		}), this.hasLoaderTarget && $(this, {
+			element: this.loaderTarget,
+			visibility: "contentLoaderVisibility"
+		});
+	}
+	async show() {
+		await this.visibility.show();
+	}
+	async hide() {
+		await this.visibility.hide();
+	}
+	async shown() {
+		await this.load();
+	}
+	contentLoad() {
+		return this.hasContentTarget && this.contentTarget.tagName.toLowerCase() === "turbo-frame" ? (this.hasUrlValue && this.contentTarget.setAttribute("src", this.urlValue), !1) : !0;
+	}
+	async contentLoading() {
+		this.hasLoaderTarget && await this.contentLoaderVisibility.show();
+	}
+	async contentLoaded({ content: e }) {
+		this.hasContentTarget && this.contentTarget.replaceChildren(this.getContentNode(e)), this.hasLoaderTarget && await this.contentLoaderVisibility.hide();
+	}
+	getContentNode(e) {
+		if (typeof e == "string") {
+			let t = document.createElement("template");
+			return t.innerHTML = e, document.importNode(t.content, !0);
+		}
+		return document.importNode(e, !0);
+	}
+	contentLoader() {
+		if (this.hasTemplateTarget) return this.templateTarget instanceof HTMLTemplateElement ? this.templateTarget.content : this.templateTarget.innerHTML;
+	}
+}, ae = class extends e {
+	static targets = ["daysOfWeek", "daysOfMonth"];
+	static classes = ["dayOfWeek", "dayOfMonth"];
+	static values = {
+		locales: {
+			type: Array,
+			default: ["default"]
+		},
+		weekdayFormat: {
+			type: String,
+			default: "short"
+		},
+		dayFormat: {
+			type: String,
+			default: "numeric"
+		},
+		daysOfOtherMonth: {
+			type: Boolean,
+			default: !1
+		}
+	};
+	initialize() {
+		R(this);
+	}
+	connect() {
+		this.draw();
+	}
+	navigated() {
+		this.draw();
+	}
+	draw() {
+		this.drawDaysOfWeek(), this.drawDaysOfMonth();
+	}
+	createDayElement(e, { selectable: t = !1, disabled: n = !1 } = {}) {
+		let r = document.createElement(t ? "button" : "div");
+		return r.tabIndex = -1, e ? r.textContent = e : r.setAttribute("aria-hidden", "true"), n && (r instanceof HTMLButtonElement ? r.disabled = !0 : r.setAttribute("aria-disabled", "true")), r;
+	}
+	drawDaysOfWeek() {
+		if (!this.hasDaysOfWeekTarget) return;
+		let e = new Intl.DateTimeFormat(this.localesValue, { weekday: this.weekdayFormatValue }), t = [];
+		for (let n of this.calendar.daysOfWeek) {
+			let r = this.createDayElement(e.format(n.date));
+			r.setAttribute("role", "columnheader"), r.title = n.long, this.hasDayOfWeekClass && r.classList.add(...this.dayOfWeekClasses), t.push(r);
+		}
+		let n = document.createElement("div");
+		n.setAttribute("role", "row"), n.replaceChildren(...t), this.daysOfWeekTarget.replaceChildren(n);
+	}
+	drawDaysOfMonth() {
+		if (!this.hasDaysOfMonthTarget) return;
+		let e = this.calendar.today, t = new Date(e.getFullYear(), e.getMonth(), e.getDate()).getTime(), n = [];
+		for (let e of this.calendar.daysOfMonth) {
+			let r = !e.current || this.calendar.isDisabled(e.date) || !this.calendar.isWithinRange(e.date), i = e.current || this.daysOfOtherMonthValue ? e.value : "", a = this.createDayElement(i, {
+				selectable: e.current,
+				disabled: r
+			});
+			t === e.date.getTime() && a.setAttribute("aria-current", "date"), this.hasDayOfMonthClass && a.classList.add(...this.dayOfMonthClasses);
+			let o = document.createElement("time");
+			o.dateTime = e.iso, a.appendChild(o), n.push(a);
+		}
+		let r = [];
+		for (let e = 0; e < n.length; e += 7) {
+			let t = document.createElement("div");
+			t.setAttribute("role", "row");
+			for (let r of n.slice(e, e + 7)) r.setAttribute("role", "gridcell"), t.appendChild(r);
+			r.push(t);
+		}
+		this.daysOfMonthTarget.replaceChildren(...r);
+	}
+}, oe = class extends e {
+	select(e) {
+		if (!(e.target instanceof HTMLElement)) return;
+		e.preventDefault();
+		let t = e.target instanceof HTMLTimeElement ? e.target.parentElement : e.target;
+		if (t.disabled || t.getAttribute("aria-disabled") === "true") return;
+		this.dispatch("select", { target: t });
+		let n = e.target instanceof HTMLTimeElement ? e.target : e.target.querySelector("time");
+		if (!n) return console.error(`unable to locate time element within ${t}`);
+		let r = M(n.dateTime);
+		if (!r) return console.error(`unable to parse ${n.dateTime} found within the time element`);
+		this.dispatch("selected", {
+			target: t,
+			detail: {
+				epoch: r.getTime(),
+				iso: r.toISOString()
+			}
+		});
+	}
+}, se = class extends e {
+	static targets = [
+		"previous",
+		"next",
+		"day",
+		"month",
+		"year",
+		"input",
+		"display"
+	];
+	static outlets = ["calendar-month"];
+	static values = {
+		locales: {
+			type: Array,
+			default: ["default"]
+		},
+		dayFormat: {
+			type: String,
+			default: "numeric"
+		},
+		monthFormat: {
+			type: String,
+			default: "long"
+		},
+		yearFormat: {
+			type: String,
+			default: "numeric"
+		}
+	};
+	initialize() {
+		this.previous = this.previous.bind(this), this.next = this.next.bind(this);
+	}
+	async calendarMonthOutletConnected() {
+		if (this.hasInputTarget && this.inputTarget.value) {
+			let e = M(this.inputTarget.value);
+			e && await this.calendarMonthOutlet.calendar.navigate(e);
+		}
+		this.draw();
+	}
+	selected(e) {
+		this.hasInputTarget && (this.inputTarget.value = e.detail.iso), this.hasDisplayTarget && (this.displayTarget.value = this.formatDate(new Date(e.detail.iso)));
+	}
+	formatDate(e) {
+		return new Intl.DateTimeFormat(this.localesValue, {
+			day: this.dayFormatValue,
+			month: this.monthFormatValue,
+			year: this.yearFormatValue
+		}).format(e);
+	}
+	previousTargetConnected(e) {
+		e.addEventListener("click", this.previous);
+	}
+	previousTargetDisconnected(e) {
+		e.removeEventListener("click", this.previous);
+	}
+	async previous() {
+		await this.calendarMonthOutlet.calendar.step("month", -1), this.draw();
+	}
+	nextTargetConnected(e) {
+		e.addEventListener("click", this.next);
+	}
+	nextTargetDisconnected(e) {
+		e.removeEventListener("click", this.next);
+	}
+	async next() {
+		await this.calendarMonthOutlet.calendar.step("month", 1), this.draw();
+	}
+	draw() {
+		this.drawDay(), this.drawMonth(), this.drawYear();
+	}
+	drawDay() {
+		if (!this.hasDayTarget || !this.hasCalendarMonthOutlet) return;
+		let { year: e, month: t, day: n } = this.calendarMonthOutlet.calendar, r = new Intl.DateTimeFormat(this.localesValue, { day: this.dayFormatValue });
+		this.dayTarget.textContent = r.format(new Date(e, t, n));
+	}
+	drawMonth() {
+		if (!this.hasMonthTarget || !this.hasCalendarMonthOutlet) return;
+		let { year: e, month: t } = this.calendarMonthOutlet.calendar, n = new Intl.DateTimeFormat(this.localesValue, { month: this.monthFormatValue });
+		this.monthTarget.textContent = n.format(new Date(e, t));
+	}
+	drawYear() {
+		if (!this.hasYearTarget || !this.hasCalendarMonthOutlet) return;
+		let { year: e } = this.calendarMonthOutlet.calendar, t = new Intl.DateTimeFormat(this.localesValue, { year: this.yearFormatValue });
+		this.yearTarget.textContent = t.format(new Date(e, 0));
+	}
+}, ce = class extends e {
+	static targets = ["content"];
+	connect() {
+		X(this, { element: this.hasContentTarget ? this.contentTarget : null });
+	}
+};
+//#endregion
+export { b as ARIA_HASPOPUP_VALUES, ae as CalendarMonthController, oe as CalendarMonthObserverController, se as DatepickerController, ne as DismisserController, t as FOCUSABLE_SELECTOR, re as FlipperController, o as FocusRestoration, a as FocusTrap, te as ModalController, ce as PannerController, ie as PopoverController, d as RovingTabIndex, p as announce, C as connectTriggerToTarget, T as disconnectTriggerFromTarget, h as ensureId, i as focusFirst, m as generateId, n as getFocusableElements, c as isActivationKey, l as isArrowKey, s as isKey, r as isVisible, u as preventDefault, g as setAriaState, y as setChecked, ee as setDisabled, _ as setExpanded, v as setPressed };

data/app/assets/javascripts/stimulus-plumbers/stimulus-plumbers-controllers.umd.js ADDED Viewed

@@ -0,0 +1 @@

data/lib/stimulus_plumbers/version.rb CHANGED Viewed

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module StimulusPlumbers
-  VERSION = "0.2.2"
+  VERSION = "0.2.7"
 end

metadata CHANGED Viewed

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: stimulus_plumbers
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.7
 platform: ruby
 authors:
 - Ryan Chang
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -40,6 +39,8 @@ extra_rdoc_files: []
 files:
 - README.md
 - app/assets/javascripts/stimulus-plumbers/.keep
+- app/assets/javascripts/stimulus-plumbers/stimulus-plumbers-controllers.es.js
+- app/assets/javascripts/stimulus-plumbers/stimulus-plumbers-controllers.umd.js
 - app/assets/stylesheets/stimulus_plumbers/tokens.css
 - lib/stimulus_plumbers.rb
 - lib/stimulus_plumbers/components/action_list/renderer.rb
@@ -107,7 +108,6 @@ metadata:
   changelog_uri: https://github.com/ryancyq/stimulus-plumbers/blob/main/CHANGELOG.md
   homepage_uri: https://github.com/ryancyq/stimulus-plumbers
   source_code_uri: https://github.com/ryancyq/stimulus-plumbers/tree/main/stimulus-plumbers-rails
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -122,8 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.2.0
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Accessible ActionView components for Rails with Stimulus controllers
 test_files: []