@rokkit/core 1.0.0-next.39 → 1.0.0-next.41

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@rokkit/core",
-  "version": "1.0.0-next.39",
+  "version": "1.0.0-next.41",
   "description": "Core components, actions and stores for svelte apps.",
   "author": "Jerry Thomas <me@jerrythomas.name>",
   "license": "MIT",
-  "main": "index.js",
+  "main": "src/index.js",
   "svelte": "src/index.js",
   "module": "src/index.js",
   "types": "dist/index.d.ts",
@@ -23,13 +23,12 @@
     "validators": "latest",
     "vite": "^4.4.7",
     "vitest": "~0.33.0",
-    "shared-config": "1.0.0-next.39"
+    "shared-config": "1.0.0-next.41"
   },
   "files": [
     "src/**/*.js",
     "src/**/*.svelte",
-    "!src/mocks",
-    "!src/**/*.spec.js"
+    "!spec"
   ],
   "exports": {
     "./src": "./src",
@@ -53,6 +52,6 @@
     "test": "vitest",
     "coverage": "vitest run --coverage",
     "latest": "pnpm upgrade --latest && pnpm test:ci",
-    "release": "tsc && pnpm publish --access public"
+    "release": "pnpm publish --access public"
   }
 }

package/src/index.js

@@ -2,6 +2,7 @@ import './types'
 export * from './constants'
 export * from './nested'
 export * from './mapping'
+export * from './mapped-list'
 export * from './connector'
 export * from './ticks'
 export * from './calendar'

package/src/mapped-list.js

@@ -0,0 +1,237 @@
+import { isExpanded, hasChildren, getAttribute } from './mapping'
+import { equals } from 'ramda'
+/**
+ * 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,
+	attr = null,
+	position = []
+) {
+	for (let i = 0; i < items.length; i++) {
+		const item = items[i]
+
+		if (attr) {
+			if (getAttribute(item, attr) === value) {
+				return { item, position: position.concat(i), fields }
+			}
+		} else if (equals(item, value)) {
+			return { item, position: position.concat(i), fields }
+		}
+
+		// If the item has children, recurse into them.
+		if (hasChildren(item, fields)) {
+			const found = findItemByValue(
+				value,
+				item[fields.children],
+				fields.fields ?? fields,
+				attr,
+				position.concat(i)
+			)
+			if (found) return found
+		}
+	}
+
+	// If the item was not found, return null.
+	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('@rokkit/core').FieldMapping} fields
+ * @returns
+ */
+export function findNearestItemBefore(position, items, fields) {
+	if (position.length == 0) return null
+	if (items.length === 0) return null
+	if ((position ?? []).length === 0)
+		return { item: items[0], position: [0], fields }
+
+	let index = position[position.length - 1]
+	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
+		)
+		return findLastVisibleChild(sibling.item, sibling.position, sibling.fields)
+	} else {
+		return findItemByIndexArray(position.slice(0, -1), items, fields)
+	}
+}
+
+/**
+ *
+ * @param {*} parent
+ * @param {Array<integer>} position
+ * @param {import('@rokkit/core').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 }
+
+	let current = findItemByIndexArray(position, items, fields)
+
+	if (isExpanded(current.item, current.fields)) {
+		return getFirstChild(current, position)
+	} else if (position.length === 1) {
+		return getNextSiblingAtRoot(position, items, fields)
+	} else {
+		return getNextSiblingOrAncestor(position, items, fields)
+	}
+}
+
+/**
+ * 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]
+		}
+		if (index < children.length - 1) {
+			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('@rokkit/core').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

@@ -29,16 +29,41 @@ export function getIcon(value, fields = defaultFields) {
 		: 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 {*}
+ */
 export function getText(node, fields = defaultFields) {
 	return typeof node === 'object' && node !== null ? node[fields.text] : node
 }
 
+/**
+ * Gets the attribute from the node
+ * @param {*} node
+ * @param {string} attr
+ * @returns {*}
+ */
+export function getAttribute(node, attr) {
+	return typeof node === 'object' && node !== null ? node[attr] : null
+}
 /**
  * Check if the current item is a parent
  *

package/src/ticks.js

@@ -1,20 +1,26 @@
+/**
+ * Generates an array of tick marks for a range of values.
+ *
+ * @param {number} lowerBound - The lower bound of the range.
+ * @param {number} upperBound - The upper bound of the range.
+ * @param {number} [minorTickStep=upperBound-lowerBound] - The step size for minor ticks.
+ * @param {number} [majorTickStep=1] - The step size for major ticks.
+ * @returns {Array<{value: number, label: string, major: boolean}>} An array of tick mark objects.
+ */
 export function generateTicks(
 	lowerBound,
 	upperBound,
-	minorTickStep,
-	majorTickStep = 1,
-	formatter = new Intl.NumberFormat('en-US', { CompactDisplay: 'short' })
+	minorTickStep = upperBound - lowerBound,
+	majorTickStep = 1
 ) {
-	minorTickStep = minorTickStep ? minorTickStep : upperBound - lowerBound
 	const length = 1 + Math.ceil((upperBound - lowerBound) / minorTickStep)
-	const ticks = Array.from({ length }, (_, i) => ({
-		value: i == length - 1 ? upperBound : lowerBound + minorTickStep * i,
-		major: i == 0 || i == length - 1 || i % majorTickStep == 0
-	})).map(({ value, major }) => ({
-		value,
-		label: major ? formatter.format(value) : '',
-		major
-	}))
-
-	return ticks
+	return Array.from({ length }, (_, i) => {
+		const value = i == length - 1 ? upperBound : lowerBound + minorTickStep * i
+		const major = i == 0 || i == length - 1 || i % majorTickStep == 0
+		return {
+			value,
+			label: major ? value : '',
+			major
+		}
+	})
 }