@hybridcore/ui 1.0.2 → 1.1.0

package/dist/components/data-management/instance-form/components/composite-list/index.js

@@ -0,0 +1,12 @@
+import "react/jsx-runtime";
+import "@mui/material";
+import "./styled.js";
+import "@mui/icons-material";
+import "../../../../../hooks/useToggle.js";
+import { C as l } from "../../../../../index-DHFb1Qpn.js";
+import "react";
+import "lodash";
+import "dayjs";
+export {
+  l as default
+};

package/dist/components/data-management/instance-form/components/composite-list/styled.js

@@ -0,0 +1,64 @@
+import { styled as i, Box as n, Button as r } from "@mui/material";
+const p = i(n)(({ theme: o, variant: t }) => ({
+  position: "relative",
+  width: "100%",
+  ...t === "outlined" ? {
+    border: "1px solid",
+    padding: "2.5px 60px 2.5px 2.5px",
+    borderRadius: o.spacing(0.5),
+    "& .MuiButton-root": {
+      margin: "7px 8px"
+    }
+  } : {
+    borderBottom: "1px solid",
+    paddingBottom: o.spacing(0.5)
+  },
+  borderColor: o.palette.action.disabled,
+  "&:hover": {
+    borderColor: o.palette.action.active
+  }
+})), d = i(n)(({ theme: o }) => ({
+  minHeight: 33,
+  whiteSpace: "normal",
+  "& .MuiChip-root": {
+    marginRight: o.spacing(0.5),
+    marginTop: o.spacing(0.5)
+  },
+  "& .MuiChip-root:first-of-type": {
+    marginLeft: 0
+  }
+})), e = i(r)(({ theme: o, variant: t }) => ({
+  position: "absolute",
+  top: 0,
+  right: 0,
+  fontSize: 10,
+  padding: "3px 8px",
+  minWidth: "auto",
+  boxShadow: o.shadows[1],
+  textTransform: "none",
+  borderRadius: 13,
+  marginLeft: o.spacing(0.5),
+  "& .MuiButton-startIcon": {
+    marginRight: 0.25,
+    "&  > :nth-of-type(1)": {
+      fontSize: 14
+    }
+  },
+  ...t === "contained" && {
+    "&:hover": {
+      backgroundColor: o.palette.grey[300],
+      boxShadow: o.shadows[1]
+    }
+  },
+  ...t === "text" && {
+    backgroundColor: o.palette.common.white,
+    "&:hover": {
+      backgroundColor: o.palette.grey[300]
+    }
+  }
+}));
+export {
+  p as Container,
+  e as MiniButton,
+  d as Values
+};

package/dist/components/data-management/instance-form/components/policy-list/index.js

@@ -0,0 +1,86 @@
+import { jsxs as s, jsx as i } from "react/jsx-runtime";
+import { Box as p, FormLabel as c } from "@mui/material";
+import m from "react-select";
+const f = ({
+  policyList: n,
+  value: l = [],
+  showError: t = !1,
+  variant: e = "standart",
+  onChange: r
+}) => {
+  const d = (o) => {
+    r(o.map((a) => a.id));
+  };
+  return /* @__PURE__ */ s(
+    p,
+    {
+      sx: {
+        mb: 2,
+        ...e === "outlined" && {
+          position: "relative",
+          mt: 1.5,
+          zIndex: 9
+        }
+      },
+      children: [
+        /* @__PURE__ */ i(
+          c,
+          {
+            sx: {
+              display: "block",
+              ...t && {
+                color: (o) => o.palette.error.main
+              },
+              ...e === "outlined" && {
+                position: "absolute",
+                fontSize: "small",
+                zIndex: 1,
+                bgcolor: (o) => o.palette.background.paper,
+                ml: 1.5,
+                mt: "-9px",
+                px: 0.5
+              }
+            },
+            children: "Policy List"
+          }
+        ),
+        /* @__PURE__ */ i(
+          m,
+          {
+            value: n.filter((o) => l.includes(o.id)),
+            options: n,
+            isMulti: !0,
+            onChange: d,
+            menuPosition: "fixed",
+            getOptionLabel: (o) => o.name ?? o.key,
+            getOptionValue: (o) => String(o.id),
+            styles: {
+              control: (o) => ({
+                ...o,
+                boxShadow: "none",
+                ...e === "standart" && {
+                  border: "none",
+                  borderBottom: "1px solid",
+                  borderRadius: 0,
+                  borderColor: "rgba(0, 0, 0, 0.42)"
+                },
+                ...t && { color: "#c00", borderColor: "#c00" }
+              }),
+              valueContainer: (o) => ({
+                ...o,
+                fontSize: "1rem",
+                ...e === "standart" ? { paddingLeft: 0 } : {
+                  padding: "6px 0px 3px 8px"
+                },
+                ...t && { color: "#c00" }
+              })
+            }
+          }
+        )
+      ]
+    }
+  );
+};
+export {
+  f as default
+};

package/dist/components/data-management/instance-form/components/variable/index.js

@@ -0,0 +1,15 @@
+import "react/jsx-runtime";
+import "lodash";
+import "dayjs";
+import { V as x } from "../../../../../index-DHFb1Qpn.js";
+import "@mui/material";
+import "@mui/icons-material";
+import "../../../../geometry-picker/index.js";
+import "../../../../phone-input/index.js";
+import "../../../../date-time-picker/index.js";
+import "../../../../../Checkbox-CxbQ9tJ5.js";
+import "../../../../../FormControl-C4PmH1vh.js";
+import "../../../../../Select-DOyHt8I_.js";
+export {
+  x as default
+};

package/dist/components/data-management/instance-form/components/variables/index.js

@@ -0,0 +1,39 @@
+import { jsx as t, Fragment as i } from "react/jsx-runtime";
+import l from "react";
+import { V as m } from "../../../../../index-DHFb1Qpn.js";
+import d from "lodash";
+function h({
+  template: o,
+  value: n,
+  mapboxAccessToken: a,
+  onChange: s
+}) {
+  if (o === void 0) return /* @__PURE__ */ t(i, {});
+  const p = l.useMemo(() => {
+    let r = o.properties.filter((e) => e.visible);
+    return r = d.orderBy(r, "id"), r;
+  }, [o]), u = (r) => {
+    const e = {
+      target: {
+        value: { ...n, ...r }
+      }
+    };
+    s(e);
+  };
+  return /* @__PURE__ */ t(i, { children: p.map((r, e) => {
+    const f = n[r.propertyId];
+    return /* @__PURE__ */ t(
+      m,
+      {
+        property: r,
+        value: f,
+        mapboxAccessToken: a,
+        onChange: u
+      },
+      e
+    );
+  }) });
+}
+export {
+  h as default
+};

package/dist/components/data-management/instance-form/index.js

@@ -0,0 +1,437 @@
+import { jsx as a, jsxs as f, Fragment as P } from "react/jsx-runtime";
+import m from "react";
+import W from "lodash";
+import { useForm as M, Controller as s } from "react-hook-form";
+import { getNestedChildrenFromMap as N } from "../../../utils/ontology.js";
+import { i as G, d as K } from "../../../utils-Bq0ye5vf.js";
+import { ConditionalWrapper as O } from "../../conditional-wrapper/index.js";
+import { Container as U } from "../../container/index.js";
+import { TextField as h, FormGroup as j, FormControl as q, InputLabel as H, Select as Y, MenuItem as J, FormControlLabel as L, Checkbox as S, Box as T, Button as g } from "@mui/material";
+import { TreeSelect as $ } from "../../tree-select/index.js";
+import Q from "./components/policy-list/index.js";
+import X from "./components/variables/index.js";
+import { DisseminationList as z } from "../../data-security-selectors/dissemination-list/index.js";
+import { SecurityLevel as Z } from "../../data-security-selectors/security-level/index.js";
+const ee = {
+  alg: "A256GCM",
+  ext: !0,
+  k: "_El6rHQxC5E7NdO5DiMDITjF7f65wrlaJmFVagVE9Ic",
+  key_ops: ["encrypt", "decrypt"],
+  kty: "oct"
+}, te = [
+  "IMAGE",
+  "VIDEO",
+  "TEXT",
+  "BINARY",
+  "OTHER"
+];
+function ae(e, F) {
+  const {
+    register: C,
+    handleSubmit: E,
+    control: d,
+    formState: { errors: V },
+    getValues: x,
+    setValue: p,
+    reset: k
+  } = M({
+    defaultValues: e.defaultValues
+  }), [R, _] = m.useState([]), [v, I] = m.useState(), [ne, w] = m.useState(0), B = m.useMemo(() => {
+    const t = [];
+    return e.mappedTemplates.forEach((n) => {
+      n.creatable || t.push(String(n.id));
+    }), t;
+  }, [e.mappedTemplates]);
+  m.useEffect(() => {
+    (async () => {
+      let t = { ...e.defaultValues };
+      const n = e.mappedTemplates.get(t.templateId);
+      if (n) {
+        const l = n.properties.filter(
+          (r) => r.privacyPreservationMethod === "ENCRYPTION"
+        );
+        if (l.length > 0)
+          for (let r = 0; r < l.length; r++) {
+            const i = l[r], o = W.get(t, `variables.${i.propertyId}`);
+            if (o && e.keyAuth) {
+              const c = await G(ee), u = await K(c, o);
+              u.data && (p(`variables.${i.propertyId}`, u.data), w((b) => b + 1));
+            }
+          }
+      }
+    })();
+  }, [e.defaultValues, e.mappedTemplates, e.keyAuth]);
+  const y = () => {
+    const t = x("templateId");
+    v && I(void 0);
+    const n = N(e.mappedTemplates);
+    _(n);
+    for (let l of e.mappedTemplates.values())
+      if (l.id === t) {
+        I(l);
+        break;
+      }
+  };
+  m.useImperativeHandle(F, () => ({
+    resetForm() {
+      k({
+        title: "",
+        description: "",
+        templateId: 0,
+        variables: {}
+      }), y();
+    },
+    setFormValue(t, n) {
+      p(t, n);
+    },
+    getFormValue(t) {
+      return x(t);
+    }
+  })), m.useEffect(() => (y(), () => {
+  }), [e.mappedTemplates]), m.useEffect(() => {
+    e.onSelectedTemplateChange && e.onSelectedTemplateChange(v);
+  }, [v]);
+  const A = () => {
+    if (e.onCancel) {
+      e.onCancel();
+      return;
+    }
+  };
+  return /* @__PURE__ */ a(
+    O,
+    {
+      condition: e.variant === void 0 || e.variant === "inline",
+      wrapper: (t) => /* @__PURE__ */ a(
+        U,
+        {
+          disableHeader: !0,
+          sx: { position: "relative", overflow: "visible" },
+          children: t
+        }
+      ),
+      children: /* @__PURE__ */ f("form", { onSubmit: E(e.onSubmit), children: [
+        /* @__PURE__ */ a(
+          h,
+          {
+            label: "Title *",
+            variant: "standard",
+            fullWidth: !0,
+            sx: { mb: 2 },
+            ...C("title", { required: !0 }),
+            ...V.title && {
+              helperText: "This field is required!",
+              error: !0
+            }
+          }
+        ),
+        /* @__PURE__ */ a(
+          h,
+          {
+            label: "Description",
+            variant: "standard",
+            fullWidth: !0,
+            multiline: !0,
+            sx: { mb: 2 },
+            ...C("description")
+          }
+        ),
+        /* @__PURE__ */ a(j, { sx: { mb: 2 }, children: /* @__PURE__ */ a(
+          s,
+          {
+            name: "templateId",
+            control: d,
+            render: ({ field: { value: t, onChange: n } }) => {
+              if (e.disableTemplateChange) {
+                const l = e.mappedTemplates.get(t);
+                return /* @__PURE__ */ a(
+                  h,
+                  {
+                    label: "Template",
+                    variant: "standard",
+                    fullWidth: !0,
+                    disabled: !0,
+                    value: l == null ? void 0 : l.name,
+                    InputLabelProps: { shrink: !0 }
+                  }
+                );
+              }
+              return /* @__PURE__ */ a(
+                $,
+                {
+                  label: "Template",
+                  data: R,
+                  selected: t === 0 ? "" : [String(t)],
+                  disabled: B,
+                  onChange: (l, r) => {
+                    const i = {
+                      target: {
+                        value: r ? Number(l) : 0
+                      }
+                    };
+                    n(i), y();
+                  }
+                }
+              );
+            }
+          }
+        ) }),
+        "aliasList" in e.defaultValues && /* @__PURE__ */ a(
+          s,
+          {
+            name: "aliasList",
+            control: d,
+            render: ({ field: { value: t, onChange: n, ...l } }) => /* @__PURE__ */ a(
+              h,
+              {
+                label: "Alias List",
+                variant: "standard",
+                fullWidth: !0,
+                value: t,
+                sx: { mb: 2 },
+                helperText: "Add list values with the comma (,) separated string",
+                onChange: (i) => {
+                  const u = {
+                    target: {
+                      value: i.target.value.split(",").map((b) => b.trimStart())
+                    }
+                  };
+                  n(u);
+                },
+                ...l
+              }
+            )
+          }
+        ),
+        "appliedPolicies" in e.defaultValues && /* @__PURE__ */ a(
+          s,
+          {
+            name: "appliedPolicies",
+            control: d,
+            render: ({ field: { value: t, onChange: n } }) => /* @__PURE__ */ a(
+              Q,
+              {
+                policyList: e.policyList,
+                value: t,
+                onChange: n
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ a(
+          s,
+          {
+            name: "variables",
+            control: d,
+            render: ({ field: { value: t, onChange: n } }) => /* @__PURE__ */ a(
+              X,
+              {
+                template: v,
+                value: t,
+                mapboxAccessToken: "",
+                onChange: n
+              }
+            )
+          }
+        ),
+        "fileInBase64" in e.defaultValues && /* @__PURE__ */ f(P, { children: [
+          /* @__PURE__ */ a(
+            s,
+            {
+              name: "fileInBase64",
+              control: d,
+              render: ({ field: { value: t, onChange: n, ...l } }) => /* @__PURE__ */ a(
+                h,
+                {
+                  type: "file",
+                  label: "File to Upload",
+                  variant: "standard",
+                  fullWidth: !0,
+                  sx: { mb: 2 },
+                  helperText: "Select a file to upload",
+                  InputLabelProps: { shrink: !0 },
+                  onChange: (i) => {
+                    if (i.target.files) {
+                      const o = new FileReader();
+                      o.onload = async (u) => {
+                        const D = u.target.result.split("base64,")[1];
+                        n(D);
+                      };
+                      const c = i.target.files[0];
+                      p("originalFileName", c.name), p("contentType", c.type), o.readAsDataURL(c);
+                    }
+                  },
+                  ...l
+                }
+              )
+            }
+          ),
+          /* @__PURE__ */ a(
+            s,
+            {
+              name: "type",
+              control: d,
+              render: ({ field: { value: t, onChange: n } }) => /* @__PURE__ */ f(
+                q,
+                {
+                  fullWidth: !0,
+                  sx: {
+                    mb: 2
+                  },
+                  variant: "standard",
+                  children: [
+                    /* @__PURE__ */ a(H, { children: "Type" }),
+                    /* @__PURE__ */ a(Y, { value: t, onChange: (r) => {
+                      const {
+                        target: { value: i }
+                      } = r;
+                      n(i);
+                    }, children: te.map((r) => /* @__PURE__ */ a(J, { value: r, children: r }, r)) })
+                  ]
+                }
+              )
+            }
+          ),
+          /* @__PURE__ */ a(
+            L,
+            {
+              control: /* @__PURE__ */ a(
+                s,
+                {
+                  name: "redacted",
+                  control: d,
+                  render: ({ field: { value: t, ...n } }) => /* @__PURE__ */ a(S, { checked: !!t, ...n })
+                }
+              ),
+              label: "Redacted",
+              sx: { mb: 2 }
+            }
+          ),
+          /* @__PURE__ */ a(
+            L,
+            {
+              control: /* @__PURE__ */ a(
+                s,
+                {
+                  name: "contentEncrypted",
+                  control: d,
+                  render: ({ field: { value: t, ...n } }) => /* @__PURE__ */ a(S, { checked: !!t, ...n })
+                }
+              ),
+              label: "Content Encrypted",
+              sx: { mb: 2 }
+            }
+          )
+        ] }),
+        /* @__PURE__ */ a(
+          s,
+          {
+            name: "disseminationList",
+            rules: {
+              required: !0
+            },
+            control: d,
+            render: ({ field: { value: t, onChange: n }, fieldState: l }) => {
+              const r = t || [], i = (o) => {
+                n(o);
+              };
+              return /* @__PURE__ */ a(
+                z,
+                {
+                  selectedIds: r,
+                  memberedGroups: e.memberedGroups,
+                  showError: !!l.error,
+                  onChange: i
+                }
+              );
+            }
+          }
+        ),
+        /* @__PURE__ */ a(T, { mt: 2, children: /* @__PURE__ */ a(
+          s,
+          {
+            name: "securityLevelId",
+            rules: {
+              required: !0
+            },
+            control: d,
+            render: ({ field: { value: t, onChange: n }, fieldState: l }) => {
+              var i, o;
+              const r = (c) => {
+                n(c);
+              };
+              return /* @__PURE__ */ a(
+                Z,
+                {
+                  value: t,
+                  ontologyId: e.ontologyId,
+                  appRoles: e.appRoles,
+                  securityLevels: e.securityLevels,
+                  minLevelId: e.minSecurityLevel,
+                  templateKeys: (i = e.securityLevelConfig) == null ? void 0 : i.templateKeys,
+                  templateType: (o = e.securityLevelConfig) == null ? void 0 : o.templateType,
+                  showError: !!l.error,
+                  onChange: r
+                }
+              );
+            }
+          }
+        ) }),
+        /* @__PURE__ */ f(T, { display: "flex", justifyContent: "space-between", mt: 3, children: [
+          /* @__PURE__ */ a(
+            g,
+            {
+              color: "primary",
+              variant: "text",
+              disabled: e.loading,
+              sx: { textTransform: "none" },
+              onClick: A,
+              children: "Cancel"
+            }
+          ),
+          /* @__PURE__ */ f(T, { children: [
+            e.onRemove !== void 0 && /* @__PURE__ */ a(
+              g,
+              {
+                type: "button",
+                color: "error",
+                variant: "contained",
+                disabled: e.removeLoading || e.loading,
+                sx: { mr: 2, textTransform: "none" },
+                onClick: e.onRemove,
+                children: e.removeLoading ? "Deleting..." : "Delete"
+              }
+            ),
+            e.saveButtons ? e.saveButtons.map((t, n) => /* @__PURE__ */ a(
+              g,
+              {
+                type: "submit",
+                color: "primary",
+                variant: "contained",
+                disabled: e.loading,
+                startIcon: t.icon,
+                sx: { ml: 1, textTransform: "none" },
+                onClick: t.onClick,
+                children: t.label
+              },
+              n
+            )) : /* @__PURE__ */ a(
+              g,
+              {
+                type: "submit",
+                color: "primary",
+                variant: "contained",
+                disabled: e.loading,
+                sx: { textTransform: "none" },
+                children: e.loading ? "Saving..." : "Save"
+              }
+            )
+          ] })
+        ] })
+      ] })
+    }
+  );
+}
+const ge = m.forwardRef(ae);
+export {
+  ge as InstanceForm
+};