shineout 1.12.2 → 1.12.3

package/esm/AnimationList/index.js

@@ -0,0 +1,27 @@
+import L from './List';
+import hidable from '../hoc/hidable';
+
+var List = function List(type, duration, display) {
+  switch (duration) {
+    case 'fast':
+      duration = 240;
+      break;
+
+    case 'slow':
+      duration = 480;
+      break;
+
+    default:
+      if (typeof duration !== 'number') duration = 360;
+      break;
+  }
+
+  if (typeof type === 'string') type = [type];
+  return hidable(L, {
+    type: type,
+    duration: duration,
+    display: display
+  });
+};
+
+export default List;

package/esm/AnimationList/styles/index.d.ts

@@ -0,0 +1,2 @@
+import '../../styles/normalize.less';
+export declare const listClass: (...args: any) => string;

package/esm/AnimationList/styles/index.js

@@ -0,0 +1,4 @@
+import '../../styles/normalize.less';
+import genaration from '../../utils/classname';
+import listLess from '../../DataList/styles/list.less';
+export var listClass = genaration(listLess, 'list');

package/esm/Breadcrumb/Props.d.ts

@@ -0,0 +1,81 @@
+import * as React from 'react';
+import { StandardProps, KeygenType } from '../@types/common';
+declare type ReactNode = React.ReactNode;
+export interface BreadcrumbData {
+    /**
+     * The click event
+     *
+     * 点击事件
+     *
+     * default: (event)=>void
+     */
+    onClick?: React.MouseEventHandler<HTMLAnchorElement>;
+    /**
+     * Displayed content
+     *
+     * 显示内容
+     *
+     * default: null
+     */
+    title?: string | ReactNode;
+    /**
+     * Link address
+     *
+     * 链接地址，onClick 属性二选一
+     *
+     * default: null
+     */
+    url?: string;
+    /**
+     * Custom render
+     *
+     * 自定义渲染
+     *
+     * default: -
+     */
+    renderItem?: (value: BreadcrumbData) => ReactNode;
+    /**
+     * Custom icon
+     *
+     * 自定义图标
+     *
+     * default: -
+     */
+    icon?: ReactNode;
+}
+export declare type StructureArray<T> = Array<T | StructureArray<T>>;
+export interface BreadcrumbProps<Item = BreadcrumbData> extends StandardProps {
+    /**
+     * The array of breadcrumb objects, see data
+     *
+     * 面包屑对象数组,见 data
+     *
+     * default: []
+     */
+    data?: StructureArray<Item>;
+    /**
+     * A breadcrumb separator which can be strings or custom elements
+     *
+     * 面包屑分隔符,可以是字符串或自定义的元素
+     *
+     * default: "/"
+     */
+    separator?: string | ReactNode;
+    /**
+     * Key generator.When it is true, the data itself is used as the key equivalent to (d => d);When it is a function, use its return value;When it is a string，ues the value of the string.For example, 'id' is the same thing as (d) => d.id.
+     *
+     * 生成每一项key的辅助方法。为 true 时，以数据项本身作为key，相当于 (d => d)；为函数时，使用此函数返回值；为string时，使用这个string对应的数据值。如 'id'，相当于 (d => d.id)
+     *
+     * default: -
+     */
+    keygen?: KeygenType<Item>;
+    /**
+     * Custom render
+     *
+     * 自定义渲染
+     *
+     * default: -
+     */
+    renderItem?: (value: BreadcrumbData) => ReactNode;
+}
+export {};

package/esm/Breadcrumb/Props.js

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

package/esm/Breadcrumb/index.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { BreadcrumbProps, BreadcrumbData, StructureArray } from './Props';
+declare class Breadcrumb extends React.PureComponent<BreadcrumbProps> {
+    static defaultProps: {
+        data: never[];
+        separator: string;
+        className: string;
+        size: import("../@types/common").RegularAttributes.Size;
+        style: React.CSSProperties;
+        type: string;
+    };
+    static displayName: string;
+    renderArray(data: StructureArray<BreadcrumbData>): JSX.Element;
+    renderItem(d: BreadcrumbData): React.ReactNode;
+    render(): JSX.Element;
+}
+export default Breadcrumb;

package/esm/Breadcrumb/index.js

@@ -0,0 +1,91 @@
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/objectSpread";
+import React from 'react';
+import classnames from 'classnames';
+import Popover from '../Popover';
+import { defaultProps } from '../utils/proptypes';
+import { breadcrumbClass } from './styles';
+import { getKey } from '../utils/uid';
+import Caret from '../icons/Caret';
+
+var defaultValue = _objectSpread({}, defaultProps, {
+  data: [],
+  separator: '/'
+});
+
+var Breadcrumb =
+/*#__PURE__*/
+function (_React$PureComponent) {
+  _inheritsLoose(Breadcrumb, _React$PureComponent);
+
+  function Breadcrumb() {
+    return _React$PureComponent.apply(this, arguments) || this;
+  }
+
+  var _proto = Breadcrumb.prototype;
+
+  _proto.renderArray = function renderArray(data) {
+    var _this = this;
+
+    var first = data[0];
+    return React.createElement("span", null, this.renderItem(first), React.createElement("span", {
+      className: breadcrumbClass('down')
+    }, React.createElement(Caret, null)), React.createElement(Popover, {
+      position: "bottom"
+    }, data.slice(1).map(function (d, i) {
+      return React.createElement("div", {
+        className: breadcrumbClass('dropdown-item'),
+        key: i
+      }, _this.renderItem(d));
+    })));
+  };
+
+  _proto.renderItem = function renderItem(d) {
+    var renderItem = this.props.renderItem;
+    var item = d.title;
+
+    if (!React.isValidElement(item)) {
+      if (d.onClick || d.url) {
+        var props = {
+          onClick: d.onClick
+        };
+        if (d.url) props.href = d.url;
+        item = React.createElement("a", props, d.icon, "\xA0", d.title);
+      } else {
+        item = React.createElement("b", null, d.title);
+      }
+    }
+
+    return renderItem ? renderItem(d) : item;
+  };
+
+  _proto.render = function render() {
+    var _this2 = this;
+
+    var _this$props = this.props,
+        data = _this$props.data,
+        separator = _this$props.separator,
+        keygen = _this$props.keygen;
+    var className = classnames(breadcrumbClass('_'), this.props.className);
+    return React.createElement("div", {
+      className: className,
+      style: this.props.style
+    }, data && data.map(function (d, index) {
+      return React.createElement("span", {
+        key: keygen ? getKey(d, keygen, index) : index
+      }, Array.isArray(d) ? _this2.renderArray(d) : _this2.renderItem(d), index !== data.length - 1 ? React.createElement("span", {
+        className: breadcrumbClass('separator')
+      }, separator) : null);
+    }));
+  };
+
+  return Breadcrumb;
+}(React.PureComponent);
+
+_defineProperty(Breadcrumb, "defaultProps", defaultValue);
+
+_defineProperty(Breadcrumb, "displayName", void 0);
+
+Breadcrumb.displayName = 'ShineoutBreadcrumb';
+export default Breadcrumb;

package/esm/Breadcrumb/interface.d.ts

@@ -0,0 +1 @@
+export { BreadcrumbProps as Props, BreadcrumbData as Data } from './Props';

package/esm/Breadcrumb/interface.js

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

package/esm/Breadcrumb/styles/breadcrumb.less

@@ -0,0 +1,52 @@
+@import '../../styles/variables.less';
+@import '../../styles/themes/@{so-theme}.less';
+
+@breadcrumb-prefix: ~'@{so-prefix}-breadcrumb';
+
+//
+// Breadcrumbs
+// --------------------------------------------------
+
+.@{breadcrumb-prefix} {
+  background-color: @breadcrumb-bg;
+  border-radius: @border-radius-base;
+  font-size: @font-size-base;
+  list-style: none;
+
+  &-separator {
+    margin: 0 @breadcrumb-padding-vertical;
+  }
+
+  a,
+  b {
+    display: inline-block;
+  }
+
+  a {
+    color: @breadcrumb-a-color;
+  }
+
+  b {
+    font-weight: normal;
+  }
+
+  a:hover {
+    color: @colors-primary;
+  }
+
+  &-down {
+    display: inline-block;
+    width: 10px;
+    margin-left: 8px;
+  }
+
+  &-dropdown-item a {
+    display: block;
+    padding: 6px 20px;
+    min-width: 100px;
+
+    &:hover {
+      background: rgba(0, 0, 0, 0.05);
+    }
+  }
+}

package/esm/Breadcrumb/styles/index.d.ts

@@ -0,0 +1,2 @@
+import '../../styles/normalize.less';
+export declare const breadcrumbClass: (...args: any) => string;

package/esm/Breadcrumb/styles/index.js

@@ -0,0 +1,4 @@
+import '../../styles/normalize.less';
+import breadcrumbLess from './breadcrumb.less';
+import genaration from '../../utils/classname';
+export var breadcrumbClass = genaration(breadcrumbLess, 'breadcrumb');

package/esm/Button/Button.d.ts

@@ -0,0 +1,13 @@
+import { PureComponent } from 'react';
+import Group from './Group';
+import Once from './Once';
+import { ButtonProps } from './Props';
+declare class Button extends PureComponent<ButtonProps> {
+    static displayName: string;
+    static Group: typeof Group;
+    static Once: typeof Once;
+    static defaultProps: ButtonProps;
+    getChildren(): any;
+    render(): JSX.Element;
+}
+export default Button;

package/esm/Button/Button.js

@@ -0,0 +1,113 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React, { PureComponent, isValidElement } from 'react';
+import classnames from 'classnames';
+import Spin from '../Spin';
+import Group from './Group';
+import Once from './Once';
+import { wrapSpan } from '../utils/dom/element';
+import { buttonClass } from './styles';
+import { isRTL } from '../config';
+import { getDirectionClass } from '../utils/classname';
+var DefaultProps = {
+  size: 'default',
+  htmlType: 'button',
+  outline: false,
+  type: 'default'
+};
+
+var Button =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(Button, _PureComponent);
+
+  function Button() {
+    return _PureComponent.apply(this, arguments) || this;
+  }
+
+  var _proto = Button.prototype;
+
+  _proto.getChildren = function getChildren() {
+    var _this$props = this.props,
+        children = _this$props.children,
+        loading = _this$props.loading,
+        space = _this$props.space;
+    if (!children) return children;
+    var parsed = React.Children.map(wrapSpan(children, space), function (item) {
+      if (loading && isValidElement(item) && item.type.isShineoutIcon) return null;
+      return item;
+    });
+    return (parsed || []).filter(function (v) {
+      return v !== null;
+    });
+  };
+
+  _proto.render = function render() {
+    var _this$props2 = this.props,
+        outlineProp = _this$props2.outline,
+        typeProp = _this$props2.type,
+        size = _this$props2.size,
+        href = _this$props2.href,
+        htmlType = _this$props2.htmlType,
+        loading = _this$props2.loading,
+        disabled = _this$props2.disabled,
+        onRef = _this$props2.onRef,
+        shape = _this$props2.shape,
+        text = _this$props2.text,
+        space = _this$props2.space,
+        target = _this$props2.target,
+        others = _objectWithoutPropertiesLoose(_this$props2, ["outline", "type", "size", "href", "htmlType", "loading", "disabled", "onRef", "shape", "text", "space", "target"]);
+
+    var isSecondary = typeProp === 'secondary' && !outlineProp && !text;
+    var type = isSecondary ? 'primary' : typeProp;
+    var outline = outlineProp || isSecondary;
+    var color = outline || type === 'default' ? undefined : '#fff';
+    if (text) color = 'currentColor';
+    var className = classnames(buttonClass('_', shape !== 'default' && shape, type, outline && 'outline', {
+      large: size === 'large',
+      small: size === 'small',
+      text: text && 'text',
+      rtl: isRTL(),
+      disabled: disabled
+    }), this.props.className);
+
+    if (href && !disabled) {
+      return React.createElement("a", _extends({
+        href: href
+      }, others, {
+        className: className,
+        ref: onRef
+      }), this.props.children);
+    }
+
+    var children = this.getChildren();
+    return (// eslint-disable-next-line react/button-has-type
+      React.createElement("button", _extends({}, others, {
+        ref: onRef,
+        disabled: disabled || loading,
+        type: htmlType,
+        className: className
+      }), loading && React.createElement("span", {
+        className: buttonClass(getDirectionClass('spin'))
+      }, React.createElement(Spin, {
+        size: 12,
+        name: "ring",
+        color: color
+      })), children)
+    );
+  };
+
+  return Button;
+}(PureComponent);
+
+_defineProperty(Button, "displayName", 'ShineoutButton');
+
+_defineProperty(Button, "Group", Group);
+
+_defineProperty(Button, "Once", Once);
+
+_defineProperty(Button, "defaultProps", DefaultProps);
+
+export default Button;

package/esm/Button/Group.d.ts

@@ -0,0 +1,10 @@
+import { PureComponent } from 'react';
+import { ButtonGroupProps } from './Props';
+declare class ButtonGroup extends PureComponent<ButtonGroupProps> {
+    static defaultProps: {
+        outline: boolean;
+        type: string;
+    };
+    render(): JSX.Element;
+}
+export default ButtonGroup;

package/esm/Button/Group.js

@@ -0,0 +1,48 @@
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React, { Children, PureComponent, cloneElement } from 'react';
+import classnames from 'classnames';
+import { buttonClass } from './styles';
+import { isRTL } from '../config';
+
+var ButtonGroup =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(ButtonGroup, _PureComponent);
+
+  function ButtonGroup() {
+    return _PureComponent.apply(this, arguments) || this;
+  }
+
+  var _proto = ButtonGroup.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        children = _this$props.children,
+        outline = _this$props.outline,
+        size = _this$props.size,
+        type = _this$props.type,
+        style = _this$props.style;
+    var typeSetted = type !== 'default';
+    var className = classnames(buttonClass('group', (outline || !typeSetted) && 'outline', isRTL() && 'group-rtl'), this.props.className);
+    return React.createElement("div", {
+      className: className,
+      style: style
+    }, Children.toArray(children).map(function (child) {
+      return cloneElement(child, {
+        size: size,
+        outline: outline,
+        type: typeSetted ? type : child.props.type
+      });
+    }));
+  };
+
+  return ButtonGroup;
+}(PureComponent);
+
+_defineProperty(ButtonGroup, "defaultProps", {
+  outline: false,
+  type: 'default'
+});
+
+export default ButtonGroup;

package/esm/Button/Once.d.ts

@@ -0,0 +1,10 @@
+import React, { PureComponent } from 'react';
+import { ButtonProps } from './Props';
+declare class OnceButton extends PureComponent<ButtonProps, {
+    loading?: boolean;
+}> {
+    constructor(props: ButtonProps);
+    handleClick(e: React.MouseEvent<HTMLElement>): void;
+    render(): JSX.Element;
+}
+export default OnceButton;

package/esm/Button/Once.js

@@ -0,0 +1,43 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import React, { PureComponent } from 'react';
+import Button from './Button';
+
+var OnceButton =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(OnceButton, _PureComponent);
+
+  function OnceButton(props) {
+    var _this;
+
+    _this = _PureComponent.call(this, props) || this;
+    _this.state = {
+      loading: props.loading
+    };
+    _this.handleClick = _this.handleClick.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
+  }
+
+  var _proto = OnceButton.prototype;
+
+  _proto.handleClick = function handleClick(e) {
+    var onClick = this.props.onClick;
+    this.setState({
+      loading: true
+    });
+    if (onClick) onClick(e);
+  };
+
+  _proto.render = function render() {
+    return React.createElement(Button, _extends({}, this.props, {
+      loading: this.state.loading,
+      onClick: this.handleClick
+    }));
+  };
+
+  return OnceButton;
+}(PureComponent);
+
+export default OnceButton;