@rokkit/states 1.0.0-next.107 → 1.0.0-next.109

package/src/base-proxy.svelte.js

@@ -1,243 +0,0 @@
-import { defaultFields } from '@rokkit/core'
-
-/**
- * Base class for all proxy models that provides a common interface
- * for navigation and selection operations.
- *
- * @abstract
- */
-export class BaseProxy {
-	/** @type {any[]} Original data array */
-	data = $state(null)
-	/** @type {NodeProxy|null} Currently focused node */
-	nodes = $state([])
-	/** @type {NodeProxy[]} Flattened array of all visible nodes */
-	visibleNodes = $state([])
-
-	/** @type {NodeProxy|null} Currently focused node */
-	currentNode = $state(null)
-	/** @type {Object|null} Currently focused node */
-	value = $state(null)
-	/** @type {Map<string, NodeProxy>} Map of selected nodes by id */
-	selectedNodes = $state(new Map())
-
-	/** @type {Object} Field mappings */
-	fields
-
-	/** @type {Object} Configuration options */
-	options = {
-		multiSelect: false,
-		keyboardNavigation: true
-	}
-
-	/**
-	 * Creates a new proxy instance
-	 *
-	 * @param {any[]} data - Original data
-	 * @param {Object} fields - Field mappings
-	 * @param {Object} options - Configuration options
-	 */
-	constructor(data, value, fields = {}, options = {}) {
-		this.fields = { ...defaultFields, ...fields }
-		this.options = { ...this.options, ...options }
-		this.value = value
-
-		this.update(data)
-	}
-
-	/**
-	 * Updates the proxy with new data
-	 *
-	 * @param {any} data - New data to use
-	 * @returns {BaseProxy} - This proxy for method chaining
-	 */
-	update(data) {
-		this.data = data
-		this.reset()
-		return this
-	}
-
-	/**
-	 * Resets selection state
-	 *
-	 * @returns {BaseProxy} - This proxy for method chaining
-	 */
-	reset() {
-		this.selectedNodes.clear()
-		this.currentNode = null
-		return this
-	}
-
-	/**
-	 * Move to a specific target (index, path, or item)
-	 *
-	 * @abstract
-	 * @param {number|number[]} target - Target to move to
-	 * @returns {boolean} - True if moved, false otherwise
-	 */
-	moveTo() {
-		throw new Error('moveTo() must be implemented by subclass')
-	}
-
-	/**
-	 * Move to the next item
-	 *
-	 * @abstract
-	 * @returns {boolean} - True if moved, false otherwise
-	 */
-	moveNext() {
-		throw new Error('moveNext() must be implemented by subclass')
-	}
-
-	/**
-	 * Move to the previous item
-	 *
-	 * @abstract
-	 * @returns {boolean} - True if moved, false otherwise
-	 */
-	movePrev() {
-		throw new Error('movePrev() must be implemented by subclass')
-	}
-
-	/**
-	 * Expand the current node
-	 *
-	 * @returns {boolean} - True if expanded, false otherwise
-	 */
-	expand() {
-		// Default implementation for flat lists (no-op)
-		return false
-	}
-
-	/**
-	 * Collapse the current node
-	 *
-	 * @returns {boolean} - True if collapsed, false otherwise
-	 */
-	collapse() {
-		// Default implementation for flat lists (no-op)
-		return false
-	}
-
-	/**
-	 * Toggle expanded/collapsed state
-	 *
-	 * @returns {boolean} - True if state changed, false otherwise
-	 */
-	toggleExpansion() {
-		// Default implementation for flat lists (no-op)
-		return false
-	}
-
-	/**
-	 * Finds a node by a custom condition
-	 *
-	 * @param {Function} condition - Function that returns true for matching nodes
-	 * @returns {NodeProxy|null} - The found node or null
-	 */
-	find(condition) {
-		let result = null
-		for (let i = 0; i < this.nodes.length; i++) {
-			result = this.nodes[i].find(condition)
-			if (result) return result
-		}
-		return null
-	}
-
-	/**
-	 * Finds the path index by a custom condition
-	 *
-	 * @param {Function} condition - Function that returns true for matching nodes
-	 * @returns {number[]} - path index of found node or empty array
-	 */
-	findPathIndex(condition) {
-		const result = this.find(condition)
-		return result?.path ?? []
-	}
-
-	/**
-	 * Gets a node by its path
-	 *
-	 * @param {number|number[]} path - Path to the node
-	 * @returns {NodeProxy|null} - The node or null if not found
-	 */
-	getNodeByPath(path = []) {
-		path = Array.isArray(path) ? path : [path]
-
-		if (!path.length || !this.data) return null
-		return path.reduce((currentNodes, index, depth) => {
-			// If we've hit a dead end or invalid index, return null
-			if (currentNodes === null || index < 0 || index >= currentNodes.length) {
-				return null
-			}
-
-			// Get the node at the current index
-			const node = currentNodes[index]
-
-			// If we've reached the final depth, return the node
-			if (depth === path.length - 1) return node
-
-			// Otherwise, move to the next level (children)
-			return node.children
-		}, this.nodes)
-	}
-
-	/**
-	 * Selects the current node
-	 *
-	 * @param {number|number[]} [path] - The path to the node to toggle selection
-	 * @returns {boolean} - Whether the selection was successful
-	 */
-	select(path) {
-		const node = path ? this.getNodeByPath(path) : this.currentNode
-		if (!node) return false
-
-		if (!this.options.multiSelect) {
-			this.selectedNodes.forEach((node) => {
-				node.selected = false
-			})
-			this.selectedNodes.clear()
-		}
-
-		// Select the current node
-		node.selected = true
-		this.selectedNodes.set(node.id, node)
-		return true
-	}
-
-	/**
-	 * Toggles selection on the current node (for multi-select)
-	 *
-	 * @param {number|number[]} [path] - The path to the node to toggle selection
-	 * @returns {boolean} - Whether the operation was successful
-	 */
-	toggleSelection(path) {
-		const node = path ? this.getNodeByPath(path) : this.currentNode
-
-		if (!node) return false
-
-		node.selected = !node.selected
-		const nodeId = node.id
-
-		if (node.selected) {
-			this.selectedNodes.set(nodeId, node)
-		} else {
-			this.selectedNodes.delete(nodeId)
-		}
-		return true
-	}
-
-	/**
-	 * Extends selection on the current node (for multi-select)
-	 *
-	 * @param {number|number[]} [path] - The path to the node to extend selection
-	 * @returns {boolean} - Whether the operation was successful
-	 */
-	extendSelection(path) {
-		if (this.options.multiSelect) {
-			return this.toggleSelection(path)
-		} else {
-			return this.select(path)
-		}
-	}
-}

package/src/list-proxy.svelte.js

@@ -1,127 +0,0 @@
-import { BaseProxy } from './base-proxy.svelte.js'
-import { NodeProxy } from './node-proxy.svelte.js'
-import { equals } from 'ramda'
-/**
- * Manages a flat list of nodes with selection and focus capabilities
- */
-export class ListProxy extends BaseProxy {
-	/**
-	 * Creates a new ListProxy
-	 *
-	 * @param {Object[]} data    - Original data array
-	 * @param {Object}   value   - Active value in the list
-	 * @param {Object}   fields  - Field mappings
-	 * @param {Object}   options - Configuration options
-	 */
-	constructor(data, value, fields = {}, options = {}) {
-		super(data, value, fields, options)
-		this.moveToValue(value)
-	}
-
-	/**
-	 * Updates the proxy with new data
-	 *
-	 * @param {any[]}    data    - New data to use
-	 * @returns {ListProxy}      - This proxy for method chaining
-	 */
-	update(data) {
-		this.data = data || null
-
-		// Create node proxies for all items
-		if (data && Array.isArray(data)) {
-			this.nodes = data.map((item, index) => new NodeProxy(item, [index], this.fields))
-		} else {
-			this.nodes = []
-		}
-
-		this.reset()
-		return this
-	}
-
-	/**
-	 * Moves focus to the specified target (index or item)
-	 *
-	 * @param {number|object} target - Index of the node or the node item to focus
-	 * @returns {boolean}            - Whether the move was successful
-	 */
-	moveTo(target) {
-		const index = Array.isArray(target) ? target[0] : target
-
-		// Validate index
-		if (index < 0 || index >= this.nodes.length) {
-			return false
-		}
-
-		// Update focus
-		if (this.currentNode) this.currentNode.focused = false
-
-		this.currentNode = this.nodes[index]
-		this.currentNode.focused = true
-
-		return true
-	}
-
-	/**
-	 * Moves focus to the next node
-	 *
-	 * @returns {boolean} - Whether the move was successful
-	 */
-	moveNext() {
-		if (!this.nodes.length) return false
-
-		let nextIndex = 0
-
-		if (this.currentNode) {
-			const currentIndex = this.nodes.indexOf(this.currentNode)
-			nextIndex = currentIndex + 1
-
-			// If at end of list, stay at current position
-			if (nextIndex >= this.nodes.length) {
-				return false
-			}
-		}
-
-		return this.moveTo(nextIndex)
-	}
-
-	/**
-	 * Moves focus to the previous node
-	 *
-	 * @returns {boolean} - Whether the move was successful
-	 */
-	movePrev() {
-		if (!this.nodes.length) return false
-
-		if (!this.currentNode) {
-			return this.moveTo(this.nodes.length - 1)
-		}
-
-		const currentIndex = this.nodes.indexOf(this.currentNode)
-		const prevIndex = currentIndex - 1
-
-		// If at start of list, stay at current position
-		if (prevIndex < 0) {
-			return false
-		}
-
-		return this.moveTo(prevIndex)
-	}
-
-	/**
-	 * Finds a node by value and makes it the current & active node
-	 *
-	 * @param {any} value
-	 * @returns
-	 */
-	moveToValue(value) {
-		if (!value || equals(this.currentNode?.value, value)) return false
-
-		const path = this.findPathIndex((node) => equals(node.value, value))
-		if (path.length > 0) {
-			this.moveTo(path)
-			this.select()
-			return true
-		}
-		return false
-	}
-}

package/src/nested-proxy.svelte.js

@@ -1,286 +0,0 @@
-import { BaseProxy } from './base-proxy.svelte.js'
-import { NodeProxy } from './node-proxy.svelte.js'
-import { equals } from 'ramda'
-
-/**
- * Manages a hierarchical tree of nodes with selection, focus and expansion capabilities
- */
-export class NestedProxy extends BaseProxy {
-	/**
-	 * Creates a new NestedProxy
-	 *
-	 * @param {any[]} data - Original hierarchical data array
-	 * @param {any} value - Initial value for the proxy
-	 * @param {Object} fields - Field mappings
-	 * @param {Object} options - Configuration options
-	 */
-	constructor(data, value, fields = {}, options = {}) {
-		// Default options for tree structures
-		const defaultTreeOptions = {
-			expandedByDefault: false
-		}
-
-		super(data, value, fields, { ...defaultTreeOptions, ...options })
-		this.moveToValue(value)
-		// this._refreshFlatNodes()
-	}
-
-	/**
-	 * Refreshes the flatNodes
-	 * @private
-	 */
-	_refreshFlatNodes(nodes = null) {
-		if (!nodes) {
-			this.visibleNodes = []
-			this._refreshFlatNodes(this.nodes)
-		} else {
-			nodes.forEach((node) => {
-				this.visibleNodes.push(node)
-				if (node.hasChildren() && node.expanded) {
-					this._refreshFlatNodes(node.children)
-				}
-			})
-		}
-	}
-
-	/**
-	 * Processes hierarchical data into node proxies
-	 *
-	 * @private
-	 * @param {any[]} items - Items to process
-	 */
-	processNodes(items) {
-		if (!items || !Array.isArray(items)) return
-
-		this.nodes = []
-		items.forEach((item, index) => {
-			const node = new NodeProxy(item, [index], this.fields)
-			this.nodes.push(node)
-		})
-		this._refreshFlatNodes()
-	}
-
-	/**
-	 * Updates the proxy with new data
-	 *
-	 * @param {any[]} data - New hierarchical data to use
-	 * @returns {NestedProxy} - This proxy for method chaining
-	 */
-	update(data) {
-		this.data = data || null
-		this.reset()
-
-		if (!data) {
-			this.visibleNodes = []
-			return this
-		}
-
-		// Create node tree and flatten visible nodes
-		this.processNodes(data)
-		return this
-	}
-
-	/**
-	 * Moves focus to the specified target (index, path)
-	 *
-	 * @param {number|number[]} target - index or path to move to
-	 * @returns {boolean} - Whether the move was successful
-	 */
-	moveTo(target) {
-		const targetNode = Array.isArray(target)
-			? this.find((node) => equals(node.path, target))
-			: this.visibleNodes[target]
-
-		if (!targetNode) return false
-
-		// Update focus
-		if (this.currentNode) {
-			this.currentNode.focused = false
-		}
-
-		this.currentNode = targetNode
-		this.currentNode.focused = true
-
-		return true
-	}
-
-	/**
-	 * Moves focus to the next visible node
-	 *
-	 * @returns {boolean} - Whether the move was successful
-	 */
-	moveNext() {
-		if (!this.visibleNodes.length) return false
-
-		let nextIndex = 0
-
-		if (this.currentNode) {
-			const currentIndex = this.visibleNodes.indexOf(this.currentNode)
-			nextIndex = currentIndex + 1
-
-			// If at end of list, stay at current position
-			if (nextIndex >= this.visibleNodes.length) {
-				return false
-			}
-		}
-
-		return this.moveTo(nextIndex)
-	}
-
-	/**
-	 * Moves focus to the previous visible node
-	 *
-	 * @returns {boolean} - Whether the move was successful
-	 */
-	movePrev() {
-		if (!this.visibleNodes.length) return false
-
-		if (!this.currentNode) {
-			return this.moveTo(this.visibleNodes.length - 1)
-		}
-
-		const currentIndex = this.visibleNodes.indexOf(this.currentNode)
-		const prevIndex = currentIndex - 1
-
-		// If at start of list, stay at current position
-		if (prevIndex < 0) {
-			return false
-		}
-
-		return this.moveTo(prevIndex)
-	}
-
-	/**
-	 * Expand the current node
-	 *
-	 * @param {number[]} [path] - The path to the node to expand
-	 * @returns {boolean} - Whether the node was expanded
-	 */
-	expand(path) {
-		const node = path ? this.getNodeByPath(path) : this.currentNode
-		if (!node || !node.hasChildren() || node.expanded) {
-			return false
-		}
-
-		node.expanded = true
-		this._refreshFlatNodes()
-		return true
-	}
-
-	/**
-	 * Collapse the current node
-	 *
-	 * @param {number[]} [path] - The path to the node to collapse
-	 * @returns {boolean} - Whether the node was collapsed
-	 */
-	collapse(path) {
-		const node = path ? this.getNodeByPath(path) : this.currentNode
-		if (!node || !node.hasChildren() || !node.expanded) return false
-
-		node.expanded = false
-		this._refreshFlatNodes()
-		return true
-	}
-
-	/**
-	 * Toggle expanded/collapsed state of current node
-	 *
-	 * @param {number[]} [path] - The path to the node to toggle expansion
-	 * @returns {boolean} - Whether the state changed
-	 */
-	toggleExpansion(path) {
-		const node = path ? this.getNodeByPath(path) : this.currentNode
-
-		if (!node || !node.hasChildren()) {
-			return false
-		}
-
-		node.expanded = !node.expanded
-		this._refreshFlatNodes()
-		return true
-	}
-
-	/**
-	 * Expands all nodes
-	 *
-	 * @returns {NestedProxy} - This proxy for method chaining
-	 */
-	expandAll() {
-		this.visibleNodes.forEach((node) => {
-			node.expandAll()
-		})
-
-		this._refreshFlatNodes()
-		return this
-	}
-
-	/**
-	 * Collapses all nodes
-	 *
-	 * @returns {NestedProxy} - This proxy for method chaining
-	 */
-	collapseAll() {
-		this.visibleNodes.forEach((node) => {
-			node.collapseAll()
-		})
-
-		this._refreshFlatNodes()
-		return this
-	}
-
-	/**
-	 * Resets selection and expansion state
-	 *
-	 * @returns {NestedProxy} - This proxy for method chaining
-	 */
-	reset() {
-		// Clear focus
-		if (this.currentNode) {
-			this.currentNode.focused = false
-			this.currentNode = null
-		}
-		if (this.options.expandedByDefault) this.expandAll()
-		this.nodes.forEach((node) => node.resetStates())
-		this.selectedNodes.clear()
-		this._refreshFlatNodes()
-
-		return this
-	}
-
-	/**
-	 * Ensures a node is visible by expanding its ancestors
-	 *
-	 * @param {NodeProxy} node - Node to make visible
-	 * @returns {boolean} - Whether the node is now visible
-	 */
-	ensureVisible(node) {
-		if (!node || !node.path || node.path.length <= 1) return true
-
-		for (let i = 1; i < node.path.length; i++) {
-			const parentNode = this.getNodeByPath(node.path.slice(0, i))
-			parentNode.expanded = true
-		}
-		this._refreshFlatNodes()
-		return true
-	}
-
-	/**
-	 * Finds a node by value and makes it the current & active node
-	 *
-	 * @param {any} value
-	 * @returns
-	 */
-	moveToValue(value) {
-		if (!value || equals(this.currentNode?.value, value)) return false
-
-		const targetNode = this.find((node) => equals(node.value, value))
-
-		if (targetNode) {
-			this.ensureVisible(targetNode)
-			this.moveTo(targetNode.path)
-			this.select()
-			return true
-		}
-		return false
-	}
-}