shineout 1.12.2 → 1.12.3

package/esm/TreeSelect/tiled.js

@@ -0,0 +1,151 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectSpread from "@babel/runtime/helpers/objectSpread";
+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 immer from 'immer';
+import Datum from '../Datum/Tree';
+import { curry } from '../utils/func';
+import { mergeFilteredTree } from '../utils/tree';
+import { treeClass } from '../Tree/styles';
+import { treeSelectClass } from './styles';
+import { Component } from '../component';
+var DefaultProps = {
+  childrenKey: 'children'
+};
+export default curry(function (options, Origin) {
+  var _options$dataKey = options.dataKey,
+      dataKey = _options$dataKey === void 0 ? 'data' : _options$dataKey;
+
+  var Tiled =
+  /*#__PURE__*/
+  function (_Component) {
+    _inheritsLoose(Tiled, _Component);
+
+    function Tiled(props) {
+      var _this;
+
+      _this = _Component.call(this, props) || this;
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "rawDatum", void 0);
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "filteredDatum", void 0);
+
+      _this.state = {
+        tileds: []
+      };
+      _this.getIcon = _this.getIcon.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      _this.handleFilter = _this.handleFilter.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      if (props.onAdvancedFilter) _this.genRawDatum();
+      return _this;
+    }
+
+    var _proto = Tiled.prototype;
+
+    _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
+      if (prevProps.rawData !== this.props.rawData && this.props.onAdvancedFilter) {
+        if (this.rawDatum) this.rawDatum.setData(this.props.rawData);else this.genRawDatum();
+        this.forceUpdate();
+      }
+    };
+
+    _proto.getFilteredDatum = function getFilteredDatum() {
+      var _this$props = this.props,
+          keygen = _this$props.keygen,
+          childrenKey = _this$props.childrenKey;
+      var data = this.props[dataKey];
+      if (this.filteredDatum && this.filteredDatum.data === data) return this.filteredDatum;
+      this.filteredDatum = new Datum({
+        data: data,
+        keygen: keygen,
+        childrenKey: childrenKey || DefaultProps.childrenKey
+      });
+      return this.filteredDatum;
+    };
+
+    _proto.getIcon = function getIcon(data) {
+      var _this$props2 = this.props,
+          childrenKey = _this$props2.childrenKey,
+          _this$props2$expanded = _this$props2.expanded,
+          expanded = _this$props2$expanded === void 0 ? [] : _this$props2$expanded;
+      var originIcon = React.createElement("span", {
+        className: treeClass('default-icon')
+      });
+      var key = this.rawDatum.getKey(data);
+      var rawData = this.rawDatum.getDataById(key);
+      if (!data || !rawData) return originIcon;
+      var sameCount = data[childrenKey] && rawData[childrenKey] && data[childrenKey].length === rawData[childrenKey].length;
+      if (expanded.indexOf(key) === -1) return originIcon;
+      return React.createElement("span", {
+        className: treeSelectClass('match', sameCount && 'full'),
+        onClick: this.handleToggle.bind(this, key)
+      }, React.createElement("span", null));
+    };
+
+    _proto.handleFilter = function handleFilter(text, from) {
+      var onFilter = this.props.onFilter;
+      if (!text) this.setState({
+        tileds: []
+      });
+      if (onFilter) onFilter(text, from);
+    };
+
+    _proto.handleToggle = function handleToggle(key, e) {
+      e.stopPropagation();
+      this.setState(immer(function (draft) {
+        var index = draft.tileds.indexOf(key);
+        if (index >= 0) draft.tileds.splice(index, 1);else draft.tileds.push(key);
+      }));
+    };
+
+    _proto.genRawDatum = function genRawDatum() {
+      var _this$props3 = this.props,
+          rawData = _this$props3.rawData,
+          _this$props3$children = _this$props3.childrenKey,
+          childrenKey = _this$props3$children === void 0 ? DefaultProps.childrenKey : _this$props3$children,
+          keygen = _this$props3.keygen;
+      this.rawDatum = new Datum({
+        data: rawData,
+        childrenKey: childrenKey,
+        keygen: keygen
+      });
+    };
+
+    _proto.render = function render() {
+      var _objectSpread2;
+
+      var _this$props4 = this.props,
+          filterText = _this$props4.filterText,
+          onAdvancedFilter = _this$props4.onAdvancedFilter;
+      var tileds = this.state.tileds;
+      if (!filterText || !onAdvancedFilter) return React.createElement(Origin, this.props);
+      var expandIcons = [this.getIcon, this.getIcon];
+      var filterDatum = this.getFilteredDatum();
+      var data = mergeFilteredTree(filterDatum, this.rawDatum, tileds);
+
+      var props = _objectSpread({}, this.props, (_objectSpread2 = {
+        onFilter: this.handleFilter,
+        expandIcons: expandIcons
+      }, _objectSpread2[dataKey] = data, _objectSpread2));
+
+      return React.createElement(Origin, props);
+    };
+
+    return Tiled;
+  }(Component);
+
+  _defineProperty(Tiled, "defaultProps", DefaultProps);
+
+  return Tiled;
+});
+export var advancedFilterHOC = function advancedFilterHOC(Origin) {
+  return function (props) {
+    var onAdvancedFilter = props.onAdvancedFilter,
+        onFilter = props.onFilter;
+    return React.createElement(Origin, _extends({}, props, {
+      onFilter: onAdvancedFilter || onFilter,
+      onAdvancedFilter: !!onAdvancedFilter
+    }));
+  };
+};

package/esm/Upload/Dragger.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { PureComponent } from '../component';
+import { DraggerProps } from './Props';
+declare class Dragger extends PureComponent<DraggerProps> {
+    constructor(props: DraggerProps);
+    getMatchedFile(files?: never[]): any;
+    handleDrop(files: File[]): void;
+    render(): JSX.Element;
+}
+export default Dragger;

package/esm/Upload/Dragger.js

@@ -0,0 +1,66 @@
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+// obsolete code
+import React from 'react';
+import { PureComponent } from '../component';
+import { uploadClass } from './styles';
+import Drop from './Drop';
+import { accept as attrAccept } from '../utils';
+
+var Dragger =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(Dragger, _PureComponent);
+
+  function Dragger(props) {
+    var _this;
+
+    _this = _PureComponent.call(this, props) || this;
+    _this.handleDrop = _this.handleDrop.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
+  }
+
+  var _proto = Dragger.prototype;
+
+  _proto.getMatchedFile = function getMatchedFile(files) {
+    if (files === void 0) {
+      files = [];
+    }
+
+    var accept = this.props.accept;
+    return Array.prototype.slice.call(files).filter(function (file) {
+      return attrAccept(file, accept);
+    });
+  };
+
+  _proto.handleDrop = function handleDrop(files) {
+    var addFile = this.props.addFile;
+    addFile({
+      files: files,
+      fromDragger: true
+    });
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        children = _this$props.children,
+        disabled = _this$props.disabled,
+        multiple = _this$props.multiple,
+        limit = _this$props.limit,
+        accept = _this$props.accept;
+    return React.createElement(Drop, {
+      className: uploadClass('dragger-wrapper'),
+      drop: true,
+      disabled: disabled,
+      multiple: multiple || limit > 1,
+      accept: accept,
+      onDrop: this.handleDrop
+    }, React.createElement("div", {
+      className: uploadClass('dragger-area', disabled && 'disabled')
+    }, children));
+  };
+
+  return Dragger;
+}(PureComponent);
+
+export default Dragger;

package/esm/Upload/Drop.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import PropType from 'prop-types';
+import { DropProps } from './Props';
+interface DropState {
+    drop: boolean;
+}
+export default class Drop<ValueItem> extends React.Component<DropProps<ValueItem>, DropState> {
+    static propTypes: {
+        disabled: PropType.Requireable<boolean>;
+        accept: PropType.Requireable<string>;
+        multiple: PropType.Requireable<boolean>;
+        onDrop: PropType.Requireable<(...args: any[]) => any>;
+        dropData: PropType.Requireable<any>;
+        children: PropType.Requireable<any>;
+        drop: PropType.Requireable<boolean>;
+        className: PropType.Requireable<string>;
+    };
+    static defaultProps: {
+        drop: boolean;
+    };
+    constructor(props: DropProps<ValueItem>);
+    handleFileDrop(e: React.DragEvent): void;
+    handleDrag(e: React.DragEvent): void;
+    render(): React.ReactNode;
+}
+export {};

package/esm/Upload/Drop.js

@@ -0,0 +1,86 @@
+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 PropType from 'prop-types';
+import classnames from 'classnames';
+import { uploadClass } from './styles';
+import { accept as fileAccept } from '../utils';
+
+var Drop =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Drop, _React$Component);
+
+  function Drop(props) {
+    var _this;
+
+    _this = _React$Component.call(this, props) || this;
+    _this.state = {
+      drop: false
+    };
+    _this.handleDrag = _this.handleDrag.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleFileDrop = _this.handleFileDrop.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
+  }
+
+  var _proto = Drop.prototype;
+
+  _proto.handleFileDrop = function handleFileDrop(e) {
+    var files = e.dataTransfer.files;
+    var _this$props = this.props,
+        accept = _this$props.accept,
+        multiple = _this$props.multiple,
+        onDrop = _this$props.onDrop,
+        dropData = _this$props.dropData;
+    var filter = accept ? Array.prototype.filter.call(files, function (f) {
+      return fileAccept(f, accept);
+    }) : files;
+    if (!filter || filter.length === 0) return;
+    if (onDrop) onDrop(multiple ? filter : [filter[0]], dropData);
+  };
+
+  _proto.handleDrag = function handleDrag(e) {
+    var disabled = this.props.disabled;
+    if (disabled) return;
+    e.preventDefault();
+    e.stopPropagation();
+    this.setState({
+      drop: e.type === 'dragover'
+    });
+    if (e.type === 'drop') this.handleFileDrop(e);
+  };
+
+  _proto.render = function render() {
+    var drop = this.state.drop;
+    var _this$props2 = this.props,
+        children = _this$props2.children,
+        className = _this$props2.className;
+    if (!this.props.drop) return children;
+    return React.createElement("span", {
+      className: classnames(className, uploadClass(drop && 'drop')),
+      onDragOver: this.handleDrag,
+      onDragLeave: this.handleDrag,
+      onDrop: this.handleDrag
+    }, children);
+  };
+
+  return Drop;
+}(React.Component);
+
+_defineProperty(Drop, "propTypes", {
+  disabled: PropType.bool,
+  accept: PropType.string,
+  multiple: PropType.bool,
+  onDrop: PropType.func,
+  dropData: PropType.any,
+  children: PropType.any,
+  drop: PropType.bool,
+  className: PropType.string
+});
+
+_defineProperty(Drop, "defaultProps", {
+  drop: false
+});
+
+export { Drop as default };

package/esm/Upload/File.d.ts

@@ -0,0 +1,8 @@
+import { PureComponent } from 'react';
+import { FileProps } from './Props';
+declare class File extends PureComponent<FileProps> {
+    constructor(props: FileProps);
+    handleRemove(): void;
+    render(): JSX.Element;
+}
+export default File;

package/esm/Upload/File.js

@@ -0,0 +1,64 @@
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import React, { PureComponent } from 'react';
+import { uploadClass } from './styles';
+import Progress from '../Progress';
+import Spin from '../Spin';
+import icons from '../icons';
+import { ERROR, UPLOADING } from './request';
+import { getDirectionClass } from '../utils/classname';
+var SPIN = React.createElement("span", {
+  style: {
+    display: 'inline-block',
+    marginRight: 8
+  }
+}, React.createElement(Spin, {
+  size: 10,
+  name: "ring"
+}));
+
+var File =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(File, _PureComponent);
+
+  function File(props) {
+    var _this;
+
+    _this = _PureComponent.call(this, props) || this;
+    _this.handleRemove = _this.handleRemove.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
+  }
+
+  var _proto = File.prototype;
+
+  _proto.handleRemove = function handleRemove() {
+    this.props.onRemove(this.props.id);
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        message = _this$props.message,
+        name = _this$props.name,
+        status = _this$props.status,
+        process = _this$props.process;
+    var className = uploadClass('view-file', status === ERROR && 'error');
+    return React.createElement("div", {
+      className: className
+    }, React.createElement("div", {
+      className: uploadClass(getDirectionClass('text'))
+    }, status === UPLOADING && SPIN, " ", name, " ", message && React.createElement("span", null, "(", message, ") ")), React.createElement("a", {
+      className: uploadClass('delete'),
+      onClick: this.handleRemove
+    }, icons.Close), status !== ERROR && React.createElement(Progress, {
+      className: uploadClass('progress'),
+      background: process >= 0 ? '#e9ecef' : 'transparent',
+      value: process,
+      strokeWidth: 2
+    }));
+  };
+
+  return File;
+}(PureComponent);
+
+export default File;

package/esm/Upload/FileInput.d.ts

@@ -0,0 +1,11 @@
+import { PureComponent } from 'react';
+import { FileInputProps } from './Props';
+declare class FileInput extends PureComponent<FileInputProps> {
+    locked: boolean;
+    input: HTMLInputElement;
+    constructor(props: FileInputProps);
+    bindElement(el: HTMLInputElement): void;
+    click(): void;
+    render(): JSX.Element;
+}
+export default FileInput;

package/esm/Upload/FileInput.js

@@ -0,0 +1,69 @@
+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';
+var inputStyle = {
+  display: 'none'
+};
+
+var FileInput =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(FileInput, _PureComponent);
+
+  function FileInput(props) {
+    var _this;
+
+    _this = _PureComponent.call(this, props) || this;
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "locked", void 0);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "input", void 0);
+
+    _this.locked = false;
+    _this.bindElement = _this.bindElement.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
+  }
+
+  var _proto = FileInput.prototype;
+
+  _proto.bindElement = function bindElement(el) {
+    this.input = el;
+  };
+
+  _proto.click = function click() {
+    var _this2 = this;
+
+    if (this.locked) return;
+    this.locked = true;
+    this.input.value = '';
+    this.input.click();
+    setTimeout(function () {
+      _this2.locked = false;
+    }, 1000);
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        accept = _this$props.accept,
+        onChange = _this$props.onChange,
+        multiple = _this$props.multiple,
+        webkitdirectory = _this$props.webkitdirectory;
+    var OriginProps = {
+      webkitdirectory: webkitdirectory
+    };
+    return React.createElement("input", _extends({
+      ref: this.bindElement,
+      accept: accept,
+      multiple: multiple,
+      onChange: onChange,
+      style: inputStyle,
+      type: "file"
+    }, OriginProps));
+  };
+
+  return FileInput;
+}(PureComponent);
+
+export default FileInput;

package/esm/Upload/Image.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import React, { PureComponent } from 'react';
+import { UploadImageHandlerProps, SimpleUploadImageProps } from './Props';
+export declare const Handler: React.FC<UploadImageHandlerProps>;
+interface ImageState {
+    urlInvalid: boolean;
+}
+declare class Image<ValueItem> extends PureComponent<SimpleUploadImageProps<ValueItem>, ImageState> {
+    timeout: NodeJS.Timeout;
+    static defaultProps: {
+        accept: string;
+        height: number;
+        validator: {};
+        width: number;
+    };
+    constructor(props: SimpleUploadImageProps<ValueItem>);
+    beforeUpload(blob: File, validatorHandle: (error: Error, file: File) => boolean): Promise<unknown>;
+    handleKeyDown(e: React.KeyboardEvent): void;
+    handleMouseDown(): void;
+    render(): JSX.Element;
+}
+export default Image;