@ecoding/components.antd 0.1.16 → 0.1.18

package/lib/core/async-select/index.d.ts

@@ -21,6 +21,7 @@ interface IData {
 interface IProps extends SelectProps<any> {
     iface?: IFace;
     data?: IData;
+    searchIface?: IFace;
 }
 declare const AsyncSlect: React.FC<IProps>;
 export default AsyncSlect;

package/lib/core/async-select/index.js

@@ -14,12 +14,14 @@ import http from "../../helpers/http";
 import { isSomething } from "@ecoding/helper.is";
 import { jsonFormatNewKey } from "@ecoding/helper.json";
 const { Option } = Select;
+let timeout;
 const AsyncSlect = memo((props) => {
     const r = http.getRequest();
     const [loading, setLoading] = useState(true);
     const [options, setOptions] = useState([]);
     const iface = useMemo(() => props.iface, []);
     const data = useMemo(() => props.data, []);
+    const searchIface = useMemo(() => props.searchIface, []);
     useEffect(() => {
         const ex = () => __awaiter(void 0, void 0, void 0, function* () {
             const innerEx = () => __awaiter(void 0, void 0, void 0, function* () {
@@ -69,6 +71,52 @@ const AsyncSlect = memo((props) => {
         });
         ex();
     }, []);
+    const handleSearch = (newValue) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!newValue) {
+            return null;
+        }
+        if (timeout) {
+            clearTimeout(timeout);
+            timeout = null;
+        }
+        const innerEx = () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            let params = {};
+            if (searchIface) {
+                if (searchIface.paramKey) {
+                    // 设置接口调用参数
+                    params[searchIface.paramKey] = newValue;
+                }
+                if (searchIface.params) {
+                    params = Object.assign({}, params, searchIface.params);
+                }
+                let resOrigin = [];
+                // 这里支持了外部直接传入列表结果
+                const cache = isSomething(searchIface.cache) ? searchIface.cache : false;
+                if (((_a = searchIface.method) === null || _a === void 0 ? void 0 : _a.toLocaleLowerCase()) === "post") {
+                    resOrigin = yield r.post(searchIface.url, params, { cache });
+                }
+                else {
+                    resOrigin = yield r.get(searchIface.url, params, { cache });
+                }
+                // 指定数据key
+                if (searchIface && searchIface.fromKey) {
+                    if (Array.isArray(searchIface.fromKey)) {
+                        searchIface.fromKey.forEach((key) => {
+                            resOrigin = resOrigin[key];
+                        });
+                    }
+                    else {
+                        resOrigin = resOrigin[searchIface.fromKey];
+                    }
+                }
+                const res = jsonFormatNewKey(resOrigin, searchIface.format);
+                setOptions(res);
+            }
+            return Promise.reject("没有searchIface");
+        });
+        timeout = setTimeout(innerEx, 300);
+    });
     const children = useMemo(() => {
         return (options &&
             options.map((item) => {
@@ -83,6 +131,6 @@ const AsyncSlect = memo((props) => {
                 return option.children.join("").toLowerCase().indexOf(input.toLowerCase()) >= 0;
             }
             return option.children.toLowerCase().indexOf(input.toLowerCase()) >= 0;
-        }, allowClear: true, showSearch: true, optionFilterProp: "children" }, props), children));
+        }, allowClear: true, showSearch: true, onSearch: handleSearch, optionFilterProp: "children" }, props), children));
 });
 export default AsyncSlect;

package/lib/helpers/throttle.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 频率控制 返回函数连续调用时，func 执行频率限定为 次 / wait
+ *
+ * @param  {function}   func      传入函数
+ * @param  {number}     wait      表示时间窗口的间隔
+ * @param  {object}     [options] 如果想忽略开始边界上的调用，传入{leading: false}。 绑定的函数先执行，而不是delay后后执行。
+ * @param  {boolean}    [options.leading=true] 如果想忽略开始边界上的调用，传入{leading: false}。
+ * @param  {boolean}    [options.trailing=true] 如果想忽略结尾边界上的调用，传入{trailing: false}
+ *
+ * @return {Function}
+ *
+ * @example
+ * const throttleCallback = throttle(callback, 100);
+ *
+
+export default function throttle(func: Function, wait: number, options: any = {}): any {
+    let context: any;
+    let args: any;
+    let result: any;
+    let timeout: any = null;
+    // 上次执行时间点
+    let previous = 0;
+    // 延迟执行函数
+    const later = () => {
+        // 若设定了开始边界不执行选项，上次执行时间始终为0
+        previous = options.leading === false ? 0 : +new Date();
+        timeout = null;
+        result = func.apply(context, args);
+        if (!timeout) {
+            context = args = null;
+        }
+    };
+    return function f(this: any) {
+        const now = +new Date();
+        // 首次执行时，如果设定了开始边界不执行选项，将上次执行时间设定为当前时间。
+        if (!previous && options.leading === false) {
+            previous = now;
+        }
+        // 延迟执行时间间隔
+        const remaining = wait - (now - previous);
+        context = this;
+        args = arguments; // eslint-disable-line
+        // 延迟时间间隔remaining小于等于0，表示上次执行至此所间隔时间已经超过一个时间窗口
+        // remaining大于时间窗口wait，表示客户端系统时间被调整过
+        if (remaining <= 0 || remaining > wait) {
+            clearTimeout(timeout);
+            timeout = null;
+            previous = now;
+            result = func.apply(context, args);
+            if (!timeout) {
+                context = args = null;
+            }
+            // 如果延迟执行不存在，且没有设定结尾边界不执行选项
+        } else if (!timeout && options.trailing !== false) {
+            timeout = setTimeout(later, remaining);
+        }
+        return result;
+    };
+}
+ */
+export default function throttle(fn: Function, delay: number, immediate: boolean, debounce?: boolean): (this: any) => void;

package/lib/helpers/throttle.js

@@ -0,0 +1,100 @@
+/**
+ * 频率控制 返回函数连续调用时，func 执行频率限定为 次 / wait
+ *
+ * @param  {function}   func      传入函数
+ * @param  {number}     wait      表示时间窗口的间隔
+ * @param  {object}     [options] 如果想忽略开始边界上的调用，传入{leading: false}。 绑定的函数先执行，而不是delay后后执行。
+ * @param  {boolean}    [options.leading=true] 如果想忽略开始边界上的调用，传入{leading: false}。
+ * @param  {boolean}    [options.trailing=true] 如果想忽略结尾边界上的调用，传入{trailing: false}
+ *
+ * @return {Function}
+ *
+ * @example
+ * const throttleCallback = throttle(callback, 100);
+ *
+
+export default function throttle(func: Function, wait: number, options: any = {}): any {
+    let context: any;
+    let args: any;
+    let result: any;
+    let timeout: any = null;
+    // 上次执行时间点
+    let previous = 0;
+    // 延迟执行函数
+    const later = () => {
+        // 若设定了开始边界不执行选项，上次执行时间始终为0
+        previous = options.leading === false ? 0 : +new Date();
+        timeout = null;
+        result = func.apply(context, args);
+        if (!timeout) {
+            context = args = null;
+        }
+    };
+    return function f(this: any) {
+        const now = +new Date();
+        // 首次执行时，如果设定了开始边界不执行选项，将上次执行时间设定为当前时间。
+        if (!previous && options.leading === false) {
+            previous = now;
+        }
+        // 延迟执行时间间隔
+        const remaining = wait - (now - previous);
+        context = this;
+        args = arguments; // eslint-disable-line
+        // 延迟时间间隔remaining小于等于0，表示上次执行至此所间隔时间已经超过一个时间窗口
+        // remaining大于时间窗口wait，表示客户端系统时间被调整过
+        if (remaining <= 0 || remaining > wait) {
+            clearTimeout(timeout);
+            timeout = null;
+            previous = now;
+            result = func.apply(context, args);
+            if (!timeout) {
+                context = args = null;
+            }
+            // 如果延迟执行不存在，且没有设定结尾边界不执行选项
+        } else if (!timeout && options.trailing !== false) {
+            timeout = setTimeout(later, remaining);
+        }
+        return result;
+    };
+}
+ */
+/*
+ * 频率控制 返回函数连续调用时，fn 执行频率限定为每多少时间执行一次
+ * @param fn {function}  需要调用的函数
+ * @param delay  {number}    延迟时间，单位毫秒
+ * @param immediate  {bool} 给 immediate参数传递false 绑定的函数先执行，而不是delay后后执行。
+ * @return {function}	实际调用函数
+ */
+export default function throttle(fn, delay, immediate, debounce) {
+    let curr = +new Date(), //当前时间
+    last_call = 0, last_exec = 0, timer = null, diff, //时间差
+    context, //上下文
+    args, exec = function () {
+        last_exec = curr;
+        fn.apply(context, args);
+    };
+    return function () {
+        curr = +new Date();
+        context = this;
+        args = arguments;
+        diff = curr - (debounce ? last_call : last_exec) - delay;
+        clearTimeout(timer);
+        if (debounce) {
+            if (immediate) {
+                timer = setTimeout(exec, delay);
+            }
+            else if (diff >= 0) {
+                exec();
+            }
+        }
+        else {
+            if (diff >= 0) {
+                exec();
+            }
+            else if (immediate) {
+                timer = setTimeout(exec, -diff);
+            }
+        }
+        last_call = curr;
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ecoding/components.antd",
-    "version": "0.1.16",
+    "version": "0.1.18",
     "author": "cxc",
     "homepage": "",
     "license": "MIT",
@@ -42,5 +42,5 @@
     "dependencies": {
         "react-quill": "^2.0.0"
     },
-    "gitHead": "73b80a6658132829238286362f933d177e8615b2"
+    "gitHead": "e8859f56f486b54a0ea0f4608bb410e497009da4"
 }