assui 2.0.2 → 2.0.6

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

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

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

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+require("antd/es/drawer/style");

package/lib/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/lib/button-modal/index.js

@@ -0,0 +1,178 @@
+"use strict";
+
+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 __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  Object.defineProperty(o, k2, {
+    enumerable: true,
+    get: function get() {
+      return m[k];
+    }
+  });
+} : function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  o[k2] = m[k];
+});
+
+var __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function (o, v) {
+  Object.defineProperty(o, "default", {
+    enumerable: true,
+    value: v
+  });
+} : function (o, v) {
+  o["default"] = v;
+});
+
+var __importStar = this && this.__importStar || function (mod) {
+  if (mod && mod.__esModule) return mod;
+  var result = {};
+  if (mod != null) for (var k in mod) {
+    if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+  }
+
+  __setModuleDefault(result, mod);
+
+  return result;
+};
+
+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;
+};
+
+var __importDefault = this && this.__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var React = __importStar(require("react"));
+
+var modal_1 = __importDefault(require("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 && React.cloneElement(children, {
+    onClick: openModal
+  });
+  return React.createElement(React.Fragment, null, buttonNode, React.createElement(modal_1["default"], __assign({
+    visible: visible,
+    onOk: handleModalOk,
+    onCancel: handleModalCancel,
+    centered: true,
+    maskClosable: false
+  }, restModalProps), React.cloneElement(content, {
+    modalAction: modalActionRef.current
+  })));
+};
+
+var ForwardRefButtonModal = React.forwardRef(ButtonModal);
+exports["default"] = ForwardRefButtonModal;

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

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

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

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+require("antd/es/modal/style");

package/lib/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/lib/condition-input/index.js

@@ -0,0 +1,158 @@
+"use strict";
+
+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 __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  Object.defineProperty(o, k2, {
+    enumerable: true,
+    get: function get() {
+      return m[k];
+    }
+  });
+} : function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  o[k2] = m[k];
+});
+
+var __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function (o, v) {
+  Object.defineProperty(o, "default", {
+    enumerable: true,
+    value: v
+  });
+} : function (o, v) {
+  o["default"] = v;
+});
+
+var __importStar = this && this.__importStar || function (mod) {
+  if (mod && mod.__esModule) return mod;
+  var result = {};
+  if (mod != null) for (var k in mod) {
+    if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+  }
+
+  __setModuleDefault(result, mod);
+
+  return result;
+};
+
+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;
+};
+
+var __importDefault = this && this.__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var React = __importStar(require("react"));
+
+var isArray_1 = __importDefault(require("lodash/isArray"));
+
+var input_1 = __importDefault(require("antd/lib/input"));
+
+var isFunction_1 = __importDefault(require("lodash/isFunction"));
+
+var parse2RegexOption_1 = __importDefault(require("./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_1["default"](regexp) ? regexp : [regexp];
+    var nextValue = resultRegexp.reduce(function (cur, acc) {
+      var regexOption = parse2RegexOption_1["default"](acc);
+
+      if (regexOption.isValid) {
+        return cur.replace(regexOption.pattern, regexOption.replacement);
+      }
+
+      return cur;
+    }, originalValue);
+
+    if (isFunction_1["default"](formatter)) {
+      nextValue = formatter(nextValue);
+    }
+
+    if (resultValue !== nextValue) {
+      setStateValue(nextValue);
+
+      if (onChange) {
+        onChange(nextValue);
+      }
+    }
+  };
+
+  return React.createElement(input_1["default"], __assign({
+    value: resultValue,
+    onChange: handleChange
+  }, rest));
+};
+
+exports["default"] = ConditionInput;

package/lib/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/lib/condition-input/parse2RegexOption.js

@@ -0,0 +1,72 @@
+"use strict";
+
+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 __importDefault = this && this.__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var isRegExp_1 = __importDefault(require("lodash/isRegExp"));
+
+var isString_1 = __importDefault(require("lodash/isString"));
+
+var isObject_1 = __importDefault(require("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_1["default"](regex)) {
+    return parseRegex2RegexOption(regex);
+  }
+
+  if (isString_1["default"](regex)) {
+    return parseString2RegexOption(regex);
+  }
+
+  if (isObject_1["default"](regex)) {
+    return __assign(__assign(__assign({}, defaultOptionValues), {
+      isValid: !!regex.pattern
+    }), regex);
+  }
+
+  return {
+    isValid: false,
+    replacement: '',
+    pattern: /./
+  };
+};
+
+exports["default"] = parse2RegexOption;