@aplus-frontend/ui 0.0.1-beta.0 → 0.0.1-beta.10

package/es/src/ap-form/ap-form-item.vue.d.ts

@@ -0,0 +1,68 @@
+import { ApFormItemProps } from './interface';
+import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes, PropType } from 'vue';
+
+type ApFormItemSlots = {
+    help: any;
+    label: any;
+    extra: any;
+    default(): VNode[];
+};
+declare function onFieldBlur(): void;
+declare function onFieldChange(): void;
+declare function clearValidate(): void;
+declare function resetField(): void;
+declare function getFieldValue(): any;
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ApFormItemProps>, {
+    hasFeedback: boolean;
+    colon: undefined;
+    autoLink: boolean;
+    required: undefined;
+    validateFirst: undefined;
+    bordered: boolean;
+    valuePropName: string;
+}>, {
+    onFieldBlur: typeof onFieldBlur;
+    onFieldChange: typeof onFieldChange;
+    clearValidate: typeof clearValidate;
+    resetField: typeof resetField;
+    getFieldValue: typeof getFieldValue;
+}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ApFormItemProps>, {
+    hasFeedback: boolean;
+    colon: undefined;
+    autoLink: boolean;
+    required: undefined;
+    validateFirst: undefined;
+    bordered: boolean;
+    valuePropName: string;
+}>>>, {
+    required: boolean;
+    bordered: boolean;
+    colon: boolean;
+    hasFeedback: boolean;
+    autoLink: boolean;
+    validateFirst: boolean;
+    valuePropName: string;
+}, {}>, Readonly<ApFormItemSlots> & ApFormItemSlots>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/src/ap-form/ap-form-item.vue.mjs

@@ -0,0 +1,144 @@
+import { defineComponent as z, useSlots as L, ref as i, computed as B, unref as o, onBeforeUpdate as T, cloneVNode as U, openBlock as b, createBlock as C, mergeProps as $, createSlots as j, withCtx as n, resolveDynamicComponent as q, createCommentVNode as D, createElementVNode as E, normalizeClass as K, createVNode as h, renderList as O, renderSlot as Q, normalizeProps as G, guardReactiveProps as H } from "vue";
+import { Form as J, Tooltip as W } from "ant-design-vue";
+import { isArray as X, omit as V } from "lodash-unified";
+import { apFormItemColPropKeys as Y } from "./constant.mjs";
+import { QuestionCircleOutlined as Z } from "@ant-design/icons-vue";
+import "../config-provider/index.mjs";
+import { useInjectForm as M } from "./context.mjs";
+import "./style/ap-form-item.css";
+import { useNamespace as ee } from "../config-provider/hooks/use-namespace.mjs";
+const ie = /* @__PURE__ */ z({
+  name: "ApFormItem",
+  __name: "ap-form-item",
+  props: {
+    htmlFor: {},
+    prefixCls: {},
+    label: {},
+    help: {},
+    extra: {},
+    labelCol: {},
+    wrapperCol: {},
+    hasFeedback: { type: Boolean, default: !1 },
+    colon: { type: Boolean, default: void 0 },
+    labelAlign: {},
+    prop: {},
+    name: {},
+    rules: {},
+    autoLink: { type: Boolean, default: !0 },
+    required: { type: Boolean, default: void 0 },
+    validateFirst: { type: Boolean, default: void 0 },
+    validateStatus: {},
+    validateTrigger: {},
+    messageVariables: {},
+    hidden: { type: Boolean },
+    noStyle: { type: Boolean },
+    tooltip: {},
+    span: {},
+    order: {},
+    offset: {},
+    push: {},
+    pull: {},
+    xs: {},
+    sm: {},
+    md: {},
+    lg: {},
+    xl: {},
+    xxl: {},
+    flex: {},
+    bordered: { type: Boolean, default: !1 },
+    valuePropName: { default: "value" }
+  },
+  setup(g, { expose: N }) {
+    var v;
+    const t = g, u = L(), { model: a, updateModel: s } = M(), { m: p } = ee("ap-form-item"), d = i(!1), l = i(), f = B(() => X(t.name) ? t.name.reduce((e, r) => e[r], o(a)) : a == null ? void 0 : a.value[t.name]), m = i((v = u.default()) == null ? void 0 : v[0]);
+    T(() => {
+      var e;
+      m.value = (e = u.default()) == null ? void 0 : e[0];
+    });
+    function k(e) {
+      s == null || s(t.name, e);
+    }
+    function x() {
+      d.value = !0;
+    }
+    function P() {
+      d.value = !1;
+    }
+    const c = B(() => {
+      var r;
+      const e = o(m);
+      return e ? U(e, {
+        [t.valuePropName]: o(f),
+        [`onUpdate:${t.valuePropName}`]: k,
+        bordered: t.bordered ? !1 : (r = e == null ? void 0 : e.props) == null ? void 0 : r.bordered,
+        onFocus: x,
+        onBlur: P
+      }) : null;
+    });
+    function I() {
+      var e;
+      (e = l.value) == null || e.onFieldBlur();
+    }
+    function S() {
+      var e;
+      (e = l.value) == null || e.onFieldChange();
+    }
+    function _() {
+      var e;
+      (e = l.value) == null || e.clearValidate();
+    }
+    function w() {
+      var e;
+      (e = l.value) == null || e.resetField();
+    }
+    function A() {
+      return o(f);
+    }
+    return N({
+      onFieldBlur: I,
+      onFieldChange: S,
+      clearValidate: _,
+      resetField: w,
+      getFieldValue: A
+    }), (e, r) => (b(), C(o(J).Item, $({
+      ref_key: "formItemRef",
+      ref: l
+    }, o(V)(t, [...o(Y), "tooltip"]), {
+      class: { [o(p)("bordered")]: e.bordered, [o(p)("focused")]: e.bordered && d.value },
+      colon: e.bordered ? !1 : t.colon
+    }), j({
+      default: n(() => [
+        c.value ? (b(), C(q(c.value), { key: 0 })) : D("", !0)
+      ]),
+      _: 2
+    }, [
+      t.tooltip ? {
+        name: "tooltip",
+        fn: n(({ class: y }) => [
+          E("span", {
+            class: K(y)
+          }, [
+            h(o(W), {
+              title: t.tooltip
+            }, {
+              default: n(() => [
+                h(o(Z), { style: { color: "#0070ff" } })
+              ]),
+              _: 1
+            }, 8, ["title"])
+          ], 2)
+        ]),
+        key: "0"
+      } : void 0,
+      O(o(V)(o(u), "default"), (y, F) => ({
+        name: F,
+        fn: n((R) => [
+          Q(e.$slots, F, G(H(R || {})))
+        ])
+      }))
+    ]), 1040, ["class", "colon"]));
+  }
+});
+export {
+  ie as default
+};

package/es/src/ap-form/ap-form-item.vue2.mjs

@@ -0,0 +1,4 @@
+import f from "./ap-form-item.vue.mjs";
+export {
+  f as default
+};

package/es/src/ap-form/ap-form-list.vue.d.ts

@@ -0,0 +1,36 @@
+import { ApFormListProps } from './interface';
+import { NamePath } from 'ant-design-vue/es/form/interface';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes, PropType } from 'vue';
+
+type FormListField = {
+    key: number;
+    name: NamePath;
+    value: any;
+    fieldName: number;
+};
+type FormListActions = {
+    add: (defaultValue?: any) => void;
+    remove: (name: number) => void;
+};
+type ApFormListSlots = {
+    default(props: {
+        fields: FormListField[];
+        actions: FormListActions;
+    }): any;
+};
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<__VLS_TypePropsToRuntimeProps<ApFormListProps>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<__VLS_TypePropsToRuntimeProps<ApFormListProps>>>, {}, {}>, Readonly<ApFormListSlots> & ApFormListSlots>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/src/ap-form/ap-form-list.vue.mjs

@@ -0,0 +1,41 @@
+import { defineComponent as v, computed as f, unref as u, renderSlot as k } from "vue";
+import { useInjectForm as F } from "./context.mjs";
+import { isArray as h } from "lodash-unified";
+const w = /* @__PURE__ */ v({
+  name: "ApFormList",
+  __name: "ap-form-list",
+  props: {
+    name: {}
+  },
+  setup(l) {
+    let s = 1;
+    const o = [], t = l, { model: a, updateModel: r } = F(), c = f(() => h(t.name) ? t.name.reduce((e, n) => e == null ? void 0 : e.value[n], a) : a == null ? void 0 : a.value[t.name]);
+    function p(e = void 0) {
+      const n = u(c) ? [...u(c), e] : [e];
+      o.push(s), s += 1, r == null || r(t.name, n);
+    }
+    function y(e) {
+      let n = u(c) || [];
+      n = [...n.slice(0, e), ...n.slice(e + 1)], o.splice(e, 1), r == null || r(t.name, n);
+    }
+    const _ = {
+      add: p,
+      remove: y
+    }, d = f(() => (u(c) || []).map((n, m) => {
+      let i = o[m];
+      return typeof i > "u" && (o[m] = s, i = s, s += 1), {
+        key: i,
+        fieldName: m,
+        name: [t.name, m],
+        value: n
+      };
+    }));
+    return (e, n) => k(e.$slots, "default", {
+      fields: d.value,
+      actions: _
+    });
+  }
+});
+export {
+  w as default
+};

package/es/src/ap-form/ap-form-list.vue2.mjs

@@ -0,0 +1,4 @@
+import f from "./ap-form-list.vue.mjs";
+export {
+  f as default
+};

package/es/src/ap-form/ap-form.vue.d.ts

@@ -0,0 +1,66 @@
+import { ApFormProps } from './interface';
+import { InternalNamePath, NamePath, ValidateOptions, FormLabelAlign } from 'ant-design-vue/es/form/interface';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes, PropType } from 'vue';
+
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ApFormProps>, {
+    layout: string;
+    hideRequiredMark: boolean;
+    colon: boolean;
+    labelAlign: string;
+    validateOnRuleChange: boolean;
+    validateTrigger: string;
+}>, {
+    resetFields: (name?: NamePath | undefined) => void;
+    clearValidate: (name?: NamePath | undefined) => void;
+    validateFields: (nameList?: string | NamePath[] | undefined, options?: ValidateOptions | undefined) => Promise<{
+        [key: string]: any;
+    }> | undefined;
+    getFieldsValue: (nameList?: true | InternalNamePath[] | undefined) => {
+        [key: string]: any;
+    } | undefined;
+    validate: (nameList?: string | NamePath[] | undefined, options?: ValidateOptions | undefined) => Promise<{
+        [key: string]: any;
+    }> | undefined;
+    scrollToField: (name: NamePath, options?: {}) => void;
+    setFieldsValue: (values: Record<string, any>) => void;
+    setFieldValue: (key: string, newValue: any) => void;
+}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ApFormProps>, {
+    layout: string;
+    hideRequiredMark: boolean;
+    colon: boolean;
+    labelAlign: string;
+    validateOnRuleChange: boolean;
+    validateTrigger: string;
+}>>>, {
+    layout: string;
+    validateTrigger: string | string[];
+    colon: boolean;
+    labelAlign: FormLabelAlign;
+    hideRequiredMark: boolean;
+    validateOnRuleChange: boolean;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/src/ap-form/ap-form.vue.mjs

@@ -0,0 +1,4 @@
+import f from "./ap-form.vue2.mjs";
+export {
+  f as default
+};

package/es/src/ap-form/ap-form.vue2.mjs

@@ -0,0 +1,89 @@
+import { defineComponent as u, ref as c, reactive as f, computed as p, openBlock as F, createBlock as m, unref as g, mergeProps as v, withCtx as h, renderSlot as V } from "vue";
+import { Form as y } from "ant-design-vue";
+import { useProvideForm as C } from "./context.mjs";
+import { isArray as B } from "lodash-unified";
+const S = /* @__PURE__ */ u({
+  __name: "ap-form",
+  props: {
+    initialValues: {},
+    layout: { default: "horizontal" },
+    labelCol: {},
+    wrapperCol: {},
+    colon: { type: Boolean, default: !0 },
+    labelAlign: { default: "right" },
+    labelWrap: { type: Boolean },
+    prefixCls: {},
+    requiredMark: {},
+    hideRequiredMark: { type: Boolean, default: !1 },
+    rules: {},
+    validateMessages: {},
+    validateOnRuleChange: { type: Boolean, default: !0 },
+    scrollToFirstError: {},
+    onSubmit: {},
+    name: {},
+    validateTrigger: { default: "change" },
+    size: {},
+    disabled: { type: Boolean },
+    onValuesChange: {},
+    onFieldsChange: {},
+    onFinish: {},
+    onFinishFailed: {},
+    onValidate: {}
+  },
+  setup(s, { expose: d }) {
+    const i = s;
+    function n(e, l) {
+      if (B(e)) {
+        let t = o;
+        for (let r = 0; r < e.length - 1; r++)
+          t = t[e[r]];
+        t[e[e.length - 1]] = l;
+      } else
+        o[e] = l;
+    }
+    const a = c(), o = f(i.initialValues || {});
+    return C({ model: p(() => o), updateModel: n }), d({
+      resetFields: (e) => {
+        var l;
+        (l = a.value) == null || l.resetFields(e);
+      },
+      clearValidate: (e) => {
+        var l;
+        (l = a.value) == null || l.clearValidate(e);
+      },
+      validateFields: (e, l) => {
+        var t;
+        return (t = a.value) == null ? void 0 : t.validateFields(e, l);
+      },
+      getFieldsValue: (e) => {
+        var l;
+        return (l = a.value) == null ? void 0 : l.getFieldsValue(e);
+      },
+      validate: (e, l) => {
+        var t;
+        return (t = a.value) == null ? void 0 : t.validate(e, l);
+      },
+      scrollToField: (e, l = {}) => {
+        var t;
+        (t = a.value) == null || t.scrollToField(e, l);
+      },
+      setFieldsValue: (e) => {
+        Object.assign(o, e);
+      },
+      setFieldValue: (e, l) => {
+        o[e] = l;
+      }
+    }), (e, l) => (F(), m(g(y), v({
+      ref_key: "formRef",
+      ref: a
+    }, i, { model: o }), {
+      default: h(() => [
+        V(e.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["model"]));
+  }
+});
+export {
+  S as default
+};

package/es/src/ap-form/constant.d.ts

@@ -0,0 +1,3 @@
+import { ApFormColProps } from './interface';
+
+export declare const apFormItemColPropKeys: Array<keyof ApFormColProps>;

package/es/src/ap-form/constant.mjs

@@ -0,0 +1,17 @@
+const l = [
+  "flex",
+  "lg",
+  "md",
+  "offset",
+  "order",
+  "pull",
+  "push",
+  "sm",
+  "span",
+  "xl",
+  "xs",
+  "xxl"
+];
+export {
+  l as apFormItemColPropKeys
+};

package/es/src/ap-form/context.d.ts

@@ -0,0 +1,11 @@
+import { NamePath } from 'ant-design-vue/es/form/interface';
+import { ComputedRef, InjectionKey } from 'vue';
+
+type ApFormContextProps<ModelType> = {
+    model?: ComputedRef<ModelType>;
+    updateModel?: (name: NamePath, value: any) => void;
+};
+export declare const ApFormContextKey: InjectionKey<ApFormContextProps<any>>;
+export declare function useProvideForm<ModelType>(state: ApFormContextProps<ModelType>): void;
+export declare function useInjectForm(): ApFormContextProps<any>;
+export {};

package/es/src/ap-form/context.mjs

@@ -0,0 +1,17 @@
+import { provide as t, inject as r, computed as n } from "vue";
+const o = Symbol("formContextKey");
+function u(e) {
+  t(o, e);
+}
+function c() {
+  return r(o, {
+    model: n(() => ({})),
+    updateModel: () => {
+    }
+  });
+}
+export {
+  o as ApFormContextKey,
+  c as useInjectForm,
+  u as useProvideForm
+};

package/es/src/ap-form/index.d.ts

@@ -0,0 +1,14 @@
+import { default as _ApForm } from './ap-form.vue';
+import { default as ApFormItem } from './ap-form-item.vue';
+import { default as ApFormItemGroup } from './ap-form-item-group/index.vue';
+import { default as ApFormList } from './ap-form-list.vue';
+
+type ApFormMixedProps = typeof _ApForm & {
+    FormItem: typeof ApFormItem;
+    FormItemGroup: typeof ApFormItemGroup;
+    FormList: typeof ApFormList;
+};
+declare const ApForm: ApFormMixedProps;
+export * from './items';
+export * from './interface';
+export { ApForm, ApFormItem, ApFormItemGroup, ApFormList };

package/es/src/ap-form/index.mjs

@@ -0,0 +1,20 @@
+import "./ap-form.vue.mjs";
+import "./ap-form-item.vue2.mjs";
+import "./ap-form-item-group/index.vue2.mjs";
+import "./ap-form-list.vue2.mjs";
+import "./items/index.mjs";
+import "./interface.mjs";
+import o from "./ap-form.vue2.mjs";
+import r from "./ap-form-item.vue.mjs";
+import t from "./ap-form-item-group/index.vue.mjs";
+import p from "./ap-form-list.vue.mjs";
+const m = o;
+m.FormItem = r;
+m.FormItemGroup = t;
+m.FormList = p;
+export {
+  m as ApForm,
+  r as ApFormItem,
+  t as ApFormItemGroup,
+  p as ApFormList
+};

package/es/src/ap-form/interface.d.ts

@@ -0,0 +1,28 @@
+import { ColProps, FormItemProps, FormProps, RowProps } from 'ant-design-vue';
+import { FormExpose } from 'ant-design-vue/es/form/Form';
+import { FormItemExpose } from 'ant-design-vue/es/form/FormItem';
+
+export type ApFormColProps = Omit<ColProps, 'prefixCls'>;
+export type ApFormItemProps = FormItemProps & Partial<ApFormColProps> & {
+    /**
+     * 是否展示包含了输入框&label的border
+     */
+    bordered?: boolean;
+    valuePropName?: string;
+};
+export type ApFormItemGroupProps = RowProps & {
+    countPerRow?: number;
+};
+export type ApFormProps = {
+    initialValues?: Record<string, any>;
+} & Omit<FormProps, 'model'>;
+export type ApFormExpose<ModelType = any> = FormExpose & {
+    setFieldsValue?: (fields: Partial<ModelType>) => void;
+    setFieldValue?: (key: keyof ModelType, value: any) => void;
+};
+export type ApFormItemExpose = FormItemExpose & {
+    getFieldValue: () => any;
+};
+export type ApFormListProps = {
+    name: FormItemProps['name'];
+};

package/es/src/ap-form/interface.mjs

@@ -0,0 +1 @@
+

package/es/src/ap-form/items/date/index.vue.d.ts

@@ -0,0 +1,65 @@
+import { ApFormItemDateProps } from '../interface';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes, PropType } from 'vue';
+import { ApFieldDateProps } from '../../..';
+
+type ApFormItemDateSlots = {
+    dateRender: any;
+    suffixIcon?: any;
+    prevIcon?: any;
+    nextIcon?: any;
+    superPrevIcon?: any;
+    superNextIcon?: any;
+    renderExtraFooter?: any;
+    monthCellRender?: any;
+    monthCellContentRender?: any;
+    clearIcon?: any;
+    default?: any;
+};
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ApFormItemDateProps>, {
+    hasFeedback: boolean;
+    colon: undefined;
+    autoLink: boolean;
+    required: undefined;
+    validateFirst: undefined;
+    disabled: boolean;
+    field: () => {};
+}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ApFormItemDateProps>, {
+    hasFeedback: boolean;
+    colon: undefined;
+    autoLink: boolean;
+    required: undefined;
+    validateFirst: undefined;
+    disabled: boolean;
+    field: () => {};
+}>>>, {
+    disabled: boolean;
+    required: boolean;
+    field: Omit< ApFieldDateProps, "value" | "onUpdate:value">;
+    colon: boolean;
+    hasFeedback: boolean;
+    autoLink: boolean;
+    validateFirst: boolean;
+}, {}>, Readonly<ApFormItemDateSlots> & ApFormItemDateSlots>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};