@aplus-frontend/ui 0.0.1-beta.4 → 0.0.1-beta.40

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

@@ -0,0 +1,41 @@
+import { defineComponent as d, 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__ */ d({
+  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
+    }, v = 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: v.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/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
+};