@bdsoft/element 1.1.8 → 1.1.11

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

@@ -1,288 +0,0 @@
-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

@@ -1,274 +0,0 @@
-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(' && ');
-}