@nutui/nutui-react-taro 2.0.0-alpha.1 → 2.0.0-alpha.10

package/dist/esm/trendarrow.taro-0cf43935.js

@@ -0,0 +1,72 @@
+import React, { useRef } from "react";
+import { TriangleUp, TriangleDown } from "@nutui/icons-react-taro";
+import { c as cn } from "./bem-cdccae08.js";
+const defaultProps = {
+  rate: 0,
+  digits: 2,
+  showSign: false,
+  showZero: false,
+  arrowLeft: false,
+  syncTextColor: true,
+  textColor: "#333",
+  riseColor: "#fa2c19",
+  dropColor: "#64b578",
+  upIcon: null,
+  downIcon: null,
+  className: ""
+};
+const TrendArrow = (props) => {
+  const { rate, digits, showSign, showZero, arrowLeft, syncTextColor, textColor, riseColor, dropColor, upIcon, downIcon, className, children, ...rest } = { ...defaultProps, ...props };
+  const b = cn("trendarrow");
+  const handleClick = () => {
+  };
+  const rateTrend = useRef(rate > 0);
+  const myFixed = (num, digit = 2) => {
+    if (Object.is(parseFloat(num), NaN)) {
+      return console.log(`传入的值：${num}不是一个数字`);
+    }
+    num = parseFloat(num);
+    const numPow = Math.pow(10, digit);
+    return (Math.round((num + Number.EPSILON) * numPow) / numPow).toFixed(digit);
+  };
+  const calcStyle = (() => {
+    const arrowColor = rateTrend.current ? riseColor : dropColor;
+    const textEquArrowColor = syncTextColor ? arrowColor : textColor;
+    const style = {
+      color: rate === 0 ? textColor : textEquArrowColor
+    };
+    return style;
+  })();
+  const calcRate = (() => {
+    rateTrend.current = rate > 0;
+    const absRate = Math.abs(rate);
+    if (!showZero && rate === 0) {
+      return "--";
+    }
+    const resultRate = `${// eslint-disable-next-line no-nested-ternary
+    showSign && rate !== 0 ? rateTrend.current ? "+" : "-" : ""}${myFixed(Number(absRate), digits)}%`;
+    return resultRate;
+  })();
+  const calcIconProps = (() => {
+    const iconProps = {
+      color: rateTrend.current ? riseColor : dropColor
+    };
+    return iconProps;
+  })();
+  const renderContent = (arrowLeft2) => {
+    const classNameSuffix = !arrowLeft2 ? "icon-after" : "icon-before";
+    return React.createElement("span", { className: `${b(classNameSuffix)} ${b("rate")}`, style: calcStyle }, calcRate);
+  };
+  return React.createElement(
+    "div",
+    { className: `${b()} ${className}`, ...rest, onClick: handleClick },
+    !arrowLeft && renderContent(!arrowLeft),
+    children || React.createElement(React.Fragment, null, Number(rate) !== 0 && React.createElement(React.Fragment, null, rateTrend ? React.createElement(TriangleUp, { color: calcIconProps.color }) : React.createElement(TriangleDown, { color: calcIconProps.color }))),
+    arrowLeft && renderContent(!arrowLeft)
+  );
+};
+TrendArrow.defaultProps = defaultProps;
+TrendArrow.displayName = "NutTrendArrow";
+export {
+  TrendArrow as T
+};

package/dist/esm/typings-11d83a22.js

@@ -0,0 +1,7 @@
+const ComponentDefaults = {
+  className: "",
+  style: {}
+};
+export {
+  ComponentDefaults as C
+};

package/dist/esm/uploader.taro-7e38fc37.js

@@ -0,0 +1,519 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import React, { useState, useEffect, useImperativeHandle } from "react";
+import classNames from "classnames";
+import Taro, { uploadFile, getEnv, chooseMedia, chooseImage } from "@tarojs/taro";
+import { Failure, Loading, Link, Del, Photograph } from "@nutui/icons-react-taro";
+import { Image } from "@tarojs/components";
+import { B as Button } from "./button.taro-01eae688.js";
+import { P as Progress } from "./progress.taro-437b9f6a.js";
+import { u as useConfig } from "./configprovider.taro-25758d9f.js";
+import { i as isPromise } from "./index-e3184f19.js";
+import { C as ComponentDefaults } from "./typings-11d83a22.js";
+class UploadOptions {
+  constructor() {
+    __publicField(this, "url", "");
+    __publicField(this, "name", "file");
+    __publicField(this, "fileType", "image");
+    __publicField(this, "formData");
+    __publicField(this, "sourceFile");
+    __publicField(this, "method", "post");
+    __publicField(this, "xhrState", 200);
+    __publicField(this, "timeout", 30 * 1e3);
+    __publicField(this, "headers", {});
+    __publicField(this, "withCredentials", false);
+    __publicField(this, "onStart");
+    __publicField(this, "taroFilePath");
+    __publicField(this, "onProgress");
+    __publicField(this, "onSuccess");
+    __publicField(this, "onFailure");
+    __publicField(this, "beforeXhrUpload");
+  }
+}
+class Upload {
+  constructor(options) {
+    __publicField(this, "options");
+    this.options = options;
+  }
+  upload() {
+    var _a;
+    const { options } = this;
+    const xhr = new XMLHttpRequest();
+    xhr.timeout = options.timeout;
+    if (xhr.upload) {
+      xhr.upload.addEventListener("progress", (e) => {
+        var _a2;
+        (_a2 = options.onProgress) == null ? void 0 : _a2.call(options, e, options);
+      }, false);
+      xhr.onreadystatechange = () => {
+        var _a2, _b;
+        if (xhr.readyState === 4) {
+          if (xhr.status === options.xhrState) {
+            (_a2 = options.onSuccess) == null ? void 0 : _a2.call(options, xhr.responseText, options);
+          } else {
+            (_b = options.onFailure) == null ? void 0 : _b.call(options, xhr.responseText, options);
+          }
+        }
+      };
+      xhr.withCredentials = options.withCredentials;
+      xhr.open(options.method, options.url, true);
+      for (const [key, value] of Object.entries(options.headers)) {
+        xhr.setRequestHeader(key, value);
+      }
+      (_a = options.onStart) == null ? void 0 : _a.call(options, options);
+      if (options.beforeXhrUpload) {
+        options.beforeXhrUpload(xhr, options);
+      } else {
+        xhr.send(options.formData);
+      }
+    } else {
+      console.warn("浏览器不支持 XMLHttpRequest");
+    }
+  }
+}
+class UploaderTaro extends Upload {
+  constructor(options) {
+    super(options);
+  }
+  uploadTaro(uploadFile2, env) {
+    var _a;
+    const options = this.options;
+    if (env === "WEB") {
+      this.upload();
+    } else {
+      if (options.beforeXhrUpload) {
+        options.beforeXhrUpload(uploadFile2, options);
+      } else {
+        const uploadTask = uploadFile2({
+          url: options.url,
+          filePath: options.taroFilePath,
+          fileType: options.fileType,
+          header: {
+            "Content-Type": "multipart/form-data",
+            ...options.headers
+          },
+          formData: options.formData,
+          name: options.name,
+          success(response) {
+            var _a2, _b;
+            if (options.xhrState == response.statusCode) {
+              (_a2 = options.onSuccess) == null ? void 0 : _a2.call(options, response, options);
+            } else {
+              (_b = options.onFailure) == null ? void 0 : _b.call(options, response, options);
+            }
+          },
+          fail(e) {
+            var _a2;
+            (_a2 = options.onFailure) == null ? void 0 : _a2.call(options, e, options);
+          }
+        });
+        (_a = options.onStart) == null ? void 0 : _a.call(options, options);
+        uploadTask.progress((res) => {
+          var _a2;
+          (_a2 = options.onProgress) == null ? void 0 : _a2.call(options, res, options);
+        });
+      }
+    }
+  }
+}
+const funcInterceptor = (interceptor, { args = [], done, canceled }) => {
+  if (interceptor) {
+    const returnVal = interceptor.apply(null, args);
+    if (isPromise(returnVal)) {
+      returnVal.then((value) => {
+        if (value) {
+          done(value);
+        } else if (canceled) {
+          canceled();
+        }
+      }).catch(() => {
+      });
+    } else if (returnVal) {
+      done();
+    } else if (canceled) {
+      canceled();
+    }
+  } else {
+    done();
+  }
+};
+const defaultProps = {
+  ...ComponentDefaults,
+  url: "",
+  maxCount: 1,
+  sizeType: ["original", "compressed"],
+  sourceType: ["album", "camera"],
+  mediaType: ["image", "video"],
+  camera: "back",
+  uploadIcon: null,
+  uploadLabel: "",
+  previewType: "picture",
+  imageFit: "cover",
+  name: "file",
+  accept: "*",
+  disabled: false,
+  autoUpload: true,
+  multiple: false,
+  maxFileSize: Number.MAX_VALUE,
+  data: {},
+  headers: {},
+  method: "post",
+  previewUrl: "",
+  xhrState: 200,
+  timeout: 1e3 * 30,
+  preview: true,
+  deletable: true,
+  maxDuration: 10,
+  beforeDelete: (file, files) => {
+    return true;
+  }
+};
+class FileItem {
+  constructor() {
+    __publicField(this, "status", "ready");
+    __publicField(this, "message", "准备中..");
+    __publicField(this, "uid", (/* @__PURE__ */ new Date()).getTime().toString());
+    __publicField(this, "name");
+    __publicField(this, "url");
+    __publicField(this, "type");
+    __publicField(this, "path");
+    __publicField(this, "percentage", 0);
+    __publicField(this, "formData", {});
+  }
+}
+const InternalUploader = (props, ref) => {
+  const { locale } = useConfig();
+  const { children, uploadIcon, uploadLabel, accept, name, camera, defaultValue, value, previewType, imageFit, disabled, multiple, url, previewUrl, headers, timeout, method, xhrState, data, preview, deletable, maxCount, maxFileSize, mediaType, className, autoUpload, sizeType, sourceType, maxDuration, onStart, onDelete, onChange, onFileItemClick, onProgress, onSuccess, onUpdate, onFailure, onOversize, beforeXhrUpload, beforeDelete, ...restProps } = { ...defaultProps, ...props };
+  const [fileList, setFileList] = useState(defaultValue || []);
+  const [uploadQueue, setUploadQueue] = useState([]);
+  useEffect(() => {
+    if (value) {
+      setFileList(value);
+    }
+  }, [value]);
+  const classes = classNames(className, "nut-uploader");
+  useImperativeHandle(ref, () => ({
+    submit: () => {
+      Promise.all(uploadQueue).then((res) => {
+        res.forEach((i) => i.uploadTaro(uploadFile, getEnv()));
+      });
+    },
+    clear: () => {
+      clearUploadQueue();
+    }
+  }));
+  const clearUploadQueue = (index = -1) => {
+    if (index > -1) {
+      uploadQueue.splice(index, 1);
+      setUploadQueue(uploadQueue);
+    } else {
+      setUploadQueue([]);
+      fileList.splice(0, fileList.length);
+      setFileList([...fileList]);
+    }
+  };
+  const _chooseImage = () => {
+    if (disabled) {
+      return;
+    }
+    if (Taro.getEnv() === "WEB") {
+      const el = document.getElementById("taroChooseImage");
+      if (el) {
+        el == null ? void 0 : el.setAttribute("accept", accept);
+      } else {
+        const obj = document.createElement("input");
+        obj.setAttribute("type", "file");
+        obj.setAttribute("id", "taroChooseImage");
+        obj.setAttribute("accept", accept);
+        obj.setAttribute("style", "position: fixed; top: -4000px; left: -3000px; z-index: -300;");
+        document.body.appendChild(obj);
+      }
+    }
+    if (getEnv() === "WEAPP") {
+      chooseMedia({
+        /** 最多可以选择的文件个数 */
+        count: multiple ? maxCount * 1 - fileList.length : 1,
+        /** 文件类型 */
+        mediaType,
+        /** 图片和视频选择的来源 */
+        sourceType,
+        /** 拍摄视频最长拍摄时间，单位秒。时间范围为 3s 至 30s 之间 */
+        maxDuration,
+        /** 仅对 mediaType 为 image 时有效，是否压缩所选文件 */
+        sizeType: [],
+        /** 仅在 sourceType 为 camera 时生效，使用前置或后置摄像头 */
+        camera,
+        /** 接口调用失败的回调函数 */
+        fail: (res) => {
+          onFailure && onFailure(res);
+        },
+        /** 接口调用成功的回调函数 */
+        success: onChangeMedia
+      });
+    } else {
+      chooseImage({
+        // 选择数量
+        count: multiple ? maxCount * 1 - fileList.length : 1,
+        // 可以指定是原图还是压缩图，默认二者都有
+        sizeType,
+        sourceType,
+        success: onChangeImage,
+        fail: (res) => {
+          onFailure && onFailure(res);
+        }
+      });
+    }
+  };
+  const executeUpload = (fileItem, index) => {
+    const uploadOption = new UploadOptions();
+    uploadOption.name = name;
+    uploadOption.url = url;
+    uploadOption.fileType = fileItem.type;
+    uploadOption.formData = fileItem.formData;
+    uploadOption.timeout = timeout * 1;
+    uploadOption.method = method;
+    uploadOption.xhrState = xhrState;
+    uploadOption.headers = headers;
+    uploadOption.taroFilePath = fileItem.path;
+    uploadOption.beforeXhrUpload = beforeXhrUpload;
+    uploadOption.onStart = (option) => {
+      clearUploadQueue(index);
+      setFileList((fileList2) => {
+        fileList2.map((item) => {
+          if (item.uid === fileItem.uid) {
+            item.status = "ready";
+            item.message = locale.uploader.readyUpload;
+          }
+        });
+        return [...fileList2];
+      });
+      onStart && onStart(option);
+    };
+    uploadOption.onProgress = (e, option) => {
+      setFileList((fileList2) => {
+        fileList2.map((item) => {
+          if (item.uid === fileItem.uid) {
+            item.status = "uploading";
+            item.message = locale.uploader.uploading;
+            item.percentage = e.progress;
+            onProgress && onProgress({ e, option, percentage: item.percentage });
+          }
+        });
+        return [...fileList2];
+      });
+    };
+    uploadOption.onSuccess = (responseText, option) => {
+      setFileList((fileList2) => {
+        onUpdate && onUpdate(fileList2);
+        fileList2.map((item) => {
+          if (item.uid === fileItem.uid) {
+            item.status = "success";
+            item.message = locale.uploader.success;
+          }
+        });
+        return [...fileList2];
+      });
+      onSuccess && onSuccess({
+        responseText,
+        option,
+        fileList
+      });
+    };
+    uploadOption.onFailure = (responseText, option) => {
+      setFileList((fileList2) => {
+        fileList2.map((item) => {
+          if (item.uid === fileItem.uid) {
+            item.status = "error";
+            item.message = locale.uploader.error;
+          }
+        });
+        return [...fileList2];
+      });
+      onFailure && onFailure({
+        responseText,
+        option,
+        fileList
+      });
+    };
+    const task = new UploaderTaro(uploadOption);
+    if (props.autoUpload) {
+      task.uploadTaro(uploadFile, getEnv());
+    } else {
+      uploadQueue.push(new Promise((resolve, reject) => {
+        resolve(task);
+      }));
+      setUploadQueue(uploadQueue);
+    }
+  };
+  const readFile = (files) => {
+    files.forEach((file, index) => {
+      var _a, _b;
+      let fileType = file.type;
+      const filepath = file.tempFilePath || file.path;
+      const fileItem = new FileItem();
+      if (file.fileType) {
+        fileType = file.fileType;
+      } else {
+        const imgReg = /\.(png|jpeg|jpg|webp|gif)$/i;
+        if (!fileType && (imgReg.test(filepath) || filepath.includes("data:image"))) {
+          fileType = "image";
+        }
+      }
+      fileItem.path = filepath;
+      fileItem.name = filepath;
+      fileItem.status = "ready";
+      fileItem.type = fileType;
+      if (autoUpload) {
+        fileItem.message = locale.uploader.readyUpload;
+      } else {
+        fileItem.message = locale.uploader.waitingUpload;
+      }
+      if (getEnv() === "WEB") {
+        const formData = new FormData();
+        for (const [key, value2] of Object.entries(data)) {
+          formData.append(key, value2);
+        }
+        formData.append(name, file.originalFileObj);
+        fileItem.name = (_a = file.originalFileObj) == null ? void 0 : _a.name;
+        fileItem.type = (_b = file.originalFileObj) == null ? void 0 : _b.type;
+        fileItem.formData = formData;
+      } else {
+        fileItem.formData = data;
+      }
+      if (preview) {
+        fileItem.url = fileType == "video" ? file.thumbTempFilePath : filepath;
+      }
+      fileList.push(fileItem);
+      setFileList([...fileList]);
+      executeUpload(fileItem, index);
+    });
+  };
+  const filterFiles = (files) => {
+    const maximum = props.maxCount * 1;
+    const maximize = props.maxFileSize * 1;
+    const oversizes = new Array();
+    const filterFile = files.filter((file) => {
+      if (file.size > maximize) {
+        oversizes.push(file);
+        return false;
+      }
+      return true;
+    });
+    if (oversizes.length) {
+      onOversize && onOversize(files);
+    }
+    const currentFileLength = filterFile.length + fileList.length;
+    if (currentFileLength > maximum) {
+      filterFile.splice(filterFile.length - (currentFileLength - maximum));
+    }
+    return filterFile;
+  };
+  const deleted = (file, index) => {
+    fileList.splice(index, 1);
+    onDelete && onDelete(file, fileList);
+    setFileList([...fileList]);
+  };
+  const onDeleteItem = (file, index) => {
+    clearUploadQueue(index);
+    funcInterceptor(beforeDelete, {
+      args: [file, fileList],
+      done: () => deleted(file, index)
+    });
+  };
+  const onChangeMedia = (res) => {
+    const { tempFiles } = res;
+    const _files = filterFiles(tempFiles);
+    readFile(_files);
+    onChange && onChange({ fileList });
+  };
+  const onChangeImage = (res) => {
+    const { tempFiles } = res;
+    const _files = filterFiles(tempFiles);
+    readFile(_files);
+    onChange && onChange({ fileList });
+  };
+  const handleItemClick = (file) => {
+    onFileItemClick && onFileItemClick(file);
+  };
+  return React.createElement(
+    "div",
+    { className: classes, ...restProps },
+    children && React.createElement(
+      "div",
+      { className: "nut-uploader__slot" },
+      React.createElement(
+        React.Fragment,
+        null,
+        children,
+        maxCount > fileList.length && React.createElement(Button, { className: "nut-uploader__input", onClick: _chooseImage })
+      )
+    ),
+    fileList.length !== 0 && fileList.map((item, index) => {
+      return React.createElement(
+        "div",
+        { className: `nut-uploader__preview ${previewType}`, key: item.uid },
+        previewType === "picture" && !children && React.createElement(
+          "div",
+          { className: "nut-uploader__preview-img" },
+          deletable && React.createElement(Failure, { color: "rgba(0,0,0,0.6)", className: "close", onClick: () => onDeleteItem(item, index) }),
+          item.status === "ready" ? React.createElement(
+            "div",
+            { className: "nut-uploader__preview__progress" },
+            React.createElement("div", { className: "nut-uploader__preview__progress__msg" }, item.message)
+          ) : item.status !== "success" && React.createElement(
+            "div",
+            { className: "nut-uploader__preview__progress" },
+            item.failIcon !== " " && item.loadingIcon !== " " && (item.status === "error" ? item.failIcon || React.createElement(Failure, { color: "#fff" }) : item.loadingIcon || React.createElement(Loading, { color: "#fff" })),
+            React.createElement("div", { className: "nut-uploader__preview__progress__msg" }, item.message)
+          ),
+          item.type.includes("image") ? React.createElement(React.Fragment, null, item.url && React.createElement(Image, { className: "nut-uploader__preview-img__c", style: { objectFit: imageFit }, mode: "aspectFit", src: item.url, onClick: () => handleItemClick(item) })) : React.createElement(React.Fragment, null, previewUrl ? React.createElement(Image, { className: "nut-uploader__preview-img__c", mode: "aspectFit", src: previewUrl, onClick: () => handleItemClick(item) }) : React.createElement(
+            "div",
+            { className: "nut-uploader__preview-img__file" },
+            React.createElement(
+              "div",
+              { onClick: () => handleItemClick(item), className: "nut-uploader__preview-img__file__name" },
+              React.createElement(Link, { color: "#808080" }),
+              " ",
+              item.name
+            )
+          )),
+          item.status === "success" ? React.createElement("div", { className: "tips" }, item.name) : null
+        ),
+        previewType === "list" && React.createElement(
+          "div",
+          { className: "nut-uploader__preview-list" },
+          React.createElement(
+            "div",
+            { className: `nut-uploader__preview-img__file__name ${item.status}`, onClick: () => handleItemClick(item) },
+            React.createElement(Link, null),
+            " ",
+            item.name
+          ),
+          deletable && React.createElement(Del, { color: "#808080", className: "nut-uploader__preview-img__file__del", onClick: () => onDeleteItem(item, index) }),
+          item.status === "uploading" && React.createElement(Progress, { percent: item.percentage, color: "linear-gradient(270deg, rgba(18,126,255,1) 0%,rgba(32,147,255,1) 32.815625%,rgba(13,242,204,1) 100%)", showText: false })
+        )
+      );
+    }),
+    maxCount > fileList.length && previewType === "picture" && !children && React.createElement(
+      "div",
+      { className: `nut-uploader__upload ${previewType} ${disabled ? "nut-uploader__upload-disabled" : ""}` },
+      React.createElement(
+        "div",
+        { className: "nut-uploader__icon" },
+        uploadIcon || React.createElement(Photograph, { size: "20px", color: "#808080" }),
+        React.createElement("span", { className: "nut-uploader__icon-tip" }, uploadLabel)
+      ),
+      React.createElement(Button, { className: "nut-uploader__input", onClick: _chooseImage })
+    )
+  );
+};
+const Uploader = React.forwardRef(InternalUploader);
+Uploader.defaultProps = defaultProps;
+Uploader.displayName = "NutUploader";
+export {
+  Uploader as U
+};

package/dist/esm/use-client-rect-f317804e.js

@@ -0,0 +1,10 @@
+const getRectByTaro = async (element) => {
+  if (element) {
+    const res = await element.getBoundingClientRect();
+    return res;
+  }
+  return Promise.resolve({});
+};
+export {
+  getRectByTaro as g
+};

package/dist/esm/use-props-value-7ac1b1b5.js

@@ -0,0 +1,16 @@
+import { useState } from "react";
+function usePropsValue({ value, defaultValue, finalValue, onChange = (value2) => {
+} }) {
+  const [uncontrolled, setUncontrolled] = useState(defaultValue !== void 0 ? defaultValue : finalValue);
+  const handleUncontrolledChange = (val) => {
+    setUncontrolled(val);
+    onChange == null ? void 0 : onChange(val);
+  };
+  if (value !== void 0) {
+    return [value, onChange];
+  }
+  return [uncontrolled, handleUncontrolledChange];
+}
+export {
+  usePropsValue as u
+};

package/dist/esm/use-touch-ff43512c.js

@@ -0,0 +1,69 @@
+import { useState } from "react";
+const MIN_DISTANCE = 10;
+function getDirection(x, y) {
+  if (x > y && x > MIN_DISTANCE) {
+    return "horizontal";
+  }
+  if (y > x && y > MIN_DISTANCE) {
+    return "vertical";
+  }
+  return "";
+}
+function useTouch() {
+  const [startX, SetStartX] = useState(0);
+  const [startY, SetStartY] = useState(0);
+  const [moveX, SetMoveX] = useState(0);
+  const [moveY, SetMoveY] = useState(0);
+  const [deltaX, SetDeltaX] = useState(0);
+  const [deltaY, SetDeltaY] = useState(0);
+  const [offsetX, SetOffsetX] = useState(0);
+  const [offsetY, SetOffsetY] = useState(0);
+  const [direction, SetDirection] = useState("");
+  const isVertical = () => direction === "vertical";
+  const isHorizontal = () => direction === "horizontal";
+  const reset = () => {
+    SetDeltaX(0);
+    SetDeltaY(0);
+    SetOffsetX(0);
+    SetOffsetY(0);
+    SetDirection("");
+  };
+  const start = (event) => {
+    reset();
+    SetStartX(event.touches[0].clientX);
+    SetStartY(event.touches[0].clientY);
+  };
+  const move = (event) => {
+    const touch = event.touches[0];
+    const dX = touch.clientX - startX;
+    const dY = touch.clientY - startY;
+    SetDeltaX(dX);
+    SetDeltaY(dY);
+    SetMoveX(touch.clientX);
+    SetMoveY(touch.clientY);
+    SetOffsetX(Math.abs(dX));
+    SetOffsetY(Math.abs(dY));
+    if (!direction) {
+      SetDirection(getDirection(offsetX, offsetY));
+    }
+  };
+  return {
+    move,
+    start,
+    reset,
+    startX,
+    startY,
+    moveX,
+    moveY,
+    deltaX,
+    deltaY,
+    offsetX,
+    offsetY,
+    direction,
+    isVertical,
+    isHorizontal
+  };
+}
+export {
+  useTouch as u
+};