asiaint-lowcode 2.0.0 → 2.0.2

package/dist/index.d.ts

@@ -0,0 +1,528 @@
+import { App } from 'vue';
+import { Component } from 'vue';
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { DefineComponent } from 'vue';
+import { ExtractPropTypes } from 'vue';
+import { FormValidationResult } from 'element-plus';
+import { PropType } from 'vue';
+import { PublicProps } from 'vue';
+import { VNode } from 'vue';
+
+declare const __VLS_component: DefineComponent<ExtractPropTypes<    {
+modelValue: PropType<Record<string, any>>;
+schema: PropType<FormSchema>;
+schemaContext: {
+type: PropType<Record<string, any>>;
+};
+design: {
+type: PropType<boolean>;
+};
+footer: {
+type: PropType<boolean>;
+};
+read: {
+type: PropType<boolean>;
+};
+pageRulePath: {
+type: PropType<string>;
+};
+}>, {
+formValues: Record<string, any>;
+selectData: Record<string, Record<string, any>>;
+initialValues: Record<string, any>;
+context: {
+$values: Record<string, any>;
+$selectData: Record<string, Record<string, any>>;
+$locale: Locale;
+};
+vCodePass: boolean;
+updateFormValues: (values: Record<string, any>, isAssign?: boolean) => void;
+updateSelectData: (key: string, value: Record<string, any>) => void;
+updateInitialValues: (values: Record<string, any>) => void;
+updateVCodePass: (value: boolean) => void;
+validate: () => FormValidationResult | undefined;
+resetFields: (names?: string[]) => void;
+submit: () => void;
+setDisabled: (disabled: boolean) => void;
+findItemByName: (items: FormItemType[], name: string) => FormItemType | null;
+type: string;
+schema: FormSchema;
+schemaContext: Record<string, any>;
+design: boolean;
+footer: boolean;
+read: boolean;
+pageRulePath: string;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+reset: () => void;
+finish: (values: Record<string, any>) => void;
+failed: (errors: {
+message?: string;
+fieldValue?: any;
+field?: string;
+}[]) => void;
+}, string, PublicProps, Readonly<ExtractPropTypes<    {
+modelValue: PropType<Record<string, any>>;
+schema: PropType<FormSchema>;
+schemaContext: {
+type: PropType<Record<string, any>>;
+};
+design: {
+type: PropType<boolean>;
+};
+footer: {
+type: PropType<boolean>;
+};
+read: {
+type: PropType<boolean>;
+};
+pageRulePath: {
+type: PropType<string>;
+};
+}>> & Readonly<{
+onReset?: (() => any) | undefined;
+onFinish?: ((values: Record<string, any>) => any) | undefined;
+onFailed?: ((errors: {
+message?: string;
+fieldValue?: any;
+field?: string;
+}[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+declare type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+
+declare type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+
+declare type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: PropType<T[K]>;
+        required: true;
+    };
+};
+
+declare 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];
+};
+
+declare type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare const _default: {
+    install: (app: App<Element>, options?: Options) => void;
+};
+export default _default;
+
+declare type FormChange = {
+    target: string;
+    value?: any;
+    condition?: any;
+};
+
+export declare const FormDesign: DefineComponent<ExtractPropTypes<    {
+modelValue: PropType<FormSchema>;
+schemaContext: {
+type: PropType<Record<string, any>>;
+default: () => {};
+};
+templates: {
+type: PropType<TemplateData>;
+default: () => never[];
+};
+omitMenus: {
+type: PropType<string[]>;
+default: () => never[];
+};
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+add: (element: FormElement) => void;
+save: () => void;
+onSave: () => void;
+}, string, PublicProps, Readonly<ExtractPropTypes<    {
+modelValue: PropType<FormSchema>;
+schemaContext: {
+type: PropType<Record<string, any>>;
+default: () => {};
+};
+templates: {
+type: PropType<TemplateData>;
+default: () => never[];
+};
+omitMenus: {
+type: PropType<string[]>;
+default: () => never[];
+};
+}>> & Readonly<{
+onAdd?: ((element: FormElement) => any) | undefined;
+onSave?: (() => any) | undefined;
+onOnSave?: (() => any) | undefined;
+}>, {
+schemaContext: Record<string, any>;
+templates: TemplateData;
+omitMenus: string[];
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+export declare type FormElement = {
+    title: string;
+    component: string;
+    render: string | VNode | Component;
+    icon: string | VNode | Component;
+    type: 'assist' | 'layout' | 'basic' | 'high';
+    order: number;
+    modelName?: string;
+    attrSchema: FormSchema;
+    lbTitle?: boolean;
+};
+
+export declare interface FormInstance extends FormRenderProps {
+    formValues: Record<string, any>;
+    selectData: Record<string, Record<string, any>>;
+    initialValues: Record<string, Record<string, any>>;
+    context: Record<string, any>;
+    vCodePass: boolean;
+    updateFormValues: (values: Record<string, any>, isAssign?: boolean) => void;
+    updateSelectData: (key: string, value: Record<string, any>) => void;
+    updateInitialValues: (values: Record<string, any>) => void;
+    updateVCodePass: (value: boolean) => void;
+    validate: () => FormValidationResult | undefined;
+    resetFields: (names?: string[]) => void;
+    submit: () => void;
+}
+
+export declare interface FormItemType {
+    label?: string;
+    name: string;
+    component: string;
+    required?: boolean;
+    props?: Record<string, any>;
+    initialValue?: any;
+    help?: string;
+    children?: FormItemType[];
+    hidden?: boolean | string;
+    hideLabel?: boolean;
+    designKey?: string;
+    rules?: FormRule[];
+    class?: any;
+    style?: any;
+    change?: FormChange[];
+    dialog?: boolean;
+    width?: number;
+}
+
+export declare const FormRender: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+
+declare interface FormRenderProps {
+    schema: FormSchema;
+    schemaContext?: Record<string, any>;
+    design?: boolean;
+    footer?: boolean;
+    read?: boolean;
+    pageRulePath?: string;
+}
+
+declare type FormRule = {
+    type: 'email' | 'url' | 'custom' | string;
+    customReg?: string;
+    templateExp?: any;
+    message?: string;
+    trigger: string[];
+};
+
+export declare type FormSchema = {
+    labelWidth?: number;
+    labelPosition?: 'top' | 'left' | 'right';
+    labelSuffix?: string;
+    size?: 'default' | 'small' | 'large';
+    disabled?: boolean;
+    hideRequiredAsterisk?: boolean;
+    labelBold?: boolean;
+    scrollToError?: boolean;
+    initialValues?: Record<string, any>;
+    key?: string;
+    items: FormItemType[];
+    rulePath?: string;
+    hidden?: boolean;
+};
+
+declare type Locale = {
+    menus: {
+        basicTitle: string;
+        highTitle: string;
+        layoutTitle: string;
+        assistTitle: string;
+        useTemplateBtn: string;
+    };
+    actions: {
+        previewJson: string;
+        previewVueCode: string;
+        previewForm: string;
+        clear: string;
+        save: string;
+    };
+    canvas: {
+        emptyTip: string;
+        wrapperEmptyTip: string;
+    };
+    attr: {
+        tab1: {
+            title: string;
+            emptyTip: string;
+            linkage: {
+                text: string;
+                action1: string;
+                action2: string;
+            };
+        };
+        tab2: {
+            title: string;
+        };
+    };
+};
+
+declare type Options = {
+    request?: (options: Record<string, any>) => Promise<Record<string, any>>;
+    extendElements?: Record<string, FormElement>;
+    lang?: 'zh' | 'en';
+};
+
+export declare type PageMethods = {
+    findRef: (key: string) => any;
+    setFormDisabled: (key: string, disabled: boolean) => void;
+    validate: (keys: string[] | string) => Promise<void>;
+    getData: (keys?: string[] | string) => any;
+    resetFields: (keys?: string[] | string) => void;
+    emit: (event: 'done' | 'refresh') => void;
+    setData: (key: string, dataModel: any, isAssign: boolean) => void;
+    getItemByName: (formKey: string, itemKey: string) => FormItemType | null | undefined;
+    setHidden: (key: string, hiddenState: boolean) => void;
+};
+
+export declare const PageRender: DefineComponent<ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+ruleMap: Record<string, any>;
+pageSchema: PageSchema;
+pageParams?: any;
+}>, {}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+done: (...args: any[]) => void;
+refresh: (...args: any[]) => void;
+}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+ruleMap: Record<string, any>;
+pageSchema: PageSchema;
+pageParams?: any;
+}>, {}>>> & Readonly<{
+onDone?: ((...args: any[]) => any) | undefined;
+onRefresh?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+declare type PageSchema = {
+    key: string;
+    rulePath?: string;
+    onMounted?: string;
+    onActivated?: string;
+    content: Array<{
+        type: 'form';
+        schema: FormSchema;
+    } | {
+        type: 'table';
+        schema: TableSchema;
+    }>;
+    btns: Array<{
+        key: string;
+        text: string;
+        onClick: string;
+        disabled: boolean;
+        visible: boolean;
+    }>;
+};
+
+declare interface TableColumn {
+    label: string;
+    key: string;
+    minWidth?: string;
+    fixed?: boolean;
+    hidden?: boolean;
+}
+
+export declare const TableRender: DefineComponent<ExtractPropTypes<    {
+schema: {
+required: true;
+type: PropType<TableSchema>;
+};
+modelValue: PropType<Array<any>>;
+design: {
+type: PropType<boolean>;
+};
+read: {
+type: PropType<boolean>;
+};
+pageRulePath: {
+type: PropType<string>;
+};
+}>, {
+setCellData: (rowIndex: number, field: string, value: any) => void;
+clearSelection: () => void;
+getData: () => any[];
+getCurrentRow: () => Record<string, any> | undefined;
+getSelectedRows: () => any;
+addRow: (rowData?: {}) => void;
+deleteRow: (rowIndex: number) => void;
+refresh: () => Promise<void>;
+validate: () => Promise<boolean>;
+setData: (data: any[]) => void;
+selectRow: (row: Record<string, any>) => void;
+selectRowNum: (num: number) => void;
+setTotal: (val: number) => void;
+getPagination: () => {
+pageNum: number;
+pageSize: number;
+};
+setPagination: (val: {
+pageNum: number;
+pageSize: number;
+}) => {
+pagination: {
+pageNum: number;
+pageSize: number;
+};
+isChange: boolean;
+};
+type: string;
+design: boolean;
+read: boolean;
+pageRulePath: string;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+schema: {
+required: true;
+type: PropType<TableSchema>;
+};
+modelValue: PropType<Array<any>>;
+design: {
+type: PropType<boolean>;
+};
+read: {
+type: PropType<boolean>;
+};
+pageRulePath: {
+type: PropType<string>;
+};
+}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+declare type TableSchema = {
+    label: string;
+    key: string;
+    rulePath: string;
+    rowKey?: string;
+    addForm?: FormRenderProps;
+    showDynamicSearch?: boolean;
+    multipleSelection?: boolean;
+    highlightCurrentRow?: boolean;
+    rowClick?: string;
+    rowDbClick?: string;
+    sizeChange?: string;
+    pageChange?: string;
+    topBtns?: Record<string, any>[];
+    rowBtns?: Record<string, any>[];
+    columns: TableColumn[];
+    form?: FormSchema;
+    hidden?: boolean;
+    hiddenPagination?: boolean;
+};
+
+export declare type TemplateData = {
+    name: string;
+    schema: FormSchema;
+    id?: string;
+}[];
+
+export declare const useFormInstance: () => {
+    readonly formValues: {
+        readonly [x: string]: any;
+    };
+    readonly selectData: {
+        readonly [x: string]: {
+            readonly [x: string]: any;
+        };
+    };
+    readonly initialValues: {
+        readonly [x: string]: {
+            readonly [x: string]: any;
+        };
+    };
+    readonly context: {
+        readonly [x: string]: any;
+    };
+    readonly vCodePass: boolean;
+    readonly updateFormValues: (values: Record<string, any>, isAssign?: boolean) => void;
+    readonly updateSelectData: (key: string, value: Record<string, any>) => void;
+    readonly updateInitialValues: (values: Record<string, any>) => void;
+    readonly updateVCodePass: (value: boolean) => void;
+    readonly validate: () => FormValidationResult | undefined;
+    readonly resetFields: (names?: string[]) => void;
+    readonly submit: () => void;
+    readonly schema: {
+        readonly labelWidth?: number | undefined;
+        readonly labelPosition?: ("top" | "left" | "right") | undefined;
+        readonly labelSuffix?: string | undefined;
+        readonly size?: ("default" | "small" | "large") | undefined;
+        readonly disabled?: boolean | undefined;
+        readonly hideRequiredAsterisk?: boolean | undefined;
+        readonly labelBold?: boolean | undefined;
+        readonly scrollToError?: boolean | undefined;
+        readonly initialValues?: {
+            readonly [x: string]: any;
+        } | undefined;
+        readonly key?: string | undefined;
+        readonly items: readonly {
+            readonly label?: string | undefined;
+            readonly name: string;
+            readonly component: string;
+            readonly required?: boolean | undefined;
+            readonly props?: {
+                readonly [x: string]: any;
+            } | undefined;
+            readonly initialValue?: any;
+            readonly help?: string | undefined;
+            readonly children?: readonly any[] | undefined;
+            readonly hidden?: (boolean | string) | undefined;
+            readonly hideLabel?: boolean | undefined;
+            readonly designKey?: string | undefined;
+            readonly rules?: readonly {
+                readonly type: "email" | "url" | "custom" | string;
+                readonly customReg?: string | undefined;
+                readonly templateExp?: any;
+                readonly message?: string | undefined;
+                readonly trigger: readonly string[];
+            }[] | undefined;
+            readonly class?: any;
+            readonly style?: any;
+            readonly change?: readonly {
+                readonly target: string;
+                readonly value?: any;
+                readonly condition?: any;
+            }[] | undefined;
+            readonly dialog?: boolean | undefined;
+            readonly width?: number | undefined;
+        }[];
+        readonly rulePath?: string | undefined;
+        readonly hidden?: boolean | undefined;
+    };
+    readonly schemaContext?: {
+        readonly [x: string]: any;
+    } | undefined;
+    readonly design?: boolean | undefined;
+    readonly footer?: boolean | undefined;
+    readonly read?: boolean | undefined;
+    readonly pageRulePath?: string | undefined;
+};
+
+export { }

package/dist/lazy/Card-op6i_z8G.js

@@ -0,0 +1,46 @@
+import { defineComponent as p, ref as c, resolveComponent as m, openBlock as r, createBlock as n, normalizeProps as u, guardReactiveProps as _, withCtx as o, createElementVNode as l, toDisplayString as f, unref as t, normalizeClass as v, createCommentVNode as C, createVNode as d, Transition as h, withDirectives as w, vShow as b } from "vue";
+import { _ as k, a as $, b as y } from "./index-DoIvJXpY.js";
+import "element-plus";
+const B = { class: "card-header" }, E = /* @__PURE__ */ p({
+  __name: "Card",
+  props: {
+    children: {},
+    collapsible: { type: Boolean },
+    header: {}
+  },
+  setup(N) {
+    const e = c(!1);
+    return (a, s) => {
+      const i = m("ElCard");
+      return r(), n(i, u(_(a.$attrs)), {
+        header: o(() => [
+          l("div", B, [
+            l("span", null, f(a.header), 1),
+            a.collapsible ? (r(), n(t(k), {
+              key: 0,
+              name: "dropdown",
+              onClick: s[0] || (s[0] = (V) => e.value = !e.value),
+              class: v(["dropdown-icon", { "is-collapsed": e.value }])
+            }, null, 8, ["class"])) : C("", !0)
+          ])
+        ]),
+        default: o(() => [
+          d(h, { name: "collapse" }, {
+            default: o(() => [
+              w(l("div", null, [
+                d(t($), { list: a.children }, null, 8, ["list"])
+              ], 512), [
+                [b, !e.value]
+              ])
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }, 16);
+    };
+  }
+}), P = /* @__PURE__ */ y(E, [["__scopeId", "data-v-f48b76d3"]]);
+export {
+  P as default
+};

package/dist/lazy/Cascader-cy25S0M_.js

@@ -0,0 +1,41 @@
+import { defineComponent as m, mergeModels as i, useModel as c, resolveComponent as f, openBlock as g, createBlock as v, mergeProps as C, unref as l } from "vue";
+import "element-plus";
+import { u as y } from "./useSelect-DkY4BS54.js";
+const h = /* @__PURE__ */ m({
+  __name: "Cascader",
+  props: /* @__PURE__ */ i({
+    options: { default: () => [] },
+    multiple: { type: Boolean, default: !1 },
+    mode: { default: "static" },
+    labelKey: { default: "label" },
+    valueKey: { default: "value" },
+    disabledKey: {},
+    api: {},
+    name: { default: "" },
+    onChange: {}
+  }, {
+    modelValue: {},
+    modelModifiers: {}
+  }),
+  emits: ["update:modelValue"],
+  setup(o) {
+    const n = o, a = c(o, "modelValue"), { currentOptions: u, selectChange: s, loading: d } = y(n);
+    return (e, t) => {
+      const p = f("el-cascader");
+      return g(), v(p, C({
+        modelValue: a.value,
+        "onUpdate:modelValue": t[0] || (t[0] = (r) => a.value = r),
+        options: l(u),
+        loading: l(d),
+        props: {
+          multiple: e.multiple,
+          label: e.labelKey,
+          value: e.valueKey
+        }
+      }, e.$attrs, { onChange: l(s) }), null, 16, ["modelValue", "options", "loading", "props", "onChange"]);
+    };
+  }
+});
+export {
+  h as default
+};

package/dist/lazy/Checkbox-CQ56BycM.js

@@ -0,0 +1,75 @@
+import { defineComponent as w, mergeModels as B, useModel as D, watch as M, resolveComponent as u, resolveDirective as F, unref as a, openBlock as l, createElementBlock as n, toDisplayString as I, Fragment as d, createCommentVNode as i, withDirectives as S, createBlock as s, mergeProps as j, withCtx as f, renderList as h } from "vue";
+import "element-plus";
+import { u as E } from "./index-DoIvJXpY.js";
+import { u as L } from "./useSelect-DkY4BS54.js";
+const N = { key: 0 }, O = {
+  key: 0,
+  style: { "font-size": "12px" }
+}, A = /* @__PURE__ */ w({
+  __name: "Checkbox",
+  props: /* @__PURE__ */ B({
+    options: { default: () => [] },
+    mode: { default: "static" },
+    labelKey: { default: "label" },
+    valueKey: { default: "value" },
+    disabledKey: {},
+    api: {},
+    name: { default: "" },
+    onChange: {},
+    optionType: { default: "circle" },
+    direction: { default: "horizontal" },
+    space: { default: 20 }
+  }, {
+    modelValue: {},
+    modelModifiers: {}
+  }),
+  emits: ["update:modelValue"],
+  setup(p) {
+    const k = p, t = D(p, "modelValue"), g = E(), { currentOptions: r, selectChange: c, loading: m } = L(k);
+    return M(t, c), (e, y) => {
+      var b;
+      const K = u("el-checkbox"), C = u("el-checkbox-button"), _ = u("el-space"), V = u("el-checkbox-group"), z = F("loading");
+      return a(g).read ? (l(), n("div", N, I((b = t.value) == null ? void 0 : b.map((o) => {
+        var v;
+        return (v = a(r).find((T) => T[e.valueKey] === o)) == null ? void 0 : v[e.labelKey];
+      }).join("、")), 1)) : (l(), n(d, { key: 1 }, [
+        !a(r).length && !a(m) ? (l(), n("div", O, "暂无选项")) : i("", !0),
+        S((l(), s(V, j(e.$attrs, {
+          modelValue: t.value,
+          "onUpdate:modelValue": y[0] || (y[0] = (o) => t.value = o),
+          onChange: a(c)
+        }), {
+          default: f(() => [
+            e.optionType === "circle" || e.optionType === "border" ? (l(!0), n(d, { key: 0 }, h(a(r), (o) => (l(), s(K, {
+              key: o[e.valueKey],
+              label: o[e.labelKey],
+              value: o[e.valueKey],
+              border: e.optionType === "border"
+            }, null, 8, ["label", "value", "border"]))), 128)) : i("", !0),
+            e.optionType === "button" ? (l(), s(_, {
+              key: 1,
+              wrap: "",
+              size: [e.space, e.space]
+            }, {
+              default: f(() => [
+                (l(!0), n(d, null, h(a(r), (o) => (l(), s(C, {
+                  key: o[e.valueKey],
+                  label: o[e.labelKey],
+                  value: o[e.valueKey],
+                  size: "large"
+                }, null, 8, ["label", "value"]))), 128))
+              ]),
+              _: 1
+            }, 8, ["size"])) : i("", !0)
+          ]),
+          _: 1
+        }, 16, ["modelValue", "onChange"])), [
+          [z, a(m)]
+        ])
+      ], 64));
+    };
+  }
+});
+export {
+  A as default
+};