icarys-fc-vant 1.0.14 → 1.0.16

package/dist/vant/src/components/select.jsx

@@ -0,0 +1,81 @@
+import {computed, defineComponent, ref, toRef} from 'vue';
+import {normalizeOptions} from '../core/utils';
+
+const NAME = 'fcSelect';
+
+export default defineComponent({
+    name: NAME,
+    inheritAttrs: false,
+    props: {
+        disabled: Boolean,
+        placeholder: String,
+        columnsFieldNames: Object,
+        modelValue: [String, Number, Boolean],
+        options: Array,
+    },
+    emits: ['update:modelValue', 'fc.el', 'change'],
+    setup(props, _) {
+        const show = ref(false);
+        const modelValue = toRef(props, 'modelValue');
+        const fieldNames = toRef(props, 'columnsFieldNames', {});
+        const options = computed(() => {
+            if (fieldNames?.value?.text) {
+                return props.options || [];
+            } else {
+                return normalizeOptions(props.options || []);
+            }
+        })
+
+        const inputValue = computed(() => {
+            if (modelValue.value == null || modelValue.value === '') {
+                return '';
+            }
+            for (let i = 0; i < (options.value || []).length; i++) {
+                if (options.value[i][fieldNames.value.value || 'value'] === modelValue.value) {
+                    return options.value[i][fieldNames.value.text || 'text'];
+                }
+            }
+            return modelValue.value;
+        });
+
+        const onInput = (val) => {
+            _.emit('update:modelValue', val);
+            _.emit('change', val);
+        }
+
+        return {
+            show,
+            inputValue,
+            options,
+            open() {
+                if (props.disabled) {
+                    return;
+                }
+                show.value = true;
+            },
+            confirm({selectedValues}) {
+                onInput(selectedValues[0]);
+                show.value = false;
+            },
+        }
+    },
+    render() {
+        return <div class="_fc-select">
+            <van-field ref="el" placeholder={this.placeholder} readonly disabled={this.$props.disabled} onClick={this.open}
+                model-value={this.inputValue} isLink/>
+            <van-popup show={this.show} onUpdate:show={(v) => this.show = v} round position="bottom">
+                <van-picker
+                    {...this.$attrs}
+                    modelValue={[this.modelValue]}
+                    columnsFieldNames={this.columnsFieldNames}
+                    columns={this.options}
+                    onCancel={() => this.show = false}
+                    onConfirm={this.confirm}
+                />
+            </van-popup>
+        </div>
+    },
+    mounted() {
+        this.$emit('fc.el', this.$refs.el);
+    }
+});

package/dist/vant/src/components/timePicker.jsx

@@ -0,0 +1,76 @@
+import {computed, defineComponent, ref, toRef} from 'vue';
+
+const NAME = 'fcTimePicker';
+
+export default defineComponent({
+    name: NAME,
+    inheritAttrs: false,
+    props: {
+        disabled: Boolean,
+        clearable: Boolean,
+        placeholder: String,
+        modelValue: [String, Number],
+    },
+    emits: ['update:modelValue', 'fc.el', 'change'],
+    setup(props, _) {
+        const show = ref(false);
+        const modelValue = toRef(props, 'modelValue');
+
+        const formValue = computed(() => {
+            if (modelValue.value == null || modelValue.value === '') {
+                return [];
+            }
+            return modelValue.value.split(':');
+        });
+
+        const onInput = (val) => {
+            _.emit('update:modelValue', val);
+            _.emit('change', val);
+        }
+
+        return {
+            show,
+            formValue,
+            open() {
+                if (props.disabled) {
+                    return;
+                }
+                show.value = true;
+            },
+            confirm({selectedValues}) {
+                onInput(selectedValues.join(':'));
+                show.value = false;
+            },
+            clear(e) {
+                e.stopPropagation();
+                onInput('');
+            }
+        }
+    },
+    render() {
+        const clearIcon = () => {
+            return this.$props.clearable && this.modelValue ?
+                <i class="van-badge__wrapper van-icon van-icon-clear van-field__clear"
+                    onClick={this.clear}></i> : undefined;
+        }
+        return <div class="_fc-time-picker">
+            <van-field ref="el" placeholder={this.placeholder} readonly disabled={this.$props.disabled}
+                onClick={this.open}
+                model-value={this.modelValue} border={false} isLink v-slots={{
+                    'right-icon': clearIcon
+                }}/>
+            <van-popup show={this.show} onUpdate:show={(v) => this.show = v} round position="bottom">
+                <van-time-picker
+                    columnsType={['hour', 'minute']}
+                    {...this.$attrs}
+                    modelValue={this.formValue}
+                    onConfirm={this.confirm}
+                    onCancel={() => this.show = false}
+                />
+            </van-popup>
+        </div>
+    },
+    mounted() {
+        this.$emit('fc.el', this.$refs.el);
+    }
+});

package/dist/vant/src/components/uploader.jsx

@@ -0,0 +1,99 @@
+import {defineComponent, ref, toRef, watch} from 'vue';
+import toArray from '@form-create/utils/lib/toarray';
+
+const NAME = 'fcUploader';
+
+function parseFile(file, i) {
+    if (typeof file === 'object') {
+        return file;
+    }
+    return {
+        url: file,
+        is_string: true,
+        name: getFileName(file),
+        uid: i
+    };
+}
+
+function parseUpload(file) {
+    return {...file, file, value: file};
+}
+
+function getFileName(file) {
+    return ('' + file).split('/').pop()
+}
+
+export default defineComponent({
+    name: NAME,
+    inheritAttrs: false,
+    props: {
+        formCreateInject: Object,
+        modelValue: [Array, String, Object],
+        afterRead: Function,
+        action: String,
+        headers: Object,
+        method: String,
+        data: Object,
+        uploadName: String,
+        onSuccess: Function,
+        onError: Function,
+        maxCount: Number,
+    },
+    emits: ['update:modelValue', 'delete'],
+    setup(props, _) {
+
+        const afterRead = toRef(props, 'afterRead');
+        const modelValue = toRef(props, 'modelValue', []);
+
+        const fileList = ref(toArray(modelValue.value).map(parseFile).map(parseUpload));
+
+        watch(() => modelValue.value, (n) => {
+            fileList.value = toArray(n).map(parseFile).map(parseUpload);
+        })
+
+        const uploadValue = () => {
+            let files = fileList.value.map((v) => v.is_string ? v.url : (v.value || v.url)).filter((url) => url !== undefined);
+            _.emit('update:modelValue', props.maxCount === 1 ? (files[0] || '') : files);
+        };
+
+        return {
+            fileList,
+            modelValue,
+            onDelete(file) {
+                uploadValue();
+                _.emit('delete', file);
+            },
+            uploadFile(file) {
+                file.status = 'uploading';
+                if (afterRead.value) {
+                    return afterRead.value(file);
+                } else {
+                    const data = props.data || {};
+                    data[props.uploadName || 'file'] = file.file;
+                    props.formCreateInject.api.fetch({
+                        action: props.action,
+                        dataType: 'formData',
+                        source: 'upload',
+                        headers: props.headers || {},
+                        method: props.method || 'post',
+                        data
+                    }).then(res => {
+                        file.status = 'success';
+                        props.onSuccess && props.onSuccess(res, file);
+                        uploadValue();
+                    }).catch(e => {
+                        file.status = 'failed';
+                        file.message = this.formCreateInject.t('uploadFail') || '上传失败';
+                        props.onError && props.onError(e, file);
+                    });
+                }
+            }
+        }
+    },
+    render() {
+        return <van-uploader {...this.$attrs} model-value={this.fileList} maxCount={this.maxCount}
+            onUpdate:model-value={(v) => this.fileList = v}
+            afterRead={this.uploadFile} onDelete={this.onDelete} v-slots={this.$slots}/>
+    }
+
+});

package/dist/vant/src/core/alias.js

@@ -0,0 +1,31 @@
+const PRE = 'van';
+export default {
+    button: PRE + '-button',
+    icon: PRE + '-icon',
+    slider: PRE + '-slider',
+    stepper: PRE + '-stepper',
+    inputNumber: PRE + '-stepper',
+    rate: PRE + '-rate',
+    uploader: 'fc-uploader',
+    upload: 'fc-uploader',
+    cell: PRE + '-cell',
+    timePicker: 'fc-time-picker',
+    datePicker: 'fc-date-picker',
+    'switch': PRE + '-switch',
+    select: 'fc-select',
+    cascader: 'fc-cascader',
+    calendar: 'fc-calendar',
+    checkbox: 'fc-checkbox',
+    radio: 'fc-radio',
+    input: PRE + '-field',
+    textarea: PRE + '-field',
+    field: PRE + '-field',
+    formItem: PRE + '-field',
+    form: PRE + '-form',
+    col: PRE + '-col',
+    row: PRE + '-row',
+    group: 'fc-group',
+    array: 'fc-group',
+    object: 'fc-sub-form',
+    subForm: 'fc-sub-form',
+}

package/dist/vant/src/core/api.js

@@ -0,0 +1,135 @@
+import extend from '../../../utils/lib/extend';
+import is from '../../../utils/lib/type';
+import {invoke} from '@form-create/core/src/frame/util';
+import toArray from '../../../utils/lib/toarray';
+
+function tidyBtnProp(btn, def) {
+    if (is.Boolean(btn))
+        btn = {show: btn};
+    else if (!is.Undef(btn) && !is.Object(btn)) btn = {show: def};
+    return btn;
+}
+
+export default function extendApi(api, h) {
+    return {
+        formEl() {
+            return h.$manager.form();
+        },
+        wrapEl(id) {
+            const ctx = h.getFieldCtx(id);
+            if (!ctx) return;
+            return h.vm.refs[ctx.wrapRef];
+        },
+        validate(callback) {
+            return new Promise((resolve, reject) => {
+                const forms = api.children;
+                const all = [h.$manager.validate()];
+                forms.filter(v=>!v.isScope).forEach(v => {
+                    all.push(v.validate());
+                })
+                Promise.all(all).then(() => {
+                    resolve(true);
+                    callback && callback(true);
+                }).catch((e) => {
+                    reject(e);
+                    callback && callback(e);
+                    h.vm.emit('validate-fail', e, {api});
+                    h.emitEvent('validate-fail', e, {api});
+                })
+            });
+        },
+        validateField(field, callback) {
+            return new Promise((resolve, reject) => {
+                const ctx = h.getFieldCtx(field);
+                if (!ctx) return;
+                const sub = h.subForm[ctx.id];
+                const all = [h.$manager.validateField(ctx.id)];
+                toArray(sub).filter(v=>!v.isScope).forEach(v => {
+                    all.push(v.validate());
+                })
+                Promise.all(all).then(() => {
+                    resolve(null);
+                    callback && callback(null);
+                }).catch((e) => {
+                    reject(e);
+                    callback && callback(e);
+                    h.vm.emit('validate-field-fail', e, {field, api});
+                })
+            });
+        },
+        clearValidateState(fields, clearSub = true) {
+            api.helper.tidyFields(fields).forEach(field => {
+                if (clearSub) this.clearSubValidateState(field);
+                h.getCtxs(field).forEach(ctx => {
+                    h.$manager.clearValidateState(ctx);
+                });
+            });
+        },
+        clearSubValidateState(fields) {
+            api.helper.tidyFields(fields).forEach(field => {
+                h.getCtxs(field).forEach(ctx => {
+                    const subForm = h.subForm[ctx.id];
+                    if (!subForm) return;
+                    if (Array.isArray(subForm)) {
+                        subForm.forEach(form => {
+                            form.clearValidateState();
+                        })
+                    } else if (subForm) {
+                        subForm.clearValidateState();
+                    }
+                });
+            })
+        },
+        btn: {
+            loading: (loading = true) => {
+                api.submitBtnProps({loading: !!loading});
+            },
+            disabled: (disabled = true) => {
+                api.submitBtnProps({disabled: !!disabled});
+            },
+            show: (isShow = true) => {
+                api.submitBtnProps({show: !!isShow});
+            }
+        },
+        resetBtn: {
+            loading: (loading = true) => {
+                api.resetBtnProps({loading: !!loading});
+            },
+            disabled: (disabled = true) => {
+                api.resetBtnProps({disabled: !!disabled});
+            },
+            show: (isShow = true) => {
+                api.resetBtnProps({show: !!isShow});
+            }
+        },
+        submitBtnProps: (props = {}) => {
+            let btn = tidyBtnProp(h.options.submitBtn, true);
+            extend(btn, props);
+            h.options.submitBtn = btn;
+            api.refreshOptions();
+        },
+        resetBtnProps: (props = {}) => {
+            let btn = tidyBtnProp(h.options.resetBtn, false);
+            extend(btn, props);
+            h.options.resetBtn = btn;
+            api.refreshOptions();
+        },
+        submit(successFn, failFn) {
+            return new Promise((resolve, reject) => {
+                const promise = h.options.validateOnSubmit === false ? Promise.resolve() : api.validate();
+                promise.then(() => {
+                    let formData = api.formData();
+                    h.beforeSubmit(formData).then(() => {
+                        is.Function(successFn) && invoke(() => successFn(formData, api));
+                        is.Function(h.options.onSubmit) && invoke(() => h.options.onSubmit(formData, api));
+                        h.vm.emit('submit', formData, api);
+                        resolve(formData);
+                    }).catch((e) => {})
+                }).catch((...args) => {
+                    is.Function(failFn) && invoke(() => failFn(api, ...args));
+                    reject(...args)
+                })
+            });
+        },
+    };
+}

package/dist/vant/src/core/config.js

@@ -0,0 +1,35 @@
+export default function getConfig() {
+    return {
+        form: {
+            required: 'auto',
+            labelAlign: 'right',
+            inputAlign: 'right',
+        },
+        row: {
+            show: true,
+            gutter: 0,
+        },
+        submitBtn: {
+            type: 'primary',
+            loading: false,
+            disabled: false,
+            block: true,
+            innerText: '',
+            size: 'small',
+            show: true,
+            col: undefined,
+            click: undefined,
+        },
+        resetBtn: {
+            type: 'default',
+            loading: false,
+            disabled: false,
+            block: true,
+            innerText: '',
+            size: 'small',
+            show: false,
+            col: undefined,
+            click: undefined,
+        },
+    };
+}

package/dist/vant/src/core/index.js

@@ -0,0 +1,45 @@
+import components from '../components';
+import parsers from '../parsers';
+import alias from './alias';
+import manager from './manager';
+import FormCreateFactory from '../../../core/src/index';
+import '../style/index.css';
+import extendApi from './api';
+import required from './provider';
+import {Field} from 'vant';
+
+function install(FormCreate) {
+    FormCreate.componentAlias(alias);
+
+    components.forEach(component => {
+        FormCreate.component(component.name, component);
+    });
+
+    FormCreate.register(required);
+
+    parsers.forEach((parser) => {
+        FormCreate.parser(parser);
+    });
+
+    if (Field.props) {
+        Field.props.modelValue = {
+            type: [String, Number, Array, Object, Boolean, Function],
+            default: '',
+        };
+    }
+}
+
+export default function VantFormCreate() {
+    return FormCreateFactory({
+        ui: 'process.env.UI',
+        version: 'process.env.VERSION',
+        manager,
+        extendApi,
+        install,
+        isMobile: true,
+        attrs: {
+            normal: ['col', 'wrap'],
+            key: ['title', 'info'],
+        }
+    });
+}