shineout 1.12.2 → 1.12.3

package/esm/config.d.ts

@@ -0,0 +1,21 @@
+import Notification from './utils/notification';
+import { LanType, Direction } from './locale/Props';
+import { CartType } from './icons/Props';
+export declare const noti: Notification;
+interface ConfigOption {
+    cssModule: boolean;
+    prefix: string;
+    locale: LanType;
+    autoSSL: boolean;
+    delay?: number;
+    scrollRatio: number;
+    trim?: boolean;
+    spin?: string;
+    caret?: CartType;
+    direction: Direction;
+}
+declare const config: ConfigOption;
+export default config;
+export declare function set<Key extends keyof ConfigOption>(name: Key, value: ConfigOption[Key]): void;
+export declare function setConfig(conf: Partial<ConfigOption>): void;
+export declare function isRTL(): boolean;

package/esm/config.js

@@ -0,0 +1,42 @@
+import { entries } from './utils/objects';
+import Notification from './utils/notification';
+export var noti = new Notification();
+var config = {
+  cssModule: !!process.env.CSS_MODULE || false,
+  prefix: process.env.SO_PREFIX || 'so',
+  locale: process.env.LOCALE || 'en-US',
+  autoSSL: false,
+  delay: undefined,
+  scrollRatio: 100,
+  trim: undefined,
+  spin: undefined,
+  caret: undefined,
+  direction: 'ltr'
+};
+export default config;
+export function set(name, value) {
+  if (value !== undefined && name in config) config[name] = value;
+  noti.dispatch(name);
+}
+export function setConfig(conf) {
+  for (var _iterator = entries(conf), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    var _ref2 = _ref,
+        key = _ref2[0],
+        value = _ref2[1];
+    set(key, value);
+  }
+}
+export function isRTL() {
+  return config.direction === 'rtl';
+}

package/esm/context/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const _default: typeof React.createContext;
+export default _default;

package/esm/context/index.js

@@ -0,0 +1,4 @@
+// copy from https://github.com/jamiebuilds/create-react-context
+// Solve the version conflict between create-react-context and react17
+import React from 'react';
+export default React.createContext;

package/esm/hoc/Props.d.ts

@@ -0,0 +1,96 @@
+import React, { ReactNode } from 'react';
+import { ForceAdd, PartialKeys, RegularAttributes } from '../@types/common';
+import { PopoverProps } from '../Popover/Props';
+import { PaginationProps } from '../Pagination/Props';
+import { PopoverPosition } from '../Popover/Props';
+export declare type MovableType<U> = U & {
+    moveable?: boolean;
+};
+export declare type ResizableType<Props> = Props & {
+    resizable?: boolean | string;
+};
+export declare type ConfigType<Props> = Props;
+/** ------ inputBorder ------ * */
+export interface InputBorderProps {
+    className?: string;
+    style?: React.CSSProperties;
+    /**
+     * Prompt information
+     *
+     * 提示信息
+     *
+     * default: none
+     */
+    tip?: ReactNode;
+    /**
+     * The position where the text pop up
+     *
+     * 信息弹出位置
+     *
+     * default: none
+     */
+    popover?: PopoverPosition;
+    width?: string | number;
+    error?: Error;
+    /**
+     * Vilidate popup properties, specific properties refer to Popover component description
+     *
+     * 校验弹框接受的属性，具体属性参考Popover组件说明
+     *
+     * default: none
+     */
+    popoverProps?: PopoverProps;
+    underline?: boolean;
+    autoFocus?: boolean;
+    border?: boolean;
+    disabled?: boolean | (() => boolean);
+    onBlur?: React.FocusEventHandler;
+    onFocus?: React.FocusEventHandler;
+    size?: RegularAttributes.Size;
+}
+export declare type GetInputBorderProps<Props extends {
+    onFocus?: any;
+    onBlur?: any;
+}> = ForceAdd<Omit<PartialKeys<Props, 'onFocus' | 'onBlur'>, 'inputFocus'>, InputBorderProps>;
+/** ------ delay ------ * */
+export interface DelayProps {
+    /**
+     * User input triggers the onChange and to check interval, unit: ms.
+     *
+     * 用户输入触发 onChange 和校验间隔时间，单位 毫秒。
+     *
+     * default: 400
+     */
+    delay?: number;
+    value?: any;
+    onChange: (...args: any) => void;
+}
+export declare type GetDelayProps<Props> = ForceAdd<Omit<Props, 'forceChange' | 'cancelChange'>, DelayProps>;
+/** ------ coin ------ * */
+export interface CoinProps {
+    value?: number | string | null;
+    onChange?: any;
+    type?: string;
+    onFocus?: (e: any) => void;
+    onBlur?: (e: any) => void;
+    onMouseDown?: React.MouseEventHandler;
+    onMouseUp?: React.MouseEventHandler;
+    /**
+     * Show as thousands separator, valid only when type is 'number'
+     *
+     * 以千位分隔符展示,仅当type为number时有效
+     *
+     * default: false
+     */
+    coin?: boolean;
+}
+export declare type GetCoinProps<Props extends {
+    onFocus?: any;
+    onBlur?: any;
+}> = ForceAdd<PartialKeys<Props, 'onFocus' | 'onBlur'>, CoinProps>;
+/** ------ hidable ------ * */
+export declare type GetHidableConsumerProps<Props> = Props;
+/** ------ pagable ------ * */
+export declare type GetPagableProps<Props> = Props & {
+    pagination?: PaginationProps;
+};

package/esm/hoc/Props.js

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

package/esm/hoc/coin.d.ts

@@ -0,0 +1,5 @@
+import React, { ComponentType } from 'react';
+import { GetCoinProps } from './Props';
+declare type CoinTypeType = 'input' | undefined;
+declare const _default: <Props extends {}>(coinType?: CoinTypeType) => (Origin: React.ComponentType<Props>) => React.ComponentType<GetCoinProps<Props>>;
+export default _default;

package/esm/hoc/coin.js

@@ -0,0 +1,122 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React, { PureComponent } from 'react';
+export default (function (coinType) {
+  return function (Origin) {
+    var _class, _temp;
+
+    return _temp = _class =
+    /*#__PURE__*/
+    function (_PureComponent) {
+      _inheritsLoose(Coin, _PureComponent);
+
+      function Coin(props) {
+        var _this;
+
+        _this = _PureComponent.call(this, props) || this;
+
+        _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "isFocus", void 0);
+
+        _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "mouseDown", void 0);
+
+        _this.state = {
+          showCoin: props.coin
+        };
+        _this.handleFocus = _this.handleFocus.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+        _this.handleBlur = _this.handleBlur.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+        _this.handleMouseDown = _this.handleMouseDown.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+        _this.handleMouseUp = _this.handleMouseUp.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+        return _this;
+      }
+
+      var _proto = Coin.prototype;
+
+      _proto.getValue = function getValue() {
+        var showCoin = this.state.showCoin;
+        var value = this.props.value;
+
+        if (showCoin && (value || value === 0)) {
+          return ("" + value).replace(/\d+/, function (n) {
+            return n.replace(/(\d)(?=(\d{3})+$)/g, function ($1) {
+              return $1 + ",";
+            });
+          });
+        }
+
+        if (value === 0) return 0;
+        return ("" + (value || '')).replace(/,/g, '');
+      };
+
+      _proto.handleFocus = function handleFocus(e) {
+        var onFocus = this.props.onFocus;
+        this.isFocus = true;
+        this.setState({
+          showCoin: false
+        });
+        if (onFocus) onFocus(e);
+      };
+
+      _proto.handleBlur = function handleBlur(e) {
+        var onBlur = this.props.onBlur;
+        this.isFocus = false;
+        this.setState({
+          showCoin: true
+        });
+        if (onBlur) onBlur(e);
+      };
+
+      _proto.handleMouseDown = function handleMouseDown(e) {
+        var onMouseDown = this.props.onMouseDown;
+        this.mouseDown = true;
+        this.setState({
+          showCoin: false
+        });
+        if (onMouseDown) onMouseDown(e);
+      };
+
+      _proto.handleMouseUp = function handleMouseUp(e) {
+        var onMouseUp = this.props.onMouseUp;
+
+        if (this.mouseDown && !this.isFocus) {
+          this.setState({
+            showCoin: true
+          });
+        }
+
+        this.mouseDown = false;
+        if (onMouseUp) onMouseUp(e);
+      };
+
+      _proto.render = function render() {
+        var _this$props = this.props,
+            coin = _this$props.coin,
+            value = _this$props.value,
+            onFocus = _this$props.onFocus,
+            onBlur = _this$props.onBlur,
+            others = _objectWithoutPropertiesLoose(_this$props, ["coin", "value", "onFocus", "onBlur"]);
+
+        if (!coin) return React.createElement(Origin, _extends({}, this.props, {
+          coin: undefined
+        }));
+        if (coinType === 'input' && this.props.type !== 'number') return React.createElement(Origin, _extends({}, this.props, {
+          coin: undefined
+        }));
+        return React.createElement(Origin, _extends({}, others, {
+          onMouseDown: this.handleMouseDown,
+          onMouseUp: this.handleMouseUp,
+          value: this.getValue(),
+          onFocus: this.handleFocus,
+          onBlur: this.handleBlur,
+          coin: true
+        }));
+      };
+
+      return Coin;
+    }(PureComponent), _defineProperty(_class, "defaultProps", {
+      coin: false
+    }), _temp;
+  };
+});

package/esm/hoc/config.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+declare const _default: <U extends unknown>(Com: React.ComponentType<U>, name: string) => {
+    new (props: U): {
+        handleUpdate: () => void;
+        componentWillUnmount(): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<U> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<any>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<U>, nextState: Readonly<any>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<U>, prevState: Readonly<any>): any;
+        componentDidUpdate?(prevProps: Readonly<U>, prevState: Readonly<any>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<U>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<U>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<U>, nextState: Readonly<any>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<U>, nextState: Readonly<any>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;

package/esm/hoc/config.js

@@ -0,0 +1,38 @@
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React from 'react';
+import { noti } from '../config';
+export default (function (Com, name) {
+  var _temp;
+
+  return _temp =
+  /*#__PURE__*/
+  function (_React$Component) {
+    _inheritsLoose(_temp, _React$Component);
+
+    function _temp(props) {
+      var _this;
+
+      _this = _React$Component.call(this, props) || this;
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "handleUpdate", void 0);
+
+      _this.handleUpdate = _this.forceUpdate.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      noti.subscribe(name, _this.handleUpdate);
+      return _this;
+    }
+
+    var _proto = _temp.prototype;
+
+    _proto.componentWillUnmount = function componentWillUnmount() {
+      noti.unsubscribe(name, this.handleUpdate);
+    };
+
+    _proto.render = function render() {
+      return React.createElement(Com, this.props);
+    };
+
+    return _temp;
+  }(React.Component), _temp;
+});

package/esm/hoc/delay.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/esm/hoc/delay.js

@@ -0,0 +1,118 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React, { PureComponent } from 'react';
+import config from '../config';
+import { curry } from '../utils/func';
+export default curry(function (defaultDelay, Origin) {
+  var _temp;
+
+  return _temp =
+  /*#__PURE__*/
+  function (_PureComponent) {
+    _inheritsLoose(_temp, _PureComponent);
+
+    function _temp(props) {
+      var _this;
+
+      _this = _PureComponent.call(this, props) || this;
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "changeLocked", void 0);
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "changeTimer", void 0);
+
+      _this.state = {
+        value: props.value
+      };
+      _this.handleChange = _this.handleChange.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      _this.forceChange = _this.forceChange.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      _this.cancelChange = _this.cancelChange.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      return _this;
+    }
+
+    var _proto = _temp.prototype;
+
+    _proto.getValue = function getValue() {
+      if (this.changeLocked) return this.state.value;
+      return this.props.value;
+    };
+
+    _proto.getDelay = function getDelay() {
+      var delay = this.props.delay;
+      if (delay !== undefined) return delay;
+      if (config.delay !== undefined) return config.delay;
+      return defaultDelay;
+    };
+
+    _proto.handleChange = function handleChange(value) {
+      var _this2 = this;
+
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+
+      var delay = this.getDelay();
+
+      if (delay === 0) {
+        var _this$props;
+
+        (_this$props = this.props).onChange.apply(_this$props, [value].concat(args));
+
+        return;
+      }
+
+      this.setState({
+        value: value
+      });
+      this.changeLocked = true;
+      this.forceUpdate();
+      if (this.changeTimer) clearTimeout(this.changeTimer);
+      this.changeTimer = setTimeout(function () {
+        var _this2$props;
+
+        _this2.changeLocked = false;
+
+        (_this2$props = _this2.props).onChange.apply(_this2$props, [value].concat(args));
+      }, delay);
+    };
+
+    _proto.cancelChange = function cancelChange() {
+      if (this.changeTimer) clearTimeout(this.changeTimer);
+    };
+
+    _proto.forceChange = function forceChange(value) {
+      var _this$props2;
+
+      this.cancelChange();
+      this.setState({
+        value: value
+      });
+
+      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        args[_key2 - 1] = arguments[_key2];
+      }
+
+      (_this$props2 = this.props).onChange.apply(_this$props2, [value].concat(args));
+
+      this.changeLocked = false;
+    };
+
+    _proto.render = function render() {
+      var _this$props3 = this.props,
+          value = _this$props3.value,
+          onChange = _this$props3.onChange,
+          props = _objectWithoutPropertiesLoose(_this$props3, ["value", "onChange"]);
+
+      return React.createElement(Origin, _extends({}, props, {
+        value: this.getValue(),
+        onChange: this.handleChange,
+        forceChange: this.forceChange,
+        cancelChange: this.cancelChange
+      }));
+    };
+
+    return _temp;
+  }(PureComponent), _temp;
+});

package/esm/hoc/draggable.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/esm/hoc/draggable.js

@@ -0,0 +1,105 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React, { PureComponent } from 'react';
+import { curry } from '../utils/func';
+var defaultProps = {
+  client: undefined,
+  onDragStart: function onDragStart() {},
+  onDrag: function onDrag() {},
+  onDragEnd: function onDragEnd() {}
+};
+export default curry(function (OriginComponent) {
+  var Drag =
+  /*#__PURE__*/
+  function (_PureComponent) {
+    _inheritsLoose(Drag, _PureComponent);
+
+    function Drag(props) {
+      var _this;
+
+      _this = _PureComponent.call(this, props) || this;
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "clientX", void 0);
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "clientY", void 0);
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "dragging", void 0);
+
+      _this.handleDragStart = _this.handleDragStart.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      _this.handleDrag = _this.handleDrag.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      _this.handleDragEnd = _this.handleDragEnd.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      return _this;
+    }
+
+    var _proto = Drag.prototype;
+
+    _proto.componentDidMount = function componentDidMount() {
+      var client = this.props.client;
+
+      if (client) {
+        this.clientX = client.x;
+        this.clientY = client.y;
+        this.dragging = true;
+        this.addEvents();
+        if (this.props.onDragStart) this.props.onDragStart();
+      }
+    };
+
+    _proto.componentWillUnmount = function componentWillUnmount() {
+      this.removeEvents();
+    };
+
+    _proto.addEvents = function addEvents() {
+      document.addEventListener('mousemove', this.handleDrag);
+      document.addEventListener('mouseup', this.handleDragEnd);
+      document.addEventListener('mouseleave', this.handleDragEnd);
+    };
+
+    _proto.removeEvents = function removeEvents() {
+      document.removeEventListener('mousemove', this.handleDrag);
+      document.removeEventListener('mouseup', this.handleDragEnd);
+      document.removeEventListener('mouseleave', this.handleDragEnd);
+    };
+
+    _proto.handleDragStart = function handleDragStart(e) {
+      if (e.button !== 0) return;
+      this.clientX = e.clientX;
+      this.clientY = e.clientY;
+      this.dragging = true;
+      this.addEvents();
+      if (this.props.onDragStart) this.props.onDragStart();
+    };
+
+    _proto.handleDrag = function handleDrag(e) {
+      if (!this.dragging) return;
+      if (e.clientX === 0 && e.clientY === 0) return;
+      var mx = e.clientX - this.clientX;
+      var my = e.clientY - this.clientY;
+      if (mx === 0 && my === 0) return;
+      this.clientX = e.clientX;
+      this.clientY = e.clientY;
+      if (this.props.onDrag) this.props.onDrag(mx, my, e.clientX, e.clientY);
+    };
+
+    _proto.handleDragEnd = function handleDragEnd() {
+      if (!this.dragging) return;
+      this.dragging = false;
+      this.removeEvents();
+      if (this.props.onDragEnd) this.props.onDragEnd();
+    };
+
+    _proto.render = function render() {
+      return React.createElement(OriginComponent, _extends({}, this.props, {
+        onDragStart: this.handleDragStart
+      }));
+    };
+
+    return Drag;
+  }(PureComponent);
+
+  _defineProperty(Drag, "defaultProps", defaultProps);
+
+  return Drag;
+});

package/esm/hoc/hidable.d.ts

@@ -0,0 +1,20 @@
+import React, { ComponentType } from 'react';
+import { GetHidableConsumerProps } from './Props';
+import { ListAnimationType } from '../AnimationList/Props';
+export declare const consumer: <U extends {}>(Origin: React.ComponentType<U>) => React.FC<U>;
+interface HideableProps {
+    show?: boolean;
+    className?: string;
+}
+interface HidableConfig {
+    type: ListAnimationType[];
+    duration: number;
+    display?: string;
+}
+/**
+ * @param {*} Component
+ * @param {*} duration
+ * @param {*} type - fade, collapse, tranlate
+ */
+export default function <U extends HideableProps>(Component: React.ComponentType<U>, { type, duration, display }: HidableConfig): React.ComponentType<U>;
+export {};