@fangzhongya/fang-ui 0.0.3

package/dist/components/forms-item/src/data.d.ts

@@ -0,0 +1,95 @@
+import type { ExtractPropTypes } from 'vue';
+export type ItemObj = {
+    /**
+     * 表单类型
+     */
+    type: string;
+    /**
+     * 表单取值字段名称
+     */
+    prop: string;
+    /**
+     * 是否多选
+     */
+    multiple: string | boolean;
+    /**
+     * 是否禁用
+     */
+    disabled: boolean;
+};
+export declare const dataProps: {
+    selects: import("../../../utils").EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
+    modelValue: {
+        readonly type: import("vue").PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    type: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    prop: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    multiple: {
+        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<(BooleanConstructor | StringConstructor)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabled: {
+        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<BooleanConstructor[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    computed: {
+        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<(ObjectConstructor | {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        })[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    config: {
+        readonly type: import("vue").PropType<Record<string, any>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export type DataProps = ExtractPropTypes<typeof dataProps>;
+/**
+ * @emits change (val:[String, Array])
+ * 选择的时间
+ */
+export declare const dataEmits: string[];
+export type DataEmits = typeof dataEmits;
+/**
+ * @slot default 默认插槽
+ */
+export declare const dataSlot: {
+    default: string;
+};
+/**
+ * expose setValue (val:<string>设置的数据 )
+ * 设置值
+ */
+export declare const dataExpose: {};

package/dist/components/forms-item/src/data.js

@@ -0,0 +1,69 @@
+import { buildProps } from "../../../utils/vue/props/runtime.js";
+import "vue";
+const dataProps = buildProps({
+  /**
+   * @props { Object } selects 选择数据集合
+   */
+  selects: {
+    type: Object,
+    default() {
+      return {};
+    }
+  },
+  /**
+   * 传入值
+   * @props { String } modelValue= ( )
+   */
+  modelValue: {
+    type: null
+  },
+  /**
+   * 表单类型
+   * @props { String } type= ( )
+   */
+  type: {
+    type: String
+  },
+  /**
+   * 表单取值字段名称
+   *   @props { String } prop= ( )
+   */
+  prop: {
+    type: String
+  },
+  /**
+   * 是否多选
+   * @props { String , Boolean } multiple= ( )
+   */
+  multiple: {
+    type: [String, Boolean]
+  },
+  /**
+   * 是否禁用
+   *  @props {Boolean } disabled= ( )
+   */
+  disabled: {
+    type: [Boolean]
+  },
+  /**
+   * 处理 v-model 值
+   * @props { Object, Array<string> } computed= ( )
+   */
+  computed: {
+    type: [Object, Array]
+  },
+  /**
+   * 子表单配置
+   * @props { Object } config= ( )
+   */
+  config: {
+    type: Object
+  }
+});
+const dataEmits = ["update:modelValue"];
+const dataExpose = {};
+export {
+  dataEmits,
+  dataExpose,
+  dataProps
+};

package/dist/components/forms-item/src/index.cjs

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const data = require("./data.cjs");
+const index = require("../../../hooks/cssname/index.cjs");
+require("../../../hooks/global-config/index.cjs");
+const runtime = require("../../../utils/vue/props/runtime.cjs");
+const util$1 = require("../../../utils/util.cjs");
+const util = require("./util.cjs");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: data.dataProps,
+  emits: data.dataEmits,
+  setup(__props, { expose, emit }) {
+    const prs = __props;
+    const cs = index.useCssName("forms-item");
+    const props = runtime.getBuildProps(prs);
+    const FormItemType = util.getComponents(props.type || "input");
+    const value = vue.computed({
+      get() {
+        let v = props.modelValue;
+        const prop = props.prop;
+        if (prop && v) {
+          let z = v[prop];
+          if (props.computed) {
+            if (props.computed instanceof Array) {
+              z = props.computed.map((k) => {
+                return v[k];
+              });
+            } else if (props.computed.get) {
+              z = props.computed.get(v);
+            }
+          }
+          return z;
+        } else {
+          return "";
+        }
+      },
+      set(value2) {
+        let v = props.modelValue || {};
+        const prop = props.prop;
+        if (prop) {
+          v[prop] = value2;
+        }
+        if (props.computed) {
+          if (props.computed instanceof Array) {
+            props.computed.forEach((k) => {
+              v[k] = value2 ? value2[k] : "";
+            });
+          } else if (props.computed.set) {
+            props.computed.set(value2, v);
+          }
+        }
+        emit("update:modelValue", v);
+      }
+    });
+    function setSelect(v, ...arr) {
+      if (v) {
+        if (typeof v.list == "string") {
+          if (props.selects) {
+            return props.selects[v.list] || [];
+          }
+        } else if (typeof v.list == "function") {
+          return v.list(v, ...arr);
+        } else {
+          return v.list;
+        }
+      }
+      return [];
+    }
+    const formEvent = vue.computed(() => {
+      const obj = {};
+      const pro = props;
+      Object.keys(pro).forEach((key) => {
+        if (/on[A-Z]/.test(key)) {
+          const m = util$1.firstLower(key.replace(/^on/, ""));
+          obj[m] = (...data2) => {
+            pro[key](
+              data2,
+              value,
+              props.modelValue,
+              props
+            );
+          };
+        }
+      });
+      return obj;
+    });
+    expose({
+      ...data.dataExpose
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(vue.unref(cs).z())
+      }, [
+        (vue.openBlock(), vue.createBlock(vue.Suspense, null, {
+          fallback: vue.withCtx(() => [
+            vue.createTextVNode(" 加载中... ")
+          ]),
+          default: vue.withCtx(() => {
+            var _a, _b;
+            return [
+              vue.createVNode(vue.unref(FormItemType), vue.mergeProps({
+                configs: vue.unref(props).config,
+                multiple: vue.unref(props).multiple,
+                disabled: vue.unref(props).disabled,
+                type: ((_b = (_a = vue.unref(props)) == null ? void 0 : _a.config) == null ? void 0 : _b.type) || vue.unref(props).type,
+                list: setSelect(vue.unref(props)),
+                modelValue: vue.unref(value),
+                "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => vue.isRef(value) ? value.value = $event : null)
+              }, vue.toHandlers(vue.unref(formEvent))), null, 16, ["configs", "multiple", "disabled", "type", "list", "modelValue"])
+            ];
+          }),
+          _: 1
+        }))
+      ], 2);
+    };
+  }
+});
+exports.default = _sfc_main;

package/dist/components/forms-item/src/index.d.ts

@@ -0,0 +1,120 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    selects: import("../../../utils").EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
+    modelValue: {
+        readonly type: import("vue").PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    type: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    prop: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    multiple: {
+        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<(BooleanConstructor | StringConstructor)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabled: {
+        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<BooleanConstructor[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    computed: {
+        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<(ObjectConstructor | {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        })[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    config: {
+        readonly type: import("vue").PropType<Record<string, any>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, string[], string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    selects: import("../../../utils").EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
+    modelValue: {
+        readonly type: import("vue").PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    type: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    prop: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    multiple: {
+        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<(BooleanConstructor | StringConstructor)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabled: {
+        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<BooleanConstructor[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    computed: {
+        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<(ObjectConstructor | {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        })[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    config: {
+        readonly type: import("vue").PropType<Record<string, any>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & {
+    [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, {
+    selects: Record<string, any>;
+}>;
+export default _sfc_main;

package/dist/components/forms-item/src/index.js

@@ -0,0 +1,120 @@
+import { defineComponent, computed, openBlock, createElementBlock, normalizeClass, unref, createBlock, Suspense, withCtx, createTextVNode, createVNode, mergeProps, isRef, toHandlers } from "vue";
+import { dataProps, dataEmits, dataExpose } from "./data.js";
+import { useCssName } from "../../../hooks/cssname/index.js";
+import "../../../hooks/global-config/index.js";
+import { getBuildProps } from "../../../utils/vue/props/runtime.js";
+import { firstLower } from "../../../utils/util.js";
+import { getComponents } from "./util.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "index",
+  props: dataProps,
+  emits: dataEmits,
+  setup(__props, { expose, emit }) {
+    const prs = __props;
+    const cs = useCssName("forms-item");
+    const props = getBuildProps(prs);
+    const FormItemType = getComponents(props.type || "input");
+    const value = computed({
+      get() {
+        let v = props.modelValue;
+        const prop = props.prop;
+        if (prop && v) {
+          let z = v[prop];
+          if (props.computed) {
+            if (props.computed instanceof Array) {
+              z = props.computed.map((k) => {
+                return v[k];
+              });
+            } else if (props.computed.get) {
+              z = props.computed.get(v);
+            }
+          }
+          return z;
+        } else {
+          return "";
+        }
+      },
+      set(value2) {
+        let v = props.modelValue || {};
+        const prop = props.prop;
+        if (prop) {
+          v[prop] = value2;
+        }
+        if (props.computed) {
+          if (props.computed instanceof Array) {
+            props.computed.forEach((k) => {
+              v[k] = value2 ? value2[k] : "";
+            });
+          } else if (props.computed.set) {
+            props.computed.set(value2, v);
+          }
+        }
+        emit("update:modelValue", v);
+      }
+    });
+    function setSelect(v, ...arr) {
+      if (v) {
+        if (typeof v.list == "string") {
+          if (props.selects) {
+            return props.selects[v.list] || [];
+          }
+        } else if (typeof v.list == "function") {
+          return v.list(v, ...arr);
+        } else {
+          return v.list;
+        }
+      }
+      return [];
+    }
+    const formEvent = computed(() => {
+      const obj = {};
+      const pro = props;
+      Object.keys(pro).forEach((key) => {
+        if (/on[A-Z]/.test(key)) {
+          const m = firstLower(key.replace(/^on/, ""));
+          obj[m] = (...data) => {
+            pro[key](
+              data,
+              value,
+              props.modelValue,
+              props
+            );
+          };
+        }
+      });
+      return obj;
+    });
+    expose({
+      ...dataExpose
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(unref(cs).z())
+      }, [
+        (openBlock(), createBlock(Suspense, null, {
+          fallback: withCtx(() => [
+            createTextVNode(" 加载中... ")
+          ]),
+          default: withCtx(() => {
+            var _a, _b;
+            return [
+              createVNode(unref(FormItemType), mergeProps({
+                configs: unref(props).config,
+                multiple: unref(props).multiple,
+                disabled: unref(props).disabled,
+                type: ((_b = (_a = unref(props)) == null ? void 0 : _a.config) == null ? void 0 : _b.type) || unref(props).type,
+                list: setSelect(unref(props)),
+                modelValue: unref(value),
+                "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(value) ? value.value = $event : null)
+              }, toHandlers(unref(formEvent))), null, 16, ["configs", "multiple", "disabled", "type", "list", "modelValue"])
+            ];
+          }),
+          _: 1
+        }))
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/forms-item/src/index2.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index_vue_vue_type_script_setup_true_lang = require("./index.cjs");
+exports.default = index_vue_vue_type_script_setup_true_lang.default;

package/dist/components/forms-item/src/index2.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./index.js";
+export {
+  _sfc_main as default
+};

package/dist/components/forms-item/src/util.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index_vue_vue_type_script_setup_true_lang = require("../../inputs/src/index.cjs");
+const vue = require("vue");
+const globalComponents = /* @__PURE__ */ Object.assign({
+  "../../subset/checks/src/index.vue": () => Promise.resolve().then(() => require("../../checks/src/index2.cjs")),
+  "../../subset/date/src/index.vue": () => Promise.resolve().then(() => require("../../date/src/index2.cjs")),
+  "../../subset/inputs/src/index.vue": () => Promise.resolve().then(() => require("../../inputs/src/index2.cjs")),
+  "../../subset/selects/src/index.vue": () => Promise.resolve().then(() => require("../../selects/src/index2.cjs"))
+});
+function getComponents(type) {
+  const reg = /\/subset\/((.+\/)?)([^\/]+)\/src\/index.(ts|vue)/;
+  for (const key in globalComponents) {
+    const regs = reg.exec(key);
+    if (regs && regs.length > 0) {
+      const v = regs[3];
+      if (v == type) {
+        return vue.defineAsyncComponent(
+          globalComponents[key]
+        );
+      }
+    }
+  }
+  return index_vue_vue_type_script_setup_true_lang.default;
+}
+exports.getComponents = getComponents;

package/dist/components/forms-item/src/util.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 获取对应的组件
+ */
+export declare function getComponents(type: string): any;

package/dist/components/forms-item/src/util.js

@@ -0,0 +1,26 @@
+import _sfc_main from "../../inputs/src/index.js";
+import { defineAsyncComponent } from "vue";
+const globalComponents = /* @__PURE__ */ Object.assign({
+  "../../subset/checks/src/index.vue": () => import("../../checks/src/index2.js"),
+  "../../subset/date/src/index.vue": () => import("../../date/src/index2.js"),
+  "../../subset/inputs/src/index.vue": () => import("../../inputs/src/index2.js"),
+  "../../subset/selects/src/index.vue": () => import("../../selects/src/index2.js")
+});
+function getComponents(type) {
+  const reg = /\/subset\/((.+\/)?)([^\/]+)\/src\/index.(ts|vue)/;
+  for (const key in globalComponents) {
+    const regs = reg.exec(key);
+    if (regs && regs.length > 0) {
+      const v = regs[3];
+      if (v == type) {
+        return defineAsyncComponent(
+          globalComponents[key]
+        );
+      }
+    }
+  }
+  return _sfc_main;
+}
+export {
+  getComponents
+};

package/dist/components/global-config/index.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+require("vue");
+const withInstall = require("../../utils/vue/withInstall.cjs");
+const index = require("./src/index.cjs");
+const GlobalConfig = withInstall.withInstall(index.default, "GlobalConfig");
+exports.GlobalConfig = GlobalConfig;
+exports.default = GlobalConfig;

package/dist/components/global-config/index.d.ts

@@ -0,0 +1,33 @@
+import { withInstall } from '../../utils';
+declare const GlobalConfig: withInstall<import("vue").DefineComponent<{
+    locale: {
+        readonly type: import("vue").PropType<import("../../types").Locale>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    zIndex: NumberConstructor;
+    cssname: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    locale: {
+        readonly type: import("vue").PropType<import("../../types").Locale>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    zIndex: NumberConstructor;
+    cssname: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>>, {}>>;
+export { GlobalConfig, GlobalConfig as default };

package/dist/components/global-config/index.js

@@ -0,0 +1,8 @@
+import "vue";
+import { withInstall } from "../../utils/vue/withInstall.js";
+import SrcVue from "./src/index.js";
+const GlobalConfig = withInstall(SrcVue, "GlobalConfig");
+export {
+  GlobalConfig,
+  GlobalConfig as default
+};

package/dist/components/global-config/src/data.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const runtime = require("../../../utils/vue/props/runtime.cjs");
+require("vue");
+const definePropType = require("../../../utils/vue/definePropType.cjs");
+const dataProps = runtime.buildProps({
+  /**
+   * @props { Object<Locale> } locale
+   * @description 国际化对象
+   */
+  locale: {
+    type: definePropType.definePropType(Object)
+  },
+  /**
+   * @description global Initial zIndex
+   */
+  zIndex: Number,
+  /**
+   * @props { String } cssname
+   * 前缀样式名称
+   */
+  cssname: {
+    type: String
+  }
+});
+exports.dataProps = dataProps;