@onewelcome/react-lib-components 1.2.0 → 1.4.0

package/src/Tooltip/Tooltip.tsx

@@ -16,6 +16,7 @@
 
 import React, {
   ComponentPropsWithRef,
+  ForwardRefRenderFunction,
   ReactElement,
   ReactNode,
   useEffect,
@@ -50,110 +51,110 @@ const defaultPosition: DefaultPosition = {
   transformOrigin: { horizontal: "left", vertical: "center" }
 };
 
-export const Tooltip = React.forwardRef<HTMLDivElement, Props>(
-  (
-    {
-      children,
-      className,
-      placement = defaultPosition.placement,
-      offset = defaultPosition.offset,
-      transformOrigin = defaultPosition.transformOrigin,
-      domRoot = document.body,
-      label,
-      ...rest
-    }: Props,
-    ref
-  ) => {
-    const [identifier] = useState(generateID());
-    const [visible, setVisible] = useState(false);
-
-    const relativeElement = useRef<HTMLDivElement>(null);
-    const elementToBePositioned = useRef<HTMLDivElement>(null);
-
-    const { top, bottom, right, left, calculatePosition } = usePosition({
-      relativeElement: relativeElement,
-      elementToBePositioned: elementToBePositioned,
-      placement: placement,
-      offset: offset,
-      transformOrigin: transformOrigin
-    });
-
-    useEffect(() => {
-      if (!visible) return;
-
-      function escapePressHandler(event: KeyboardEvent) {
-        if (event.key === "Escape") {
-          setVisible(false);
-        }
-      }
+const TooltipComponent: ForwardRefRenderFunction<HTMLDivElement, Props> = (
+  {
+    children,
+    className,
+    placement = defaultPosition.placement,
+    offset = defaultPosition.offset,
+    transformOrigin = defaultPosition.transformOrigin,
+    domRoot = document.body,
+    label,
+    ...rest
+  }: Props,
+  ref
+) => {
+  const [identifier] = useState(generateID());
+  const [visible, setVisible] = useState(false);
+
+  const relativeElement = useRef<HTMLDivElement>(null);
+  const elementToBePositioned = useRef<HTMLDivElement>(null);
+
+  const { top, bottom, right, left, calculatePosition } = usePosition({
+    relativeElement: relativeElement,
+    elementToBePositioned: elementToBePositioned,
+    placement: placement,
+    offset: offset,
+    transformOrigin: transformOrigin
+  });
 
-      document.addEventListener("keyup", escapePressHandler);
-
-      return () => {
-        document.removeEventListener("keyup", escapePressHandler);
-      };
-    }, [visible]);
-
-    useLayoutEffect(() => {
-      calculatePosition();
-    }, [visible]);
-
-    const renderChildren = () => {
-      if (React.isValidElement(label)) {
-        return React.cloneElement(label as ReactElement, {
-          onFocus: () => setVisible(true),
-          onBlur: () => setVisible(false),
-          "aria-describedby": identifier,
-          tabIndex: 0,
-          className: classes["label"]
-        });
+  useEffect(() => {
+    if (!visible) return;
+
+    function escapePressHandler(event: KeyboardEvent) {
+      if (event.key === "Escape") {
+        setVisible(false);
       }
+    }
+
+    document.addEventListener("keyup", escapePressHandler);
 
-      return (
-        <span
-          className={classes["label"]}
-          tabIndex={0}
-          onFocus={() => setVisible(true)}
-          onBlur={() => setVisible(false)}
-          aria-describedby={identifier}
-        >
-          {label}
-        </span>
-      );
+    return () => {
+      document.removeEventListener("keyup", escapePressHandler);
     };
+  }, [visible]);
+
+  useLayoutEffect(() => {
+    calculatePosition();
+  }, [visible]);
+
+  const renderChildren = () => {
+    if (React.isValidElement(label)) {
+      return React.cloneElement(label as ReactElement, {
+        onFocus: () => setVisible(true),
+        onBlur: () => setVisible(false),
+        "aria-describedby": identifier,
+        tabIndex: 0,
+        className: classes["label"]
+      });
+    }
 
     return (
-      <div {...rest} ref={ref} className={`${classes.wrapper} ${className ?? ""}`}>
-        {renderChildren()}
-        <div className={`${classes["tooltip-wrapper"]}`}>
-          <Icon
-            ref={relativeElement}
-            tag="div"
-            onMouseEnter={() => setVisible(true)}
-            onMouseLeave={() => setVisible(false)}
-            icon={Icons.InfoCircle}
-            className={classes.icon}
-          />
-          {createPortal(
-            <div
-              ref={elementToBePositioned}
-              style={{
-                ...rest.style,
-                top: top,
-                left: left,
-                right: right,
-                bottom: bottom
-              }}
-              aria-hidden={!visible}
-              id={identifier}
-              className={`${classes.tooltip} ${visible ? classes.visible : ""}`}
-            >
-              {children}
-            </div>,
-            domRoot
-          )}
-        </div>
-      </div>
+      <span
+        className={classes["label"]}
+        tabIndex={0}
+        onFocus={() => setVisible(true)}
+        onBlur={() => setVisible(false)}
+        aria-describedby={identifier}
+      >
+        {label}
+      </span>
     );
-  }
-);
+  };
+
+  return (
+    <div {...rest} ref={ref} className={`${classes.wrapper} ${className ?? ""}`}>
+      {renderChildren()}
+      <div className={`${classes["tooltip-wrapper"]}`}>
+        <Icon
+          ref={relativeElement}
+          tag="div"
+          onMouseEnter={() => setVisible(true)}
+          onMouseLeave={() => setVisible(false)}
+          icon={Icons.InfoCircle}
+          className={classes.icon}
+        />
+        {createPortal(
+          <div
+            ref={elementToBePositioned}
+            style={{
+              ...rest.style,
+              top: top,
+              left: left,
+              right: right,
+              bottom: bottom
+            }}
+            aria-hidden={!visible}
+            id={identifier}
+            className={`${classes.tooltip} ${visible ? classes.visible : ""}`}
+          >
+            {children}
+          </div>,
+          domRoot
+        )}
+      </div>
+    </div>
+  );
+};
+
+export const Tooltip = React.forwardRef(TooltipComponent);

package/src/Typography/Typography.tsx

@@ -14,7 +14,7 @@
  *    limitations under the License.
  */
 
-import React, { ComponentPropsWithRef, ReactNode } from "react";
+import React, { ForwardRefRenderFunction, ComponentPropsWithRef, ReactNode } from "react";
 import classes from "./Typography.module.scss";
 import { Spacing, useSpacing } from "../hooks/useSpacing";
 
@@ -56,51 +56,54 @@ export interface Props extends ComponentPropsWithRef<any> {
   spacing?: Spacing;
 }
 
-export const Typography = React.forwardRef<any, Props>(
-  ({ children, variant, tag, style, spacing, className = "", ...rest }: Props, ref) => {
-    if (!validVariants.includes(variant)) {
-      throw new Error(
-        `You entered an invalid variant. You can choose from: ${validVariants}, you entered: ${variant}`
-      );
-    }
+const TypographyComponent: ForwardRefRenderFunction<any, Props> = (
+  { children, variant, tag, style, spacing, className = "", ...rest }: Props,
+  ref
+) => {
+  if (!validVariants.includes(variant)) {
+    throw new Error(
+      `You entered an invalid variant. You can choose from: ${validVariants}, you entered: ${variant}`
+    );
+  }
 
-    const styleWithSpacing = useSpacing(spacing, style);
+  const styleWithSpacing = useSpacing(spacing, style);
 
-    if (!tag) {
-      switch (variant) {
-        case "h1":
-        case "h2":
-        case "h3":
-        case "h4":
-        case "code":
-          tag = variant;
-          break;
-        case "body":
-          tag = "p";
-          break;
-        case "body-bold":
-          tag = "p";
-          break;
-        case "sub-text":
-          tag = "span";
-          break;
-        default:
-          tag = "div";
-          break;
-      }
+  if (!tag) {
+    switch (variant) {
+      case "h1":
+      case "h2":
+      case "h3":
+      case "h4":
+      case "code":
+        tag = variant;
+        break;
+      case "body":
+        tag = "p";
+        break;
+      case "body-bold":
+        tag = "p";
+        break;
+      case "sub-text":
+        tag = "span";
+        break;
+      default:
+        tag = "div";
+        break;
     }
+  }
 
-    let TagName = tag;
+  let TagName = tag;
 
-    return (
-      <TagName
-        {...rest}
-        ref={ref}
-        style={styleWithSpacing}
-        className={`${classes["typography_style_" + variant]} ${className}`}
-      >
-        {children}
-      </TagName>
-    );
-  }
-);
+  return (
+    <TagName
+      {...rest}
+      ref={ref}
+      style={styleWithSpacing}
+      className={`${classes["typography_style_" + variant]} ${className}`}
+    >
+      {children}
+    </TagName>
+  );
+};
+
+export const Typography = React.forwardRef(TypographyComponent);

package/src/Wizard/BaseWizardSteps/BaseWizardSteps.tsx

@@ -14,7 +14,7 @@
  *    limitations under the License.
  */
 
-import React, { ComponentPropsWithRef, Fragment } from "react";
+import React, { ForwardRefRenderFunction, ComponentPropsWithRef, Fragment } from "react";
 import classes from "./BaseWizardSteps.module.scss";
 import { Icon, Icons } from "../../Icon/Icon";
 
@@ -32,59 +32,62 @@ export interface Props extends Omit<ComponentPropsWithRef<"div">, "onClick"> {
   futureStepsClickable?: boolean;
 }
 
-export const BaseWizardSteps = React.forwardRef<HTMLDivElement, Props>(
-  ({ steps, currentStepNo, onClick, futureStepsClickable = false, ...rest }: Props, ref) => {
-    const getStepState = (stepNo: number): StepState => {
-      if (currentStepNo === stepNo) {
-        return "current";
-      } else if (stepNo < currentStepNo) {
-        return "finished";
-      }
-      return "future";
-    };
+const BaseWizardStepsComponent: ForwardRefRenderFunction<HTMLDivElement, Props> = (
+  { steps, currentStepNo, onClick, futureStepsClickable = false, ...rest }: Props,
+  ref
+) => {
+  const getStepState = (stepNo: number): StepState => {
+    if (currentStepNo === stepNo) {
+      return "current";
+    } else if (stepNo < currentStepNo) {
+      return "finished";
+    }
+    return "future";
+  };
 
-    const getStepContent = (stepState: StepState, index: number, disabled?: boolean) => {
-      const stepNumberString = String(index + 1);
-      if (stepState === "finished") {
-        return disabled ? null : <Icon className={classes["checkmark"]} icon={Icons.Checkmark} />;
-      } else {
-        return <Fragment>{stepNumberString}</Fragment>;
-      }
-    };
+  const getStepContent = (stepState: StepState, index: number, disabled?: boolean) => {
+    const stepNumberString = String(index + 1);
+    if (stepState === "finished") {
+      return disabled ? null : <Icon className={classes["checkmark"]} icon={Icons.Checkmark} />;
+    } else {
+      return <Fragment>{stepNumberString}</Fragment>;
+    }
+  };
 
-    const generatedSteps = steps.map((step, index) => {
-      const stepState = getStepState(index);
-      const disabledStyleClassName = step.disabled ? classes["disabled"] : "";
-      const clickableClassName = futureStepsClickable ? classes["clickable"] : "";
-
-      return (
-        <button
-          key={step.label.toLowerCase().replace(/\s/, "-")}
-          disabled={
-            step.disabled ||
-            (stepState === "future" && !futureStepsClickable) ||
-            stepState === "current"
-          }
-          aria-current={stepState === "current" ? "step" : undefined}
-          onClick={() => onClick && onClick(index)}
-          className={`${classes["wizard-element"]} ${classes[stepState]} ${clickableClassName} ${disabledStyleClassName}`}
-        >
-          <div className={classes["number-wrapper"]}>
-            <span className={classes["number"]}>
-              {getStepContent(stepState, index, step.disabled)}
-            </span>
-          </div>
-          <div className={classes["two-line-text-overflow"]}>
-            <span className={classes["label"]}>{step.label}</span>
-          </div>
-        </button>
-      );
-    });
+  const generatedSteps = steps.map((step, index) => {
+    const stepState = getStepState(index);
+    const disabledStyleClassName = step.disabled ? classes["disabled"] : "";
+    const clickableClassName = futureStepsClickable ? classes["clickable"] : "";
 
     return (
-      <div {...rest} ref={ref} className={classes["wizard"]}>
-        {generatedSteps}
-      </div>
+      <button
+        key={step.label.toLowerCase().replace(/\s/, "-")}
+        disabled={
+          step.disabled ||
+          (stepState === "future" && !futureStepsClickable) ||
+          stepState === "current"
+        }
+        aria-current={stepState === "current" ? "step" : undefined}
+        onClick={() => onClick && onClick(index)}
+        className={`${classes["wizard-element"]} ${classes[stepState]} ${clickableClassName} ${disabledStyleClassName}`}
+      >
+        <div className={classes["number-wrapper"]}>
+          <span className={classes["number"]}>
+            {getStepContent(stepState, index, step.disabled)}
+          </span>
+        </div>
+        <div className={classes["two-line-text-overflow"]}>
+          <span className={classes["label"]}>{step.label}</span>
+        </div>
+      </button>
     );
-  }
-);
+  });
+
+  return (
+    <div {...rest} ref={ref} className={classes["wizard"]}>
+      {generatedSteps}
+    </div>
+  );
+};
+
+export const BaseWizardSteps = React.forwardRef(BaseWizardStepsComponent);

package/src/Wizard/WizardSteps/WizardSteps.tsx

@@ -14,7 +14,7 @@
  *    limitations under the License.
  */
 
-import React, { ComponentPropsWithRef, useContext } from "react";
+import React, { ForwardRefRenderFunction, ComponentPropsWithRef, useContext } from "react";
 import { WizardStateContext } from "../WizardStateProvider";
 import { BaseWizardSteps } from "../BaseWizardSteps/BaseWizardSteps";
 import { changeCurrentStepNo } from "../wizardStateReducer";
@@ -23,26 +23,29 @@ export interface Props extends ComponentPropsWithRef<"div"> {
   onStepClick: (currentStepNo: number, selectedStepNo: number) => boolean;
 }
 
-export const WizardSteps = React.forwardRef<HTMLDivElement, Props>(
-  ({ onStepClick, ...rest }: Props, ref) => {
-    const {
-      state: { currentStepNo, mode, steps },
-      dispatch
-    } = useContext(WizardStateContext);
+const WizardStepsComponent: ForwardRefRenderFunction<HTMLDivElement, Props> = (
+  { onStepClick, ...rest }: Props,
+  ref
+) => {
+  const {
+    state: { currentStepNo, mode, steps },
+    dispatch
+  } = useContext(WizardStateContext);
 
-    const onClick = (selectedStepNo: number) => {
-      onStepClick(currentStepNo, selectedStepNo) && dispatch(changeCurrentStepNo(selectedStepNo));
-    };
+  const onClick = (selectedStepNo: number) => {
+    onStepClick(currentStepNo, selectedStepNo) && dispatch(changeCurrentStepNo(selectedStepNo));
+  };
 
-    return (
-      <BaseWizardSteps
-        {...rest}
-        ref={ref}
-        onClick={onClick}
-        steps={steps}
-        currentStepNo={currentStepNo}
-        futureStepsClickable={mode === "edit"}
-      />
-    );
-  }
-);
+  return (
+    <BaseWizardSteps
+      {...rest}
+      ref={ref}
+      onClick={onClick}
+      steps={steps}
+      currentStepNo={currentStepNo}
+      futureStepsClickable={mode === "edit"}
+    />
+  );
+};
+
+export const WizardSteps = React.forwardRef(WizardStepsComponent);

package/src/hooks/useDebouncedCallback.test.ts

@@ -0,0 +1,140 @@
+import { renderHook, act } from "@testing-library/react-hooks";
+import { useDebouncedCallback } from "./useDebouncedCallback";
+
+const BASE_DELAY = 300;
+const EXTRA_DELAY = 200;
+
+const sleep = (delay: number) => new Promise(resolve => setTimeout(resolve, delay));
+
+describe("Testing the useDebouncedCallback hook", () => {
+  it("should run callback after specified delay", async () => {
+    const delay = BASE_DELAY;
+    const callback = jest.fn();
+
+    const { result } = renderHook(() => useDebouncedCallback(callback, delay));
+
+    expect(callback).toHaveBeenCalledTimes(0);
+    act(result.current);
+    await sleep(delay + EXTRA_DELAY);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    act(result.current);
+    await sleep(delay + EXTRA_DELAY);
+
+    expect(callback).toHaveBeenCalledTimes(2);
+  });
+
+  it("should pass args through to callback function", async () => {
+    let mutableValue = "";
+    const delay = BASE_DELAY;
+    const callback = jest.fn(arg => (mutableValue = `got arg ${arg}`));
+
+    const { result } = renderHook(() => useDebouncedCallback(callback, delay));
+
+    act(() => result.current("passthrough"));
+    await sleep(delay + EXTRA_DELAY);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(mutableValue).toBe(`got arg passthrough`);
+  });
+
+  it("should cancel pending call if fn is called again", async () => {
+    const delay = BASE_DELAY;
+    const callback = jest.fn();
+
+    const { result } = renderHook(() => useDebouncedCallback(callback, delay));
+
+    expect(callback).toHaveBeenCalledTimes(0);
+    act(result.current);
+    await sleep(delay / 2);
+
+    act(result.current);
+    await sleep(delay + EXTRA_DELAY);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+  });
+
+  it("should cancel pending call if callback changes", async () => {
+    const delay = BASE_DELAY;
+    const callback1 = jest.fn();
+    const callback2 = jest.fn();
+
+    const { result, rerender } = renderHook(
+      ({ callback, delay }) => useDebouncedCallback(callback, delay),
+      { initialProps: { callback: callback1, delay } }
+    );
+
+    act(result.current);
+    await sleep(delay / 2);
+
+    rerender({ callback: callback2, delay });
+    act(result.current);
+    await sleep(delay + EXTRA_DELAY);
+
+    expect(callback1).toHaveBeenCalledTimes(0);
+    expect(callback2).toHaveBeenCalledTimes(1);
+  });
+
+  it("should cancel pending call if delay changes", async () => {
+    const delay1 = BASE_DELAY;
+    const delay2 = BASE_DELAY * 2;
+    const callback = jest.fn();
+
+    const { result, rerender } = renderHook(
+      ({ callback, delay }) => useDebouncedCallback(callback, delay),
+      { initialProps: { callback, delay: delay1 } }
+    );
+
+    act(result.current);
+    await sleep(delay1 / 2);
+
+    rerender({ callback, delay: delay2 });
+    act(result.current);
+    await sleep(delay2 + EXTRA_DELAY);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+  });
+
+  it("should cancel pending call if dependencies change", async () => {
+    const delay = BASE_DELAY;
+    const callback = jest.fn();
+
+    const { result, rerender } = renderHook(
+      ({ callback, delay, dependencies }) => useDebouncedCallback(callback, delay, dependencies),
+      { initialProps: { callback, delay, dependencies: ["a"] } }
+    );
+
+    act(result.current);
+    await sleep(delay / 2);
+
+    rerender({ callback, delay, dependencies: ["b"] });
+    act(result.current);
+    await sleep(delay + EXTRA_DELAY);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+  });
+
+  it("should support async callbacks", async () => {
+    const makeAsyncCall = jest.fn(
+      () =>
+        new Promise(async resolve => {
+          await sleep(delay / 2);
+          resolve(null);
+        })
+    );
+
+    const delay = BASE_DELAY;
+    const callback = jest.fn(async () => {
+      await makeAsyncCall();
+    });
+
+    const { result } = renderHook(() => useDebouncedCallback(callback, delay));
+
+    await act(async () => result.current());
+    await sleep(delay + EXTRA_DELAY);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(makeAsyncCall).toHaveBeenCalledTimes(1);
+  });
+});

package/src/hooks/useDebouncedCallback.tsx

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2022 OneWelcome B.V.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+import React from "react";
+
+export const useDebouncedCallback = (callback: Function, delay: number, dependencies?: any[]) => {
+  const timeout = React.useRef<ReturnType<typeof setTimeout>>();
+  const comboDeps = dependencies ? [callback, delay, ...dependencies] : [callback, delay];
+
+  return React.useCallback((...args) => {
+    if (timeout.current != null) {
+      clearTimeout(timeout.current);
+    }
+
+    timeout.current = setTimeout(() => {
+      callback(...args);
+    }, delay);
+  }, comboDeps);
+};