@hitachivantara/uikit-react-core 4.4.3 → 5.0.0-next.10

package/dist/esm/components/BaseDropdown/BaseDropdown.styles.js

@@ -0,0 +1,238 @@
+import _styled from "@emotion/styled/base";
+import { DropUpXS, DropDownXS } from "@hitachivantara/uikit-react-icons";
+import { theme } from "@hitachivantara/uikit-styles";
+import { transientOptions } from "../../utils/transientOptions.js";
+import { outlineStyles } from "../../utils/focusUtils.js";
+import { HvTypography } from "../Typography/Typography.js";
+function _EMOTION_STRINGIFIED_CSS_ERROR__() {
+  return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
+}
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+const StyledRoot = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  target: "eapzthe9"
+} : {
+  target: "eapzthe9",
+  label: "StyledRoot"
+})(process.env.NODE_ENV === "production" ? {
+  name: "n48rgu",
+  styles: "width:100%;position:relative"
+} : {
+  name: "n48rgu",
+  styles: "width:100%;position:relative",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const StyledAnchor = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? _extends({}, {
+  target: "eapzthe8"
+}, transientOptions) : _extends({}, {
+  target: "eapzthe8",
+  label: "StyledAnchor"
+}, transientOptions))(({
+  $disabled
+}) => ({
+  display: "inline-block",
+  width: "100%",
+  ...$disabled && {
+    cursor: "not-allowed",
+    "&:focus": {
+      outline: "none"
+    }
+  }
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2h2LXVpa2l0LXJlYWN0L2h2LXVpa2l0LXJlYWN0L3BhY2thZ2VzL2NvcmUvc3JjL2NvbXBvbmVudHMvQmFzZURyb3Bkb3duL0Jhc2VEcm9wZG93bi5zdHlsZXMudHN4Il0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQWE0QiIsImZpbGUiOiIvaG9tZS9ydW5uZXIvd29yay9odi11aWtpdC1yZWFjdC9odi11aWtpdC1yZWFjdC9wYWNrYWdlcy9jb3JlL3NyYy9jb21wb25lbnRzL0Jhc2VEcm9wZG93bi9CYXNlRHJvcGRvd24uc3R5bGVzLnRzeCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENTU1Byb3BlcnRpZXMgfSBmcm9tIFwiQGVtb3Rpb24vc2VyaWFsaXplXCI7XG5pbXBvcnQgc3R5bGVkIGZyb20gXCJAZW1vdGlvbi9zdHlsZWRcIjtcbmltcG9ydCB7IERyb3BEb3duWFMsIERyb3BVcFhTIH0gZnJvbSBcIkBoaXRhY2hpdmFudGFyYS91aWtpdC1yZWFjdC1pY29uc1wiO1xuaW1wb3J0IHsgdGhlbWUgfSBmcm9tIFwiQGhpdGFjaGl2YW50YXJhL3Vpa2l0LXN0eWxlc1wiO1xuaW1wb3J0IHsgSHZUeXBvZ3JhcGh5IH0gZnJvbSBcImNvbXBvbmVudHNcIjtcbmltcG9ydCB7IG91dGxpbmVTdHlsZXMgfSBmcm9tIFwidXRpbHNcIjtcbmltcG9ydCB7IHRyYW5zaWVudE9wdGlvbnMgfSBmcm9tIFwidXRpbHMvdHJhbnNpZW50T3B0aW9uc1wiO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkUm9vdCA9IHN0eWxlZChcImRpdlwiKSh7XG4gIHdpZHRoOiBcIjEwMCVcIixcbiAgcG9zaXRpb246IFwicmVsYXRpdmVcIixcbn0pO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkQW5jaG9yID0gc3R5bGVkKFxuICBcImRpdlwiLFxuICB0cmFuc2llbnRPcHRpb25zXG4pKCh7ICRkaXNhYmxlZCB9OiB7ICRkaXNhYmxlZDogYm9vbGVhbiB9KSA9PiAoe1xuICBkaXNwbGF5OiBcImlubGluZS1ibG9ja1wiLFxuICB3aWR0aDogXCIxMDAlXCIsXG5cbiAgLi4uKCRkaXNhYmxlZCAmJiB7XG4gICAgY3Vyc29yOiBcIm5vdC1hbGxvd2VkXCIsXG4gICAgXCImOmZvY3VzXCI6IHtcbiAgICAgIG91dGxpbmU6IFwibm9uZVwiLFxuICAgIH0sXG4gIH0pLFxufSkpO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkSGVhZGVyUm9vdCA9IHN0eWxlZChcbiAgXCJkaXZcIixcbiAgdHJhbnNpZW50T3B0aW9uc1xuKShcbiAgKHtcbiAgICAkZGlzYWJsZWQsXG4gICAgJHJlYWRPbmx5LFxuICAgICRvcGVuZWQsXG4gICAgJG9wZW5lZFVwLFxuICAgICRvcGVuZWREb3duLFxuICB9OiB7XG4gICAgJGRpc2FibGVkOiBib29sZWFuO1xuICAgICRyZWFkT25seTogYm9vbGVhbjtcbiAgICAkb3BlbmVkOiBib29sZWFuO1xuICAgICRvcGVuZWRVcDogYm9vbGVhbjtcbiAgICAkb3BlbmVkRG93bjogYm9vbGVhbjtcbiAgfSkgPT4gKHtcbiAgICBjdXJzb3I6IFwicG9pbnRlclwiLFxuICAgIHVzZXJTZWxlY3Q6IFwibm9uZVwiLFxuICAgIHBvc2l0aW9uOiBcInJlbGF0aXZlXCIsXG4gICAgYmFja2dyb3VuZDogdGhlbWUuY29sb3JzLmF0bW8xLFxuICAgIGJvcmRlcjogYDFweCBzb2xpZCAke3RoZW1lLmJhc2VEcm9wZG93bi5ib3JkZXJDb2xvcn1gLFxuICAgIGJvcmRlclJhZGl1czogXCIycHhcIixcbiAgICBcIiY6aG92ZXJcIjoge1xuICAgICAgYm9yZGVyOiBgMXB4IHNvbGlkICR7dGhlbWUuYmFzZURyb3Bkb3duLmhvdmVyQm9yZGVyQ29sb3J9YCxcbiAgICB9LFxuICAgIFwiJjpmb2N1c1wiOiB7XG4gICAgICBvdXRsaW5lOiBcIm5vbmVcIixcbiAgICB9LFxuICAgIFwiJjpmb2N1cy12aXNpYmxlXCI6IHtcbiAgICAgIC4uLm91dGxpbmVTdHlsZXMsXG4gICAgICBib3JkZXI6IGAxcHggc29saWQgJHt0aGVtZS5iYXNlRHJvcGRvd24uaG92ZXJCb3JkZXJDb2xvcn1gLFxuICAgIH0sXG5cbiAgICAuLi4oJGRpc2FibGVkICYmIHtcbiAgICAgIGN1cnNvcjogXCJub3QtYWxsb3dlZFwiLFxuICAgICAgcG9pbnRlckV2ZW50czogXCJub25lXCIsXG4gICAgICBib3JkZXI6IGAxcHggc29saWQgJHt0aGVtZS5iYXNlRHJvcGRvd24uZGlzYWJsZWRCb3JkZXJDb2xvcn1gLFxuICAgICAgYmFja2dyb3VuZDogdGhlbWUuYmFzZURyb3Bkb3duLmRpc2FibGVkQmFja2dyb3VuZENvbG9yLFxuICAgICAgXCImOmhvdmVyXCI6IHtcbiAgICAgICAgYm9yZGVyOiBgMXB4IHNvbGlkICR7dGhlbWUuYmFzZURyb3Bkb3duLmRpc2FibGVkQm9yZGVyQ29sb3J9YCxcbiAgICAgIH0sXG4gICAgfSksXG5cbiAgICAuLi4oJHJlYWRPbmx5ICYmIHtcbiAgICAgIGN1cnNvcjogXCJub3QtYWxsb3dlZFwiLFxuICAgICAgcG9pbnRlckV2ZW50czogXCJub25lXCIsXG4gICAgICBib3JkZXI6IHRoZW1lLmJhc2VEcm9wZG93bi5yZWFkT25seUJvcmRlcixcbiAgICAgIGJhY2tncm91bmQ6IHRoZW1lLmJhc2VEcm9wZG93bi5yZWFkT25seUJhY2tncm91bmRDb2xvcixcbiAgICAgIHVzZXJTZWxlY3Q6IFwidGV4dFwiLFxuICAgICAgXCImOmZvY3VzLXZpc2libGVcIjoge1xuICAgICAgICBvdXRsaW5lOiBcIm5vbmVcIixcbiAgICAgICAgYm9yZGVyOiB0aGVtZS5iYXNlRHJvcGRvd24ucmVhZE9ubHlCb3JkZXIsXG4gICAgICB9LFxuICAgIH0pLFxuXG4gICAgLi4uKCRvcGVuZWQgJiYge1xuICAgICAgYm9yZGVyOiBgMXB4IHNvbGlkICR7dGhlbWUuYmFzZURyb3Bkb3duLm9wZW5Cb3JkZXJDb2xvcn1gLFxuICAgICAgYm94U2hhZG93OiB0aGVtZS5iYXNlRHJvcGRvd24uc2hhZG93LFxuICAgICAgXCImOmhvdmVyXCI6IHtcbiAgICAgICAgYm9yZGVyOiBgMXB4IHNvbGlkICR7dGhlbWUuYmFzZURyb3Bkb3duLm9wZW5Cb3JkZXJDb2xvcn1gLFxuICAgICAgICBib3hTaGFkb3c6IHRoZW1lLmJhc2VEcm9wZG93bi5zaGFkb3csXG4gICAgICB9LFxuICAgIH0pLFxuXG4gICAgLi4uKCRvcGVuZWRVcCAmJiB7XG4gICAgICBib3JkZXJSYWRpdXM6IFwiMHB4IDBweCAycHggMnB4XCIsXG4gICAgfSksXG5cbiAgICAuLi4oJG9wZW5lZERvd24gJiYge1xuICAgICAgYm9yZGVyUmFkaXVzOiBcIjJweCAycHggMHB4IDBweFwiLFxuICAgIH0pLFxuICB9KVxuKTtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZFNlbGVjdGlvbiA9IHN0eWxlZChcImRpdlwiKSh7XG4gIGRpc3BsYXk6IFwiZmxleFwiLFxuICBhbGlnbkl0ZW1zOiBcImNlbnRlclwiLFxuICBoZWlnaHQ6IFwiMzBweFwiLFxuICBwYWRkaW5nOiBgMHB4ICR7dGhlbWUuc3BhY2UubWR9IDBweCAke3RoZW1lLnNwYWNlLnhzfWAsXG59KTtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZFBsYWNlaG9sZGVyID0gc3R5bGVkKFxuICBIdlR5cG9ncmFwaHksXG4gIHRyYW5zaWVudE9wdGlvbnNcbikoKHsgJGRpc2FibGVkIH06IHsgJGRpc2FibGVkOiBib29sZWFuIH0pID0+ICh7XG4gIGRpc3BsYXk6IFwiYmxvY2tcIixcbiAgb3ZlcmZsb3c6IFwiaGlkZGVuXCIsXG4gIHRleHRPdmVyZmxvdzogXCJlbGxpcHNpc1wiLFxuICB3aGl0ZVNwYWNlOiBcIm5vd3JhcFwiLFxuICAuLi4odGhlbWUudHlwb2dyYXBoeS5ib2R5IGFzIENTU1Byb3BlcnRpZXMpLFxuICBjb2xvcjogdGhlbWUuYmFzZURyb3Bkb3duLnBsYWNlaG9sZGVyQ29sb3IsXG5cbiAgLi4uKCRkaXNhYmxlZCAmJiB7XG4gICAgY29sb3I6IHRoZW1lLmNvbG9ycy5hdG1vNSxcbiAgfSksXG59KSk7XG5cbmNvbnN0IGljb25zU3R5bGVzOiBDU1NQcm9wZXJ0aWVzID0ge1xuICBwb3NpdGlvbjogXCJhYnNvbHV0ZVwiLFxuICBwb2ludGVyRXZlbnRzOiBcIm5vbmVcIixcbiAgdG9wOiAtMSxcbiAgcmlnaHQ6IC0xLFxufTtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZERyb3BVcFhTID0gc3R5bGVkKERyb3BVcFhTKSh7XG4gIC4uLmljb25zU3R5bGVzLFxufSk7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWREcm9wRG93blhTID0gc3R5bGVkKFxuICBEcm9wRG93blhTLFxuICB0cmFuc2llbnRPcHRpb25zXG4pKCh7ICRkaXNhYmxlZCB9OiB7ICRkaXNhYmxlZDogYm9vbGVhbiB9KSA9PiAoe1xuICAuLi5pY29uc1N0eWxlcyxcblxuICAuLi4oJGRpc2FibGVkICYmIHtcbiAgICBcIiYgc3ZnXCI6IHtcbiAgICAgIFwiJiBwYXRoXCI6IHtcbiAgICAgICAgZmlsbDogdGhlbWUuY29sb3JzLmF0bW81LFxuICAgICAgfSxcbiAgICB9LFxuICB9KSxcbn0pKTtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZENvbnRhaW5lciA9IHN0eWxlZChcImRpdlwiKSh7XG4gIHpJbmRleDogdGhlbWUuekluZGljZXMudG9vbHRpcCxcbiAgd2lkdGg6IFwiYXV0b1wiLFxufSk7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRFeHRlbnNpb24gPSBzdHlsZWQoXG4gIFwiZGl2XCIsXG4gIHRyYW5zaWVudE9wdGlvbnNcbikoXG4gICh7XG4gICAgJGxlZnRQb3NpdGlvbixcbiAgICAkb3BlblNoYWRvdyxcbiAgICAkZmxvYXRMZWZ0LFxuICAgICRmbG9hdFJpZ2h0LFxuICB9OiB7XG4gICAgJGxlZnRQb3NpdGlvbjogYm9vbGVhbjtcbiAgICAkb3BlblNoYWRvdzogYm9vbGVhbjtcbiAgICAkZmxvYXRMZWZ0OiBib29sZWFuO1xuICAgICRmbG9hdFJpZ2h0OiBib29sZWFuO1xuICB9KSA9PiAoe1xuICAgIGhlaWdodDogdGhlbWUuZHJvcERvd25NZW51LmV4dGVuc2lvbkhlaWdodCxcbiAgICBiYWNrZ3JvdW5kQ29sb3I6IHRoZW1lLmNvbG9ycy5hdG1vMSxcbiAgICBib3JkZXJUb3A6IFwibm9uZVwiLFxuICAgIGJvcmRlckJvdHRvbTogXCJub25lXCIsXG4gICAgYm9yZGVyUmlnaHQ6IGAxcHggc29saWQgJHt0aGVtZS5kcm9wRG93bk1lbnUuZXh0ZW5zaW9uQm9yZGVyQ29sb3J9YCxcbiAgICBib3JkZXJMZWZ0OiBgMXB4IHNvbGlkICR7dGhlbWUuZHJvcERvd25NZW51LmV4dGVuc2lvbkJvcmRlckNvbG9yfWAsXG5cbiAgICAuLi4oJGxlZnRQb3NpdGlvbiAmJiB7XG4gICAgICBtYXJnaW5MZWZ0OiBcImF1dG9cIixcbiAgICB9KSxcblxuICAgIC4uLigkb3BlblNoYWRvdyAmJiB7XG4gICAgICBib3hTaGFkb3c6IGAwcHggOHB4IDBweCAke3RoZW1lLmNvbG9ycy5hdG1vMX0sIDBweCAwcHggOXB4IDBweCByZ2JhKDY1LDY1LDY1LC4xMilgLFxuICAgIH0pLFxuXG4gICAgLi4uKCRmbG9hdExlZnQgJiYge1xuICAgICAgZmxvYXQ6IFwibGVmdFwiLFxuICAgIH0pLFxuXG4gICAgLi4uKCRmbG9hdFJpZ2h0ICYmIHtcbiAgICAgIGZsb2F0OiBcInJpZ2h0XCIsXG4gICAgfSksXG4gIH0pXG4pO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkUGFuZWwgPSBzdHlsZWQoXCJkaXZcIikoe1xuICBwb3NpdGlvbjogXCJyZWxhdGl2ZVwiLFxuICBib3hTaGFkb3c6IHRoZW1lLmJhc2VEcm9wZG93bi5zaGFkb3csXG59KTtcbiJdfQ== */");
+const StyledHeaderRoot = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? _extends({}, {
+  target: "eapzthe7"
+}, transientOptions) : _extends({}, {
+  target: "eapzthe7",
+  label: "StyledHeaderRoot"
+}, transientOptions))(({
+  $disabled,
+  $readOnly,
+  $opened,
+  $openedUp,
+  $openedDown
+}) => ({
+  cursor: "pointer",
+  userSelect: "none",
+  position: "relative",
+  background: theme.colors.atmo1,
+  border: `1px solid ${theme.baseDropdown.borderColor}`,
+  borderRadius: "2px",
+  "&:hover": {
+    border: `1px solid ${theme.baseDropdown.hoverBorderColor}`
+  },
+  "&:focus": {
+    outline: "none"
+  },
+  "&:focus-visible": {
+    ...outlineStyles,
+    border: `1px solid ${theme.baseDropdown.hoverBorderColor}`
+  },
+  ...$disabled && {
+    cursor: "not-allowed",
+    pointerEvents: "none",
+    border: `1px solid ${theme.baseDropdown.disabledBorderColor}`,
+    background: theme.baseDropdown.disabledBackgroundColor,
+    "&:hover": {
+      border: `1px solid ${theme.baseDropdown.disabledBorderColor}`
+    }
+  },
+  ...$readOnly && {
+    cursor: "not-allowed",
+    pointerEvents: "none",
+    border: theme.baseDropdown.readOnlyBorder,
+    background: theme.baseDropdown.readOnlyBackgroundColor,
+    userSelect: "text",
+    "&:focus-visible": {
+      outline: "none",
+      border: theme.baseDropdown.readOnlyBorder
+    }
+  },
+  ...$opened && {
+    border: `1px solid ${theme.baseDropdown.openBorderColor}`,
+    boxShadow: theme.baseDropdown.shadow,
+    "&:hover": {
+      border: `1px solid ${theme.baseDropdown.openBorderColor}`,
+      boxShadow: theme.baseDropdown.shadow
+    }
+  },
+  ...$openedUp && {
+    borderRadius: "0px 0px 2px 2px"
+  },
+  ...$openedDown && {
+    borderRadius: "2px 2px 0px 0px"
+  }
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+const StyledSelection = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  target: "eapzthe6"
+} : {
+  target: "eapzthe6",
+  label: "StyledSelection"
+})({
+  display: "flex",
+  alignItems: "center",
+  height: "30px",
+  padding: `0px ${theme.space.md} 0px ${theme.space.xs}`
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+const StyledPlaceholder = /* @__PURE__ */ _styled(HvTypography, process.env.NODE_ENV === "production" ? _extends({}, {
+  target: "eapzthe5"
+}, transientOptions) : _extends({}, {
+  target: "eapzthe5",
+  label: "StyledPlaceholder"
+}, transientOptions))(({
+  $disabled
+}) => ({
+  display: "block",
+  overflow: "hidden",
+  textOverflow: "ellipsis",
+  whiteSpace: "nowrap",
+  ...theme.typography.body,
+  color: theme.baseDropdown.placeholderColor,
+  ...$disabled && {
+    color: theme.colors.atmo5
+  }
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+const iconsStyles = {
+  position: "absolute",
+  pointerEvents: "none",
+  top: -1,
+  right: -1
+};
+const StyledDropUpXS = /* @__PURE__ */ _styled(DropUpXS, process.env.NODE_ENV === "production" ? {
+  target: "eapzthe4"
+} : {
+  target: "eapzthe4",
+  label: "StyledDropUpXS"
+})({
+  ...iconsStyles
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+const StyledDropDownXS = /* @__PURE__ */ _styled(DropDownXS, process.env.NODE_ENV === "production" ? _extends({}, {
+  target: "eapzthe3"
+}, transientOptions) : _extends({}, {
+  target: "eapzthe3",
+  label: "StyledDropDownXS"
+}, transientOptions))(({
+  $disabled
+}) => ({
+  ...iconsStyles,
+  ...$disabled && {
+    "& svg": {
+      "& path": {
+        fill: theme.colors.atmo5
+      }
+    }
+  }
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+const StyledContainer = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  target: "eapzthe2"
+} : {
+  target: "eapzthe2",
+  label: "StyledContainer"
+})({
+  zIndex: theme.zIndices.tooltip,
+  width: "auto"
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+const StyledExtension = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? _extends({}, {
+  target: "eapzthe1"
+}, transientOptions) : _extends({}, {
+  target: "eapzthe1",
+  label: "StyledExtension"
+}, transientOptions))(({
+  $leftPosition,
+  $openShadow,
+  $floatLeft,
+  $floatRight
+}) => ({
+  height: theme.dropDownMenu.extensionHeight,
+  backgroundColor: theme.colors.atmo1,
+  borderTop: "none",
+  borderBottom: "none",
+  borderRight: `1px solid ${theme.dropDownMenu.extensionBorderColor}`,
+  borderLeft: `1px solid ${theme.dropDownMenu.extensionBorderColor}`,
+  ...$leftPosition && {
+    marginLeft: "auto"
+  },
+  ...$openShadow && {
+    boxShadow: `0px 8px 0px ${theme.colors.atmo1}, 0px 0px 9px 0px rgba(65,65,65,.12)`
+  },
+  ...$floatLeft && {
+    float: "left"
+  },
+  ...$floatRight && {
+    float: "right"
+  }
+}), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+const StyledPanel = /* @__PURE__ */ _styled("div", process.env.NODE_ENV === "production" ? {
+  target: "eapzthe0"
+} : {
+  target: "eapzthe0",
+  label: "StyledPanel"
+})({
+  position: "relative",
+  boxShadow: theme.baseDropdown.shadow
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
+export {
+  StyledAnchor,
+  StyledContainer,
+  StyledDropDownXS,
+  StyledDropUpXS,
+  StyledExtension,
+  StyledHeaderRoot,
+  StyledPanel,
+  StyledPlaceholder,
+  StyledRoot,
+  StyledSelection
+};
+//# sourceMappingURL=BaseDropdown.styles.js.map

package/dist/esm/components/BaseDropdown/BaseDropdown.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseDropdown.styles.js","sources":["../../../../src/components/BaseDropdown/BaseDropdown.styles.tsx"],"sourcesContent":["import { CSSProperties } from \"@emotion/serialize\";\nimport styled from \"@emotion/styled\";\nimport { DropDownXS, DropUpXS } from \"@hitachivantara/uikit-react-icons\";\nimport { theme } from \"@hitachivantara/uikit-styles\";\nimport { HvTypography } from \"components\";\nimport { outlineStyles } from \"utils\";\nimport { transientOptions } from \"utils/transientOptions\";\n\nexport const StyledRoot = styled(\"div\")({\n  width: \"100%\",\n  position: \"relative\",\n});\n\nexport const StyledAnchor = styled(\n  \"div\",\n  transientOptions\n)(({ $disabled }: { $disabled: boolean }) => ({\n  display: \"inline-block\",\n  width: \"100%\",\n\n  ...($disabled && {\n    cursor: \"not-allowed\",\n    \"&:focus\": {\n      outline: \"none\",\n    },\n  }),\n}));\n\nexport const StyledHeaderRoot = styled(\n  \"div\",\n  transientOptions\n)(\n  ({\n    $disabled,\n    $readOnly,\n    $opened,\n    $openedUp,\n    $openedDown,\n  }: {\n    $disabled: boolean;\n    $readOnly: boolean;\n    $opened: boolean;\n    $openedUp: boolean;\n    $openedDown: boolean;\n  }) => ({\n    cursor: \"pointer\",\n    userSelect: \"none\",\n    position: \"relative\",\n    background: theme.colors.atmo1,\n    border: `1px solid ${theme.baseDropdown.borderColor}`,\n    borderRadius: \"2px\",\n    \"&:hover\": {\n      border: `1px solid ${theme.baseDropdown.hoverBorderColor}`,\n    },\n    \"&:focus\": {\n      outline: \"none\",\n    },\n    \"&:focus-visible\": {\n      ...outlineStyles,\n      border: `1px solid ${theme.baseDropdown.hoverBorderColor}`,\n    },\n\n    ...($disabled && {\n      cursor: \"not-allowed\",\n      pointerEvents: \"none\",\n      border: `1px solid ${theme.baseDropdown.disabledBorderColor}`,\n      background: theme.baseDropdown.disabledBackgroundColor,\n      \"&:hover\": {\n        border: `1px solid ${theme.baseDropdown.disabledBorderColor}`,\n      },\n    }),\n\n    ...($readOnly && {\n      cursor: \"not-allowed\",\n      pointerEvents: \"none\",\n      border: theme.baseDropdown.readOnlyBorder,\n      background: theme.baseDropdown.readOnlyBackgroundColor,\n      userSelect: \"text\",\n      \"&:focus-visible\": {\n        outline: \"none\",\n        border: theme.baseDropdown.readOnlyBorder,\n      },\n    }),\n\n    ...($opened && {\n      border: `1px solid ${theme.baseDropdown.openBorderColor}`,\n      boxShadow: theme.baseDropdown.shadow,\n      \"&:hover\": {\n        border: `1px solid ${theme.baseDropdown.openBorderColor}`,\n        boxShadow: theme.baseDropdown.shadow,\n      },\n    }),\n\n    ...($openedUp && {\n      borderRadius: \"0px 0px 2px 2px\",\n    }),\n\n    ...($openedDown && {\n      borderRadius: \"2px 2px 0px 0px\",\n    }),\n  })\n);\n\nexport const StyledSelection = styled(\"div\")({\n  display: \"flex\",\n  alignItems: \"center\",\n  height: \"30px\",\n  padding: `0px ${theme.space.md} 0px ${theme.space.xs}`,\n});\n\nexport const StyledPlaceholder = styled(\n  HvTypography,\n  transientOptions\n)(({ $disabled }: { $disabled: boolean }) => ({\n  display: \"block\",\n  overflow: \"hidden\",\n  textOverflow: \"ellipsis\",\n  whiteSpace: \"nowrap\",\n  ...(theme.typography.body as CSSProperties),\n  color: theme.baseDropdown.placeholderColor,\n\n  ...($disabled && {\n    color: theme.colors.atmo5,\n  }),\n}));\n\nconst iconsStyles: CSSProperties = {\n  position: \"absolute\",\n  pointerEvents: \"none\",\n  top: -1,\n  right: -1,\n};\n\nexport const StyledDropUpXS = styled(DropUpXS)({\n  ...iconsStyles,\n});\n\nexport const StyledDropDownXS = styled(\n  DropDownXS,\n  transientOptions\n)(({ $disabled }: { $disabled: boolean }) => ({\n  ...iconsStyles,\n\n  ...($disabled && {\n    \"& svg\": {\n      \"& path\": {\n        fill: theme.colors.atmo5,\n      },\n    },\n  }),\n}));\n\nexport const StyledContainer = styled(\"div\")({\n  zIndex: theme.zIndices.tooltip,\n  width: \"auto\",\n});\n\nexport const StyledExtension = styled(\n  \"div\",\n  transientOptions\n)(\n  ({\n    $leftPosition,\n    $openShadow,\n    $floatLeft,\n    $floatRight,\n  }: {\n    $leftPosition: boolean;\n    $openShadow: boolean;\n    $floatLeft: boolean;\n    $floatRight: boolean;\n  }) => ({\n    height: theme.dropDownMenu.extensionHeight,\n    backgroundColor: theme.colors.atmo1,\n    borderTop: \"none\",\n    borderBottom: \"none\",\n    borderRight: `1px solid ${theme.dropDownMenu.extensionBorderColor}`,\n    borderLeft: `1px solid ${theme.dropDownMenu.extensionBorderColor}`,\n\n    ...($leftPosition && {\n      marginLeft: \"auto\",\n    }),\n\n    ...($openShadow && {\n      boxShadow: `0px 8px 0px ${theme.colors.atmo1}, 0px 0px 9px 0px rgba(65,65,65,.12)`,\n    }),\n\n    ...($floatLeft && {\n      float: \"left\",\n    }),\n\n    ...($floatRight && {\n      float: \"right\",\n    }),\n  })\n);\n\nexport const StyledPanel = styled(\"div\")({\n  position: \"relative\",\n  boxShadow: theme.baseDropdown.shadow,\n});\n"],"names":["StyledRoot","process","env","NODE_ENV","target","label","name","styles","map","toString","_EMOTION_STRINGIFIED_CSS_ERROR__","StyledAnchor","_extends","transientOptions","$disabled","display","width","cursor","outline","StyledHeaderRoot","$readOnly","$opened","$openedUp","$openedDown","userSelect","position","background","theme","colors","atmo1","border","baseDropdown","borderColor","borderRadius","hoverBorderColor","outlineStyles","pointerEvents","disabledBorderColor","disabledBackgroundColor","readOnlyBorder","readOnlyBackgroundColor","openBorderColor","boxShadow","shadow","StyledSelection","alignItems","height","padding","space","md","xs","StyledPlaceholder","HvTypography","overflow","textOverflow","whiteSpace","typography","body","color","placeholderColor","atmo5","iconsStyles","top","right","StyledDropUpXS","DropUpXS","StyledDropDownXS","DropDownXS","fill","StyledContainer","zIndex","zIndices","tooltip","StyledExtension","$leftPosition","$openShadow","$floatLeft","$floatRight","dropDownMenu","extensionHeight","backgroundColor","borderTop","borderBottom","borderRight","extensionBorderColor","borderLeft","marginLeft","float","StyledPanel"],"mappings":"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"}

package/dist/esm/components/BaseDropdown/BaseDropdownContext/BaseDropdownContext.js

@@ -0,0 +1,8 @@
+import React__default from "react";
+const BaseDropdownContext = React__default.createContext({});
+BaseDropdownContext.displayName = "BaseDropdownContext";
+const BaseDropdownContext$1 = BaseDropdownContext;
+export {
+  BaseDropdownContext$1 as default
+};
+//# sourceMappingURL=BaseDropdownContext.js.map

package/dist/esm/components/BaseDropdown/BaseDropdownContext/BaseDropdownContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseDropdownContext.js","sources":["../../../../../src/components/BaseDropdown/BaseDropdownContext/BaseDropdownContext.tsx"],"sourcesContent":["import React from \"react\";\n\nconst BaseDropdownContext = React.createContext<{\n  width?: number;\n  height?: number;\n}>({});\n\nBaseDropdownContext.displayName = \"BaseDropdownContext\";\n\nexport default BaseDropdownContext;\n"],"names":["BaseDropdownContext","React","createContext","displayName"],"mappings":";AAEA,MAAMA,sBAAsBC,eAAMC,cAG/B,CAAA,CAAE;AAELF,oBAAoBG,cAAc;AAElC,MAAA,wBAAeH;"}

package/dist/esm/components/BaseDropdown/baseDropdownClasses.js

@@ -0,0 +1,8 @@
+import { getClasses } from "../../utils/classes.js";
+const classKeys = ["root", "rootDisabled", "anchor", "container", "header", "headerOpen", "headerOpenUp", "headerOpenDown", "headerDisabled", "headerReadOnly", "arrow", "selection", "placeholder", "selectionDisabled", "panel", "inputExtensionOpen", "inputExtensionLeftPosition", "inputExtensionOpenShadow", "inputExtensionFloatRight", "inputExtensionFloatLeft"];
+const baseDropdownClasses = getClasses(classKeys, "HvBaseDropdown");
+const baseDropdownClasses$1 = baseDropdownClasses;
+export {
+  baseDropdownClasses$1 as default
+};
+//# sourceMappingURL=baseDropdownClasses.js.map

package/dist/esm/components/BaseDropdown/baseDropdownClasses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseDropdownClasses.js","sources":["../../../../src/components/BaseDropdown/baseDropdownClasses.ts"],"sourcesContent":["import { getClasses } from \"utils\";\n\nexport type HvBaseDropdownClasses = {\n  root?: string;\n  rootDisabled?: string;\n  anchor?: string;\n  container?: string;\n  header?: string;\n  headerOpen?: string;\n  headerOpenUp?: string;\n  headerOpenDown?: string;\n  headerDisabled?: string;\n  headerReadOnly?: string;\n  arrow?: string;\n  selection?: string;\n  placeholder?: string;\n  selectionDisabled?: string;\n  panel?: string;\n  inputExtensionOpen?: string;\n  inputExtensionLeftPosition?: string;\n  inputExtensionOpenShadow?: string;\n  inputExtensionFloatRight?: string;\n  inputExtensionFloatLeft?: string;\n};\n\nconst classKeys: string[] = [\n  \"root\",\n  \"rootDisabled\",\n  \"anchor\",\n  \"container\",\n  \"header\",\n  \"headerOpen\",\n  \"headerOpenUp\",\n  \"headerOpenDown\",\n  \"headerDisabled\",\n  \"headerReadOnly\",\n  \"arrow\",\n  \"selection\",\n  \"placeholder\",\n  \"selectionDisabled\",\n  \"panel\",\n  \"inputExtensionOpen\",\n  \"inputExtensionLeftPosition\",\n  \"inputExtensionOpenShadow\",\n  \"inputExtensionFloatRight\",\n  \"inputExtensionFloatLeft\",\n];\n\nconst baseDropdownClasses = getClasses<HvBaseDropdownClasses>(\n  classKeys,\n  \"HvBaseDropdown\"\n);\n\nexport default baseDropdownClasses;\n"],"names":["classKeys","baseDropdownClasses","getClasses"],"mappings":";AAyBA,MAAMA,YAAsB,CAC1B,QACA,gBACA,UACA,aACA,UACA,cACA,gBACA,kBACA,kBACA,kBACA,SACA,aACA,eACA,qBACA,SACA,sBACA,8BACA,4BACA,4BACA,yBAAyB;AAG3B,MAAMC,sBAAsBC,WAC1BF,WACA,gBAAgB;AAGlB,MAAA,wBAAeC;"}

package/dist/esm/components/BaseInput/BaseInput.js

@@ -0,0 +1,61 @@
+import { jsxs, Fragment, jsx } from "@emotion/react/jsx-runtime";
+import { useContext } from "react";
+import { StyledRoot, StyledInput, StyledInputBorderContainer } from "./BaseInput.styles.js";
+import clsx from "clsx";
+import baseInputClasses from "./baseInputClasses.js";
+import { css, Global } from "@emotion/react";
+import { theme } from "@hitachivantara/uikit-styles";
+import { buildFormElementPropsFromContext, buildAriaPropsFromContext } from "../Forms/FormElement/utils/FormUtils.js";
+import { HvFormElementContext } from "../Forms/FormElement/context/FormElementContext.js";
+import { HvFormElementDescriptorsContext } from "../Forms/FormElement/context/FormElementDescriptorsContext.js";
+const baseInputStyles = /* @__PURE__ */ css('"input:-webkit-autofill":{"-webkit-box-shadow":0 0 0px 1000px ', theme.colors.atmo1, ' inset,"-webkit-text-fill-color":', theme.colors.acce1, ',;},"input[type=search]::-ms-clear":{display:"none",width:0,height:0,;},"input[type=search]::-ms-reveal":{display:"none",width:0,height:0,;},"input[type=search]::-webkit-search-decoration":{display:"none";},"input[type=search]::-webkit-search-cancel-button":{display:"none";},"input[type=search]::-webkit-search-results-button":{display:"none",;},"input[type=search]::-webkit-search-results-decoration":{display:"none",;}' + (process.env.NODE_ENV === "production" ? "" : ";label:baseInputStyles;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/hv-uikit-react/hv-uikit-react/packages/core/src/components/BaseInput/BaseInput.tsx"],"names":[],"mappings":"AAuB2B","file":"/home/runner/work/hv-uikit-react/hv-uikit-react/packages/core/src/components/BaseInput/BaseInput.tsx","sourcesContent":["import { RefObject, useContext } from \"react\";\nimport {\n  InputBaseComponentProps as MuiInputBaseComponentProps,\n  InputProps as MuiInputProps,\n} from \"@mui/material\";\nimport { HvBaseProps } from \"../../types\";\nimport {\n  StyledRoot,\n  StyledInputBorderContainer,\n  StyledInput,\n} from \"./BaseInput.styles\";\nimport {\n  HvFormElementContext,\n  HvFormElementDescriptorsContext,\n  buildFormElementPropsFromContext,\n  buildAriaPropsFromContext,\n} from \"../Forms/FormElement\";\nimport clsx from \"clsx\";\nimport baseInputClasses, { HvBaseInputClasses } from \"./baseInputClasses\";\nimport { css, Global } from \"@emotion/react\";\nimport { theme } from \"@hitachivantara/uikit-styles\";\n\n// Global styles for the base input.\nconst baseInputStyles = css`\n  \"input:-webkit-autofill\": {\n    \"-webkit-box-shadow\": 0 0 0px 1000px ${theme.colors.atmo1} inset,\n    \"-webkit-text-fill-color\": ${theme.colors.acce1},\n  },\n\n  /* Clears input's clear and reveal buttons from IE */\n  \"input[type=search]::-ms-clear\": {\n    display: \"none\",\n    width: 0,\n    height: 0,\n  },\n  \"input[type=search]::-ms-reveal\": {\n    display: \"none\",\n    width: 0,\n    height: 0,\n  },\n\n  /* Clears input's clear button from Chrome */\n  \"input[type=search]::-webkit-search-decoration\": { display: \"none\" },\n  \"input[type=search]::-webkit-search-cancel-button\": { display: \"none\" },\n  \"input[type=search]::-webkit-search-results-button\": {\n    display: \"none\",\n  },\n  \"input[type=search]::-webkit-search-results-decoration\": {\n    display: \"none\",\n  },\n}`;\n\nexport type HvBaseInputProps = Omit<MuiInputProps, \"onChange\" | \"classes\"> &\n  HvBaseProps<HTMLDivElement, { onChange }> & {\n    /** The input name. */\n    name?: string;\n    /** The value of the input, when controlled. */\n    value?: string;\n    /** The initial value of the input, when uncontrolled. */\n    defaultValue?: string;\n    /** If `true` the input is disabled. */\n    disabled?: boolean;\n    /** Indicates that the input is not editable. */\n    readOnly?: boolean;\n    /** If true, the input element will be required. */\n    required?: boolean;\n    /** The function that will be executed onChange, allows modification of the input,\n     * it receives the value. If a new value should be presented it must returned it. */\n    onChange?: (\n      event: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>,\n      value: string\n    ) => void;\n    /** The input type. */\n    type?: string;\n    /** Label inside the input used to help user. */\n    placeholder?: string;\n    /** If true, a textarea element will be rendered. */\n    multiline?: boolean;\n    /** If true and multiline is also true the textarea element will be resizable. */\n    resizable?: boolean;\n    /** Denotes if the input is in an invalid state. */\n    invalid?: boolean;\n    /** Attributes applied to the input element. */\n    inputProps?: MuiInputBaseComponentProps;\n    /** Allows passing a ref to the underlying input */\n    inputRef?: RefObject<HTMLElement>;\n    /** A Jss Object used to override or extend the styles applied to the component. */\n    classes?: HvBaseInputClasses;\n  };\n\n/**\n * An Input component that only posses the most basic functionalities.\n * It should be used alongside the other form elements to construct a proper accessible form.\n */\nexport const HvBaseInput = ({\n  classes,\n  className = \"\",\n  id,\n  name,\n  value,\n  defaultValue,\n  required,\n  readOnly,\n  disabled,\n  onChange,\n  type = \"text\",\n  placeholder,\n  multiline = false,\n  resizable = false,\n  invalid = false,\n  inputRef,\n  inputProps = {},\n  ...others\n}: HvBaseInputProps) => {\n  const formElementContext = useContext(HvFormElementContext);\n  const formElementProps = buildFormElementPropsFromContext(\n    name,\n    disabled,\n    readOnly,\n    required,\n    status,\n    formElementContext\n  );\n\n  const localInvalid = invalid || formElementProps.status === \"invalid\";\n\n  const formElementDescriptorsContext = useContext(\n    HvFormElementDescriptorsContext\n  );\n  const ariaProps = buildAriaPropsFromContext(\n    inputProps,\n    formElementDescriptorsContext,\n    localInvalid,\n    id\n  );\n\n  const onChangeHandler = (\n    event: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>\n  ) => {\n    onChange?.(event, event.target.value);\n  };\n\n  return (\n    <>\n      <Global styles={baseInputStyles} />\n      <StyledRoot\n        className={clsx(\n          baseInputClasses.root,\n          classes?.root,\n          className,\n          formElementProps.disabled &&\n            clsx(baseInputClasses.disabled, classes?.disabled),\n          localInvalid && clsx(baseInputClasses.invalid, classes?.invalid),\n          multiline &&\n            resizable &&\n            clsx(baseInputClasses.resizable, classes?.resizable),\n          readOnly && clsx(baseInputClasses.readOnly, classes?.readOnly)\n        )}\n        $disabled={formElementProps.disabled}\n        $invalid={localInvalid}\n        $resizable={multiline && resizable}\n        $readOnly={!!readOnly}\n      >\n        <StyledInput\n          id={id}\n          name={formElementProps.name}\n          value={value}\n          defaultValue={defaultValue}\n          type={type}\n          placeholder={placeholder}\n          readOnly={!!formElementProps.readOnly}\n          disabled={formElementProps.disabled}\n          onChange={onChangeHandler}\n          className={clsx(\n            localInvalid &&\n              clsx(\n                baseInputClasses.inputRootInvalid,\n                classes?.inputRootInvalid\n              ),\n            readOnly &&\n              clsx(\n                baseInputClasses.inputRootReadOnly,\n                classes?.inputRootReadOnly\n              )\n          )}\n          classes={{\n            root: clsx(baseInputClasses.inputRoot, classes?.inputRoot),\n            focused: clsx(\n              baseInputClasses.inputRootFocused,\n              classes?.inputRootFocused\n            ),\n            disabled: clsx(\n              baseInputClasses.inputRootDisabled,\n              classes?.inputRootDisabled\n            ),\n            multiline: clsx(\n              baseInputClasses.inputRootMultiline,\n              classes?.inputRootMultiline\n            ),\n            input: clsx(\n              baseInputClasses.input,\n              classes?.input,\n              !formElementProps.disabled &&\n                resizable &&\n                clsx(baseInputClasses.inputResizable, classes?.inputResizable),\n              disabled &&\n                clsx(baseInputClasses.inputDisabled, classes?.inputDisabled),\n              readOnly &&\n                clsx(baseInputClasses.inputReadOnly, classes?.readOnly)\n            ),\n          }}\n          inputProps={{\n            // Avoid the required attribute at the root node\n            required: formElementProps.required,\n            ...inputProps,\n            ...ariaProps,\n          }}\n          inputRef={inputRef}\n          multiline={multiline}\n          rows={10}\n          $resizable={!formElementProps.disabled && resizable}\n          $disabled={!!disabled}\n          $readOnly={!!readOnly}\n          $invalid={localInvalid}\n          {...others}\n        />\n        {!multiline && (\n          <StyledInputBorderContainer\n            role=\"presentation\"\n            className={clsx(\n              baseInputClasses.inputBorderContainer,\n              classes?.inputBorderContainer\n            )}\n          />\n        )}\n      </StyledRoot>\n    </>\n  );\n};\n"]} */");
+const HvBaseInput = ({
+  classes,
+  className = "",
+  id,
+  name,
+  value,
+  defaultValue,
+  required,
+  readOnly,
+  disabled,
+  onChange,
+  type = "text",
+  placeholder,
+  multiline = false,
+  resizable = false,
+  invalid = false,
+  inputRef,
+  inputProps = {},
+  ...others
+}) => {
+  const formElementContext = useContext(HvFormElementContext);
+  const formElementProps = buildFormElementPropsFromContext(name, disabled, readOnly, required, status, formElementContext);
+  const localInvalid = invalid || formElementProps.status === "invalid";
+  const formElementDescriptorsContext = useContext(HvFormElementDescriptorsContext);
+  const ariaProps = buildAriaPropsFromContext(inputProps, formElementDescriptorsContext, localInvalid, id);
+  const onChangeHandler = (event) => {
+    onChange == null ? void 0 : onChange(event, event.target.value);
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Global, { styles: baseInputStyles }),
+    /* @__PURE__ */ jsxs(StyledRoot, { className: clsx(baseInputClasses.root, classes == null ? void 0 : classes.root, className, formElementProps.disabled && clsx(baseInputClasses.disabled, classes == null ? void 0 : classes.disabled), localInvalid && clsx(baseInputClasses.invalid, classes == null ? void 0 : classes.invalid), multiline && resizable && clsx(baseInputClasses.resizable, classes == null ? void 0 : classes.resizable), readOnly && clsx(baseInputClasses.readOnly, classes == null ? void 0 : classes.readOnly)), $disabled: formElementProps.disabled, $invalid: localInvalid, $resizable: multiline && resizable, $readOnly: !!readOnly, children: [
+      /* @__PURE__ */ jsx(StyledInput, { id, name: formElementProps.name, value, defaultValue, type, placeholder, readOnly: !!formElementProps.readOnly, disabled: formElementProps.disabled, onChange: onChangeHandler, className: clsx(localInvalid && clsx(baseInputClasses.inputRootInvalid, classes == null ? void 0 : classes.inputRootInvalid), readOnly && clsx(baseInputClasses.inputRootReadOnly, classes == null ? void 0 : classes.inputRootReadOnly)), classes: {
+        root: clsx(baseInputClasses.inputRoot, classes == null ? void 0 : classes.inputRoot),
+        focused: clsx(baseInputClasses.inputRootFocused, classes == null ? void 0 : classes.inputRootFocused),
+        disabled: clsx(baseInputClasses.inputRootDisabled, classes == null ? void 0 : classes.inputRootDisabled),
+        multiline: clsx(baseInputClasses.inputRootMultiline, classes == null ? void 0 : classes.inputRootMultiline),
+        input: clsx(baseInputClasses.input, classes == null ? void 0 : classes.input, !formElementProps.disabled && resizable && clsx(baseInputClasses.inputResizable, classes == null ? void 0 : classes.inputResizable), disabled && clsx(baseInputClasses.inputDisabled, classes == null ? void 0 : classes.inputDisabled), readOnly && clsx(baseInputClasses.inputReadOnly, classes == null ? void 0 : classes.readOnly))
+      }, inputProps: {
+        required: formElementProps.required,
+        ...inputProps,
+        ...ariaProps
+      }, inputRef, multiline, rows: 10, $resizable: !formElementProps.disabled && resizable, $disabled: !!disabled, $readOnly: !!readOnly, $invalid: localInvalid, ...others }),
+      !multiline && /* @__PURE__ */ jsx(StyledInputBorderContainer, { role: "presentation", className: clsx(baseInputClasses.inputBorderContainer, classes == null ? void 0 : classes.inputBorderContainer) })
+    ] })
+  ] });
+};
+export {
+  HvBaseInput
+};
+//# sourceMappingURL=BaseInput.js.map

package/dist/esm/components/BaseInput/BaseInput.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseInput.js","sources":["../../../../src/components/BaseInput/BaseInput.tsx"],"sourcesContent":["import { RefObject, useContext } from \"react\";\nimport {\n  InputBaseComponentProps as MuiInputBaseComponentProps,\n  InputProps as MuiInputProps,\n} from \"@mui/material\";\nimport { HvBaseProps } from \"../../types\";\nimport {\n  StyledRoot,\n  StyledInputBorderContainer,\n  StyledInput,\n} from \"./BaseInput.styles\";\nimport {\n  HvFormElementContext,\n  HvFormElementDescriptorsContext,\n  buildFormElementPropsFromContext,\n  buildAriaPropsFromContext,\n} from \"../Forms/FormElement\";\nimport clsx from \"clsx\";\nimport baseInputClasses, { HvBaseInputClasses } from \"./baseInputClasses\";\nimport { css, Global } from \"@emotion/react\";\nimport { theme } from \"@hitachivantara/uikit-styles\";\n\n// Global styles for the base input.\nconst baseInputStyles = css`\n  \"input:-webkit-autofill\": {\n    \"-webkit-box-shadow\": 0 0 0px 1000px ${theme.colors.atmo1} inset,\n    \"-webkit-text-fill-color\": ${theme.colors.acce1},\n  },\n\n  /* Clears input's clear and reveal buttons from IE */\n  \"input[type=search]::-ms-clear\": {\n    display: \"none\",\n    width: 0,\n    height: 0,\n  },\n  \"input[type=search]::-ms-reveal\": {\n    display: \"none\",\n    width: 0,\n    height: 0,\n  },\n\n  /* Clears input's clear button from Chrome */\n  \"input[type=search]::-webkit-search-decoration\": { display: \"none\" },\n  \"input[type=search]::-webkit-search-cancel-button\": { display: \"none\" },\n  \"input[type=search]::-webkit-search-results-button\": {\n    display: \"none\",\n  },\n  \"input[type=search]::-webkit-search-results-decoration\": {\n    display: \"none\",\n  },\n}`;\n\nexport type HvBaseInputProps = Omit<MuiInputProps, \"onChange\" | \"classes\"> &\n  HvBaseProps<HTMLDivElement, { onChange }> & {\n    /** The input name. */\n    name?: string;\n    /** The value of the input, when controlled. */\n    value?: string;\n    /** The initial value of the input, when uncontrolled. */\n    defaultValue?: string;\n    /** If `true` the input is disabled. */\n    disabled?: boolean;\n    /** Indicates that the input is not editable. */\n    readOnly?: boolean;\n    /** If true, the input element will be required. */\n    required?: boolean;\n    /** The function that will be executed onChange, allows modification of the input,\n     * it receives the value. If a new value should be presented it must returned it. */\n    onChange?: (\n      event: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>,\n      value: string\n    ) => void;\n    /** The input type. */\n    type?: string;\n    /** Label inside the input used to help user. */\n    placeholder?: string;\n    /** If true, a textarea element will be rendered. */\n    multiline?: boolean;\n    /** If true and multiline is also true the textarea element will be resizable. */\n    resizable?: boolean;\n    /** Denotes if the input is in an invalid state. */\n    invalid?: boolean;\n    /** Attributes applied to the input element. */\n    inputProps?: MuiInputBaseComponentProps;\n    /** Allows passing a ref to the underlying input */\n    inputRef?: RefObject<HTMLElement>;\n    /** A Jss Object used to override or extend the styles applied to the component. */\n    classes?: HvBaseInputClasses;\n  };\n\n/**\n * An Input component that only posses the most basic functionalities.\n * It should be used alongside the other form elements to construct a proper accessible form.\n */\nexport const HvBaseInput = ({\n  classes,\n  className = \"\",\n  id,\n  name,\n  value,\n  defaultValue,\n  required,\n  readOnly,\n  disabled,\n  onChange,\n  type = \"text\",\n  placeholder,\n  multiline = false,\n  resizable = false,\n  invalid = false,\n  inputRef,\n  inputProps = {},\n  ...others\n}: HvBaseInputProps) => {\n  const formElementContext = useContext(HvFormElementContext);\n  const formElementProps = buildFormElementPropsFromContext(\n    name,\n    disabled,\n    readOnly,\n    required,\n    status,\n    formElementContext\n  );\n\n  const localInvalid = invalid || formElementProps.status === \"invalid\";\n\n  const formElementDescriptorsContext = useContext(\n    HvFormElementDescriptorsContext\n  );\n  const ariaProps = buildAriaPropsFromContext(\n    inputProps,\n    formElementDescriptorsContext,\n    localInvalid,\n    id\n  );\n\n  const onChangeHandler = (\n    event: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>\n  ) => {\n    onChange?.(event, event.target.value);\n  };\n\n  return (\n    <>\n      <Global styles={baseInputStyles} />\n      <StyledRoot\n        className={clsx(\n          baseInputClasses.root,\n          classes?.root,\n          className,\n          formElementProps.disabled &&\n            clsx(baseInputClasses.disabled, classes?.disabled),\n          localInvalid && clsx(baseInputClasses.invalid, classes?.invalid),\n          multiline &&\n            resizable &&\n            clsx(baseInputClasses.resizable, classes?.resizable),\n          readOnly && clsx(baseInputClasses.readOnly, classes?.readOnly)\n        )}\n        $disabled={formElementProps.disabled}\n        $invalid={localInvalid}\n        $resizable={multiline && resizable}\n        $readOnly={!!readOnly}\n      >\n        <StyledInput\n          id={id}\n          name={formElementProps.name}\n          value={value}\n          defaultValue={defaultValue}\n          type={type}\n          placeholder={placeholder}\n          readOnly={!!formElementProps.readOnly}\n          disabled={formElementProps.disabled}\n          onChange={onChangeHandler}\n          className={clsx(\n            localInvalid &&\n              clsx(\n                baseInputClasses.inputRootInvalid,\n                classes?.inputRootInvalid\n              ),\n            readOnly &&\n              clsx(\n                baseInputClasses.inputRootReadOnly,\n                classes?.inputRootReadOnly\n              )\n          )}\n          classes={{\n            root: clsx(baseInputClasses.inputRoot, classes?.inputRoot),\n            focused: clsx(\n              baseInputClasses.inputRootFocused,\n              classes?.inputRootFocused\n            ),\n            disabled: clsx(\n              baseInputClasses.inputRootDisabled,\n              classes?.inputRootDisabled\n            ),\n            multiline: clsx(\n              baseInputClasses.inputRootMultiline,\n              classes?.inputRootMultiline\n            ),\n            input: clsx(\n              baseInputClasses.input,\n              classes?.input,\n              !formElementProps.disabled &&\n                resizable &&\n                clsx(baseInputClasses.inputResizable, classes?.inputResizable),\n              disabled &&\n                clsx(baseInputClasses.inputDisabled, classes?.inputDisabled),\n              readOnly &&\n                clsx(baseInputClasses.inputReadOnly, classes?.readOnly)\n            ),\n          }}\n          inputProps={{\n            // Avoid the required attribute at the root node\n            required: formElementProps.required,\n            ...inputProps,\n            ...ariaProps,\n          }}\n          inputRef={inputRef}\n          multiline={multiline}\n          rows={10}\n          $resizable={!formElementProps.disabled && resizable}\n          $disabled={!!disabled}\n          $readOnly={!!readOnly}\n          $invalid={localInvalid}\n          {...others}\n        />\n        {!multiline && (\n          <StyledInputBorderContainer\n            role=\"presentation\"\n            className={clsx(\n              baseInputClasses.inputBorderContainer,\n              classes?.inputBorderContainer\n            )}\n          />\n        )}\n      </StyledRoot>\n    </>\n  );\n};\n"],"names":["baseInputStyles","theme","colors","atmo1","acce1","process","env","NODE_ENV","HvBaseInput","classes","className","id","name","value","defaultValue","required","readOnly","disabled","onChange","type","placeholder","multiline","resizable","invalid","inputRef","inputProps","others","formElementContext","useContext","HvFormElementContext","formElementProps","buildFormElementPropsFromContext","status","localInvalid","formElementDescriptorsContext","HvFormElementDescriptorsContext","ariaProps","buildAriaPropsFromContext","onChangeHandler","event","target","clsx","baseInputClasses","root","inputRootInvalid","inputRootReadOnly","inputRoot","focused","inputRootFocused","inputRootDisabled","inputRootMultiline","input","inputResizable","inputDisabled","inputReadOnly","inputBorderContainer"],"mappings":"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"}