@fangzhongya/fang-ui 0.1.38 → 0.1.40

package/dist/components/common/css.d.ts

@@ -1,3 +1,10 @@
+/**
+ * 设置样式函数，用于根据配置对象生成最终的样式对象
+ * @param v - 列表对象，包含样式配置信息
+ * @param data - 数据对象，用于样式函数计算
+ * @param props - 属性对象，包含默认的样式配置
+ * @returns 返回合并后的样式对象
+ */
 export declare function setStyles(v: ListObj, data: ObjStr, props: ObjAny): string | {
     [key: string]: string | number;
 };

package/dist/components/common/list.d.ts

@@ -71,6 +71,13 @@ export declare const emits: string[];
 type HandleConfig = {
     getValue: <T>(v: T) => T;
 };
+/**
+ * select选择的通用处理
+ * @param props 组件属性
+ * @param emit 触发事件
+ * @param config 	{ getValue: (v: T) => T } 获取值处理函数
+ * @returns
+ */
 export declare function comHandle(props: any, emit: any, config?: HandleConfig): {
     setMultipleValue: (v: any) => any;
     getMultipleValue: (v: any) => any;

package/dist/components/common/urls.d.ts

@@ -51,5 +51,11 @@ export declare const props: {
 };
 export declare const emits: never[];
 export type UrlProps = ExtractPropTypes<typeof props>;
+/**
+ * 处理通用请求逻辑的函数
+ * @param props 包含请求配置信息的对象
+ * @param obj 额外的参数对象
+ * @returns 返回一个Promise，解析后的数据结果
+ */
 export declare function comHandle(props: UrlProps, obj: ObjAny): ObjAny;
 export declare const expose: {};

package/dist/components/common/use.cjs

@@ -90,17 +90,26 @@ function handleComputedWithoutDefault(obj, v) {
   }
 }
 function setFormDefaultValue(obj, value) {
-  let v = util.getChildrenData(obj, value, true) ?? {};
+  let v = util.getChildrenData(obj, value);
   if (obj.orig) {
-    v = value;
+    v = value ?? {};
   }
   setComputed(obj, v);
   const prop = obj.prop;
   if (prop) {
-    if (obj.pars) {
-      objValue.setObjValue(v, prop, objValue.getObjValue(prop, v) ?? obj.default);
+    if (v) {
+      if (obj.pars) {
+        objValue.setObjValue(v, prop, objValue.getObjValue(prop, v) ?? obj.default);
+      } else {
+        v[prop] = v[prop] ?? obj.default;
+      }
     } else {
-      v[prop] = v[prop] ?? obj.default;
+      v = util.getChildrenData(obj, value, true);
+      if (obj.pars) {
+        objValue.setObjValue(v, prop, objValue.getObjValue(prop, v) ?? obj.default);
+      } else {
+        v[prop] = v[prop] ?? obj.default;
+      }
     }
   }
 }
@@ -150,48 +159,46 @@ function getValueObjs(value, multiple, options, config) {
     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 setOptionsValue(value, obj, data, options = {}) {
+  return getValueObjs(
+    value,
+    obj.multiple,
+    processOptions(value, obj, data, options),
+    obj.config
+  );
 }
 function setValue(value, obj, data) {
-  let v = util.getChildrenData(obj, data) ?? {};
+  let v = util.getChildrenData(obj, data);
   if (obj.orig) {
     v = data ?? {};
   }
   const prop = obj.prop;
   if (prop) {
-    if (obj.pars) {
-      objValue.setObjValue(v, prop, value);
+    if (v) {
+      if (obj.pars) {
+        objValue.setObjValue(v, prop, value);
+      } else {
+        v[prop] = value;
+      }
     } else {
-      v[prop] = value;
+      v = util.getChildrenData(obj, data, true);
+      if (obj.pars) {
+        objValue.setObjValue(v, prop, value);
+      } else {
+        v[prop] = value;
+      }
     }
   }
 }
 function getValue(obj, data, index) {
   const prop = obj.prop;
-  const cdata = util.getChildrenData(obj, data, true) ?? {};
+  const cdata = util.getChildrenData(obj, data);
   let cellValue;
   if (prop) {
     if (obj.pars) {
       cellValue = objValue.getObjValue(prop, cdata);
     } else {
-      cellValue = cdata[prop];
+      cellValue = cdata == null ? void 0 : cdata[prop];
     }
   } else {
     cellValue = obj.value;
@@ -202,36 +209,51 @@ function getValue(obj, data, index) {
     return cellValue ?? obj.default;
   }
 }
-function setComponString(value, obj, componObj, data, optionss, compons) {
-  processOptions(obj, componObj, optionss, value, data);
+function setComponString(value, obj, componObj, compons) {
   const compon = obj.compon;
   const tcom = lineToLargeHump.lineToLargeHump(compon);
-  return renderComponent(tcom, compon, componObj, value, compons);
+  return renderComponent(obj, tcom, compon, componObj, value, compons);
 }
-function processOptions(obj, componObj, optionss, value, data) {
-  if (!(obj == null ? void 0 : obj.options)) return;
-  let options = [];
+function processOptions(value, obj, data, options) {
+  if (!(obj == null ? void 0 : obj.options)) return [];
+  let option = [];
   const opt = obj.options;
   if (typeof opt === "string") {
-    const optionsvalue = optionss[opt];
-    options = typeof optionsvalue == "function" ? optionsvalue(optionss, value, obj, data) || [] : optionsvalue || [];
+    const optionsvalue = options[opt];
+    option = typeof optionsvalue == "function" ? optionsvalue(options, value, obj, data) || [] : optionsvalue || [];
   } else if (typeof opt == "function") {
-    options = opt(optionss, value, obj, data) || [];
+    option = opt(options, value, obj, data) || [];
   } else {
-    options = opt || [];
+    option = opt || [];
   }
-  if ((options == null ? void 0 : options.length) > 0) {
-    componObj.options = options;
+  return option;
+}
+function setSlots(obj) {
+  const slots = obj.slots;
+  if (vue.isVNode(slots)) {
+    return {
+      default: () => slots
+    };
+  } else if (typeof slots === "function") {
+    return {
+      default: slots
+    };
+  } else if (isObject.isObject(slots)) {
+    return slots;
+  } else if (slots) {
+    return {
+      default: () => slots
+    };
   }
 }
-function renderComponent(tcom, compon, componObj, value, compons) {
+function renderComponent(obj, tcom, compon, componObj, value, compons) {
   if (Object.keys(compons).includes(tcom)) {
-    return vue.h(compons[tcom], componObj);
+    return vue.h(compons[tcom], componObj, setSlots(obj));
   }
   if (shared.isHTMLTag(compon) || shared.isSVGTag(compon)) {
     return vue.h(compon, componObj, value);
   }
-  return vue.h(vue.resolveComponent(compon), componObj);
+  return vue.h(vue.resolveComponent(compon), componObj, setSlots(obj));
 }
 function getOnObjs(obj, data, emit, ...arrs) {
   const objs = {};
@@ -252,7 +274,7 @@ function getOnObjs(obj, data, emit, ...arrs) {
   }
   return objs;
 }
-function useSetSlot(obj, data, slots, index, scope) {
+function useSetSlot(obj, data, slots, options, emit, index, scope) {
   const slotname = obj.slot ?? obj.prop;
   if (slotname) {
     const slot = slots[slotname];
@@ -265,50 +287,61 @@ function useSetSlot(obj, data, slots, index, scope) {
           setValue(value2, obj, data);
         }
       });
+      const componObj = getComponObj(
+        value.value,
+        obj,
+        data,
+        options,
+        emit,
+        scope
+      );
       return slot({
-        comscope: scope,
         column: obj,
         row: data,
         value,
-        index
+        index,
+        ...componObj
       });
     }
   }
 }
-function useSetCompon(obj, data, optionss, compons, emit, index, scope) {
+function getComponObj(value, obj, data, options, emit, scope) {
+  const componValueName = obj.componValueName || "modelValue";
+  const componObj = {
+    // ...attrs,
+    [componValueName]: value,
+    ["onUpdate:" + componValueName]: (v) => setValue(v, obj, data),
+    listobj: obj,
+    valueobj: data,
+    comscope: scope,
+    ...obj.config,
+    ...getOnObjs(obj, data, emit, scope)
+  };
+  if (obj.multiple) {
+    componObj.multiple = obj.multiple;
+  }
+  const option = processOptions(value, obj, data, options);
+  if (option.length > 0) {
+    componObj.options = option;
+  }
+  return componObj;
+}
+function useSetCompon(obj, data, options, compons, emit, index, scope) {
   if (obj.compon) {
     const value = getValue(obj, data, index);
-    const componValueName = obj.componValueName || "modelValue";
-    const attrs = vue.useAttrs();
-    const componObj = {
-      ...attrs,
-      ...obj.config,
-      ...getOnObjs(obj, data, emit, scope),
-      [componValueName]: value,
-      ["onUpdate:" + componValueName]: (v) => setValue(v, obj, data),
-      listobj: obj,
-      valueobj: data,
-      comscope: scope
-    };
-    if (obj.multiple) {
-      componObj.multiple = obj.multiple;
-    }
-    if (typeof obj.compon == "string") {
-      return setComponString(
-        value,
-        obj,
-        componObj,
-        data,
-        optionss,
-        compons
-      );
-    } else if (typeof obj.compon == "function") {
-      return obj.compon(componObj);
-    } else if (vue.isVNode(obj.compon)) {
-      return obj.compon;
-    } else {
-      return vue.h(obj.compon, componObj);
-    }
+    const componObj = getComponObj(value, obj, data, options, emit, scope);
+    return useGetCompon(obj.compon, componObj, obj, compons, value);
+  }
+}
+function useGetCompon(compon, componObj, obj, compons, value) {
+  if (typeof compon == "string") {
+    return setComponString(value, obj, componObj, compons);
+  } else if (typeof compon == "function") {
+    return compon(componObj, setSlots(obj));
+  } else if (vue.isVNode(compon)) {
+    return compon;
+  } else {
+    return vue.h(compon, componObj, setSlots(obj));
   }
 }
 const useGetDomValue = (obj, data, options, index) => {
@@ -318,7 +351,8 @@ const useGetDomValue = (obj, data, options, index) => {
   }
   return value;
 };
-const useGetDomLabel = (label, obj, data, slots, optionss, compons, emit, index, isComponSelected = (obj2) => true) => {
+const useGetDomLabel = (obj, data, slots, options, compons, emit, index) => {
+  const label = obj.label;
   if (!label) {
     return label;
   }
@@ -331,65 +365,47 @@ const useGetDomLabel = (label, obj, data, slots, optionss, compons, emit, index,
   if (!isObject.isObject(label)) {
     return label;
   }
-  return handleObjectLabel(
-    label,
-    obj,
-    data,
-    slots,
-    optionss,
-    compons,
-    emit,
-    index,
-    isComponSelected
-  );
-};
-const handleObjectLabel = (label, obj, data, slots, optionss, compons, emit, index, isComponSelected) => {
   if (Array.isArray(label)) {
-    return renderLabelArray(label, data, optionss, compons, emit, index);
-  }
-  return handleSingleObjectLabel(
-    label,
-    obj,
-    data,
-    slots,
-    optionss,
+    return renderLabelArray(label, data, options, compons, emit, index);
+  }
+  return useVNodeComponDom(label, data, slots, emit, {
+    options,
     compons,
-    emit,
-    index,
-    isComponSelected
-  );
+    index
+  });
 };
-const renderLabelArray = (labels, data, optionss, compons, emit, index) => {
+const renderLabelArray = (labels, data, options, compons, emit, index) => {
   return vue.h(
     "div",
     { class: "com-lable-array" },
     labels.map((v) => {
       const labelObj = typeof v === "string" ? { value: v, compon: "div" } : v;
-      return useSetCompon(labelObj, data, optionss, compons, emit, index);
+      return useSetCompon(labelObj, data, options, compons, emit, index);
     })
   );
 };
-const handleSingleObjectLabel = (label, obj, data, slots, optionss, compons, emit, index, isComponSelected) => {
-  const mergedLabel = { ...obj, ...label };
-  const slot = useSetSlot(mergedLabel, data, slots, index);
+function useVNodeComponDom(obj, data, slots, emit, config) {
+  const { options, compons, index, scope } = config;
+  const slot = useSetSlot(obj, data, slots, options, emit, index, scope);
   if (slot) {
     return slot;
   }
-  if (mergedLabel.compon && isComponSelected(obj)) {
+  if (obj.compon) {
     const column = useSetCompon(
-      mergedLabel,
+      obj,
       data,
-      optionss,
+      options,
       compons,
       emit,
-      index
+      index,
+      scope
     );
     if (column) {
       return column;
     }
   }
-  return useGetDomValue(mergedLabel, data, optionss, index);
-};
+  return useGetDomValue(obj, data, options, index);
+}
 function useObjComponSelected(obj, props) {
   const arrs = [obj];
   util.getFathers(obj, arrs);
@@ -428,27 +444,38 @@ function getVNodeContent(vnode) {
   vue.render(null, container);
   return textContent;
 }
-function getLabelText(label) {
-  if (typeof label == "undefined") {
-    return "";
-  } else if (typeof label == "string") {
-    return label;
-  } else if (typeof label == "function") {
-    label = label();
+function getLabelText(obj) {
+  if (obj.labelText) {
+    return obj.labelText;
+  }
+  if (!obj.label) {
+    const farrs = [];
+    util.getFathers(obj, farrs);
+    farrs.reverse();
+    for (const v of farrs) {
+      if (v.labelText) {
+        return v.labelText;
+      } else if (v.label) {
+        obj = v;
+        break;
+      }
+    }
   }
+  const label = useGetDomLabel(obj, {}, {}, {}, {}, () => {
+  }, 0);
   if (vue.isVNode(label)) {
     return getVNodeContent(label);
-  } else if (Array.isArray(label)) {
-    return label.join("");
   } else {
     return (label == null ? void 0 : label.toString()) || "";
   }
 }
+exports.getComponObj = getComponObj;
 exports.getFormRule = getFormRule;
 exports.getLabelText = getLabelText;
 exports.getOnObjs = getOnObjs;
 exports.getVNodeContent = getVNodeContent;
 exports.setFormDefaultValue = setFormDefaultValue;
+exports.useGetCompon = useGetCompon;
 exports.useGetDomLabel = useGetDomLabel;
 exports.useGetDomValue = useGetDomValue;
 exports.useHide = useHide;
@@ -458,4 +485,5 @@ exports.usePropsDefault = usePropsDefault;
 exports.useSetCompon = useSetCompon;
 exports.useSetSlot = useSetSlot;
 exports.useSetValue = useSetValue;
+exports.useVNodeComponDom = useVNodeComponDom;
 exports.useVueValue = useVueValue;

package/dist/components/common/use.d.ts

@@ -1,25 +1,131 @@
 import { Component, VNode } from 'vue';
+/**
+ * 根据指定的键或函数从对象中提取值
+ * @param v - 要处理的值，通常是一个对象
+ * @param key - 字符串类型的属性名或函数，用于提取值
+ * @returns 如果key是函数则返回函数执行结果，如果key是字符串则返回对象对应属性值，否则返回原值
+ */
 export declare function useVueValue(v: any, key: string | Function): any;
+/**
+ * 设置对象属性值的工具函数
+ * @param v - 要设置值的目标对象
+ * @param key - 属性名或设置函数，可以是字符串或函数类型
+ * @param value - 要设置的值
+ * @returns 返回修改后的对象
+ */
 export declare function useSetValue(v: any, key: string | Function, value: any): any;
+/**
+ * 获取表单规则路径
+ * @param obj - 包含属性和父子关系的对象
+ * @returns 返回格式化的属性路径字符串
+ */
 export declare function getFormRule(obj: ListObj): string | undefined;
+/**
+ * 设置表单默认值
+ * @param obj - 列表对象，包含表单配置信息
+ * @param value - 表单值对象，用于设置默认值的数据源
+ */
 export declare function setFormDefaultValue(obj: ListObj, value: ObjAny): void;
+/**
+ * 判断列表对象是否应该隐藏
+ * @param v - 列表对象，可能包含hide属性
+ * @param form - 表单数据，可选参数，用于hide函数的计算
+ * @returns 返回是否隐藏的布尔值，如果v.hide是函数则执行函数返回结果，如果是布尔值则直接返回，否则返回false
+ */
 export declare function useHide(v: ListObj, form?: any): boolean;
+/**
+ * 获取事件处理对象集合
+ * @param obj - 包含事件配置的对象
+ * @param data - 数据对象
+ * @param emit - 事件发射函数
+ * @param arrs - 额外的参数数组
+ * @returns 返回一个包含事件处理函数的对象
+ */
 export declare function getOnObjs(obj: ListObj, data: ObjAny, emit: Function, ...arrs: any[]): {
     [key: string]: (...arr: any[]) => void;
 };
 type Compons = {
     [key: string]: Component;
 };
-export declare function useSetSlot(obj: ListObj, data: ObjAny, slots: ObjAny, index?: number, scope?: ObjAny): any;
-export declare function useSetCompon(obj: ListObj, data: ObjAny, optionss: ObjAny, compons: Compons, emit: Function, index?: number, scope?: ObjAny): any;
-export declare const useGetDomValue: (obj: ListObj, data: ObjAny, options: ObjAny, index?: number) => any;
-export declare const useGetDomLabel: (label: string | ListObj | VNode | Function | undefined, obj: ListObj, data: ObjAny, slots: ObjAny, optionss: ObjAny, compons: Compons, emit: Function, index: number, isComponSelected?: (obj: ListObj) => boolean) => any;
+/**
+ * 设置并渲染插槽内容的自定义hook函数
+ *
+ * @param obj - 列表对象配置，包含插槽名称或属性名
+ * @param data - 数据对象，用于获取和设置值
+ * @param slots - 插槽映射对象，存储可用的插槽函数
+ * @param index - 可选的索引值，用于数据定位
+ * @param scope - 可选的作用域对象，传递给插槽函数
+ * @returns 插槽函数执行结果或undefined
+ */
+export declare function useSetSlot(obj: ListObj, data: ObjAny, slots: ObjAny, options: ObjAny, emit: Function, index?: number | number[], scope?: ObjAny): any;
+export declare function getComponObj(value: any, obj: ListObj, data: ObjAny, options: ObjAny, emit: Function, scope?: ObjAny): {
+    [x: string]: any;
+    listobj: ListObj;
+    valueobj: ObjAny;
+    comscope: ObjAny | undefined;
+};
+/**
+ * 根据配置对象设置组件
+ * @param obj - 列表对象配置，包含组件相关配置信息
+ * @param data - 数据对象，用于获取和设置组件值
+ * @param options - 选项配置对象
+ * @param compons - 组件集合
+ * @param emit - 事件发射函数
+ * @param index - 索引值，可选参数
+ * @param scope - 作用域对象，可选参数
+ * @returns 返回创建的组件节点或组件调用结果
+ */
+export declare function useSetCompon(obj: ListObj, data: ObjAny, options: ObjAny, compons: Compons, emit: Function, index?: number | number[], scope?: ObjAny): any;
+export declare function useGetCompon(compon: any, componObj: ObjAny, obj: ListObj, compons: Compons, value: any): any;
+/**
+ * 获取DOM元素的值
+ * @param obj - 列表对象配置
+ * @param data - 数据对象
+ * @param options - 选项配置对象
+ * @param index - 可选的索引值
+ * @returns 返回处理后的值
+ */
+export declare const useGetDomValue: (obj: ListObj, data: ObjAny, options: ObjAny, index?: number | number[]) => any;
+/**
+ * 获取DOM标签的处理函数
+ * @param obj - 包含label属性的对象
+ * @param data - 数据对象
+ * @param slots - 插槽对象
+ * @param options - 选项配置对象
+ * @param compons - 组件对象
+ * @param emit - 事件发射函数
+ * @param index - 索引值
+ * @returns 返回处理后的标签内容，可能是字符串、VNode或渲染后的数组/对象
+ */
+export declare const useGetDomLabel: (obj: ListObj, data: ObjAny, slots: ObjAny, options: ObjAny, compons: Compons, emit: Function, index: number) => any;
+/**
+ * 根据配置对象处理虚拟节点的组件或DOM渲染
+ * @param obj - 列表对象配置，包含标签和组件信息
+ * @param data - 数据对象，用于渲染的数据源
+ * @param slots - 插槽配置对象
+ * @param options - 选项配置对象
+ * @param compons - 组件集合
+ * @param emit - 事件发射函数
+ * @param index - 当前项的索引
+ * @param config - 可选的额外配置对象
+ * @returns 处理后的虚拟节点、组件或DOM值
+ */
+export declare function useVNodeComponDom(obj: ListObj, data: ObjAny, slots: ObjAny, emit: Function, config: ObjAny): any;
+/**
+ * 获取对象及其父级链中选中的组件
+ * @param obj - 当前列表对象
+ * @param props - 包含组件选择状态的属性对象
+ * @returns 返回在对象层级链中找到的选中组件，如果没有则返回默认选中组件
+ */
 export declare function useObjComponSelected(obj: ListObj, props: ObjAny): any;
 /**
  * 设置获取默认值
- * @param props
- * @param keyObj
- * @returns
+ * 创建一个代理对象，用于处理属性默认值
+ * 当访问的属性值为undefined时，会调用对应的默认值函数来获取默认值
+ *
+ * @param props 原始属性对象
+ * @param keyObj 包含属性键和对应默认值函数的对象
+ * @returns 返回一个代理对象，支持默认值处理
  */
 export declare function usePropsDefault(props: any, keyObj: {
     [key: string]: () => any;
@@ -42,5 +148,5 @@ export declare function getVNodeContent(vnode: VNode): string;
  * @param label
  * @returns
  */
-export declare function getLabelText(label: string | ListObj | VNode | Function | undefined): string;
+export declare function getLabelText(obj: ListObj): string;
 export {};