jky-component-lib 0.0.37 → 0.0.45

package/dist/es/_virtual/_plugin-vue_export-helper.js

@@ -0,0 +1,10 @@
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+export {
+  _export_sfc as default
+};

package/dist/es/components.d.ts

@@ -1,6 +1,7 @@
 import { Plugin } from 'vue';
 export * from './button';
 export * from './button-nav';
+export * from './form';
 export * from './menu';
 export * from './page-header';
 export * from './say-hello';

package/dist/es/components.js

@@ -1,5 +1,6 @@
 import { JkyButton } from "./button/index.js";
 import { JkyButtonNav } from "./button-nav/index.js";
+import { JkyForm } from "./form/index.js";
 import { JkyMenu } from "./menu/index.js";
 import { JkyPageHeader } from "./page-header/index.js";
 import { JkySayHello } from "./say-hello/index.js";
@@ -8,11 +9,13 @@ const components = [
   JkyButton,
   JkyButtonNav,
   JkyPageHeader,
-  JkyMenu
+  JkyMenu,
+  JkyForm
 ];
 export {
   JkyButton,
   JkyButtonNav,
+  JkyForm,
   JkyMenu,
   JkyPageHeader,
   JkySayHello,

package/dist/es/form/Form.vue.d.ts

@@ -0,0 +1,237 @@
+import { FormProps } from './types';
+type __VLS_Props = FormProps;
+declare function validate(callback?: (isValid: boolean, invalidFields?: any) => void): Promise<boolean>;
+declare function resetFields(): void;
+declare function clearValidate(props?: any): void;
+declare function getFormInstance(): ({
+    $: import('vue').ComponentInternalInstance;
+    $data: {};
+    $props: {
+        readonly model?: Record<string, any> | undefined;
+        readonly rules?: import('element-plus').FormRules | undefined;
+        readonly labelPosition?: "left" | "right" | "top" | undefined;
+        readonly requireAsteriskPosition?: "left" | "right" | undefined;
+        readonly labelWidth?: string | number | undefined;
+        readonly labelSuffix?: string | undefined;
+        readonly inline?: boolean | undefined;
+        readonly inlineMessage?: boolean | undefined;
+        readonly statusIcon?: boolean | undefined;
+        readonly showMessage?: boolean | undefined;
+        readonly validateOnRuleChange?: boolean | undefined;
+        readonly hideRequiredAsterisk?: boolean | undefined;
+        readonly scrollToError?: boolean | undefined;
+        readonly scrollIntoViewOptions?: (ScrollIntoViewOptions | boolean) | undefined;
+        readonly size?: import('element-plus').ComponentSize | undefined;
+        readonly disabled?: boolean | undefined;
+        readonly onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+    $attrs: import('vue').Attrs;
+    $refs: {
+        [x: string]: unknown;
+    };
+    $slots: Readonly<{
+        [name: string]: globalThis.Slot | undefined;
+    }>;
+    $root: ComponentPublicInstance | null;
+    $parent: ComponentPublicInstance | null;
+    $host: Element | null;
+    $emit: (event: "validate", prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => void;
+    $el: any;
+    $options: import('vue').ComponentOptionsBase<Readonly<import('element-plus').FormProps> & Readonly<{
+        onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined;
+    }>, {
+        validate: (callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+        validateField: (props?: import('element-plus/es/utils').Arrayable<import('element-plus').FormItemProp>, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+        resetFields: (props?: import('element-plus/es/utils').Arrayable<import('element-plus').FormItemProp>) => void;
+        clearValidate: (props?: import('element-plus/es/utils').Arrayable<import('element-plus').FormItemProp>) => void;
+        scrollToField: (prop: import('element-plus').FormItemProp) => void;
+        getField: (prop: import('element-plus').FormItemProp) => import('element-plus').FormItemContext | undefined;
+        fields: import('vue').Reactive<import('element-plus').FormItemContext[]>;
+        setInitialValues: (initModel: Record<string, any>) => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        validate: (prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => void;
+    }, string, {
+        scrollIntoViewOptions: ScrollIntoViewOptions | boolean;
+        labelWidth: string | number;
+        labelPosition: "left" | "right" | "top";
+        requireAsteriskPosition: "left" | "right";
+        labelSuffix: string;
+        showMessage: boolean;
+        validateOnRuleChange: boolean;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+        beforeCreate?: (() => void) | (() => void)[];
+        created?: (() => void) | (() => void)[];
+        beforeMount?: (() => void) | (() => void)[];
+        mounted?: (() => void) | (() => void)[];
+        beforeUpdate?: (() => void) | (() => void)[];
+        updated?: (() => void) | (() => void)[];
+        activated?: (() => void) | (() => void)[];
+        deactivated?: (() => void) | (() => void)[];
+        beforeDestroy?: (() => void) | (() => void)[];
+        beforeUnmount?: (() => void) | (() => void)[];
+        destroyed?: (() => void) | (() => void)[];
+        unmounted?: (() => void) | (() => void)[];
+        renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+        renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+        errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+    };
+    $forceUpdate: () => void;
+    $nextTick: typeof import('vue').nextTick;
+    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+} & Readonly<{
+    scrollIntoViewOptions: ScrollIntoViewOptions | boolean;
+    labelWidth: string | number;
+    labelPosition: "left" | "right" | "top";
+    requireAsteriskPosition: "left" | "right";
+    labelSuffix: string;
+    showMessage: boolean;
+    validateOnRuleChange: boolean;
+}> & Omit<Readonly<import('element-plus').FormProps> & Readonly<{
+    onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined;
+}>, "labelWidth" | "labelPosition" | "showMessage" | "validate" | "clearValidate" | "requireAsteriskPosition" | "labelSuffix" | "validateOnRuleChange" | "scrollIntoViewOptions" | "validateField" | "resetFields" | "scrollToField" | "getField" | "fields" | "setInitialValues"> & import('vue').ShallowUnwrapRef<{
+    validate: (callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+    validateField: (props?: import('element-plus/es/utils').Arrayable<import('element-plus').FormItemProp>, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+    resetFields: (props?: import('element-plus/es/utils').Arrayable<import('element-plus').FormItemProp>) => void;
+    clearValidate: (props?: import('element-plus/es/utils').Arrayable<import('element-plus').FormItemProp>) => void;
+    scrollToField: (prop: import('element-plus').FormItemProp) => void;
+    getField: (prop: import('element-plus').FormItemProp) => import('element-plus').FormItemContext | undefined;
+    fields: import('vue').Reactive<import('element-plus').FormItemContext[]>;
+    setInitialValues: (initModel: Record<string, any>) => void;
+}> & {} & import('vue').ComponentCustomProperties & {} & {
+    $slots: {
+        default?: (props: {}) => any;
+    };
+}) | undefined;
+type __VLS_PublicProps = {
+    modelValue: Record<string, any>;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {
+    validate: typeof validate;
+    resetFields: typeof resetFields;
+    clearValidate: typeof clearValidate;
+    getFormInstance: typeof getFormInstance;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (value: Record<string, any>) => any;
+    "update:modelValue": (value: Record<string, any>) => any;
+    validate: (result: {
+        valid: boolean;
+        fields?: any;
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onChange?: ((value: Record<string, any>) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: Record<string, any>) => any) | undefined;
+    onValidate?: ((result: {
+        valid: boolean;
+        fields?: any;
+    }) => any) | undefined;
+}>, {
+    size: import('element-plus').ComponentSize;
+    labelWidth: string | number;
+    labelPosition: "left" | "right" | "top";
+    showTitle: boolean;
+    gutter: number;
+    defaultSpan: number;
+    responsive: boolean;
+    watchDeep: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    formRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly model?: Record<string, any> | undefined;
+            readonly rules?: import('element-plus').FormRules | undefined;
+            readonly labelPosition?: "left" | "right" | "top" | undefined;
+            readonly requireAsteriskPosition?: "left" | "right" | undefined;
+            readonly labelWidth?: string | number | undefined;
+            readonly labelSuffix?: string | undefined;
+            readonly inline?: boolean | undefined;
+            readonly inlineMessage?: boolean | undefined;
+            readonly statusIcon?: boolean | undefined;
+            readonly showMessage?: boolean | undefined;
+            readonly validateOnRuleChange?: boolean | undefined;
+            readonly hideRequiredAsterisk?: boolean | undefined;
+            readonly scrollToError?: boolean | undefined;
+            readonly scrollIntoViewOptions?: (ScrollIntoViewOptions | boolean) | undefined;
+            readonly size?: import('element-plus').ComponentSize | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: globalThis.Slot | undefined;
+        }>;
+        $root: ComponentPublicInstance | null;
+        $parent: ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: "validate", prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => void;
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('element-plus').FormProps> & Readonly<{
+            onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined;
+        }>, {
+            validate: (callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+            validateField: (props?: import('element-plus/es/utils').Arrayable<import('element-plus').FormItemProp>, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+            resetFields: (props?: import('element-plus/es/utils').Arrayable<import('element-plus').FormItemProp>) => void;
+            clearValidate: (props?: import('element-plus/es/utils').Arrayable<import('element-plus').FormItemProp>) => void;
+            scrollToField: (prop: import('element-plus').FormItemProp) => void;
+            getField: (prop: import('element-plus').FormItemProp) => import('element-plus').FormItemContext | undefined;
+            fields: import('vue').Reactive<import('element-plus').FormItemContext[]>;
+            setInitialValues: (initModel: Record<string, any>) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            validate: (prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => void;
+        }, string, {
+            scrollIntoViewOptions: ScrollIntoViewOptions | boolean;
+            labelWidth: string | number;
+            labelPosition: "left" | "right" | "top";
+            requireAsteriskPosition: "left" | "right";
+            labelSuffix: string;
+            showMessage: boolean;
+            validateOnRuleChange: boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        scrollIntoViewOptions: ScrollIntoViewOptions | boolean;
+        labelWidth: string | number;
+        labelPosition: "left" | "right" | "top";
+        requireAsteriskPosition: "left" | "right";
+        labelSuffix: string;
+        showMessage: boolean;
+        validateOnRuleChange: boolean;
+    }> & Omit<Readonly<import('element-plus').FormProps> & Readonly<{
+        onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined;
+    }>, "labelWidth" | "labelPosition" | "showMessage" | "validate" | "clearValidate" | "requireAsteriskPosition" | "labelSuffix" | "validateOnRuleChange" | "scrollIntoViewOptions" | "validateField" | "resetFields" | "scrollToField" | "getField" | "fields" | "setInitialValues"> & import('vue').ShallowUnwrapRef<{
+        validate: (callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+        validateField: (props?: import('element-plus/es/utils').Arrayable<import('element-plus').FormItemProp>, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+        resetFields: (props?: import('element-plus/es/utils').Arrayable<import('element-plus').FormItemProp>) => void;
+        clearValidate: (props?: import('element-plus/es/utils').Arrayable<import('element-plus').FormItemProp>) => void;
+        scrollToField: (prop: import('element-plus').FormItemProp) => void;
+        getField: (prop: import('element-plus').FormItemProp) => import('element-plus').FormItemContext | undefined;
+        fields: import('vue').Reactive<import('element-plus').FormItemContext[]>;
+        setInitialValues: (initModel: Record<string, any>) => void;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            default?: (props: {}) => any;
+        };
+    }) | null;
+}, HTMLDivElement>;
+export default _default;

package/dist/es/form/Form.vue.js

@@ -0,0 +1,178 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { defineComponent, useModel, ref, computed, watch, openBlock, createElementBlock, normalizeClass, toDisplayString, createCommentVNode, createVNode, unref, mergeProps, withCtx, createElementVNode, normalizeStyle, Fragment, renderList, createBlock, mergeModels } from "vue";
+import { ElForm } from "element-plus";
+import _sfc_main$1 from "./FormItem.vue.js";
+/* empty css              */
+const _hoisted_1 = {
+  key: 0,
+  class: "jky-form__title mb-4 text-xl font-semibold"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues({}, {
+  name: "JkyForm"
+}), {
+  __name: "Form",
+  props: /* @__PURE__ */ mergeModels({
+    modelValue: {},
+    items: {},
+    showTitle: { type: Boolean, default: false },
+    title: {},
+    gutter: { default: 0 },
+    defaultSpan: { default: 24 },
+    responsive: { type: Boolean, default: true },
+    className: {},
+    readonly: { type: Boolean },
+    disabled: { type: Boolean },
+    watchDeep: { type: Boolean, default: true },
+    onValidate: {},
+    model: {},
+    rules: {},
+    labelPosition: { default: "right" },
+    requireAsteriskPosition: {},
+    labelWidth: { default: "100" },
+    labelSuffix: {},
+    inline: { type: Boolean },
+    inlineMessage: { type: Boolean },
+    statusIcon: { type: Boolean },
+    showMessage: { type: Boolean },
+    validateOnRuleChange: { type: Boolean },
+    hideRequiredAsterisk: { type: Boolean },
+    scrollToError: { type: Boolean },
+    scrollIntoViewOptions: { type: Boolean },
+    size: { default: "default" }
+  }, {
+    "modelValue": { required: true, default: () => ({}) },
+    "modelModifiers": {}
+  }),
+  emits: /* @__PURE__ */ mergeModels(["change", "validate"], ["update:modelValue"]),
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const modelValue = useModel(__props, "modelValue");
+    const formRef = ref();
+    const formClass = computed(() => {
+      return [
+        "jky-form",
+        props.className
+      ].filter(Boolean).join(" ");
+    });
+    watch(
+      () => props.modelValue,
+      (newVal, oldVal) => {
+        if (newVal !== oldVal) {
+          emit("change", __spreadValues({}, newVal));
+        }
+      },
+      { deep: props.watchDeep }
+    );
+    function validate(callback) {
+      return __async(this, null, function* () {
+        var _a;
+        try {
+          yield (_a = formRef.value) == null ? void 0 : _a.validate();
+          emit("validate", { valid: true });
+          callback == null ? void 0 : callback(true, void 0);
+          return true;
+        } catch (error) {
+          emit("validate", { valid: false, fields: error.fields });
+          callback == null ? void 0 : callback(false, error.fields);
+          return false;
+        }
+      });
+    }
+    function resetFields() {
+      var _a;
+      (_a = formRef.value) == null ? void 0 : _a.resetFields();
+    }
+    function clearValidate(props2) {
+      var _a;
+      (_a = formRef.value) == null ? void 0 : _a.clearValidate(props2);
+    }
+    function getFormInstance() {
+      return formRef.value;
+    }
+    __expose({
+      validate,
+      resetFields,
+      clearValidate,
+      getFormInstance
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(formClass.value)
+      }, [
+        __props.showTitle && __props.title ? (openBlock(), createElementBlock("div", _hoisted_1, toDisplayString(__props.title), 1)) : createCommentVNode("", true),
+        createVNode(unref(ElForm), mergeProps({
+          ref_key: "formRef",
+          ref: formRef,
+          model: modelValue.value,
+          "label-width": __props.labelWidth,
+          "label-position": __props.labelPosition,
+          size: __props.size
+        }, _ctx.$attrs), {
+          default: withCtx(() => [
+            createElementVNode("div", {
+              class: "grid",
+              style: normalizeStyle({
+                gridTemplateColumns: "repeat(12, minmax(0, 1fr))",
+                gap: `${__props.gutter}px`
+              })
+            }, [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(__props.items, (item) => {
+                return openBlock(), createBlock(_sfc_main$1, {
+                  key: item.field,
+                  field: item.field,
+                  config: item,
+                  model: modelValue.value,
+                  readonly: __props.readonly,
+                  disabled: __props.disabled
+                }, null, 8, ["field", "config", "model", "readonly", "disabled"]);
+              }), 128))
+            ], 4)
+          ]),
+          _: 1
+        }, 16, ["model", "label-width", "label-position", "size"])
+      ], 2);
+    };
+  }
+}));
+export {
+  _sfc_main as default
+};

package/dist/es/form/Form.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./Form.vue.js";
+/* empty css          */
+export {
+  _sfc_main as default
+};

package/dist/es/form/FormItem.vue.d.ts

@@ -0,0 +1,6 @@
+import { FormItemProps } from './types';
+declare const _default: import('vue').DefineComponent<FormItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<FormItemProps> & Readonly<{}>, {
+    disabled: boolean;
+    readonly: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;