shineout 1.12.2 → 1.12.3

package/esm/Rule/length.js

@@ -0,0 +1,54 @@
+import { deepMerge } from '../utils/objects';
+import { substitute } from '../utils/strings';
+import { getLocale } from '../locale';
+
+var createMessage = function createMessage(key) {
+  return function (props) {
+    var lt = '';
+
+    switch (props.type) {
+      case 'integer':
+      case 'number':
+        lt = 'number';
+        break;
+
+      case 'array':
+        lt = 'array';
+        break;
+
+      default:
+        lt = 'string';
+    }
+
+    return substitute(getLocale("rules.length." + key + "." + lt), props);
+  };
+};
+
+var options = {
+  skipUndefined: true
+};
+export var lengthMessage = {
+  max: createMessage('max'),
+  min: createMessage('min')
+};
+export default (function (key, _temp) {
+  var _ref = _temp === void 0 ? {} : _temp,
+      message = _ref.message;
+
+  return function (len, msg) {
+    var _deepMerge;
+
+    if (typeof len !== 'number') {
+      console.error(new Error("Rule \"" + key + "\" param expect a number, get " + typeof len));
+      return null;
+    }
+
+    return deepMerge({
+      message: lengthMessage[key]
+    }, deepMerge((_deepMerge = {
+      message: message
+    }, _deepMerge[key] = len, _deepMerge), {
+      message: msg
+    }, options), options);
+  };
+});

package/esm/Rule/regExp.d.ts

@@ -0,0 +1,5 @@
+import { MessageType } from './Props';
+declare const _default: ({ message }?: {
+    message?: MessageType | undefined;
+}) => (regExp: string | RegExp, msg?: MessageType | undefined) => import("../@types/common").ObjectType<any> | null;
+export default _default;

package/esm/Rule/regExp.js

@@ -0,0 +1,25 @@
+import { deepMerge } from '../utils/objects';
+import { getLocale } from '../locale';
+var options = {
+  skipUndefined: true
+};
+export default (function (_temp) {
+  var _ref = _temp === void 0 ? {} : _temp,
+      message = _ref.message;
+
+  return function (regExp, msg) {
+    if (typeof regExp !== 'string' && !(regExp instanceof RegExp)) {
+      console.error(new Error("Rule \"reg\" param expect a RegExp object or a string, get " + typeof regExp));
+      return null;
+    }
+
+    return deepMerge({
+      message: getLocale('rules.reg')
+    }, deepMerge({
+      message: message,
+      regExp: regExp
+    }, {
+      message: msg
+    }, options), options);
+  };
+});

package/esm/Rule/required.d.ts

@@ -0,0 +1,8 @@
+import { ObjectType } from '../@types/common';
+import { MessageType } from './Props';
+export declare const requiredMessage: (props: ObjectType) => any;
+declare const _default: ({ message, tip }?: {
+    message?: MessageType | undefined;
+    tip?: string | undefined;
+}) => (msg: MessageType) => ObjectType<any>;
+export default _default;

package/esm/Rule/required.js

@@ -0,0 +1,27 @@
+import { deepMerge } from '../utils/objects';
+import { substitute } from '../utils/strings';
+import { getLocale } from '../locale';
+var options = {
+  skipUndefined: true
+};
+export var requiredMessage = function requiredMessage(props) {
+  var type = props.type === 'array' ? 'array' : 'string';
+  return substitute(getLocale("rules.required." + type), props);
+};
+export default (function (_temp) {
+  var _ref = _temp === void 0 ? {} : _temp,
+      message = _ref.message,
+      tip = _ref.tip;
+
+  return function (msg) {
+    return deepMerge({
+      required: true,
+      message: requiredMessage
+    }, deepMerge({
+      message: message,
+      tip: tip
+    }, {
+      message: msg
+    }, options), options);
+  };
+});

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

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

package/esm/Rule/styles/index.js

@@ -0,0 +1 @@
+import '../../styles/normalize.less';

package/esm/Rule/type.d.ts

@@ -0,0 +1,8 @@
+import { ObjectType } from '../@types/common';
+import { MessageType } from './Props';
+export declare const typeMessage: (props: ObjectType) => any;
+declare const _default: (type: string, { message, tip }?: {
+    message?: MessageType | undefined;
+    tip?: string | undefined;
+}) => (msg: MessageType) => ObjectType<any>;
+export default _default;

package/esm/Rule/type.js

@@ -0,0 +1,27 @@
+import { deepMerge } from '../utils/objects';
+import { substitute } from '../utils/strings';
+import { getLocale } from '../locale';
+export var typeMessage = function typeMessage(props) {
+  var path = props.title ? 'rules.type' : 'rules.reg';
+  return substitute(getLocale(path), props);
+};
+var options = {
+  skipUndefined: true
+};
+export default (function (type, _temp) {
+  var _ref = _temp === void 0 ? {} : _temp,
+      message = _ref.message,
+      tip = _ref.tip;
+
+  return function (msg) {
+    return deepMerge({
+      type: type,
+      message: typeMessage
+    }, deepMerge({
+      message: message,
+      tip: tip
+    }, {
+      message: msg
+    }, options), options);
+  };
+});

package/esm/Scroll/Bar.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const _default: React.ComponentType<import("./Props").FixedLengthProps>;
+export default _default;

package/esm/Scroll/Bar.js

@@ -0,0 +1,183 @@
+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 classnames from 'classnames';
+import { scrollClass } from './styles';
+import fixedLength from './fixedLength';
+import { isRTL } from '../config';
+
+var ScrollBar =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(ScrollBar, _PureComponent);
+
+  function ScrollBar(props) {
+    var _this;
+
+    _this = _PureComponent.call(this, props) || this;
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "handle", void 0);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "cacheOffset", void 0);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "mouseX", void 0);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "mouseY", void 0);
+
+    _this.state = {
+      dragging: false
+    };
+    _this.bindHandle = _this.bindHandle.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleBarClick = _this.handleBarClick.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleBgClick = _this.handleBgClick.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleMouseMove = _this.handleMouseMove.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.unbindEvent = _this.unbindEvent.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
+  }
+
+  var _proto = ScrollBar.prototype;
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    this.unbindEvent();
+  };
+
+  _proto.toggleClassList = function toggleClassList(method) {
+    if (this.handle && this.handle.parentNode && this.handle.parentNode.parentNode) {
+      var classList = this.handle.parentNode.parentNode.classList;
+
+      if (classList) {
+        classList[method](scrollClass('dragging'));
+      }
+    }
+  };
+
+  _proto.bindHandle = function bindHandle(el) {
+    this.handle = el;
+  };
+
+  _proto.bindEvent = function bindEvent() {
+    document.addEventListener('mousemove', this.handleMouseMove);
+    document.addEventListener('mouseup', this.unbindEvent);
+  };
+
+  _proto.unbindEvent = function unbindEvent() {
+    this.setState({
+      dragging: false
+    });
+    this.toggleClassList('remove');
+    document.removeEventListener('mousemove', this.handleMouseMove);
+    document.removeEventListener('mouseup', this.unbindEvent);
+  };
+
+  _proto.handleBarClick = function handleBarClick(event) {
+    var offset = this.props.offset;
+    this.cacheOffset = offset;
+    this.setState({
+      dragging: true
+    });
+    this.mouseX = event.clientX;
+    this.mouseY = event.clientY;
+    this.toggleClassList('add');
+    this.bindEvent();
+  };
+
+  _proto.handleMouseMove = function handleMouseMove(event) {
+    var x = event.clientX - this.mouseX;
+    var y = event.clientY - this.mouseY;
+    this.mouseX = event.clientX;
+    this.mouseY = event.clientY;
+    var _this$props = this.props,
+        direction = _this$props.direction,
+        length = _this$props.length,
+        onScroll = _this$props.onScroll,
+        barLength = _this$props.barLength;
+    var value = direction === 'x' ? x : y;
+    var newOffset;
+
+    if (direction === 'x' && isRTL()) {
+      newOffset = this.cacheOffset - value / (length - barLength);
+    } else {
+      newOffset = this.cacheOffset + value / (length - barLength);
+    }
+
+    if (newOffset < 0) newOffset = 0;
+    if (newOffset > 1) newOffset = 1;
+    if (newOffset === this.cacheOffset) return;
+    this.cacheOffset = newOffset;
+    onScroll(newOffset);
+  };
+
+  _proto.handleBgClick = function handleBgClick(event) {
+    if (event.target === this.handle) return;
+    var _this$props2 = this.props,
+        direction = _this$props2.direction,
+        length = _this$props2.length,
+        scrollLength = _this$props2.scrollLength,
+        offset = _this$props2.offset,
+        onScroll = _this$props2.onScroll;
+    var rect = this.handle.getBoundingClientRect();
+    var newOffset = offset;
+    var page = length / (scrollLength - length);
+    var plus = isRTL() ? event.clientX < rect.left : event.clientX > rect.left;
+    var add = isRTL() ? event.clientX > rect.left : event.clientX < rect.left;
+
+    if (direction === 'x' && add || direction === 'y' && event.clientY < rect.top) {
+      newOffset = offset - page;
+      if (newOffset < 0) newOffset = 0;
+    } else if (direction === 'x' && plus || direction === 'y' && event.clientY > rect.top) {
+      newOffset = offset + page;
+      if (newOffset > 1) newOffset = 1;
+    }
+
+    onScroll(newOffset);
+  };
+
+  _proto.render = function render() {
+    var _this$props3 = this.props,
+        direction = _this$props3.direction,
+        length = _this$props3.length,
+        scrollLength = _this$props3.scrollLength,
+        offset = _this$props3.offset,
+        barLength = _this$props3.barLength,
+        forceHeight = _this$props3.forceHeight;
+    var dragging = this.state.dragging;
+    var show = scrollLength > length;
+    var rtl = isRTL();
+    var className = classnames(scrollClass('bar', direction, show && 'show', dragging && 'dragging', !forceHeight && 'padding-y'), this.props.className);
+    var value = (length - barLength) * offset;
+    var x = rtl ? 'right' : 'left';
+    var style = {};
+
+    if (scrollLength > 0) {
+      if (direction === 'x') {
+        style.width = length / scrollLength * 100 + "%";
+        style[x] = value;
+      } else {
+        style.height = length / scrollLength * 100 + "%";
+        style.top = value;
+      }
+    }
+
+    return React.createElement("div", {
+      className: className,
+      style: {
+        height: forceHeight
+      },
+      onMouseDown: show ? this.handleBgClick : undefined
+    }, React.createElement("div", {
+      className: scrollClass('handle'),
+      onMouseDown: this.handleBarClick,
+      ref: this.bindHandle,
+      style: style
+    }));
+  };
+
+  return ScrollBar;
+}(PureComponent);
+
+_defineProperty(ScrollBar, "defaultProps", {
+  direction: 'y'
+});
+
+export default fixedLength(ScrollBar);

package/esm/Scroll/Props.d.ts

@@ -0,0 +1,44 @@
+/** ------ context ------ */
+import { CSSProperties, ReactNode } from 'react';
+export interface ScrollContextProviderValue {
+    element?: HTMLElement;
+    left?: number;
+    top?: number;
+}
+export declare type ScrollFixedType = 'x' | 'y' | 'both';
+export declare type GetScrollContextConsumerValue<U> = Omit<U, 'scrollElement' | 'scrollLeft' | 'scrollTop'>;
+/** ------ scroll ------ */
+export interface ScrollProps {
+    left: number;
+    top: number;
+    scrollHeight?: number;
+    scrollWidth?: number;
+    scrollX: boolean;
+    scrollY: boolean;
+    onScroll: (x: number, y: number, maxX: number, inner: HTMLElement, rectWidth: number, rectHeight: number, pixelX?: number, pixelY?: number, drag?: boolean) => void;
+    stable?: boolean;
+    footer?: ReactNode;
+    innerScrollAttr?: string[];
+    className?: string;
+    style?: CSSProperties;
+}
+/** ------ bar ------ */
+export interface BarProps {
+    className?: string;
+    direction?: 'x' | 'y';
+    forceHeight?: number;
+    length: number;
+    barLength: number;
+    offset: number;
+    onScroll: (offset: number) => void;
+    scrollLength: number;
+}
+/** ------ fixedLength ------ */
+export interface FixedLengthProps extends Omit<BarProps, 'barLength'> {
+}
+/** ------ index ------ */
+export interface ScrollIndexProps extends Omit<ScrollProps, 'left' | 'top' | 'scrollX' | 'scrollY'> {
+    scrollLeft?: number;
+    scrollTop?: number;
+    scroll?: ScrollFixedType;
+}

package/esm/Scroll/Props.js

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

package/esm/Scroll/Scroll.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="react" />
+import { PureComponent } from '../component';
+import { ScrollProps } from './Props';
+export declare const BAR_WIDTH = 16;
+declare class Scroll extends PureComponent<ScrollProps> {
+    static defaultProps: {
+        scrollHeight: number;
+        scrollWidth: number;
+        innerScrollAttr: never[];
+    };
+    baseScrollRatio: number;
+    touchStartX: number;
+    touchStartY: number;
+    wheelX: boolean;
+    wheelY: boolean;
+    pixelX: number;
+    pixelY: number;
+    cacheWidth: number;
+    cacheHeight: number;
+    wheelElement: HTMLElement;
+    inner: HTMLElement;
+    footerElement: HTMLElement;
+    rmOverScrollListener: () => void;
+    constructor(props: ScrollProps);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: ScrollProps): void;
+    componentWillUnmount(): void;
+    getWheelRect(): {
+        width: number;
+        height: number;
+    };
+    setRect(): void;
+    setBaseScrollHeightRatio(height: number): void;
+    setStartPoint(position: {
+        clientX: number;
+        clientY: number;
+    }): void;
+    bindInner(el: HTMLDivElement): void;
+    bindIframe(el: HTMLIFrameElement): void;
+    bindWheel(el: HTMLDivElement): void;
+    bindFooter(el: HTMLDivElement): void;
+    boundleScroll(): void;
+    handleWheel(event: WheelEvent): void;
+    handleScroll(x: number, y: number, pixelX?: number, pixelY?: number, { drag }?: {
+        drag?: boolean;
+    }): void;
+    handleScrollX(left: number): void;
+    handleScrollY(top: number): void;
+    handleTouchStart(e: TouchEvent): void;
+    handleTouchMove(e: TouchEvent): void;
+    handleInnerScroll(e: MouseEvent): void;
+    render(): JSX.Element;
+}
+export default Scroll;