@fangzhongya/fang-ui 0.0.14 → 0.0.16

package/dist/components/common/use.ts

@@ -0,0 +1,381 @@
+import { computed, h, resolveComponent, type Component } from 'vue';
+import {
+	isObject,
+	getFathers,
+	getChildrenData,
+	setObjValue,
+	firstLower,
+	lineToLargeHump,
+	getObjValue,
+	isArray,
+} from '../../utils/index';
+
+export function useVueValue(v: any, key: string | Function) {
+	if (key && isObject(v)) {
+		if (typeof key == 'function') {
+			return key(v);
+		} else if (typeof key == 'string') {
+			return v[key];
+		}
+	}
+	return v;
+}
+
+export function getFormRule(obj: ListObj) {
+	const prop = obj.prop;
+	if (obj.orig) {
+		return prop;
+	} else {
+		const farrs: ListObj[] = [];
+		getFathers(obj, farrs);
+		if (farrs.length > 0) {
+			let fps: string[] = [];
+			farrs.forEach((obj: ListObj) => {
+				if (obj.orig) {
+					fps = [];
+				} else {
+					if (obj.prop) {
+						fps.push(obj.prop);
+					}
+				}
+			});
+			fps.push(prop as string);
+			return fps.join('.');
+		} else {
+			return prop;
+		}
+	}
+}
+
+export function setFormDefaultValue(obj: ListObj, value: ObjAny) {
+	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;
+		}
+	}
+}
+
+export function useHide(v: ListObj, form?: any) {
+	if (v.hide) {
+		if (typeof v.hide == 'function') {
+			return v.hide(form, v);
+		} else {
+			return v.hide;
+		}
+	} else {
+		return false;
+	}
+}
+
+function getValueObjs(
+	value: string,
+	multiple: boolean | string,
+	options: ObjAny[],
+	config?: ObjAny,
+) {
+	if (value !== undefined && value !== null) {
+		if (multiple) {
+			if (multiple === true) {
+				const d = options?.filter((o: any) => {
+					return value.includes(
+						useVueValue(o, config?.prop ?? 'value'),
+					);
+				});
+				return d
+					.map((o) => {
+						return (
+							o[config?.label ?? 'label'] ??
+							useVueValue(o, config?.prop ?? 'value')
+						);
+					})
+					.join(',');
+			} else {
+				const z = value.split(multiple);
+				const d = options?.filter((o: any) => {
+					return z.includes(useVueValue(o, config?.prop ?? 'value'));
+				});
+				return d
+					.map((o) => {
+						return (
+							o[config?.label ?? 'label'] ??
+							useVueValue(o, config?.prop ?? 'value')
+						);
+					})
+					.join(multiple);
+			}
+		} else {
+			const d = options?.filter((o: any) => {
+				return useVueValue(o, config?.prop ?? 'value') === value;
+			});
+			if (d.length > 0) {
+				return d[0][config?.label ?? 'label'] ?? value;
+			} else {
+				return value;
+			}
+		}
+	} else {
+		return value;
+	}
+}
+
+function setOptionsValue(
+	value: string,
+	obj: ListObj,
+	data: ObjAny,
+	optionss: ObjAny,
+) {
+	let options = [];
+	if (obj?.options) {
+		const opt = obj.options;
+		if (typeof opt === 'string') {
+			const value = optionss[opt];
+			if (typeof value == 'function') {
+				options = value(optionss, value, obj, data) || [];
+			} else {
+				options = value || [];
+			}
+		} 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: string, obj: ListObj, data: ObjAny) {
+	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: ListObj, data: ObjAny, index?: number) {
+	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: string,
+	obj: ListObj,
+	componObj: ObjAny,
+	data: ObjAny,
+	optionss: ObjAny,
+	compons: Compons,
+) {
+	if (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 as string;
+	const tcom = lineToLargeHump(compon);
+	if (Object.keys(compons).includes(tcom)) {
+		return h(compons[tcom], componObj);
+	} else {
+		// const components = getCurrentInstance()?.appContext?.components
+		// if (components && Object.keys(components).includes(tcom)) {
+		//   return h(resolveComponent(tcom), componObj)
+		// } else {
+		//   return h(obj.compon, componObj)
+		// }
+		return h(resolveComponent(compon), componObj);
+	}
+}
+
+export function getOnObjs(
+	obj: ListObj,
+	data: ObjAny,
+	emit: Function,
+	...arrs: any[]
+) {
+	const objs: {
+		[key: string]: (...arr: any[]) => void;
+	} = {};
+	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: any[]) => {
+			if (es[key] && typeof es[key] == 'function') {
+				es[key](...v, data, obj);
+			} else {
+				emit('list-events', key, ...v, data, obj, ...arrs);
+			}
+		};
+	});
+	return objs;
+}
+
+type Compons = { [key: string]: Component };
+
+export function useSetSlot(
+	obj: ListObj,
+	data: ObjAny,
+	slots: ObjAny,
+	index?: number,
+) {
+	const slotname = obj.slot ?? obj.prop;
+	if (slotname) {
+		const slot = slots[slotname];
+		if (slot) {
+			const value = computed({
+				get() {
+					return getValue(obj, data, index);
+				},
+				set(value) {
+					setValue(value, obj, data);
+				},
+			});
+			return slot({
+				column: obj,
+				row: data,
+				value: value,
+				index,
+			});
+		}
+	}
+}
+
+export function useSetCompon(
+	obj: ListObj,
+	data: ObjAny,
+	optionss: ObjAny,
+	compons: Compons,
+	emit: Function,
+	index?: number,
+) {
+	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: any) => 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);
+		}
+	}
+}
+
+export const useGetDomValue = (
+	obj: ListObj,
+	data: ObjAny,
+	options: ObjAny,
+	index?: number,
+) => {
+	let value = getValue(obj, data, index);
+	if (obj.options) {
+		value = setOptionsValue(value, obj, data, options) ?? value;
+	}
+	return value;
+};
+
+export const useGetDomLabel = (
+	label: string | ListObj | undefined,
+	obj: ListObj,
+	data: ObjAny,
+	slots: ObjAny,
+	optionss: ObjAny,
+	compons: Compons,
+	emit: Function,
+	index: number,
+) => {
+	if (label) {
+		if (isObject(label)) {
+			if (isArray(label)) {
+				return label;
+			} else {
+				label = Object.assign({}, obj, label) as ListObj;
+				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;
+};
+
+export function uesObjComponSelected(obj: ListObj, props: ObjAny) {
+	const arrs: ListObj[] = [obj];
+	getFathers(obj, arrs);
+	let componSelected = props.componSelected;
+	arrs.forEach((v) => {
+		componSelected = v.componSelected ?? componSelected;
+	});
+	return componSelected;
+}

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

@@ -1,11 +1,13 @@
+import { CreateComponentPublicInstanceWithMixins, ExtractPropTypes, PropType, ComponentOptionsMixin, PublicProps, GlobalComponents, GlobalDirectives, ComponentProvideOptions, ComponentOptionsBase, VNodeProps, AllowedComponentProps, ComponentCustomProps, Plugin } from 'vue';
+import { ObjStrAny, CompanySelect } from './src/data';
 declare const CompanySelect: {
-    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< 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[];
+                (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[];
@@ -43,28 +45,28 @@ declare const CompanySelect: {
             default(): never[];
         };
         props: {
-            type: import('vue').PropType<import('./src/data').CompanySelect>;
+            type: PropType<CompanySelect>;
             default(): {};
         };
-    }>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
-        props: import('./src/data').CompanySelect;
+    }>> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
+        props: CompanySelect;
         modelValue: (string | number)[];
         options: unknown[];
-        labels: import('./src/data').ObjStrAny[];
-    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        labels: ObjStrAny[];
+    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLDivElement, ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
         C: {};
         M: {};
         Defaults: {};
-    }, Readonly<import('vue').ExtractPropTypes<{
+    }, Readonly< 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[];
+                (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[];
@@ -102,25 +104,25 @@ declare const CompanySelect: {
             default(): never[];
         };
         props: {
-            type: import('vue').PropType<import('./src/data').CompanySelect>;
+            type: PropType<CompanySelect>;
             default(): {};
         };
     }>> & Readonly<{}>, {}, {}, {}, {}, {
-        props: import('./src/data').CompanySelect;
+        props: CompanySelect;
         modelValue: (string | number)[];
         options: unknown[];
-        labels: import('./src/data').ObjStrAny[];
+        labels: ObjStrAny[];
     }>;
     __isFragment?: never;
     __isTeleport?: never;
     __isSuspense?: never;
-} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+} & ComponentOptionsBase<Readonly< 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[];
+            (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[];
@@ -158,13 +160,13 @@ declare const CompanySelect: {
         default(): never[];
     };
     props: {
-        type: import('vue').PropType<import('./src/data').CompanySelect>;
+        type: PropType<CompanySelect>;
         default(): {};
     };
-}>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
-    props: import('./src/data').CompanySelect;
+}>> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+    props: 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;
+    labels: ObjStrAny[];
+}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & Plugin;
 export { CompanySelect, CompanySelect as default };

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

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

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

@@ -1,7 +1,6 @@
 "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");
@@ -15,7 +14,9 @@ require("@fangzhongya/utils/name/humpToLine");
 require("@fangzhongya/utils/basic/object/deepCopy");
 require("@fangzhongya/utils/basic/Array/toggleArray");
 require("@fangzhongya/utils/basic/object/objValue");
+const definePropType = require("../../../utils/vues/definePropType.cjs");
 require("../../../utils/vues/getBuildProps.cjs");
+require("../../../utils/vues/withInstall.cjs");
 require("@fangzhongya/utils/css/setObjStyle");
 require("@fangzhongya/utils/css/getCss");
 const companySelect = {

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

@@ -1,4 +1,4 @@
-import { ExtractPropTypes } from 'vue';
+import { ExtractPropTypes, PropType } from 'vue';
 export type ObjStrAny = {
     [key: string]: any;
 };
@@ -81,7 +81,7 @@ export declare const dataProps: {
      * 配置选项
      */
     props: {
-        type: import('vue').PropType<CompanySelect>;
+        type: PropType<CompanySelect>;
         default(): {};
     };
 };

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

@@ -1,5 +1,4 @@
 import { buildProps } from "../../../utils/vues/buildProps.js";
-import { definePropType } from "../../../utils/vues/definePropType.js";
 import "vue";
 import "@fangzhongya/utils/basic/string/splitUpper";
 import "@fangzhongya/utils/basic/array/isArray";
@@ -13,7 +12,9 @@ import "@fangzhongya/utils/name/humpToLine";
 import "@fangzhongya/utils/basic/object/deepCopy";
 import "@fangzhongya/utils/basic/Array/toggleArray";
 import "@fangzhongya/utils/basic/object/objValue";
+import { definePropType } from "../../../utils/vues/definePropType.js";
 import "../../../utils/vues/getBuildProps.js";
+import "../../../utils/vues/withInstall.js";
 import "@fangzhongya/utils/css/setObjStyle";
 import "@fangzhongya/utils/css/getCss";
 const companySelect = {

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

@@ -0,0 +1,114 @@
+import type { ExtractPropTypes } from 'vue';
+
+import { buildProps } from '../../../utils/index';
+import { definePropType } from '../../../utils/index';
+
+export type ObjStrAny = {
+	[key: string]: any;
+};
+
+export const companySelect = {
+	value: 'value',
+	//指定选项标签为选项对象的某个属性值
+	label: 'label',
+	//指定选项的子选项为选项对象的某个属性值
+	children: 'children',
+	//指定选项的禁用为选项对象的某个属性值
+	disabled: 'disabled',
+	// 在选中节点改变时，是否返回由该节点所在的各级菜单的值所组成的数组
+	// 若设置 false，则只返回该节点的值
+	emitPath: true,
+	// 是否严格的遵守父子节点不互相关联
+	checkStrictly: true,
+	// 是否动态加载子节点，需与 lazyLoad 方法结合使用
+	lazy: false,
+	// // 是否多选
+	// multiple: false,
+};
+
+export type CompanySelect = {
+	//指定选项的值为选项对象的某个属性值
+	value: string;
+	//指定选项标签为选项对象的某个属性值
+	label: string;
+	//指定选项的子选项为选项对象的某个属性值
+	children: string;
+	//指定选项的禁用为选项对象的某个属性值
+	disabled: string;
+	// // 在选中节点改变时，是否返回由该节点所在的各级菜单的值所组成的数组，若设置 false，则只返回该节点的值
+	// emitPath: boolean;
+	// 是否动态加载子节点，需与 lazyLoad 方法结合使用
+	lazy: boolean;
+	// 加载动态数据的方法，仅在 lazy 为 true 时有效
+	lazyLoad: Function;
+	// 是否多选
+	multiple: boolean;
+	// 是否严格的遵守父子节点不互相关联
+	checkStrictly: boolean;
+};
+
+export const dataProps = buildProps({
+	/**
+	 * @props { } labels=[] ( )
+	 * 展示选择的列
+	 */
+	labels: {
+		type: Array<ObjStrAny>,
+		default() {
+			return [];
+		},
+	},
+	/**
+	 * @props { String } modelValue= ( )
+	 * 输入框展示数据
+	 */
+	modelValue: {
+		type: Array<string | number>,
+		default() {
+			return [];
+		},
+	},
+	/**
+	 * @props { Array } options=[] ( )
+	 * 选项的数据源， value 和 label 可以通过 props 自定义.
+	 */
+	options: {
+		type: Array,
+		default() {
+			return [];
+		},
+	},
+	/**
+	 * @props { Object } props={} ( )
+	 * 配置选项
+	 */
+	props: {
+		type: definePropType<CompanySelect>(Object),
+		default() {
+			return {};
+		},
+	},
+});
+
+export type DataProps = ExtractPropTypes<typeof dataProps>;
+
+/**
+ * @emits change (val)
+ * 选择
+ */
+export const dataEmits = ['update:modelValue', 'change'];
+
+export type DataEmits = typeof dataEmits;
+
+/**
+ * @slot default 默认插槽
+ */
+export const dataSlot = {
+	default: 'default',
+};
+
+/**
+ * @expose setValue (val:<string>设置的数据 )
+ * 设置值
+ */
+export const dataExpose = {};