@rokkit/data 1.0.0-next.100

package/src/rollup.js

@@ -0,0 +1,138 @@
+import { omit, pick, mergeLeft, map, difference, uniq, pipe } from 'ramda'
+
+/**
+ * Groups data by specified keys.
+ *
+ * @param {Array} data - An array of data points.
+ * @param {Array} groupByKeys - Keys to group the data by.
+ * @param {Array} summaries - An array of summary objects to define aggregation operations.
+ * @returns {Object} Grouped data object with aggregation placeholders.
+ */
+export function groupDataByKeys(data, groupByKeys, summaries) {
+	const keysExtractor = pick(groupByKeys)
+	const groupedData = data.reduce((grouped, row) => {
+		const key = JSON.stringify(keysExtractor(row))
+		if (!grouped[key]) {
+			grouped[key] = { ...keysExtractor(row), ...initialValues(summaries) }
+		}
+		addToSummaries(grouped[key], row, summaries)
+		return grouped
+	}, {})
+
+	return Object.values(groupedData)
+}
+
+/**
+ * Sets initial values for summaries.
+ *
+ * @param {Array} summaries - An array of summary objects.
+ * @returns {Object} An object with keys for each summary initialized to empty arrays.
+ */
+export function initialValues(summaries) {
+	const fields = summaries.map(({ reducers }) => reducers.map((r) => r.field)).flat()
+	return fields.reduce((acc, name) => ({ ...acc, [name]: [] }), {})
+}
+
+/**
+ * Adds data to summary aggregation arrays.
+ *
+ * @param {Object} group - The group object to add data to.
+ * @param {Object} row - The data row being processed.
+ * @param {Array} summaries - An array of summary objects.
+ */
+export function addToSummaries(group, row, summaries) {
+	summaries.forEach(({ mapper, reducers }) => {
+		const value = mapper(row)
+		reducers.forEach((r) => {
+			group[r.field].push(value)
+		})
+	})
+}
+
+/**
+ * Fills grouped data with aligned data if specified in configuration.
+ *
+ * @param {Object} groupedData - The grouped data object.
+ * @param {Object} config - Configuration object containing alignment settings.
+ * @returns {Array} Aligned data array.
+ */
+export function fillAlignedData(groupedData, config, fillRowsFunc) {
+	// const fillRowsFunc = getAlignGenerator(df.data, config)
+	const { actual_flag, children } = config
+	return Object.values(groupedData).map((row) => ({
+		...row,
+		[children]: [
+			...row[children].map((value) => ({ ...value, [actual_flag]: 1 })),
+			...fillRowsFunc(row[children])
+		]
+	}))
+}
+
+/**
+ * Performs aggregation operations on grouped data.
+ *
+ * @param {Array} dataArray - An array of grouped data with aggregation arrays.
+ * @param {Array} summaries - An array of summary objects with reducer functions.
+ * @returns {Array} Aggregated data array with computed summary values.
+ */
+export function aggregateData(dataArray, summaries) {
+	const fields = summaries.map(({ name, reducers }) => reducers.map((r) => ({ name, ...r }))).flat()
+	return dataArray.map((row) => ({
+		...row,
+		...fields.reduce(
+			(acc, { field, formula }) => ({
+				...acc,
+				[field]: formula(row[field])
+			}),
+			{}
+		)
+	}))
+}
+
+/**
+ * Creates a generator that produces missing rows in a dataset based on specified columns.
+ * The function determines all unique combinations of the specified columns in config.align_by
+ * and returns a generator function to create the missing combinations, potentially with default
+ * values for other columns.
+ * @param {Array<Object>} data - The array of objects representing the dataset.
+ * @param {Object} config - The configuration object.
+ *
+ * @returns {Function} A generator function that when called, produces the missing rows.
+ */
+export function getAlignGenerator(data, config) {
+	const { align_by, group_by, actual_flag } = config
+	const template = { ...omit([...align_by, ...group_by], config.template), [actual_flag]: 0 }
+	const subset = pipe(map(pick(align_by)), uniq)(data)
+
+	return pipe(map(pick(align_by)), uniq, difference(subset), map(mergeLeft(template)))
+}
+
+/**
+ * Returns an aggregator object with a mapper and reducer function.
+ *
+ * @param {Array<string>} from  - The key or keys to aggregate.
+ * @param {Function}      using - The aggregation function.
+ * @returns {import('./types').SummaryConfig}  - An object with a mapper and reducer function.
+ */
+// export function getAggregator(from, into, using = identity) {
+// 	// const mapper = pick(Array.isArray ? from : [from])
+// 	return {
+// 		mapper: pick(from),
+// 		reducers: [{ field: into, formula: using }]
+// 	}
+// }
+
+/**
+ * Returns the default aggregator which rolls up the columns other than the group_by columns into a single object.
+ *
+ * @param {import('./types').Metadata} metadata - The metadata for the columns to be aggregated.
+ * @param {Object} config                       - The configuration used to build the aggregator.
+ *
+ * @returns {Object} An object containing the default aggregator for the specified metadata and configuration.
+ */
+// export function defaultAggregator(metadata, config) {
+// 	const child = metadata.filter((col) => !config.group_by.includes(col.name))
+// 	const keys = child.map((col) => col.name)
+
+// 	return { ...getAggregator(keys, config.children), metadata: child }
+// }

package/src/types.js

@@ -0,0 +1,173 @@
+/**
+ * @typedef {import('@rokkit/core').FieldMapping} FieldMapping
+ * @typedef {import('@rokkit/core').SortOptions} SortOptions
+ * @typedef {import('@rokkit/core').HorizontalAlignOptions} HorizontalAlignOptions
+ * @typedef {import('@rokkit/core').ActionTypes} ActionTypes
+ * @typedef {import('@rokkit/core').SelectionState} SelectionState
+ */
+
+/**
+ * @typedef {Object} ColumnSorter
+ * @property {string}   name
+ * @property {function} sorter
+ *
+ * @typedef {string|[string,boolean]|ColumnSorter} SortableColumn
+ */
+
+/**
+ * @typedef {Object} ColumnAggregator
+ * @property {string}   name
+ * @property {function} aggregator
+ * @property {string}   suffix
+ */
+
+/**
+ * Options for joining two data sets
+ *
+ * @typedef OptionsToRenameKeys
+ * @property {string} [prefix]         - Prefix to be added to each attribute
+ * @property {string} [suffix]         - Suffix to be added to each attribute
+ * @property {string} [separator='_']  - Separator to be used when adding prefix or suffix. defaults to _
+ */
+
+/**
+ * Column metadata for the table.
+ *
+ * @typedef {Object} ColumnMetadata
+ *
+ * @property {string}                 name        - The name of the column.
+ * @property {string}                 type        - The data type of the column (e.g., "string", "number", "date").
+ * @property {FieldMapping}           [field] - The field mapping for the column.
+ * @property {number}                 [digits=0]  - The number of digits for numeric values (defaults to 0).
+ * @property {Function}               formatter   - A function to format the column value.
+ * @property {boolean}                [sortable]  - Indicates if the column is sortable (true/false).
+ * @property {SortOptions}            [sortOrder] - The sort order of the column.
+ * @property {HorizontalAlignOptions} [align]     - The alignment of the column content.
+ * @property {ActionTypes}            [action]    - Action attribute for action columns.
+ */
+
+/**
+ * @typedef {Array<ColumnMetadata>} Metadata
+ */
+
+/**
+ * @typedef {Object<string,number} ColumnIndexMap
+ */
+
+/**
+ * Track the state of a row in the table.
+ *
+ * @typedef {Object} TreeTableNode
+ * @property {number}         row          - Reference to actual row in the data.
+ * @property {number}         depth        - The depth of the node in the hierarchy.
+ * @property {string}         [value]      - The value of the hierarchy node.
+ * @property {boolean}        [isHidden]   - Indicates whether the node is visible (true/false).
+ * @property {boolean}        [isParent]   - Indicates if this node is a parent (true/false).
+ * @property {boolean}        [isExpanded] - Indicates whether the node is expanded (true/false).
+ * @property {number}         [parent]     - Reference to the parent node in the flat list.
+ * @property {SelectionState} [selected]   - Indicates whether the node is selected (true/false/indeterminate).
+ * @property {Array<any>}     children     - Reference to the children nodes in the flat list.
+ */
+
+/**
+ * Track the state of all rows in the table.
+ *
+ * @typedef {Object} TreeTable
+ * @property {TreeTableNode[]} rows - Flat list of hierarchy nodes.
+ */
+
+/**
+ * @typedef {Object} OverrideConfig
+ * @property {string} actual_flag - the field used for identifying filler rows in the data
+ * @property {string} children    - the field used for collecting children of a node in rollup
+ */
+
+/**
+ * @typedef {Object} ReducerConfig
+ * @property {string}   field - The target field to hold the reduced value
+ * @property {Function} using - The function to use for reducing the data
+ */
+
+/**
+ * @typedef {Object} SummaryConfig
+ * @property {Function}            mapper     - A function used to collect the data for the summary
+ * @property {Array<ReducerConfig} reducers   - Array of reducer configurations
+ * @property {Metadata}            [metadata] - Array of column metadata for the summary
+ */
+
+/**
+ * @typedef {Object} DataFrameConfig
+ * @property {Array<string>} group_by=[]         - The columns to group by.
+ * @property {Array<string>} align_by=[]         - The columns to be aligned during rollup.
+ * @property {Array<SummaryConfig>} summaries=[] - Array of summary configurations.
+ * @property {any} template={}                   - Template row to be used for filling in missing rows.
+ * @extends OverrideConfig
+ */
+
+/**
+ * @typedef {Function} SortBy
+ * @description Sort the DataFrame by the specified columns.
+ * @param {SortableColumn} columns - The columns to sort by.
+ * @returns {DataFrame}            - The sorted DataFrame.
+ */
+
+/**
+ * DataFrame-like object with data manipulation methods.
+ *
+ * @typedef {Object} DataFrame
+ * @property {Array<Object>}                         data       - Array of objects representing the rows of data.
+ * @property {Metadata}                              metadata   - Array of column metadata for the data.
+ * @property {DataFrameConfig}                       config     - Configuration options for the DataFrame.
+ * @property {ColumnIndexMap}                        columns    - A map of column names to their index in the metadata.
+ * @property {function(OverrideConfig):DataFrame}    override   - Method to override the configuration of the DataFrame.
+ * @property {function(...string):DataFrame}         groupBy    - Method to group the DataFrame by specified columns.
+ * @property {function(function(any)):DataFrame}     where      - Sets the filter function for the DataFrame
+ * @property {function():DataFrame}                  align      - Method to align the DataFrame.
+ * @property {function():DataFrame}                  using      - set the template to be used for filling in missing rows.
+ * @property {function():DataFrame}                  summarize  - add a summarizer to be used during rollup
+ * @property {function(...SortableColumn):DataFrame} sortBy     - Method to sort the DataFrame by specified columns.
+ * @property {function():DataFrame}                  join       - perform join with another DataFrame returning a new DataFrmae. Defaults to innerJoin, other join types can be specified.
+ * @property {function():DataFrame}                  innerJoin  - perform an ineer join with another DataFrame and return a new DataFrame.
+ * @property {function():DataFrame}                  leftJoin   - perform a left join with another DataFrame and return a new DataFrame.
+ * @property {function():DataFrame}                  rightJoin  - perform a right join with another DataFrame returning a new DataFrame.
+ * @property {function():DataFrame}                  fullJoin   - perform a full join with another DataFrame returning a new DataFrame.
+ * @property {function():DataFrame}                  nestedJoin - perform a nested join with another DataFrame returning a new DataFrame.
+ * @property {function():DataFrame}                  rename     - Method to rename the columns of the DataFrame.
+ * @property {function():DataFrame}                  drop       - Method to drop the columns of the DataFrame.
+ * @property {function():DataFrame}                  delete     - Method to delete the rows of the DataFrame.
+ * @property {function():DataFrame}                  update     - Method to update the rows of the DataFrame.
+ * @property {function():DataFrame}                  union      - Method to combine the rows of the DataFrame with another DataFrame.
+ * @property {function():DataFrame}                  minus      - Method to remove the rows of the DataFrame which are present in another DataFrame.
+ * @property {function():DataFrame}                  intersect  - Method to keep the rows of the DataFrame which are present in another DataFrame.
+ * @property {function():DataFrame}                  rollup     - Method to rollup the DataFrame.
+ * @property {function():Arrat<Object>}              select     - Method to select the columns of the DataFrame.
+
+ */
+
+/**
+ * @typedef {inner|outer|full|nested} JoinType
+ */
+/**
+ * Options for joining two data sets
+ *
+ * @typedef JoinOptions
+ * @property {boolean} [inner]                - Flag indicating inner join
+ * @property {JoinType} [type='inner]         - The join type to use (inner, outer, full, nested).
+ * @property {string} [prefix]                - prefix to be used for renaming keys in the second data set.
+ * @property {string} [suffix]                - suffix to be used for renaming keys in the second data set.
+ * @property {string} [separator='_']         - separator to be used for renaming keys in the second data set.
+ */
+
+/**
+ * DataView
+ * @typedef {Object} DataView
+ * @property {TreeTable} hierarchy - The state of the rows in the table.
+ * @property {Metadata} columns      - The metadata for the columns in the table.
+ * @property {Function} sortBy       - Sort the DataView by the specified columns.
+ * @property {Function} clearSort    - Clear the sorting of the DataView.
+ * @property {Function} filter       - Filter the DataView by the specified columns.
+ * @property {Function} toggle      - toggle expand or collapse the DataView by the specified columns.
+ * @property {Function} select      - select the DataView by the specified columns.
+ */
+
+export default {}

package/src/utils.js

@@ -0,0 +1,36 @@
+/**
+ * Check if a value is a date string
+ * @param {string} value
+ * @returns {boolean}
+ */
+function isDateString(value) {
+	return !isNaN(Date.parse(value))
+}
+
+function deriveTypeFromEmptyValue(value) {
+	if (value === undefined || value === null) return 'string'
+	return typeof value
+}
+/**
+ * Infer the type of a value as array, date or the default type
+ * @param {any} value
+ * @returns {string}
+ */
+function deriveArrayAndDateTypes(value) {
+	if (Array.isArray(value)) return 'array'
+	if (value instanceof Date) return 'date'
+
+	return deriveTypeFromEmptyValue(value)
+}
+/**
+ * Derive the type of a value
+ * @param {any} value
+ * @returns {string}
+ */
+export function typeOf(value) {
+	const type = deriveArrayAndDateTypes(value)
+	if (type === 'string' && isDateString(value)) return 'date'
+	if (type === 'number' && Number.isInteger(value)) return 'integer'
+
+	return type
+}

package/src/view.js

@@ -0,0 +1,181 @@
+import { omit } from 'ramda'
+import { get, writable } from 'svelte/store'
+import { deriveMetadata, deriveSortableColumn } from './infer'
+
+import {
+	flattenNestedChildren,
+	removeChildren,
+	deriveHierarchy,
+	toggleExpansion
+} from './hierarchy'
+
+/**
+ * Sorts a nested array of objects based on a group of sorters.
+ *
+ * @param {Array<Object>} elements - The array of objects to sort.
+ */
+function sortNested(elements, group) {
+	elements
+		.sort((a, b) => {
+			let result = 0
+			for (let i = 0; i < group.length && result === 0; i++) {
+				result = group[i].sorter(a, b)
+			}
+			return result
+		})
+		.forEach((x) => {
+			if (Array.isArray(x.children) && x.children.length > 0) {
+				sortNested(x.children, group)
+			}
+		})
+}
+
+/**
+ * Sorts a hierarchy based on a group of sorters.
+ *
+ * @param {Array<Object>} hierarchy - The hierarchy to sort.
+ * @param {Array<Array<string, boolean>>} sortGroup - The group of sorters to apply.
+ */
+export function groupSort(hierarchy, sortGroup) {
+	const group = sortGroup.map(deriveSortableColumn).map(({ name, sorter }) => ({
+		name,
+		sorter: (a, b) => sorter(a.row[name], b.row[name])
+	}))
+
+	removeChildren(hierarchy)
+	sortNested(hierarchy, group)
+	flattenNestedChildren(hierarchy)
+}
+
+/**
+ * Sorts the hierarchy based on a specific field name and order.
+ *
+ * @param {string} name - The field name to sort by.
+ * @param {boolean} [ascending=true] - Whether the sort should be in ascending order.
+ */
+const sortHierarchyBy = (store, sortGroup, name, ascending = true) => {
+	sortGroup = [...sortGroup, [name, ascending]]
+	// change the sort order in the metadata
+	const { columns, hierarchy } = get(store)
+	columns.forEach((column) => {
+		if (column.name === name) {
+			column.order = ascending ? 'ascending' : 'descending'
+		}
+	})
+	groupSort(hierarchy, sortGroup)
+	store.set({ columns, hierarchy })
+}
+
+/**
+ * Updates the selection state for all children of a node in the hierarchy.
+ *
+ * @param {Array<import('./types').Hierarchy>} hierarchy - The hierarchy to update.
+ * @param {number} index - The index of the node to update.
+ */
+function updateChildren(item) {
+	if (!item.children) return
+
+	item.children.forEach((child) => {
+		child.selected = item.selected
+		updateChildren(child)
+	})
+}
+
+/**
+ * Determines the selected state of a group of children in the hierarchy.
+ * If all children are checked, returns 'checked'.
+ * If all children are unchecked, returns 'unchecked'.
+ * Otherwise, returns 'indeterminate'.
+ *
+ * @param {Array<Object>} children - The array of child objects with a 'selected' property.
+ * @returns {string} The determined selected state: 'checked', 'unchecked', or 'indeterminate'.
+ */
+export function determineSelectedState(children) {
+	const allChecked = children.every((child) => child.selected === 'checked')
+	const allUnchecked =
+		!allChecked && children.every((child) => !child.selected || child.selected === 'unchecked')
+
+	return allChecked ? 'checked' : allUnchecked ? 'unchecked' : 'indeterminate'
+}
+
+/**
+ * Updates the selection state of parent nodes in the hierarchy based on their children's states.
+ * It traverses up from the provided `index` position in the hierarchy array, ensuring each
+ * parent's selected state reflects whether all, none, or some of its children are selected.
+ *
+ * @param {Array<Object>} hierarchy - The hierarchy structure containing nodes with
+ *                                    'parent' and 'children' references.
+ * @param {number} index - The index of the node in the hierarchy array from where
+ *                         to start updating parent nodes.
+ */
+function updateParents(item) {
+	let parent = item.parent
+
+	while (parent) {
+		parent.selected = determineSelectedState(parent.children)
+		parent = parent.parent
+	}
+}
+
+/**
+ * Toggles the selection state of a node in the hierarchy.
+ * Depending on whether the node to toggle is a parent or child,
+ * it will either select or deselect all children, or update the parent's selection state based on its children's states.
+ *
+ * @param {import('./types').Hierarchy} item - The node to toggle.
+ *
+ */
+export function toggleSelection(item) {
+	item.selected = item.selected === 'checked' ? 'unchecked' : 'checked'
+
+	updateParents(item)
+	updateChildren(item)
+}
+
+/**
+ * Toggles the expansion or selection state of a data element at the specified index.
+ *
+ * @param {import('svelte/store').Writable} store - The store object representing the view.
+ * @param {number} index - The index of the element in the hierarchy to expand or collapse.
+ * @param {string} mode - The mode to toggle, either 'expansion' or 'selection'.
+ */
+function toggleState(store, index, mode) {
+	const { hierarchy } = get(store)
+	if (mode === 'selection') toggleSelection(hierarchy[index])
+	else if (mode === 'expansion') toggleExpansion(hierarchy[index])
+	store.update((state) => ({ ...state, hierarchy }))
+}
+
+/**
+ * Creates a view object for managing data presentation with metadata and hierarchy structures,
+ * as well as providing methods for sorting, selection, and toggling of data expansion.
+ *
+ * @param {Array<Object>} data    - The source data array to be presented by the view.
+ * @param {Object}        options - The configuration options used for deriving metadata and hierarchy from the data.
+ * @returns {import('svelte/store').Writable} An object representing the view, providing methods to manipulate and query the presentation state.
+ */
+export function dataview(data, options) {
+	const store = writable({
+		columns: deriveMetadata(data, options),
+		hierarchy: deriveHierarchy(data, options)
+	})
+	let sortGroup = []
+
+	return {
+		...omit(['set', 'update'], store),
+		// filter: noop,
+		/**
+		 * Clears the applied sort order from the hierarchy.
+		 */
+		clearSort: () => {
+			sortGroup = []
+			store.update((state) => ({
+				...state,
+				columns: state.columns.map((column) => ({ ...column, order: 'none' }))
+			}))
+		},
+		sortBy: (name, ascending) => sortHierarchyBy(store, sortGroup, name, ascending),
+		select: (index) => toggleState(store, index, 'selection'),
+		toggle: (index) => toggleState(store, index, 'expansion')
+	}
+}