@bdsoft/element 1.1.0

package/package-form/core/frame/provider.js

@@ -0,0 +1,288 @@
+import {err} from '@bdsoft-element/utils/lib/console';
+import {byCtx, deepGet, invoke, parseFn} from './util';
+import is, {hasProperty} from '@bdsoft-element/utils/lib/type';
+import deepSet from '@bdsoft-element/utils/lib/deepset';
+import {deepCopy} from '@bdsoft-element/utils/lib/deepextend';
+import toArray from '@bdsoft-element/utils/lib/toarray';
+import debounce from '@bdsoft-element/utils/lib/debounce';
+
+const loadData = function (fc) {
+    const loadData = {
+        name: 'loadData',
+        _fn: [],
+        loaded(inject, rule, api) {
+            this.deleted(inject);
+            let attrs = toArray(inject.getValue());
+            const unwatchs = [];
+            attrs.forEach(attr => {
+                if (attr && (attr.attr || attr.template)) {
+                    let fn = (get) => {
+                        let value;
+                        if (attr.template) {
+                            value = fc.$handle.loadStrVar(attr.template, get);
+                        } else if (attr.handler && is.Function(attr.handler)) {
+                            value = attr.handler(get, rule, api);
+                        } else {
+                            value = get(attr.attr, attr.default);
+                        }
+                        if (attr.copy !== false) {
+                            value = deepCopy(value)
+                        }
+                        const _rule = (attr.modify ? rule : inject.getProp());
+                        if (attr.to === 'child') {
+                            if (_rule.children) {
+                                _rule.children[0] = value;
+                            } else {
+                                _rule.children = [value];
+                            }
+                        } else {
+                            deepSet(_rule, attr.to || 'options', value);
+                        }
+                        api.sync(rule);
+                    };
+                    let callback = (get) => fn(get);
+                    const unwatch = fc.watchLoadData(callback);
+                    fn = debounce(fn, attr.wait || 300)
+                    if (attr.watch !== false) {
+                        unwatchs.push(unwatch);
+                    } else {
+                        unwatch();
+                    }
+                }
+            })
+            this._fn[inject.id] = unwatchs;
+        },
+        deleted(inject) {
+            if (this._fn[inject.id]) {
+                this._fn[inject.id].forEach(un => {
+                    un();
+                })
+                delete this._fn[inject.id];
+            }
+            inject.clearProp();
+        },
+    };
+    loadData.watch = loadData.mounted;
+    return loadData;
+}
+
+const t = function (fc) {
+    const t = {
+        name: 't',
+        _fn: [],
+        loaded(inject, rule, api) {
+            this.deleted(inject);
+            let attrs = inject.getValue() || {};
+            const unwatchs = [];
+            Object.keys(attrs).forEach(key => {
+                const attr = attrs[key];
+                if (attr) {
+                    const isObj = typeof attr === 'object';
+                    let fn = (get) => {
+                        let value = fc.t(isObj ? attr.attr : attr, isObj ? attr.params : null, get);
+                        const _rule = ((isObj && attr.modify) ? rule : inject.getProp());
+                        if (key === 'child') {
+                            if (_rule.children) {
+                                _rule.children[0] = value;
+                            } else {
+                                _rule.children = [value];
+                            }
+                        } else {
+                            deepSet(_rule, key, value);
+                        }
+                        api.sync(rule);
+                    };
+                    let callback = (get) => fn(get);
+                    const unwatch = fc.watchLoadData(callback);
+                    fn = debounce(fn, attr.wait || 300)
+                    if (attr.watch !== false) {
+                        unwatchs.push(unwatch);
+                    } else {
+                        unwatch();
+                    }
+                }
+            })
+            this._fn[inject.id] = unwatchs;
+        },
+        deleted(inject) {
+            if (this._fn[inject.id]) {
+                this._fn[inject.id].forEach(un => {
+                    un();
+                })
+                delete this._fn[inject.id];
+            }
+            inject.clearProp();
+        },
+    };
+    t.watch = t.loaded;
+    return t;
+}
+
+const componentValidate = {
+    name: 'componentValidate',
+    load(attr, rule, api) {
+        let options = attr.getValue();
+        if (!options || options.method === false) {
+            attr.clearProp();
+            api.clearValidateState([rule.field]);
+        } else {
+            if (!is.Object(options)) {
+                options = {method: options};
+            }
+            const method = options.method;
+            delete options.method;
+            attr.getProp().validate = [{
+                ...options,
+                validator(...args) {
+                    const ctx = byCtx(rule);
+                    if (ctx) {
+                        return api.exec(ctx.id, is.String(method) ? method : 'formCreateValidate', ...args, {
+                            attr,
+                            rule,
+                            api
+                        });
+                    }
+                }
+            }];
+        }
+    },
+    watch(...args) {
+        componentValidate.load(...args);
+    }
+};
+
+
+const fetch = function (fc) {
+
+    function parseOpt(option) {
+        if (is.String(option)) {
+            option = {
+                action: option,
+                to: 'options'
+            }
+        }
+        return option;
+    }
+
+    function run(inject, rule, api) {
+        let option = inject.value;
+        fetchAttr.deleted(inject);
+        if (is.Function(option)) {
+            option = option(rule, api);
+        }
+        option = parseOpt(option);
+
+        const set = (val) => {
+            if (val === undefined) {
+                inject.clearProp();
+            } else {
+                deepSet(inject.getProp(), option.to || 'options', val);
+            }
+            if (val != null && option && option.key && fc.$handle.options.globalData[option.key]) {
+                fc.fetchCache.set(fc.$handle.options.globalData[option.key], {status: true, data: val});
+            }
+            api.sync(rule);
+        }
+
+        if (!option || (!option.action && !option.key)) {
+            set(undefined);
+            return;
+        }
+        option = deepCopy(option);
+        if (!option.to) {
+            option.to = 'options';
+        }
+
+        if (option.key) {
+            const item = fc.$handle.options.globalData[option.key];
+            if (!item) {
+                set(undefined);
+                return;
+            }
+            if (item.type === 'static') {
+                set(item.data);
+                return;
+            } else {
+                option = {...option, ...item}
+            }
+        }
+
+        const onError = option.onError;
+
+        const check = () => {
+            if (!inject.getValue()) {
+                inject.clearProp();
+                api.sync(rule);
+                return true;
+            }
+        }
+        fetchAttr._fn[inject.id] = fc.watchLoadData(debounce((get, change) => {
+            if (change && option.watch === false) {
+                return fetchAttr._fn[inject.id]();
+            }
+            const _option = fc.$handle.loadFetchVar(deepCopy(option), get);
+            const config = {
+                headers: {},
+                ..._option,
+                onSuccess(body, flag) {
+                    if (check()) return;
+                    let fn = (v) => flag ? v : (hasProperty(v, 'data') ? v.data : v);
+                    const parse = parseFn(_option.parse);
+                    if (is.Function(parse)) {
+                        fn = parse;
+                    } else if (parse && is.String(parse)) {
+                        fn = (v) => {
+                            return deepGet(v, parse);
+                        }
+                    }
+                    set(fn(body, rule, api));
+                    api.sync(rule);
+                },
+                onError(e) {
+                    set(undefined);
+                    if (check()) return;
+                    (onError || ((e) => err(e.message || 'fetch fail ' + _option.action)))(e, rule, api);
+                }
+            };
+            fc.$handle.beforeFetch(config, {rule, api}).then(() => {
+                if (is.Function(_option.action)) {
+                    _option.action(rule, api).then((val) => {
+                        config.onSuccess(val, true);
+                    }).catch((e) => {
+                        config.onError(e);
+                    });
+                    return;
+                }
+                invoke(() => fc.create.fetch(config, {inject, rule, api}));
+            });
+        }, option.wait || 600));
+    }
+
+    const fetchAttr = {
+        name: 'fetch',
+        _fn: [],
+        loaded(...args) {
+            run(...args);
+        },
+        watch(...args) {
+            run(...args);
+        },
+        deleted(inject) {
+            if (this._fn[inject.id]) {
+                this._fn[inject.id]();
+                delete this._fn[inject.id];
+            }
+            inject.clearProp();
+        },
+    };
+
+    return fetchAttr;
+}
+
+
+export default {
+    fetch,
+    loadData,
+    t,
+    componentValidate,
+};

package/package-form/core/frame/util.js

@@ -0,0 +1,274 @@
+import deepExtend from '@bdsoft-element/utils/lib/deepextend';
+import is from '@bdsoft-element/utils/lib/type';
+import mergeProps from '@bdsoft-element/utils/lib/mergeprops';
+import {arrayAttrs, normalAttrs} from './attrs';
+import {logError} from '@bdsoft-element/utils/lib/console';
+import {isVNode} from 'vue';
+import {upper} from '@bdsoft-element/utils/lib/toline';
+import toCase from '@bdsoft-element/utils/lib/tocase';
+
+export {parseJson, parseFn, toJson} from '@bdsoft-element/utils/lib/json';
+
+export function enumerable(value, writable) {
+    return {
+        value,
+        enumerable: false,
+        configurable: false,
+        writable: !!writable
+    }
+}
+
+//todo 优化位置
+export function copyRule(rule, mode) {
+    return copyRules([rule], mode || false)[0];
+}
+
+export function copyRules(rules, mode) {
+    return deepExtend([], [...rules], mode || false);
+}
+
+export function mergeRule(rule, merge) {
+    mergeProps(Array.isArray(merge) ? merge : [merge], rule, {array: arrayAttrs, normal: normalAttrs});
+    return rule;
+}
+
+export function getRule(rule) {
+    const r = is.Function(rule.getRule) ? rule.getRule() : rule;
+    if (!r.type) {
+        r.type = 'input';
+    }
+    return r;
+}
+
+export function mergeGlobal(target, merge) {
+    if (!target) return merge;
+    Object.keys(merge || {}).forEach((k) => {
+        if (merge[k]) {
+            target[k] = mergeRule(target[k] || {}, merge[k])
+        }
+    });
+    return target;
+}
+
+export function funcProxy(that, proxy) {
+    Object.defineProperties(that, Object.keys(proxy).reduce((initial, k) => {
+        initial[k] = {
+            get() {
+                return proxy[k]();
+            }
+        }
+        return initial;
+    }, {}))
+}
+
+export function byCtx(rule) {
+    return rule.__fc__ || (rule.__origin__ ? rule.__origin__.__fc__ : null)
+}
+
+/**
+ * 执行一个函数并捕获可能的错误
+ * @param {Function} fn - 要执行的函数
+ * @param {any} def - 如果函数执行过程中抛出错误，返回的默认值
+ * @returns {any} - 函数执行的结果，如果发生错误则返回默认值
+ */
+export function invoke(fn, def) {
+    try {
+        // 尝试执行传入的函数，并将结果赋值给 def
+        def = fn()
+    } catch (e) {
+        // 如果执行过程中抛出错误，使用 logError 函数记录错误信息
+        logError(e);
+    }
+    // 返回函数执行结果或默认值
+    return def;
+}
+
+
+
+export function makeSlotBag() {
+    const slotBag = {};
+
+    const slotName = (n) => n || 'default';
+
+    return {
+        setSlot(slot, vnFn) {
+            slot = slotName(slot);
+            if (!vnFn || (Array.isArray(vnFn) && vnFn.length))
+                return;
+            if (!slotBag[slot]) slotBag[slot] = [];
+            slotBag[slot].push(vnFn);
+        },
+        getSlot(slot, val) {
+            slot = slotName(slot);
+            const children = [];
+            (slotBag[slot] || []).forEach(fn => {
+                if (Array.isArray(fn)) {
+                    children.push(...fn);
+                } else if (is.Function(fn)) {
+                    const res = fn(...(val || []));
+                    if (Array.isArray(res)) {
+                        children.push(...res);
+                    } else {
+                        children.push(res);
+                    }
+                } else if (!is.Undef(fn)) {
+                    children.push(fn);
+                }
+            })
+            return children;
+        },
+        getSlots() {
+            const slots = {};
+            Object.keys(slotBag).forEach(k => {
+                slots[k] = (...args) => {
+                    return this.getSlot(k, args);
+                }
+            })
+            return slots
+        },
+        slotLen(slot) {
+            slot = slotName(slot);
+            return slotBag[slot] ? slotBag[slot].length : 0;
+        },
+        mergeBag(bag) {
+            if (!bag) return this;
+            const slots = is.Function(bag.getSlots) ? bag.getSlots() : bag;
+            if (Array.isArray(bag) || isVNode(bag)) {
+                this.setSlot(undefined, () => bag);
+            } else {
+                Object.keys(slots).forEach(k => {
+                    this.setSlot(k, slots[k]);
+                });
+            }
+
+            return this;
+        }
+    };
+}
+
+export function toProps(rule) {
+    const prop = {...(rule.props || {})};
+
+    Object.keys(rule.on || {}).forEach(k => {
+        if(k.indexOf('-') > 0) {
+            k = toCase(k);
+        }
+        const name = `on${upper(k)}`;
+        if (Array.isArray(prop[name])) {
+            prop[name] = [...prop[name], rule.on[k]];
+        } else if (prop[name]) {
+            prop[name] = [prop[name], rule.on[k]];
+        } else {
+            prop[name] = rule.on[k];
+        }
+    })
+    prop.key = rule.key;
+    prop.ref = rule.ref;
+    prop.class = rule.class;
+    prop.id = rule.id;
+    prop.style = rule.style;
+    if (prop.slot) delete prop.slot;
+
+    return prop;
+}
+
+export function setPrototypeOf(o, proto) {
+    Object.setPrototypeOf(o, proto);
+    return o;
+}
+
+
+const changeType = (a, b) => {
+    if (typeof a === 'string') {
+        return String(b);
+    } else if (typeof a === 'number') {
+        return Number(b);
+    }
+    return b;
+}
+
+export const condition = {
+    '==': (a, b) => {
+        return JSON.stringify(a) === JSON.stringify(changeType(a, b));
+    },
+    '!=': (a, b) => {
+        return !condition['=='](a, b);
+    },
+    '>': (a, b) => {
+        return a > b;
+    },
+    '>=': (a, b) => {
+        return a >= b;
+    },
+    '<': (a, b) => {
+        return a < b;
+    },
+    '<=': (a, b) => {
+        return a <= b;
+    },
+    on(a, b) {
+        return a && a.indexOf && a.indexOf(changeType(a[0], b)) > -1;
+    },
+    notOn(a, b) {
+        return !condition.on(a, b);
+    },
+    in(a, b) {
+        return b && b.indexOf && b.indexOf(a) > -1;
+    },
+    notIn(a, b) {
+        return !condition.in(a, b);
+    },
+    between(a, b) {
+        return a > b[0] && a < b[1];
+    },
+    notBetween(a, b) {
+        return a < b[0] || a > b[1];
+    },
+    empty(a) {
+        return is.empty(a);
+    },
+    notEmpty(a) {
+        return !is.empty(a);
+    },
+    pattern(a, b) {
+        return new RegExp(b, 'g').test(a);
+    }
+};
+
+export function deepGet(val, split) {
+    (Array.isArray(split) ? split : (split || '').split('.')).forEach(k => {
+        if (val != null) {
+            val = val[k];
+        }
+    });
+    return val;
+}
+
+export function extractVar(str) {
+    const regex = /{{\s*(.*?)\s*}}/g;
+    let match;
+    const matches = {};
+    while ((match = regex.exec(str)) !== null) {
+        if (match[1]) {
+            matches[match[1]] = true;
+        }
+    }
+    return Object.keys(matches);
+}
+
+export function convertFieldToConditions(field) {
+    let parts = field.split('.');
+    let conditions = [];
+    let currentCondition = '';
+
+    parts.forEach((part, index) => {
+        if (index === 0) {
+            currentCondition = part;
+        } else {
+            currentCondition += '.' + part;
+        }
+        conditions.push(currentCondition);
+    });
+
+    return conditions.join(' && ');
+}