@vunk/form 0.0.0-alpha.5 → 0.0.0-alpha.8

package/components/config/index.js

@@ -1,6 +1,6 @@
 import { _VkConfigRendererCtx, VkfConfigRenderer } from '@vunk/form/components/config-renderer';
 import { bindPropsFactory, onEmitsFactory } from 'vunk/shared/utils-vue';
-import { defineComponent, resolveComponent, openBlock, createBlock, normalizeProps, guardReactiveProps, withCtx, createVNode, mergeProps, renderSlot } from 'vue';
+import { defineComponent, resolveComponent, openBlock, createBlock, normalizeProps, guardReactiveProps, withCtx, renderSlot } from 'vue';
 import { VkfConfigRendererTemplate } from '@vunk/form/components/config-renderer-template';
 import { VkfInputConfig } from '@vunk/form/components/input-config';
 
@@ -44,24 +44,9 @@ var script = defineComponent({
 });
 
 function render(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_VkfInputConfig = resolveComponent("VkfInputConfig");
-  const _component_VkfConfigRendererTemplate = resolveComponent("VkfConfigRendererTemplate");
   const _component_VkfConfigRenderer = resolveComponent("VkfConfigRenderer");
   return openBlock(), createBlock(_component_VkfConfigRenderer, normalizeProps(guardReactiveProps(_ctx.configRendererProps)), {
     default: withCtx(() => [
-      createVNode(_component_VkfConfigRendererTemplate, { type: "VkfInput" }, {
-        default: withCtx(({ data: sourceData }) => [
-          createVNode(_component_VkfInputConfig, mergeProps(sourceData, {
-            data: _ctx.data,
-            onSetData: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("setData", $event)),
-            "onUpdate:propDisabled": _cache[1] || (_cache[1] = ($event) => _ctx.$emit("setData:source", {
-              k: "propDisabled",
-              v: $event
-            }))
-          }), null, 16, ["data"])
-        ]),
-        _: 1
-      }),
       renderSlot(_ctx.$slots, "rendererTemplate")
     ]),
     _: 3

package/components/config-renderer/index.js

@@ -31,6 +31,7 @@ var script = defineComponent({
           data: slotData,
           raw: c
         });
+        console.log(nodes);
         return nodes;
       }
     };

package/components/confirm-input/index.css

@@ -1,9 +1,9 @@
-
-.vkf-confirm-input .el-input-group__append {
-  cursor: initial;
-}
-
-.vkf-confirm-input .vkf-confirm-input-icon {
-  color: var(--el-color-primary);
-  cursor: pointer;
-}
+
+.vkf-confirm-input .el-input-group__append {
+  cursor: initial;
+}
+
+.vkf-confirm-input .vkf-confirm-input-icon {
+  color: var(--el-color-primary);
+  cursor: pointer;
+}

package/components/confirm-input/index.js

@@ -1,5 +1,5 @@
 import { _VkfInputCtx, VkfInput } from '@vunk/form/components/input';
-import { defineComponent, openBlock, createElementBlock, createElementVNode, ref, watch, h, resolveComponent, createBlock, mergeProps, toHandlers } from 'vue';
+import { defineComponent, openBlock, createElementBlock, createElementVNode, ref, watch, computed, h, resolveComponent, createBlock, mergeProps, toHandlers } from 'vue';
 import { ElButton, ElIcon } from 'element-plus';
 
 const props = {
@@ -7,6 +7,14 @@ const props = {
   inputSlot: {
     type: Object,
     default: () => ({})
+  },
+  disabled: {
+    type: Boolean,
+    default: void 0
+  },
+  validateUpdate: {
+    type: Function,
+    default: () => () => true
   }
 };
 const emits = {
@@ -79,21 +87,39 @@ var script = defineComponent({
     watch(() => props2.modelValue, (v) => {
       inputValue.value = v;
     });
+    const _disabled = ref(true);
+    const disabled = computed({
+      get() {
+        return props2.disabled ?? _disabled.value;
+      },
+      set(v) {
+        _disabled.value = v;
+        emit("update:disabled", v);
+      }
+    });
     const appendEl = () => h(ElButton, {
       onClick: () => {
-        if (!props2.disabled) {
-          emit("update:modelValue", inputValue.value);
+        if (!disabled.value) {
+          if (inputValue.value === props2.modelValue) {
+            disabled.value = true;
+            return;
+          }
+          if (props2.validateUpdate(inputValue.value)) {
+            emit("update:modelValue", inputValue.value);
+            disabled.value = true;
+          }
         } else {
-          emit("update:disabled", false);
+          disabled.value = false;
         }
       }
     }, () => h(ElIcon, {
       class: "vkf-confirm-input-icon",
       size: 16
-    }, () => h(props2.disabled ? edit : check)));
+    }, () => h(disabled.value ? edit : check)));
     return {
       inputProps,
       appendEl,
+      disabled,
       inputEmits,
       inputValue
     };
@@ -109,9 +135,8 @@ function render(_ctx, _cache, $props, $setup, $data, $options) {
     inputSlots: {
       append: _ctx.appendEl,
       ..._ctx.inputSlot
-    },
-    disabled: _ctx.disabled
-  }, _ctx.inputProps, toHandlers(_ctx.inputEmits)), null, 16, ["modelValue", "inputSlots", "disabled"]);
+    }
+  }, _ctx.inputProps, toHandlers(_ctx.inputEmits), { disabled: _ctx.disabled }), null, 16, ["modelValue", "inputSlots", "disabled"]);
 }
 
 script.render = render;

package/components/confirm-input/src/ctx.d.ts

@@ -7,6 +7,14 @@ export declare const props: {
         }>;
         default: () => {};
     };
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    validateUpdate: {
+        type: PropType<(v?: any) => boolean | undefined>;
+        default: () => () => boolean;
+    };
     inputSlots: {
         type: PropType<import("../../input/src/types").InputSlots>;
         default: undefined;
@@ -18,7 +26,6 @@ export declare const props: {
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
-    disabled: BooleanConstructor;
     modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;
     type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "text", boolean>;
     resize: {

package/components/confirm-input/src/index.vue.d.ts

@@ -6,6 +6,14 @@ declare const _default: import("vue").DefineComponent<{
         }>;
         default: () => {};
     };
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    validateUpdate: {
+        type: import("vue").PropType<(v?: any) => boolean | undefined>;
+        default: () => () => boolean;
+    };
     inputSlots: {
         type: import("vue").PropType<import("../../input/src/types").InputSlots>;
         default: undefined;
@@ -17,7 +25,6 @@ declare const _default: import("vue").DefineComponent<{
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
-    disabled: BooleanConstructor;
     modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;
     type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "text", boolean>;
     resize: {
@@ -128,6 +135,7 @@ declare const _default: import("vue").DefineComponent<{
     appendEl: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
         [key: string]: any;
     }>;
+    disabled: import("vue").WritableComputedRef<boolean>;
     inputEmits: {
         "update:modelValue": ((event: "update:modelValue", value: string) => void) & ((event: "input", value: string) => void) & ((event: "change", value: string) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "clear") => void) & ((event: "mouseleave", evt: MouseEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void) & ((event: "keydown", evt: Event | KeyboardEvent) => void) & ((event: "compositionstart", evt: CompositionEvent) => void) & ((event: "compositionupdate", evt: CompositionEvent) => void) & ((event: "compositionend", evt: CompositionEvent) => void) & ((event: "update:disabled", e: boolean) => void);
         input: ((event: "update:modelValue", value: string) => void) & ((event: "input", value: string) => void) & ((event: "change", value: string) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "clear") => void) & ((event: "mouseleave", evt: MouseEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void) & ((event: "keydown", evt: Event | KeyboardEvent) => void) & ((event: "compositionstart", evt: CompositionEvent) => void) & ((event: "compositionupdate", evt: CompositionEvent) => void) & ((event: "compositionend", evt: CompositionEvent) => void) & ((event: "update:disabled", e: boolean) => void);
@@ -165,6 +173,14 @@ declare const _default: import("vue").DefineComponent<{
         }>;
         default: () => {};
     };
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    validateUpdate: {
+        type: import("vue").PropType<(v?: any) => boolean | undefined>;
+        default: () => () => boolean;
+    };
     inputSlots: {
         type: import("vue").PropType<import("../../input/src/types").InputSlots>;
         default: undefined;
@@ -176,7 +192,6 @@ declare const _default: import("vue").DefineComponent<{
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
-    disabled: BooleanConstructor;
     modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;
     type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "text", boolean>;
     resize: {
@@ -293,5 +308,6 @@ declare const _default: import("vue").DefineComponent<{
         type: import("vue").PropType<import("../../input/src/types").InputSlots>;
         default: undefined;
     };
+    validateUpdate: (v?: any) => boolean | undefined;
 }>;
 export default _default;

package/components/date-picker/index.d.ts

@@ -0,0 +1,4 @@
+import VkfDatePicker from './src/index.vue';
+export * as __VkfDatePicker from './src/types';
+export { VkfDatePicker, };
+export default VkfDatePicker;

package/components/date-picker/index.js

@@ -0,0 +1,81 @@
+import { _VkfFormItemCtx, VkfFormItem } from '@vunk/form/components/form-item';
+import { datePickerProps, datePickerEmits as datePickerEmits$1 } from '@vunk/form/shared/element-plus/instances/date-picker';
+import { defineComponent, resolveComponent, openBlock, createBlock, normalizeProps, guardReactiveProps, withCtx, createVNode, mergeProps, toHandlers, createSlots, renderList, resolveDynamicComponent } from 'vue';
+import { ElDatePicker } from 'element-plus';
+import { createDatePickerBindProps, createDatePickerOnEmits } from '@vunk/form/shared/element-plus/ctx';
+
+const props = {
+  ..._VkfFormItemCtx.props,
+  ...datePickerProps,
+  datePickerSlots: {
+    type: Object,
+    default: void 0
+  }
+};
+const emits = {
+  ...datePickerEmits$1
+};
+
+var script = defineComponent({
+  name: "VkfDatePicker",
+  components: {
+    VkfFormItem,
+    ElDatePicker
+  },
+  emits,
+  props,
+  setup(props2, { emit }) {
+    const formItemBindProps = _VkfFormItemCtx.createBindProps(props2);
+    const datePickerBindProps = createDatePickerBindProps(props2, ["type"]);
+    const datePickerOnEmits = createDatePickerOnEmits(emit);
+    return {
+      formItemBindProps,
+      datePickerBindProps,
+      datePickerOnEmits
+    };
+  }
+});
+
+function render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ElDatePicker = resolveComponent("ElDatePicker");
+  const _component_VkfFormItem = resolveComponent("VkfFormItem");
+  return openBlock(), createBlock(_component_VkfFormItem, normalizeProps(guardReactiveProps(_ctx.formItemBindProps)), {
+    default: withCtx(() => [
+      createVNode(_component_ElDatePicker, mergeProps(_ctx.datePickerBindProps, { type: _ctx.type }, toHandlers(_ctx.datePickerOnEmits)), createSlots({ _: 2 }, [
+        renderList(_ctx.datePickerSlots, (item, key) => {
+          return {
+            name: key,
+            fn: withCtx((e) => [
+              (openBlock(), createBlock(resolveDynamicComponent(item?.(e))))
+            ])
+          };
+        })
+      ]), 1040, ["type"])
+    ]),
+    _: 1
+  }, 16);
+}
+
+script.render = render;
+script.__file = "date-picker/src/index.vue";
+
+const datePickerEmits = {
+  "update:modelValue": null,
+  "change": null,
+  "focus": null,
+  "blur": null,
+  "calendar-change": null,
+  "panel-change": null,
+  "visible-change": null
+};
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  datePickerEmits: datePickerEmits
+});
+
+script.install = (app) => {
+  app.component(script.name, script);
+};
+
+export { script as VkfDatePicker, types as __VkfDatePicker, script as default };

package/components/date-picker/src/ctx.d.ts

@@ -0,0 +1,131 @@
+import { PropType } from 'vue';
+import { DatePickerSlots } from './types';
+export declare const props: {
+    datePickerSlots: {
+        type: PropType<DatePickerSlots>;
+        default: undefined;
+    };
+    type: {
+        type: PropType<"date" | "year" | "month" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange">;
+        default: string;
+    };
+    id: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").SingleOrRange<string> & {}) | (() => import("element-plus").SingleOrRange<string>) | ((new (...args: any[]) => import("element-plus").SingleOrRange<string> & {}) | (() => import("element-plus").SingleOrRange<string>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    name: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").SingleOrRange<string> & {}) | (() => import("element-plus").SingleOrRange<string>) | ((new (...args: any[]) => import("element-plus").SingleOrRange<string> & {}) | (() => import("element-plus").SingleOrRange<string>))[], unknown, unknown, "", boolean>;
+    popperClass: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    format: StringConstructor;
+    valueFormat: StringConstructor;
+    clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    clearIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown, import("vue").DefineComponent<{}, {}, {}, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>, boolean>;
+    editable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    prefixIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown, "", boolean>;
+    size: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    disabled: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    placeholder: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    popperOptions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>) | ((new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>))[], unknown, unknown, () => {}, boolean>;
+    modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").ModelValueType & {}) | (() => import("element-plus").ModelValueType) | ((new (...args: any[]) => import("element-plus").ModelValueType & {}) | (() => import("element-plus").ModelValueType))[], unknown, unknown, "", boolean>;
+    rangeSeparator: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "-", boolean>;
+    startPlaceholder: StringConstructor;
+    endPlaceholder: StringConstructor;
+    defaultValue: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => import("element-plus").SingleOrRange<Date>) | ((new (...args: any[]) => Date | [Date, Date]) | (() => import("element-plus").SingleOrRange<Date>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    defaultTime: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => import("element-plus").SingleOrRange<Date>) | ((new (...args: any[]) => Date | [Date, Date]) | (() => import("element-plus").SingleOrRange<Date>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    isRange: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    disabledHours: {
+        readonly type: PropType<Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabledMinutes: {
+        readonly type: PropType<Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabledSeconds: {
+        readonly type: PropType<Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabledDate: {
+        readonly type: PropType<Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    cellClassName: {
+        readonly type: PropType<Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    shortcuts: import("element-plus/es/utils").EpPropFinalized<ArrayConstructor, unknown, unknown, () => never[], boolean>;
+    arrowControl: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    label: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    tabindex: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown, 0, boolean>;
+    validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    unlinkPanels: BooleanConstructor;
+    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    rules: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    inlineMessage: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+    showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    prop: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    error: StringConstructor;
+    validateStatus: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    for: StringConstructor;
+    formItemSize: {
+        type: PropType<"small" | "default" | "large">;
+        default: string;
+    };
+    formItemSlots: {
+        type: PropType<import("../../form-item/src/types").FormItemSlots>;
+        default: undefined;
+    };
+};
+export declare const emits: {
+    'update:modelValue': null;
+    change: null;
+    focus: null;
+    blur: null;
+    'calendar-change': null;
+    'panel-change': null;
+    'visible-change': null;
+    keydown: null;
+};