@king-design/react 2.0.0-beta.0

package/components/tooltip/tooltip.js

@@ -0,0 +1,78 @@
+import _inheritsLoose from "@babel/runtime-corejs3/helpers/inheritsLoose";
+import _extends from "@babel/runtime-corejs3/helpers/extends";
+import _concatInstanceProperty from "@babel/runtime-corejs3/core-js/instance/concat";
+import { Dropdown } from '../dropdown/dropdown';
+import { _$ } from '../../i18n';
+import { themes } from './styles';
+
+var typeDefs = _extends({}, Dropdown.typeDefs, {
+  showArrow: Boolean,
+  theme: themes,
+  hoverable: Boolean,
+  always: Boolean,
+  confirm: Boolean,
+  okText: String,
+  cancelText: String,
+  size: ['small', 'default'],
+  content: null
+});
+
+var defaults = function defaults() {
+  return _extends({}, Dropdown.defaults(), {
+    showArrow: true,
+    theme: 'dark',
+    position: {
+      my: 'center bottom-10',
+      at: 'center top',
+      collision: 'flipfit'
+    },
+    hoverable: false,
+    always: false,
+    confirm: false,
+    okText: _$('确定'),
+    cancelText: _$('取消'),
+    size: 'default'
+  });
+};
+
+var events = _extends({}, Dropdown.events, {
+  ok: true,
+  cancel: true
+});
+
+export var Tooltip = /*#__PURE__*/function (_Dropdown) {
+  _inheritsLoose(Tooltip, _Dropdown);
+
+  function Tooltip() {
+    var _context;
+
+    var _this;
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _Dropdown.call.apply(_Dropdown, _concatInstanceProperty(_context = [this]).call(_context, args)) || this;
+    _this.alwaysPortal = true;
+    return _this;
+  }
+
+  var _proto = Tooltip.prototype;
+
+  _proto.hide = function hide(immediately) {
+    if (this.get('always')) return;
+
+    if (this.get('hoverable')) {
+      return _Dropdown.prototype.hide.call(this, immediately);
+    }
+
+    _Dropdown.prototype.hide.call(this, true);
+  };
+
+  return Tooltip;
+}(Dropdown);
+Tooltip.typeDefs = typeDefs;
+Tooltip.defaults = defaults;
+Tooltip.events = events;
+
+export {normalize} from 'intact-react';

package/components/tooltip/useArrow.d.ts

@@ -0,0 +1,7 @@
+export declare function useArrow(): {
+    arrowType: import("../../hooks/useState").State<string | null>;
+    arrowRef: import('intact-react').RefObject<HTMLElement>;
+};
+
+
+export {normalize} from 'intact-react';

package/components/tooltip/useArrow.js

@@ -0,0 +1,53 @@
+import { useInstance, createRef, onBeforeUnmount, nextTick } from 'intact-react';
+import { useState } from '../../hooks/useState';
+import { clamp } from '../utils';
+export function useArrow() {
+  var instance = useInstance();
+  var arrowType = useState(null);
+  var arrowRef = createRef();
+  instance.dropdown.on('positioned', updateArrow);
+  onBeforeUnmount(function () {
+    instance.dropdown.off('positioned', updateArrow);
+  });
+
+  function updateArrow(feedback) {
+    if (!instance.dropdown.get('showArrow')) return;
+    arrowType.set(feedback[feedback.important]); // we must calcuate style after set arrow type and view has updated
+
+    nextTick(function () {
+      if (instance.$unmounted) return;
+      var arrow = arrowRef.value;
+      var target = feedback.target,
+          element = feedback.element;
+
+      if (feedback.important === 'vertical') {
+        var arrowWidth = arrow.offsetWidth;
+        var left; // if (feedback.horizontal === 'center') {
+        // left = (element.width - arrowWidth) / 2;
+        // } else {
+
+        left = target.left - element.left + (target.width - arrowWidth) / 2; // }
+
+        left = clamp(left, 1, element.width - 1 - arrowWidth);
+        arrow.setAttribute('style', "left: " + left + "px");
+      } else {
+        var arrowHeight = arrow.offsetHeight;
+        var top; // if (feedback.vertical === 'center') {
+        // top = (element.height - arrowHeight) / 2;
+        // } else {
+
+        top = target.top - element.top + target.height / 2 - arrowHeight / 2; // }
+
+        top = clamp(top, 1, element.height - 1 - arrowHeight);
+        arrow.setAttribute('style', "top: " + top + "px");
+      }
+    });
+  }
+
+  return {
+    arrowType: arrowType,
+    arrowRef: arrowRef
+  };
+}
+
+export {normalize} from 'intact-react';

package/components/transfer/index.d.ts

@@ -0,0 +1,51 @@
+import { Component, TypeDefs, VNode, Key, Children } from 'intact-react';
+import { Model } from './useFilter';
+import type { Events } from '../types';
+export interface TransferProps<K extends string = 'key', L extends string = 'label', T extends TransferDataItem<K, L> = TransferDataItem<K, L>, V extends T[K] = T[K]> {
+    data?: T[];
+    keyName?: K;
+    labelName?: L;
+    value?: V[];
+    leftCheckedKeys?: V[];
+    rightCheckedKeys?: V[];
+    filterable?: boolean;
+    filter?: (data: T, keywords: string) => boolean;
+    placeholder?: string;
+    leftKeywords?: string;
+    rightKeywords?: string;
+    leftTitle?: string | VNode;
+    rightTitle?: string | VNode;
+    enableAdd?: () => boolean;
+    enableRemove?: () => boolean;
+}
+export declare type TransferDataItem<A extends string = 'key', B extends string = 'label'> = {
+    [K in A]: Key;
+} & {
+    [K in B]?: Children;
+} & {
+    disabled?: boolean;
+};
+export interface TransferEvents {
+    add: [];
+    remove: [];
+}
+export interface TransferBlocks<T, V> {
+    header: Model;
+    filter: Model;
+    list: Model;
+    label: [T, V, Model];
+}
+export declare class Transfer<K extends string = 'key', L extends string = 'label', T extends TransferDataItem<K, L> = TransferDataItem<K, L>, V extends T[K] = T[K]> extends Component<TransferProps<K, L, T, V>, TransferEvents, TransferBlocks<T, V>> {
+    static template: string | import("intact").Template<any>;
+    static typeDefs: Required<TypeDefs<TransferProps<"key", "label", TransferDataItem<"key", "label">, Key>>>;
+    static defaults: () => Partial<TransferProps<"key", "label", TransferDataItem<"key", "label">, Key>>;
+    static events: Events<TransferEvents>;
+    private transfer;
+    private filter;
+    private check;
+    getData(): any[];
+    getCheckedData(model: Model): any[];
+}
+
+
+export {normalize} from 'intact-react';

package/components/transfer/index.js

@@ -0,0 +1,90 @@
+import _inheritsLoose from "@babel/runtime-corejs3/helpers/inheritsLoose";
+import _concatInstanceProperty from "@babel/runtime-corejs3/core-js/instance/concat";
+import _filterInstanceProperty from "@babel/runtime-corejs3/core-js/instance/filter";
+import { Component, VNode } from 'intact-react';
+import template from './index.vdt';
+import { _$ } from '../../i18n';
+import { useTransfer } from './useTransfer';
+import { useFilter } from './useFilter';
+import { useCheck } from './useCheck';
+var typeDefs = {
+  data: Array,
+  keyName: String,
+  labelName: String,
+  value: Array,
+  leftCheckedKeys: Array,
+  rightCheckedKeys: Array,
+  filterable: Boolean,
+  filter: Function,
+  placeholder: String,
+  leftKeywords: String,
+  rightKeywords: String,
+  leftTitle: [String, VNode],
+  rightTitle: [String, VNode],
+  enableAdd: Function,
+  enableRemove: Function
+};
+
+var defaults = function defaults() {
+  return {
+    data: [],
+    keyName: 'key',
+    labelName: 'label',
+    value: [],
+    leftCheckedKeys: [],
+    rightCheckedKeys: [],
+    placeholder: _$('请输入'),
+    leftTitle: _$('请选择'),
+    rightTitle: _$('已选择')
+  };
+};
+
+var events = {
+  add: true,
+  remove: true
+};
+export var Transfer = /*#__PURE__*/function (_Component) {
+  _inheritsLoose(Transfer, _Component);
+
+  function Transfer() {
+    var _context;
+
+    var _this;
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _Component.call.apply(_Component, _concatInstanceProperty(_context = [this]).call(_context, args)) || this;
+    _this.transfer = useTransfer();
+    _this.filter = useFilter(_this.transfer.rightData);
+    _this.check = useCheck(_filterInstanceProperty(_this));
+    return _this;
+  }
+
+  var _proto = Transfer.prototype;
+
+  _proto.getData = function getData() {
+    return this.transfer.rightData.value;
+  };
+
+  _proto.getCheckedData = function getCheckedData(model) {
+    var data = _filterInstanceProperty(this).getFilterData(model);
+
+    var _this$get = this.get(),
+        keyName = _this$get.keyName;
+
+    var checkedKeys = this.get(model + "CheckedKeys");
+    return _filterInstanceProperty(data).call(data, function (item) {
+      return ~checkedKeys.indexOf(item[keyName]);
+    });
+  };
+
+  return Transfer;
+}(Component);
+Transfer.template = template;
+Transfer.typeDefs = typeDefs;
+Transfer.defaults = defaults;
+Transfer.events = events;
+
+export {normalize} from 'intact-react';

package/components/transfer/index.spec.d.ts

@@ -0,0 +1,4 @@
+export {};
+
+
+export {normalize} from 'intact-react';

package/components/transfer/index.spec.js

@@ -0,0 +1,242 @@
+import _asyncToGenerator from "@babel/runtime-corejs3/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime-corejs3/regenerator";
+import BasicDemo from '~/components/transfer/demos/basic';
+import LabelDemo from '~/components/transfer/demos/label';
+import { mount, unmount, dispatchEvent, wait } from '../../test/utils';
+describe('Transfer', function () {
+  afterEach(function () {
+    return unmount();
+  });
+  it('should only fix leftChecked when data changed', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var _mount, instance, element, transfer, checkAll, data;
+
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _mount = mount(BasicDemo), instance = _mount[0], element = _mount[1];
+            transfer = instance.refs.__test;
+            checkAll = element.querySelector('.k-checkbox');
+            checkAll.click();
+            _context.next = 6;
+            return wait();
+
+          case 6:
+            data = [{
+              label: '1',
+              key: 'a1'
+            }, {
+              label: '2',
+              key: 'a2'
+            }];
+            instance.set('data', data);
+            _context.next = 10;
+            return wait();
+
+          case 10:
+            expect(transfer.check.isCheckAll('left')).to.be.false;
+            expect(transfer.get('leftCheckedKeys')).to.eql([]);
+            expect(transfer.get('rightCheckedKeys')).to.eql([]);
+            expect(instance.get('value').length).to.eql(2); // keep the checked item when the key in the new data
+
+            checkAll.click();
+            _context.next = 17;
+            return wait();
+
+          case 17:
+            data = [{
+              label: '1',
+              key: 'a1'
+            }, {
+              label: '3',
+              key: 'a3'
+            }];
+            instance.set('data', data);
+            _context.next = 21;
+            return wait();
+
+          case 21:
+            expect(transfer.get('leftCheckedKeys')).to.eql(['a1']);
+            instance.set('data', []);
+            _context.next = 25;
+            return wait();
+
+          case 25:
+            expect(transfer.get('leftCheckedKeys')).to.eql([]);
+
+          case 26:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  })));
+  it('add and remove', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var _mount2, instance, element, leftFirst, _element$querySelecto, remove, add, rightFirst;
+
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _mount2 = mount(BasicDemo), instance = _mount2[0], element = _mount2[1];
+            leftFirst = element.querySelector('.k-transfer-list .k-checkbox');
+            leftFirst.click();
+            _context2.next = 5;
+            return wait();
+
+          case 5:
+            expect(element.outerHTML).to.matchSnapshot();
+            _element$querySelecto = element.querySelectorAll('.k-btn'), remove = _element$querySelecto[0], add = _element$querySelecto[1];
+            add.click();
+            _context2.next = 10;
+            return wait(300);
+
+          case 10:
+            expect(element.outerHTML).to.matchSnapshot();
+            rightFirst = element.querySelector('.k-transfer-panel:nth-child(3) .k-transfer-list .k-checkbox');
+            rightFirst.click();
+            _context2.next = 15;
+            return wait();
+
+          case 15:
+            expect(element.outerHTML).to.matchSnapshot();
+            remove.click();
+            _context2.next = 19;
+            return wait(300);
+
+          case 19:
+            expect(element.outerHTML).to.matchSnapshot();
+
+          case 20:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  })));
+  it('checkAll and uncheckAll', function () {
+    var _mount3 = mount(BasicDemo),
+        instance = _mount3[0],
+        element = _mount3[1];
+
+    var tree = instance.refs.__test;
+
+    var _element$querySelecto2 = element.querySelectorAll('.k-transfer-title .k-checkbox'),
+        leftCheckAll = _element$querySelecto2[0],
+        rightCheckAll = _element$querySelecto2[1];
+
+    leftCheckAll.click();
+    expect(tree.get('leftCheckedKeys')).to.eql([2, 4]);
+    rightCheckAll.click();
+    expect(tree.get('rightCheckedKeys')).to.eql([0]);
+    leftCheckAll.click();
+    expect(tree.get('leftCheckedKeys')).to.eql([]);
+    rightCheckAll.click();
+    expect(tree.get('rightCheckedKeys')).to.eql([]);
+  });
+  it('check with shift key', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+    var _mount4, instance, element, tree, data, _element$querySelecto3, first, second, last;
+
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            _mount4 = mount(BasicDemo), instance = _mount4[0], element = _mount4[1];
+            tree = instance.refs.__test;
+            data = instance.get('data');
+            instance.set('value', [data[1].key]);
+            _context3.next = 6;
+            return wait();
+
+          case 6:
+            _element$querySelecto3 = element.querySelectorAll('.k-transfer-list .k-transfer-item:not(.k-disabled) input'), first = _element$querySelecto3[0], second = _element$querySelecto3[1], last = _element$querySelecto3[2];
+            first.click();
+            dispatchEvent(last, 'click', {
+              shiftKey: true
+            });
+            expect(tree.get('leftCheckedKeys')).to.eql([0, 2, 4]);
+            dispatchEvent(second, 'click', {
+              shiftKey: true
+            });
+            expect(tree.get('leftCheckedKeys')).to.eql([0, 2]);
+            dispatchEvent(last, 'click', {
+              shiftKey: true
+            });
+            expect(tree.get('leftCheckedKeys')).to.eql([0, 2, 4]);
+            first.click();
+            dispatchEvent(last, 'click', {
+              shiftKey: true
+            });
+            expect(tree.get('leftCheckedKeys')).to.eql([]);
+            dispatchEvent(second, 'click', {
+              shiftKey: true
+            });
+            expect(tree.get('leftCheckedKeys')).to.eql([4]);
+            dispatchEvent(last, 'click', {
+              shiftKey: true
+            });
+            expect(tree.get('leftCheckedKeys')).to.eql([]);
+
+          case 21:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  })));
+  it('filter', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var _mount5, instance, element, transfer, checkAll;
+
+    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            _mount5 = mount(LabelDemo), instance = _mount5[0], element = _mount5[1];
+            transfer = instance.refs.__test;
+            transfer.set('leftKeywords', '0');
+            _context4.next = 5;
+            return wait(300);
+
+          case 5:
+            expect(element.innerHTML).to.matchSnapshot();
+            checkAll = element.querySelector('.k-transfer-title .k-checkbox');
+            checkAll.click();
+            _context4.next = 10;
+            return wait();
+
+          case 10:
+            expect(element.innerHTML).to.matchSnapshot();
+            transfer.set('leftKeywords', '');
+            _context4.next = 14;
+            return wait(300);
+
+          case 14:
+            expect(element.innerHTML).to.matchSnapshot();
+            checkAll.click();
+            _context4.next = 18;
+            return wait();
+
+          case 18:
+            expect(element.innerHTML).to.matchSnapshot();
+            transfer.set('leftKeywords', '0');
+            _context4.next = 22;
+            return wait();
+
+          case 22:
+            transfer.set('leftKeywords', '');
+            _context4.next = 25;
+            return wait(300);
+
+          case 25:
+            expect(element.innerHTML).to.matchSnapshot();
+
+          case 26:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  })));
+});
+
+export {normalize} from 'intact-react';

package/components/transfer/index.vdt.js

@@ -0,0 +1,161 @@
+import _extends from "@babel/runtime-corejs3/helpers/extends";
+import _filterInstanceProperty from "@babel/runtime-corejs3/core-js/instance/filter";
+import { createElementVNode as _$ce, createTextVNode as _$ct, createUnknownComponentVNode as _$cc, noop as _$no, extend as _$ex, EMPTY_OBJ as _$em, map as _$ma, className as _$cn, createVNode as _$cv } from 'intact-react';
+import { linkEvent, Transition, TransitionGroup } from 'intact';
+import { getRestProps } from '../utils';
+import { makeStyles } from './styles';
+import { Input } from '../input';
+import { Checkbox } from '../checkbox';
+import { Button } from '../button';
+import { Tree } from '../tree';
+export default function ($props, $blocks, $__proto__) {
+  var _classNameObj,
+      _this = this;
+
+  $blocks || ($blocks = {});
+  $props || ($props = {});
+  var $this = this;
+  var _$blocks = {};
+  var __$blocks = {};
+
+  var _this$get = this.get(),
+      data = _this$get.data,
+      className = _this$get.className,
+      keyName = _this$get.keyName,
+      labelName = _this$get.labelName,
+      filterable = _this$get.filterable,
+      filter = _filterInstanceProperty(_this$get),
+      placeholder = _this$get.placeholder;
+
+  var getShowedData = _filterInstanceProperty(this).getShowedData;
+
+  var _this$transfer = this.transfer,
+      enableAdd = _this$transfer.enableAdd,
+      enableRemove = _this$transfer.enableRemove,
+      add = _this$transfer.add,
+      remove = _this$transfer.remove;
+  var _this$check = this.check,
+      isCheckAll = _this$check.isCheckAll,
+      toggleCheckAll = _this$check.toggleCheckAll,
+      onCheckboxChange = _this$check.onCheckboxChange;
+  var classNameObj = (_classNameObj = {
+    'k-transfer': true
+  }, _classNameObj[className] = className, _classNameObj[makeStyles()] = true, _classNameObj);
+
+  var Panel = function Panel(model) {
+    var title = _this.get(model + "Title");
+
+    var data = getShowedData(model);
+    return _$ce(2, 'div', [_$ce(2, 'div', (_$blocks['header'] = function ($super) {
+      return [_$ce(2, 'div', [this.get(model + "CheckedKeys.length"), _$ct(' /\n                    '), data.length], 0, 'k-transfer-count'), _$cc(Checkbox, {
+        'className': 'c-ellipsis',
+        'value': isCheckAll(model),
+        'ev-click': toggleCheckAll.bind(null, model),
+        'children': title
+      })];
+    }, __$blocks['header'] = function ($super, data) {
+      var block = $blocks['header'];
+
+      var callBlock = function callBlock() {
+        return _$blocks['header'].call($this, $super, data);
+      };
+
+      return block ? block.call($this, callBlock, data) : callBlock();
+    }, __$blocks['header'](_$no, model)), 0, 'k-transfer-title'), filterable ? (_$blocks['filter'] = function ($super) {
+      return _$cc(Input, {
+        'placeholder': placeholder,
+        'clearable': true,
+        'size': 'small',
+        '$blocks': function ($blocks) {
+          var _$blocks = {},
+              __$blocks = _$ex({}, $blocks);
+
+          return (_$blocks['prefix'] = function ($super) {
+            return _$ce(2, 'i', null, 1, 'ion-ios-search');
+          }, __$blocks['prefix'] = function ($super, data) {
+            var block = $blocks['prefix'];
+
+            var callBlock = function callBlock() {
+              return _$blocks['prefix'].call($this, $super, data);
+            };
+
+            return block ? block.call($this, callBlock, data) : callBlock();
+          }), __$blocks;
+        }.call($this, _$em),
+        'ev-$model:value': function ev$modelValue($v) {
+          $this.set(model + "Keywords", $v);
+        },
+        'value': $this.get(model + "Keywords")
+      });
+    }, __$blocks['filter'] = function ($super, data) {
+      var block = _filterInstanceProperty($blocks);
+
+      var callBlock = function callBlock() {
+        return _filterInstanceProperty(_$blocks).call($this, $super, data);
+      };
+
+      return block ? block.call($this, callBlock, data) : callBlock();
+    }, _filterInstanceProperty(__$blocks).call(__$blocks, _$no, model)) : undefined, _$ce(2, 'div', (_$blocks['list'] = function ($super) {
+      return _$cc(TransitionGroup, {
+        'name': 'k-fade',
+        'children': _$ma(data, function ($value, $key) {
+          return _$ce(2, 'div', _$cc(Checkbox, {
+            'name': model,
+            'trueValue': $value[keyName],
+            'disabled': $value.disabled,
+            'ev-click': onCheckboxChange.bind(this, model, $key),
+            'children': (_$blocks['label'] = function ($super) {
+              return $value[labelName];
+            }, __$blocks['label'] = function ($super, data) {
+              var block = $blocks['label'];
+
+              var callBlock = function callBlock() {
+                return _$blocks['label'].call($this, $super, data);
+              };
+
+              return block ? block.call($this, callBlock, data) : callBlock();
+            }, __$blocks['label'](_$no, [$value, $key, model])),
+            'ev-$model:value': function ev$modelValue($v) {
+              $this.set(model + "CheckedKeys", $v);
+            },
+            'value': $this.get(model + "CheckedKeys")
+          }), 2, _$cn({
+            "k-transfer-item": true,
+            "k-disabled": $value.disabled
+          }), null, $value[keyName] || $value[labelName] || $value);
+        }, $this)
+      });
+    }, __$blocks['list'] = function ($super, data) {
+      var block = $blocks['list'];
+
+      var callBlock = function callBlock() {
+        return _$blocks['list'].call($this, $super, data);
+      };
+
+      return block ? block.call($this, callBlock, data) : callBlock();
+    }, __$blocks['list'](_$no, model)), 0, 'k-transfer-list')], 0, 'k-transfer-panel');
+  };
+
+  return _$cv('div', _extends({
+    'className': _$cn(classNameObj)
+  }, getRestProps(this)), [Panel('left'), _$ce(2, 'div', [_$cc(Button, {
+    'circle': true,
+    'icon': true,
+    'disabled': !enableRemove(),
+    'ev-click': remove,
+    'type': 'primary',
+    'size': 'large',
+    'children': _$ce(2, 'i', null, 1, 'k-transfer-icon ion-ios-arrow-left')
+  }), _$cc(Button, {
+    'circle': true,
+    'icon': true,
+    'disabled': !enableAdd(),
+    'ev-click': add,
+    'type': 'primary',
+    'size': 'large',
+    'children': _$ce(2, 'i', null, 1, 'k-transfer-icon ion-ios-arrow-right')
+  })], 4, 'k-transfer-arrows'), Panel('right')]);
+}
+;
+
+export {normalize} from 'intact-react';