antd-mobile 5.17.0 → 5.18.0

package/2x/cjs/components/swiper/swiper.js

@@ -0,0 +1,302 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Swiper = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _nativeProps = require("../../utils/native-props");
+
+var _withDefaultProps = require("../../utils/with-default-props");
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _swiperItem = require("./swiper-item");
+
+var _devLog = require("../../utils/dev-log");
+
+var _web = require("@react-spring/web");
+
+var _react2 = require("@use-gesture/react");
+
+var _pageIndicator = _interopRequireDefault(require("../page-indicator"));
+
+var _stagedComponents = require("staged-components");
+
+var _useRefState = require("../../utils/use-ref-state");
+
+var _bound = require("../../utils/bound");
+
+var _ahooks = require("ahooks");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const classPrefix = `adm-swiper`;
+const defaultProps = {
+  defaultIndex: 0,
+  allowTouchMove: true,
+  autoplay: false,
+  autoplayInterval: 3000,
+  loop: false,
+  direction: 'horizontal',
+  slideSize: 100,
+  trackOffset: 0,
+  stuckAtBoundary: true,
+  rubberband: true
+};
+const Swiper = (0, _react.forwardRef)((0, _stagedComponents.staged)((p, ref) => {
+  const props = (0, _withDefaultProps.mergeProps)(defaultProps, p);
+  const isVertical = props.direction === 'vertical';
+  const slideRatio = props.slideSize / 100;
+  const offsetRatio = props.trackOffset / 100;
+  const {
+    validChildren,
+    count
+  } = (0, _react.useMemo)(() => {
+    let count = 0;
+
+    const validChildren = _react.default.Children.map(props.children, child => {
+      if (!_react.default.isValidElement(child)) return null;
+
+      if (child.type !== _swiperItem.SwiperItem) {
+        (0, _devLog.devWarning)('Swiper', 'The children of `Swiper` must be `Swiper.Item` components.');
+        return null;
+      }
+
+      count++;
+      return child;
+    });
+
+    return {
+      validChildren,
+      count
+    };
+  }, [props.children]);
+
+  if (count === 0 || !validChildren) {
+    (0, _devLog.devWarning)('Swiper', '`Swiper` needs at least one child.');
+    return null;
+  }
+
+  return () => {
+    let loop = props.loop;
+
+    if (slideRatio * (count - 1) < 1) {
+      loop = false;
+    }
+
+    const trackRef = (0, _react.useRef)(null);
+
+    function getSlidePixels() {
+      const track = trackRef.current;
+      if (!track) return 0;
+      const trackPixels = isVertical ? track.offsetHeight : track.offsetWidth;
+      return trackPixels * props.slideSize / 100;
+    }
+
+    const [current, setCurrent] = (0, _react.useState)(props.defaultIndex);
+    (0, _ahooks.useUpdateEffect)(() => {
+      var _a;
+
+      (_a = props.onIndexChange) === null || _a === void 0 ? void 0 : _a.call(props, current);
+    }, [current]);
+    const [dragging, setDragging, draggingRef] = (0, _useRefState.useRefState)(false);
+
+    function boundIndex(current) {
+      let min = 0;
+      let max = count - 1;
+
+      if (props.stuckAtBoundary) {
+        min += offsetRatio / slideRatio;
+        max -= (1 - slideRatio - offsetRatio) / slideRatio;
+      }
+
+      return (0, _bound.bound)(current, min, max);
+    }
+
+    const [{
+      position
+    }, api] = (0, _web.useSpring)(() => ({
+      position: boundIndex(current) * 100,
+      config: {
+        tension: 200,
+        friction: 30
+      },
+      onRest: () => {
+        if (draggingRef.current) return;
+        if (!loop) return;
+        const rawX = position.get();
+        const totalWidth = 100 * count;
+        const standardPosition = modulus(rawX, totalWidth);
+        if (standardPosition === rawX) return;
+        api.start({
+          position: standardPosition,
+          immediate: true
+        });
+      }
+    }), [count]);
+    const bind = (0, _react2.useDrag)(state => {
+      const slidePixels = getSlidePixels();
+      if (!slidePixels) return;
+      const paramIndex = isVertical ? 1 : 0;
+      const offset = state.offset[paramIndex];
+      const direction = state.direction[paramIndex];
+      const velocity = state.velocity[paramIndex];
+      setDragging(true);
+
+      if (!state.last) {
+        api.start({
+          position: offset * 100 / slidePixels,
+          immediate: true
+        });
+      } else {
+        const minIndex = Math.floor(offset / slidePixels);
+        const maxIndex = minIndex + 1;
+        const index = Math.round((offset + velocity * 2000 * direction) / slidePixels);
+        swipeTo((0, _bound.bound)(index, minIndex, maxIndex));
+        window.setTimeout(() => {
+          setDragging(false);
+        });
+      }
+    }, {
+      transform: ([x, y]) => [-x, -y],
+      from: () => {
+        const slidePixels = getSlidePixels();
+        return [position.get() / 100 * slidePixels, position.get() / 100 * slidePixels];
+      },
+      bounds: () => {
+        if (loop) return {};
+        const slidePixels = getSlidePixels();
+        const lowerBound = boundIndex(0) * slidePixels;
+        const upperBound = boundIndex(count - 1) * slidePixels;
+        return isVertical ? {
+          top: lowerBound,
+          bottom: upperBound
+        } : {
+          left: lowerBound,
+          right: upperBound
+        };
+      },
+      rubberband: props.rubberband,
+      axis: isVertical ? 'y' : 'x',
+      preventScroll: !isVertical,
+      pointer: {
+        touch: true
+      }
+    });
+
+    function swipeTo(index, immediate = false) {
+      const roundedIndex = Math.round(index);
+      const targetIndex = loop ? modulus(roundedIndex, count) : (0, _bound.bound)(roundedIndex, 0, count - 1);
+      setCurrent(targetIndex);
+      api.start({
+        position: (loop ? roundedIndex : boundIndex(roundedIndex)) * 100,
+        immediate
+      });
+    }
+
+    function swipeNext() {
+      swipeTo(Math.round(position.get() / 100) + 1);
+    }
+
+    function swipePrev() {
+      swipeTo(Math.round(position.get() / 100) - 1);
+    }
+
+    (0, _react.useImperativeHandle)(ref, () => ({
+      swipeTo,
+      swipeNext,
+      swipePrev
+    }));
+    (0, _ahooks.useIsomorphicLayoutEffect)(() => {
+      const maxIndex = validChildren.length - 1;
+
+      if (current > maxIndex) {
+        swipeTo(maxIndex, true);
+      }
+    });
+    const {
+      autoplay,
+      autoplayInterval
+    } = props;
+    (0, _react.useEffect)(() => {
+      if (!autoplay || dragging) return;
+      const interval = window.setInterval(() => {
+        swipeNext();
+      }, autoplayInterval);
+      return () => {
+        window.clearInterval(interval);
+      };
+    }, [autoplay, autoplayInterval, dragging]);
+
+    function renderTrackInner() {
+      if (loop) {
+        return _react.default.createElement("div", {
+          className: `${classPrefix}-track-inner`
+        }, _react.default.Children.map(validChildren, (child, index) => {
+          return _react.default.createElement(_web.animated.div, {
+            className: `${classPrefix}-slide`,
+            style: {
+              [isVertical ? 'y' : 'x']: position.to(position => {
+                let finalPosition = -position + index * 100;
+                const totalWidth = count * 100;
+                const flagWidth = totalWidth / 2;
+                finalPosition = modulus(finalPosition + flagWidth, totalWidth) - flagWidth;
+                return `${finalPosition}%`;
+              }),
+              [isVertical ? 'top' : 'left']: `-${index * 100}%`
+            }
+          }, child);
+        }));
+      } else {
+        return _react.default.createElement(_web.animated.div, {
+          className: `${classPrefix}-track-inner`,
+          style: {
+            [isVertical ? 'y' : 'x']: position.to(position => `${-position}%`)
+          }
+        }, _react.default.Children.map(validChildren, child => {
+          return _react.default.createElement("div", {
+            className: `${classPrefix}-slide`
+          }, child);
+        }));
+      }
+    }
+
+    const style = {
+      '--slide-size': `${props.slideSize}%`,
+      '--track-offset': `${props.trackOffset}%`
+    };
+    return (0, _nativeProps.withNativeProps)(props, _react.default.createElement("div", {
+      className: (0, _classnames.default)(classPrefix, `${classPrefix}-${props.direction}`),
+      style: style
+    }, _react.default.createElement("div", Object.assign({
+      ref: trackRef,
+      className: (0, _classnames.default)(`${classPrefix}-track`, {
+        [`${classPrefix}-track-allow-touch-move`]: props.allowTouchMove
+      }),
+      onClickCapture: e => {
+        if (draggingRef.current) {
+          e.stopPropagation();
+        }
+      }
+    }, props.allowTouchMove ? bind() : {}), renderTrackInner()), props.indicator === undefined ? _react.default.createElement("div", {
+      className: `${classPrefix}-indicator`
+    }, _react.default.createElement(_pageIndicator.default, Object.assign({}, props.indicatorProps, {
+      total: count,
+      current: current,
+      direction: props.direction
+    }))) : props.indicator(count, current)));
+  };
+}));
+exports.Swiper = Swiper;
+
+function modulus(value, division) {
+  const remainder = value % division;
+  return remainder < 0 ? remainder + division : remainder;
+}

package/2x/cjs/components/swiper/swiper.patch.css

@@ -0,0 +1,26 @@
+.adm-swiper {
+  display: block;
+  width: 100%;
+  height: auto;
+  border-radius: 0;
+}
+
+.adm-swiper-track {
+  padding: 0;
+}
+
+.adm-swiper-horizontal .adm-swiper-track {
+  transform: translateX(0%);
+}
+
+.adm-swiper-horizontal .adm-swiper-track-inner {
+  width: 100%;
+}
+
+.adm-swiper-vertical .adm-swiper-track {
+  transform: translateY(0%);
+}
+
+.adm-swiper-vertical .adm-swiper-track-inner {
+  height: 100%;
+}

package/2x/cjs/components/switch/index.d.ts

@@ -0,0 +1,4 @@
+import './switch.less';
+import { Switch } from './switch';
+export type { SwitchProps } from './switch';
+export default Switch;

package/2x/cjs/components/switch/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("./switch.css");
+
+var _switch2 = require("./switch");
+
+var _default = _switch2.Switch;
+exports.default = _default;

package/2x/cjs/components/switch/spin-icon.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { NativeProps } from '../../utils/native-props';
+export declare const SpinIcon: React.NamedExoticComponent<NativeProps<never>>;

package/2x/cjs/components/switch/spin-icon.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SpinIcon = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _nativeProps = require("../../utils/native-props");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const SpinIcon = (0, _react.memo)(props => {
+  return (0, _nativeProps.withNativeProps)(props, _react.default.createElement("svg", {
+    width: '28px',
+    height: '28px',
+    viewBox: '0 0 28 28'
+  }, _react.default.createElement("g", {
+    stroke: 'none',
+    strokeWidth: '1',
+    fill: 'none',
+    fillRule: 'evenodd'
+  }, _react.default.createElement("g", {
+    transform: 'translate(-137.000000, -840.000000)',
+    fill: '#1576FE'
+  }, _react.default.createElement("g", {
+    transform: 'translate(80.000000, 823.000000)'
+  }, _react.default.createElement("g", {
+    transform: 'translate(53.000000, 13.000000)'
+  }, _react.default.createElement("path", {
+    d: 'M17.9996753,31.5 C10.5556724,31.5 4.5,25.4443275 4.5,18.0003247 C4.5,10.5563219 10.5556724,4.5 17.9996753,4.5 C18.5355492,4.5 18.9702974,4.93474816 18.9702974,5.47062208 C18.9702974,6.006496 18.5355492,6.44124416 17.9996753,6.44124416 C11.6261524,6.44124416 6.44124416,11.6267709 6.44124416,18.0002938 C6.44124416,24.3738167 11.6261524,29.5587249 17.9996753,29.5587249 C24.3731982,29.5587249 29.5587249,24.3738167 29.5587249,18.0002938 C29.5587249,14.7964616 28.2778291,11.8169616 25.9523687,9.61220279 C25.5637302,9.24317094 25.5473089,8.62893223 25.9157222,8.23967523 C26.2841356,7.84976878 26.8989928,7.83461537 27.2882498,8.20302872 C30.0042351,10.7787368 31.5,14.2580826 31.5,18.0002938 C31.5,25.4443275 25.4436781,31.5 17.9996753,31.5 Z'
+  })))))));
+});
+exports.SpinIcon = SpinIcon;

package/2x/cjs/components/switch/switch.css

@@ -0,0 +1,108 @@
+@keyframes loading-rotate {
+  100% {
+    transform: rotate(1turn);
+  }
+}
+
+.adm-switch {
+  --checked-color: var(--adm-color-primary);
+  --height: 62px;
+  --width: 102px;
+  --border-width: 4px;
+  display: inline-block;
+  vertical-align: middle;
+  box-sizing: border-box;
+  position: relative;
+  align-self: center;
+  cursor: pointer;
+  /* 选中状态 */
+  /* 禁用状态 */
+  /* loading图标 */
+}
+
+.adm-switch input {
+  display: none;
+}
+
+.adm-switch-checkbox {
+  min-width: var(--width);
+  height: var(--height);
+  box-sizing: border-box;
+  border-radius: 62px;
+  background: var(--adm-color-border);
+  z-index: 0;
+  overflow: hidden;
+  line-height: var(--height);
+}
+
+.adm-switch-checkbox:before {
+  content: ' ';
+  position: absolute;
+  left: var(--border-width);
+  top: var(--border-width);
+  width: calc(100% - 2 * var(--border-width));
+  height: calc(var(--height) - 2 * var(--border-width));
+  border-radius: calc(var(--height) - 2 * var(--border-width));
+  box-sizing: border-box;
+  background: var(--adm-color-background);
+  z-index: 1;
+  transition: all 200ms;
+  transform: scale(1);
+}
+
+.adm-switch-handle {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  width: calc(var(--height) - 2 * var(--border-width));
+  height: calc(var(--height) - 2 * var(--border-width));
+  border-radius: calc(var(--height) - 2 * var(--border-width));
+  background: var(--adm-color-white);
+  position: absolute;
+  z-index: 2;
+  top: var(--border-width);
+  left: var(--border-width);
+  transition: all 200ms;
+  box-shadow: 0 0 4px 0 rgba(0, 0, 0, 0.2), 0 4px 23px 0 rgba(0, 0, 0, 0.08), -2px 4px 4px 0 rgba(0, 0, 0, 0.1);
+}
+
+.adm-switch-inner {
+  position: relative;
+  z-index: 1;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  margin: 0 16px 0 calc(var(--height) - var(--border-width) + 8px);
+  height: 100%;
+  color: var(--adm-color-weak);
+  transition: margin 200ms;
+  font-size: var(--adm-font-size-7);
+}
+
+.adm-switch.adm-switch-checked .adm-switch-checkbox {
+  background: var(--checked-color);
+}
+
+.adm-switch.adm-switch-checked .adm-switch-checkbox:before {
+  transform: scale(0);
+}
+
+.adm-switch.adm-switch-checked .adm-switch-handle {
+  left: calc(100% - (var(--height) - var(--border-width)));
+}
+
+.adm-switch.adm-switch-checked .adm-switch-inner {
+  margin: 0 calc(var(--height) - var(--border-width) + 10px) 0 20px;
+  color: var(--adm-color-white);
+}
+
+.adm-switch.adm-switch-disabled {
+  cursor: not-allowed;
+  opacity: 0.4;
+}
+
+.adm-switch-spin-icon {
+  width: 28px;
+  height: 28px;
+  animation: loading-rotate 1s linear infinite;
+}

package/2x/cjs/components/switch/switch.d.ts

@@ -0,0 +1,14 @@
+import { FC, ReactNode } from 'react';
+import { NativeProps } from '../../utils/native-props';
+export declare type SwitchProps = {
+    loading?: boolean;
+    disabled?: boolean;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    /** @deprecated use `onChange` instead */
+    beforeChange?: (val: boolean) => Promise<void>;
+    onChange?: (checked: boolean) => void | Promise<void>;
+    checkedText?: ReactNode;
+    uncheckedText?: ReactNode;
+} & NativeProps<'--checked-color' | '--width' | '--height' | '--border-width'>;
+export declare const Switch: FC<SwitchProps>;

package/2x/cjs/components/switch/switch.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Switch = void 0;
+
+var _tslib = require("tslib");
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _nativeProps = require("../../utils/native-props");
+
+var _usePropsValue = require("../../utils/use-props-value");
+
+var _withDefaultProps = require("../../utils/with-default-props");
+
+var _spinIcon = require("./spin-icon");
+
+var _configProvider = require("../config-provider");
+
+var _validate = require("../../utils/validate");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const classPrefix = `adm-switch`;
+const defaultProps = {
+  defaultChecked: false
+};
+
+const Switch = p => {
+  const props = (0, _withDefaultProps.mergeProps)(defaultProps, p);
+  const disabled = props.disabled || props.loading || false;
+  const [changing, setChanging] = (0, _react.useState)(false);
+  const {
+    locale
+  } = (0, _configProvider.useConfig)();
+  const [checked, setChecked] = (0, _usePropsValue.usePropsValue)({
+    value: props.checked,
+    defaultValue: props.defaultChecked,
+    onChange: props.onChange
+  });
+
+  function onClick() {
+    return (0, _tslib.__awaiter)(this, void 0, void 0, function* () {
+      if (disabled || props.loading || changing) {
+        return;
+      }
+
+      const nextChecked = !checked;
+
+      if (props.beforeChange) {
+        setChanging(true);
+
+        try {
+          yield props.beforeChange(nextChecked);
+          setChanging(false);
+        } catch (e) {
+          setChanging(false);
+          throw e;
+        }
+      }
+
+      const result = setChecked(nextChecked);
+
+      if ((0, _validate.isPromise)(result)) {
+        setChanging(true);
+
+        try {
+          yield result;
+          setChanging(false);
+        } catch (e) {
+          setChanging(false);
+          throw e;
+        }
+      }
+    });
+  }
+
+  return (0, _nativeProps.withNativeProps)(props, _react.default.createElement("div", {
+    onClick: onClick,
+    className: (0, _classnames.default)(classPrefix, {
+      [`${classPrefix}-checked`]: checked,
+      [`${classPrefix}-disabled`]: disabled || changing
+    }),
+    role: 'switch',
+    "aria-label": locale.Switch.name,
+    "aria-checked": checked,
+    "aria-disabled": disabled
+  }, _react.default.createElement("div", {
+    className: `${classPrefix}-checkbox`
+  }, _react.default.createElement("div", {
+    className: `${classPrefix}-handle`
+  }, (props.loading || changing) && _react.default.createElement(_spinIcon.SpinIcon, {
+    className: `${classPrefix}-spin-icon`
+  })), _react.default.createElement("div", {
+    className: `${classPrefix}-inner`
+  }, checked ? props.checkedText : props.uncheckedText))));
+};
+
+exports.Switch = Switch;

package/2x/cjs/components/tab-bar/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import './tab-bar.less';
+export type { TabBarProps, TabBarItemProps } from './tab-bar';
+declare const _default: import("react").FC<import("./tab-bar").TabBarProps> & {
+    Item: import("react").FC<import("./tab-bar").TabBarItemProps>;
+};
+export default _default;

package/2x/cjs/components/tab-bar/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("./tab-bar.css");
+
+var _tabBar2 = require("./tab-bar");
+
+var _attachPropertiesToComponent = require("../../utils/attach-properties-to-component");
+
+var _default = (0, _attachPropertiesToComponent.attachPropertiesToComponent)(_tabBar2.TabBar, {
+  Item: _tabBar2.TabBarItem
+});
+
+exports.default = _default;