@volverjs/ui-vue 0.0.10-beta.5 → 0.0.10-beta.51

package/src/utils/ObjectUtilities.ts

@@ -7,12 +7,12 @@ import type { Ref } from 'vue'
  * @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)
-	}
-	return deepEquals(obj1, obj2)
+    if (field) {
+        return resolveFieldData(obj1, field) === resolveFieldData(obj2, field)
+    }
+    return deepEquals(obj1, obj2)
 }
 
 /**
@@ -21,94 +21,108 @@ export function equals(obj1: any, obj2: any, field?: string) {
  * @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
-
-			return true
-		}
-
-		if (arrA != arrB) return false
-
-		const dateA = a instanceof Date,
-			dateB = b instanceof Date
-
-		if (dateA != dateB) return false
-		if (dateA && dateB) return a.getTime() == b.getTime()
-
-		const regexpA = a instanceof RegExp,
-			regexpB = b instanceof RegExp
-
-		if (regexpA != regexpB) return false
-		if (regexpA && regexpB) return a.toString() == b.toString()
-
-		const keys = Object.keys(a)
-
-		length = keys.length
 
-		if (length !== Object.keys(b).length) return false
-
-		for (i = length; i-- !== 0; )
-			if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false
-
-		for (i = length; i-- !== 0; ) {
-			key = keys[i]
-			if (!deepEquals(a[key], b[key])) return false
-		}
-
-		return true
-	}
-
-	return a !== a && b !== b
+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
+            }
+
+            return true
+        }
+
+        if (arrA !== arrB)
+            return false
+
+        const dateA = a instanceof Date
+        const dateB = b instanceof Date
+
+        if (dateA !== dateB)
+            return false
+        if (dateA && dateB)
+            return a.getTime() === b.getTime()
+
+        const regexpA = a instanceof RegExp
+        const regexpB = b instanceof RegExp
+
+        if (regexpA !== regexpB)
+            return false
+        if (regexpA && regexpB)
+            return a.toString() === b.toString()
+
+        const keys = Object.keys(a)
+
+        length = keys.length
+
+        if (length !== Object.keys(b).length)
+            return false
+
+        for (i = length; i-- !== 0;) {
+            if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
+                return false
+        }
+
+        for (i = length; i-- !== 0;) {
+            key = keys[i]
+            if (!deepEquals(a[key], b[key]))
+                return false
+        }
+
+        return true
+    }
+    return Number.isNaN(a) && Number.isNaN(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}
+ * @returns {boolean} the field value
  */
 export function resolveFieldData(data: Record<string, unknown>, 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]] as Record<string, unknown>
-			}
-
-			return value
-		}
-	} else {
-		return null
-	}
+    if (data && Object.keys(data).length && field) {
+        if (!field.includes('.')) {
+            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]] 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 !!(obj && obj.constructor && obj.call && obj.apply)
 }
 
 /**
@@ -118,18 +132,18 @@ export function isFunction(obj: any) {
  * @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 index
+    let index = -1
+
+    if (list) {
+        for (let i = 0; i < list.length; i++) {
+            if (equals(list[i], value)) {
+                index = i
+                break
+            }
+        }
+    }
+
+    return index
 }
 
 /**
@@ -139,120 +153,121 @@ export function findIndexInList<Type = unknown>(value: Type, list: Type[]) {
  * @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
-			}
-		}
-	}
-	return false
+    if (value != null && list && list.length) {
+        for (const val of list) {
+            if (equals(value, val)) {
+                return true
+            }
+        }
+    }
+    return false
 }
 
 /**
  * @param {boolean | string | null | undefined | number | Array<unknown> | object} value element to checj
- * @returns {boolean}
+ * @returns {boolean} true if value is empty
  */
 export function isEmpty(
-	value:
-		| boolean
-		| string
-		| null
-		| undefined
-		| number
-		| unknown[]
-		| object
-		| Ref,
+    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 (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 {object} value
  * @param {Function} predicate
- * @returns {Object}
+ * @returns {object} the object entries
  */
 export function pickBy(
-	value: Record<string, unknown>,
-	predicate: (k: string) => boolean,
+    value: Record<string, unknown>,
+    predicate: (k: string) => boolean,
 ) {
-	return Object.fromEntries(
-		Object.entries(value).filter(([key]) => predicate(key)),
-	)
+    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>}
+ * @returns {Array<any>} the list without the value
  */
 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
-	}
+    // 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}
+ * @returns {boolean} true if value is a string
  */
 export function isString(value: unknown) {
-	return typeof value === 'string' || value instanceof String
+    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}
+ * @returns {object}
  */
-// eslint-disable-next-line
+
 export function propsToObject(props: any) {
-	return Object.keys(props).reduce(
-		(accumulator: Record<string, unknown>, key: string) => {
-			if (key === 'modelValue') {
-				return accumulator
-			}
-			if ('default' in props[key]) {
-				accumulator[key] =
-					typeof props[key].default === 'function'
-						? props[key].default()
-						: props[key].default
-				return accumulator
-			}
-			if (isFunction(props[key])) {
-				// case prop1: String
-				accumulator[key] = props[key]()
-				return accumulator
-			}
-			if (Array.isArray(props[key])) {
-				// case prop1: [ String, Array ]
-				accumulator[key] = props[key][0]()
-				return accumulator
-			}
-			// case prop1: { type: ... }
-			if (Array.isArray(props[key].type)) {
-				accumulator[key] = props[key]?.type[0]()
-				return accumulator
-			}
-			// case prop1: { type: String }
-			accumulator[key] = props[key]?.type()
-			return accumulator
-		},
-		{} as Record<string, unknown>,
-	)
+    return Object.keys(props).reduce(
+        (accumulator: Record<string, unknown>, key: string) => {
+            if (key === 'modelValue') {
+                return accumulator
+            }
+            if ('default' in props[key]) {
+                accumulator[key]
+					= typeof props[key].default === 'function'
+                        ? props[key].default()
+                        : props[key].default
+                return accumulator
+            }
+            if (isFunction(props[key])) {
+                // case prop1: String
+                accumulator[key] = props[key]()
+                return accumulator
+            }
+            if (Array.isArray(props[key])) {
+                // case prop1: [ String, Array ]
+                accumulator[key] = props[key][0]()
+                return accumulator
+            }
+            // case prop1: { type: ... }
+            if (Array.isArray(props[key].type)) {
+                accumulator[key] = props[key]?.type[0]()
+                return accumulator
+            }
+            // case prop1: { type: String }
+            accumulator[key] = props[key]?.type()
+            return accumulator
+        },
+        {} as Record<string, unknown>,
+    )
 }
 
 /**
@@ -263,26 +278,15 @@ export function propsToObject(props: any) {
  * @return {object[]}
  */
 export function filterArray<T = Record<string, unknown>>(
-	list: T[],
-	filter: T[] | string[],
-	key: string,
+    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])
-		})
-	})
-}
-
-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()
-	}
+    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])
+        })
+    })
 }

package/src/workers/blurhash.ts

@@ -0,0 +1,9 @@
+import { decode, encode, isBlurhashValid, ValidationError } from 'blurhash'
+import { expose } from 'comlink'
+
+expose({
+    ValidationError,
+    encode,
+    decode,
+    isBlurhashValid,
+})

package/dist/composables/alert/useInjectAlert.d.ts

@@ -1,9 +0,0 @@
-/**
- * Injects alert group name
- */
-export declare function useInjectedAlertGroup(): {
-    name?: globalThis.Ref<string | undefined> | undefined;
-    bus?: import("mitt").Emitter<{
-        close: string;
-    }> | undefined;
-};

package/dist/composables/dropdown/useInjectDropdown.d.ts

@@ -1,32 +0,0 @@
-/**
- * Injects dropdown reference and the event bus
- */
-export declare function useInjectedDropdownTrigger(): {
-    id?: globalThis.Ref<string | number> | undefined;
-    reference?: globalThis.Ref<HTMLElement | null> | undefined;
-    bus?: import("mitt").Emitter<{
-        click: Event;
-        mouseover: Event;
-        mouseleave: Event;
-    }> | undefined;
-    expanded?: globalThis.Ref<boolean> | undefined;
-    aria?: globalThis.Ref<{
-        'aria-controls': string;
-        'aria-haspopup': boolean;
-        'aria-expanded': boolean;
-    }> | undefined;
-};
-/**
- * Injects dropdown item role
- */
-export declare function useInjectedDropdownItem(): {
-    role?: globalThis.Ref<"option" | "presentation"> | undefined;
-    expanded?: globalThis.Ref<boolean> | undefined;
-};
-/**
- * Injects dropdown action role
- */
-export declare function useInjectedDropdownAction(): {
-    role?: globalThis.Ref<"button" | "link" | "menuitem"> | undefined;
-    expanded?: globalThis.Ref<boolean> | undefined;
-};

package/dist/composables/group/useInjectedGroupState.d.ts

@@ -1,10 +0,0 @@
-import type { Ref } from 'vue';
-import type GroupState from '../../types/group';
-/**
- * Injects a group state
- */
-export declare function useInjectedGroupState<GroupStateType extends GroupState>(groupKey: string | symbol): {
-    group: Ref<GroupStateType> | undefined;
-    isInGroup: globalThis.ComputedRef<boolean>;
-    getGroupOrLocalRef: <PropsType extends object>(propName: keyof GroupStateType, props: PropsType, emit?: ((event: string, ...args: unknown[]) => void) | undefined) => globalThis.WritableComputedRef<any>;
-};

package/dist/composables/group/useProvideGroupState.d.ts

@@ -1,6 +0,0 @@
-import type GroupState from '../../types/group';
-/**
- * Share part of the state of the component with all its children.
- * @param {IGroupState} groupState the group state with all group options
- */
-export declare function useProvideGroupState<GroupStateType extends GroupState>(groupState: GroupStateType): void;

package/src/composables/dropdown/useProvideDropdown.ts

@@ -1,94 +0,0 @@
-import { type Ref, Fragment } from 'vue'
-import mitt from 'mitt'
-import {
-	INJECTION_KEY_DROPDOWN_TRIGGER,
-	INJECTION_KEY_DROPDOWN_ACTION,
-	INJECTION_KEY_DROPDOWN_ITEM,
-	DropdownRole,
-	DropdownItemRole,
-	ActionRoles,
-} from '../../constants'
-
-/**
- * Share the dropdown reference and the event bus with all its children.
- * @param {Ref<HTMLElement | null>} reference the dropdown reference
- */
-export function useProvideDropdownTrigger({
-	reference,
-	id,
-	expanded,
-	aria,
-}: {
-	reference: Ref<HTMLElement | null>
-	id: Ref<string | number>
-	expanded: Ref<boolean>
-	aria: Ref<{
-		'aria-controls': string
-		'aria-haspopup': boolean
-		'aria-expanded': boolean
-	}>
-}) {
-	const bus = mitt<{
-		click: Event
-		mouseover: Event
-		mouseleave: Event
-	}>()
-	const component = defineComponent({
-		name: 'VvDropdownTriggerProvider',
-		setup() {
-			provide(INJECTION_KEY_DROPDOWN_TRIGGER, {
-				reference,
-				id,
-				expanded,
-				aria,
-				bus,
-			})
-		},
-		render() {
-			return h(Fragment, {}, this.$slots.default?.())
-		},
-	})
-
-	return {
-		bus,
-		component,
-	}
-}
-
-/**
- * Share the dropdown item role with all its children.
- * @param {Ref<string>} role the dropdown item role
- */
-export function useProvideDropdownItem({
-	role,
-	expanded,
-}: {
-	role: Ref<`${DropdownRole}`>
-	expanded: Ref<boolean>
-}) {
-	const itemRole = computed(() =>
-		role.value === DropdownRole.listbox
-			? DropdownItemRole.option
-			: DropdownItemRole.presentation,
-	)
-	provide(INJECTION_KEY_DROPDOWN_ITEM, {
-		role: itemRole,
-		expanded,
-	})
-	return { itemRole }
-}
-
-/**
- * Share the dropdown item role with all its children.
- * @param {Ref<string>} role the dropdown item role
- */
-export function useProvideDropdownAction({
-	expanded,
-}: {
-	expanded?: Ref<boolean>
-}) {
-	provide(INJECTION_KEY_DROPDOWN_ACTION, {
-		role: ref(ActionRoles.menuitem),
-		expanded,
-	})
-}

package/src/composables/group/useInjectedGroupState.ts

@@ -1,51 +0,0 @@
-import type { Ref } from 'vue'
-import type GroupState from '../../types/group'
-
-/**
- * Injects a group state
- */
-export function useInjectedGroupState<GroupStateType extends GroupState>(
-	groupKey: string | symbol,
-) {
-	// Get group state
-	const group = inject<Ref<GroupStateType> | undefined>(groupKey, undefined)
-
-	// Check if component is in group
-	const isInGroup = computed(() => !isEmpty(group))
-
-	/**
-	 * Get a group or local property
-	 */
-	function getGroupOrLocalRef<PropsType extends object>(
-		propName: keyof GroupStateType,
-		props: PropsType,
-		emit?: (event: string, ...args: unknown[]) => void,
-	) {
-		if (group?.value) {
-			const groupPropValue = unref(group.value)[propName] as Ref<unknown>
-			return computed({
-				get() {
-					return groupPropValue?.value
-				},
-				set(value: unknown) {
-					groupPropValue.value = value
-				},
-			})
-		}
-		const propRef = toRef(props, propName as keyof PropsType)
-		return computed({
-			get() {
-				return propRef.value
-			},
-			set(value: unknown) {
-				if (emit) emit(`update:${propName as string}`, value)
-			},
-		})
-	}
-
-	return {
-		group,
-		isInGroup,
-		getGroupOrLocalRef,
-	}
-}