@solostylist/ui-kit 1.0.216 → 1.0.217

package/dist/defaultTheme-DCktV_zC.js

@@ -0,0 +1,5 @@
+import { t as e } from "./createTheme-YGsrOe_4.js";
+//#region ../../node_modules/@mui/material/styles/defaultTheme.mjs
+var t = e();
+//#endregion
+export { t };

package/dist/{generateUtilityClass-D4Rn9MbW.js → generateUtilityClass-tRYNDrlH.js}

@@ -1,4 +1,4 @@
-//#region ../../node_modules/@mui/utils/esm/ClassNameGenerator/ClassNameGenerator.js
+//#region ../../node_modules/@mui/utils/ClassNameGenerator/ClassNameGenerator.mjs
 var e = (e) => e, t = (() => {
 	let t = e;
 	return {

package/dist/generateUtilityClasses-XrPHiTcM.js

@@ -0,0 +1,10 @@
+import { t as e } from "./generateUtilityClass-tRYNDrlH.js";
+//#region ../../node_modules/@mui/utils/generateUtilityClasses/generateUtilityClasses.mjs
+function t(t, n, r = "Mui") {
+	let i = {};
+	return n.forEach((n) => {
+		i[n] = e(t, n, r);
+	}), i;
+}
+//#endregion
+export { t };

package/dist/{iconButtonClasses-UNZ6hKTU.js → iconButtonClasses-9jjSQ9-U.js}

@@ -1,6 +1,6 @@
-import { t as e } from "./generateUtilityClass-D4Rn9MbW.js";
-import { t } from "./generateUtilityClasses-CX1nR7K3.js";
-//#region ../../node_modules/@mui/material/esm/IconButton/iconButtonClasses.js
+import { t as e } from "./generateUtilityClass-tRYNDrlH.js";
+import { t } from "./generateUtilityClasses-XrPHiTcM.js";
+//#region ../../node_modules/@mui/material/IconButton/iconButtonClasses.mjs
 function n(t) {
 	return e("MuiIconButton", t);
 }

package/dist/inputLabelClasses-CC5i2Dsg.js

@@ -0,0 +1,659 @@
+import { n as e } from "./chunk-efA98nb6.js";
+import { _ as t } from "./createTheme-YGsrOe_4.js";
+import { a as n, n as r } from "./styled-engine-DOxAQ3qw.js";
+import { n as i, o as a, r as o, t as s } from "./memoTheme-BmiT8U43.js";
+import { t as c } from "./clsx-69XFQeWf.js";
+import { t as l } from "./generateUtilityClass-tRYNDrlH.js";
+import { t as u } from "./generateUtilityClasses-XrPHiTcM.js";
+import { t as d } from "./styled-BRk8Ukg1.js";
+import { g as f } from "./List-CtVrgES0.js";
+import { t as p } from "./ButtonBase-Pxs48joz.js";
+import { h as m } from "./useSlot-CugRM0KJ.js";
+import { t as h } from "./createSimplePaletteValueFilter-GHK52GLU.js";
+import { n as g, t as _ } from "./iconButtonClasses-9jjSQ9-U.js";
+import { r as v } from "./useFormControl-CUs308br.js";
+import * as y from "react";
+import { jsx as b, jsxs as x } from "react/jsx-runtime";
+//#region ../../node_modules/@mui/utils/isMuiElement/isMuiElement.mjs
+function S(e, t) {
+	return /* @__PURE__ */ y.isValidElement(e) && t.indexOf(e.type.muiName ?? e.type?._payload?.value?.muiName) !== -1;
+}
+//#endregion
+//#region ../../node_modules/@mui/material/utils/isMuiElement.mjs
+var C = S;
+//#endregion
+//#region ../../node_modules/@mui/material/CircularProgress/circularProgressClasses.mjs
+function w(e) {
+	return l("MuiCircularProgress", e);
+}
+u("MuiCircularProgress", [
+	"root",
+	"determinate",
+	"indeterminate",
+	"colorPrimary",
+	"colorSecondary",
+	"svg",
+	"track",
+	"circle",
+	"circleDisableShrink"
+]);
+//#endregion
+//#region ../../node_modules/@mui/material/CircularProgress/CircularProgress.mjs
+var T = /* @__PURE__ */ e(t(), 1), E = 44, D = n`
+  0% {
+    transform: rotate(0deg);
+  }
+
+  100% {
+    transform: rotate(360deg);
+  }
+`, O = n`
+  0% {
+    stroke-dasharray: 1px, 200px;
+    stroke-dashoffset: 0;
+  }
+
+  50% {
+    stroke-dasharray: 100px, 200px;
+    stroke-dashoffset: -15px;
+  }
+
+  100% {
+    stroke-dasharray: 1px, 200px;
+    stroke-dashoffset: -126px;
+  }
+`, k = typeof D == "string" ? null : r`
+        animation: ${D} 1.4s linear infinite;
+      `, A = typeof O == "string" ? null : r`
+        animation: ${O} 1.4s ease-in-out infinite;
+      `, j = (e) => {
+	let { classes: t, variant: n, color: r, disableShrink: o } = e;
+	return a({
+		root: [
+			"root",
+			n,
+			`color${i(r)}`
+		],
+		svg: ["svg"],
+		track: ["track"],
+		circle: ["circle", o && "circleDisableShrink"]
+	}, w, t);
+}, M = d("span", {
+	name: "MuiCircularProgress",
+	slot: "Root",
+	overridesResolver: (e, t) => {
+		let { ownerState: n } = e;
+		return [
+			t.root,
+			t[n.variant],
+			t[`color${i(n.color)}`]
+		];
+	}
+})(s(({ theme: e }) => ({
+	display: "inline-block",
+	variants: [
+		{
+			props: { variant: "determinate" },
+			style: { transition: e.transitions.create("transform") }
+		},
+		{
+			props: { variant: "indeterminate" },
+			style: k || { animation: `${D} 1.4s linear infinite` }
+		},
+		...Object.entries(e.palette).filter(h()).map(([t]) => ({
+			props: { color: t },
+			style: { color: (e.vars || e).palette[t].main }
+		}))
+	]
+}))), N = d("svg", {
+	name: "MuiCircularProgress",
+	slot: "Svg"
+})({ display: "block" }), P = d("circle", {
+	name: "MuiCircularProgress",
+	slot: "Circle",
+	overridesResolver: (e, t) => {
+		let { ownerState: n } = e;
+		return [t.circle, n.disableShrink && t.circleDisableShrink];
+	}
+})(s(({ theme: e }) => ({
+	stroke: "currentColor",
+	variants: [
+		{
+			props: { variant: "determinate" },
+			style: { transition: e.transitions.create("stroke-dashoffset") }
+		},
+		{
+			props: { variant: "indeterminate" },
+			style: {
+				strokeDasharray: "80px, 200px",
+				strokeDashoffset: 0
+			}
+		},
+		{
+			props: ({ ownerState: e }) => e.variant === "indeterminate" && !e.disableShrink,
+			style: A || { animation: `${O} 1.4s ease-in-out infinite` }
+		}
+	]
+}))), F = d("circle", {
+	name: "MuiCircularProgress",
+	slot: "Track"
+})(s(({ theme: e }) => ({
+	stroke: "currentColor",
+	opacity: (e.vars || e).palette.action.activatedOpacity
+}))), I = /* @__PURE__ */ y.forwardRef(function(e, t) {
+	let n = o({
+		props: e,
+		name: "MuiCircularProgress"
+	}), { className: r, color: i = "primary", disableShrink: a = !1, enableTrackSlot: s = !1, min: l, max: u, size: d = 40, style: f, thickness: p = 3.6, value: m = n.min ?? 0, variant: h = "indeterminate", ...g } = n;
+	process.env.NODE_ENV !== "production" && h === "indeterminate" && (l !== void 0 || u !== void 0) && console.warn("MUI: You have provided the `min` or `max` props with an 'indeterminate' variant. These props will have no effect.");
+	let _ = l ?? 0, v = u ?? 100, y = {
+		...n,
+		color: i,
+		disableShrink: a,
+		size: d,
+		thickness: p,
+		value: m,
+		variant: h,
+		enableTrackSlot: s
+	}, S = j(y), C = {}, w = {}, T = {};
+	if (h === "determinate") {
+		let e = 2 * Math.PI * ((E - p) / 2);
+		process.env.NODE_ENV !== "production" && (m < _ || m > v || _ >= v) && console.error(`MUI: The min, max, and value props in CircularProgress should be numbers where min < max and min <= value <= max. Received min=${_}, max=${v}, value=${m}.`);
+		let t = v - _;
+		C.strokeDasharray = e.toFixed(3), C.strokeDashoffset = t > 0 ? `${((v - m) / t * e).toFixed(3)}px` : `${e.toFixed(3)}px`, w.transform = "rotate(-90deg)", T["aria-valuenow"] = m, T["aria-valuemin"] = _, T["aria-valuemax"] = v;
+	}
+	return /* @__PURE__ */ b(M, {
+		className: c(S.root, r),
+		style: {
+			width: d,
+			height: d,
+			...w,
+			...f
+		},
+		ownerState: y,
+		ref: t,
+		role: "progressbar",
+		...T,
+		...g,
+		children: /* @__PURE__ */ x(N, {
+			className: S.svg,
+			ownerState: y,
+			viewBox: `${E / 2} ${E / 2} ${E} ${E}`,
+			children: [s ? /* @__PURE__ */ b(F, {
+				className: S.track,
+				ownerState: y,
+				cx: E,
+				cy: E,
+				r: (E - p) / 2,
+				fill: "none",
+				strokeWidth: p,
+				"aria-hidden": "true"
+			}) : null, /* @__PURE__ */ b(P, {
+				className: S.circle,
+				style: C,
+				ownerState: y,
+				cx: E,
+				cy: E,
+				r: (E - p) / 2,
+				fill: "none",
+				strokeWidth: p
+			})]
+		})
+	});
+});
+process.env.NODE_ENV !== "production" && (I.propTypes = {
+	classes: T.default.object,
+	className: T.default.string,
+	color: T.default.oneOfType([T.default.oneOf([
+		"inherit",
+		"primary",
+		"secondary",
+		"error",
+		"info",
+		"success",
+		"warning"
+	]), T.default.string]),
+	disableShrink: m(T.default.bool, (e) => e.disableShrink && e.variant && e.variant !== "indeterminate" ? /* @__PURE__ */ Error("MUI: You have provided the `disableShrink` prop with a variant other than `indeterminate`. This will have no effect.") : null),
+	enableTrackSlot: T.default.bool,
+	max: T.default.number,
+	min: T.default.number,
+	size: T.default.oneOfType([T.default.number, T.default.string]),
+	style: T.default.object,
+	sx: T.default.oneOfType([
+		T.default.arrayOf(T.default.oneOfType([
+			T.default.func,
+			T.default.object,
+			T.default.bool
+		])),
+		T.default.func,
+		T.default.object
+	]),
+	thickness: T.default.number,
+	value: T.default.number,
+	variant: T.default.oneOf(["determinate", "indeterminate"])
+});
+//#endregion
+//#region ../../node_modules/@mui/material/IconButton/IconButton.mjs
+var L = (e) => {
+	let { classes: t, disabled: n, color: r, edge: o, size: s, loading: c } = e;
+	return a({
+		root: [
+			"root",
+			c && "loading",
+			n && "disabled",
+			r !== "default" && `color${i(r)}`,
+			o && `edge${i(o)}`,
+			`size${i(s)}`
+		],
+		loadingIndicator: ["loadingIndicator"],
+		loadingWrapper: ["loadingWrapper"]
+	}, _, t);
+}, R = d(p, {
+	name: "MuiIconButton",
+	slot: "Root",
+	overridesResolver: (e, t) => {
+		let { ownerState: n } = e;
+		return [
+			t.root,
+			n.loading && t.loading,
+			n.color !== "default" && t[`color${i(n.color)}`],
+			n.edge && t[`edge${i(n.edge)}`],
+			t[`size${i(n.size)}`]
+		];
+	}
+})(s(({ theme: e }) => ({
+	textAlign: "center",
+	flex: "0 0 auto",
+	fontSize: e.typography.pxToRem(24),
+	padding: 8,
+	borderRadius: "50%",
+	color: (e.vars || e).palette.action.active,
+	transition: e.transitions.create("background-color", { duration: e.transitions.duration.shortest }),
+	variants: [
+		{
+			props: (e) => !e.disableRipple,
+			style: {
+				"--IconButton-hoverBg": e.alpha((e.vars || e).palette.action.active, (e.vars || e).palette.action.hoverOpacity),
+				"&:hover": {
+					backgroundColor: "var(--IconButton-hoverBg)",
+					"@media (hover: none)": { backgroundColor: "transparent" }
+				}
+			}
+		},
+		{
+			props: { edge: "start" },
+			style: { marginLeft: -12 }
+		},
+		{
+			props: {
+				edge: "start",
+				size: "small"
+			},
+			style: { marginLeft: -3 }
+		},
+		{
+			props: { edge: "end" },
+			style: { marginRight: -12 }
+		},
+		{
+			props: {
+				edge: "end",
+				size: "small"
+			},
+			style: { marginRight: -3 }
+		}
+	]
+})), s(({ theme: e }) => ({
+	variants: [
+		{
+			props: { color: "inherit" },
+			style: { color: "inherit" }
+		},
+		...Object.entries(e.palette).filter(h()).map(([t]) => ({
+			props: { color: t },
+			style: {
+				color: (e.vars || e).palette[t].main,
+				"--IconButton-hoverBg": e.alpha((e.vars || e).palette[t].main, (e.vars || e).palette.action.hoverOpacity)
+			}
+		})),
+		{
+			props: { size: "small" },
+			style: {
+				padding: 5,
+				fontSize: e.typography.pxToRem(18)
+			}
+		},
+		{
+			props: { size: "large" },
+			style: {
+				padding: 12,
+				fontSize: e.typography.pxToRem(28)
+			}
+		}
+	],
+	[`&.${g.disabled}`]: {
+		backgroundColor: "transparent",
+		color: (e.vars || e).palette.action.disabled
+	},
+	[`&.${g.loading}`]: { color: "transparent" }
+}))), z = d("span", {
+	name: "MuiIconButton",
+	slot: "LoadingIndicator"
+})(({ theme: e }) => ({
+	display: "none",
+	position: "absolute",
+	visibility: "visible",
+	top: "50%",
+	left: "50%",
+	transform: "translate(-50%, -50%)",
+	color: (e.vars || e).palette.action.disabled,
+	variants: [{
+		props: { loading: !0 },
+		style: { display: "flex" }
+	}]
+})), B = /* @__PURE__ */ y.forwardRef(function(e, t) {
+	let n = o({
+		props: e,
+		name: "MuiIconButton"
+	}), { edge: r = !1, children: i, className: a, color: s = "default", disabled: l = !1, disableFocusRipple: u = !1, size: d = "medium", id: p, loading: m = null, loadingIndicator: h, ...g } = n, _ = f(p), v = h ?? /* @__PURE__ */ b(I, {
+		"aria-labelledby": _,
+		color: "inherit",
+		size: 16
+	}), y = {
+		...n,
+		edge: r,
+		color: s,
+		disabled: l,
+		disableFocusRipple: u,
+		loading: m,
+		loadingIndicator: v,
+		size: d
+	}, S = L(y);
+	return /* @__PURE__ */ x(R, {
+		id: m ? _ : p,
+		className: c(S.root, a),
+		centerRipple: !0,
+		internalNativeButton: !0,
+		focusRipple: !u,
+		disabled: l || m,
+		ref: t,
+		...g,
+		ownerState: y,
+		children: [typeof m == "boolean" && /* @__PURE__ */ b("span", {
+			className: S.loadingWrapper,
+			style: { display: "contents" },
+			children: /* @__PURE__ */ b(z, {
+				className: S.loadingIndicator,
+				ownerState: y,
+				children: m && v
+			})
+		}), i]
+	});
+});
+process.env.NODE_ENV !== "production" && (B.propTypes = {
+	children: m(T.default.node, (e) => y.Children.toArray(e.children).some((e) => /* @__PURE__ */ y.isValidElement(e) && e.props.onClick) ? Error([
+		"MUI: You are providing an onClick event listener to a child of a button element.",
+		"Prefer applying it to the IconButton directly.",
+		"This guarantees that the whole <button> will be responsive to click events."
+	].join("\n")) : null),
+	classes: T.default.object,
+	className: T.default.string,
+	color: T.default.oneOfType([T.default.oneOf([
+		"inherit",
+		"default",
+		"primary",
+		"secondary",
+		"error",
+		"info",
+		"success",
+		"warning"
+	]), T.default.string]),
+	disabled: T.default.bool,
+	disableFocusRipple: T.default.bool,
+	disableRipple: T.default.bool,
+	edge: T.default.oneOf([
+		"end",
+		"start",
+		!1
+	]),
+	id: T.default.string,
+	loading: T.default.bool,
+	loadingIndicator: T.default.node,
+	size: T.default.oneOfType([T.default.oneOf([
+		"small",
+		"medium",
+		"large"
+	]), T.default.string]),
+	sx: T.default.oneOfType([
+		T.default.arrayOf(T.default.oneOfType([
+			T.default.func,
+			T.default.object,
+			T.default.bool
+		])),
+		T.default.func,
+		T.default.object
+	])
+});
+//#endregion
+//#region ../../node_modules/@mui/material/InputBase/utils.mjs
+function V(e) {
+	return e != null && !(Array.isArray(e) && e.length === 0);
+}
+function H(e, t = !1) {
+	return e && (V(e.value) && e.value !== "" || t && V(e.defaultValue) && e.defaultValue !== "");
+}
+function U(e) {
+	return e.startAdornment;
+}
+//#endregion
+//#region ../../node_modules/@mui/material/FormControl/formControlClasses.mjs
+function W(e) {
+	return l("MuiFormControl", e);
+}
+u("MuiFormControl", [
+	"root",
+	"marginNone",
+	"marginNormal",
+	"marginDense",
+	"fullWidth",
+	"disabled"
+]);
+//#endregion
+//#region ../../node_modules/@mui/material/FormControl/FormControl.mjs
+var G = (e) => {
+	let { classes: t, margin: n, fullWidth: r } = e;
+	return a({ root: [
+		"root",
+		n !== "none" && `margin${i(n)}`,
+		r && "fullWidth"
+	] }, W, t);
+}, K = d("div", {
+	name: "MuiFormControl",
+	slot: "Root",
+	overridesResolver: (e, t) => {
+		let { ownerState: n } = e;
+		return [
+			t.root,
+			t[`margin${i(n.margin)}`],
+			n.fullWidth && t.fullWidth
+		];
+	}
+})({
+	display: "inline-flex",
+	flexDirection: "column",
+	position: "relative",
+	minWidth: 0,
+	padding: 0,
+	margin: 0,
+	border: 0,
+	verticalAlign: "top",
+	variants: [
+		{
+			props: { margin: "normal" },
+			style: {
+				marginTop: 16,
+				marginBottom: 8
+			}
+		},
+		{
+			props: { margin: "dense" },
+			style: {
+				marginTop: 8,
+				marginBottom: 4
+			}
+		},
+		{
+			props: { fullWidth: !0 },
+			style: { width: "100%" }
+		}
+	]
+}), q = /* @__PURE__ */ y.forwardRef(function(e, t) {
+	let n = o({
+		props: e,
+		name: "MuiFormControl"
+	}), { children: r, className: i, color: a = "primary", component: s = "div", disabled: l = !1, error: u = !1, focused: d, fullWidth: f = !1, hiddenLabel: p = !1, margin: m = "none", required: h = !1, size: g = "medium", variant: _ = "outlined", ...x } = n, S = {
+		...n,
+		color: a,
+		component: s,
+		disabled: l,
+		error: u,
+		fullWidth: f,
+		hiddenLabel: p,
+		margin: m,
+		required: h,
+		size: g,
+		variant: _
+	}, w = G(S), [T, E] = y.useState(() => {
+		let e = !1;
+		return r && y.Children.forEach(r, (t) => {
+			if (!C(t, ["Input", "Select"])) return;
+			let n = C(t, ["Select"]) ? t.props.input : t;
+			n && U(n.props) && (e = !0);
+		}), e;
+	}), [D, O] = y.useState(() => {
+		let e = !1;
+		return r && y.Children.forEach(r, (t) => {
+			C(t, ["Input", "Select"]) && (H(t.props, !0) || H(t.props.inputProps, !0)) && (e = !0);
+		}), e;
+	}), [k, A] = y.useState(!1);
+	l && k && A(!1);
+	let j = d !== void 0 && !l ? d : k, M, N = y.useRef(!1);
+	process.env.NODE_ENV !== "production" && (M = () => (N.current && console.error(["MUI: There are multiple `InputBase` components inside a FormControl.", "This creates visual inconsistencies, only use one `InputBase`."].join("\n")), N.current = !0, () => {
+		N.current = !1;
+	}));
+	let P = y.useCallback(() => {
+		O(!0);
+	}, []), F = y.useCallback(() => {
+		O(!1);
+	}, []), I = y.useMemo(() => ({
+		adornedStart: T,
+		setAdornedStart: E,
+		color: a,
+		disabled: l,
+		error: u,
+		filled: D,
+		focused: j,
+		fullWidth: f,
+		hiddenLabel: p,
+		size: g,
+		onBlur: () => {
+			A(!1);
+		},
+		onFocus: () => {
+			A(!0);
+		},
+		onEmpty: F,
+		onFilled: P,
+		registerEffect: M,
+		required: h,
+		variant: _
+	}), [
+		T,
+		a,
+		l,
+		u,
+		D,
+		j,
+		f,
+		p,
+		M,
+		F,
+		P,
+		h,
+		g,
+		_
+	]);
+	return /* @__PURE__ */ b(v.Provider, {
+		value: I,
+		children: /* @__PURE__ */ b(K, {
+			as: s,
+			ownerState: S,
+			className: c(w.root, i),
+			ref: t,
+			...x,
+			children: r
+		})
+	});
+});
+process.env.NODE_ENV !== "production" && (q.propTypes = {
+	children: T.default.node,
+	classes: T.default.object,
+	className: T.default.string,
+	color: T.default.oneOfType([T.default.oneOf([
+		"primary",
+		"secondary",
+		"error",
+		"info",
+		"success",
+		"warning"
+	]), T.default.string]),
+	component: T.default.elementType,
+	disabled: T.default.bool,
+	error: T.default.bool,
+	focused: T.default.bool,
+	fullWidth: T.default.bool,
+	hiddenLabel: T.default.bool,
+	margin: T.default.oneOf([
+		"dense",
+		"none",
+		"normal"
+	]),
+	required: T.default.bool,
+	size: T.default.oneOfType([T.default.oneOf(["medium", "small"]), T.default.string]),
+	sx: T.default.oneOfType([
+		T.default.arrayOf(T.default.oneOfType([
+			T.default.func,
+			T.default.object,
+			T.default.bool
+		])),
+		T.default.func,
+		T.default.object
+	]),
+	variant: T.default.oneOf([
+		"filled",
+		"outlined",
+		"standard"
+	])
+});
+//#endregion
+//#region ../../node_modules/@mui/material/InputLabel/inputLabelClasses.mjs
+function J(e) {
+	return l("MuiInputLabel", e);
+}
+var Y = u("MuiInputLabel", [
+	"root",
+	"focused",
+	"disabled",
+	"error",
+	"required",
+	"asterisk",
+	"formControl",
+	"sizeSmall",
+	"shrink",
+	"animated",
+	"standard",
+	"filled",
+	"outlined"
+]);
+//#endregion
+export { B as a, H as i, Y as n, I as o, q as r, J as t };