icarys-fc-vant 1.0.15 → 1.0.16

package/dist/core/src/frame/language.js

@@ -0,0 +1,50 @@
+export default  {
+    en: {
+        required: '{title} is required',
+        validate: {
+            url: '{title} is not a valid url',
+            email: '{title} is not a valid email',
+            ip: '{title} {title} is not a valid ip',
+            phone: '{title} {title} is not a valid phone',
+            pattern: '{title} does not match pattern {pattern}',
+            uppercase: '{title} must be all uppercase',
+            lowercase: '{title} must be all lowercased',
+            positive: '{title} is not a positive number',
+            negative: '{title} is not a negative number',
+            equal: '{title} is not equal to {equal}',
+            min: '{title} cannot be less than {min}',
+            max: '{title} cannot be greater than {max}',
+            enum: '{title} must be one of {enum}',
+            hasKeys: '{title} does not contain required fields {hasKeys}',
+            minLen: '{title} must be at least {minLen}',
+            maxLen: '{title} cannot be longer than {maxLen}',
+            len: '{title} must be exactly {len}',
+            integer: '{title} is not an integer',
+            number: '{title} is not an number',
+        }
+    },
+    'zh-cn': {
+        required: '{title}不能为空',
+        validate: {
+            url: '{title}不是有效的 url 地址',
+            email: '{title}不是有效的邮箱地址',
+            ip: '{title}不是有效的 IP 地址',
+            phone: '{title}不是正确的手机号',
+            pattern: '{title}必须匹配 {pattern}',
+            uppercase: '{title}必须全大写',
+            lowercase: '{title}必须全小写',
+            positive: '{title}不是正数',
+            negative: '{title}不是负数',
+            equal: '{title}必须等于 {equal}',
+            min: '{title}必须大于等于 {min}',
+            max: '{title}必须小于等于 {max}',
+            enum: '{title}必须是 {enum} 之一',
+            hasKeys: '{title}必须包含 {hasKeys} 字段',
+            minLen: '{title}长度必须大于 {minLen}',
+            maxLen: '{title}长度必须小于 {maxLen}',
+            len: '{title}长度必须为 {len}',
+            integer: '{title}必须为整数',
+            number: '{title}必须为数字',
+        },
+    }
+}

package/dist/core/src/frame/provider.js

@@ -0,0 +1,297 @@
+import {err} from '../../../utils/lib/console';
+import {byCtx, deepGet, invoke, parseFn} from './util';
+import is, {hasProperty} from '../../../utils/lib/type';
+import deepSet from '../../../utils/lib/deepset';
+import {deepCopy} from '../../../utils/lib/deepextend';
+import toArray from '../../../utils/lib/toarray';
+import debounce from '../../../utils/lib/debounce';
+import {nextTick} from 'vue';
+import {toPromise} from '@form-create/utils';
+
+const loadData = function (fc) {
+    const loadData = {
+        name: 'loadData',
+        _fn: [],
+        loaded(inject, rule, api) {
+            this.deleted(inject);
+            nextTick(() => {
+                let attrs = toArray(inject.getValue());
+                const unwatchs = [];
+                attrs.forEach(attr => {
+                    if (attr && (attr.attr || attr.template)) {
+                        let fn = (get) => {
+                            let group;
+                            if (rule && rule.__fc__) {
+                                group = rule.__fc__.getParentGroup();
+                            }
+                            let value;
+                            if (attr.template) {
+                                value = fc.$handle.loadStrVar(attr.template, get, group ? {rule, value: (fc.$handle.subRuleData[group.id] || {})} : null);
+                            } else if (attr.handler && is.Function(attr.handler)) {
+                                value = attr.handler(get, rule, api);
+                            } else {
+                                value = fc.$handle.loadStrVar(`{{${attr.attr}}}`, get, group ? {rule, value: (fc.$handle.subRuleData[group.id] || {})} : null);
+                            }
+                            if ((value == null || value === '') && attr.default != null) {
+                                value = 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.loaded;
+    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;
+            const validate = {
+                ...options,
+                validator(...args) {
+                    const ctx = byCtx(rule);
+                    if (ctx) {
+                        return api.exec(ctx.id, is.String(method) ? method : 'formCreateValidate', ...args, {
+                            attr,
+                            rule,
+                            api
+                        });
+                    }
+                }
+            };
+            delete validate.method;
+            attr.getProp().validate = [validate];
+        }
+    },
+    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';
+        }
+
+        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]();
+            }
+            if(option.key) {
+                fc.targetRule = rule;
+                const res = get('$globalData.' + option.key);
+                delete fc.targetRule;
+                if (res) {
+                    if (check()) return;
+                    set(res);
+                }
+                return ;
+            }
+            const _option = fc.$handle.loadFetchVar(deepCopy(option), get, rule);
+            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);
+                        }
+                    }
+                    toPromise(fn(body, rule, api)).then(res => {
+                        set(res);
+                    })
+                },
+                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)) {
+                    toPromise(_option.action(rule, api)).then((val) => {
+                        config.onSuccess(val, true);
+                    }).catch((e) => {
+                        config.onError(e);
+                    });
+                    return;
+                }
+                invoke(() => fc.create.fetch(config, {inject, rule, api}));
+            }).catch(e => {});
+        }, 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/dist/core/src/frame/util.js

@@ -0,0 +1,311 @@
+import deepExtend from '../../../utils/lib/deepextend';
+import is from '../../../utils/lib/type';
+import mergeProps from '../../../utils/lib/mergeprops';
+import {arrayAttrs, normalAttrs} from './attrs';
+import {logError} from '../../../utils/lib/console';
+import {isVNode} from 'vue';
+import {upper} from '../../../utils/lib/toline';
+import toCase from '../../../utils/lib/tocase';
+
+export {parseJson, parseFn, toJson} from '../../../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)
+}
+
+export function invoke(fn, def) {
+    try {
+        def = fn()
+    } catch (e) {
+        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(' && ');
+}
+
+export function parseTemplateToTree(template) {
+    const tokens = [];
+    let current = '';
+    let depth = 0;
+
+    for (let i = 0; i < template.length; i++) {
+        const char = template[i];
+
+        if (char === '[') {
+            if (depth === 0 && current) {
+                tokens.push({type: 'key', value: current});
+                current = '';
+            }
+            depth++;
+            current += char;
+        } else if (char === ']') {
+            depth--;
+            current += char;
+
+            if (depth === 0) {
+                tokens.push({
+                    type: 'bracket',
+                    value: parseTemplateToTree(current.slice(1, -1))
+                });
+                current = '';
+            }
+        } else if (char === '.' && depth === 0) {
+            if (current) {
+                tokens.push({type: 'key', value: current});
+                current = '';
+            }
+        } else {
+            current += char;
+        }
+    }
+
+    if (current) {
+        tokens.push({type: 'key', value: current});
+    }
+
+    return tokens.map(token => {
+        if (token.type === 'key') {
+            return {key: token.value};
+        } else {
+            return {children: token.value};
+        }
+    });
+}