@kdcloudjs/kdesign 1.0.2

package/lib/typography/text.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { BlockProps } from './base';
+export interface TextProps extends BlockProps {
+    onClick?: (e?: React.MouseEvent<HTMLDivElement>) => void;
+}
+declare const Text: React.FC<TextProps>;
+export default Text;

package/lib/typography/text.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/extends"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _base = _interopRequireDefault(require("./base"));
+
+var Text = function Text(props) {
+  return /*#__PURE__*/_react.default.createElement(_base.default, (0, _extends2.default)({}, props, {
+    component: "span"
+  }));
+};
+
+var _default = Text;
+exports.default = _default;

package/lib/typography/title.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { BlockProps } from './base';
+export declare const TitleLevels: [1, 2, 3];
+export declare type TitleLevel = typeof TitleLevels[number];
+export declare type TitleProps = Omit<BlockProps & {
+    level?: TitleLevel;
+    onClick?: (e?: React.MouseEvent<HTMLDivElement>) => void;
+}, 'strong'>;
+declare const Title: React.FC<TitleProps>;
+export default Title;

package/lib/typography/title.js

@@ -0,0 +1,58 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.TitleLevels = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/extends"));
+
+var _getOwnPropertySymbols = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _type = require("../_utils/type");
+
+var _base = _interopRequireDefault(require("./base"));
+
+var _devwarning = _interopRequireDefault(require("../_utils/devwarning"));
+
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof _getOwnPropertySymbols.default === "function") for (var i = 0, p = (0, _getOwnPropertySymbols.default)(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+
+var TitleLevels = (0, _type.tupleNum)(1, 2, 3);
+exports.TitleLevels = TitleLevels;
+
+var Title = function Title(props) {
+  var _props$level = props.level,
+      level = _props$level === void 0 ? 1 : _props$level,
+      restProps = __rest(props, ["level"]);
+
+  var component;
+
+  if (TitleLevels.indexOf(level) !== -1) {
+    component = "h".concat(level);
+  } else {
+    (0, _devwarning.default)(true, 'typography', "cannot found level '".concat(level, "'"));
+    component = 'h1';
+  }
+
+  return /*#__PURE__*/_react.default.createElement(_base.default, (0, _extends2.default)({}, restProps, {
+    component: component
+  }));
+};
+
+var _default = Title;
+exports.default = _default;

package/lib/typography/typography.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export interface TypographyProps {
+    id?: string;
+    prefixCls?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    children?: React.ReactNode;
+    ['aria-label']?: string;
+}
+interface InternalTypographyProps extends TypographyProps {
+    component?: string;
+}
+declare const Typography: React.ForwardRefExoticComponent<InternalTypographyProps & React.RefAttributes<unknown>>;
+export default Typography;

package/lib/typography/typography.js

@@ -0,0 +1,79 @@
+"use strict";
+
+var _typeof = require("@babel/runtime-corejs3/helpers/typeof");
+
+var _WeakMap = require("@babel/runtime-corejs3/core-js-stable/weak-map");
+
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/extends"));
+
+var _getOwnPropertySymbols = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _ConfigContext = _interopRequireDefault(require("../config-provider/ConfigContext"));
+
+var _utils = require("../_utils");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof _WeakMap !== "function") return null; var cacheBabelInterop = new _WeakMap(); var cacheNodeInterop = new _WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && _Object$getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? _Object$getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof _getOwnPropertySymbols.default === "function") for (var i = 0, p = (0, _getOwnPropertySymbols.default)(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+
+// remove this line and code Typography component here
+var InternalTypography = function InternalTypography(props, ref) {
+  var _useContext = (0, _react.useContext)(_ConfigContext.default),
+      getPrefixCls = _useContext.getPrefixCls,
+      prefixCls = _useContext.prefixCls,
+      userDefaultProps = _useContext.compDefaultProps;
+
+  var typographyProps = (0, _utils.getCompProps)('Typography', userDefaultProps, props);
+
+  var customPrefixcls = typographyProps.prefixCls,
+      _typographyProps$comp = typographyProps.component,
+      component = _typographyProps$comp === void 0 ? 'article' : _typographyProps$comp,
+      className = typographyProps.className,
+      ariaLabel = typographyProps['aria-label'],
+      children = typographyProps.children,
+      restProps = __rest(typographyProps, ["prefixCls", "component", "className", 'aria-label', "children"]);
+
+  var typographyPrefixCls = getPrefixCls(prefixCls, 'typography', customPrefixcls); // 排版样式前缀
+
+  var typographyClasses = (0, _classnames.default)(typographyPrefixCls, className, {// [`${typographyPrefixCls}-size-${size}`]: size,
+    // [`${typographyPrefixCls}-borderless`]: borderType === 'none',
+  });
+  var Component = component;
+  return /*#__PURE__*/_react.default.createElement(Component, (0, _extends2.default)({
+    className: typographyClasses,
+    "aria-label": ariaLabel,
+    ref: ref
+  }, restProps), children);
+};
+
+var Typography = /*#__PURE__*/_react.default.forwardRef(InternalTypography);
+
+Typography.displayName = 'Typography';
+var _default = Typography;
+exports.default = _default;

package/lib/upload/dragger.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { UploadProps } from './interface';
+export declare type DraggerProps = UploadProps & {
+    height?: number;
+};
+declare const Dragger: React.FC<DraggerProps>;
+export default Dragger;

package/lib/upload/dragger.js

@@ -0,0 +1,59 @@
+"use strict";
+
+var _typeof = require("@babel/runtime-corejs3/helpers/typeof");
+
+var _WeakMap = require("@babel/runtime-corejs3/core-js-stable/weak-map");
+
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/extends"));
+
+var _getOwnPropertySymbols = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _upload = _interopRequireDefault(require("./upload"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof _WeakMap !== "function") return null; var cacheBabelInterop = new _WeakMap(); var cacheNodeInterop = new _WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && _Object$getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? _Object$getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof _getOwnPropertySymbols.default === "function") for (var i = 0, p = (0, _getOwnPropertySymbols.default)(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+
+var InternalDragger = function InternalDragger(_a, ref) {
+  var style = _a.style,
+      height = _a.height,
+      restProps = __rest(_a, ["style", "height"]);
+
+  return /*#__PURE__*/React.createElement(_upload.default, (0, _extends2.default)({
+    ref: ref
+  }, restProps, {
+    type: "drag",
+    style: (0, _extends2.default)((0, _extends2.default)({}, style), {
+      height: height
+    })
+  }));
+};
+
+var Dragger = /*#__PURE__*/React.forwardRef(InternalDragger);
+Dragger.displayName = 'Dragger';
+var _default = Dragger;
+exports.default = _default;

package/lib/upload/index.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import Dragger from './dragger';
+import { UploadProps } from './interface';
+export * from './upload';
+interface CompoundedComponent extends React.ForwardRefExoticComponent<React.PropsWithChildren<UploadProps> & React.RefAttributes<any>> {
+    Dragger: typeof Dragger;
+}
+declare const Upload: CompoundedComponent;
+export default Upload;

package/lib/upload/index.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _typeof = require("@babel/runtime-corejs3/helpers/typeof");
+
+var _WeakMap = require("@babel/runtime-corejs3/core-js-stable/weak-map");
+
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor");
+
+var _Object$keys = require("@babel/runtime-corejs3/core-js-stable/object/keys");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {};
+exports.default = void 0;
+
+var _upload = _interopRequireWildcard(require("./upload"));
+
+_Object$keys(_upload).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _upload[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _upload[key];
+    }
+  });
+});
+
+var _dragger = _interopRequireDefault(require("./dragger"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof _WeakMap !== "function") return null; var cacheBabelInterop = new _WeakMap(); var cacheNodeInterop = new _WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && _Object$getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? _Object$getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var Upload = _upload.default;
+Upload.Dragger = _dragger.default;
+var _default = Upload;
+exports.default = _default;

package/lib/upload/interface.d.ts

@@ -0,0 +1,144 @@
+import * as React from 'react';
+import { ProgressProps } from '../progress';
+export declare type UploadFileStatus = 'error' | 'success' | 'done' | 'uploading' | 'removed' | 'notStart';
+export declare type UploadRequestMethod = 'POST' | 'PUT' | 'PATCH' | 'post' | 'put' | 'patch';
+export declare type Action = string | ((file: UploadFile) => string) | ((file: UploadFile) => PromiseLike<string>);
+export interface HttpRequestHeader {
+    [key: string]: string;
+}
+export interface UploadFile<T = any> extends File {
+    uid: string;
+    size: number;
+    name: string;
+    type: string;
+    fileName?: string;
+    readonly lastModified: number;
+    readonly lastModifiedDate: Date;
+    webkitRelativePath: string;
+    url?: string;
+    status?: UploadFileStatus;
+    percent?: number;
+    thumbUrl?: string;
+    originFileObj?: File | Blob;
+    response?: T;
+    error?: any;
+    linkProps?: any;
+    xhr?: T;
+    preview?: string;
+}
+export interface UploadChangeParam<T extends UploadFile> {
+    file: T;
+    fileList: Array<UploadFile>;
+    event?: {
+        percent: number;
+    };
+}
+export interface ShowUploadListInterface {
+    showRemoveIcon?: boolean;
+    showPreviewIcon?: boolean;
+    showDownloadIcon?: boolean;
+    removeIcon?: React.ReactNode | ((file: UploadFile) => React.ReactNode);
+    downloadIcon?: React.ReactNode | ((file: UploadFile) => React.ReactNode);
+}
+export interface UploadLocale {
+    uploading?: string;
+    removeFile?: string;
+    downloadFile?: string;
+    uploadError?: string;
+    previewFile?: string;
+}
+export declare type UploadType = 'drag' | 'select';
+export declare type UploadListType = 'text' | 'picture';
+export declare type UploadListProgressProps = Omit<ProgressProps, 'percent' | 'type'>;
+export declare type ItemRender<T = any> = (originNode: React.ReactElement, file: UploadFile, fileList?: Array<UploadFile<T>>) => React.ReactNode;
+declare type PreviewFileHandler = (file: File | Blob) => PromiseLike<string>;
+declare type TransformFileHandler = (file: UploadFile) => string | Blob | File | PromiseLike<string | Blob | File>;
+export interface UploadProps<T = any> {
+    type?: UploadType;
+    name?: string;
+    defaultFileList?: Array<UploadFile<T>>;
+    fileList?: Array<UploadFile<T>>;
+    action?: Action;
+    directory?: boolean;
+    data?: Record<string, unknown> | ((file: UploadFile<T>) => Record<string, unknown>);
+    method?: 'POST' | 'PUT' | 'PATCH' | 'post' | 'put' | 'patch';
+    headers?: HttpRequestHeader;
+    showUploadList?: boolean | ShowUploadListInterface;
+    multiple?: boolean;
+    accept?: string;
+    beforeUpload?: (file: UploadFile, FileList: UploadFile[]) => boolean | Promise<void | Blob | File>;
+    onStart?: (file: UploadFile<T>) => void;
+    onChange?: (info: UploadChangeParam<UploadFile>) => void;
+    listType?: UploadListType;
+    className?: string;
+    onPreview?: (file: UploadFile<T>) => void;
+    onDownload?: (file: UploadFile<T>) => void;
+    onRemove?: (file: UploadFile<T>) => void | boolean | Promise<void | boolean>;
+    supportServerRender?: boolean;
+    style?: React.CSSProperties;
+    disabled?: boolean;
+    prefixCls?: string;
+    customRequest?: (options: UploadRequestOption) => void;
+    withCredentials?: boolean;
+    openFileDialogOnClick?: boolean;
+    locale?: UploadLocale;
+    id?: string;
+    previewFile?: PreviewFileHandler;
+    /** @deprecated Please use `beforeUpload` directly */
+    transformFile?: TransformFileHandler;
+    iconRender?: (file: UploadFile<T>, listType?: UploadListType) => React.ReactNode;
+    isImageUrl?: (file: UploadFile) => boolean;
+    progress?: UploadListProgressProps;
+    itemRender?: ItemRender<T>;
+    onError?: (error: Error, ret: Record<string, unknown>, file: UploadFile) => void;
+    onSuccess?: (response: Record<string, unknown>, file: UploadFile, xhr: XMLHttpRequest) => void;
+    onProgress?: (event: UploadProgressEvent, file: UploadFile) => void;
+    onMouseEnter?: (e: React.MouseEvent<HTMLDivElement>) => void;
+    onMouseLeave?: (e: React.MouseEvent<HTMLDivElement>) => void;
+    onClick?: (e: React.MouseEvent<HTMLDivElement> | React.KeyboardEvent<HTMLDivElement>) => void;
+}
+export interface UploadState<T = any> {
+    fileList: UploadFile<T>[];
+    dragState: string;
+}
+export interface UploadListProps<T = any> {
+    listType?: UploadListType;
+    onPreview?: (file: UploadFile<T>) => void;
+    onDownload?: (file: UploadFile<T>) => void;
+    onRemove?: (file: UploadFile<T>) => void | boolean;
+    items?: Array<UploadFile<T>>;
+    progress?: UploadListProgressProps;
+    prefixCls?: string;
+    showRemoveIcon?: boolean;
+    showDownloadIcon?: boolean;
+    showPreviewIcon?: boolean;
+    removeIcon?: React.ReactNode | ((file: UploadFile) => React.ReactNode);
+    downloadIcon?: React.ReactNode | ((file: UploadFile) => React.ReactNode);
+    locale: UploadLocale;
+    previewFile?: PreviewFileHandler;
+    iconRender?: (file: UploadFile<T>, listType?: UploadListType) => React.ReactNode;
+    isImageUrl?: (file: UploadFile) => boolean;
+    appendAction?: React.ReactNode;
+    itemRender?: ItemRender<T>;
+}
+export interface UploadRequestError extends Error {
+    status?: number;
+    method?: UploadRequestMethod;
+    url?: string;
+}
+export interface UploadProgressEvent extends ProgressEvent {
+    percent: number;
+}
+export interface UploadRequestOption<T = any> {
+    onProgress?: (event: UploadProgressEvent) => void;
+    onError?: (event: UploadRequestError | ProgressEvent, body?: T) => void;
+    onSuccess?: (body: T, xhr: XMLHttpRequest) => void;
+    data?: Record<string, unknown>;
+    filename?: string;
+    file: UploadFile;
+    withCredentials?: boolean;
+    action: string;
+    headers?: HttpRequestHeader;
+    method: UploadRequestMethod;
+}
+export {};

package/lib/upload/request.d.ts

@@ -0,0 +1,2 @@
+import { UploadRequestOption } from './interface';
+export default function upload(option: UploadRequestOption): XMLHttpRequest;

package/lib/upload/request.js

@@ -0,0 +1,108 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = upload;
+
+var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
+
+var _keys = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/keys"));
+
+function getError(option, xhr) {
+  var _context, _context2;
+
+  var msg = (0, _concat.default)(_context = (0, _concat.default)(_context2 = "cannot ".concat(option.method, " ")).call(_context2, option.action, " ")).call(_context, xhr.status, "'");
+  var err = new Error(msg);
+  err.status = xhr.status;
+  err.method = option.method;
+  err.url = option.action;
+  return err;
+}
+
+function getBody(xhr) {
+  var text = xhr.responseText || xhr.response;
+
+  if (!text) {
+    return text;
+  }
+
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    return text;
+  }
+}
+
+function upload(option) {
+  var xhr = new XMLHttpRequest();
+
+  if (option.onProgress && xhr.upload) {
+    xhr.upload.onprogress = function progress(e) {
+      if (e.total > 0) {
+        e.percent = e.loaded / e.total * 100;
+      }
+
+      option.onProgress(e);
+    };
+  }
+
+  var formData = new FormData();
+
+  if (option.data) {
+    (0, _keys.default)(option.data).forEach(function (key) {
+      var value = option.data[key]; // support key-value array data
+
+      if (Array.isArray(value)) {
+        value.forEach(function (item) {
+          // { list: [ 11, 22 ] }
+          // formData.append('list[]', 11)
+          formData.append("".concat(key, "[]"), item);
+        });
+        return;
+      }
+
+      formData.append(key, value);
+    });
+  }
+
+  if (option.file instanceof Blob) {
+    formData.append(option.filename, option.file, option.file.name);
+  } else {
+    formData.append(option.filename, option.file);
+  }
+
+  xhr.onerror = function error(e) {
+    option.onError(e);
+  };
+
+  xhr.onload = function onload() {
+    if (xhr.status < 200 || xhr.status >= 300) {
+      return option.onError(getError(option, xhr), getBody(xhr));
+    }
+
+    return option.onSuccess(getBody(xhr), xhr);
+  };
+
+  xhr.open(option.method, option.action, true); // Has to be after `.open()`. See https://github.com/enyo/dropzone/issues/179
+
+  if (option.withCredentials && 'withCredentials' in xhr) {
+    xhr.withCredentials = true;
+  }
+
+  var headers = option.headers || {}; // when set headers['X-Requested-With'] = null , can close default XHR header
+
+  if (headers['X-Requested-With'] !== null) {
+    xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
+  }
+
+  (0, _keys.default)(headers).forEach(function (key) {
+    if (headers[key] !== null) {
+      xhr.setRequestHeader(key, headers[key]);
+    }
+  });
+  xhr.send(formData);
+  return xhr;
+}

package/lib/upload/scan-files.d.ts

@@ -0,0 +1,14 @@
+import { UploadFile } from './interface';
+interface InternalDataTransferItem extends DataTransferItem {
+    isFile: boolean;
+    file: (cd: (file: UploadFile & {
+        webkitRelativePath?: string;
+    }) => void) => void;
+    createReader: () => any;
+    fullPath: string;
+    isDirectory: boolean;
+    name: string;
+    path: string;
+}
+declare const scanFiles: (files: Array<InternalDataTransferItem>, isAccepted: (file: UploadFile) => boolean, callback: (file: UploadFile) => void) => void;
+export default scanFiles;

package/lib/upload/scan-files.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _slice = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/slice"));
+
+var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
+
+function loopFiles(item, callback) {
+  var dirReader = item.createReader();
+  var fileList = [];
+
+  function sequence() {
+    dirReader.readEntries(function (entries) {
+      var entryList = (0, _slice.default)(Array.prototype).apply(entries);
+      fileList = (0, _concat.default)(fileList).call(fileList, entryList); // Check if all the file has been viewed
+
+      var isFinished = !entryList.length;
+
+      if (isFinished) {
+        callback(fileList);
+      } else {
+        sequence();
+      }
+    });
+  }
+
+  return sequence();
+}
+
+var scanFiles = function scanFiles(files, isAccepted, callback) {
+  var _traverseFileTree = function _traverseFileTree(item, path) {
+    item.path = path || '';
+
+    if (item.isFile) {
+      item.file(function (file) {
+        if (isAccepted(file)) {
+          if (item.fullPath && !file.webkitRelativePath) {
+            Object.defineProperties(file, {
+              webkitRelativePath: {
+                writable: true
+              }
+            });
+            file.webkitRelativePath = item.fullPath.replace(/^\//, '');
+            Object.defineProperties(file, {
+              webkitRelativePath: {
+                writable: false
+              }
+            });
+          }
+
+          callback(file);
+        }
+      });
+    } else if (item.isDirectory) {
+      loopFiles(item, function (entries) {
+        entries.forEach(function (entryItem) {
+          var _context;
+
+          _traverseFileTree(entryItem, (0, _concat.default)(_context = "".concat(path)).call(_context, item.name, "/"));
+        });
+      });
+    }
+  };
+
+  files.forEach(function (file) {
+    _traverseFileTree(file.webkitGetAsEntry());
+  });
+};
+
+var _default = scanFiles;
+exports.default = _default;