@hitachivantara/uikit-react-core 5.102.1 → 5.104.0

package/dist/esm/Switch/Switch.js

@@ -1,139 +0,0 @@
-import { jsxs, jsx } from "react/jsx-runtime";
-import { forwardRef, useCallback } from "react";
-import { useDefaultProps } from "@hitachivantara/uikit-react-utils";
-import { useControlled } from "../hooks/useControlled.js";
-import { useUniqueId } from "../hooks/useUniqueId.js";
-import { setId } from "../utils/setId.js";
-import { useClasses } from "./Switch.styles.js";
-import { staticClasses } from "./Switch.styles.js";
-import { HvBaseSwitch } from "../BaseSwitch/BaseSwitch.js";
-import { HvFormElement } from "../FormElement/FormElement.js";
-import { HvLabel } from "../FormElement/Label/Label.js";
-import { isInvalid } from "../FormElement/utils.js";
-import { HvWarningText } from "../FormElement/WarningText/WarningText.js";
-const HvSwitch = forwardRef(
-  function HvSwitch2(props, ref) {
-    const {
-      classes: classesProp,
-      className,
-      id,
-      name,
-      value = "on",
-      required,
-      readOnly,
-      disabled,
-      label,
-      "aria-label": ariaLabel,
-      "aria-labelledby": ariaLabelledBy,
-      "aria-describedby": ariaDescribedBy,
-      labelProps,
-      checked,
-      defaultChecked = false,
-      onChange,
-      status,
-      statusMessage,
-      "aria-errormessage": ariaErrorMessage,
-      inputProps,
-      ...others
-    } = useDefaultProps("HvSwitch", props);
-    const { classes, cx } = useClasses(classesProp);
-    const elementId = useUniqueId(id);
-    const [isChecked, setIsChecked] = useControlled(checked, defaultChecked);
-    const [validationState, setValidationState] = useControlled(
-      status,
-      "standBy"
-    );
-    const [validationMessage] = useControlled(statusMessage, "Required");
-    const onLocalChange = useCallback(
-      (evt, newChecked) => {
-        setIsChecked(() => {
-          if (required && !newChecked) {
-            setValidationState("invalid");
-          } else {
-            setValidationState("valid");
-          }
-          return newChecked;
-        });
-        onChange?.(evt, newChecked, value);
-      },
-      [onChange, required, setIsChecked, setValidationState, value]
-    );
-    const canShowError = ariaErrorMessage == null && (status !== void 0 && statusMessage !== void 0 || status === void 0 && required);
-    const isStateInvalid = isInvalid(validationState);
-    let errorMessageId;
-    if (isStateInvalid) {
-      errorMessageId = canShowError ? setId(elementId, "error") : ariaErrorMessage;
-    }
-    return /* @__PURE__ */ jsxs(
-      HvFormElement,
-      {
-        id,
-        name,
-        status: validationState,
-        disabled,
-        required,
-        readOnly,
-        className: cx(classes.root, className),
-        children: [
-          label && /* @__PURE__ */ jsx(
-            HvLabel,
-            {
-              showGutter: true,
-              id: setId(elementId, "label"),
-              htmlFor: setId(elementId, "input"),
-              label,
-              className: classes.label,
-              ...labelProps
-            }
-          ),
-          /* @__PURE__ */ jsx(
-            "div",
-            {
-              className: cx(classes.switchContainer, {
-                [classes.invalidSwitch]: isStateInvalid
-              }),
-              children: /* @__PURE__ */ jsx(
-                HvBaseSwitch,
-                {
-                  ref,
-                  id: label ? setId(elementId, "input") : setId(id, "input"),
-                  name,
-                  disabled,
-                  readOnly,
-                  required,
-                  onChange: onLocalChange,
-                  value,
-                  checked: isChecked,
-                  inputProps: {
-                    "aria-invalid": isStateInvalid ? true : void 0,
-                    "aria-errormessage": errorMessageId,
-                    "aria-label": ariaLabel,
-                    "aria-labelledby": ariaLabelledBy,
-                    "aria-describedby": ariaDescribedBy,
-                    ...inputProps
-                  },
-                  ...others
-                }
-              )
-            }
-          ),
-          canShowError && /* @__PURE__ */ jsx(
-            HvWarningText,
-            {
-              id: setId(elementId, "error"),
-              className: classes.error,
-              disableBorder: true,
-              disableAdornment: true,
-              hideText: true,
-              children: validationMessage
-            }
-          )
-        ]
-      }
-    );
-  }
-);
-export {
-  HvSwitch,
-  staticClasses as switchClasses
-};

package/dist/esm/Switch/Switch.styles.js

@@ -1,26 +0,0 @@
-import { createClasses } from "@hitachivantara/uikit-react-utils";
-import { theme } from "@hitachivantara/uikit-styles";
-const { staticClasses, useClasses } = createClasses("HvSwitch", {
-  root: {
-    display: "inline-flex",
-    flexDirection: "column",
-    alignItems: "flex-start"
-  },
-  label: {},
-  error: {},
-  switchContainer: {
-    height: "32px",
-    display: "flex",
-    flexDirection: "column",
-    justifyContent: "center",
-    borderBottom: "1px solid transparent"
-  },
-  invalidSwitch: {
-    paddingBottom: "1px",
-    borderBottom: `1px solid ${theme.form.errorColor}`
-  }
-});
-export {
-  staticClasses,
-  useClasses
-};

package/dist/esm/TreeView/internals/DescendantProvider.js

@@ -1,129 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import * as React from "react";
-import { unstable_useEnhancedEffect } from "@mui/material/utils";
-function binaryFindElement(array, element) {
-  let start = 0;
-  let end = array.length - 1;
-  while (start <= end) {
-    const middle = Math.floor((start + end) / 2);
-    if (array[middle].element === element) {
-      return middle;
-    }
-    if (
-      // eslint-disable-next-line no-bitwise
-      array[middle].element.compareDocumentPosition(element) & Node.DOCUMENT_POSITION_PRECEDING
-    ) {
-      end = middle - 1;
-    } else {
-      start = middle + 1;
-    }
-  }
-  return start;
-}
-const DescendantContext = React.createContext({
-  level: 0
-});
-function usePrevious(value) {
-  const ref = React.useRef(null);
-  React.useEffect(() => {
-    ref.current = value;
-  }, [value]);
-  return ref.current;
-}
-const noop = () => {
-};
-function useDescendant(descendant) {
-  const [, forceUpdate] = React.useState();
-  const {
-    registerDescendant = noop,
-    unregisterDescendant = noop,
-    descendants = [],
-    parentId = null,
-    level = 0
-  } = React.useContext(DescendantContext);
-  const index = descendants.findIndex(
-    (item) => item.element === descendant.element
-  );
-  const previousDescendants = usePrevious(descendants);
-  const someDescendantsHaveChanged = descendants.some(
-    (newDescendant, position) => {
-      return previousDescendants?.[position] && previousDescendants[position].element !== newDescendant.element;
-    }
-  );
-  unstable_useEnhancedEffect(() => {
-    if (descendant.element) {
-      registerDescendant({
-        ...descendant,
-        index
-      });
-      return () => {
-        unregisterDescendant(descendant.element);
-      };
-    }
-    forceUpdate({});
-    return void 0;
-  }, [
-    registerDescendant,
-    unregisterDescendant,
-    index,
-    someDescendantsHaveChanged,
-    descendant
-  ]);
-  return { parentId, index, level };
-}
-const DescendantProvider = (props) => {
-  const { children, id, level } = props;
-  const [items, set] = React.useState([]);
-  const registerDescendant = React.useCallback(
-    ({ element, ...other }) => {
-      set((oldItems) => {
-        if (oldItems.length === 0) {
-          return [
-            {
-              ...other,
-              element,
-              index: 0
-            }
-          ];
-        }
-        const index = binaryFindElement(oldItems, element);
-        let newItems;
-        if (oldItems[index] && oldItems[index].element === element) {
-          newItems = oldItems;
-        } else {
-          const newItem = {
-            ...other,
-            element,
-            index
-          };
-          newItems = oldItems.slice();
-          newItems.splice(index, 0, newItem);
-        }
-        newItems.forEach((item, position) => {
-          item.index = position;
-        });
-        return newItems;
-      });
-    },
-    []
-  );
-  const unregisterDescendant = React.useCallback((element) => {
-    set((oldItems) => oldItems.filter((item) => element !== item.element));
-  }, []);
-  const value = React.useMemo(
-    () => ({
-      descendants: items,
-      registerDescendant,
-      unregisterDescendant,
-      parentId: id,
-      level
-    }),
-    [items, registerDescendant, unregisterDescendant, id, level]
-  );
-  return /* @__PURE__ */ jsx(DescendantContext.Provider, { value, children });
-};
-export {
-  DescendantContext,
-  DescendantProvider,
-  useDescendant
-};

package/dist/esm/TreeView/internals/hooks/plugins/useTreeViewExpansion.js

@@ -1,66 +0,0 @@
-import * as React from "react";
-import { useEventCallback } from "@mui/material/utils";
-import { populateInstance } from "../utils.js";
-const useTreeViewExpansion = ({ instance, params, models }) => {
-  const isNodeExpanded = React.useCallback(
-    (nodeId) => {
-      return Array.isArray(models.expanded.value) ? models.expanded.value.indexOf(nodeId) !== -1 : false;
-    },
-    [models.expanded.value]
-  );
-  const isNodeExpandable = React.useCallback(
-    (nodeId) => !!instance.getNode(nodeId)?.expandable,
-    [instance]
-  );
-  const toggleNodeExpansion = useEventCallback(
-    (event, nodeId) => {
-      if (nodeId == null) {
-        return;
-      }
-      let newExpanded;
-      if (models.expanded.value.indexOf(nodeId) !== -1) {
-        newExpanded = models.expanded.value.filter((id) => id !== nodeId);
-      } else {
-        newExpanded = [nodeId].concat(models.expanded.value);
-      }
-      if (params.onNodeToggle) {
-        params.onNodeToggle(event, newExpanded);
-      }
-      models.expanded.setValue(newExpanded);
-    }
-  );
-  const expandAllSiblings = (event, nodeId) => {
-    const node = instance.getNode(nodeId);
-    const siblings = instance.getChildrenIds(node.parentId);
-    const diff = siblings.filter(
-      (child) => instance.isNodeExpandable(child) && !instance.isNodeExpanded(child)
-    );
-    const newExpanded = models.expanded.value.concat(diff);
-    if (diff.length > 0) {
-      models.expanded.setValue(newExpanded);
-      if (params.onNodeToggle) {
-        params.onNodeToggle(event, newExpanded);
-      }
-    }
-  };
-  populateInstance(instance, {
-    isNodeExpanded,
-    isNodeExpandable,
-    toggleNodeExpansion,
-    expandAllSiblings
-  });
-};
-useTreeViewExpansion.models = {
-  expanded: {
-    controlledProp: "expanded",
-    defaultProp: "defaultExpanded"
-  }
-};
-const DEFAULT_EXPANDED = [];
-useTreeViewExpansion.getDefaultizedParams = (params) => ({
-  ...params,
-  defaultExpanded: params.defaultExpanded ?? DEFAULT_EXPANDED
-});
-export {
-  useTreeViewExpansion
-};

package/dist/esm/TreeView/internals/hooks/plugins/useTreeViewFocus.js

@@ -1,85 +0,0 @@
-import * as React from "react";
-import { useEventCallback, ownerDocument } from "@mui/material/utils";
-import { useInstanceEventHandler } from "../useInstanceEventHandler.js";
-import { populateInstance } from "../utils.js";
-const useTreeViewFocus = ({
-  instance,
-  params,
-  state,
-  setState,
-  models,
-  rootRef
-}) => {
-  const setFocusedNodeId = useEventCallback(
-    (nodeId) => {
-      const cleanNodeId = typeof nodeId === "function" ? nodeId(state.focusedNodeId) : nodeId;
-      setState((prevState) => ({ ...prevState, focusedNodeId: cleanNodeId }));
-    }
-  );
-  const isNodeFocused = React.useCallback(
-    (nodeId) => state.focusedNodeId === nodeId,
-    [state.focusedNodeId]
-  );
-  const focusNode = useEventCallback(
-    (event, nodeId) => {
-      if (nodeId) {
-        setFocusedNodeId(nodeId);
-        if (params.onNodeFocus) {
-          params.onNodeFocus(event, nodeId);
-        }
-      }
-    }
-  );
-  populateInstance(instance, {
-    isNodeFocused,
-    focusNode
-  });
-  useInstanceEventHandler(instance, "removeNode", ({ id }) => {
-    setFocusedNodeId((oldFocusedNodeId) => {
-      if (oldFocusedNodeId === id && rootRef.current === ownerDocument(rootRef.current).activeElement) {
-        return instance.getChildrenIds(null)[0];
-      }
-      return oldFocusedNodeId;
-    });
-  });
-  const createHandleFocus = (otherHandlers) => (event) => {
-    otherHandlers.onFocus?.(event);
-    if (event.target === event.currentTarget) {
-      const isNodeVisible = (nodeId) => {
-        const node = instance.getNode(nodeId);
-        return node && (node.parentId == null || instance.isNodeExpanded(node.parentId));
-      };
-      let nodeToFocusId;
-      if (Array.isArray(models.selected.value)) {
-        nodeToFocusId = models.selected.value.find(isNodeVisible);
-      } else if (models.selected.value != null && isNodeVisible(models.selected.value)) {
-        nodeToFocusId = models.selected.value;
-      }
-      if (nodeToFocusId == null) {
-        nodeToFocusId = instance.getNavigableChildrenIds(null)[0];
-      }
-      instance.focusNode(event, nodeToFocusId);
-    }
-  };
-  const createHandleBlur = (otherHandlers) => (event) => {
-    otherHandlers.onBlur?.(event);
-    setFocusedNodeId(null);
-  };
-  const focusedNode = instance.getNode(state.focusedNodeId);
-  const activeDescendant = focusedNode ? focusedNode.idAttribute : null;
-  return {
-    getRootProps: (otherHandlers) => ({
-      onFocus: createHandleFocus(otherHandlers),
-      onBlur: createHandleBlur(otherHandlers),
-      "aria-activedescendant": activeDescendant ?? void 0
-    })
-  };
-};
-useTreeViewFocus.getInitialState = () => ({ focusedNodeId: null });
-useTreeViewFocus.getDefaultizedParams = (params) => ({
-  ...params,
-  disabledItemsFocusable: params.disabledItemsFocusable ?? false
-});
-export {
-  useTreeViewFocus
-};

package/dist/esm/TreeView/internals/hooks/plugins/useTreeViewKeyboardNavigation.js

@@ -1,218 +0,0 @@
-import * as React from "react";
-import { useTheme } from "@mui/material/styles";
-import { useEventCallback } from "@mui/material/utils";
-import { populateInstance, getLastNode, getFirstNode, getPreviousNode, getNextNode } from "../utils.js";
-function isPrintableCharacter(string) {
-  return string && string.length === 1 && string.match(/\S/);
-}
-function findNextFirstChar(firstChars, startIndex, char) {
-  for (let i = startIndex; i < firstChars.length; i += 1) {
-    if (char === firstChars[i]) {
-      return i;
-    }
-  }
-  return -1;
-}
-const useTreeViewKeyboardNavigation = ({ instance, params, state }) => {
-  const theme = useTheme();
-  const isRtl = theme.direction === "rtl";
-  const firstCharMap = React.useRef({});
-  const mapFirstChar = useEventCallback((nodeId, firstChar) => {
-    firstCharMap.current[nodeId] = firstChar;
-    return () => {
-      const newMap = { ...firstCharMap.current };
-      delete newMap[nodeId];
-      firstCharMap.current = newMap;
-    };
-  });
-  populateInstance(instance, {
-    mapFirstChar
-  });
-  const handleNextArrow = (event) => {
-    if (state.focusedNodeId != null && instance.isNodeExpandable(state.focusedNodeId)) {
-      if (instance.isNodeExpanded(state.focusedNodeId)) {
-        instance.focusNode(event, getNextNode(instance, state.focusedNodeId));
-      } else if (!instance.isNodeDisabled(state.focusedNodeId)) {
-        instance.toggleNodeExpansion(event, state.focusedNodeId);
-      }
-    }
-    return true;
-  };
-  const handlePreviousArrow = (event) => {
-    if (state.focusedNodeId == null) {
-      return false;
-    }
-    if (instance.isNodeExpanded(state.focusedNodeId) && !instance.isNodeDisabled(state.focusedNodeId)) {
-      instance.toggleNodeExpansion(event, state.focusedNodeId);
-      return true;
-    }
-    const parent = instance.getNode(state.focusedNodeId).parentId;
-    if (parent) {
-      instance.focusNode(event, parent);
-      return true;
-    }
-    return false;
-  };
-  const focusByFirstCharacter = (event, nodeId, firstChar) => {
-    let start;
-    let index;
-    const lowercaseChar = firstChar.toLowerCase();
-    const firstCharIds = [];
-    const firstChars = [];
-    Object.keys(firstCharMap.current).forEach((mapNodeId) => {
-      const map = instance.getNode(mapNodeId);
-      const visible = map.parentId ? instance.isNodeExpanded(map.parentId) : true;
-      const shouldBeSkipped = params.disabledItemsFocusable ? false : instance.isNodeDisabled(mapNodeId);
-      if (visible && !shouldBeSkipped) {
-        firstCharIds.push(mapNodeId);
-        firstChars.push(firstCharMap.current[mapNodeId]);
-      }
-    });
-    start = firstCharIds.indexOf(nodeId) + 1;
-    if (start >= firstCharIds.length) {
-      start = 0;
-    }
-    index = findNextFirstChar(firstChars, start, lowercaseChar);
-    if (index === -1) {
-      index = findNextFirstChar(firstChars, 0, lowercaseChar);
-    }
-    if (index > -1) {
-      instance.focusNode(event, firstCharIds[index]);
-    }
-  };
-  const selectNextNode = (event, id) => {
-    if (!instance.isNodeDisabled(getNextNode(instance, id))) {
-      instance.selectRange(
-        event,
-        {
-          end: getNextNode(instance, id),
-          current: id
-        },
-        true
-      );
-    }
-  };
-  const selectPreviousNode = (event, nodeId) => {
-    if (!instance.isNodeDisabled(getPreviousNode(instance, nodeId))) {
-      instance.selectRange(
-        event,
-        {
-          end: getPreviousNode(instance, nodeId),
-          current: nodeId
-        },
-        true
-      );
-    }
-  };
-  const createHandleKeyDown = (otherHandlers) => (event) => {
-    otherHandlers.onKeyDown?.(event);
-    let flag = false;
-    const { key } = event;
-    if (event.altKey || event.currentTarget !== event.target || state.focusedNodeId == null) {
-      return;
-    }
-    const ctrlPressed = event.ctrlKey || event.metaKey;
-    switch (key) {
-      case " ":
-        if (!params.disableSelection && !instance.isNodeDisabled(state.focusedNodeId)) {
-          flag = true;
-          if (params.multiSelect && event.shiftKey) {
-            instance.selectRange(event, { end: state.focusedNodeId });
-          } else if (params.multiSelect) {
-            instance.selectNode(event, state.focusedNodeId, true);
-          } else {
-            instance.selectNode(event, state.focusedNodeId);
-          }
-        }
-        event.stopPropagation();
-        break;
-      case "Enter":
-        if (!instance.isNodeDisabled(state.focusedNodeId)) {
-          if (instance.isNodeExpandable(state.focusedNodeId)) {
-            instance.toggleNodeExpansion(event, state.focusedNodeId);
-            flag = true;
-          } else if (!params.disableSelection) {
-            flag = true;
-            if (params.multiSelect) {
-              instance.selectNode(event, state.focusedNodeId, true);
-            } else {
-              instance.selectNode(event, state.focusedNodeId);
-            }
-          }
-        }
-        event.stopPropagation();
-        break;
-      case "ArrowDown":
-        if (params.multiSelect && event.shiftKey && !params.disableSelection) {
-          selectNextNode(event, state.focusedNodeId);
-        }
-        instance.focusNode(event, getNextNode(instance, state.focusedNodeId));
-        flag = true;
-        break;
-      case "ArrowUp":
-        if (params.multiSelect && event.shiftKey && !params.disableSelection) {
-          selectPreviousNode(event, state.focusedNodeId);
-        }
-        instance.focusNode(
-          event,
-          getPreviousNode(instance, state.focusedNodeId)
-        );
-        flag = true;
-        break;
-      case "ArrowRight":
-        if (isRtl) {
-          flag = handlePreviousArrow(event);
-        } else {
-          flag = handleNextArrow(event);
-        }
-        break;
-      case "ArrowLeft":
-        if (isRtl) {
-          flag = handleNextArrow(event);
-        } else {
-          flag = handlePreviousArrow(event);
-        }
-        break;
-      case "Home":
-        if (params.multiSelect && ctrlPressed && event.shiftKey && !params.disableSelection && !instance.isNodeDisabled(state.focusedNodeId)) {
-          instance.rangeSelectToFirst(event, state.focusedNodeId);
-        }
-        instance.focusNode(event, getFirstNode(instance));
-        flag = true;
-        break;
-      case "End":
-        if (params.multiSelect && ctrlPressed && event.shiftKey && !params.disableSelection && !instance.isNodeDisabled(state.focusedNodeId)) {
-          instance.rangeSelectToLast(event, state.focusedNodeId);
-        }
-        instance.focusNode(event, getLastNode(instance));
-        flag = true;
-        break;
-      default:
-        if (key === "*") {
-          instance.expandAllSiblings(event, state.focusedNodeId);
-          flag = true;
-        } else if (params.multiSelect && ctrlPressed && key.toLowerCase() === "a" && !params.disableSelection) {
-          instance.selectRange(event, {
-            start: getFirstNode(instance),
-            end: getLastNode(instance)
-          });
-          flag = true;
-        } else if (!ctrlPressed && !event.shiftKey && isPrintableCharacter(key)) {
-          focusByFirstCharacter(event, state.focusedNodeId, key);
-          flag = true;
-        }
-    }
-    if (flag) {
-      event.preventDefault();
-      event.stopPropagation();
-    }
-  };
-  return {
-    getRootProps: (otherHandlers) => ({
-      onKeyDown: createHandleKeyDown(otherHandlers)
-    })
-  };
-};
-export {
-  useTreeViewKeyboardNavigation
-};