@rebilly/revel 13.6.2 → 13.6.3

package/dist/components/r-checkbox/r-checkbox.vue_vue_type_script_setup_true_lang.mjs

@@ -0,0 +1,77 @@
+import e from "../r-icon/r-icon.vue.mjs";
+import { nanoid as t } from "../../vendor/nanoid/non-secure/index.mjs";
+import { useValidate as n } from "../../composables/use-validate.mjs";
+import { computed as r, createCommentVNode as i, createElementBlock as a, createElementVNode as o, createTextVNode as s, createVNode as c, defineComponent as l, normalizeClass as u, openBlock as d, renderSlot as f, toDisplayString as p, unref as m } from "vue";
+//#region src/components/r-checkbox/r-checkbox.vue?vue&type=script&setup=true&lang.ts
+var h = ["aria-checked"], g = ["for"], _ = [
+	"id",
+	"disabled",
+	"value",
+	"checked"
+], v = { class: "r-field-checkbox-style" }, y = ["innerHTML"], b = /*@__PURE__*/ l({
+	__name: "r-checkbox",
+	props: {
+		label: { default: "" },
+		id: { default: () => t() },
+		caption: { default: void 0 },
+		modelValue: {
+			type: [
+				String,
+				Number,
+				Boolean,
+				Array
+			],
+			default: !1
+		},
+		value: {
+			type: [String, Boolean],
+			default: "on"
+		},
+		fuzzy: {
+			type: Boolean,
+			default: !1
+		},
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		validate: { default: null }
+	},
+	emits: ["update:modelValue"],
+	setup(t, { emit: l }) {
+		let b = t, x = l, { isInvalid: S } = n(() => b.validate), C = r(() => b.fuzzy ? !0 : b.modelValue === null ? !1 : Array.isArray(b.modelValue) ? b.modelValue.includes(b.value.toString()) : b.modelValue === b.value), w = r(() => b.fuzzy ? "dash-l" : "check-s"), T = () => {
+			if (!Array.isArray(b.modelValue)) return !C.value;
+			let e = b.modelValue.slice();
+			return Array.isArray(e) ? (C.value ? e.splice(b.modelValue.indexOf(b.value.toString()), 1) : e.push(b.value.toString()), e) : !C.value;
+		}, E = () => {
+			x("update:modelValue", T());
+		};
+		return (n, r) => (d(), a("div", {
+			class: u(["r-checkbox", { "r-is-error": m(S) }]),
+			role: "checkbox",
+			"aria-checked": C.value
+		}, [
+			o("label", {
+				class: u(["r-field-label r-field-label-toggle", { "r-is-disabled": t.disabled }]),
+				for: t.id
+			}, [f(n.$slots, "label", {}, () => [s(p(t.label), 1)])], 10, g),
+			o("input", {
+				id: t.id,
+				type: "checkbox",
+				class: "r-field-checkbox",
+				disabled: t.disabled,
+				value: t.value,
+				checked: C.value,
+				onChange: E
+			}, null, 40, _),
+			o("span", v, [c(e, { icon: w.value }, null, 8, ["icon"])]),
+			t.caption ? (d(), a("span", {
+				key: 0,
+				class: "r-field-caption r-field-caption-toggle",
+				innerHTML: t.caption
+			}, null, 8, y)) : i("", !0)
+		], 10, h));
+	}
+});
+//#endregion
+export { b as default };

package/dist/components/r-date-input/calendar-presets.mjs

@@ -0,0 +1,85 @@
+import e from "moment";
+//#region src/components/r-date-input/calendar-presets.ts
+var t = {
+	today: "today",
+	yesterday: "yesterday",
+	thisWeek: "thisWeek",
+	lastWeek: "lastWeek",
+	last30Days: "last30Days",
+	thisMonth: "thisMonth",
+	lastMonth: "lastMonth",
+	last3Months: "last3Months",
+	last6Months: "last6Months",
+	thisYear: "thisYear",
+	lastYear: "lastYear"
+}, n = [t.today, t.yesterday], r = {
+	[t.today]: "Today",
+	[t.yesterday]: "Yesterday",
+	[t.thisWeek]: "This week",
+	[t.lastWeek]: "Last week",
+	[t.last30Days]: "Last 30 days",
+	[t.thisMonth]: "This month",
+	[t.lastMonth]: "Last month",
+	[t.last3Months]: "Last 3 months",
+	[t.last6Months]: "Last 6 months",
+	[t.thisYear]: "This year",
+	[t.lastYear]: "Last year"
+}, i = (n = "UTC") => ({
+	[t.today]: {
+		relativeFilterValue: "today..tomorrow",
+		start: e().tz(n).startOf("day"),
+		end: e().tz(n).endOf("day")
+	},
+	[t.yesterday]: {
+		relativeFilterValue: "yesterday..midnight",
+		start: e().tz(n).subtract(1, "day").startOf("day"),
+		end: e().tz(n).subtract(1, "day").endOf("day")
+	},
+	[t.thisWeek]: {
+		relativeFilterValue: "start of this week midnight..now",
+		start: e().tz(n).startOf("week"),
+		end: e().tz(n).endOf("day")
+	},
+	[t.lastWeek]: {
+		relativeFilterValue: "start of last week midnight..end of last week",
+		start: e().tz(n).subtract(1, "week").startOf("week"),
+		end: e().tz(n).subtract(1, "week").endOf("week")
+	},
+	[t.last30Days]: {
+		relativeFilterValue: "30 days ago midnight..now",
+		start: e().tz(n).startOf("day").subtract(29, "days"),
+		end: e().tz(n).endOf("day")
+	},
+	[t.thisMonth]: {
+		relativeFilterValue: "first day of this month midnight..now",
+		start: e().tz(n).startOf("month"),
+		end: e().tz(n).endOf("day")
+	},
+	[t.lastMonth]: {
+		relativeFilterValue: "first day of last month midnight..last day of last month 23:59:59",
+		start: e().tz(n).subtract(1, "month").startOf("month"),
+		end: e().tz(n).subtract(1, "month").endOf("month")
+	},
+	[t.last3Months]: {
+		relativeFilterValue: "first day of 3 month ago midnight..now",
+		start: e().tz(n).subtract(3, "month").startOf("month"),
+		end: e().tz(n).subtract(1, "month").endOf("month")
+	},
+	[t.last6Months]: {
+		relativeFilterValue: "first day of 6 month ago midnight..now",
+		start: e().tz(n).subtract(6, "month").startOf("month"),
+		end: e().tz(n).subtract(1, "month").endOf("month")
+	},
+	[t.thisYear]: {
+		relativeFilterValue: "first day of January midnight..now 23:59:59",
+		start: e().tz(n).startOf("year"),
+		end: e().tz(n).endOf("day")
+	},
+	[t.lastYear]: {
+		relativeFilterValue: "first day of January last year midnight..last day of December last year 23:59:59",
+		start: e().tz(n).subtract(1, "year").startOf("year"),
+		end: e().tz(n).subtract(1, "year").endOf("year")
+	}
+});
+//#endregion
+export { t as calendarPresets, r as calendarPresetsLabels, i as getCalendarPresetPeriods, n as oneValuePresetsList };

package/dist/components/r-date-input/r-calendar.vue.mjs

@@ -0,0 +1,5 @@
+import e from "./r-calendar.vue_vue_type_script_setup_true_lang.mjs";
+//#region src/components/r-date-input/r-calendar.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/components/r-date-input/r-calendar.vue_vue_type_script_setup_true_lang.mjs

@@ -0,0 +1,108 @@
+import { DatePicker as e } from "../../vendor/@angelblanco/v-calendar/dist/es/index.mjs";
+/* empty css                                                   */
+import { getComputedPopoverConfigs as t, themeStyles as n } from "./shared-calendar-options.mjs";
+import { computed as r, createBlock as i, createCommentVNode as a, createElementBlock as o, createElementVNode as s, createSlots as c, createTextVNode as l, createVNode as u, defineComponent as d, mergeProps as f, openBlock as p, ref as m, resolveComponent as h, unref as g, useAttrs as _, withCtx as v } from "vue";
+//#region src/components/r-date-input/r-calendar.vue?vue&type=script&setup=true&lang.ts
+var y = { class: "calendar" }, b = { class: "r-ml-3 r-mr-3 r-mb-3" }, x = /*@__PURE__*/ d({
+	__name: "r-calendar",
+	props: {
+		modelValue: { default: "" },
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		timezone: { default: "UTC" },
+		type: { default: "" },
+		modelConfig: { default: void 0 },
+		masks: { default: () => ({}) },
+		allowEmpty: { type: Boolean },
+		hideSelectToday: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	emits: ["update:modelValue"],
+	setup(d, { emit: x }) {
+		let S = d, C = x, w = _(), T = m(null), E = r(() => S.type === "datetime" ? S.modelConfig : {
+			type: "object",
+			mask: "YYYY-MM-DD",
+			...S.modelConfig
+		}), D = (e) => {
+			e ? C("update:modelValue", e) : S.allowEmpty && C("update:modelValue", null);
+		}, O = (e) => {
+			let t = new Date(e);
+			return t instanceof Date && !isNaN(t.getTime());
+		}, k = () => {
+			if ((S.type === "datetime" || S.type === "time") && (!S.modelValue || !O(S.modelValue))) return C("update:modelValue", /* @__PURE__ */ new Date());
+		}, A = t({ attrs: w }), j = () => {
+			C("update:modelValue", /* @__PURE__ */ new Date()), T.value && S.type === "date" && T.value.hidePopover();
+		};
+		return (t, r) => {
+			let m = h("r-button"), _ = h("r-input");
+			return p(), o("div", y, [u(g(e), f({
+				ref_key: "datepicker",
+				ref: T
+			}, t.$attrs, {
+				mode: d.type,
+				"popover-visibility": "focus",
+				"popover-content-offset": 4,
+				popover: g(A),
+				color: "blue",
+				"theme-styles": g(n),
+				timezone: d.timezone,
+				"model-config": E.value,
+				"model-value": d.modelValue,
+				masks: d.masks,
+				"onUpdate:modelValue": D
+			}), c({
+				default: v(({ inputValue: e, inputEvents: n }) => [u(_, {
+					name: t.$attrs.name,
+					value: e,
+					"input-events": n,
+					disabled: d.disabled,
+					placeholder: t.$attrs.placeholder,
+					"right-icon": !d.allowEmpty || !d.modelValue ? "calendar" : !1,
+					onFocus: k,
+					onRightIconClick: n.click
+				}, {
+					"right-button": v(() => [d.modelValue && d.allowEmpty ? (p(), i(m, {
+						key: 0,
+						icon: "trash",
+						class: "r-flex-none",
+						onClick: r[0] ||= (e) => D(null)
+					})) : a("", !0)]),
+					_: 1
+				}, 8, [
+					"name",
+					"value",
+					"input-events",
+					"disabled",
+					"placeholder",
+					"right-icon",
+					"onRightIconClick"
+				])]),
+				_: 2
+			}, [d.hideSelectToday ? void 0 : {
+				name: "footer",
+				fn: v(() => [s("div", b, [u(m, {
+					fluid: "",
+					onClick: j
+				}, {
+					default: v(() => [...r[1] ||= [l("Today", -1)]]),
+					_: 1
+				})])]),
+				key: "0"
+			}]), 1040, [
+				"mode",
+				"popover",
+				"theme-styles",
+				"timezone",
+				"model-config",
+				"model-value",
+				"masks"
+			])]);
+		};
+	}
+});
+//#endregion
+export { x as default };

package/dist/components/r-date-input/r-date-input.vue.mjs

@@ -0,0 +1,6 @@
+import e from "./r-date-input.vue_vue_type_script_setup_true_lang.mjs";
+/* empty css                                                             */
+//#region src/components/r-date-input/r-date-input.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/components/r-date-input/r-date-input.vue_vue_type_script_setup_true_lang.mjs

@@ -0,0 +1,136 @@
+import { nanoid as e } from "../../vendor/nanoid/non-secure/index.mjs";
+import { useValidate as t } from "../../composables/use-validate.mjs";
+import n from "./r-calendar.vue.mjs";
+import r from "./r-range-calendar.vue.mjs";
+import i from "../r-input-errors/r-input-errors.vue.mjs";
+import a from "../r-field-label/r-field-label.vue.mjs";
+import { computed as o, createBlock as s, createCommentVNode as c, createElementBlock as l, createTextVNode as u, createVNode as d, defineComponent as f, mergeProps as p, normalizeClass as m, openBlock as h, toDisplayString as g, unref as _, withCtx as v } from "vue";
+import y from "moment";
+//#region src/components/r-date-input/r-date-input.vue?vue&type=script&setup=true&lang.ts
+var b = {
+	key: 3,
+	class: "r-field-caption"
+}, x = /*@__PURE__*/ f({
+	__name: "r-date-input",
+	props: {
+		label: { default: "" },
+		required: {
+			type: Boolean,
+			default: !1
+		},
+		optional: {
+			type: Boolean,
+			default: !1
+		},
+		id: { default: () => e() },
+		caption: { default: void 0 },
+		modelValue: { default: () => /* @__PURE__ */ new Date() },
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		validate: { default: null },
+		showValidateMessages: {
+			type: Boolean,
+			default: !1
+		},
+		timezone: { default: "UTC" },
+		availableDates: { default: void 0 },
+		columns: { default: 1 },
+		timePicker: {
+			type: Boolean,
+			default: !1
+		},
+		placeholder: { default: "" },
+		minDate: { default: void 0 },
+		maxDate: { default: void 0 },
+		type: { default: "date" },
+		is24hr: {
+			type: Boolean,
+			default: !1
+		},
+		hideTimeHeader: {
+			type: Boolean,
+			default: !1
+		},
+		placement: { default: "bottom" },
+		locale: { default: void 0 },
+		masks: { default: () => ({}) },
+		allowEmpty: { type: Boolean },
+		hideSelectToday: {
+			type: Boolean,
+			default: !1
+		},
+		rules: { default: void 0 },
+		timeAccuracy: { default: void 0 }
+	},
+	emits: ["update:modelValue"],
+	setup(e, { emit: f }) {
+		let x = e, S = f, { isInvalid: C } = t(() => x.validate), w = o(() => x.type === "range"), T = o(() => {
+			let e = {
+				name: x.id,
+				minDate: x.minDate,
+				maxDate: x.maxDate,
+				columns: x.columns,
+				placement: x.placement,
+				timePicker: x.timePicker,
+				timezone: x.timezone,
+				is24hr: x.is24hr,
+				hideTimeHeader: x.hideTimeHeader,
+				dates: x.availableDates,
+				placeholder: x.placeholder,
+				popoverVisibility: "focus",
+				disabled: x.disabled,
+				locale: void 0
+			};
+			return x.locale && (e.locale = x.locale), e;
+		}), E = o(() => x.type === "datetime" && !x.modelValue ? { timeAdjust: "00:00:00" } : {}), D = (e) => {
+			S("update:modelValue", e);
+		};
+		return y.isMoment(x.modelValue) && (console.log(`You are passing a moment instance (${x.modelValue.toISOString()}) to r-date-input. It is recommended to pass a native Date instance instead (and using timezone property for dealing with timezones)`), S("update:modelValue", x.modelValue.toDate())), (t, o) => (h(), l("div", { class: m(["r-field", { "r-is-error": _(C) }]) }, [
+			e.label ? (h(), s(a, {
+				key: 0,
+				for: e.id,
+				required: e.required,
+				optional: e.optional
+			}, {
+				default: v(() => [u(g(e.label), 1)]),
+				_: 1
+			}, 8, [
+				"for",
+				"required",
+				"optional"
+			])) : c("", !0),
+			w.value ? (h(), s(r, p({
+				key: 1,
+				"model-value": e.modelValue
+			}, T.value, { "onUpdate:modelValue": D }), null, 16, ["model-value"])) : (h(), s(n, p({ key: 2 }, T.value, {
+				"model-value": e.modelValue,
+				"model-config": E.value,
+				type: e.type,
+				masks: e.masks,
+				"allow-empty": e.allowEmpty,
+				"hide-select-today": e.hideSelectToday,
+				rules: e.rules,
+				"time-accuracy": e.timeAccuracy,
+				"onUpdate:modelValue": D
+			}), null, 16, [
+				"model-value",
+				"model-config",
+				"type",
+				"masks",
+				"allow-empty",
+				"hide-select-today",
+				"rules",
+				"time-accuracy"
+			])),
+			e.caption ? (h(), l("span", b, g(e.caption), 1)) : c("", !0),
+			d(i, {
+				validate: e.validate,
+				"show-validate-messages": e.showValidateMessages
+			}, null, 8, ["validate", "show-validate-messages"])
+		], 2));
+	}
+});
+//#endregion
+export { x as default };

package/dist/components/r-date-input/r-date-range-button-group.vue.mjs

@@ -0,0 +1,6 @@
+import e from "./r-date-range-button-group.vue_vue_type_script_setup_true_lang.mjs";
+/* empty css                                                                          */
+//#region src/components/r-date-input/r-date-range-button-group.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/components/r-date-input/r-date-range-button-group.vue_vue_type_script_setup_true_lang.mjs

@@ -0,0 +1,159 @@
+import { isMobile as e } from "../../common/helpers/is-mobile.mjs";
+import { DateTimeFormats as t } from "../../common/datetime-formats.mjs";
+import { formatDate as n } from "../../common/helpers/format-date.mjs";
+import { calendarPresets as r, calendarPresetsLabels as i, getCalendarPresetPeriods as a, oneValuePresetsList as o } from "./calendar-presets.mjs";
+import { Fragment as s, computed as c, createBlock as l, createCommentVNode as u, createElementBlock as d, createElementVNode as f, createVNode as p, defineComponent as m, nextTick as h, normalizeClass as g, openBlock as _, ref as v, renderList as y, resolveComponent as b, toDisplayString as x, withCtx as S } from "vue";
+import C from "moment";
+//#region src/components/r-date-input/r-date-range-button-group.vue?vue&type=script&setup=true&lang.ts
+var w = {
+	key: 0,
+	class: "r-date-range-label"
+}, T = {
+	key: 1,
+	class: "r-date-range-label r-text-muted"
+}, E = { class: "r-popover" }, D = { class: "r-popover-control" }, O = { class: "r-popover-content r-popover-menu r-is-scrollable" }, k = ["onClick"], A = { class: "r-text-muted" }, j = /*@__PURE__*/ m({
+	__name: "r-date-range-button-group",
+	props: {
+		modelValue: { default: void 0 },
+		calendarToggle: {
+			type: Function,
+			default: () => () => void 0
+		},
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		timePicker: {
+			type: Boolean,
+			default: !1
+		},
+		is24hr: {
+			type: Boolean,
+			default: !1
+		},
+		showPresets: {
+			type: Boolean,
+			default: !0
+		},
+		placeholder: { default: "" },
+		timezone: { default: "UTC" }
+	},
+	emits: ["preset-select"],
+	setup(m, { emit: j }) {
+		function M(e) {
+			return typeof e != "string";
+		}
+		let N = m, P = j, F = v(null), I = c(() => r), L = c(() => a(N.timezone)), R = c(() => Object.entries(L.value)), z = c(() => {
+			if (!N.modelValue) return !1;
+			if (typeof N.modelValue == "string") return q(N.modelValue);
+			let e = N.modelValue.start instanceof Date ? N.modelValue.start : C(N.modelValue.start).toDate(), t = N.modelValue.end instanceof Date ? N.modelValue.end : C(N.modelValue.end).toDate();
+			return q(e) && q(t);
+		}), B = c(() => N.modelValue && typeof N.modelValue != "string" && N.modelValue.isRelative || !z.value), V = c(() => {
+			if (!B.value) return null;
+			let e = R.value.find(([, { relativeFilterValue: e }]) => N.modelValue !== void 0 && M(N.modelValue) && e === N.modelValue.relativeFilterValue);
+			if (e) {
+				let [t, n] = e;
+				return {
+					presetName: t,
+					presetLabel: i[t],
+					...n
+				};
+			}
+			if (N.modelValue) return Y(N.modelValue);
+		}), H = c(() => V.value && "presetName" in V.value && !!V.value.presetName), U = c(() => {
+			if (!N.modelValue) return null;
+			if (B.value && H.value) {
+				let e = V.value;
+				return {
+					...e,
+					start: e.start,
+					end: e.end
+				};
+			}
+			let { start: e, end: t } = Y(N.modelValue);
+			return {
+				start: e,
+				end: t
+			};
+		}), W = c(() => {
+			let r = U.value;
+			if (!r) return null;
+			let i = t.shortDate;
+			if (N.timePicker && (i = N.is24hr ? t.shortDate24HrTime : t.shortDateTime), !e.value) {
+				if (B.value && H.value) return o.includes(r.presetName) ? [r.presetLabel, n(r.start, t.orderDate, N.timezone)].join(" / ") : `${r.presetLabel} / ${[n(r.start, i, N.timezone), n(r.end, i, N.timezone)].join(" - ")}`;
+				if (B.value) return `${[n(r.start, i, N.timezone), n(r.end, i, N.timezone)].join(" - ")}`;
+			}
+			return [n(r.start, i, N.timezone), n(r.end, i, N.timezone)].join(" - ");
+		}), G = (e) => i[e], K = (e) => {
+			let r = L.value[e];
+			if (o.includes(e)) return n(r.start, t.orderDate, N.timezone);
+			let i = (e) => n(e, t.shortDate, N.timezone);
+			return `${i(r.start)} — ${i(r.end)}`;
+		}, q = (e) => {
+			let r = n(e, t.datePickerDate, N.timezone);
+			return !!(r && /[0-9]{4}-[0-9]{2}-[0-9]{2}/.test(r));
+		}, J = () => {
+			F.value?.popper && F.value.popper.toggle();
+		}, Y = (e) => {
+			if (!e) return null;
+			if (typeof e == "string") {
+				let t = Object.values(L.value).find((t) => t.relativeFilterValue === e);
+				if (t) return t;
+				let [n, r] = e.split("..");
+				return {
+					start: n,
+					end: r
+				};
+			}
+			return e;
+		}, X = (e) => {
+			let t = L.value[e];
+			P("preset-select", {
+				isRelative: !0,
+				...t,
+				start: t.start,
+				end: t.end
+			}), h(() => {
+				J();
+			});
+		};
+		return (e, t) => {
+			let n = b("r-button"), r = b("r-popper"), i = b("r-button-group");
+			return _(), l(i, { class: g({ "r-button-group-single": !m.showPresets }) }, {
+				default: S(() => [p(n, {
+					"icon-left": "calendar",
+					"capitalize-first-letter": !1,
+					disabled: m.disabled,
+					class: g({ "r-date-range-button": m.showPresets }),
+					onClick: t[0] ||= (e) => m.calendarToggle()
+				}, {
+					default: S(() => [W.value ? (_(), d("span", w, x(W.value), 1)) : (_(), d("span", T, x(m.placeholder), 1))]),
+					_: 1
+				}, 8, ["disabled", "class"]), m.showPresets ? (_(), l(r, {
+					key: 0,
+					ref_key: "presets",
+					ref: F,
+					class: "r-date-range-preset-picker",
+					position: "bottomEnd",
+					offset: 6,
+					disabled: m.disabled
+				}, {
+					trigger: S(() => [p(n, {
+						disabled: m.disabled,
+						icon: "actions",
+						onClick: J
+					}, null, 8, ["disabled"])]),
+					content: S(() => [f("div", E, [f("div", D, [f("div", O, [(_(!0), d(s, null, y(I.value, (e) => (_(), d("a", {
+						key: e,
+						class: "r-popover-menu-item r-range-picker-item",
+						onClick: (t) => X(e)
+					}, [f("strong", null, x(G(e)) + "\xA0", 1), f("span", A, x(K(e)), 1)], 8, k))), 128))])])])]),
+					_: 1
+				}, 8, ["disabled"])) : u("", !0)]),
+				_: 1
+			}, 8, ["class"]);
+		};
+	}
+});
+//#endregion
+export { j as default };

package/dist/components/r-date-input/r-range-calendar.vue.mjs

@@ -0,0 +1,5 @@
+import e from "./r-range-calendar.vue_vue_type_script_setup_true_lang.mjs";
+//#region src/components/r-date-input/r-range-calendar.vue
+var t = e;
+//#endregion
+export { t as default };