icarys-fc-vant 1.0.14 → 1.0.16

package/dist/core/src/factory/context.js

@@ -0,0 +1,264 @@
+import unique from '../../../utils/lib/unique';
+import toCase from '../../../utils/lib/tocase';
+import extend from '../../../utils/lib/extend';
+import {enumerable, invoke, mergeRule} from '../frame/util';
+import {deepCopy} from '../../../utils/lib/deepextend';
+import {markRaw, reactive} from 'vue';
+import is from '../../../utils/lib/type';
+import toArray from '../../../utils/lib/toarray';
+
+function bind(ctx) {
+    Object.defineProperties(ctx.origin, {
+        __fc__: enumerable(markRaw(ctx), true)
+    });
+    if(ctx.rule !== ctx.origin) {
+        Object.defineProperties(ctx.rule, {
+            __fc__: enumerable(markRaw(ctx), true)
+        });
+    }
+}
+
+export default function RuleContext(handle, rule, defaultValue) {
+    const id = unique();
+    const isInput = !!rule.field;
+    extend(this, {
+        id,
+        ref: id,
+        wrapRef: id + 'fi',
+        rule,
+        origin: rule.__origin__ || rule,
+        name: rule.name,
+        pending: {},
+        none: false,
+        watch: [],
+        linkOn: [],
+        root: [],
+        ctrlRule: [],
+        children: [],
+        parent: null,
+        group: rule.subRule ? this : null,
+        cacheConfig: null,
+        prop: {...rule},
+        computed: {},
+        payload: {},
+        refRule: {},
+        input: isInput,
+        el: undefined,
+        exportEl: undefined,
+        defaultValue: isInput ? deepCopy(defaultValue) : undefined,
+        field: rule.field || undefined
+    })
+
+    this.updateKey();
+    bind(this);
+    this.update(handle, true);
+}
+
+extend(RuleContext.prototype, {
+    getParentGroup() {
+        let ctx = this.parent;
+        while (ctx) {
+            if (ctx.group) {
+                return ctx;
+            }
+            ctx = ctx.parent;
+        }
+    },
+    loadChildrenPending() {
+        const children = this.rule.children || [];
+        if (Array.isArray(children))
+            return children;
+        return this.loadPending({
+            key: 'children', origin: children, def: [],
+            onLoad: (data) => {
+                this.$handle && this.$handle.loadChildren(data, this);
+            }, onUpdate: (value, oldValue) => {
+                if (this.$handle) {
+                    value === oldValue ? this.$handle.loadChildren(value, this) : this.$handle.updateChildren(this, value, oldValue);
+                }
+            }, onReload: (value) => {
+                if (this.$handle) {
+                    this.$handle.updateChildren(this, [], value);
+                } else {
+                    delete this.pending.children;
+                }
+            }
+        });
+    },
+    loadPending(config) {
+        const {key, origin, def, onLoad, onReload, onUpdate} = config;
+
+        if (this.pending[key] && this.pending[key].origin === origin) {
+            return this.getPending(key, def);
+        }
+
+        delete this.pending[key];
+
+        let value = origin;
+        if (is.Function(origin)) {
+            let source = invoke(() => origin({
+                rule: this.rule, api: this.$api, update: (data) => {
+                    const value = data || def;
+                    const oldValue = this.getPending(key, def);
+                    this.setPending(key, origin, value);
+                    onUpdate && onUpdate(value, oldValue);
+                }, reload: () => {
+                    const oldValue = this.getPending(key, def);
+                    delete this.pending[key];
+                    onReload && onReload(oldValue);
+                    this.$api && this.$api.sync(this.rule);
+                }
+            }));
+            if (source && is.Function(source.then)) {
+                source.then((data) => {
+                    const value = data || def;
+                    this.setPending(key, origin, value);
+                    onLoad && onLoad(value);
+                    this.$api && this.$api.sync(this.rule);
+                }).catch(e => {
+                    console.error(e);
+                })
+                value = def;
+                this.setPending(key, origin, value);
+            } else {
+                value = source || def;
+                this.setPending(key, origin, value);
+                onLoad && onLoad(value);
+            }
+        }
+        return value;
+    },
+    getPending(key, def) {
+        return (this.pending[key] && this.pending[key].value) || def;
+    },
+    setPending(key, origin, value) {
+        this.pending[key] = {
+            origin,
+            value: reactive(value)
+        };
+    },
+    effectData(name) {
+        if (!this.payload[name]) {
+            this.payload[name] = {};
+        }
+        return this.payload[name];
+    },
+    clearEffectData(name) {
+        if (name === undefined) {
+            this.payload = {};
+        } else {
+            delete this.payload[name];
+        }
+    },
+    updateKey(flag) {
+        this.key = unique();
+        flag && this.parent && this.parent.updateKey(flag);
+    },
+    updateType() {
+        this.originType = this.rule.type;
+        this.type = toCase(this.rule.type);
+        this.trueType = this.$handle.getType(this.originType);
+    },
+    setParser(parser) {
+        this.parser = parser;
+        parser.init(this);
+    },
+    initProp() {
+        const rule = {...this.rule};
+        delete rule.children;
+        delete rule.validate;
+        this.prop = mergeRule({}, [rule, ...Object.keys(this.payload).map(k => this.payload[k]), this.computed]);
+        this.prop.validate = [...this.refRule?.__$validate?.value || [], ...this.prop.validate || []]
+    },
+    initNone() {
+        this.none = !(is.Undef(this.prop.display) || !!this.prop.display)
+    },
+    hasHidden() {
+        return (!!this.rule.hidden) || (this.parent ? this.parent.hasHidden() : false);
+    },
+    injectValidate() {
+        return this.prop.validate;
+    },
+    check(handle) {
+        return this.vm === handle.vm
+    },
+    unwatch() {
+        this.watch.forEach(un => un());
+        this.watch = [];
+        Object.keys(this.refRule).forEach(key => {
+            if (key.indexOf('__$') !== 0) {
+                delete this.refRule[key];
+            }
+        })
+    },
+    unlink() {
+        this.linkOn.forEach(un => un());
+        this.linkOn = [];
+    },
+    link() {
+        this.unlink();
+        this.$handle.appendLink(this);
+    },
+    watchTo() {
+        this.$handle.watchCtx(this);
+    },
+    delete() {
+        this.unwatch();
+        this.unlink();
+        this.rmCtrl();
+        if (this.parent) {
+            this.parent.children.splice(this.parent.children.indexOf(this) >>> 0, 1);
+        }
+        extend(this, {
+            deleted: true,
+            computed: {},
+            parent: null,
+            children: [],
+            cacheConfig: null,
+            none: false,
+        })
+    },
+    rmCtrl() {
+        this.ctrlRule.forEach(ctrl => ctrl.__fc__ && ctrl.__fc__.rm());
+        this.ctrlRule = [];
+    },
+    rm() {
+        const _rm = () => {
+            let index = this.root.indexOf(this.origin);
+            if (index > -1) {
+                this.root.splice(index, 1);
+                this.$handle && this.$handle.refresh();
+            }
+        }
+        if (this.deleted) {
+            _rm();
+            return;
+        }
+        this.$handle.noWatch(() => {
+            this.$handle.deferSyncValue(() => {
+                this.rmCtrl();
+                _rm();
+                this.$handle.rmCtx(this);
+                extend(this, {
+                    root: []
+                });
+            }, this.input);
+        });
+    },
+    update(handle, init) {
+        extend(this, {
+            deleted: false,
+            $handle: handle,
+            $render: handle.$render,
+            $api: handle.api,
+            vm: handle.vm,
+            vNode: handle.$render.vNode,
+            updated: false,
+            cacheValue: this.rule.value
+        });
+        !init && this.unwatch();
+        this.watchTo();
+        this.link();
+        this.updateType();
+    }
+})

package/dist/core/src/factory/creator.js

@@ -0,0 +1,63 @@
+import extend from '../../../utils/lib/extend';
+import is from '../../../utils/lib/type';
+import {attrs} from '../frame/attrs';
+import {copyRule, mergeRule} from '../frame/util';
+import {$set} from '../../../utils/lib/modify';
+
+export function baseRule() {
+    return {
+        props: {},
+        on: {},
+        options: [],
+        children: [],
+        hidden: false,
+        display: true,
+        value: undefined,
+    };
+}
+
+export function creatorFactory(name, init) {
+    return (title, field, value, props = {}) => {
+        const maker = new Creator(name, title, field, value, props);
+        if (init) {
+            if (is.Function(init)) init(maker);
+            else maker.props(init);
+        }
+        return maker;
+    };
+}
+
+export default function Creator(type, title, field, value, props) {
+    this._data = extend(baseRule(), {type, title, field, value, props: props || {}});
+    this.event = this.on;
+}
+
+extend(Creator.prototype, {
+    getRule() {
+        return this._data;
+    },
+    setProp(key, value) {
+        $set(this._data, key, value);
+        return this;
+    },
+    modelField(field) {
+        this._data.modelField = field;
+        return this;
+    },
+    _clone() {
+        const clone = new this.constructor();
+        clone._data = copyRule(this._data);
+        return clone;
+    },
+})
+
+export function appendProto(attrs) {
+    attrs.forEach(name => {
+        Creator.prototype[name] = function (key) {
+            mergeRule(this._data, {[name]: arguments.length < 2 ? key : {[key]: arguments[1]}})
+            return this;
+        };
+    });
+}
+
+appendProto(attrs());

package/dist/core/src/factory/maker.js

@@ -0,0 +1,17 @@
+import {creatorFactory} from './creator';
+
+const commonMaker = creatorFactory('');
+
+export function create(type, field, title) {
+    let make = commonMaker('', field);
+    make._data.type = type;
+    make._data.title = title;
+    return make;
+}
+
+export default function makerFactory() {
+    return {
+        create,
+        factory: creatorFactory
+    };
+}

package/dist/core/src/factory/manager.js

@@ -0,0 +1,87 @@
+import mergeProps from '../../../utils/lib/mergeprops';
+import unique from '../../../utils/lib/unique';
+import extend from '../../../utils/lib/extend';
+import {invoke} from '../frame/util';
+
+export function createManager(proto) {
+    class CustomManager extends Manager {
+    }
+
+    Object.assign(CustomManager.prototype, proto);
+    return CustomManager;
+}
+
+export default function Manager(handler) {
+    extend(this, {
+        $handle: handler,
+        vm: handler.vm,
+        options: {},
+        ref: 'fcForm',
+        mergeOptionsRule: {
+            normal: ['form', 'row', 'info', 'submitBtn', 'resetBtn']
+        }
+    });
+    this.updateKey();
+    this.init();
+}
+
+extend(Manager.prototype, {
+    __init() {
+        this.$render = this.$handle.$render;
+        this.$r = (...args) => this.$render.renderRule(...args);
+    },
+    updateKey() {
+        this.key = unique();
+    },
+    //TODO interface
+    init() {
+    },
+    update() {
+    },
+    beforeRender() {
+    },
+    form() {
+        return this.vm.refs[this.ref];
+    },
+    adapterValidate(validate, validator) {
+        validate.validator = (rule, value, callback) => {
+            return validator(value, callback);
+        }
+        return validate;
+    },
+    getSlot(name) {
+        const _fn = (vm) => {
+            if (vm) {
+                let slot = vm.slots[name];
+                if (slot) {
+                    return slot;
+                }
+                return _fn(vm.setupState.parent);
+            }
+            return undefined;
+        }
+        return _fn(this.vm);
+    },
+    mergeOptions(args, opt) {
+        return mergeProps(args.map(v => this.tidyOptions(v)), opt, this.mergeOptionsRule);
+    },
+    updateOptions(options) {
+        this.$handle.fc.targetFormDriver('updateOptions', options, {handle: this.$handle, api: this.$handle.api})
+        this.options = this.mergeOptions([options], this.getDefaultOptions());
+        this.update();
+    },
+    tidyOptions(options) {
+        return options;
+    },
+    tidyRule(ctx) {
+    },
+    mergeProp(ctx) {
+    },
+    getDefaultOptions() {
+        return {};
+    },
+    fieldChange(ctx, value, formValue, setFlag) {
+    },
+    render(children) {
+    }
+})

package/dist/core/src/factory/node.js

@@ -0,0 +1,89 @@
+import toLine from '../../../utils/lib/toline';
+import toString from '../../../utils/lib/tostring';
+import extend from '../../../utils/lib/extend';
+import {toProps} from '../frame/util';
+import {createVNode, getCurrentInstance, resolveComponent, resolveDirective, withDirectives} from 'vue';
+
+
+function tidyDirectives(directives) {
+    return Object.keys(directives).map(n => {
+        const data = directives[n];
+        const directive = resolveDirective(n);
+        if (!directive) return;
+        return [
+            directive, data.value, data.arg, data.modifiers
+        ]
+    }).filter(v => !!v);
+}
+
+function makeDirective(data, vn) {
+    let directives = data.directives;
+    if (!directives) return vn;
+    if (!Array.isArray(directives)) {
+        directives = [directives];
+    }
+    return withDirectives(vn, directives.reduce((lst, v) => {
+        return lst.concat(tidyDirectives(v));
+    }, []))
+}
+
+export function CreateNodeFactory() {
+
+    const aliasMap = {};
+
+    function CreateNode(handle) {
+        this.vm = handle.vm;
+        this.handle = handle;
+    }
+
+    extend(CreateNode.prototype, {
+        make(tag, data, children) {
+            return makeDirective(data, this.h(tag, toProps(data), children));
+        },
+        makeComponent(type, data, children) {
+            try {
+                return makeDirective(data, createVNode(type, toProps(data), children));
+            } catch (e) {
+                console.error(e);
+                return createVNode('');
+            }
+        },
+        h(tag, data, children) {
+            const vm = this.vm || getCurrentInstance();
+            const isNativeTag = vm.appContext.config.isNativeTag(tag);
+            const component = this.handle.fc.prop.components[tag];
+            if (!component && isNativeTag) {
+                delete data.formCreateInject;
+            }
+            try{
+                return createVNode(component || (isNativeTag ? tag : resolveComponent(tag)), data, children);
+            }catch (e){
+                console.error(e);
+                return createVNode('');
+            }
+        },
+        aliasMap
+    });
+
+    extend(CreateNode, {
+        aliasMap,
+        alias(alias, name) {
+            aliasMap[alias] = name;
+        },
+        use(nodes) {
+            Object.keys(nodes).forEach((k) => {
+                const line = toLine(k);
+                const lower = toString(k).toLocaleLowerCase();
+                const v = nodes[k];
+                CreateNode.alias(k, v);
+                [k, line, lower].forEach(n => {
+                    CreateNode.prototype[n] = function (data, children) {
+                        return this.make(aliasMap[k] || n, data, children);
+                    };
+                });
+            });
+        }
+    })
+
+    return CreateNode;
+}

package/dist/core/src/factory/parser.js

@@ -0,0 +1,28 @@
+const BaseParser = {
+    init(ctx) {
+    },
+    toFormValue(value, ctx) {
+        return value
+    },
+    toValue(formValue, ctx) {
+        return formValue;
+    },
+    mounted(ctx) {
+    },
+    render(children, ctx) {
+        if(ctx.$handle.fc.renderDriver && ctx.$handle.fc.renderDriver.defaultRender){
+            return ctx.$handle.fc.renderDriver.defaultRender(ctx, children);
+        }
+        return ctx.$render.defaultRender(ctx, children);
+    },
+    preview(children, ctx) {
+        if(ctx.$handle.fc.renderDriver && ctx.$handle.fc.renderDriver.defaultPreview){
+            return ctx.$handle.fc.renderDriver.defaultPreview(ctx, children);
+        }
+        return this.render(children, ctx);
+    },
+    mergeProp(ctx) {
+    }
+}
+
+export default BaseParser;