@hybridcore/ui 1.0.2 → 1.1.0

package/dist/index-DHFb1Qpn.js

@@ -0,0 +1,1105 @@
+import { jsx as l, jsxs as F, Fragment as ae } from "react/jsx-runtime";
+import M from "lodash";
+import ie from "dayjs";
+import { Typography as ce, Chip as Re, Dialog as Ve, DialogTitle as ke, DialogContent as we, DialogActions as je, Button as oe, InputAdornment as Ne, Tooltip as Le, Stack as Se } from "@mui/material";
+import { Container as $e, Values as De, MiniButton as qe } from "./components/data-management/instance-form/components/composite-list/styled.js";
+import { Add as Ee, LockOutlined as Me } from "@mui/icons-material";
+import _e from "./hooks/useToggle.js";
+import { GeometryPicker as Be } from "./components/geometry-picker/index.js";
+import { PhoneInput as Ae } from "./components/phone-input/index.js";
+import { DateTimePicker as He } from "./components/date-time-picker/index.js";
+import { a as g, _ } from "./extends-C3382pL0.js";
+import * as V from "react";
+import { useState as We } from "react";
+import { P as e, a as Ue, h as ne, r as z, f as Ge, d as ze, m as Ye, j as te, c as B } from "./createTheme-agWfFD64.js";
+import { c as S, a as A, g as J, u as H } from "./chainPropTypes-DtBfUj5o.js";
+import { e as Je, g as W, s as $ } from "./styled-Iq9jsO4F.js";
+import { f as de, F as ue, I as me } from "./FormControl-C4PmH1vh.js";
+import { u as Ke } from "./useId-BHG98T5I.js";
+import { S as pe, F as Qe, M as Xe } from "./Select-DOyHt8I_.js";
+import { u as fe } from "./useFormControl-CatNKXAi.js";
+import { r as be } from "./ButtonBase-B6WYZgVU.js";
+import { I as Ze } from "./Input-CH_JyT5B.js";
+import { O as eo } from "./OutlinedInput-gnp48tDo.js";
+import { B as E, C as oo } from "./Checkbox-CxbQ9tJ5.js";
+import { T as re } from "./Typography-XIiVCSto.js";
+import { s as no } from "./styled-B22KrhDR.js";
+import { u as to } from "./useThemeProps-CzAjOL6F.js";
+const ro = ["component", "direction", "spacing", "divider", "children", "className", "useFlexGap"], lo = Ue(), so = no("div", {
+  name: "MuiStack",
+  slot: "Root",
+  overridesResolver: (n, o) => o.root
+});
+function ao(n) {
+  return to({
+    props: n,
+    name: "MuiStack",
+    defaultTheme: lo
+  });
+}
+function io(n, o) {
+  const t = V.Children.toArray(n).filter(Boolean);
+  return t.reduce((a, c, r) => (a.push(c), r < t.length - 1 && a.push(/* @__PURE__ */ V.cloneElement(o, {
+    key: `separator-${r}`
+  })), a), []);
+}
+const co = (n) => ({
+  row: "Left",
+  "row-reverse": "Right",
+  column: "Top",
+  "column-reverse": "Bottom"
+})[n], uo = ({
+  ownerState: n,
+  theme: o
+}) => {
+  let t = g({
+    display: "flex",
+    flexDirection: "column"
+  }, ne({
+    theme: o
+  }, z({
+    values: n.direction,
+    breakpoints: o.breakpoints.values
+  }), (a) => ({
+    flexDirection: a
+  })));
+  if (n.spacing) {
+    const a = Ge(o), c = Object.keys(o.breakpoints.values).reduce((d, i) => ((typeof n.spacing == "object" && n.spacing[i] != null || typeof n.direction == "object" && n.direction[i] != null) && (d[i] = !0), d), {}), r = z({
+      values: n.direction,
+      base: c
+    }), u = z({
+      values: n.spacing,
+      base: c
+    });
+    typeof r == "object" && Object.keys(r).forEach((d, i, b) => {
+      if (!r[d]) {
+        const x = i > 0 ? r[b[i - 1]] : "column";
+        r[d] = x;
+      }
+    }), t = ze(t, ne({
+      theme: o
+    }, u, (d, i) => n.useFlexGap ? {
+      gap: te(a, d)
+    } : {
+      // The useFlexGap={false} implement relies on each child to give up control of the margin.
+      // We need to reset the margin to avoid double spacing.
+      "& > :not(style):not(style)": {
+        margin: 0
+      },
+      "& > :not(style) ~ :not(style)": {
+        [`margin${co(i ? r[i] : n.direction)}`]: te(a, d)
+      }
+    }));
+  }
+  return t = Ye(o.breakpoints, t), t;
+};
+function mo(n = {}) {
+  const {
+    // This will allow adding custom styled fn (for example for custom sx style function)
+    createStyledComponent: o = so,
+    useThemeProps: t = ao,
+    componentName: a = "MuiStack"
+  } = n, c = () => A({
+    root: ["root"]
+  }, (d) => W(a, d), {}), r = o(uo), u = /* @__PURE__ */ V.forwardRef(function(d, i) {
+    const b = t(d), y = Je(b), {
+      component: x = "div",
+      direction: f = "column",
+      spacing: h = 0,
+      divider: C,
+      children: s,
+      className: p,
+      useFlexGap: v = !1
+    } = y, O = _(y, ro), P = {
+      direction: f,
+      spacing: h,
+      useFlexGap: v
+    }, T = c();
+    return /* @__PURE__ */ l(r, g({
+      as: x,
+      ownerState: P,
+      ref: i,
+      className: S(T.root, p)
+    }, O, {
+      children: C ? io(s, C) : s
+    }));
+  });
+  return process.env.NODE_ENV !== "production" && (u.propTypes = {
+    children: e.node,
+    direction: e.oneOfType([e.oneOf(["column-reverse", "column", "row-reverse", "row"]), e.arrayOf(e.oneOf(["column-reverse", "column", "row-reverse", "row"])), e.object]),
+    divider: e.node,
+    spacing: e.oneOfType([e.arrayOf(e.oneOfType([e.number, e.string])), e.number, e.object, e.string]),
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object])
+  }), u;
+}
+function po(n) {
+  return W("MuiFormHelperText", n);
+}
+const le = J("MuiFormHelperText", ["root", "error", "disabled", "sizeSmall", "sizeMedium", "contained", "focused", "filled", "required"]);
+var se;
+const fo = ["children", "className", "component", "disabled", "error", "filled", "focused", "margin", "required", "variant"], bo = (n) => {
+  const {
+    classes: o,
+    contained: t,
+    size: a,
+    disabled: c,
+    error: r,
+    filled: u,
+    focused: m,
+    required: d
+  } = n, i = {
+    root: ["root", c && "disabled", r && "error", a && `size${B(a)}`, t && "contained", m && "focused", u && "filled", d && "required"]
+  };
+  return A(i, po, o);
+}, ho = $("p", {
+  name: "MuiFormHelperText",
+  slot: "Root",
+  overridesResolver: (n, o) => {
+    const {
+      ownerState: t
+    } = n;
+    return [o.root, t.size && o[`size${B(t.size)}`], t.contained && o.contained, t.filled && o.filled];
+  }
+})(({
+  theme: n,
+  ownerState: o
+}) => g({
+  color: (n.vars || n).palette.text.secondary
+}, n.typography.caption, {
+  textAlign: "left",
+  marginTop: 3,
+  marginRight: 0,
+  marginBottom: 0,
+  marginLeft: 0,
+  [`&.${le.disabled}`]: {
+    color: (n.vars || n).palette.text.disabled
+  },
+  [`&.${le.error}`]: {
+    color: (n.vars || n).palette.error.main
+  }
+}, o.size === "small" && {
+  marginTop: 4
+}, o.contained && {
+  marginLeft: 14,
+  marginRight: 14
+})), he = /* @__PURE__ */ V.forwardRef(function(o, t) {
+  const a = H({
+    props: o,
+    name: "MuiFormHelperText"
+  }), {
+    children: c,
+    className: r,
+    component: u = "p"
+  } = a, m = _(a, fo), d = fe(), i = de({
+    props: a,
+    muiFormControl: d,
+    states: ["variant", "size", "disabled", "error", "filled", "focused", "required"]
+  }), b = g({}, a, {
+    component: u,
+    contained: i.variant === "filled" || i.variant === "outlined",
+    variant: i.variant,
+    size: i.size,
+    disabled: i.disabled,
+    error: i.error,
+    filled: i.filled,
+    focused: i.focused,
+    required: i.required
+  }), y = bo(b);
+  return /* @__PURE__ */ l(ho, g({
+    as: u,
+    ownerState: b,
+    className: S(y.root, r),
+    ref: t
+  }, m, {
+    children: c === " " ? (
+      // notranslate needed while Google Translate will not fix zero-width space issue
+      se || (se = /* @__PURE__ */ l("span", {
+        className: "notranslate",
+        children: "​"
+      }))
+    ) : c
+  }));
+});
+process.env.NODE_ENV !== "production" && (he.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   *
+   * If `' '` is provided, the component reserves one line height for displaying a future message.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * If `true`, the helper text should be displayed in a disabled state.
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, helper text should be displayed in an error state.
+   */
+  error: e.bool,
+  /**
+   * If `true`, the helper text should use filled classes key.
+   */
+  filled: e.bool,
+  /**
+   * If `true`, the helper text should use focused classes key.
+   */
+  focused: e.bool,
+  /**
+   * If `dense`, will adjust vertical spacing. This is normally obtained via context from
+   * FormControl.
+   */
+  margin: e.oneOf(["dense"]),
+  /**
+   * If `true`, the helper text should use required classes key.
+   */
+  required: e.bool,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * The variant to use.
+   */
+  variant: e.oneOfType([e.oneOf(["filled", "outlined", "standard"]), e.string])
+});
+function go(n) {
+  return W("MuiTextField", n);
+}
+J("MuiTextField", ["root"]);
+const yo = ["autoComplete", "autoFocus", "children", "className", "color", "defaultValue", "disabled", "error", "FormHelperTextProps", "fullWidth", "helperText", "id", "InputLabelProps", "inputProps", "InputProps", "inputRef", "label", "maxRows", "minRows", "multiline", "name", "onBlur", "onChange", "onFocus", "placeholder", "required", "rows", "select", "SelectProps", "type", "value", "variant"], vo = {
+  standard: Ze,
+  filled: Qe,
+  outlined: eo
+}, To = (n) => {
+  const {
+    classes: o
+  } = n;
+  return A({
+    root: ["root"]
+  }, go, o);
+}, xo = $(ue, {
+  name: "MuiTextField",
+  slot: "Root",
+  overridesResolver: (n, o) => o.root
+})({}), Y = /* @__PURE__ */ V.forwardRef(function(o, t) {
+  const a = H({
+    props: o,
+    name: "MuiTextField"
+  }), {
+    autoComplete: c,
+    autoFocus: r = !1,
+    children: u,
+    className: m,
+    color: d = "primary",
+    defaultValue: i,
+    disabled: b = !1,
+    error: y = !1,
+    FormHelperTextProps: x,
+    fullWidth: f = !1,
+    helperText: h,
+    id: C,
+    InputLabelProps: s,
+    inputProps: p,
+    InputProps: v,
+    inputRef: O,
+    label: P,
+    maxRows: T,
+    minRows: j,
+    multiline: k = !1,
+    name: I,
+    onBlur: w,
+    onChange: ve,
+    onFocus: Te,
+    placeholder: xe,
+    required: K = !1,
+    rows: Ce,
+    select: D = !1,
+    SelectProps: U,
+    type: Pe,
+    value: Q,
+    variant: q = "outlined"
+  } = a, Oe = _(a, yo), X = g({}, a, {
+    autoFocus: r,
+    color: d,
+    disabled: b,
+    error: y,
+    fullWidth: f,
+    multiline: k,
+    required: K,
+    select: D,
+    variant: q
+  }), Fe = To(X);
+  process.env.NODE_ENV !== "production" && D && !u && console.error("MUI: `children` must be passed when using the `TextField` component with `select`.");
+  const N = {};
+  q === "outlined" && (s && typeof s.shrink < "u" && (N.notched = s.shrink), N.label = P), D && ((!U || !U.native) && (N.id = void 0), N["aria-describedby"] = void 0);
+  const R = Ke(C), G = h && R ? `${R}-helper-text` : void 0, Z = P && R ? `${R}-label` : void 0, Ie = vo[q], ee = /* @__PURE__ */ l(Ie, g({
+    "aria-describedby": G,
+    autoComplete: c,
+    autoFocus: r,
+    defaultValue: i,
+    fullWidth: f,
+    multiline: k,
+    name: I,
+    rows: Ce,
+    maxRows: T,
+    minRows: j,
+    type: Pe,
+    value: Q,
+    id: R,
+    inputRef: O,
+    onBlur: w,
+    onChange: ve,
+    onFocus: Te,
+    placeholder: xe,
+    inputProps: p
+  }, N, v));
+  return /* @__PURE__ */ F(xo, g({
+    className: S(Fe.root, m),
+    disabled: b,
+    error: y,
+    fullWidth: f,
+    ref: t,
+    required: K,
+    color: d,
+    variant: q,
+    ownerState: X
+  }, Oe, {
+    children: [P != null && P !== "" && /* @__PURE__ */ l(me, g({
+      htmlFor: R,
+      id: Z
+    }, s, {
+      children: P
+    })), D ? /* @__PURE__ */ l(pe, g({
+      "aria-describedby": G,
+      id: R,
+      labelId: Z,
+      value: Q,
+      input: ee
+    }, U, {
+      children: u
+    })) : ee, h && /* @__PURE__ */ l(he, g({
+      id: G
+    }, x, {
+      children: h
+    }))]
+  }));
+});
+process.env.NODE_ENV !== "production" && (Y.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * This prop helps users to fill forms faster, especially on mobile devices.
+   * The name can be confusing, as it's more like an autofill.
+   * You can learn more about it [following the specification](https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill).
+   */
+  autoComplete: e.string,
+  /**
+   * If `true`, the `input` element is focused during the first mount.
+   * @default false
+   */
+  autoFocus: e.bool,
+  /**
+   * @ignore
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The color of the component.
+   * It supports both default and custom theme colors, which can be added as shown in the
+   * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
+   * @default 'primary'
+   */
+  color: e.oneOfType([e.oneOf(["primary", "secondary", "error", "info", "success", "warning"]), e.string]),
+  /**
+   * The default value. Use when the component is not controlled.
+   */
+  defaultValue: e.any,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, the label is displayed in an error state.
+   * @default false
+   */
+  error: e.bool,
+  /**
+   * Props applied to the [`FormHelperText`](/material-ui/api/form-helper-text/) element.
+   */
+  FormHelperTextProps: e.object,
+  /**
+   * If `true`, the input will take up the full width of its container.
+   * @default false
+   */
+  fullWidth: e.bool,
+  /**
+   * The helper text content.
+   */
+  helperText: e.node,
+  /**
+   * The id of the `input` element.
+   * Use this prop to make `label` and `helperText` accessible for screen readers.
+   */
+  id: e.string,
+  /**
+   * Props applied to the [`InputLabel`](/material-ui/api/input-label/) element.
+   * Pointer events like `onClick` are enabled if and only if `shrink` is `true`.
+   */
+  InputLabelProps: e.object,
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
+   */
+  inputProps: e.object,
+  /**
+   * Props applied to the Input element.
+   * It will be a [`FilledInput`](/material-ui/api/filled-input/),
+   * [`OutlinedInput`](/material-ui/api/outlined-input/) or [`Input`](/material-ui/api/input/)
+   * component depending on the `variant` prop value.
+   */
+  InputProps: e.object,
+  /**
+   * Pass a ref to the `input` element.
+   */
+  inputRef: be,
+  /**
+   * The label content.
+   */
+  label: e.node,
+  /**
+   * If `dense` or `normal`, will adjust vertical spacing of this and contained components.
+   * @default 'none'
+   */
+  margin: e.oneOf(["dense", "none", "normal"]),
+  /**
+   * Maximum number of rows to display when multiline option is set to true.
+   */
+  maxRows: e.oneOfType([e.number, e.string]),
+  /**
+   * Minimum number of rows to display when multiline option is set to true.
+   */
+  minRows: e.oneOfType([e.number, e.string]),
+  /**
+   * If `true`, a `textarea` element is rendered instead of an input.
+   * @default false
+   */
+  multiline: e.bool,
+  /**
+   * Name attribute of the `input` element.
+   */
+  name: e.string,
+  /**
+   * @ignore
+   */
+  onBlur: e.func,
+  /**
+   * Callback fired when the value is changed.
+   *
+   * @param {object} event The event source of the callback.
+   * You can pull out the new value by accessing `event.target.value` (string).
+   */
+  onChange: e.func,
+  /**
+   * @ignore
+   */
+  onFocus: e.func,
+  /**
+   * The short hint displayed in the `input` before the user enters a value.
+   */
+  placeholder: e.string,
+  /**
+   * If `true`, the label is displayed as required and the `input` element is required.
+   * @default false
+   */
+  required: e.bool,
+  /**
+   * Number of rows to display when multiline option is set to true.
+   */
+  rows: e.oneOfType([e.number, e.string]),
+  /**
+   * Render a [`Select`](/material-ui/api/select/) element while passing the Input element to `Select` as `input` parameter.
+   * If this option is set you must pass the options of the select as children.
+   * @default false
+   */
+  select: e.bool,
+  /**
+   * Props applied to the [`Select`](/material-ui/api/select/) element.
+   */
+  SelectProps: e.object,
+  /**
+   * The size of the component.
+   */
+  size: e.oneOfType([e.oneOf(["medium", "small"]), e.string]),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * Type of the `input` element. It should be [a valid HTML5 input type](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Form_%3Cinput%3E_types).
+   */
+  type: e.string,
+  /**
+   * The value of the `input` element, required for a controlled component.
+   */
+  value: e.any,
+  /**
+   * The variant to use.
+   * @default 'outlined'
+   */
+  variant: e.oneOf(["filled", "outlined", "standard"])
+});
+const ge = mo({
+  createStyledComponent: $("div", {
+    name: "MuiStack",
+    slot: "Root",
+    overridesResolver: (n, o) => o.root
+  }),
+  useThemeProps: (n) => H({
+    props: n,
+    name: "MuiStack"
+  })
+});
+process.env.NODE_ENV !== "production" && (ge.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   */
+  children: e.node,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * Defines the `flex-direction` style property.
+   * It is applied for all screen sizes.
+   * @default 'column'
+   */
+  direction: e.oneOfType([e.oneOf(["column-reverse", "column", "row-reverse", "row"]), e.arrayOf(e.oneOf(["column-reverse", "column", "row-reverse", "row"])), e.object]),
+  /**
+   * Add an element between each child.
+   */
+  divider: e.node,
+  /**
+   * Defines the space between immediate children.
+   * @default 0
+   */
+  spacing: e.oneOfType([e.arrayOf(e.oneOfType([e.number, e.string])), e.number, e.object, e.string]),
+  /**
+   * The system prop, which allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * If `true`, the CSS flexbox `gap` is used instead of applying `margin` to children.
+   *
+   * While CSS `gap` removes the [known limitations](https://mui.com/joy-ui/react-stack/#limitations),
+   * it is not fully supported in some browsers. We recommend checking https://caniuse.com/?search=flex%20gap before using this flag.
+   *
+   * To enable this flag globally, follow the [theme's default props](https://mui.com/material-ui/customization/theme-components/#default-props) configuration.
+   * @default false
+   */
+  useFlexGap: e.bool
+});
+function Co(n) {
+  return W("MuiFormControlLabel", n);
+}
+const L = J("MuiFormControlLabel", ["root", "labelPlacementStart", "labelPlacementTop", "labelPlacementBottom", "disabled", "label", "error", "required", "asterisk"]), Po = ["checked", "className", "componentsProps", "control", "disabled", "disableTypography", "inputRef", "label", "labelPlacement", "name", "onChange", "required", "slotProps", "value"], Oo = (n) => {
+  const {
+    classes: o,
+    disabled: t,
+    labelPlacement: a,
+    error: c,
+    required: r
+  } = n, u = {
+    root: ["root", t && "disabled", `labelPlacement${B(a)}`, c && "error", r && "required"],
+    label: ["label", t && "disabled"],
+    asterisk: ["asterisk", c && "error"]
+  };
+  return A(u, Co, o);
+}, Fo = $("label", {
+  name: "MuiFormControlLabel",
+  slot: "Root",
+  overridesResolver: (n, o) => {
+    const {
+      ownerState: t
+    } = n;
+    return [{
+      [`& .${L.label}`]: o.label
+    }, o.root, o[`labelPlacement${B(t.labelPlacement)}`]];
+  }
+})(({
+  theme: n,
+  ownerState: o
+}) => g({
+  display: "inline-flex",
+  alignItems: "center",
+  cursor: "pointer",
+  // For correct alignment with the text.
+  verticalAlign: "middle",
+  WebkitTapHighlightColor: "transparent",
+  marginLeft: -11,
+  marginRight: 16,
+  // used for row presentation of radio/checkbox
+  [`&.${L.disabled}`]: {
+    cursor: "default"
+  }
+}, o.labelPlacement === "start" && {
+  flexDirection: "row-reverse",
+  marginLeft: 16,
+  // used for row presentation of radio/checkbox
+  marginRight: -11
+}, o.labelPlacement === "top" && {
+  flexDirection: "column-reverse",
+  marginLeft: 16
+}, o.labelPlacement === "bottom" && {
+  flexDirection: "column",
+  marginLeft: 16
+}, {
+  [`& .${L.label}`]: {
+    [`&.${L.disabled}`]: {
+      color: (n.vars || n).palette.text.disabled
+    }
+  }
+})), Io = $("span", {
+  name: "MuiFormControlLabel",
+  slot: "Asterisk",
+  overridesResolver: (n, o) => o.asterisk
+})(({
+  theme: n
+}) => ({
+  [`&.${L.error}`]: {
+    color: (n.vars || n).palette.error.main
+  }
+})), ye = /* @__PURE__ */ V.forwardRef(function(o, t) {
+  var a, c;
+  const r = H({
+    props: o,
+    name: "MuiFormControlLabel"
+  }), {
+    className: u,
+    componentsProps: m = {},
+    control: d,
+    disabled: i,
+    disableTypography: b,
+    label: y,
+    labelPlacement: x = "end",
+    required: f,
+    slotProps: h = {}
+  } = r, C = _(r, Po), s = fe(), p = (a = i ?? d.props.disabled) != null ? a : s == null ? void 0 : s.disabled, v = f ?? d.props.required, O = {
+    disabled: p,
+    required: v
+  };
+  ["checked", "name", "onChange", "value", "inputRef"].forEach((w) => {
+    typeof d.props[w] > "u" && typeof r[w] < "u" && (O[w] = r[w]);
+  });
+  const P = de({
+    props: r,
+    muiFormControl: s,
+    states: ["error"]
+  }), T = g({}, r, {
+    disabled: p,
+    labelPlacement: x,
+    required: v,
+    error: P.error
+  }), j = Oo(T), k = (c = h.typography) != null ? c : m.typography;
+  let I = y;
+  return I != null && I.type !== re && !b && (I = /* @__PURE__ */ l(re, g({
+    component: "span"
+  }, k, {
+    className: S(j.label, k == null ? void 0 : k.className),
+    children: I
+  }))), /* @__PURE__ */ F(Fo, g({
+    className: S(j.root, u),
+    ownerState: T,
+    ref: t
+  }, C, {
+    children: [/* @__PURE__ */ V.cloneElement(d, O), v ? /* @__PURE__ */ F(ge, {
+      display: "block",
+      children: [I, /* @__PURE__ */ F(Io, {
+        ownerState: T,
+        "aria-hidden": !0,
+        className: j.asterisk,
+        children: [" ", "*"]
+      })]
+    }) : I]
+  }));
+});
+process.env.NODE_ENV !== "production" && (ye.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * If `true`, the component appears selected.
+   */
+  checked: e.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  componentsProps: e.shape({
+    typography: e.object
+  }),
+  /**
+   * A control element. For instance, it can be a `Radio`, a `Switch` or a `Checkbox`.
+   */
+  control: e.element.isRequired,
+  /**
+   * If `true`, the control is disabled.
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, the label is rendered as it is passed without an additional typography node.
+   */
+  disableTypography: e.bool,
+  /**
+   * Pass a ref to the `input` element.
+   */
+  inputRef: be,
+  /**
+   * A text or an element to be used in an enclosing label element.
+   */
+  label: e.node,
+  /**
+   * The position of the label.
+   * @default 'end'
+   */
+  labelPlacement: e.oneOf(["bottom", "end", "start", "top"]),
+  /**
+   * @ignore
+   */
+  name: e.string,
+  /**
+   * Callback fired when the state is changed.
+   *
+   * @param {React.SyntheticEvent} event The event source of the callback.
+   * You can pull out the new checked state by accessing `event.target.checked` (boolean).
+   */
+  onChange: e.func,
+  /**
+   * If `true`, the label will indicate that the `input` is required.
+   */
+  required: e.bool,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: e.shape({
+    typography: e.object
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * The value of the component.
+   */
+  value: e.any
+});
+function Ro({
+  property: n,
+  mapboxAccessToken: o,
+  value: t,
+  variant: a = "standard",
+  size: c = "medium",
+  onChange: r
+}) {
+  var x;
+  const u = _e(!1), [m, d] = We(), i = (f) => {
+    d(M.get(f, n.propertyId));
+  }, b = () => {
+    r([...t || [], m]), d(""), u.action.close();
+  }, y = (f) => () => {
+    if (t) {
+      let h = [...t];
+      h.splice(f, 1), r(h);
+    }
+  };
+  return /* @__PURE__ */ F(ae, { children: [
+    /* @__PURE__ */ F($e, { variant: a, children: [
+      /* @__PURE__ */ l(ce, { children: n.name }),
+      /* @__PURE__ */ l(De, { children: M.isArray(t) && t.map((f, h) => {
+        var C, s;
+        return /* @__PURE__ */ l(
+          Re,
+          {
+            label: ((s = (C = n.dataTypeInfo) == null ? void 0 : C.innerType) == null ? void 0 : s.type) === "date" ? ie(f).format("DD/MM/YYYY HH:mm:ss") : f,
+            size: c,
+            onDelete: y(h)
+          },
+          h
+        );
+      }) }),
+      /* @__PURE__ */ l(
+        qe,
+        {
+          startIcon: /* @__PURE__ */ l(Ee, {}),
+          variant: "text",
+          onClick: u.action.open,
+          children: "Add"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ F(
+      Ve,
+      {
+        open: u.state.isOpen,
+        onClose: u.action.close,
+        maxWidth: "sm",
+        fullWidth: !0,
+        children: [
+          /* @__PURE__ */ l(ke, { children: "Add List Value" }),
+          /* @__PURE__ */ l(we, { children: (x = n.dataTypeInfo) != null && x.innerType ? /* @__PURE__ */ l(
+            Vo,
+            {
+              mapboxAccessToken: o,
+              property: {
+                ...n,
+                name: "Value",
+                type: n.dataTypeInfo.innerType.type
+              },
+              value: m,
+              onChange: i
+            }
+          ) : null }),
+          /* @__PURE__ */ F(je, { children: [
+            /* @__PURE__ */ l(
+              oe,
+              {
+                variant: "contained",
+                color: "inherit",
+                onClick: u.action.close,
+                children: "Cancel"
+              }
+            ),
+            /* @__PURE__ */ l(oe, { variant: "contained", color: "primary", onClick: b, children: "Ok" })
+          ] })
+        ]
+      }
+    )
+  ] });
+}
+function Vo({
+  mapboxAccessToken: n,
+  property: o,
+  value: t,
+  variant: a = "standard",
+  size: c = "medium",
+  disableMargin: r = !1,
+  defaultExtent: u,
+  // keyAuth,
+  onChange: m
+}) {
+  var C;
+  const d = (s) => {
+    const v = s.target.value.split(",").map((O) => O.trimStart());
+    m({
+      [o.propertyId]: v
+    });
+  }, i = (s) => {
+    const { name: p, type: v, checked: O, value: P } = s.target;
+    let T = P;
+    o.type === "double" && (T = T.replace(",", "."), T = T.replace(/[^\d.-]+/g, "")), m({
+      [p]: v === "checkbox" ? O : T
+    });
+  }, b = (s) => {
+    m({
+      [o.propertyId]: s
+    });
+  }, y = (s) => {
+    m({
+      [o.propertyId]: s.target.value
+    });
+  }, x = (s) => (p) => {
+    m({
+      [s]: p
+    });
+  }, f = (s) => (p) => {
+    m({
+      [s]: p
+    });
+  }, h = (s) => (p) => {
+    m({
+      [s]: p
+    });
+  };
+  if ([
+    "string",
+    "integer",
+    "double",
+    "text",
+    "long",
+    "byte",
+    "bank-account"
+  ].includes(o.type))
+    return /* @__PURE__ */ l(
+      Y,
+      {
+        label: o.name,
+        name: o.propertyId,
+        value: t ?? o.defaultValue ?? "",
+        defaultValue: t,
+        onChange: i,
+        variant: a,
+        type: "text",
+        multiline: o.type === "text",
+        disabled: !o.editable,
+        fullWidth: !0,
+        sx: { mb: r ? 0 : 2 },
+        InputProps: {
+          size: c,
+          ...o.privacyPreservationMethod === "ENCRYPTION" ? {
+            endAdornment: /* @__PURE__ */ l(Ne, { position: "end", children: /* @__PURE__ */ l(Le, { title: "Encrypted Field", children: /* @__PURE__ */ l(Me, {}) }) })
+          } : {}
+        }
+      }
+    );
+  if (o.type === "date") {
+    const s = t !== void 0 ? ie(t).format() : "";
+    return /* @__PURE__ */ F(Se, { mb: r ? 0 : 2, children: [
+      /* @__PURE__ */ l(ce, { variant: "subtitle2", children: o.name }),
+      /* @__PURE__ */ l(
+        He,
+        {
+          value: s,
+          variant: a,
+          size: c,
+          name: o.propertyId,
+          onChange: b
+        }
+      )
+    ] });
+  }
+  if (o.type === "list") {
+    let s = "";
+    return o.defaultValue && (s = M.isArray(o.defaultValue) ? t.join(", ") : o.defaultValue), t && (s = M.isArray(t) ? t.join(",") : t), /* @__PURE__ */ l(
+      Y,
+      {
+        label: o.name,
+        name: o.propertyId,
+        value: s,
+        onChange: d,
+        variant: a,
+        disabled: !o.editable,
+        fullWidth: !0,
+        helperText: c === "small" ? null : "Add list values with the comma (,) separated string",
+        sx: { mb: r ? 0 : 2 },
+        InputProps: {
+          size: c,
+          placeholder: c === "small" ? "Add list values with the comma (,) separated string" : ""
+        }
+      }
+    );
+  }
+  if (o.type === "boolean")
+    return /* @__PURE__ */ l(E, { mb: r ? 0 : 2, children: /* @__PURE__ */ l(
+      ye,
+      {
+        control: /* @__PURE__ */ l(
+          oo,
+          {
+            name: o.propertyId,
+            checked: !!t,
+            onChange: i,
+            size: c
+          }
+        ),
+        label: o.name
+      }
+    ) });
+  if (o.type === "enum") {
+    let s = [];
+    return (C = o.dataTypeInfo) != null && C.enumValues && (s = o.dataTypeInfo.enumValues), /* @__PURE__ */ F(
+      ue,
+      {
+        fullWidth: !0,
+        variant: a,
+        sx: { mb: r ? 0 : 2 },
+        size: c,
+        children: [
+          /* @__PURE__ */ l(me, { id: `${o.propertyId}-label`, children: o.name }),
+          /* @__PURE__ */ l(
+            pe,
+            {
+              label: o.name,
+              name: o.name,
+              labelId: `${o.propertyId}-label`,
+              id: o.propertyId,
+              value: t ?? "",
+              onChange: y,
+              children: s.map((p, v) => /* @__PURE__ */ l(Xe, { value: p, children: p }, v))
+            }
+          )
+        ]
+      }
+    );
+  }
+  return o.type === "geometry" ? /* @__PURE__ */ l(E, { sx: { mb: r ? 0 : 2, width: "100%" }, children: /* @__PURE__ */ l(
+    Be,
+    {
+      mapboxAccessToken: n,
+      label: o.name,
+      value: t ?? o.defaultValue ?? "",
+      defaultExtent: u,
+      onChange: x(o.propertyId)
+    }
+  ) }) : o.type === "phone-number" ? /* @__PURE__ */ l(E, { sx: { mb: r ? 0 : 2, width: "100%" }, children: /* @__PURE__ */ l(
+    Ae,
+    {
+      label: o.name,
+      placeholder: "Enter phone number",
+      value: t ?? o.defaultValue ?? "",
+      onChange: f(o.propertyId)
+    }
+  ) }) : o.type === "composite-list" ? /* @__PURE__ */ l(E, { sx: { mb: r ? 0 : 2, width: "100%" }, children: /* @__PURE__ */ l(
+    Ro,
+    {
+      property: o,
+      value: t ?? o.defaultValue ?? "",
+      variant: a,
+      size: c,
+      mapboxAccessToken: n,
+      onChange: h(o.propertyId)
+    }
+  ) }) : /* @__PURE__ */ l(ae, {});
+}
+export {
+  Ro as C,
+  Vo as V
+};