@volverjs/ui-vue 0.0.1-beta.12 → 0.0.1-beta.17

package/src/utils/ObjectUtilities.ts

@@ -1,275 +1,281 @@
-export default {
-	/**
-	 * Compare objects, primitives, array, dates, regexp
-	 * @param {any} obj1 first literal
-	 * @param {any} obj2 second literal
-	 * @param {string} field optional field of obj1 and obj2 (also nested dotted field "prop1.prop12")
-	 * @returns {boolean}
-	 */
-	equals(obj1: any, obj2: any, field?: string) {
-		if (field)
-			return (
-				this.resolveFieldData(obj1, field) ===
-				this.resolveFieldData(obj2, field)
-			)
-		else return this.deepEquals(obj1, obj2)
-	},
-
-	/**
-	 * Compare objects, primitives, array, dates, regexp
-	 * @param {any} a first literal
-	 * @param {any} b second literal
-	 * @returns {boolean}
-	 */
-	deepEquals(a: any, b: any) {
-		if (a === b) return true
-
-		if (a && b && typeof a == 'object' && typeof b == 'object') {
-			const arrA = Array.isArray(a)
-			const arrB = Array.isArray(b)
-			let i, length, key
-
-			if (arrA && arrB) {
-				length = a.length
-				if (length != b.length) return false
-				for (i = length; i-- !== 0; )
-					if (!this.deepEquals(a[i], b[i])) return false
+import { unref, type Ref } from 'vue'
+
+/**
+ * Compare objects, primitives, array, dates, regexp
+ * @param {any} obj1 first literal
+ * @param {any} obj2 second literal
+ * @param {string} field optional field of obj1 and obj2 (also nested dotted field "prop1.prop12")
+ * @returns {boolean}
+ */
+// eslint-disable-next-line
+export function equals(obj1: any, obj2: any, field?: string) {
+	if (field)
+		return resolveFieldData(obj1, field) === resolveFieldData(obj2, field)
+	else return deepEquals(obj1, obj2)
+}
 
-				return true
-			}
+/**
+ * Compare objects, primitives, array, dates, regexp
+ * @param {any} a first literal
+ * @param {any} b second literal
+ * @returns {boolean}
+ */
+// eslint-disable-next-line
+export function deepEquals(a: any, b: any) {
+	if (a === b) return true
+
+	if (a && b && typeof a == 'object' && typeof b == 'object') {
+		const arrA = Array.isArray(a)
+		const arrB = Array.isArray(b)
+		let i, length, key
+
+		if (arrA && arrB) {
+			length = a.length
+			if (length != b.length) return false
+			for (i = length; i-- !== 0; )
+				if (!deepEquals(a[i], b[i])) return false
 
-			if (arrA != arrB) return false
+			return true
+		}
 
-			const dateA = a instanceof Date,
-				dateB = b instanceof Date
+		if (arrA != arrB) return false
 
-			if (dateA != dateB) return false
-			if (dateA && dateB) return a.getTime() == b.getTime()
+		const dateA = a instanceof Date,
+			dateB = b instanceof Date
 
-			const regexpA = a instanceof RegExp,
-				regexpB = b instanceof RegExp
+		if (dateA != dateB) return false
+		if (dateA && dateB) return a.getTime() == b.getTime()
 
-			if (regexpA != regexpB) return false
-			if (regexpA && regexpB) return a.toString() == b.toString()
+		const regexpA = a instanceof RegExp,
+			regexpB = b instanceof RegExp
 
-			const keys = Object.keys(a)
+		if (regexpA != regexpB) return false
+		if (regexpA && regexpB) return a.toString() == b.toString()
 
-			length = keys.length
+		const keys = Object.keys(a)
 
-			if (length !== Object.keys(b).length) return false
+		length = keys.length
 
-			for (i = length; i-- !== 0; )
-				if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
-					return false
+		if (length !== Object.keys(b).length) return false
 
-			for (i = length; i-- !== 0; ) {
-				key = keys[i]
-				if (!this.deepEquals(a[key], b[key])) return false
-			}
+		for (i = length; i-- !== 0; )
+			if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false
 
-			return true
+		for (i = length; i-- !== 0; ) {
+			key = keys[i]
+			if (!deepEquals(a[key], b[key])) return false
 		}
 
-		return a !== a && b !== b
-	},
-
-	/**
-	 * Find and return field or nested field from object (also nested dotted field)
-	 * @param {object} data object that contains the field
-	 * @param {string} field ex: "prop1" or "prop1.prop12"
-	 * @returns {boolean}
-	 */
-	resolveFieldData(data: { [key: string]: any }, field: string) {
-		if (data && Object.keys(data).length && field) {
-			if (field.indexOf('.') === -1) {
-				return data[field]
-			} else {
-				const fields = field.split('.')
-				let value = data
-
-				for (let i = 0, len = fields.length; i < len; ++i) {
-					if (data == null) {
-						return null
-					}
-
-					value = value[fields[i]]
-				}
+		return true
+	}
 
-				return value
-			}
+	return a !== a && b !== b
+}
+
+/**
+ * Find and return field or nested field from object (also nested dotted field)
+ * @param {object} data object that contains the field
+ * @param {string} field ex: "prop1" or "prop1.prop12"
+ * @returns {boolean}
+ */
+export function resolveFieldData(data: Record<string, unknown>, field: string) {
+	if (data && Object.keys(data).length && field) {
+		if (field.indexOf('.') === -1) {
+			return data[field]
 		} else {
-			return null
-		}
-	},
-
-	/**
-	 * @param {any} obj data to check
-	 * @returns {boolean}
-	 */
-	isFunction(obj: any) {
-		return !!(obj && obj.constructor && obj.call && obj.apply)
-	},
-
-	/**
-	 * Return the index of value in list array
-	 * @param {any} value the element to find
-	 * @param {Array<any>} list array list
-	 * @returns {number} the index
-	 */
-	findIndexInList(value: any, list: Array<any>) {
-		let index = -1
-
-		if (list) {
-			for (let i = 0; i < list.length; i++) {
-				if (this.equals(list[i], value)) {
-					index = i
-					break
+			const fields = field.split('.')
+			let value = data
+
+			for (let i = 0, len = fields.length; i < len; ++i) {
+				if (data == null) {
+					return null
 				}
+
+				value = value[fields[i]] as Record<string, unknown>
 			}
+
+			return value
 		}
+	} else {
+		return null
+	}
+}
+
+/**
+ * @param {any} obj data to check
+ * @returns {boolean}
+ */
+// eslint-disable-next-line
+export function isFunction(obj: any) {
+	return !!(obj && obj.constructor && obj.call && obj.apply)
+}
 
-		return index
-	},
-
-	/**
-	 * Return the index of value in list array
-	 * @param {any} value the element to find
-	 * @param {Array<any>} list array list
-	 * @returns {boolean} the index
-	 */
-	contains(value: any, list: Array<any>) {
-		if (value != null && list && list.length) {
-			for (const val of list) {
-				if (this.equals(value, val)) return true
+/**
+ * Return the index of value in list array
+ * @param {any} value the element to find
+ * @param {Array<any>} list array list
+ * @returns {number} the index
+ */
+export function findIndexInList<Type = unknown>(value: Type, list: Type[]) {
+	let index = -1
+
+	if (list) {
+		for (let i = 0; i < list.length; i++) {
+			if (equals(list[i], value)) {
+				index = i
+				break
 			}
 		}
+	}
 
-		return false
-	},
-
-	/**
-	 * @param {string | null | undefined | number | Array<any> | object} value element to checj
-	 * @returns {boolean}
-	 */
-	isEmpty(value: string | null | undefined | number | Array<any> | object) {
-		return (
-			value === null ||
-			value === undefined ||
-			value === '' ||
-			(Array.isArray(value) && value.length === 0) ||
-			(!(value instanceof Date) &&
-				typeof value === 'object' &&
-				Object.keys(value).length === 0)
-		)
-	},
-
-	/**
-	 * @param {string | null | undefined | number | Array<any> | object} value element to checj
-	 * @returns {boolean}
-	 */
-	isNotEmpty(
-		value: string | null | undefined | number | Array<any> | object
-	) {
-		return !this.isEmpty(value)
-	},
-
-	/**
-	 * Return the object entries that match the predicate passed
-	 * @param {Object} value
-	 * @param {Function} predicate
-	 * @returns {Object}
-	 */
-	pickBy(value: { [key: string]: any }, predicate: (k: string) => boolean) {
-		return Object.fromEntries(
-			Object.entries(value).filter(([key]) => predicate(key))
-		)
-	},
-
-	/**
-	 * Remove a value from an Array
-	 * @param {any} value the element to remove
-	 * @param {Array<any>} list
-	 * @returns {Array<any>}
-	 */
-	removeFromList(value: any, list: Array<any>) {
-		//check off
-		const indexElToRemove = this.findIndexInList(value, list)
-		if (indexElToRemove > -1) {
-			return list.filter((el, elIndex) => elIndex !== indexElToRemove)
-		} else {
-			return list
+	return index
+}
+
+/**
+ * Return the index of value in list array
+ * @param {any} value the element to find
+ * @param {Array<any>} list array list
+ * @returns {boolean} the index
+ */
+export function contains<Type = unknown>(value: Type, list: Type[]) {
+	if (value != null && list && list.length) {
+		for (const val of list) {
+			if (equals(value, val)) {
+				return true
+			}
 		}
-	},
-
-	/**
-	 * @param {any} value
-	 * @returns {boolean}
-	 */
-	isString(value: any) {
-		return typeof value === 'string' || value instanceof String
-	},
-
-	/**
-	 * Convert props definition to object with "prop" as key and default as value
-	 * @param {ComponentObjectPropsOptions} props vue component props
-	 * @returns {Object}
-	 */
-	propsToObject(props: any) {
-		return Object.keys(props).reduce((initValue: any, value: any) => {
-			if (this.isFunction(props[value])) {
+	}
+	return false
+}
+
+/**
+ * @param {boolean | string | null | undefined | number | Array<unknown> | object} value element to checj
+ * @returns {boolean}
+ */
+export function isEmpty(
+	value:
+		| boolean
+		| string
+		| null
+		| undefined
+		| number
+		| unknown[]
+		| object
+		| Ref
+) {
+	return ((value) =>
+		value === null ||
+		value === undefined ||
+		value === '' ||
+		(Array.isArray(value) && value.length === 0) ||
+		(!(value instanceof Date) &&
+			typeof value === 'object' &&
+			Object.keys(value).length === 0))(unref(value))
+}
+
+/**
+ * Return the object entries that match the predicate passed
+ * @param {Object} value
+ * @param {Function} predicate
+ * @returns {Object}
+ */
+export function pickBy(
+	value: Record<string, unknown>,
+	predicate: (k: string) => boolean
+) {
+	return Object.fromEntries(
+		Object.entries(value).filter(([key]) => predicate(key))
+	)
+}
+
+/**
+ * Remove a value from an Array
+ * @param {any} value the element to remove
+ * @param {Array<any>} list
+ * @returns {Array<any>}
+ */
+export function removeFromList<Type = unknown>(value: Type, list: Type[]) {
+	//check off
+	const indexElToRemove = findIndexInList(value, list)
+	if (indexElToRemove > -1) {
+		return list.filter((el, elIndex) => elIndex !== indexElToRemove)
+	} else {
+		return list
+	}
+}
+
+/**
+ * @param {any} value
+ * @returns {boolean}
+ */
+export function isString(value: unknown) {
+	return typeof value === 'string' || value instanceof String
+}
+
+/**
+ * Convert props definition to object with "prop" as key and default as value
+ * @param {ComponentObjectPropsOptions} props vue component props
+ * @returns {Object}
+ */
+// eslint-disable-next-line
+export function propsToObject(props: any) {
+	return Object.keys(props).reduce(
+		(initValue: Record<string, unknown>, value: string) => {
+			if ('default' in props[value]) {
+				initValue[value] = props[value].default
+				return initValue
+			}
+			if (isFunction(props[value])) {
 				// case prop1: String
 				initValue[value] = props[value]()
-			} else if (Array.isArray(props[value])) {
+				return initValue
+			}
+			if (Array.isArray(props[value])) {
 				// case prop1: [ String, Array ]
 				initValue[value] = props[value][0]()
-			} else if (props[value]?.type) {
-				// case prop1: { type: ... }
-				if (Array.isArray(props[value].type)) {
-					// case prop1: { type: [ String, Array ] }
-					initValue[value] =
-						props[value]?.default || props[value]?.type[0]()
-				} else {
-					// case prop1: { type: String }
-					initValue[value] =
-						props[value]?.default || props[value]?.type()
-				}
+				return initValue
+			}
+			// case prop1: { type: ... }
+			if (Array.isArray(props[value].type)) {
+				initValue[value] = props[value]?.type[0]()
+				return initValue
 			}
+			// case prop1: { type: String }
+			initValue[value] = props[value]?.default ?? props[value]?.type()
 			return initValue
-		}, {})
-	},
-
-	/**
-	 * Filter array objects by filter array
-	 * @param {object[]} list the listo to filter
-	 * @param {object[] | string[]} filter the filter list, array of string or array of object
-	 * @param {string} key
-	 * @return {object[]}
-	 */
-	filterArray<T = { [key: string]: any }>(
-		list: T[],
-		filter: T[] | string[],
-		key: string
-	): T[] {
-		return list.filter((el) => {
-			return filter.some((f) => {
-				return typeof f === 'string'
-					? el[key as keyof typeof el] == f
-					: this.equals(
-							el[key as keyof typeof el],
-							f[key as keyof typeof f]
-					  )
-			})
+		},
+		{} as Record<string, unknown>
+	)
+}
+
+/**
+ * Filter array objects by filter array
+ * @param {object[]} list the listo to filter
+ * @param {object[] | string[]} filter the filter list, array of string or array of object
+ * @param {string} key
+ * @return {object[]}
+ */
+export function filterArray<T = Record<string, unknown>>(
+	list: T[],
+	filter: T[] | string[],
+	key: string
+): T[] {
+	return list.filter((el) => {
+		return filter.some((f) => {
+			return typeof f === 'string'
+				? el[key as keyof typeof el] == f
+				: equals(el[key as keyof typeof el], f[key as keyof typeof f])
 		})
-	},
+	})
+}
 
-	kebabCase(value: string) {
-		if (value) {
-			return value
-				.match(
-					/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g
-				)
-				?.join('-')
-				?.toLowerCase()
-		}
+export function kebabCase(value: string) {
+	if (value) {
+		return value
+			.match(
+				/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g
+			)
+			?.join('-')
+			?.toLowerCase()
 	}
 }

package/dist/components/VvAccordion/VvAccordion.d.ts

@@ -1,32 +0,0 @@
-import type { ExtractPropTypes } from 'vue';
-export declare const VvAccordionProps: {
-    /**
-     * Accordion header title
-     */
-    title: StringConstructor;
-    /**
-     * Accordion content description
-     */
-    content: StringConstructor;
-    /**
-     * (Optional) Defines if item is open. Event "update:open" is emitted on accordion header click
-     */
-    open: BooleanConstructor;
-    /**
-     * Change icon position to right side
-     */
-    iconRight: BooleanConstructor;
-    /**
-     * Add border to accordion item
-     */
-    bordered: BooleanConstructor;
-    /**
-     * String or String[] of css classes (modifiers) that will be concatenated to prefix 'vv-accordion--'
-     */
-    modifiers: (StringConstructor | ArrayConstructor)[];
-    disabled: BooleanConstructor;
-};
-export declare const VvAccordionEvents: string[];
-declare type _VvAccordionPropsType = typeof VvAccordionProps;
-export declare type VvAccordionPropsTypes = ExtractPropTypes<_VvAccordionPropsType>;
-export {};

package/dist/components/VvAccordion/useAccordionProps.d.ts

@@ -1,16 +0,0 @@
-import type { VvAccordionPropsTypes } from './VvAccordion';
-import type IAccordionGroupState from '@/composables/group/types/IAccordionGroupState';
-/**
- * Estreae tutte le prop del componente VvButton che possono essere
- * "sovrascritte" quando il buttone si trova in un gruppo.
- */
-export declare function toAccordionRefs(props: VvAccordionPropsTypes, emit: (event: any, ...args: any[]) => void): {
-    modelValue: import("vue").WritableComputedRef<any>;
-    disabled: import("vue").WritableComputedRef<any>;
-    bordered: import("vue").WritableComputedRef<any>;
-    iconRight: import("vue").WritableComputedRef<any>;
-    isInGroup: import("vue").ComputedRef<boolean>;
-    group: import("vue").Ref<IAccordionGroupState> | undefined;
-    accordion: import("vue").WritableComputedRef<any>;
-    modifiers: import("vue").Ref<string | unknown[] | undefined> | undefined;
-};

package/dist/components/VvButton/useButtonGroupProps.d.ts

@@ -1,18 +0,0 @@
-import type IButtonGroupState from '../../composables/group/types/IButtonGroupState';
-import type { VvButtonPropsTypes } from './VvButton';
-/**
- * Estreae tutte le prop del componente VvButton che possono essere
- * "sovrascritte" quando il buttone si trova in un gruppo.
- */
-export declare function toButtonRefs(props: VvButtonPropsTypes): {
-    modelValue: import("vue").WritableComputedRef<any>;
-    disabled: import("vue").WritableComputedRef<any>;
-    toggle: import("vue").WritableComputedRef<any>;
-    isInGroup: import("vue").ComputedRef<boolean>;
-    group: import("vue").Ref<IButtonGroupState> | undefined;
-    modifiers: import("vue").WritableComputedRef<any>;
-    selected: import("vue").Ref<boolean>;
-    iconPosition: import("vue").Ref<import("./VvButton").ButtonIconPosition>;
-    icon: import("vue").Ref<string | undefined> | undefined;
-    label: import("vue").Ref<string | undefined> | undefined;
-};

package/dist/components/VvCheck/VvCheck.d.ts

@@ -1,47 +0,0 @@
-import type { ExtractPropTypes } from 'vue';
-export declare const VvCheckProps: {
-    /**
-     * Valore della check
-     */
-    value: null;
-    /**
-     * VModel
-     * @description
-     * Se Binary = true, modelValue puo essere Object,Boolean,Number
-     * Altrimenti modelValue sarà un Array
-     */
-    modelValue: null;
-    /**
-     * True - ritorna un valore del checkbox binario (es True/False) invece di un valori multipli
-     */
-    binary: BooleanConstructor;
-    /**
-     * Se binary=true, valore associato allo stato checked (ritornato al posto di TRUE)
-     */
-    trueValue: {
-        type: null;
-        default: boolean;
-    };
-    /**
-     * Se binary=true, valore associato allo stato unchecked (ritornato al posto di FALSE)
-     */
-    falseValue: {
-        type: null;
-        default: boolean;
-    };
-    /**
-     * True - visualizza il VvCheck come un pulsante Switch/Toggle
-     */
-    switch: BooleanConstructor;
-    label: StringConstructor;
-    disabled: BooleanConstructor;
-    readonly: BooleanConstructor;
-    error: BooleanConstructor;
-    errorLabel: (StringConstructor | ArrayConstructor)[];
-    valid: BooleanConstructor;
-    validLabel: (StringConstructor | ArrayConstructor)[];
-};
-export declare const VvCheckEvents: string[];
-declare type _VvCheckPropsType = typeof VvCheckProps;
-export declare type VvCheckPropsTypes = ExtractPropTypes<_VvCheckPropsType>;
-export {};