@elliemae/ds-tabs 2.0.0-rc.9 → 2.0.0

package/types/DSTabsTypes.d.ts

@@ -0,0 +1,202 @@
+import type React from 'react';
+import { TabTypes } from './utils/constants';
+declare type TabTypesT = typeof TabTypes[keyof typeof TabTypes];
+export interface DSTabsPropsT {
+    containerProps?: Record<string, unknown>;
+    innerRef?: React.MutableRefObject<HTMLDivElement>;
+    animated?: boolean;
+    enableMouseEvents?: boolean;
+    allowTextSelection?: boolean;
+    onTabChange?: (tabId: string, e?: React.MouseEvent) => void;
+    tabsListAriaLabel?: string;
+    type?: TabTypesT;
+    tabBarExtraContent?: React.ReactNode;
+    children: React.ReactElement<DSTabPropsWithDefaultT>[];
+    onlyRenderActiveTab?: boolean;
+    activeTab?: string;
+    withCarousel?: boolean;
+    firstSubtabRef?: React.MutableRefObject<HTMLElement>;
+    lastTabRef?: React.MutableRefObject<HTMLElement>;
+    fixedTabsHeaders?: boolean;
+    isDSMobile?: boolean;
+    showSelectionIndicator?: boolean;
+    showSeparator?: boolean;
+}
+export interface DSTabsPropsWithDefaultsT {
+    containerProps: Record<string, unknown>;
+    innerRef?: React.MutableRefObject<HTMLDivElement>;
+    animated: boolean;
+    enableMouseEvents: boolean;
+    allowTextSelection: boolean;
+    onTabChange: (tabId: string, e?: React.MouseEvent) => void;
+    tabsListAriaLabel: string;
+    type: TabTypesT;
+    tabBarExtraContent?: React.ReactNode;
+    children: React.ReactElement<DSTabPropsWithDefaultT>[];
+    onlyRenderActiveTab: boolean;
+    activeTab?: string;
+    withCarousel: boolean;
+    firstSubtabRef?: React.MutableRefObject<HTMLElement>;
+    lastTabRef?: React.MutableRefObject<HTMLElement>;
+    fixedTabsHeaders: boolean;
+    isDSMobile: boolean;
+    showSelectionIndicator: boolean;
+    showSeparator: boolean;
+}
+export interface DSTabsDefaultPropsT {
+    containerProps: Record<string, unknown>;
+    animated: boolean;
+    enableMouseEvents: boolean;
+    allowTextSelection: boolean;
+    onTabChange: (tabId: string, e?: React.MouseEvent) => void;
+    tabsListAriaLabel: string;
+    type: TabTypesT;
+    onlyRenderActiveTab: boolean;
+    fixedTabsHeaders: boolean;
+    children: React.ReactElement<DSTabPropsWithDefaultT>[];
+    withCarousel: boolean;
+    isDSMobile: boolean;
+    showSelectionIndicator: boolean;
+    showSeparator: boolean;
+}
+export interface CarouselPropsT {
+    children: React.ReactNode[];
+    updateIndicatorStyle?: () => void;
+}
+export interface DSTabPropsT {
+    tabId: string;
+    title?: string;
+    required?: boolean;
+    children?: React.ReactNode;
+    style?: Record<string, unknown>;
+    disabled?: boolean;
+    ref?: React.MutableRefObject<HTMLButtonElement>;
+    onClick?: (tabId: string, e: React.MouseEvent) => null | void;
+    onKeyDown?: (e: React.KeyboardEvent) => null | void;
+}
+export interface DSTabPropsWithDefaultT {
+    tabId: string;
+    title: string;
+    required: boolean;
+    children?: React.ReactNode;
+    style?: Record<string, unknown>;
+    disabled: boolean;
+    ref?: React.MutableRefObject<HTMLButtonElement>;
+    onClick?: (tabId: string, e: React.MouseEvent) => null | void;
+    onKeyDown?: (e: React.KeyboardEvent) => null | void;
+}
+export interface CarouselButtonsPropsT {
+    leftButtonOnClick: () => void;
+    rightButtonOnClick: () => void;
+    showChevrons: ShowChevronsT;
+    type: TabTypesT;
+}
+export interface DSTabsUseCrossRefContextT {
+    lastTabInternalRef: React.MutableRefObject<HTMLButtonElement | null | undefined>;
+    firstSubtabInternalRef: React.MutableRefObject<HTMLButtonElement | null | undefined>;
+}
+export interface DSTabsUseTabsContextT {
+    props: DSTabsPropsWithDefaultsT;
+    tabsRef: React.MutableRefObject<Record<number, HTMLButtonElement> | null>;
+    focusableTabsRef: React.MutableRefObject<HTMLButtonElement[] | null>;
+    tabsListRef: React.MutableRefObject<HTMLDivElement | null>;
+    tabsRefAsArray: React.MutableRefObject<HTMLButtonElement[] | null>;
+    actualActiveTabRef: React.MutableRefObject<HTMLButtonElement | null>;
+    carouselOnlyListRef: React.MutableRefObject<HTMLDivElement | null>;
+    setInternalActiveTab: React.Dispatch<React.SetStateAction<string>>;
+    actualActiveTab: string;
+}
+export interface UseRezisePropsT {
+    ref: React.MutableRefObject<HTMLDivElement | null>;
+    callback: () => void;
+}
+export interface UseCarouselPropsT {
+    updateIndicatorStyle?: () => void;
+}
+export interface ShowChevronsT {
+    right: boolean;
+    left: boolean;
+}
+export interface MobileGradientsT {
+    right: boolean;
+    left: boolean;
+}
+export interface IndicatorStyleT {
+    left: string;
+    width: string;
+    backgroundWithTransparentAndWhite: string;
+    backgroundWithTransparent: string;
+}
+export interface UseCarouselReturnTypeT {
+    showChevrons: ShowChevronsT;
+    leftButtonOnClick: () => void;
+    rightButtonOnClick: () => void;
+    handleOnClick: (e: React.MouseEvent) => void;
+    handleOnScroll: (e: React.UIEvent) => void;
+}
+export interface UseCarouselCallbacksPropsT {
+    getVisibleItemsOffset: () => number;
+    recalcChevrons: () => void;
+    updateIndicatorStyle?: () => void;
+}
+export interface UseCarouselCallbacksReturnTypeT {
+    leftButtonOnClick: () => void;
+    rightButtonOnClick: () => void;
+    handleOnClick: (e: React.MouseEvent) => void;
+    handleOnScroll: (e: React.UIEvent) => void;
+}
+export interface UseKeyboardNavigationReturnTypeT {
+    handleOnKeyDown: (e: React.KeyboardEvent) => void;
+}
+export interface UseTabsCallbacksReturnTypeT {
+    handleOnTabChange: (tabId: string, e?: React.MouseEvent) => void;
+    handleOnMouseDown: (e: React.MouseEvent) => void;
+}
+export interface UseTabBarReturnTypeT {
+    updateIndicatorStyle: () => void;
+    updateMobileGradients: () => void;
+    setIndicatorStyle: React.Dispatch<React.SetStateAction<IndicatorStyleT>>;
+    indicatorStyle: IndicatorStyleT;
+    mobileGradients: MobileGradientsT;
+}
+export interface VisibleDimensionsT {
+    width: number;
+    height: number;
+}
+export interface StyledTabWrapperPropsT {
+    isDSMobile: boolean;
+    fixedTabsHeaders: boolean;
+}
+export interface StyledTabListPropsT {
+    withCarousel: boolean;
+    isDSMobile: boolean;
+    fixedTabsHeaders: boolean;
+    mobileGradients: MobileGradientsT;
+    indicatorStyle: IndicatorStyleT;
+    tabType: TabTypesT;
+}
+export interface StyledSubTabsListPropsT {
+    withCarousel: boolean;
+}
+export interface StyledTabButtonPropsT {
+    isActive: boolean;
+    disabled: boolean;
+    showSeparator: boolean;
+    isDSMobile: boolean;
+    fixedTabsHeaders: boolean;
+    withCarousel: boolean;
+    tabType: TabTypesT;
+}
+export interface StyledCarouselButtonWrapperPropsT {
+    right?: boolean;
+    tabType: TabTypesT;
+}
+export interface StyledPanelContainerPropsT {
+    hidden: boolean;
+    isDSMobile: boolean;
+}
+export interface StyledSelectionIndicatoPropsT {
+    isDSMobile: boolean;
+    tabType: TabTypesT;
+}
+export {};

package/types/config/useCrossRef.d.ts

@@ -0,0 +1,2 @@
+import type { DSTabsUseCrossRefContextT } from '../DSTabsTypes';
+export declare const useCrossRef: () => DSTabsUseCrossRefContextT;

package/types/config/useTabs.d.ts

@@ -0,0 +1,2 @@
+import type { DSTabsPropsT, DSTabsUseTabsContextT } from '../DSTabsTypes';
+export declare const useTabs: (props: DSTabsPropsT) => DSTabsUseTabsContextT;

package/types/defaultProps.d.ts

@@ -0,0 +1,2 @@
+import type { DSTabsDefaultPropsT } from './DSTabsTypes';
+export declare const tabsDefaultProps: DSTabsDefaultPropsT;

package/types/exportsRelated/DSTab.d.ts

@@ -0,0 +1,14 @@
+/// <reference path="../../../../../shared/typings/react-desc.d.ts" />
+import React from 'react';
+import type { DSTabPropsT } from '../DSTabsTypes';
+declare const DSTab: {
+    (props: DSTabPropsT): JSX.Element;
+    propTypes: React.WeakValidationMap<unknown>;
+};
+declare const DSTabWithSchema: {
+    (props?: DSTabPropsT | undefined): JSX.Element;
+    propTypes: unknown;
+    toTypescript: () => import("react-desc").TypescriptSchema;
+};
+export { DSTab, DSTabWithSchema };
+export default DSTab;

package/types/index.d.ts

@@ -1,4 +1,5 @@
-export * from './DSTab';
+export * from './exportsRelated/DSTab';
 export * from './DSTabs';
-export * from './TabTypes';
-export { default } from './DSTabs';
+export { TabTypes } from './utils/constants';
+export * from './DSTabsDatatestid';
+export type { DSTabsPropsT, DSTabPropsT } from './DSTabsTypes';

package/types/parts/carousel/Carousel.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { CarouselPropsT } from '../../DSTabsTypes';
+export declare const Carousel: ({ children, updateIndicatorStyle }: CarouselPropsT) => JSX.Element;

package/types/parts/carousel/styles.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import type { StyledCarouselButtonWrapperPropsT } from '../../DSTabsTypes';
+export declare const StyledCarouselBtn: import("styled-components").StyledComponent<{
+    (props: import("@elliemae/ds-button/types/v2/propTypes").DSButtonPropsT): JSX.Element;
+    propTypes: import("react").WeakValidationMap<unknown>;
+}, import("styled-components").DefaultTheme, {}, never>;
+export declare const StyledCarouselWrapper: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {}, never>;
+export declare const StyledChildrenWrap: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const StyledCarouselButtonWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, StyledCarouselButtonWrapperPropsT, never>;

package/types/parts/carousel/useCarousel.d.ts

@@ -0,0 +1,2 @@
+import type { UseCarouselPropsT, UseCarouselReturnTypeT } from '../../DSTabsTypes';
+export declare const useCarousel: ({ updateIndicatorStyle }: UseCarouselPropsT) => UseCarouselReturnTypeT;

package/types/parts/carousel/useCarouselCallbacks.d.ts

@@ -0,0 +1,2 @@
+import type { UseCarouselCallbacksPropsT, UseCarouselCallbacksReturnTypeT } from '../../DSTabsTypes';
+export declare const useCarouselCallbacks: ({ getVisibleItemsOffset, updateIndicatorStyle, recalcChevrons, }: UseCarouselCallbacksPropsT) => UseCarouselCallbacksReturnTypeT;

package/types/parts/tabBar/TabBar.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const TabBar: () => JSX.Element;

package/types/parts/tabBar/styles.d.ts

@@ -0,0 +1,7 @@
+import type { StyledSelectionIndicatoPropsT, StyledSubTabsListPropsT, StyledTabListPropsT, StyledTabButtonPropsT, StyledTabWrapperPropsT } from '../../DSTabsTypes';
+export declare const StyledSelectionIndicator: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, StyledSelectionIndicatoPropsT, never>;
+export declare const StyledTabWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, StyledTabWrapperPropsT, never>;
+export declare const StyledTabButton: import("styled-components").StyledComponent<"button", import("styled-components").DefaultTheme, StyledTabButtonPropsT, never>;
+export declare const StyledSubTabsList: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, StyledSubTabsListPropsT, never>;
+export declare const StyledTabList: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, StyledTabListPropsT, never>;
+export declare const StyledRequiredMark: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {}, never>;

package/types/parts/tabBar/useTabBar.d.ts

@@ -0,0 +1,2 @@
+import type { UseTabBarReturnTypeT } from '../../DSTabsTypes';
+export declare const useTabBar: () => UseTabBarReturnTypeT;

package/types/parts/tabsContent/TabsContent.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const TabsContent: () => JSX.Element;

package/types/parts/tabsContent/styles.d.ts

@@ -0,0 +1 @@
+export declare const StyledTabBarContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;

package/types/parts/tabsPanel/TabsPanels.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const TabsPanels: () => JSX.Element;

package/types/parts/tabsPanel/styles.d.ts

@@ -0,0 +1,2 @@
+import type { StyledPanelContainerPropsT } from '../../DSTabsTypes';
+export declare const StyledPanelContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, StyledPanelContainerPropsT, never>;

package/types/propTypes.d.ts

@@ -0,0 +1,54 @@
+/// <reference path="../../../../shared/typings/react-desc.d.ts" />
+export declare const tabPropTypes: {
+    tabId: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    title: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    required: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    disabled: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+};
+export declare const tabsPropTypes: {
+    animated: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    enableMouseEvents: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    allowTextSelection: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    onTabChange: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    type: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    tabBarExtraContent: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    onlyRenderActiveTab: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    withCarousel: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    activeTab: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    children: import("react-desc").PropTypesDescValidator;
+    tabsListAriaLabel: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    containerProps: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    innerRef: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+};

package/types/tests/DSTabs.func.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/tests/DSTabs.keyboard.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/utils/constants.d.ts

@@ -0,0 +1,19 @@
+export declare const TabTypes: {
+    NORMAL: "normal";
+    NORMAL_SMALL: "normal_small";
+    SUBTABS: "subtabs";
+};
+export declare const TabTypesValuesAsArray: ("normal" | "normal_small" | "subtabs")[];
+export declare const MOBILE_GRADIENT_WIDTH = 24;
+export declare const defaultIndicatorStyles: {
+    left: string;
+    width: string;
+    backgroundWithTransparentAndWhite: string;
+    backgroundWithTransparent: string;
+};
+export declare const gradientOffsetsAccordingType: {
+    normal_small: number;
+    normal: number;
+    subtabs: number;
+    fixedTabsHeaders: number;
+};

package/types/utils/helpers.d.ts

@@ -0,0 +1,8 @@
+import type { DSTabPropsWithDefaultT, VisibleDimensionsT } from '../DSTabsTypes';
+export declare const isElementVisible: (tab: HTMLElement, tabList: HTMLElement) => boolean;
+export declare const isElementVisibleCarousel: (tab: HTMLElement | null, tabContainer: HTMLDivElement | null, firstOrLastItem?: boolean) => boolean;
+export declare const getVisibleDimensions: (node: HTMLElement, referenceNode: HTMLElement) => VisibleDimensionsT;
+export declare const getIndexById: (children: React.ReactElement<DSTabPropsWithDefaultT>[], activeId?: string | undefined) => number;
+export declare const getIdByIndex: (children: React.ReactElement<DSTabPropsWithDefaultT>[], index: number) => string;
+export declare const shouldHaveLeftGradient: (scrollLeft: number) => boolean;
+export declare const shouldHaveRightGradient: (scrollLeft: number, clientWidth: number, scrollWidth: number) => boolean;

package/types/utils/hooks/useKeyboardNavigation.d.ts

@@ -0,0 +1,2 @@
+import type { UseKeyboardNavigationReturnTypeT } from '../../DSTabsTypes';
+export declare const useKeyboardNavigation: () => UseKeyboardNavigationReturnTypeT;

package/types/utils/hooks/useTabsCallbacks.d.ts

@@ -0,0 +1,2 @@
+import type { UseTabsCallbacksReturnTypeT } from '../../DSTabsTypes';
+export declare const useTabsCallbacks: () => UseTabsCallbacksReturnTypeT;

package/cjs/Carousel.js

@@ -1,205 +0,0 @@
-'use strict';
-
-var _jsx = require('@babel/runtime/helpers/jsx');
-require('core-js/modules/web.dom-collections.iterator.js');
-require('core-js/modules/esnext.async-iterator.reduce.js');
-require('core-js/modules/esnext.iterator.constructor.js');
-require('core-js/modules/esnext.iterator.reduce.js');
-require('core-js/modules/esnext.async-iterator.map.js');
-require('core-js/modules/esnext.iterator.map.js');
-var React = require('react');
-var dsIcons = require('@elliemae/ds-icons');
-var styled = require('styled-components');
-var DSButton = require('@elliemae/ds-button');
-var useResize = require('./useResize.js');
-var jsxRuntime = require('react/jsx-runtime');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-var styled__default = /*#__PURE__*/_interopDefaultLegacy(styled);
-var DSButton__default = /*#__PURE__*/_interopDefaultLegacy(DSButton);
-
-const CarouselBtn = /*#__PURE__*/styled__default["default"](DSButton__default["default"]).withConfig({
-  componentId: "sc-1317h31-0"
-})(["position:absolute;z-index:1;margin:0;&:focus{& span{background-color:", ";background-size:90%;border-radius:2px;border-color:transparent;}}&&{width:16px;height:calc(100% - 2px);@media (min-width:", "){height:calc(100% - 4px);&:focus{& span{background-color:unset;}}}}", " && .em-ds-icon{height:16px;width:16px;}"], props => props.theme.colors.brand[200], _ref => {
-  let {
-    theme
-  } = _ref;
-  return theme.breakpoints.medium;
-}, props => props.right ? 'right: 0;' : 'left: 0;');
-const CarouselWrapper = /*#__PURE__*/styled__default["default"].span.withConfig({
-  componentId: "sc-1317h31-1"
-})(["position:relative;padding:0 16px;width:100%;"]);
-const ChildrenWrap = /*#__PURE__*/styled__default["default"].div.withConfig({
-  componentId: "sc-1317h31-2"
-})(["display:flex;flex-wrap:nowrap;flex:1;overflow:hidden;"]);
-
-function isVisibleElement(el, container) {
-  const rect = el.getBoundingClientRect();
-  const cRect = container.getBoundingClientRect();
-  const elemLeft = rect.left + 3;
-  const elemRight = rect.right - 3; // Only completely visible elements return true:
-
-  const isVisible = elemLeft >= cRect.left && elemRight <= cRect.right;
-  return isVisible;
-}
-
-const Carousel = _ref2 => {
-  let {
-    children,
-    onScroll
-  } = _ref2;
-  const itemsRef = React.useRef([]);
-  const wrapRef = React.useRef(null);
-  const leftRef = React.useRef(null);
-  const rightRef = React.useRef(null);
-
-  const shouldShowLeft = () => children && children[0] && wrapRef.current && itemsRef.current[0] && !isVisibleElement(itemsRef.current[0], wrapRef.current);
-
-  const shouldShowRight = () => children && children[children.length - 1] && wrapRef.current && itemsRef.current[children.length - 1] && !isVisibleElement(itemsRef.current[children.length - 1], wrapRef.current);
-
-  const [{
-    right,
-    left,
-    CHEVRON_FOCUS_FLAG
-  }, setShow] = React.useState({
-    right: false,
-    left: false,
-    CHEVRON_FOCUS_FLAG: false // flag to replace lack of callback in useState hook
-
-  });
-
-  const recalcChevrons = () => setShow({
-    right: shouldShowRight(),
-    left: shouldShowLeft()
-  });
-
-  React.useEffect(() => {
-    recalcChevrons();
-  }, []);
-  React.useEffect(() => {
-    if (CHEVRON_FOCUS_FLAG) {
-      // focus opposite chevron when current one hides
-      if (!left && right && rightRef.current) {
-        rightRef.current.focus();
-      } else if (!right && left && leftRef.current) {
-        leftRef.current.focus();
-      }
-
-      setShow({
-        right,
-        left,
-        CHEVRON_FOCUS_FLAG: false
-      });
-    }
-  }, [CHEVRON_FOCUS_FLAG]);
-  useResize.useResize(wrapRef, recalcChevrons);
-
-  const getVisibleItemsOffset = () => itemsRef.current.reduce((acc, c) => {
-    if (isVisibleElement(c, wrapRef.current)) {
-      const styles = window.getComputedStyle(c);
-      const width = c.offsetWidth;
-      const margin = parseFloat(styles.marginLeft) + parseFloat(styles.marginRight);
-      return acc + (width + margin);
-    }
-
-    return acc;
-  }, 0);
-
-  const rightClick = () => {
-    wrapRef.current.scrollLeft += getVisibleItemsOffset();
-  };
-
-  const leftClick = () => {
-    wrapRef.current.scrollLeft -= getVisibleItemsOffset();
-  };
-
-  const handleScroll = e => {
-    // forces render when element.scrollTop is changed (out of react flow)
-    setShow({
-      right: shouldShowRight(),
-      left: shouldShowLeft(),
-      // to trigger focus logic at effect above
-      CHEVRON_FOCUS_FLAG: true
-    });
-    onScroll(e);
-  };
-
-  const handleClick = function (e) {
-    let onClick = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : () => {};
-    const tabListDomEl = wrapRef.current;
-    const el = e.target;
-    const rect = el.getBoundingClientRect();
-    const cRect = tabListDomEl.getBoundingClientRect();
-
-    if (!isVisibleElement(el, tabListDomEl)) {
-      const containerWidth = cRect.width;
-      const halfContainer = containerWidth / 2;
-      const elementScrollPosition = rect.left - cRect.left;
-      const positionInContainer = elementScrollPosition % containerWidth;
-      const width = el.offsetWidth; // align to right
-
-      if (positionInContainer > halfContainer) {
-        wrapRef.current.scrollLeft += width + positionInContainer - containerWidth;
-      } else {
-        // align left
-        wrapRef.current.scrollLeft += positionInContainer;
-      }
-
-      recalcChevrons();
-    }
-
-    onClick(e);
-  };
-
-  return /*#__PURE__*/_jsx__default["default"](CarouselWrapper, {}, void 0, left && /*#__PURE__*/_jsx__default["default"](CarouselBtn, {
-    "data-testid": "chevron-left",
-    buttonType: "link",
-    innerRef: leftRef,
-    size: "s",
-    icon: /*#__PURE__*/_jsx__default["default"](dsIcons.ChevronLeft, {
-      size: "s",
-      color: ['brand-primary', '600']
-    }),
-    onClick: leftClick,
-    tabIndex: -1
-  }), right && /*#__PURE__*/_jsx__default["default"](CarouselBtn, {
-    "data-testid": "chevron-right",
-    innerRef: rightRef,
-    right: true,
-    size: "s",
-    buttonType: "link",
-    icon: /*#__PURE__*/_jsx__default["default"](dsIcons.ChevronRight, {
-      size: "s",
-      color: ['brand-primary', '600']
-    }),
-    onClick: rightClick,
-    tabIndex: -1
-  }), /*#__PURE__*/jsxRuntime.jsx(ChildrenWrap, {
-    onScroll: handleScroll,
-    ref: wrapRef,
-    children: React__default["default"].Children.map(children, (child, idx) => /*#__PURE__*/React__default["default"].cloneElement(child, {
-      onClick: e => {
-        var _child$props;
-
-        return handleClick(e, (_child$props = child.props) === null || _child$props === void 0 ? void 0 : _child$props.onClick);
-      },
-      key: 'carousel'.concat(idx),
-      ref: el => {
-        itemsRef.current[idx] = el; // keep old refs
-
-        if (typeof child.ref === 'function') {
-          child.ref(el);
-        }
-      }
-    }))
-  }));
-};
-
-Carousel.defaultProps = {
-  onScroll: () => null
-};
-
-module.exports = Carousel;

package/cjs/DSTab.js

@@ -1,46 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var _jsx = require('@babel/runtime/helpers/jsx');
-require('react');
-var reactDesc = require('react-desc');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
-
-const DSTab = _ref => {
-  let {
-    tabId = '',
-    title = '',
-    required = false
-  } = _ref;
-  return /*#__PURE__*/_jsx__default["default"]("div", {
-    "aria-labelledby": "".concat(tabId, "-label"),
-    tabId: tabId,
-    title: title,
-    required: required
-  });
-};
-
-DSTab.displayName = 'DSTab';
-const props = {
-  /** unique id for tab */
-  tabId: reactDesc.PropTypes.string.description('unique id for tab'),
-
-  /** tab title */
-  title: reactDesc.PropTypes.string.description('tab title'),
-
-  /** Show a required mark next to the title */
-  required: reactDesc.PropTypes.bool.description('Show a required mark next to the title'),
-
-  /** Whether or not it's a ds-tab from DSMobile tabs */
-  isDSMobile: reactDesc.PropTypes.bool.description("Whether or not it's a ds-tab from DSMobile tabs")
-};
-const DSTabWithSchema = reactDesc.describe(DSTab);
-DSTabWithSchema.propTypes = props;
-
-exports.DSTab = DSTab;
-exports.DSTabWithSchema = DSTabWithSchema;
-exports["default"] = DSTab;