@fangzhongya/fang-ui 0.0.12 → 0.0.13

package/dist/components/common/use.js

@@ -0,0 +1,309 @@
+import { computed, h, resolveComponent } from "vue";
+import { getChildrenData, getFathers } from "../../utils/util.js";
+import "../../utils/vues/getBuildProps.js";
+import "@fangzhongya/utils/css/setObjStyle";
+import "@fangzhongya/utils/css/getCss";
+import { lineToLargeHump } from "@fangzhongya/utils/name/lineToLargeHump";
+import { firstLower } from "@fangzhongya/utils/basic/string/firstLower";
+import { setObjValue, getObjValue } from "@fangzhongya/utils/basic/object/objValue";
+import { isObject } from "@fangzhongya/utils/basic/object/isObject";
+import { isArray } from "@fangzhongya/utils/basic/array/isArray";
+function useVueValue(v, key) {
+  if (key && isObject(v)) {
+    if (typeof key == "function") {
+      return key(v);
+    } else if (typeof key == "string") {
+      return v[key];
+    }
+  }
+  return v;
+}
+function getFormRule(obj) {
+  const prop = obj.prop;
+  if (obj.orig) {
+    return prop;
+  } else {
+    const farrs = [];
+    getFathers(obj, farrs);
+    if (farrs.length > 0) {
+      let fps = [];
+      farrs.forEach((obj2) => {
+        if (obj2.orig) {
+          fps = [];
+        } else {
+          if (obj2.prop) {
+            fps.push(obj2.prop);
+          }
+        }
+      });
+      fps.push(prop);
+      return fps.join(".");
+    } else {
+      return prop;
+    }
+  }
+}
+function setFormDefaultValue(obj, value) {
+  let v = getChildrenData(obj, value, true) ?? {};
+  if (obj.orig) {
+    v = value;
+  }
+  const prop = obj.prop;
+  if (prop) {
+    if (obj.pars) {
+      setObjValue(v, prop, getObjValue(prop, v) ?? obj.default);
+    } else {
+      v[prop] = v[prop] ?? obj.default;
+    }
+  }
+}
+function useHide(v, form) {
+  if (v.hide) {
+    if (typeof v.hide == "function") {
+      return v.hide(form, v);
+    } else {
+      return v.hide;
+    }
+  } else {
+    return false;
+  }
+}
+function getValueObjs(value, multiple, options, config) {
+  if (value !== void 0 && value !== null) {
+    if (multiple) {
+      if (multiple === true) {
+        const d = options == null ? void 0 : options.filter((o) => {
+          return value.includes(
+            useVueValue(o, (config == null ? void 0 : config.prop) ?? "value")
+          );
+        });
+        return d.map((o) => {
+          return o[(config == null ? void 0 : config.label) ?? "label"] ?? useVueValue(o, (config == null ? void 0 : config.prop) ?? "value");
+        }).join(",");
+      } else {
+        const z = value.split(multiple);
+        const d = options == null ? void 0 : options.filter((o) => {
+          return z.includes(useVueValue(o, (config == null ? void 0 : config.prop) ?? "value"));
+        });
+        return d.map((o) => {
+          return o[(config == null ? void 0 : config.label) ?? "label"] ?? useVueValue(o, (config == null ? void 0 : config.prop) ?? "value");
+        }).join(multiple);
+      }
+    } else {
+      const d = options == null ? void 0 : options.filter((o) => {
+        return useVueValue(o, (config == null ? void 0 : config.prop) ?? "value") === value;
+      });
+      if (d.length > 0) {
+        return d[0][(config == null ? void 0 : config.label) ?? "label"] ?? value;
+      } else {
+        return value;
+      }
+    }
+  } else {
+    return value;
+  }
+}
+function setOptionsValue(value, obj, data, optionss) {
+  let options = [];
+  if (obj == null ? void 0 : obj.options) {
+    const opt = obj.options;
+    if (typeof opt === "string") {
+      const value2 = optionss[opt];
+      if (typeof value2 == "function") {
+        options = value2(optionss, value2, obj, data) || [];
+      } else {
+        options = value2 || [];
+      }
+    } else if (typeof opt == "function") {
+      options = opt(optionss, value, obj, data) || [];
+    } else {
+      options = opt || [];
+    }
+  }
+  return getValueObjs(value, obj.multiple, options, obj.config);
+}
+function setValue(value, obj, data) {
+  let v = getChildrenData(obj, data) ?? {};
+  if (obj.orig) {
+    v = data ?? {};
+  }
+  const prop = obj.prop;
+  if (prop) {
+    if (obj.pars) {
+      setObjValue(v, prop, value);
+    } else {
+      v[prop] = value;
+    }
+  }
+}
+function getValue(obj, data, index) {
+  const prop = obj.prop;
+  const cdata = getChildrenData(obj, data, true) ?? {};
+  let cellValue;
+  if (prop) {
+    if (obj.pars) {
+      cellValue = getObjValue(prop, cdata);
+    } else {
+      cellValue = cdata[prop];
+    }
+  }
+  if (obj.formatter) {
+    return obj.formatter(data, obj, cellValue, index, cdata);
+  } else {
+    return cellValue ?? obj.default;
+  }
+}
+function setComponString(value, obj, componObj, data, optionss, compons) {
+  if (obj == null ? void 0 : obj.options) {
+    let options = [];
+    const opt = obj.options;
+    if (typeof opt === "string") {
+      const optionsvalue = optionss[opt];
+      if (typeof optionsvalue == "function") {
+        options = optionsvalue(optionss, value, obj, data) || [];
+      } else {
+        options = optionsvalue || [];
+      }
+    } else if (typeof opt == "function") {
+      options = opt(optionss, value, obj, data) || [];
+    } else {
+      options = opt || [];
+    }
+    if (options && options.length > 0) {
+      componObj.options = options;
+    }
+  }
+  const compon = obj.compon;
+  const tcom = lineToLargeHump(compon);
+  if (Object.keys(compons).includes(tcom)) {
+    return h(compons[tcom], componObj);
+  } else {
+    return h(resolveComponent(compon), componObj);
+  }
+}
+function getOnObjs(obj, data, emit, ...arrs) {
+  const objs = {};
+  const es = obj.events || {};
+  Object.keys(es).forEach((key) => {
+    let ml = key;
+    if (!/on[A-Z]/.test(key)) {
+      ml = "on" + lineToLargeHump(key);
+    }
+    ml = firstLower(lineToLargeHump(ml));
+    objs[ml] = (...v) => {
+      if (es[key] && typeof es[key] == "function") {
+        es[key](...v, data, obj);
+      } else {
+        emit("list-events", key, ...v, data, obj, ...arrs);
+      }
+    };
+  });
+  return objs;
+}
+function useSetSlot(obj, data, slots, index) {
+  const slotname = obj.slot ?? obj.prop;
+  if (slotname) {
+    const slot = slots[slotname];
+    if (slot) {
+      const value = computed({
+        get() {
+          return getValue(obj, data, index);
+        },
+        set(value2) {
+          setValue(value2, obj, data);
+        }
+      });
+      return slot({
+        column: obj,
+        row: data,
+        value,
+        index
+      });
+    }
+  }
+}
+function useSetCompon(obj, data, optionss, compons, emit, index) {
+  if (obj.compon) {
+    const value = getValue(obj, data, index);
+    const componValueName = obj.componValueName || "modelValue";
+    const componObj = {
+      ...obj.config,
+      ...getOnObjs(obj, data, emit),
+      multiple: obj.multiple,
+      [componValueName]: value,
+      ["onUpdate:" + componValueName]: (v) => setValue(v, obj, data),
+      listobj: obj,
+      valueobj: data
+    };
+    if (typeof obj.compon == "string") {
+      return setComponString(
+        value,
+        obj,
+        componObj,
+        data,
+        optionss,
+        compons
+      );
+    } else {
+      return h(obj.compon, componObj);
+    }
+  }
+}
+const useGetDomValue = (obj, data, options, index) => {
+  let value = getValue(obj, data, index);
+  if (obj.options) {
+    value = setOptionsValue(value, obj, data, options) ?? value;
+  }
+  return value;
+};
+const useGetDomLabel = (label, obj, data, slots, optionss, compons, emit, index) => {
+  if (label) {
+    if (isObject(label)) {
+      if (isArray(label)) {
+        return label;
+      } else {
+        label = Object.assign({}, obj, label);
+        const slot = useSetSlot(label, data, slots, index);
+        if (slot) {
+          return slot;
+        }
+        if (label.compon) {
+          const column = useSetCompon(
+            label,
+            data,
+            optionss,
+            compons,
+            emit,
+            index
+          );
+          if (column) {
+            return column;
+          }
+        }
+        return useGetDomValue(label, data, optionss, index);
+      }
+    }
+  }
+  return label;
+};
+function uesObjComponSelected(obj, props) {
+  const arrs = [obj];
+  getFathers(obj, arrs);
+  let componSelected = props.componSelected;
+  arrs.forEach((v) => {
+    componSelected = v.componSelected ?? componSelected;
+  });
+  return componSelected;
+}
+export {
+  getFormRule,
+  getOnObjs,
+  setFormDefaultValue,
+  uesObjComponSelected,
+  useGetDomLabel,
+  useGetDomValue,
+  useHide,
+  useSetCompon,
+  useSetSlot,
+  useVueValue
+};

package/dist/components/company-select/index.cjs

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

package/dist/components/company-select/index.d.ts

@@ -0,0 +1,170 @@
+declare const CompanySelect: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        labels: {
+            type: {
+                (arrayLength: number): import('./src/data').ObjStrAny[];
+                (...items: import('./src/data').ObjStrAny[]): import('./src/data').ObjStrAny[];
+                new (arrayLength: number): import('./src/data').ObjStrAny[];
+                new (...items: import('./src/data').ObjStrAny[]): import('./src/data').ObjStrAny[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default(): never[];
+        };
+        modelValue: {
+            type: {
+                (arrayLength: number): (string | number)[];
+                (...items: (string | number)[]): (string | number)[];
+                new (arrayLength: number): (string | number)[];
+                new (...items: (string | number)[]): (string | number)[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default(): never[];
+        };
+        options: {
+            type: ArrayConstructor;
+            default(): never[];
+        };
+        props: {
+            type: import('vue').PropType<import('./src/data').CompanySelect>;
+            default(): {};
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        props: import('./src/data').CompanySelect;
+        modelValue: (string | number)[];
+        options: unknown[];
+        labels: import('./src/data').ObjStrAny[];
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        labels: {
+            type: {
+                (arrayLength: number): import('./src/data').ObjStrAny[];
+                (...items: import('./src/data').ObjStrAny[]): import('./src/data').ObjStrAny[];
+                new (arrayLength: number): import('./src/data').ObjStrAny[];
+                new (...items: import('./src/data').ObjStrAny[]): import('./src/data').ObjStrAny[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default(): never[];
+        };
+        modelValue: {
+            type: {
+                (arrayLength: number): (string | number)[];
+                (...items: (string | number)[]): (string | number)[];
+                new (arrayLength: number): (string | number)[];
+                new (...items: (string | number)[]): (string | number)[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default(): never[];
+        };
+        options: {
+            type: ArrayConstructor;
+            default(): never[];
+        };
+        props: {
+            type: import('vue').PropType<import('./src/data').CompanySelect>;
+            default(): {};
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, {
+        props: import('./src/data').CompanySelect;
+        modelValue: (string | number)[];
+        options: unknown[];
+        labels: import('./src/data').ObjStrAny[];
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    labels: {
+        type: {
+            (arrayLength: number): import('./src/data').ObjStrAny[];
+            (...items: import('./src/data').ObjStrAny[]): import('./src/data').ObjStrAny[];
+            new (arrayLength: number): import('./src/data').ObjStrAny[];
+            new (...items: import('./src/data').ObjStrAny[]): import('./src/data').ObjStrAny[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): never[];
+    };
+    modelValue: {
+        type: {
+            (arrayLength: number): (string | number)[];
+            (...items: (string | number)[]): (string | number)[];
+            new (arrayLength: number): (string | number)[];
+            new (...items: (string | number)[]): (string | number)[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): never[];
+    };
+    options: {
+        type: ArrayConstructor;
+        default(): never[];
+    };
+    props: {
+        type: import('vue').PropType<import('./src/data').CompanySelect>;
+        default(): {};
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    props: import('./src/data').CompanySelect;
+    modelValue: (string | number)[];
+    options: unknown[];
+    labels: import('./src/data').ObjStrAny[];
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin;
+export { CompanySelect, CompanySelect as default };

package/dist/components/company-select/index.js

@@ -0,0 +1,7 @@
+import { withInstall } from "../../utils/vues/withInstall.js";
+import _sfc_main from "./src/index.js";
+const CompanySelect = withInstall(_sfc_main, "CompanySelect");
+export {
+  CompanySelect,
+  CompanySelect as default
+};

package/dist/components/company-select/src/data.cjs

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const buildProps = require("../../../utils/vues/buildProps.cjs");
+const definePropType = require("../../../utils/vues/definePropType.cjs");
+require("vue");
+require("@fangzhongya/utils/basic/string/splitUpper");
+require("@fangzhongya/utils/basic/array/isArray");
+require("@fangzhongya/utils/basic/object/isObject");
+require("@fangzhongya/utils/basic/string/firstLower");
+require("@fangzhongya/utils/basic/object/hasOwn");
+require("@fangzhongya/utils/basic/string/firstUpper");
+require("@fangzhongya/utils/name/lineToLargeHump");
+require("@fangzhongya/utils/name/lineToSmallHump");
+require("@fangzhongya/utils/name/humpToLine");
+require("@fangzhongya/utils/basic/object/deepCopy");
+require("@fangzhongya/utils/basic/Array/toggleArray");
+require("@fangzhongya/utils/basic/object/objValue");
+require("../../../utils/vues/getBuildProps.cjs");
+require("@fangzhongya/utils/css/setObjStyle");
+require("@fangzhongya/utils/css/getCss");
+const companySelect = {
+  value: "value",
+  //指定选项标签为选项对象的某个属性值
+  label: "label",
+  //指定选项的子选项为选项对象的某个属性值
+  children: "children",
+  //指定选项的禁用为选项对象的某个属性值
+  disabled: "disabled",
+  // 在选中节点改变时，是否返回由该节点所在的各级菜单的值所组成的数组
+  // 若设置 false，则只返回该节点的值
+  emitPath: true,
+  // 是否严格的遵守父子节点不互相关联
+  checkStrictly: true,
+  // 是否动态加载子节点，需与 lazyLoad 方法结合使用
+  lazy: false
+  // // 是否多选
+  // multiple: false,
+};
+const dataProps = buildProps.buildProps({
+  /**
+   * @props { } labels=[] ( )
+   * 展示选择的列
+   */
+  labels: {
+    type: Array,
+    default() {
+      return [];
+    }
+  },
+  /**
+   * @props { String } modelValue= ( )
+   * 输入框展示数据
+   */
+  modelValue: {
+    type: Array,
+    default() {
+      return [];
+    }
+  },
+  /**
+   * @props { Array } options=[] ( )
+   * 选项的数据源， value 和 label 可以通过 props 自定义.
+   */
+  options: {
+    type: Array,
+    default() {
+      return [];
+    }
+  },
+  /**
+   * @props { Object } props={} ( )
+   * 配置选项
+   */
+  props: {
+    type: definePropType.definePropType(Object),
+    default() {
+      return {};
+    }
+  }
+});
+const dataEmits = ["update:modelValue", "change"];
+const dataExpose = {};
+exports.companySelect = companySelect;
+exports.dataEmits = dataEmits;
+exports.dataExpose = dataExpose;
+exports.dataProps = dataProps;

package/dist/components/company-select/src/data.d.ts

@@ -0,0 +1,105 @@
+import { ExtractPropTypes } from 'vue';
+export type ObjStrAny = {
+    [key: string]: any;
+};
+export declare const companySelect: {
+    value: string;
+    label: string;
+    children: string;
+    disabled: string;
+    emitPath: boolean;
+    checkStrictly: boolean;
+    lazy: boolean;
+};
+export type CompanySelect = {
+    value: string;
+    label: string;
+    children: string;
+    disabled: string;
+    lazy: boolean;
+    lazyLoad: Function;
+    multiple: boolean;
+    checkStrictly: boolean;
+};
+export declare const dataProps: {
+    /**
+     * @props { } labels=[] ( )
+     * 展示选择的列
+     */
+    labels: {
+        type: {
+            (arrayLength: number): ObjStrAny[];
+            (...items: ObjStrAny[]): ObjStrAny[];
+            new (arrayLength: number): ObjStrAny[];
+            new (...items: ObjStrAny[]): ObjStrAny[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): never[];
+    };
+    /**
+     * @props { String } modelValue= ( )
+     * 输入框展示数据
+     */
+    modelValue: {
+        type: {
+            (arrayLength: number): (string | number)[];
+            (...items: (string | number)[]): (string | number)[];
+            new (arrayLength: number): (string | number)[];
+            new (...items: (string | number)[]): (string | number)[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): never[];
+    };
+    /**
+     * @props { Array } options=[] ( )
+     * 选项的数据源， value 和 label 可以通过 props 自定义.
+     */
+    options: {
+        type: ArrayConstructor;
+        default(): never[];
+    };
+    /**
+     * @props { Object } props={} ( )
+     * 配置选项
+     */
+    props: {
+        type: import('vue').PropType<CompanySelect>;
+        default(): {};
+    };
+};
+export type DataProps = ExtractPropTypes<typeof dataProps>;
+/**
+ * @emits change (val)
+ * 选择
+ */
+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: {};