@hybridcore/ui 1.0.2 → 1.1.2

package/dist/useFormControl-CatNKXAi.js

@@ -0,0 +1,10 @@
+import * as o from "react";
+const t = /* @__PURE__ */ o.createContext(void 0);
+process.env.NODE_ENV !== "production" && (t.displayName = "FormControlContext");
+function e() {
+  return o.useContext(t);
+}
+export {
+  t as F,
+  e as u
+};

package/dist/useId-BHG98T5I.js

@@ -0,0 +1,26 @@
+import * as u from "react";
+function f(...t) {
+  return t.reduce((n, e) => e == null ? n : function(...a) {
+    n.apply(this, a), e.apply(this, a);
+  }, () => {
+  });
+}
+let c = 0;
+function s(t) {
+  const [n, e] = u.useState(t), o = t || n;
+  return u.useEffect(() => {
+    n == null && (c += 1, e(`mui-${c}`));
+  }, [n]), o;
+}
+const l = u.useId;
+function i(t) {
+  if (l !== void 0) {
+    const n = l();
+    return t ?? n;
+  }
+  return s(t);
+}
+export {
+  f as c,
+  i as u
+};

package/dist/useTheme-C0Dky5rV.js

@@ -0,0 +1,17 @@
+import * as n from "react";
+import { ThemeContext as o } from "@emotion/react";
+import { a as m } from "./createTheme-agWfFD64.js";
+function r(e) {
+  return Object.keys(e).length === 0;
+}
+function s(e = null) {
+  const t = n.useContext(o);
+  return !t || r(t) ? e : t;
+}
+const u = m();
+function f(e = u) {
+  return s(e);
+}
+export {
+  f as u
+};

package/dist/useTheme-CeyGVuQP.js

@@ -0,0 +1,10 @@
+import * as o from "react";
+import { d as r, T as s } from "./styled-Iq9jsO4F.js";
+import { u as t } from "./useTheme-C0Dky5rV.js";
+function a() {
+  const e = t(r);
+  return process.env.NODE_ENV !== "production" && o.useDebugValue(e), e[s] || e;
+}
+export {
+  a as u
+};

package/dist/useThemeProps-CzAjOL6F.js

@@ -0,0 +1,26 @@
+import { r as n } from "./chainPropTypes-DtBfUj5o.js";
+import { u as p } from "./useTheme-C0Dky5rV.js";
+function m(t) {
+  const {
+    theme: e,
+    name: o,
+    props: r
+  } = t;
+  return !e || !e.components || !e.components[o] || !e.components[o].defaultProps ? r : n(e.components[o].defaultProps, r);
+}
+function P({
+  props: t,
+  name: e,
+  defaultTheme: o,
+  themeId: r
+}) {
+  let s = p(o);
+  return r && (s = s[r] || s), m({
+    theme: s,
+    name: e,
+    props: t
+  });
+}
+export {
+  P as u
+};

package/dist/utils/ontology.js

@@ -0,0 +1,37 @@
+import p from "lodash";
+const m = (e, i = !0) => {
+  let n = [];
+  const s = e.values();
+  for (let t of s)
+    (t.parent === null || !e.has(t.parent)) && n.push(t.templateKey);
+  const c = (t) => {
+    let l = [];
+    const r = e.get(t);
+    if (r && r.childrenKeys)
+      for (let u of r.childrenKeys) {
+        let f = c(u), o = e.get(u);
+        o && (f.length && (o.children = f), l.push(o));
+      }
+    return l;
+  };
+  let h = [];
+  return n.forEach((t) => {
+    let l = e.get(t);
+    if (l) {
+      const r = c(t);
+      l.children = r, i && l.parent === null ? h.push(...l.children) : h.push(l);
+    }
+  }), p.uniqBy(h, "id");
+}, d = (e) => {
+  let i = [];
+  for (let n in e)
+    if (i.push(e[n]), e[n].children) {
+      const s = d(e[n].children);
+      i.push(...s);
+    }
+  return i;
+};
+export {
+  d as flattenNestedTemplates,
+  m as getNestedChildrenFromMap
+};

package/dist/utils-Bq0ye5vf.js

@@ -0,0 +1,115 @@
+async function c() {
+  const e = {
+    challenge: new Uint8Array([583, 3, 100]),
+    rp: { id: window.location.hostname, name: "Smart Navigator" },
+    user: {
+      id: new TextEncoder().encode("hybridcore"),
+      name: "info@hybridcore.eu",
+      displayName: "Hybrid Core"
+    },
+    pubKeyCredParams: [{ type: "public-key", alg: -7 }]
+  };
+  return await navigator.credentials.create({ publicKey: e });
+}
+async function i(e) {
+  const r = {
+    challenge: new Uint8Array([583, 3, 100]),
+    rpId: window.location.hostname,
+    userVerification: "required",
+    allowCredentials: [
+      {
+        type: "public-key",
+        id: e
+      }
+    ]
+  };
+  return await navigator.credentials.get({
+    publicKey: r
+  }), !0;
+}
+async function s() {
+  return await crypto.subtle.generateKey(
+    { name: "AES-GCM", length: 256 },
+    !0,
+    ["encrypt", "decrypt"]
+  );
+}
+async function y(e, r) {
+  try {
+    const t = new TextEncoder().encode(r), { ciphertext: n, iv: a } = await p(e, t);
+    return {
+      status: "SUCCESS",
+      data: window.btoa(
+        a.toString() + ":" + new Uint8Array(n).toString()
+      )
+    };
+  } catch (t) {
+    let n = "Encryption error!";
+    return (t.name === "NotAllowedError" || t.name === "TimeoutError") && (n = "User interaction required or operation timed out."), {
+      status: "ERROR",
+      message: n
+    };
+  }
+}
+async function d(e, r) {
+  try {
+    const t = window.atob(r).split(":"), n = new Uint8Array(t[0].split(",")), a = new Uint8Array(t[1].split(",")).buffer, o = await u(e, a, n);
+    return {
+      status: "SUCCESS",
+      data: new TextDecoder().decode(o)
+    };
+  } catch (t) {
+    let n = "Decryption error!";
+    return (t.name === "NotAllowedError" || t.name === "TimeoutError") && (n = "User interaction required or operation timed out."), console.log(t), {
+      status: "ERROR",
+      message: n
+    };
+  }
+}
+async function p(e, r) {
+  const t = crypto.getRandomValues(new Uint8Array(12));
+  return { ciphertext: await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv: t },
+    e,
+    r
+  ), iv: t };
+}
+async function u(e, r, t) {
+  return crypto.subtle.decrypt({ name: "AES-GCM", iv: t }, e, r);
+}
+async function l(e) {
+  return await window.crypto.subtle.exportKey("jwk", e);
+}
+async function w(e) {
+  return await window.crypto.subtle.importKey(
+    "jwk",
+    e,
+    {
+      name: "AES-GCM",
+      length: 256
+      // namedCurve: "P-384",
+    },
+    !0,
+    ["encrypt", "decrypt"]
+  );
+}
+const b = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  authenticate: i,
+  decrypt: d,
+  encrypt: y,
+  exportKey: l,
+  generateKey: s,
+  importKey: w,
+  register: c
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  b as S,
+  i as a,
+  l as b,
+  d,
+  y as e,
+  s as g,
+  w as i,
+  c as r
+};

package/dist/utils-DLpkeyhZ.js

@@ -0,0 +1,365 @@
+import { _ as D } from "./extends-C3382pL0.js";
+import { _ as C, T as S } from "./ButtonBase-BYmh3G5j.js";
+import { P as i } from "./createTheme-agWfFD64.js";
+import v from "react";
+import b from "react-dom";
+const N = {
+  disabled: !1
+};
+var R = process.env.NODE_ENV !== "production" ? i.oneOfType([i.number, i.shape({
+  enter: i.number,
+  exit: i.number,
+  appear: i.number
+}).isRequired]) : null;
+process.env.NODE_ENV !== "production" && i.oneOfType([i.string, i.shape({
+  enter: i.string,
+  exit: i.string,
+  active: i.string
+}), i.shape({
+  enter: i.string,
+  enterDone: i.string,
+  enterActive: i.string,
+  exit: i.string,
+  exitDone: i.string,
+  exitActive: i.string
+})]);
+var y = function(a) {
+  return a.scrollTop;
+}, x = "unmounted", f = "exited", c = "entering", h = "entered", T = "exiting", l = /* @__PURE__ */ function(u) {
+  C(a, u);
+  function a(r, e) {
+    var t;
+    t = u.call(this, r, e) || this;
+    var n = e, s = n && !n.isMounting ? r.enter : r.appear, p;
+    return t.appearStatus = null, r.in ? s ? (p = f, t.appearStatus = c) : p = h : r.unmountOnExit || r.mountOnEnter ? p = x : p = f, t.state = {
+      status: p
+    }, t.nextCallback = null, t;
+  }
+  a.getDerivedStateFromProps = function(e, t) {
+    var n = e.in;
+    return n && t.status === x ? {
+      status: f
+    } : null;
+  };
+  var o = a.prototype;
+  return o.componentDidMount = function() {
+    this.updateStatus(!0, this.appearStatus);
+  }, o.componentDidUpdate = function(e) {
+    var t = null;
+    if (e !== this.props) {
+      var n = this.state.status;
+      this.props.in ? n !== c && n !== h && (t = c) : (n === c || n === h) && (t = T);
+    }
+    this.updateStatus(!1, t);
+  }, o.componentWillUnmount = function() {
+    this.cancelNextCallback();
+  }, o.getTimeouts = function() {
+    var e = this.props.timeout, t, n, s;
+    return t = n = s = e, e != null && typeof e != "number" && (t = e.exit, n = e.enter, s = e.appear !== void 0 ? e.appear : n), {
+      exit: t,
+      enter: n,
+      appear: s
+    };
+  }, o.updateStatus = function(e, t) {
+    if (e === void 0 && (e = !1), t !== null)
+      if (this.cancelNextCallback(), t === c) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          var n = this.props.nodeRef ? this.props.nodeRef.current : b.findDOMNode(this);
+          n && y(n);
+        }
+        this.performEnter(e);
+      } else
+        this.performExit();
+    else this.props.unmountOnExit && this.state.status === f && this.setState({
+      status: x
+    });
+  }, o.performEnter = function(e) {
+    var t = this, n = this.props.enter, s = this.context ? this.context.isMounting : e, p = this.props.nodeRef ? [s] : [b.findDOMNode(this), s], d = p[0], m = p[1], g = this.getTimeouts(), O = s ? g.appear : g.enter;
+    if (!e && !n || N.disabled) {
+      this.safeSetState({
+        status: h
+      }, function() {
+        t.props.onEntered(d);
+      });
+      return;
+    }
+    this.props.onEnter(d, m), this.safeSetState({
+      status: c
+    }, function() {
+      t.props.onEntering(d, m), t.onTransitionEnd(O, function() {
+        t.safeSetState({
+          status: h
+        }, function() {
+          t.props.onEntered(d, m);
+        });
+      });
+    });
+  }, o.performExit = function() {
+    var e = this, t = this.props.exit, n = this.getTimeouts(), s = this.props.nodeRef ? void 0 : b.findDOMNode(this);
+    if (!t || N.disabled) {
+      this.safeSetState({
+        status: f
+      }, function() {
+        e.props.onExited(s);
+      });
+      return;
+    }
+    this.props.onExit(s), this.safeSetState({
+      status: T
+    }, function() {
+      e.props.onExiting(s), e.onTransitionEnd(n.exit, function() {
+        e.safeSetState({
+          status: f
+        }, function() {
+          e.props.onExited(s);
+        });
+      });
+    });
+  }, o.cancelNextCallback = function() {
+    this.nextCallback !== null && (this.nextCallback.cancel(), this.nextCallback = null);
+  }, o.safeSetState = function(e, t) {
+    t = this.setNextCallback(t), this.setState(e, t);
+  }, o.setNextCallback = function(e) {
+    var t = this, n = !0;
+    return this.nextCallback = function(s) {
+      n && (n = !1, t.nextCallback = null, e(s));
+    }, this.nextCallback.cancel = function() {
+      n = !1;
+    }, this.nextCallback;
+  }, o.onTransitionEnd = function(e, t) {
+    this.setNextCallback(t);
+    var n = this.props.nodeRef ? this.props.nodeRef.current : b.findDOMNode(this), s = e == null && !this.props.addEndListener;
+    if (!n || s) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+    if (this.props.addEndListener) {
+      var p = this.props.nodeRef ? [this.nextCallback] : [n, this.nextCallback], d = p[0], m = p[1];
+      this.props.addEndListener(d, m);
+    }
+    e != null && setTimeout(this.nextCallback, e);
+  }, o.render = function() {
+    var e = this.state.status;
+    if (e === x)
+      return null;
+    var t = this.props, n = t.children;
+    t.in, t.mountOnEnter, t.unmountOnExit, t.appear, t.enter, t.exit, t.timeout, t.addEndListener, t.onEnter, t.onEntering, t.onEntered, t.onExit, t.onExiting, t.onExited, t.nodeRef;
+    var s = D(t, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]);
+    return (
+      // allows for nested Transitions
+      /* @__PURE__ */ v.createElement(S.Provider, {
+        value: null
+      }, typeof n == "function" ? n(e, s) : v.cloneElement(v.Children.only(n), s))
+    );
+  }, a;
+}(v.Component);
+l.contextType = S;
+l.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * A React reference to DOM element that need to transition:
+   * https://stackoverflow.com/a/51127130/4671932
+   *
+   *   - When `nodeRef` prop is used, `node` is not passed to callback functions
+   *      (e.g. `onEnter`) because user already has direct access to the node.
+   *   - When changing `key` prop of `Transition` in a `TransitionGroup` a new
+   *     `nodeRef` need to be provided to `Transition` with changed `key` prop
+   *     (see
+   *     [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).
+   */
+  nodeRef: i.shape({
+    current: typeof Element > "u" ? i.any : function(u, a, o, r, e, t) {
+      var n = u[a];
+      return i.instanceOf(n && "ownerDocument" in n ? n.ownerDocument.defaultView.Element : Element)(u, a, o, r, e, t);
+    }
+  }),
+  /**
+   * A `function` child can be used instead of a React element. This function is
+   * called with the current transition status (`'entering'`, `'entered'`,
+   * `'exiting'`, `'exited'`), which can be used to apply context
+   * specific props to a component.
+   *
+   * ```jsx
+   * <Transition in={this.state.in} timeout={150}>
+   *   {state => (
+   *     <MyComponent className={`fade fade-${state}`} />
+   *   )}
+   * </Transition>
+   * ```
+   */
+  children: i.oneOfType([i.func.isRequired, i.element.isRequired]).isRequired,
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: i.bool,
+  /**
+   * By default the child component is mounted immediately along with
+   * the parent `Transition` component. If you want to "lazy mount" the component on the
+   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay
+   * mounted, even on "exited", unless you also specify `unmountOnExit`.
+   */
+  mountOnEnter: i.bool,
+  /**
+   * By default the child component stays mounted after it reaches the `'exited'` state.
+   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.
+   */
+  unmountOnExit: i.bool,
+  /**
+   * By default the child component does not perform the enter transition when
+   * it first mounts, regardless of the value of `in`. If you want this
+   * behavior, set both `appear` and `in` to `true`.
+   *
+   * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop
+   * > only adds an additional enter transition. However, in the
+   * > `<CSSTransition>` component that first enter transition does result in
+   * > additional `.appear-*` classes, that way you can choose to style it
+   * > differently.
+   */
+  appear: i.bool,
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: i.bool,
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: i.bool,
+  /**
+   * The duration of the transition, in milliseconds.
+   * Required unless `addEndListener` is provided.
+   *
+   * You may specify a single timeout for all transitions:
+   *
+   * ```jsx
+   * timeout={500}
+   * ```
+   *
+   * or individually:
+   *
+   * ```jsx
+   * timeout={{
+   *  appear: 500,
+   *  enter: 300,
+   *  exit: 500,
+   * }}
+   * ```
+   *
+   * - `appear` defaults to the value of `enter`
+   * - `enter` defaults to `0`
+   * - `exit` defaults to `0`
+   *
+   * @type {number | { enter?: number, exit?: number, appear?: number }}
+   */
+  timeout: function(a) {
+    var o = R;
+    a.addEndListener || (o = o.isRequired);
+    for (var r = arguments.length, e = new Array(r > 1 ? r - 1 : 0), t = 1; t < r; t++)
+      e[t - 1] = arguments[t];
+    return o.apply(void 0, [a].concat(e));
+  },
+  /**
+   * Add a custom transition end trigger. Called with the transitioning
+   * DOM node and a `done` callback. Allows for more fine grained transition end
+   * logic. Timeouts are still used as a fallback if provided.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * ```jsx
+   * addEndListener={(node, done) => {
+   *   // use the css transitionend event to mark the finish of a transition
+   *   node.addEventListener('transitionend', done, false);
+   * }}
+   * ```
+   */
+  addEndListener: i.func,
+  /**
+   * Callback fired before the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEnter: i.func,
+  /**
+   * Callback fired after the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntering: i.func,
+  /**
+   * Callback fired after the "entered" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEntered: i.func,
+  /**
+   * Callback fired before the "exiting" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExit: i.func,
+  /**
+   * Callback fired after the "exiting" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExiting: i.func,
+  /**
+   * Callback fired after the "exited" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExited: i.func
+} : {};
+function E() {
+}
+l.defaultProps = {
+  in: !1,
+  mountOnEnter: !1,
+  unmountOnExit: !1,
+  appear: !1,
+  enter: !0,
+  exit: !0,
+  onEnter: E,
+  onEntering: E,
+  onEntered: E,
+  onExit: E,
+  onExiting: E,
+  onExited: E
+};
+l.UNMOUNTED = x;
+l.EXITED = f;
+l.ENTERING = c;
+l.ENTERED = h;
+l.EXITING = T;
+const P = (u) => u.scrollTop;
+function U(u, a) {
+  var o, r;
+  const {
+    timeout: e,
+    easing: t,
+    style: n = {}
+  } = u;
+  return {
+    duration: (o = n.transitionDuration) != null ? o : typeof e == "number" ? e : e[a.mode] || 0,
+    easing: (r = n.transitionTimingFunction) != null ? r : typeof t == "object" ? t[a.mode] : t,
+    delay: n.transitionDelay
+  };
+}
+export {
+  l as T,
+  U as g,
+  P as r
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hybridcore/ui",
   "description": "Hybrid Core UI Library",
-  "version": "1.0.2",
+  "version": "1.1.2",
   "author": "Hybrid Core",
   "license": "ISC",
   "type": "module",
@@ -18,17 +18,35 @@
     "build": "tsc -b ./tsconfig.lib.json && vite build",
     "lint": "eslint .",
     "preview": "vite preview",
-    "prepublishOnly": "npm run build",
+    "prepublishOnly": "yarn build",
     "storybook": "storybook dev -p 6006",
-    "build-storybook": "storybook build"
+    "build-storybook": "storybook build",
+    "tsc": "tsc -b ./tsconfig.lib.json"
   },
-  "peerDependencies": {
+  "dependencies": {
     "@emotion/react": "^11.10.6",
     "@emotion/styled": "^11.10.6",
     "@mui/icons-material": "^5.11.11",
+    "@mui/lab": "5.0.0-alpha.130",
     "@mui/material": "^5.11.13",
+    "@mui/x-data-grid": "^6.0.4",
+    "@mui/x-date-pickers": "^6.3.0",
+    "@turf/turf": "^7.0.0",
+    "dayjs": "^1.11.7",
+    "fast-xml-parser": "^4.2.2",
+    "geodesy": "^2.4.0",
+    "lodash": "^4.17.21",
+    "mapbox-gl": "^2.15.0",
+    "ol": "^7.3.0",
     "react": "^18.3.1",
-    "react-dom": "^18.3.1"
+    "react-confirm": "^0.3.0-2",
+    "react-dom": "^18.3.1",
+    "react-dropdown-tree-select": "^2.8.0",
+    "react-hook-form": "^7.43.9",
+    "react-number-format": "^5.3.4",
+    "react-phone-number-input": "^3.3.7",
+    "react-select": "^5.8.0",
+    "terraformer-wkt-parser": "^1.2.1"
   },
   "devDependencies": {
     "@chromatic-com/storybook": "^1.9.0",
@@ -41,6 +59,9 @@
     "@storybook/react": "^8.3.5",
     "@storybook/react-vite": "^8.3.5",
     "@storybook/test": "^8.3.5",
+    "@types/geodesy": "^2.2.3",
+    "@types/lodash": "^4.14.194",
+    "@types/mapbox-gl": "^2.7.11",
     "@types/node": "^22.7.5",
     "@types/react": "^18.3.10",
     "@types/react-dom": "^18.3.0",