@algolia/satellite 1.0.0-beta.175 → 1.0.0-beta.176

package/esm/MenuButton/useMenuItemProps.d.ts

@@ -1,11 +1,11 @@
-import type { EventHandler, MouseEvent } from "react";
+import type { MouseEventHandler } from "react";
 export interface BaseItemProps<T extends HTMLElement = HTMLElement> {
     className?: string;
     disabled?: boolean;
-    onClick?: EventHandler<MouseEvent<T>>;
+    onClick?: MouseEventHandler<T>;
 }
 export declare const useMenuItemProps: <T extends HTMLElement = HTMLElement>(props: BaseItemProps<T>) => {
     className: string;
-    onClick: ((event: MouseEvent<T, globalThis.MouseEvent>) => void) | undefined;
+    onClick: MouseEventHandler<T> | undefined;
 };
 export default useMenuItemProps;

package/esm/MenuButton/useMenuItemProps.js

@@ -3,7 +3,7 @@ var _templateObject;
 import cx from "clsx";
 import stl from "../styles/helpers/satellitePrefixer";
 export var useMenuItemProps = function useMenuItemProps(props) {
-  var className = cx(stl(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n      flex items-center\n      min-h-10 px-4 text-left\n      focus:no-underline hover:no-underline\n      ", "\n    "])), props.disabled ? "text-grey-300 cursor-not-allowed outline-none" : "text-inherit hover:bg-grey-100 focus:bg-grey-100 focus:outline-none cursor-pointer"), props.className);
+  var className = cx(stl(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n      flex items-center\n      min-h-10 px-4 text-left\n      focus:no-underline hover:no-underline\n      ", "\n    "])), props.disabled ? "text-grey-300 cursor-not-allowed outline-none pointer-events-none" : "text-inherit hover:bg-grey-100 focus:bg-grey-100 focus:outline-none cursor-pointer"), props.className);
   return {
     className: className,
     onClick: props.onClick

package/esm/Satellite/locale.d.ts

@@ -3,7 +3,6 @@ import type { AutoCompleteLocale } from "../AutoComplete";
 import type { UserAvatarLocale } from "../Avatars/UserAvatar";
 import type { DatePickerLocale } from "../DatePicker/types";
 import type { DropzoneLocale } from "../Dropzone";
-import type { FlagLocale } from "../Flag";
 import type { InputPropsLocale } from "../Input";
 import type { ModalLocale } from "../Modal";
 import type { PaginationLocale } from "../Pagination";
@@ -11,8 +10,11 @@ import type { CompactPaginationLocale } from "../Pagination/CompactPagination";
 import type { DotPaginationLocale } from "../Pagination/DotPagination";
 import type { PopoverLocale } from "../Popover/types";
 import type { SidebarLocale } from "../Sidebar";
+import type { StepperLocale } from "../Stepper";
 import type { DataTableLocale } from "../Tables/DataTable";
 import type { TagLocale } from "../Tag";
+import type { ToastLocale } from "../Toast";
+import type { ToastsLocale } from "../Toast/Toasts";
 export declare type ComponentsLocales = {
     announcementBadge?: AnnouncementBadgeLocale;
     autoComplete?: AutoCompleteLocale;
@@ -21,13 +23,15 @@ export declare type ComponentsLocales = {
     datePicker?: DatePickerLocale;
     dotPagination?: DotPaginationLocale;
     dropzone?: DropzoneLocale;
-    flag?: FlagLocale;
     input?: InputPropsLocale;
     modal?: ModalLocale;
     pagination?: PaginationLocale;
     popover?: PopoverLocale;
     sidebar?: SidebarLocale;
+    stepper?: StepperLocale;
     tag?: TagLocale;
+    toast?: ToastLocale;
+    toasts?: ToastsLocale;
     userAvatar?: UserAvatarLocale;
 };
 export declare const useLocale: <ComponentKey extends keyof ComponentsLocales>(componentKey: ComponentKey) => ComponentsLocales[ComponentKey];

package/esm/Stepper/Step.d.ts

@@ -0,0 +1,7 @@
+import { type HTMLAttributes, type VFC } from "react";
+import type { BaseStep } from "./types";
+export declare type StepProps = BaseStep & HTMLAttributes<HTMLLIElement> & {
+    index: number;
+};
+export declare const Step: VFC<StepProps>;
+export default Step;

package/esm/Stepper/Step.js

@@ -0,0 +1,110 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/taggedTemplateLiteral";
+var _excluded = ["className", "index", "icon", "label", "name", "completed", "disabled"];
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8, _templateObject9, _templateObject10, _templateObject11, _templateObject12, _templateObject13, _templateObject14, _templateObject15, _templateObject16, _templateObject17, _templateObject18, _templateObject19, _templateObject20, _templateObject21, _templateObject22, _templateObject23, _templateObject24, _templateObject25, _templateObject26, _templateObject27, _templateObject28, _templateObject29;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import cx from "clsx";
+import { useMemo } from "react";
+import { CheckIcon } from "../Icons";
+import stl from "../styles/helpers/satellitePrefixer";
+import { getTextFromReactNode } from "../utils/getTextFromReactNode";
+import { uniqueId } from "../utils/uniqueId";
+import { useStepperContext } from "./StepperContext";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var BUTTON_SIZE_CLASSNAMES = {
+  small: stl(_templateObject || (_templateObject = _taggedTemplateLiteral(["px-2.5 py-2"]))),
+  "default": stl(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["px-3 py-2.5"]))),
+  large: stl(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["p-4"])))
+};
+var CONNECTOR_SIZE_CLASSNAMES = {
+  small: stl(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["left-5 top-7"]))),
+  "default": stl(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["left-6 top-7"]))),
+  large: stl(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["left-8 top-8"])))
+};
+var ICON_SIZE_CLASSNAMES = {
+  small: stl(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["w-5 h-5"]))),
+  "default": stl(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["w-6 h-6"]))),
+  large: stl(_templateObject9 || (_templateObject9 = _taggedTemplateLiteral(["w-8 h-8"])))
+};
+var ICON_SIZE = {
+  small: 12,
+  "default": 14,
+  large: 16
+};
+var CheckIconInternal = function CheckIconInternal(props) {
+  return /*#__PURE__*/_jsx(CheckIcon, _objectSpread({}, props));
+};
+export var Step = function Step(_ref) {
+  var className = _ref.className,
+    index = _ref.index,
+    CustomIcon = _ref.icon,
+    label = _ref.label,
+    name = _ref.name,
+    completed = _ref.completed,
+    disabled = _ref.disabled,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var context = useStepperContext();
+  var active = context.activeStep === index;
+  var stepName = getTextFromReactNode(name);
+  var buttonId = useMemo(function () {
+    return uniqueId("stepper-step-");
+  }, []);
+  var locale = context.locale;
+  var disabledLocale = typeof locale.disabledStep === "function" ? locale.disabledStep(stepName) : locale.disabledStep;
+  var activeLocale = typeof locale.activeStep === "function" ? locale.activeStep(stepName) : locale.activeStep;
+  var completedLocale = typeof locale.completedStep === "function" ? locale.completedStep(stepName) : locale.completedStep;
+  var incompletedLocale = typeof locale.incompletedStep === "function" ? locale.incompletedStep(stepName) : locale.incompletedStep;
+  var Icon = CustomIcon;
+  if (completed) {
+    Icon = CheckIconInternal;
+  }
+  return /*#__PURE__*/_jsx("li", _objectSpread(_objectSpread({}, props), {}, {
+    className: cx(className, stl(_templateObject10 || (_templateObject10 = _taggedTemplateLiteral(["text-grey-600 group/step"])))),
+    children: /*#__PURE__*/_jsxs("button", {
+      id: buttonId,
+      className: cx(stl(_templateObject11 || (_templateObject11 = _taggedTemplateLiteral(["relative w-full flex items-center text-left gap-2 rounded border transition-colors group/button"]))), stl(_templateObject12 || (_templateObject12 = _taggedTemplateLiteral(["-outline-offset-2 focus-visible:outline focus-visible:outline-2 focus-visible:outline-xenon-600"]))), disabled ? stl(_templateObject13 || (_templateObject13 = _taggedTemplateLiteral(["cursor-not-allowed"]))) : stl(_templateObject14 || (_templateObject14 = _taggedTemplateLiteral(["hover:bg-grey-100"]))), active ? stl(_templateObject15 || (_templateObject15 = _taggedTemplateLiteral(["border-grey-200 bg-white"]))) : stl(_templateObject16 || (_templateObject16 = _taggedTemplateLiteral(["border-transparent"]))), BUTTON_SIZE_CLASSNAMES[context.size]),
+      "aria-label": disabled ? disabledLocale : active ? activeLocale : completed ? completedLocale : incompletedLocale,
+      "aria-current": active ? "step" : undefined,
+      disabled: disabled,
+      tabIndex: index === context.activeStep ? 0 : -1,
+      "data-step-idx": index,
+      onClick: function onClick() {
+        var _context$onStepChange;
+        return (_context$onStepChange = context.onStepChange) === null || _context$onStepChange === void 0 ? void 0 : _context$onStepChange.call(context, index);
+      },
+      onKeyDown: function onKeyDown(event) {
+        switch (event.key) {
+          case "Space":
+          case "Enter":
+            {
+              var _context$onStepChange2;
+              (_context$onStepChange2 = context.onStepChange) === null || _context$onStepChange2 === void 0 || _context$onStepChange2.call(context, index);
+              break;
+            }
+        }
+      },
+      children: [context.connectors && /*#__PURE__*/_jsx("span", {
+        className: cx(stl(_templateObject17 || (_templateObject17 = _taggedTemplateLiteral(["absolute -z-10 border-l h-full group-last/step:hidden"]))), completed ? stl(_templateObject18 || (_templateObject18 = _taggedTemplateLiteral(["border-green-600"]))) : stl(_templateObject19 || (_templateObject19 = _taggedTemplateLiteral(["border-grey-200"]))), CONNECTOR_SIZE_CLASSNAMES[context.size])
+      }), /*#__PURE__*/_jsx("span", {
+        className: cx(stl(_templateObject20 || (_templateObject20 = _taggedTemplateLiteral(["rounded-full flex items-center justify-center shrink-0 text-sm transition-colors"]))), !active && !completed && stl(_templateObject21 || (_templateObject21 = _taggedTemplateLiteral(["bg-grey-100"]))), !active && !completed && !disabled && stl(_templateObject22 || (_templateObject22 = _taggedTemplateLiteral(["group-hover/button:bg-white"]))), active && !completed && stl(_templateObject23 || (_templateObject23 = _taggedTemplateLiteral(["bg-grey-800 text-white"]))), completed && stl(_templateObject24 || (_templateObject24 = _taggedTemplateLiteral(["bg-green-600 text-white"]))), ICON_SIZE_CLASSNAMES[context.size]),
+        children: Icon ? /*#__PURE__*/_jsx(Icon, {
+          width: ICON_SIZE[context.size],
+          height: ICON_SIZE[context.size]
+        }) : index + 1
+      }), /*#__PURE__*/_jsxs("div", {
+        className: cx(disabled && stl(_templateObject25 || (_templateObject25 = _taggedTemplateLiteral(["text-grey-300"])))),
+        children: [!!label && /*#__PURE__*/_jsx("div", {
+          className: stl(_templateObject26 || (_templateObject26 = _taggedTemplateLiteral(["text-sm line-clamp-1"]))),
+          children: label
+        }), /*#__PURE__*/_jsx("div", {
+          className: cx(stl(_templateObject27 || (_templateObject27 = _taggedTemplateLiteral(["text-base line-clamp-2"]))), (completed || active) && stl(_templateObject28 || (_templateObject28 = _taggedTemplateLiteral(["text-grey-900"]))), context.size === "small" && stl(_templateObject29 || (_templateObject29 = _taggedTemplateLiteral(["text-sm"])))),
+          children: name
+        })]
+      })]
+    })
+  }));
+};
+export default Step;

package/esm/Stepper/Stepper.d.ts

@@ -0,0 +1,42 @@
+import type { HTMLAttributes, VFC } from "react";
+import type { BaseStep } from "./types";
+export declare type StepperLocale = {
+    disabledStep?: string | ((stepName: string) => string);
+    activeStep?: string | ((stepName: string) => string);
+    incompletedStep?: string | ((stepName: string) => string);
+    completedStep?: string | ((stepName: string) => string);
+};
+export declare type StepperSizes = "small" | "default" | "large";
+export interface StepperProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /**
+     * Defines the steps of the Stepper.
+     */
+    steps: BaseStep[];
+    /**
+     * Defines the controlled index of the active step.
+     * If omitted, the first step will be active by default
+     * and the Stepper will be uncontrolled.
+     */
+    activeStep?: number;
+    /**
+     * Defines the callback fired when a step is clicked.
+     */
+    onStepChange?: (index: number) => void;
+    /**
+     * Defines the size of the Stepper.
+     * @default "default"
+     */
+    size?: StepperSizes;
+    /**
+     * Defines whether the connectors should be displayed.
+     * @default true
+     */
+    connectors?: boolean;
+    /**
+     * Defines the text describing the steps.
+     * If not provided, default values will be used.
+     */
+    locale?: StepperLocale;
+}
+export declare const Stepper: VFC<StepperProps>;
+export default Stepper;

package/esm/Stepper/Stepper.js

@@ -0,0 +1,139 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/taggedTemplateLiteral";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _templateObject;
+var _excluded = ["steps", "activeStep", "onStepChange", "size", "connectors", "locale", "className"];
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import cx from "clsx";
+import { useRef, useState } from "react";
+import { useLocale } from "../Satellite";
+import stl from "../styles/helpers/satellitePrefixer";
+import { Step } from "./Step";
+import { StepperContext } from "./StepperContext";
+import { useStepIndices } from "./utils";
+import { jsx as _jsx } from "react/jsx-runtime";
+var DEFAULT_TAG_LOCALE = {
+  disabledStep: function disabledStep(stepName) {
+    return "".concat(stepName, " disabled");
+  },
+  activeStep: function activeStep(stepName) {
+    return "".concat(stepName, " active");
+  },
+  incompletedStep: function incompletedStep(stepName) {
+    return "".concat(stepName, " incompleted");
+  },
+  completedStep: function completedStep(stepName) {
+    return "".concat(stepName, " completed");
+  }
+};
+export var Stepper = function Stepper(_ref) {
+  var steps = _ref.steps,
+    customActiveStep = _ref.activeStep,
+    _onStepChange = _ref.onStepChange,
+    _ref$size = _ref.size,
+    size = _ref$size === void 0 ? "default" : _ref$size,
+    _ref$connectors = _ref.connectors,
+    connectors = _ref$connectors === void 0 ? true : _ref$connectors,
+    propsLocale = _ref.locale,
+    className = _ref.className,
+    props = _objectWithoutProperties(_ref, _excluded);
+  if (process.env.NODE_ENV !== "production") {
+    var stepsNb = steps.length;
+    if (stepsNb < 2) {
+      console.warn("The Stepper component should have at least 2 steps.");
+    }
+    if (stepsNb > 6) {
+      console.warn("The Stepper component should not have more than 6 steps.");
+    }
+  }
+  var contextLocale = useLocale("stepper");
+  var locale = _objectSpread(_objectSpread(_objectSpread({}, DEFAULT_TAG_LOCALE), contextLocale), propsLocale);
+  var isControlled = typeof customActiveStep !== "undefined";
+  var _useState = useState(customActiveStep || 0),
+    _useState2 = _slicedToArray(_useState, 2),
+    activeStep = _useState2[0],
+    setActiveStep = _useState2[1];
+  if (isControlled && activeStep !== customActiveStep) {
+    setActiveStep(customActiveStep);
+  }
+  var containerRef = useRef(null);
+  var _useState3 = useState(customActiveStep || 0),
+    _useState4 = _slicedToArray(_useState3, 2),
+    focusedStep = _useState4[0],
+    setFocusedStep = _useState4[1];
+  var _useStepIndices = useStepIndices(steps, focusedStep, true),
+    _useStepIndices2 = _slicedToArray(_useStepIndices, 4),
+    getPreviousFocusStep = _useStepIndices2[0],
+    getNextFocusStep = _useStepIndices2[1],
+    getFirstFocusStep = _useStepIndices2[2],
+    getLastFocusStep = _useStepIndices2[3];
+  var focusStep = function focusStep(index) {
+    var _containerRef$current;
+    if (index === -1) return;
+    (_containerRef$current = containerRef.current) === null || _containerRef$current === void 0 || (_containerRef$current = _containerRef$current.querySelector("[data-step-idx='".concat(index, "']"))) === null || _containerRef$current === void 0 || _containerRef$current.focus();
+    setFocusedStep(index);
+  };
+  return /*#__PURE__*/_jsx(StepperContext.Provider, {
+    value: {
+      activeStep: activeStep,
+      focusedStep: focusedStep,
+      size: size,
+      connectors: connectors,
+      locale: locale,
+      onStepChange: function onStepChange(index) {
+        if (!isControlled) {
+          setActiveStep(index);
+        }
+        _onStepChange === null || _onStepChange === void 0 || _onStepChange(index);
+        setFocusedStep(index);
+      }
+    },
+    children: /*#__PURE__*/_jsx("nav", _objectSpread(_objectSpread({
+      "aria-label": "progress"
+    }, props), {}, {
+      className: cx(className),
+      children: /*#__PURE__*/_jsx("ol", {
+        role: "presentation",
+        className: stl(_templateObject || (_templateObject = _taggedTemplateLiteral(["flex flex-col isolate"]))),
+        ref: containerRef,
+        onFocus: function onFocus() {
+          setFocusedStep(activeStep);
+        },
+        onKeyDown: function onKeyDown(event) {
+          switch (event.key) {
+            case "ArrowLeft":
+            case "ArrowUp":
+              {
+                focusStep(getPreviousFocusStep());
+                break;
+              }
+            case "ArrowRight":
+            case "ArrowDown":
+              {
+                focusStep(getNextFocusStep());
+                break;
+              }
+            case "Home":
+              {
+                focusStep(getFirstFocusStep());
+                break;
+              }
+            case "End":
+              {
+                focusStep(getLastFocusStep());
+                break;
+              }
+          }
+        },
+        children: steps.map(function (step, index) {
+          return /*#__PURE__*/_jsx(Step, _objectSpread({
+            index: index
+          }, step), index);
+        })
+      })
+    }))
+  });
+};
+export default Stepper;

package/esm/Stepper/StepperContext.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import type { StepperLocale, StepperSizes } from "./Stepper";
+export declare type StepperContextType = {
+    activeStep: number;
+    focusedStep: number;
+    size: StepperSizes;
+    connectors: boolean;
+    locale: StepperLocale;
+    onStepChange?: (index: number) => void;
+};
+export declare const StepperContext: import("react").Context<StepperContextType | null>;
+export declare const useStepperContext: () => StepperContextType;

package/esm/Stepper/StepperContext.js

@@ -0,0 +1,9 @@
+import { createContext, useContext } from "react";
+export var StepperContext = /*#__PURE__*/createContext(null);
+export var useStepperContext = function useStepperContext() {
+  var context = useContext(StepperContext);
+  if (!context) {
+    throw new Error("useStepperContext used outside of Stepper");
+  }
+  return context;
+};

package/esm/Stepper/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Stepper";
+export * from "./types";
+export * from "./utils";
+export { default } from "./Stepper";

package/esm/Stepper/index.js

@@ -0,0 +1,4 @@
+export * from "./Stepper";
+export * from "./types";
+export * from "./utils";
+export { default } from "./Stepper";

package/esm/Stepper/types.d.ts

@@ -0,0 +1,26 @@
+import type { ReactNode } from "react";
+import type { IconComponentType } from "../Icons";
+export declare type BaseStep = {
+    /**
+     * Defines the icon to display in the step.
+     * If omitted, the `index + 1` of the step will be displayed instead.
+     * If the step is completed, a check icon will be displayed instead.
+     */
+    icon?: IconComponentType;
+    /**
+     * Defines the label to display in the step.
+     */
+    label?: ReactNode;
+    /**
+     * Defines the name to display in the step.
+     */
+    name: ReactNode;
+    /**
+     * Defines whether the step is completed.
+     */
+    completed?: boolean;
+    /**
+     * Defines whether the step is disabled.
+     */
+    disabled?: boolean;
+};

package/esm/Stepper/utils.d.ts

@@ -0,0 +1,5 @@
+import type { BaseStep } from "./types";
+/**
+ * Returns a tuple of functions that return the previous and next step indices.
+ */
+export declare const useStepIndices: (steps: BaseStep[], activeStep: number, loop?: boolean) => [() => number, () => number, () => number, () => number, boolean, boolean];

package/esm/Stepper/utils.js

@@ -0,0 +1,61 @@
+var findPreviousStep = function findPreviousStep(steps, activeStep, loop) {
+  var stepCount = steps.length;
+  var startIndex = activeStep - 1;
+  if (loop) {
+    startIndex = (startIndex + stepCount) % stepCount;
+  }
+  for (var i = startIndex; i >= 0; i--) {
+    if (!steps[i].disabled) {
+      return i;
+    }
+  }
+  return -1;
+};
+var findNextStep = function findNextStep(steps, activeStep, loop) {
+  var stepCount = steps.length;
+  var endIndex = stepCount;
+  if (loop) {
+    endIndex = activeStep + stepCount;
+  }
+  for (var i = activeStep + 1; i < endIndex; i++) {
+    if (!steps[i % stepCount].disabled) {
+      return i % stepCount;
+    }
+  }
+  return -1;
+};
+var findFirstOrLastStep = function findFirstOrLastStep(steps, reverse) {
+  var stepCount = steps.length;
+  for (var i = reverse ? stepCount - 1 : 0; i >= 0 && i < stepCount; i += reverse ? -1 : 1) {
+    if (!steps[i].disabled) {
+      return i;
+    }
+  }
+  return -1;
+};
+var findFirstStep = function findFirstStep(steps) {
+  return findFirstOrLastStep(steps, false);
+};
+var findLastStep = function findLastStep(steps) {
+  return findFirstOrLastStep(steps, true);
+};
+
+/**
+ * Returns a tuple of functions that return the previous and next step indices.
+ */
+export var useStepIndices = function useStepIndices(steps, activeStep) {
+  var loop = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var getPreviousStep = function getPreviousStep() {
+    return findPreviousStep(steps, activeStep, loop);
+  };
+  var getNextStep = function getNextStep() {
+    return findNextStep(steps, activeStep, loop);
+  };
+  var getFirstStep = function getFirstStep() {
+    return findFirstStep(steps);
+  };
+  var getLastStep = function getLastStep() {
+    return findLastStep(steps);
+  };
+  return [getPreviousStep, getNextStep, getFirstStep, getLastStep, getPreviousStep() === -1, getNextStep() === -1];
+};

package/esm/Toast/Toast.d.ts

@@ -0,0 +1,6 @@
+import type { FC, HTMLAttributes } from "react";
+import type { Notification } from "./types";
+export declare type ToastLocale = Notification["locale"];
+export declare type ToastProps = Omit<Notification, "id" | "content" | "autoDismissAfter"> & HTMLAttributes<HTMLElement>;
+export declare const Toast: FC<ToastProps>;
+export default Toast;