@sprinklrjs/spaceweb 10.1.0

package/esm/style/__mocks__/CSS.mock.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @author Ivan Torres
+ */
+import { ReactElement } from 'react';
+import { Styles } from '../../types';
+declare type Props = {
+    styleTest: Styles | Styles[];
+};
+declare const StyledComponent: (props: Props) => ReactElement;
+export default StyledComponent;

package/esm/style/__mocks__/CSS.mock.js

@@ -0,0 +1,9 @@
+import { __assign, __read, __spreadArray } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import useStyle from '../useStyle';
+var StyledComponent = function (props) {
+    var styleTest = props.styleTest;
+    var css = useStyle().css;
+    return (_jsx("div", __assign({ "data-testid": "cssComponent", className: css.apply(void 0, __spreadArray([], __read((Array.isArray(styleTest) ? styleTest : [styleTest])), false)) }, { children: "Hello World!" }), void 0));
+};
+export default StyledComponent;

package/esm/style/__mocks__/UseStyle.mock.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @author Ivan Torres
+ */
+import { ReactElement } from 'react';
+import { StyleUtils } from '../../types';
+declare type Props = {
+    children: (styleUtils: StyleUtils) => ReactElement;
+};
+declare const _default: ({ children }: Props) => ReactElement;
+export default _default;

package/esm/style/__mocks__/UseStyle.mock.js

@@ -0,0 +1,8 @@
+/**
+ * @author Ivan Torres
+ */
+import useStyle from '../useStyle';
+export default (function (_a) {
+    var children = _a.children;
+    return children(useStyle());
+});

package/esm/style/_buildUtils.d.ts

@@ -0,0 +1,4 @@
+import { StyleUtils, ThemeContext, StyleObject } from '../types';
+declare type StyletronCSS = (arg: StyleObject) => string;
+declare const _default: (ctx: ThemeContext, styletronCSS: StyletronCSS) => StyleUtils;
+export default _default;

package/esm/style/_buildUtils.js

@@ -0,0 +1,10 @@
+import { __assign } from "tslib";
+import _getStyle from './_getStyle';
+import _css from './_css';
+import _px2rem from './_px2rem';
+export default (function (ctx, styletronCSS) {
+    var css = _css.bind(null, ctx, styletronCSS);
+    var getStyle = _getStyle.bind(null, ctx);
+    var px2rem = _px2rem.bind(null, ctx);
+    return __assign(__assign({}, ctx), { css: css, getStyle: getStyle, px2rem: px2rem });
+});

package/esm/style/_css.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @author Ivan Torres
+ */
+import { Styles, StyleUtils, StyleObject } from '../types';
+declare const _css: (utils: StyleUtils, styletronCSS: (arg: StyleObject) => string, ...args: Styles[]) => string;
+export default _css;

package/esm/style/_css.js

@@ -0,0 +1,18 @@
+/**
+ * @author Ivan Torres
+ */
+import { __read } from "tslib";
+import cx from '../classNames';
+import _parseStyle from './_parseStyle';
+var _css = function (utils, styletronCSS) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    // NOTE: prepend previously generated classes by styletron, this can happen
+    // when re-styling a component built with `styled` or `className` added
+    // on top of it:
+    var _a = __read(_parseStyle(utils, {}, args), 2), styleObject = _a[0], invalidArgs = _a[1];
+    return cx(invalidArgs, styletronCSS(styleObject));
+};
+export default _css;

package/esm/style/_escapeClassName.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @author Ivan Torres
+ */
+/// <reference types="lodash" />
+declare const _default: ((className: string) => string) & import("lodash").MemoizedFunction;
+export default _default;

package/esm/style/_escapeClassName.js

@@ -0,0 +1,6 @@
+/**
+ * @author Ivan Torres
+ */
+import _memoize from 'lodash/memoize';
+var _escapeClassName = function (className) { return className.replace(/\//g, '\\/'); };
+export default _memoize(_escapeClassName);

package/esm/style/_getStyle.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @author Ivan Torres
+ */
+import { Styles, StyleUtils, StyleObject } from '../types';
+declare const _getStyle: (utils: StyleUtils, ...args: Styles[]) => StyleObject;
+export default _getStyle;

package/esm/style/_getStyle.js

@@ -0,0 +1,15 @@
+/**
+ * @author Ivan Torres
+ */
+import { __read } from "tslib";
+import _parseStyle from './_parseStyle';
+var EMPTY_OBJECT = {};
+var _getStyle = function (utils) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    var _a = __read(_parseStyle(utils, EMPTY_OBJECT, args), 1), styleObject = _a[0];
+    return styleObject;
+};
+export default _getStyle;

package/esm/style/_getStyleWithProps.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @author Ivan Torres
+ */
+import { Styles, StyleUtils, StyleObject } from '../types';
+declare const _getStyleWithProps: (utils: StyleUtils, props: any, ...args: Styles[]) => StyleObject;
+export default _getStyleWithProps;

package/esm/style/_getStyleWithProps.js

@@ -0,0 +1,15 @@
+/**
+ * @author Ivan Torres
+ */
+import { __read } from "tslib";
+import _parseStyle from './_parseStyle';
+/* eslint @typescript-eslint/no-explicit-any: 0 */
+var _getStyleWithProps = function (utils, props) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    var _a = __read(_parseStyle(utils, props, args), 1), styleObject = _a[0];
+    return styleObject;
+};
+export default _getStyleWithProps;

package/esm/style/_parseStyle.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @author Ivan Torres
+ */
+import { Styles, StyleUtils, StyleObject } from '../types';
+export declare const PSEUDO_SELECTORS: {
+    hover: string;
+    focus: string;
+    active: string;
+    disabled: string;
+    visited: string;
+    'first-child': string;
+    'last-child': string;
+    'odd-child': string;
+    'even-child': string;
+    'focus-within': string;
+    'focus-visible': string;
+};
+declare const _parseStyle: (utils: StyleUtils, props: any, ...args: Styles[]) => [StyleObject, string[]];
+export default _parseStyle;

package/esm/style/_parseStyle.js

@@ -0,0 +1,68 @@
+/**
+ * @author Ivan Torres
+ */
+import { __read } from "tslib";
+/* eslint @typescript-eslint/no-use-before-define: 0, @typescript-eslint/no-explicit-any: 0 */
+import _flattenDeep from 'lodash/flattenDeep';
+import _merge from 'lodash/merge';
+import _escapeClassName from './_escapeClassName';
+export var PSEUDO_SELECTORS = {
+    hover: ':hover',
+    focus: ':focus',
+    active: ':active',
+    disabled: ':disabled',
+    visited: ':visited',
+    'first-child': ':first-child',
+    'last-child': ':last-child',
+    'odd-child': ':nth-child(odd)',
+    'even-child': ':nth-child(2n)',
+    'focus-within': ':focus-within',
+    'focus-visible': ':focus-visible',
+};
+// @ts-ignore Array.prototype.flat - will always be defined
+var flattenDeep = Array.prototype.flat ? function (arr) { return arr.flat(Infinity); } : _flattenDeep;
+var _parseStyle = function (utils, props) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    var invalidArgs = [];
+    if (!args.length)
+        return [{}, invalidArgs];
+    var styleObject = flattenDeep(args).reduce(function (mergedStyleObject, arg) {
+        if (!arg)
+            return mergedStyleObject;
+        if (typeof arg === 'string') {
+            arg.split(' ').forEach(function (className) {
+                var isInvalidClassName = true;
+                if (className.indexOf(':') >= 0) {
+                    var _a = __read(className.split(':'), 2), prefix = _a[0], prefixedClassName = _a[1];
+                    if (utils.theme.screens[prefix]) {
+                        var mediaQuery = "@media screen and (min-width: ".concat(utils.theme.screens[prefix], ")");
+                        mergedStyleObject[mediaQuery] = Object.assign(mergedStyleObject[mediaQuery] || {}, utils.classes[_escapeClassName(prefixedClassName)]);
+                        isInvalidClassName = false;
+                    }
+                    if (PSEUDO_SELECTORS[prefix]) {
+                        var prefixKey = PSEUDO_SELECTORS[prefix];
+                        mergedStyleObject[prefixKey] = Object.assign(mergedStyleObject[prefixKey] || {}, utils.classes[_escapeClassName(prefixedClassName)]);
+                        isInvalidClassName = false;
+                    }
+                }
+                var utilityStyle = utils.classes[_escapeClassName(className)];
+                if (utilityStyle)
+                    Object.assign(mergedStyleObject, utilityStyle);
+                else if (isInvalidClassName)
+                    invalidArgs.push(className);
+            });
+            return mergedStyleObject;
+        }
+        if (typeof arg === 'function') {
+            var _a = __read(_parseStyle(utils, props, arg(utils, props)), 2), _styleObject = _a[0], _invalidArgs = _a[1];
+            invalidArgs = invalidArgs.concat(_invalidArgs);
+            return _merge(mergedStyleObject, _styleObject);
+        }
+        return _merge(mergedStyleObject, arg);
+    }, {});
+    return [styleObject, invalidArgs];
+};
+export default _parseStyle;

package/esm/style/_px2rem.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @author Ivan Torres
+ */
+import { ThemeContext } from '../types';
+declare const _default: ({ theme }: ThemeContext, pixels: number | string) => string;
+/**
+ * Translates length from pixels to rems units (based on theme `htmlFontSize`)
+ */
+export default _default;

package/esm/style/_px2rem.js

@@ -0,0 +1,14 @@
+/**
+ * @author Ivan Torres
+ */
+var isPercent = /[0-9]+(?:\.[0-9]+)?%/;
+var BROWSER_DEFAULT_FONT_SIZE = '16px';
+/**
+ * Translates length from pixels to rems units (based on theme `htmlFontSize`)
+ */
+export default (function (_a, pixels) {
+    var theme = _a.theme;
+    var htmlFontSize = (theme === null || theme === void 0 ? void 0 : theme.htmlFontSize) || BROWSER_DEFAULT_FONT_SIZE;
+    var fontPixels = isPercent.test(htmlFontSize) ? "".concat((parseFloat(htmlFontSize) / 100) * 16, "px") : htmlFontSize;
+    return "".concat((typeof pixels === 'string' ? parseInt(pixels, 10) : pixels) / parseInt(fontPixels, 10), "rem");
+});

package/esm/style/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @author Ivan Torres
+ */
+export { default as styled } from './styled';
+export { default as useStyle } from './useStyle';

package/esm/style/index.js

@@ -0,0 +1,5 @@
+/**
+ * @author Ivan Torres
+ */
+export { default as styled } from './styled';
+export { default as useStyle } from './useStyle';

package/esm/style/styled.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @author Ivan Torres
+ */
+import { ForwardRefExoticComponent, PropsWithoutRef, RefAttributes } from 'react';
+import * as React from 'react';
+import { Styles } from '../types';
+declare type Tag = keyof JSX.IntrinsicElements | React.ComponentType<any>;
+declare type StyledFunc = (ComponentOrTag: Tag, ...args: Styles[]) => StyledComponent;
+export declare type StyledComponent = ForwardRefExoticComponent<PropsWithoutRef<any> & RefAttributes<HTMLElement | React.ComponentClass>>;
+declare const styled: StyledFunc;
+export default styled;

package/esm/style/styled.js

@@ -0,0 +1,40 @@
+import { __assign, __read, __rest } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * @author Ivan Torres
+ */
+/* eslint @typescript-eslint/no-explicit-any: 0 */
+import { useMemo } from 'react';
+import * as React from 'react';
+import cx from '../classNames';
+import { useTheme } from '../theme';
+import { omit$props } from '../helpers';
+import _buildUtils from './_buildUtils';
+import _parseStyle from './_parseStyle';
+import useMemoizedStyletron from './useMemoizedStyletron';
+var styled = function (ComponentOrTag) {
+    var styleArgs = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        styleArgs[_i - 1] = arguments[_i];
+    }
+    var StyledInit = React.forwardRef(function (props, ref) {
+        var ctx = useTheme();
+        var _a = __read(useMemoizedStyletron(), 1), styletronCSS = _a[0];
+        var _b = props.className, className = _b === void 0 ? '' : _b, style = props.style, $style = props.$style, ownProps = __rest(props, ["className", "style", "$style"]);
+        var Component = props.$as || ComponentOrTag;
+        // NOTE: prepend previously generated classes by styletron, this can happen
+        // when re-styling a component built with `styled` or `className` added
+        // on top of it:
+        var utils = _buildUtils(ctx, styletronCSS);
+        var _c = __read(_parseStyle(utils, ownProps, [styleArgs, className, $style, style]), 2), styleObject = _c[0], invalidArgs = _c[1];
+        var classNames = cx(invalidArgs, styletronCSS(styleObject));
+        var componentProps = useMemo(function () { return omit$props(ownProps); }, [ownProps]);
+        return _jsx(Component, __assign({}, componentProps, { className: classNames, ref: ref }), void 0);
+    });
+    StyledInit.displayName =
+        typeof ComponentOrTag === 'string'
+            ? "styled(".concat(ComponentOrTag, ")")
+            : "styled(".concat(ComponentOrTag.displayName || ComponentOrTag.name || ComponentOrTag, ")");
+    return React.memo(StyledInit);
+};
+export default styled;

package/esm/style/useMemoizedStyletron.d.ts

@@ -0,0 +1,5 @@
+/**
+ * styletron returns new `styletronCSS` function each time the hook is called. This hook memorizes the css function and returns same reference every time.
+ */
+declare const useMemoizedStyletron: () => [(arg: import("styletron-standard").StyleObject) => string, import("baseui").Theme];
+export default useMemoizedStyletron;

package/esm/style/useMemoizedStyletron.js

@@ -0,0 +1,14 @@
+import { __read } from "tslib";
+import { useStyletron } from 'baseui';
+import { useCallback } from 'react';
+import { useLatest } from '../hooks/useLatest';
+/**
+ * styletron returns new `styletronCSS` function each time the hook is called. This hook memorizes the css function and returns same reference every time.
+ */
+var useMemoizedStyletron = function () {
+    var _a = __read(useStyletron(), 2), styletronCSS = _a[0], theme = _a[1];
+    var cssRef = useLatest(styletronCSS);
+    var css = useCallback(function (arg) { return cssRef.current(arg); }, [cssRef]);
+    return [css, theme];
+};
+export default useMemoizedStyletron;

package/esm/style/useStyle.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @author Ivan Torres
+ */
+import { StyleUtils } from '../types';
+declare const useStyle: () => StyleUtils;
+export default useStyle;

package/esm/style/useStyle.js

@@ -0,0 +1,14 @@
+/**
+ * @author Ivan Torres
+ */
+import { __read } from "tslib";
+import { useMemo } from 'react';
+import { useTheme } from '../theme';
+import _buildUtils from './_buildUtils';
+import useMemoizedStyletron from './useMemoizedStyletron';
+var useStyle = function () {
+    var ctx = useTheme();
+    var _a = __read(useMemoizedStyletron(), 1), styletronCSS = _a[0];
+    return useMemo(function () { return _buildUtils(ctx, styletronCSS); }, [ctx, styletronCSS]);
+};
+export default useStyle;

package/esm/styleEngine/index.d.ts

@@ -0,0 +1 @@
+export * from './styleEngine';

package/esm/styleEngine/index.js

@@ -0,0 +1 @@
+export * from './styleEngine';

package/esm/styleEngine/styleEngine.d.ts

@@ -0,0 +1,19 @@
+import { PropsWithChildren, ReactElement } from 'react';
+import { Sheet } from 'styletron-engine-atomic';
+import { StandardEngine } from '../types';
+export declare type ProviderProps = {
+    styleEngine?: StandardEngine;
+    debug?: boolean;
+};
+export declare const SPACEWEB_STYLE_PREFIX: Readonly<string>;
+export declare const SPACEWEB_STYLE_CONTAINER_ID: Readonly<string>;
+export declare const isServer: Readonly<boolean>;
+export declare const hydrate: (ownerDocument?: Document) => HTMLCollectionOf<HTMLStyleElement>;
+export declare const getStyleEngine: (ownerDocument?: Document) => StandardEngine;
+export declare const StyleProvider: {
+    (props: PropsWithChildren<ProviderProps>): ReactElement;
+    displayName: string;
+};
+export declare const getStylesheets: () => Sheet[];
+export declare const getStylesheetsHtml: () => string;
+export declare const appendCacheContainer: (ownerDocument?: Document) => Element;

package/esm/styleEngine/styleEngine.js

@@ -0,0 +1,94 @@
+import { __assign } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+/* eslint @typescript-eslint/no-use-before-define: 0 */
+import { useMemo } from 'react';
+import { Client, Server } from 'styletron-engine-atomic';
+import { DebugEngine, Provider as StyletronProvider } from 'styletron-react';
+import { useDocument } from '../spacewebProvider/DocumentProvider';
+export var SPACEWEB_STYLE_PREFIX = 'sw--';
+export var SPACEWEB_STYLE_CONTAINER_ID = 'spaceweb-style-cache';
+export var isServer = typeof window === 'undefined';
+var NoopDebugEngine = /** @class */ (function () {
+    function NoopDebugEngine() {
+        this.debug = function () { return ''; };
+    }
+    return NoopDebugEngine;
+}());
+// NOTE: Define styletron as module variable (singleton)
+var styletron;
+var hasStyletron = function () { return typeof styletron !== 'undefined'; };
+// Throws and error if not called from the server.
+var ensureServer = function () {
+    if (!isServer) {
+        throw new Error('This method can only be called from the server.');
+    }
+};
+// Throws and error if called from the server.
+var ensureClient = function () {
+    if (isServer) {
+        throw new Error('This method can only be called from the browser.');
+    }
+};
+// Throws an error if Styletron engine is not initialized (`getStyleEngine`).
+var ensureEngine = function () {
+    if (!hasStyletron())
+        throw new Error("Styletron engine hasn't been initialized.");
+};
+export var hydrate = function (ownerDocument) {
+    return (ownerDocument || document).getElementsByClassName('_spaceweb_hydrate_');
+};
+// Gets isomorphic Styletron engine.
+export var getStyleEngine = function (ownerDocument) {
+    if (isServer) {
+        if (typeof styletron !== 'undefined')
+            return styletron;
+        styletron = new Server({ prefix: SPACEWEB_STYLE_PREFIX });
+    }
+    else {
+        var doc = ownerDocument || document;
+        var el = doc.getElementById(SPACEWEB_STYLE_CONTAINER_ID);
+        if (el && styletron) {
+            return styletron;
+        }
+        // adds a style tag in document.head to make sure only one instance of styletron is created in an app.
+        appendCacheContainer(ownerDocument);
+        styletron = new Client({
+            hydrate: hydrate(ownerDocument),
+            prefix: SPACEWEB_STYLE_PREFIX,
+        });
+    }
+    return styletron;
+};
+// @ts-ignore
+StyletronProvider.displayName = 'StyletronProvider';
+// Style engine provider (a.k.a. StyletronProvider).
+export var StyleProvider = function (props) {
+    var doc = useDocument();
+    var debugEngine = useMemo(function () { return (props.debug ? new DebugEngine() : new NoopDebugEngine()); }, [props.debug]);
+    return (_jsx(StyletronProvider, __assign({ debug: debugEngine, value: props.styleEngine || getStyleEngine(doc), debugAfterHydration: !!props.debug }, { children: props.children }), void 0));
+};
+StyleProvider.displayName = 'StyleProvider';
+// Gets hydration stylesheets as `Sheet[]` (e.g. Next.js).
+export var getStylesheets = function () {
+    ensureServer();
+    ensureEngine();
+    return styletron.getStylesheets();
+};
+// Gets hydration stylesheets HTML code as string.
+export var getStylesheetsHtml = function () {
+    ensureServer();
+    ensureEngine();
+    return styletron.getStylesheetsHtml();
+};
+// Appends cache styles to the DOM and returns element's instance.
+export var appendCacheContainer = function (ownerDocument) {
+    ensureClient();
+    var doc = ownerDocument || document;
+    var el = doc.getElementById(SPACEWEB_STYLE_CONTAINER_ID);
+    if (el)
+        return el;
+    el = doc.createElement('style');
+    el.id = SPACEWEB_STYLE_CONTAINER_ID;
+    doc.head.appendChild(el);
+    return el;
+};

package/esm/switch/__test__/switch.spec.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom/extend-expect';

package/esm/switch/__test__/switch.spec.js

@@ -0,0 +1,94 @@
+import { __assign, __awaiter, __generator, __rest } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cleanup, fireEvent, render } from '@testing-library/react';
+import '@testing-library/jest-dom/extend-expect';
+import { Switch } from '../index';
+import { TestProvider, getCSSFromEl, getTestStyleUtils, setupBreakpoints } from '../../test-utils/test-provider';
+import { mount } from 'enzyme';
+var renderSwitch = function (_a) {
+    var _b = _a.size, size = _b === void 0 ? 'md' : _b, _c = _a.intent, intent = _c === void 0 ? 'default' : _c, rest = __rest(_a, ["size", "intent"]);
+    return render(_jsx(TestProvider, { children: _jsx(Switch, __assign({ size: size, intent: intent }, rest, { children: "Switch Label" }), void 0) }, void 0));
+};
+var getRenderedSwitch = function () { return window.document.body.querySelectorAll('[data-baseweb="checkbox"]')[0]; };
+describe('Switch', function () {
+    beforeAll(setupBreakpoints);
+    afterEach(cleanup);
+    test('attached on click', function () {
+        var mockFn = jest.fn();
+        var getAllByRole = renderSwitch({ onChange: mockFn }).getAllByRole;
+        var checkboxElement = getAllByRole('checkbox')[0];
+        fireEvent.click(checkboxElement);
+        expect(mockFn).toHaveBeenCalled();
+    });
+    test('on click, aria-checked sets to false when checked', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockFn, getAllByRole, checkboxElement;
+        return __generator(this, function (_a) {
+            mockFn = jest.fn();
+            getAllByRole = renderSwitch({ onChange: mockFn, checked: false }).getAllByRole;
+            checkboxElement = getAllByRole('checkbox')[0];
+            expect(checkboxElement.getAttribute('aria-checked')).toBe('false');
+            return [2 /*return*/];
+        });
+    }); });
+    test('on click, aria-checked sets to true when not checked', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockFn, getAllByRole, checkboxElement;
+        return __generator(this, function (_a) {
+            mockFn = jest.fn();
+            getAllByRole = renderSwitch({ onChange: mockFn, checked: true }).getAllByRole;
+            checkboxElement = getAllByRole('checkbox')[0];
+            expect(checkboxElement.getAttribute('aria-checked')).toBe('true');
+            return [2 /*return*/];
+        });
+    }); });
+    describe('different sizes', function () {
+        var mockFn = jest.fn();
+        afterEach(cleanup);
+        var px2rem = getTestStyleUtils().px2rem;
+        test('ToggleTrack correct dimensions in "sm" size, ', function () {
+            renderSwitch({ size: 'sm', onChange: mockFn });
+            var element = getRenderedSwitch();
+            //first element always be toggleTrack
+            var css1 = getCSSFromEl(element.firstChild);
+            expect(css1.height).toEqual(px2rem(14));
+            expect(css1.width).toEqual(px2rem(24));
+        });
+        test('ToggleTrack correct dimensions in "md" size', function () {
+            renderSwitch({ size: 'md' });
+            var element = getRenderedSwitch();
+            var css1 = getCSSFromEl(element.firstChild);
+            expect(css1.height).toEqual(px2rem(16));
+            expect(css1.width).toEqual(px2rem(28));
+            expect(css1.borderLeftWidth).toEqual(px2rem(1));
+            expect(css1.borderTopWidth).toEqual(px2rem(1));
+            expect(css1.borderRightWidth).toEqual(px2rem(1));
+            expect(css1.borderBottomWidth).toEqual(px2rem(1));
+        });
+        test('ToggleTrack correct dimensions in "lg" size', function () {
+            renderSwitch({ size: 'lg' });
+            var element = getRenderedSwitch();
+            var css1 = getCSSFromEl(element.firstChild);
+            expect(css1.height).toEqual(px2rem(20));
+            expect(css1.width).toEqual(px2rem(36));
+            expect(css1.borderTopLeftRadius).toEqual(px2rem(27));
+            expect(css1.borderTopRightRadius).toEqual(px2rem(27));
+            expect(css1.borderBottomLeftRadius).toEqual(px2rem(27));
+            expect(css1.borderBottomRightRadius).toEqual(px2rem(27));
+        });
+    });
+    describe('Props', function () {
+        jest.mock('../index');
+        var forwardProps = [
+            ['checked', true],
+            ['disabled', true],
+            ['intent', true],
+            ['size', 'lg'],
+        ];
+        describe.each(forwardProps)('when `%s` prop is set', function (prop, exp) {
+            test('prop gets passed down', function () {
+                var _a;
+                var wrapper = mount(_jsx(TestProvider, { children: _jsx(Switch, __assign({}, (_a = {}, _a[prop] = exp, _a)), void 0) }, void 0));
+                expect(wrapper.find('Switch').prop(prop)).toEqual(exp);
+            });
+        });
+    });
+});

package/esm/switch/basewebAdapter.d.ts

@@ -0,0 +1,5 @@
+import { OutlineProps } from '../helpers/commonStyles';
+import { StatefulSwitchProps, SwitchProps } from './types';
+declare type AdaptProps = SwitchProps | StatefulSwitchProps;
+export declare const useSwitchAdapter: (props: AdaptProps) => Omit<AdaptProps, keyof OutlineProps>;
+export {};

package/esm/switch/basewebAdapter.js

@@ -0,0 +1,18 @@
+import { __assign, __rest } from "tslib";
+import { mergeOverrides } from '../overrides';
+import { getToggleTrackOverrides, getToggleOverrides, getLabelOverrides } from './styled-components';
+export var useSwitchAdapter = function (props) {
+    var overrides = props.overrides, $outlineStyle = props.$outlineStyle, $outlineColor = props.$outlineColor, $outlineOffset = props.$outlineOffset, $outlineWidth = props.$outlineWidth, restProps = __rest(props, ["overrides", "$outlineStyle", "$outlineColor", "$outlineOffset", "$outlineWidth"]);
+    var mergedOverrides = mergeOverrides({
+        Toggle: {
+            style: getToggleOverrides,
+        },
+        ToggleTrack: {
+            style: getToggleTrackOverrides,
+        },
+        Label: {
+            style: getLabelOverrides,
+        },
+    }, overrides);
+    return __assign(__assign({}, restProps), { overrides: mergedOverrides });
+};

package/esm/switch/index.d.ts

@@ -0,0 +1,3 @@
+export { Switch, StatefulSwitch } from './switch';
+export { StatefulContainer, StyledRoot, StyledLabel, StyledInput, StyledToggle, StyledToggleTrack, } from 'baseui/checkbox';
+export * from './types';

package/esm/switch/index.js

@@ -0,0 +1,3 @@
+export { Switch, StatefulSwitch } from './switch';
+export { StatefulContainer, StyledRoot, StyledLabel, StyledInput, StyledToggle, StyledToggleTrack, } from 'baseui/checkbox';
+export * from './types';