assui 2.0.2 → 2.0.6

package/es/button-drawer/index.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { DrawerProps } from 'antd/lib/drawer';
+export interface ButtonDrawerProps extends DrawerProps {
+    onClose: () => void;
+    onOpen: () => void;
+    content: React.ReactElement;
+    children: React.ReactElement;
+}
+declare const ForwardRefButtonDrawer: React.ForwardRefExoticComponent<ButtonDrawerProps & React.RefAttributes<unknown>>;
+export default ForwardRefButtonDrawer;

package/es/button-drawer/index.js

@@ -0,0 +1,116 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+    }
+
+    return t;
+  };
+
+  return __assign.apply(this, arguments);
+};
+
+var __rest = this && this.__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 Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(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 __read = this && this.__read || function (o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o),
+      r,
+      ar = [],
+      e;
+
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) {
+      ar.push(r.value);
+    }
+  } catch (error) {
+    e = {
+      error: error
+    };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+
+  return ar;
+};
+
+import React, { useState, useRef, useImperativeHandle } from 'react';
+import Drawer from 'antd/lib/drawer';
+import classNames from 'classnames';
+
+var ButtonDrawer = function ButtonDrawer(props, ref) {
+  var _a = __read(useState(false), 2),
+      drawerVisible = _a[0],
+      setDrawerVisible = _a[1];
+
+  var children = props.children,
+      onOpen = props.onOpen,
+      onClose = props.onClose,
+      content = props.content,
+      title = props.title,
+      className = props.className,
+      restProps = __rest(props, ["children", "onOpen", "onClose", "content", "title", "className"]);
+
+  var closeDrawer = function closeDrawer() {
+    if (onClose) {
+      onClose();
+    }
+
+    setDrawerVisible(false);
+  };
+
+  var openDrawer = function openDrawer() {
+    if (onOpen) {
+      onOpen();
+    }
+
+    setDrawerVisible(true);
+  };
+
+  var actionRef = useRef({
+    close: function close() {
+      closeDrawer();
+    },
+    open: function open() {
+      openDrawer();
+    }
+  });
+  useImperativeHandle(ref, function () {
+    return actionRef.current;
+  }, [actionRef.current]);
+  var buttonNode = children && /*#__PURE__*/React.cloneElement(children, {
+    onClick: openDrawer
+  });
+  return /*#__PURE__*/React.createElement(React.Fragment, null, buttonNode, /*#__PURE__*/React.createElement(Drawer, __assign({
+    maskClosable: false,
+    className: classNames('button-drawer', className),
+    title: title,
+    onClose: closeDrawer,
+    visible: drawerVisible
+  }, restProps), /*#__PURE__*/React.cloneElement(content, {
+    drawerAction: actionRef.current
+  })));
+};
+
+var ForwardRefButtonDrawer = /*#__PURE__*/React.forwardRef(ButtonDrawer);
+export default ForwardRefButtonDrawer; // export default React.memo(ButtonDrawer);

package/es/button-drawer/style/index.d.ts

@@ -0,0 +1 @@
+import 'antd/es/drawer/style';

package/es/button-drawer/style/index.js

@@ -0,0 +1 @@
+import 'antd/es/drawer/style';

package/es/button-modal/index.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { ModalProps } from 'antd/lib/modal';
+export interface refProps {
+    open: () => void;
+    close: () => void;
+}
+export interface ButtonModalProps extends ModalProps {
+    content: React.ReactElement;
+    children: React.ReactElement;
+    onClose: () => void;
+    onOpen: () => void;
+}
+declare const ForwardRefButtonModal: React.ForwardRefExoticComponent<ButtonModalProps & React.RefAttributes<unknown>>;
+export default ForwardRefButtonModal;

package/es/button-modal/index.js

@@ -0,0 +1,131 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+    }
+
+    return t;
+  };
+
+  return __assign.apply(this, arguments);
+};
+
+var __rest = this && this.__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 Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(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 __read = this && this.__read || function (o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o),
+      r,
+      ar = [],
+      e;
+
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) {
+      ar.push(r.value);
+    }
+  } catch (error) {
+    e = {
+      error: error
+    };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+
+  return ar;
+};
+
+import * as React from 'react';
+import Modal from 'antd/lib/modal';
+
+var ButtonModal = function ButtonModal(props, ref) {
+  var _a = __read(React.useState(false), 2),
+      visible = _a[0],
+      setModalVisible = _a[1];
+
+  var children = props.children,
+      content = props.content,
+      onOpen = props.onOpen,
+      onClose = props.onClose,
+      onOk = props.onOk,
+      onCancel = props.onCancel,
+      restModalProps = __rest(props, ["children", "content", "onOpen", "onClose", "onOk", "onCancel"]);
+
+  var openModal = function openModal() {
+    if (onOpen) {
+      onOpen();
+    }
+
+    setModalVisible(true);
+  };
+
+  var closeModal = function closeModal() {
+    if (onClose) {
+      onClose();
+    }
+
+    setModalVisible(false);
+  };
+
+  var modalActionRef = React.useRef({
+    open: open,
+    close: close
+  });
+  React.useImperativeHandle(ref, function () {
+    return {
+      open: open,
+      close: close
+    };
+  }, [modalActionRef]);
+
+  var handleModalOk = function handleModalOk(e) {
+    if (onOk) {
+      return onOk(e);
+    }
+
+    close();
+  };
+
+  var handleModalCancel = function handleModalCancel(e) {
+    if (onCancel) {
+      onCancel(e);
+    }
+
+    closeModal();
+  };
+
+  var buttonNode = children && /*#__PURE__*/React.cloneElement(children, {
+    onClick: openModal
+  });
+  return /*#__PURE__*/React.createElement(React.Fragment, null, buttonNode, /*#__PURE__*/React.createElement(Modal, __assign({
+    visible: visible,
+    onOk: handleModalOk,
+    onCancel: handleModalCancel,
+    centered: true,
+    maskClosable: false
+  }, restModalProps), /*#__PURE__*/React.cloneElement(content, {
+    modalAction: modalActionRef.current
+  })));
+};
+
+var ForwardRefButtonModal = /*#__PURE__*/React.forwardRef(ButtonModal);
+export default ForwardRefButtonModal;

package/es/button-modal/style/index.d.ts

@@ -0,0 +1 @@
+import 'antd/es/modal/style';

package/es/button-modal/style/index.js

@@ -0,0 +1 @@
+import 'antd/es/modal/style';

package/es/condition-input/index.d.ts

@@ -0,0 +1,15 @@
+export interface ConditionInputProps {
+    /** 过滤的正则条件 */
+    regexp: RegExp | (RegExp | string | {
+        pattern: RegExp;
+        replacement?: string;
+    })[];
+    /** 指定输入框展示值的格式 */
+    formatter?: (value: string) => string;
+    /** 变化回调 */
+    onChange?: (value: string) => void;
+    /** 输入框内容 */
+    value?: string;
+}
+declare const ConditionInput: (props: ConditionInputProps) => JSX.Element;
+export default ConditionInput;

package/es/condition-input/index.js

@@ -0,0 +1,108 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+    }
+
+    return t;
+  };
+
+  return __assign.apply(this, arguments);
+};
+
+var __rest = this && this.__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 Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(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 __read = this && this.__read || function (o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o),
+      r,
+      ar = [],
+      e;
+
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) {
+      ar.push(r.value);
+    }
+  } catch (error) {
+    e = {
+      error: error
+    };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+
+  return ar;
+};
+
+import * as React from 'react';
+import isArray from 'lodash/isArray';
+import Input from 'antd/lib/input';
+import isFunction from 'lodash/isFunction';
+import parse2RegexOption from './parse2RegexOption';
+
+var ConditionInput = function ConditionInput(props) {
+  var regexp = props.regexp,
+      formatter = props.formatter,
+      value = props.value,
+      onChange = props.onChange,
+      rest = __rest(props, ["regexp", "formatter", "value", "onChange"]);
+
+  var _a = __read(React.useState(''), 2),
+      stateValue = _a[0],
+      setStateValue = _a[1];
+
+  var resultValue = value === undefined ? stateValue : value;
+
+  var handleChange = function handleChange(e) {
+    var originalValue = e.target.value;
+    var resultRegexp = isArray(regexp) ? regexp : [regexp];
+    var nextValue = resultRegexp.reduce(function (cur, acc) {
+      var regexOption = parse2RegexOption(acc);
+
+      if (regexOption.isValid) {
+        return cur.replace(regexOption.pattern, regexOption.replacement);
+      }
+
+      return cur;
+    }, originalValue);
+
+    if (isFunction(formatter)) {
+      nextValue = formatter(nextValue);
+    }
+
+    if (resultValue !== nextValue) {
+      setStateValue(nextValue);
+
+      if (onChange) {
+        onChange(nextValue);
+      }
+    }
+  };
+
+  return /*#__PURE__*/React.createElement(Input, __assign({
+    value: resultValue,
+    onChange: handleChange
+  }, rest));
+};
+
+export default ConditionInput;

package/es/condition-input/parse2RegexOption.d.ts

@@ -0,0 +1,13 @@
+export interface RegexOptionType {
+    isValid: boolean;
+    replacement: string;
+}
+declare type regexParamsType = RegExp | string | {
+    pattern: RegExp;
+    replacement?: string;
+};
+export interface ResultType extends RegexOptionType {
+    pattern: RegExp;
+}
+declare const parse2RegexOption: (regex: regexParamsType) => ResultType;
+export default parse2RegexOption;

package/es/condition-input/parse2RegexOption.js

@@ -0,0 +1,57 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+    }
+
+    return t;
+  };
+
+  return __assign.apply(this, arguments);
+};
+
+import isRegExp from 'lodash/isRegExp';
+import isString from 'lodash/isString';
+import isObject from 'lodash/isObject';
+var defaultOptionValues = {
+  isValid: true,
+  replacement: ''
+};
+
+var parseRegex2RegexOption = function parseRegex2RegexOption(regex, options) {
+  return __assign(__assign(__assign({}, defaultOptionValues), {
+    pattern: regex
+  }), options);
+};
+
+var parseString2RegexOption = function parseString2RegexOption(regexString, options) {
+  return parseRegex2RegexOption(new RegExp(regexString), options);
+};
+
+var parse2RegexOption = function parse2RegexOption(regex) {
+  if (isRegExp(regex)) {
+    return parseRegex2RegexOption(regex);
+  }
+
+  if (isString(regex)) {
+    return parseString2RegexOption(regex);
+  }
+
+  if (isObject(regex)) {
+    return __assign(__assign(__assign({}, defaultOptionValues), {
+      isValid: !!regex.pattern
+    }), regex);
+  }
+
+  return {
+    isValid: false,
+    replacement: '',
+    pattern: /./
+  };
+};
+
+export default parse2RegexOption;