icarys-form-create-vant 1.0.2 → 1.0.4

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

@@ -0,0 +1,63 @@
+import extend from '@form-create/utils/lib/extend';
+import is from '@form-create/utils/lib/type';
+import {attrs} from '../frame/attrs';
+import {copyRule, mergeRule} from '../frame/util';
+import {$set} from '@form-create/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/src/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/src/core/src/factory/manager.js

@@ -0,0 +1,87 @@
+import mergeProps from '@form-create/utils/lib/mergeprops';
+import unique from '@form-create/utils/lib/unique';
+import extend from '@form-create/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/src/core/src/factory/node.js

@@ -0,0 +1,89 @@
+import toLine from '@form-create/utils/lib/toline';
+import toString from '@form-create/utils/lib/tostring';
+import extend from '@form-create/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/src/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;