@rokkit/core 1.0.0-next.100

package/src/mapped-list.js

@@ -0,0 +1,233 @@
+import { defaultFields } from './constants'
+import { isExpanded, hasChildren, getAttribute } from './mapping'
+import { equals } from 'ramda'
+
+/**
+ * Checks if a specifc attribute of an item matches a value.
+ *
+ * @param {Object} item - The item.
+ * @param {string} attr - The attribute to check.
+ */
+function isMatch(item, attr, value) {
+	const itemValue = attr ? getAttribute(item, attr) : item
+	return equals(itemValue, value)
+}
+
+/**
+ * Traverses the tree to find an item by value.
+ * @param {Array} items - The items array.
+ * @param {Object} fields - The fields mapping.
+ * @param {any} value - The value to find.
+ * @param {Array} position - The current position in the tree.
+ * @returns {Object} The found item, or null if not found.
+ */
+function findInChildren(item, index, fields, value, attr, position) {
+	if (hasChildren(item, fields)) {
+		return findItemByValue(value, item[fields.children], fields.fields ?? fields, attr, [
+			...position,
+			index
+		])
+	}
+	return null
+}
+/**
+ * Traverses the tree to find an item by value.
+ * @param {Array} items - The items array.
+ * @param {Object} fields - The fields mapping.
+ * @param {any} value - The value to find.
+ * @param {Array} position - The current position in the tree.
+ * @returns {Object} The found item, or null if not found.
+ */
+export function findItemByValue(value, items, fields = defaultFields, attr = null, position = []) {
+	for (let i = 0; i < items.length; i++) {
+		if (isMatch(items[i], attr, value)) {
+			return { item: items[i], position: [...position, i], fields }
+		}
+
+		const foundInChildren = findInChildren(items[i], i, fields, value, attr, position)
+		if (foundInChildren) return foundInChildren
+	}
+
+	return null
+}
+
+/**
+ * Gets an item from an items array using an index array.
+ * @param {Array} indices - The index array.
+ * @param {Array} items - The items array.
+ * @param {Object} fields - The fields configuration.
+ * @returns {Object} The item.
+ */
+export function findItemByIndexArray(indices, items, fields) {
+	let item = items[indices[0]]
+	let levelFields = fields
+	for (let level = 1; level < indices.length; level++) {
+		if (hasChildren(item, levelFields)) {
+			item = item[levelFields.children][indices[level]]
+			levelFields = levelFields.fields ?? levelFields
+		} else {
+			return null
+		}
+	}
+	return { item, position: indices, fields: levelFields }
+}
+
+/**
+ *
+ * @param {Array<integer>} position
+ * @param {Array<*>} items
+ * @param {import('./types').FieldMapping} fields
+ * @returns
+ */
+export function findNearestItemBefore(position, items, fields) {
+	if (items.length === 0) return null
+	if (position.length === 0) return { item: items[0], position: [0], fields }
+
+	let index = position[position.length - 1]
+	let result = null
+	if (index > 0) {
+		index -= 1
+		if (position.length === 1) {
+			return findLastVisibleChild(items[index], [index], fields)
+		}
+
+		const sibling = findItemByIndexArray([...position.slice(0, -1), index], items, fields)
+		result = findLastVisibleChild(sibling.item, sibling.position, sibling.fields)
+	} else {
+		result = findItemByIndexArray(position.slice(0, -1), items, fields)
+	}
+	return result
+}
+
+/**
+ * Returns the next sibling of the current item.
+ *
+ * @param {*} parent
+ * @param {Array<integer>} position
+ * @param {import('./types').FieldMapping} fields
+ * @returns
+ */
+export function findLastVisibleChild(parent, position, fields) {
+	if (isExpanded(parent, fields)) {
+		const children = parent[fields.children]
+		return findLastVisibleChild(
+			children[children.length - 1],
+			position.concat(children.length - 1),
+			fields.fields ?? fields
+		)
+	}
+	return { item: parent, position, fields }
+}
+
+/**
+ * Returns the next item in the tree.
+ * @param {Array} position - The position of the current item.
+ * @param {Array} items - The items in the tree.
+ * @param {Object} fields - The fields mapping.
+ * @returns {Object|null} The next item or null if there is none.
+ */
+export function findNearestItemAfter(position, items, fields) {
+	if (items.length === 0) return null
+	if (position.length === 0) return { item: items[0], position: [0], fields }
+
+	const current = findItemByIndexArray(position, items, fields)
+	let result = null
+	if (isExpanded(current.item, current.fields)) {
+		result = getFirstChild(current, position)
+	} else if (position.length === 1) {
+		result = getNextSiblingAtRoot(position, items, fields)
+	} else {
+		result = getNextSiblingOrAncestor(position, items, fields)
+	}
+	return result
+}
+
+/**
+ * Returns the next child of the current item.
+ * @param {Object} current - The current item.
+ * @param {Array} position - The position of the current item.
+ * @returns {Object} The next child.
+ */
+function getFirstChild(current, position) {
+	return {
+		item: current.item[current.fields.children][0],
+		position: position.concat(0),
+		fields: current.fields.fields ?? current.fields
+	}
+}
+
+/**
+ * Returns the next sibling of the current item at the root level.
+ * @param {Array} position - The position of the current item.
+ * @param {Array} items - The items in the tree.
+ * @param {Object} fields - The fields mapping.
+ * @returns {Object|null} The next sibling or null if there is none.
+ */
+function getNextSiblingAtRoot(position, items, fields) {
+	if (position[0] < items.length - 1) {
+		return {
+			item: items[position[0] + 1],
+			position: [position[0] + 1],
+			fields
+		}
+	}
+	return null
+}
+
+/**
+ * Returns the next sibling of the current item or the next item in the ancestor.
+ * @param {Array} position - The position of the current item.
+ * @param {Array} items - The items in the tree.
+ * @param {Object} fields - The fields mapping.
+ * @returns {Object|null} The next sibling or ancestor or null if there is none.
+ */
+function getNextSiblingOrAncestor(position, items, fields) {
+	let index = position[position.length - 1]
+	let parent = findItemByIndexArray(position.slice(0, -1), items, fields)
+	let children = parent.item[parent.fields.children]
+	if (index < children.length - 1) {
+		index += 1
+		const sibling = findItemByIndexArray([...position.slice(0, -1), index], items, fields)
+		return { item: sibling.item, position: sibling.position, fields }
+	} else {
+		while (index === children.length - 1) {
+			index = position[position.length - 1]
+			position = position.slice(0, -1)
+			if (position.length === 0) return null
+			parent = findItemByIndexArray(position, items, fields)
+			children = parent.item[parent.fields.children]
+		}
+		return {
+			item: children[index + 1],
+			position: [...position, index + 1],
+			fields
+		}
+	}
+}
+
+/**
+ * Creates a mapped list from an items array and a fields mapping.
+ * @param {Array<Object>} items - The items array.
+ * @param {import('./types').FieldMapping} fields - The fields mapping.
+ * @returns {Object} The mapped list.
+ */
+export function mappedList(items, fields) {
+	const findByValue = (value) => findItemByValue(value, items, fields)
+	const findByAttribute = (value, attr) => findItemByValue(value, items, fields, attr)
+	const findByIndexArray = (index) => findItemByIndexArray(index, items, fields)
+	const previous = (position) => findNearestItemBefore(position, items, fields)
+	const next = (position) => findNearestItemAfter(position, items, fields)
+
+	const update = (newItems, newFields) => {
+		items = newItems
+		fields = newFields
+	}
+	return {
+		findByValue,
+		findByAttribute,
+		findByIndexArray,
+		previous,
+		next,
+		update
+	}
+}

package/src/mapping.js

@@ -0,0 +1,138 @@
+import { defaultFields } from './constants'
+import { toString, isObject } from './utils'
+
+/**
+ * Get the component to be used to render the item.
+ * If the component is null or undefined, it will return the default component.
+ *
+ * @param {object|string}                     value
+ * @param {import('./types.js').FieldMapping} fields
+ * @param {import('./types.js').ComponentMap} using
+ */
+export function getComponent(value, fields, using) {
+	return fields.component && isObject(value)
+		? using[value[fields.component]] ?? using.default
+		: using.default
+}
+
+/**
+ * Get the icon for the item. If the icon is an object, it will use the state to determine which icon to use.
+ *
+ * @param {object|string}                     value
+ * @param {import('./types.js').FieldMapping} fields
+ * @returns {string}
+ */
+export function getIcon(value, fields = defaultFields) {
+	if (fields.icon === undefined || typeof (value ?? '') !== 'object') return null
+
+	const name = getIconFromObject(value, fields)
+	return fields.iconPrefix ? [fields.iconPrefix, name].join('-') : name
+}
+
+/**
+ * Get the icon for the item. If the icon is an object, it will use the state to determine which icon to use.
+ *
+ * @param {object}                            value
+ * @param {import('./types.js').FieldMapping} fields
+ * @returns {string}
+ */
+function getIconFromObject(value, fields) {
+	if (typeof value[fields.icon] === 'object') return value[fields.icon][value[fields.state]]
+	return value[fields.icon]
+}
+
+/**
+ * Get the value for the item. If the value is an object,
+ * it will use the field mapping to determine which attribute to get.
+ *
+ * @param {*}                              node
+ * @param {import('./types').FieldMapping} fields
+ * @returns {*}
+ */
+export function getValue(node, fields = defaultFields) {
+	return typeof node === 'object' && node !== null ? node[fields.value] ?? node[fields.text] : node
+}
+
+/**
+ * Get the text for the item. If the text is an object,
+ * it will use the field mapping to determine which attribute to get.
+ *
+ * @param {*}                              node
+ * @param {import('./types').FieldMapping} fields
+ * @returns {string}
+ */
+export function getText(node, fields = defaultFields) {
+	const value = isObject(node) ? node[fields.text] : node
+	return value
+}
+
+/**
+ * Get the formatted text for the item. If the text is an object, use the field mapping to determine
+ * which attribute to get currency. Use the formatter or identity function to format the text.
+ *
+ * @param {*}                              node
+ * @param {import('./types').FieldMapping} fields
+ * @param {Function}                       formatter
+ * @returns {Function}
+ */
+export function getFormattedText(node, fields = defaultFields, formatter = toString) {
+	const value = isObject(node) ? node[fields.text] : node
+	const currency = getAttribute(node, fields.currency)
+	const formatValue = typeof formatter === 'function' ? formatter : toString
+
+	return currency ? formatValue(value, currency) : formatValue(value)
+}
+/**
+ * Gets the attribute from the node
+ * @param {*}      node
+ * @param {string} attr
+ * @returns {*}
+ */
+export function getAttribute(node, attr) {
+	return typeof node === 'object' && node !== null && attr !== null ? node[attr] : null
+}
+/**
+ * Check if the current item is a parent
+ *
+ * @param {*}                              item
+ * @param {import('./types').FieldMapping} fields
+ * @returns {boolean}
+ */
+export function hasChildren(item, fields) {
+	return (
+		item !== null &&
+		typeof item === 'object' &&
+		fields.children in item &&
+		Array.isArray(item[fields.children])
+	)
+}
+
+/**
+ * Check if the current item is a parent and is expanded
+ *
+ * @param {*}                              item
+ * @param {import('./types').FieldMapping} fields
+ * @returns {boolean}
+ */
+export function isExpanded(item, fields) {
+	if (item === null) return false
+	if (!hasChildren(item, fields)) return false
+	if (fields.isOpen in item) {
+		return item[fields.isOpen]
+	}
+	return false
+}
+
+/**
+ * Verify if at least one item has children
+ *
+ * @param {Array<*>}                       items
+ * @param {import('./types').FieldMapping} fields
+ * @returns {boolean}
+ */
+export function isNested(items, fields) {
+	for (let i = 0; i < items.length; i++) {
+		if (hasChildren(items[i], fields)) return true
+	}
+	return false
+}

package/src/nested.js

@@ -0,0 +1,56 @@
+import { omit } from 'ramda'
+import { defaultFields } from './constants'
+
+/**
+ * Flattens a nested list of items
+ *
+ * @param {Array}                         items
+ * @param {import('./types).FieldMapping} fields
+ * @param {number}                        level
+ * @returns {Array}
+ */
+export function flattenNestedList(items, fields = defaultFields, level = 0) {
+	fields = { ...defaultFields, ...fields }
+	let data = []
+	items.forEach((item) => {
+		const children = item[fields.children] ?? []
+		data = [
+			...data,
+			{
+				...omit([fields.children], item),
+				[fields.level]: level,
+				[fields.parent]: children.length > 0
+			},
+			...flattenNestedList(children, fields, level + 1)
+		]
+	})
+	return data
+}
+
+/**
+ * Matches a path slug to a value in the menu
+ *
+ * @param {string}                         slug
+ * @param {Array}                          data
+ * @param {import('./types').FieldMapping} fields
+ * @returns {any}
+ */
+export function findValueFromPath(slug, data, fields) {
+	fields = { ...defaultFields, ...fields }
+	const keys = slug.split('/')
+	let items = data
+	let value = null
+
+	keys.forEach((key, index) => {
+		const match = items.find((item) => item[fields.key] === key)
+		if (match) {
+			if (index < keys.length - 1) {
+				match[fields.isOpen] = true
+				items = match[fields.children]
+			} else {
+				value = match
+			}
+		}
+	})
+	return value
+}

package/src/string.js

@@ -0,0 +1,97 @@
+import { filter } from 'ramda'
+/**
+ * Capitalizes the first letter of input string
+ *
+ * @param {String} str
+ * @returns {String}
+ */
+export function toInitCapCase(text) {
+	return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase()
+}
+
+/**
+ * Convert a hyphen separated string to PascalCase
+ *
+ * @param {String} text
+ * @returns
+ */
+export function toPascalCase(text) {
+	return text
+		.split('-')
+		.map((part) => toInitCapCase(part))
+		.join('')
+}
+
+/**
+ * Convert a PascalCase string to snake case with separator as hyphen
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+export function toHyphenCase(text) {
+	return text
+		.replace(/\s+/, '-')
+		.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)
+		.replace(/^-/, '')
+}
+
+/**
+ * Sort by splitting hyphen separated strings while keeping strings with same number of parts together
+ *
+ * @param {String} a hyphen separates string
+ * @param {String} b hyphen separates string
+ * @param {string} separator - separator to split the string
+ * @returns {Number} -1, 0, 1 based on comparison
+ */
+export function sortByParts(a, b, separator = '-') {
+	const partsOfA = a.split(separator)
+	const partsOfB = b.split(separator)
+
+	let result = compareStrings(partsOfA[0], partsOfB[0])
+	if (result === 0) result = partsOfA.length - partsOfB.length
+	if (result === 0) result = compareStrings(a, b)
+	return result
+}
+
+/**
+ * Simple comparison for two strings
+ *
+ * @param {String} a
+ * @param {String} b
+ * @returns
+ */
+export function compareStrings(a, b) {
+	return a > b ? 1 : a < b ? -1 : 0
+}
+
+/**
+ * Generates a unique id from current timestamp
+ *
+ * @returns {String} timestamp based unique id
+ */
+export function uniqueId(prefix = '', separator = '-') {
+	const pair = prefix && prefix.length > 0 ? [prefix] : []
+	pair.push(Date.now().toString(36))
+	return pair.join(separator)
+}
+
+/**
+ * Removes undefined and null values from the input object.
+ *
+ * @param {Object} obj
+ * @returns {Object}
+ */
+export function compact(obj) {
+	return filter((x) => x !== undefined && x !== null, obj)
+}
+
+/**
+ * Converts an input number into it's hexadecimal representation, with optional left padded zeroes based on the `size`
+ *
+ * @param {number} value
+ * @param {number} size
+ * @returns
+ */
+export function toHexString(value, size = 2) {
+	return value.toString(16).padStart(size, '0')
+}