@rokkit/core 1.0.0-next.93 → 1.0.0-next.95

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rokkit/core",
-  "version": "1.0.0-next.93",
+  "version": "1.0.0-next.95",
   "description": "Core components, actions and stores for svelte apps.",
   "author": "Jerry Thomas <me@jerrythomas.name>",
   "license": "MIT",
@@ -14,16 +14,16 @@
   "devDependencies": {
     "@sveltejs/vite-plugin-svelte": "^3.0.2",
     "@testing-library/svelte": "^4.1.0",
-    "@types/ramda": "^0.29.11",
+    "@types/ramda": "^0.29.12",
     "@vitest/coverage-v8": "^1.4.0",
     "@vitest/ui": "~1.4.0",
     "jsdom": "^24.0.0",
     "svelte": "^4.2.12",
-    "typescript": "^5.4.3",
-    "vite": "^5.2.7",
+    "typescript": "^5.4.4",
+    "vite": "^5.2.8",
     "vitest": "~1.4.0",
-    "shared-config": "1.0.0-next.93",
-    "validators": "1.0.0-next.93"
+    "shared-config": "1.0.0-next.95",
+    "validators": "1.0.0-next.95"
   },
   "files": [
     "src/**/*.js",

package/src/index.js

@@ -1,4 +1,4 @@
-import './types'
+export * from './types'
 export * from './constants'
 export * from './nested'
 export * from './mapping'

package/src/mapped-list.js

@@ -2,11 +2,25 @@ 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, [
@@ -69,7 +83,7 @@ export function findNearestItemBefore(position, items, fields) {
 	if (position.length === 0) return { item: items[0], position: [0], fields }
 
 	let index = position[position.length - 1]
-	let result
+	let result = null
 	if (index > 0) {
 		index -= 1
 		if (position.length === 1) {
@@ -85,6 +99,7 @@ export function findNearestItemBefore(position, items, fields) {
 }
 
 /**
+ * Returns the next sibling of the current item.
  *
  * @param {*} parent
  * @param {Array<integer>} position
@@ -114,8 +129,8 @@ export function findNearestItemAfter(position, items, fields) {
 	if (items.length === 0) return null
 	if (position.length === 0) return { item: items[0], position: [0], fields }
 
-	let current = findItemByIndexArray(position, items, fields)
-	let result
+	const current = findItemByIndexArray(position, items, fields)
+	let result = null
 	if (isExpanded(current.item, current.fields)) {
 		result = getFirstChild(current, position)
 	} else if (position.length === 1) {

package/src/mapping.js

@@ -1,5 +1,5 @@
 import { defaultFields } from './constants'
-import { isObject } from '.'
+import { toString, isObject } from './utils'
 
 /**
  * Get the component to be used to render the item.
@@ -10,7 +10,7 @@ import { isObject } from '.'
  * @param {import('./types.js').ComponentMap} using
  */
 export function getComponent(value, fields, using) {
-	return fields.component && typeof value === 'object'
+	return fields.component && isObject(value)
 		? using[value[fields.component]] ?? using.default
 		: using.default
 }
@@ -47,20 +47,36 @@ export function getValue(node, fields = defaultFields) {
  * 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 {*}                              node
  * @param {import('./types').FieldMapping} fields
- * @returns {*}
+ * @returns {string}
  */
 export function getText(node, fields = defaultFields) {
-	let value = typeof node === 'object' && node != null ? node[fields.text] : node
-
-	return value != null
-		? isObject(value)
-			? JSON.stringify(value, null, 2)
-			: value.toString()
-		: value
+	const value = isObject(node) ? node[fields.text] : node
+	return value
+	// return value != null
+	// 	? isObject(value)
+	// 		? JSON.stringify(value, null, 2)
+	// 		: value.toString()
+	// 	: 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 {*}
+ */
+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

package/src/nested.js

@@ -4,7 +4,7 @@ import { defaultFields } from './constants'
 export function flattenNestedList(items, fields = defaultFields, level = 0) {
 	fields = { ...defaultFields, ...fields }
 	let data = []
-	items.map((item) => {
+	items.forEach((item) => {
 		const children = item[fields.children] ?? []
 		data = [
 			...data,
@@ -31,7 +31,7 @@ export function findValueFromPath(slug, data, fields) {
 	let items = data
 	let value = null
 
-	keys.map((key, index) => {
+	keys.forEach((key, index) => {
 		const match = items.find((item) => item[fields.key] === key)
 		if (match) {
 			if (index < keys.length - 1) {

package/src/parser.js

@@ -19,11 +19,11 @@
  * @returns {RegExp} - The regular expression pattern to identify search filter elements.
  */
 export function getRegex() {
-	let column = '[\\w]+'
-	let operator = ':|>|<|>=|<=|=<|=>|=|!=|~|~\\*|!~|!~\\*'
-	let value = '("[^"]+"|[^\\s=:<>!~*]+)'
+	const column = '[\\w]+'
+	const operator = ':|>|<|>=|<=|=<|=>|=|!=|~|~\\*|!~|!~\\*'
+	const value = '("[^"]+"|[^\\s=:<>!~*]+)'
 
-	let pattern = `(?<group>((?<column>${column})\\s?(?<operator>${operator})\\s?)(?<value>${value}))`
+	const pattern = `(?<group>((?<column>${column})\\s?(?<operator>${operator})\\s?)(?<value>${value}))`
 
 	return new RegExp(pattern, 'gm')
 }

package/src/string.js

@@ -25,8 +25,8 @@ export function toPascalCase(text) {
 /**
  * Convert a PascalCase string to snake case with separator as hyphen
  *
- * @param {Strin} text
- * @returns
+ * @param {string} text
+ * @returns {string}
  */
 export function toHyphenCase(text) {
 	return text
@@ -40,11 +40,12 @@ export function toHyphenCase(text) {
  *
  * @param {String} a hyphen separates string
  * @param {String} b hyphen separates string
- * @returns
+ * @param {string} separator - separator to split the string
+ * @returns {Number} -1, 0, 1 based on comparison
  */
-export function sortByParts(a, b) {
-	const partsOfA = a.split('-')
-	const partsOfB = b.split('-')
+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
@@ -69,7 +70,7 @@ export function compareStrings(a, b) {
  * @returns {String} timestamp based unique id
  */
 export function uniqueId(prefix = '', separator = '-') {
-	let pair = prefix && prefix.length > 0 ? [prefix] : []
+	const pair = prefix && prefix.length > 0 ? [prefix] : []
 	pair.push(Date.now().toString(36))
 	return pair.join(separator)
 }

package/src/theme.js

@@ -47,8 +47,8 @@ export function stateColors(name, modifier = 'none') {
 export function themeColors(modifier = 'none') {
 	const fn = modifier in modifiers ? modifiers[modifier] : modifiers.none
 
-	let states = ['info', 'danger', 'warning', 'success', 'error']
-	let variants = ['neutral', 'primary', 'secondary', 'accent']
+	const states = ['info', 'danger', 'warning', 'success', 'error']
+	const variants = ['neutral', 'primary', 'secondary', 'accent']
 	let colors = states.reduce(
 		(acc, state) => ({ ...acc, [state]: stateColors(state, modifier) }),
 		{}
@@ -82,7 +82,7 @@ function createShadeMappings(variant, mode, valueCondition) {
 	return shades.map((shade) => ({
 		key: `--on-${variant}-${shade}`,
 		value: valueCondition(shade),
-		mode: mode
+		mode
 	}))
 }
 

package/src/types.js

@@ -10,7 +10,7 @@
  */
 
 /**
- * @typedef {checked|unchecked|indeterminate} SelectionState
+ * @typedef {'checked'|'unchecked'|'indeterminate'} SelectionState
  */
 
 /**
@@ -85,3 +85,5 @@
  * @typedef {Object} RowStateMap
  * @property {RowState[]} rows - Flat list of hierarchy nodes.
  */
+
+export default {}

package/src/utils.js

@@ -1,3 +1,10 @@
+/**
+ * A function that performs no operations.
+ */
+export function noop() {
+	// intentionally empty to support default actions
+}
+
 /**
  * Generates a random id
  *
@@ -17,6 +24,26 @@ export function isObject(val) {
 	return typeof val === 'object' && val !== null && !(val instanceof Date)
 }
 
+/**
+ * Converts the value to a string. If the value is an object, it will convert it to a JSON string.
+ *
+ * @param {*} value
+ * @returns {string}
+ */
+export function toString(value) {
+	if (value === null || value === undefined) return value
+	if (isObject(value)) return JSON.stringify(value, null, 2)
+	return value.toString()
+}
+
+/**
+ * Generates icon shortcuts for a collection of icons
+ *
+ * @param {string[]} icons
+ * @param {string} collection
+ * @param {string} variants
+ * @returns {Object}
+ */
 export function iconShortcuts(icons, collection, variants) {
 	const suffix = variants ? `-${variants}` : ''
 	const shortcuts = !collection
@@ -32,7 +59,14 @@ export function iconShortcuts(icons, collection, variants) {
 	return shortcuts
 }
 
+/**
+ * Scales the path by the size
+ *
+ * @param {number} size
+ * @param {string|number} x
+ * @returns {string|number}
+ */
 export function scaledPath(size, x) {
-	if (Array.isArray(x)) return x.map((x) => scaledPath(size, x)).join(' ')
+	if (Array.isArray(x)) return x.map((v) => scaledPath(size, v)).join(' ')
 	return typeof x === 'number' ? x * size : x
 }