@entur/form 8.4.2 → 9.0.1

package/dist/InputGroupLabel.d.ts

@@ -4,6 +4,7 @@ export type InputGroupLabelProps = {
     required?: boolean;
     labelTooltip?: string;
     labelId: string;
+    isFilled?: boolean;
     staticAnimation?: boolean;
 } & React.DetailedHTMLProps<React.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>;
 export declare const InputGroupLabel: React.FC<InputGroupLabelProps>;

package/dist/form.cjs.js

@@ -116,15 +116,18 @@ const InputGroupLabel = ({
   required,
   labelId,
   staticAnimation = false,
+  className,
+  isFilled: forceIsFilled,
   ...rest
 }) => {
   const { isFilled: isFilled2 } = useInputGroupContext();
-  const filler = staticAnimation || isFilled2;
+  const filler = staticAnimation || (forceIsFilled ?? isFilled2);
   return /* @__PURE__ */ jsxRuntime.jsx(
     "label",
     {
-      className: classNames(rest.className, {
-        "eds-input-group-label-wrapper--filled": filler
+      className: classNames(className, {
+        "eds-input-group-label-wrapper--filled": filler,
+        "eds-input-group-label-wrapper--controlled-label-position": forceIsFilled !== void 0
       }),
       id: labelId,
       ...rest,
@@ -893,142 +896,217 @@ const ClearButton = ({ onClear, ...props }) => {
 const SegmentedContext = React.createContext(
   null
 );
-const SegmentedProvider = ({
-  name,
-  onChange = () => void 0,
-  selectedValue,
-  multiple,
-  size,
-  ...rest
-}) => {
-  const generatedName = utils.useRandomId("eds-segmented-control");
-  const contextValue = React.useMemo(
-    () => ({
-      name: name || generatedName,
-      onChange,
-      multiple,
-      selectedValue,
-      size
-    }),
-    [generatedName, multiple, name, onChange, selectedValue, size]
-  );
-  return /* @__PURE__ */ jsxRuntime.jsx(SegmentedContext.Provider, { value: contextValue, ...rest });
-};
 const useSegmentedContext = () => {
   const context = React.useContext(SegmentedContext);
   if (!context) {
     throw new Error(
-      "You need to wrap your SegmentedChoice in either SegmentedControl or MultipleSegmentedControl"
+      "You need to wrap your SegmentedChoice in SegmentedControl"
     );
   }
   return context;
 };
-const SegmentedChoice = React.forwardRef(
+const SegmentedControl = React.forwardRef(
   ({
     children,
-    className,
-    style,
-    value,
+    label,
     name,
-    onChange = () => void 0,
+    onChange,
+    value,
+    defaultValue,
+    size = "medium",
+    className,
+    selectedValue: deprecatedValue,
     ...rest
   }, ref) => {
-    const {
-      name: commonName,
-      selectedValue,
-      onChange: commonOnChange,
-      multiple,
-      size
-    } = useSegmentedContext();
-    const isChecked = multiple ? selectedValue[value] : selectedValue === value;
-    const handleChange = (e) => {
-      onChange(e);
-      if (multiple) {
-        commonOnChange({
-          ...selectedValue,
-          [value]: e.target.checked
-        });
-      } else if (e.target.checked) {
-        commonOnChange(value);
-      }
-    };
-    return /* @__PURE__ */ jsxRuntime.jsxs(
-      "label",
+    const [internalValue, setInternalValue] = React.useState(
+      defaultValue ?? null
+    );
+    const [focusedValue, setFocusedValue] = React.useState(null);
+    const id = utils.useRandomId("eds-segmented-control");
+    const isControlled = deprecatedValue !== void 0 || value !== void 0;
+    const currentValue = deprecatedValue !== void 0 ? deprecatedValue : value !== void 0 ? value : internalValue;
+    const handleChange = React.useCallback(
+      (newValue) => {
+        if (!isControlled) {
+          setInternalValue(newValue);
+        }
+        onChange?.(newValue);
+      },
+      [isControlled, onChange]
+    );
+    const contextValue = React.useMemo(
+      () => ({
+        name: name ?? label ?? id,
+        onChange: handleChange,
+        value: currentValue,
+        size,
+        focusedValue,
+        setFocusedValue
+      }),
+      [id, name, handleChange, currentValue, size, focusedValue, label]
+    );
+    const labelId = `${id}-label`;
+    return /* @__PURE__ */ jsxRuntime.jsx(SegmentedContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
       {
-        className: classNames("eds-segmented-choice", className),
-        style,
+        className: classNames("eds-segmented-control", className),
+        role: "radiogroup",
+        "aria-labelledby": label ? labelId : void 0,
+        ref,
+        ...rest,
         children: [
+          label !== void 0 && /* @__PURE__ */ jsxRuntime.jsx(typography.Label, { htmlFor: id, id: labelId, children: label }),
           /* @__PURE__ */ jsxRuntime.jsx(
             "input",
             {
-              type: multiple ? "checkbox" : "radio",
-              name: name || commonName,
-              checked: isChecked,
-              value,
-              onChange: handleChange,
-              ref,
-              ...rest
+              name: name ?? label ?? id,
+              value: currentValue ?? void 0,
+              type: "hidden",
+              id
             }
           ),
-          /* @__PURE__ */ jsxRuntime.jsx(
-            "div",
-            {
-              className: classNames("eds-base-segmented", {
-                "eds-base-segmented--large": size === "large"
-              }),
-              children
-            }
-          )
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "eds-segmented-control__choices", children: React.Children.map(children, (child, index) => {
+            if (index === 0 && React.isValidElement(child))
+              return React.cloneElement(child, {
+                "data-first-child": true
+              });
+            return child;
+          }) })
         ]
       }
-    );
+    ) });
   }
 );
-const SegmentedControl = ({
+const defaultElement = "button";
+const SegmentedChoice = React.forwardRef(function SegmentedChoice2({
   children,
-  label,
-  name,
-  onChange,
-  selectedValue,
-  size = "medium",
   className,
+  style,
+  value,
+  as,
+  onChange,
+  "data-first-child": isFirstChild,
   ...rest
-}) => {
-  return /* @__PURE__ */ jsxRuntime.jsx(
-    SegmentedProvider,
-    {
-      name,
-      selectedValue,
-      onChange,
-      multiple: false,
-      size,
-      children: /* @__PURE__ */ jsxRuntime.jsx(Fieldset, { label, children: /* @__PURE__ */ jsxRuntime.jsx(
-        "div",
-        {
-          className: classNames("eds-segmented-control", className),
-          ...rest,
-          children
+}, ref) {
+  const Element = as || defaultElement;
+  const {
+    value: selectedValue,
+    onChange: contextOnChange,
+    size,
+    focusedValue,
+    setFocusedValue
+  } = useSegmentedContext();
+  const isChecked = selectedValue === value;
+  const tabIndex = React.useMemo(() => {
+    if (selectedValue !== null) return isChecked ? 0 : -1;
+    return isFirstChild ? 0 : -1;
+  }, [isChecked, selectedValue, isFirstChild]);
+  const handleSelection = () => {
+    contextOnChange(value);
+    onChange?.(value);
+  };
+  const handleKeyDown = (e) => {
+    switch (e.key) {
+      case "ArrowLeft":
+      case "ArrowUp": {
+        e.preventDefault();
+        const prevSibling = e.currentTarget.previousElementSibling;
+        if (prevSibling && prevSibling instanceof HTMLElement) {
+          prevSibling.focus();
+          setFocusedValue(prevSibling.getAttribute("data-value") || null);
+        }
+        break;
+      }
+      case "ArrowRight":
+      case "ArrowDown": {
+        e.preventDefault();
+        const nextSibling = e.currentTarget.nextElementSibling;
+        if (nextSibling && nextSibling instanceof HTMLElement) {
+          nextSibling.focus();
+          setFocusedValue(nextSibling.getAttribute("data-value") || null);
+        }
+        break;
+      }
+      case "Home": {
+        e.preventDefault();
+        const firstSibling = e.currentTarget.parentElement?.firstElementChild;
+        if (firstSibling && firstSibling instanceof HTMLElement) {
+          firstSibling.focus();
+          setFocusedValue(firstSibling.getAttribute("data-value") || null);
+        }
+        break;
+      }
+      case "End": {
+        e.preventDefault();
+        const lastSibling = e.currentTarget.parentElement?.lastElementChild;
+        if (lastSibling && lastSibling instanceof HTMLElement) {
+          lastSibling.focus();
+          setFocusedValue(lastSibling.getAttribute("data-value") || null);
         }
-      ) })
+        break;
+      }
+      case " ":
+        e.preventDefault();
+        if (as === "a") {
+          handleSelection();
+          const linkElement = e.currentTarget;
+          if (linkElement.href) {
+            queueMicrotask(() => {
+              linkElement.click();
+            });
+          }
+        } else {
+          handleSelection();
+        }
+        break;
+      case "Enter":
+        handleSelection();
+        break;
+      case "Escape":
+        e.preventDefault();
+        setFocusedValue(null);
+        break;
     }
-  );
-};
-const MultipleSegmentedControl = ({ children, label, name, onChange, selectedValue, ...rest }) => {
-  return /* @__PURE__ */ jsxRuntime.jsxs(
-    SegmentedProvider,
-    {
-      name,
-      selectedValue,
-      onChange,
-      multiple: true,
-      size: "medium",
-      children: [
-        /* @__PURE__ */ jsxRuntime.jsx(typography.Label, { as: "div", children: label }),
-        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "eds-segmented-control", ...rest, children })
-      ]
+  };
+  const onFocus = React.useCallback(() => {
+    setFocusedValue(value);
+  }, [setFocusedValue, value]);
+  const onBlur = React.useCallback(() => {
+    if (focusedValue === value) {
+      setFocusedValue(null);
     }
-  );
-};
+  }, [focusedValue, value, setFocusedValue]);
+  const elementProps = {
+    className: classNames(
+      "eds-segmented-choice",
+      {
+        "eds-segmented-choice--large": size === "large"
+      },
+      className
+    ),
+    style,
+    "aria-checked": isChecked,
+    "data-value": value,
+    ref,
+    tabIndex,
+    onClick: handleSelection,
+    onKeyDown: handleKeyDown,
+    onFocus,
+    onBlur,
+    role: "radio",
+    // For defaultElement button we override type submit
+    ...as === void 0 && { type: "button" },
+    ...rest
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(Element, { ...elementProps, children });
+});
+const SegmentedControlComponent = Object.assign(
+  SegmentedControl,
+  {
+    Item: SegmentedChoice
+  }
+);
+SegmentedControlComponent.Item.displayName = "SegmentedControl.Item";
 utils.warnAboutMissingStyles("form", "icons", "typography");
 exports.BaseFormControl = BaseFormControl;
 exports.Checkbox = Checkbox;
@@ -1037,12 +1115,12 @@ exports.FeedbackText = FeedbackText;
 exports.Fieldset = Fieldset;
 exports.InputGroupContextProvider = InputGroupContextProvider;
 exports.InputGroupLabel = InputGroupLabel;
-exports.MultipleSegmentedControl = MultipleSegmentedControl;
 exports.Radio = Radio;
 exports.RadioGroup = RadioGroup;
 exports.RadioPanel = RadioPanel;
 exports.SegmentedChoice = SegmentedChoice;
-exports.SegmentedControl = SegmentedControl;
+exports.SegmentedControl = SegmentedControlComponent;
+exports.SegmentedControlComponent = SegmentedControlComponent;
 exports.Switch = Switch;
 exports.TextArea = TextArea;
 exports.TextField = TextField;