@rokkit/data 1.0.0-next.100 → 1.0.0-next.105

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rokkit/data",
-  "version": "1.0.0-next.100",
+  "version": "1.0.0-next.105",
   "description": "Contains generic data manipulation functions that can be used in various components.",
   "author": "Jerry Thomas <me@jerrythomas.name>",
   "license": "MIT",
@@ -11,16 +11,10 @@
   "publishConfig": {
     "access": "public"
   },
-  "devDependencies": {
-    "@sveltejs/vite-plugin-svelte": "^3.1.2",
-    "@testing-library/svelte": "^5.2.1",
-    "@types/ramda": "^0.30.2",
-    "@vitest/coverage-v8": "^2.1.1",
-    "@vitest/ui": "~2.1.1",
-    "typescript": "^5.6.2",
-    "vite": "^5.4.6",
-    "vitest": "~2.1.1",
-    "shared-config": "1.0.0-next.100"
+  "scripts": {
+    "prepublishOnly": "tsc --project tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "build": "bun clean && bun prepublishOnly"
   },
   "files": [
     "src/**/*.js",
@@ -37,20 +31,10 @@
   },
   "dependencies": {
     "@lukeed/uuid": "^2.0.1",
+    "@rokkit/core": "1.0.0-next.104",
     "d3-array": "^3.2.4",
     "d3-collection": "^1.0.7",
     "ramda": "^0.30.1",
-    "svelte": "^4.2.19",
-    "@rokkit/core": "1.0.0-next.100"
-  },
-  "scripts": {
-    "format": "prettier --write .",
-    "lint": "eslint --fix .",
-    "test:ci": "vitest run",
-    "test:ui": "vitest --ui",
-    "test": "vitest",
-    "coverage": "vitest run --coverage",
-    "latest": "pnpm upgrade --latest && pnpm test:ci",
-    "release": "pnpm publish --access public"
+    "svelte": "^5.10.0"
   }
-}
+}

package/src/dataset.js

@@ -3,54 +3,6 @@ import { descending } from 'd3-array'
 import { pickAllowedConfig, defaultConfig, includeAll } from './constants'
 import { deriveSortableColumn } from './infer'
 import { groupDataByKeys, fillAlignedData, getAlignGenerator, aggregateData } from './rollup'
-/**
- * Dataset is a collection of data with a set of operations that can be performed on it.
- * @param {Array} data - The data to be stored in the dataset.
- * @param {Object} options - The configuration options for the dataset.
- * @returns {Object} - An object with a set of operations that can be performed on the dataset.
- */
-// eslint-disable-next-line max-lines-per-function
-export function dataset(data, options = {}) {
-	const config = { ...clone(defaultConfig), ...options }
-
-	const actions = {
-		// configuration
-		override: (props) => dataset(data, { ...config, ...pickAllowedConfig(props) }),
-		where: (condition) => dataset(data, where(config, condition)),
-		groupBy: (...fields) => dataset(data, groupBy(config, ...fields)),
-		alignBy: (...fields) => dataset(data, alignBy(config, ...fields)),
-		using: (template) => dataset(data, usingTemplate(config, template)),
-		summarize: (from, fields) => dataset(data, summarize(config, from, fields)),
-		// alter keys
-		rename: (how) => dataset(renameKeys(data, how)),
-		drop: (...fields) => dataset(dropKeys(data, ...fields)),
-		// alter rows
-		sortBy: (...fields) => dataset(sortDataBy(data, ...fields)),
-		delete: () => dataset(deleteRows(data, config.filter || includeAll)),
-		update: (value) => dataset(updateRows(data, config.filter || identity, value)),
-		fillNA: (value) => dataset(fillNA(data, value)),
-		// transform data
-		apply: (callback) => dataset(data.map(callback)),
-		rollup: () => dataset(rollup(data, config)),
-		select: (...cols) => selectKeys(data, config, ...cols),
-		// set operations
-		union: (other) => dataset(data.concat(other)),
-		minus: (other) => dataset(data.filter((d) => !other.find((x) => equals(x, d)))),
-		intersect: (other) => dataset(data.filter((d) => other.find((x) => equals(x, d)))),
-		// joins
-		innerJoin: (other, condition) => dataset(innerJoin(data, other.select(), condition)),
-		leftJoin: (other, condition) => dataset(leftJoin(data, other.select(), condition)),
-		rightJoin: (other, condition) => dataset(leftJoin(other.select(), data, condition)),
-		fullJoin: (other, condition) => dataset(fullJoin(data, other.select(), condition)),
-		crossJoin: (other) => dataset(crossJoin(data, other.select())),
-		semiJoin: (other, condition) => dataset(semiJoin(data, other.select(), condition)),
-		antiJoin: (other, condition) => dataset(antiJoin(data, other.select(), condition)),
-		nestedJoin: (other, condition) =>
-			dataset(nestedJoin(data, other.select(), condition, config.children))
-	}
-
-	return actions
-}
 
 /**
  * Adds a filter to the dataset using the provided condition. This filter is applied
@@ -252,19 +204,6 @@ function nestedJoin(first, second, condition, key = 'children') {
 	return result
 }
 
-/**
- * Renames the keys of the data based on the provided mapping, or function
- * that returns the new key. If the new key already exists, the value is overwritten.
- *
- * @param {Array<Object>}   data - The data to rename the keys of.
- * @param {Object|Function} how  - The mapping of old keys to new keys, or a function that performs renaming.
- * returns Array<Object>         - The updated data with renamed keys.
- */
-function renameKeys(data, how) {
-	const rename = typeof how === 'function' ? how : renameKeysUsingMap(how)
-	return data.map(rename)
-}
-
 /**
  * Drops the specified keys from the data.
  *
@@ -342,6 +281,19 @@ function renameKeysUsingMap(lookup) {
 			.reduce((acc, [k, v]) => ({ ...acc, [lookup[k] || k]: v }), {})
 }
 
+/**
+ * Renames the keys of the data based on the provided mapping, or function
+ * that returns the new key. If the new key already exists, the value is overwritten.
+ *
+ * @param {Array<Object>}   data - The data to rename the keys of.
+ * @param {Object|Function} how  - The mapping of old keys to new keys, or a function that performs renaming.
+ * returns Array<Object>         - The updated data with renamed keys.
+ */
+function renameKeys(data, how) {
+	const rename = typeof how === 'function' ? how : renameKeysUsingMap(how)
+	return data.map(rename)
+}
+
 /**
  * Sorts data by the specified columns.
  *
@@ -378,6 +330,21 @@ function selectKeys(data, config, ...cols) {
 	return result
 }
 
+/**
+ * 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(config) {
+	return {
+		mapper: omit(config.group_by),
+		reducers: [{ field: config.children, formula: identity }]
+	}
+}
+
 /**
  * Summarizes the dataset by the specified columns.
  * @param {import('./types').dataset} df - The dataset object to summarize.
@@ -413,16 +380,50 @@ function rollup(data, config) {
 }
 
 /**
- * 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.
+ * Dataset is a collection of data with a set of operations that can be performed on it.
+ * @param {Array} data - The data to be stored in the dataset.
+ * @param {Object} options - The configuration options for the dataset.
+ * @returns {Object} - An object with a set of operations that can be performed on the dataset.
  */
-export function defaultAggregator(config) {
-	return {
-		mapper: omit(config.group_by),
-		reducers: [{ field: config.children, formula: identity }]
+// eslint-disable-next-line max-lines-per-function
+export function dataset(data, options = {}) {
+	const config = { ...clone(defaultConfig), ...options }
+
+	const actions = {
+		// configuration
+		override: (props) => dataset(data, { ...config, ...pickAllowedConfig(props) }),
+		where: (condition) => dataset(data, where(config, condition)),
+		groupBy: (...fields) => dataset(data, groupBy(config, ...fields)),
+		alignBy: (...fields) => dataset(data, alignBy(config, ...fields)),
+		using: (template) => dataset(data, usingTemplate(config, template)),
+		summarize: (from, fields) => dataset(data, summarize(config, from, fields)),
+		// alter keys
+		rename: (how) => dataset(renameKeys(data, how)),
+		drop: (...fields) => dataset(dropKeys(data, ...fields)),
+		// alter rows
+		sortBy: (...fields) => dataset(sortDataBy(data, ...fields)),
+		delete: () => dataset(deleteRows(data, config.filter || includeAll)),
+		update: (value) => dataset(updateRows(data, config.filter || identity, value)),
+		fillNA: (value) => dataset(fillNA(data, value)),
+		// transform data
+		apply: (callback) => dataset(data.map(callback)),
+		rollup: () => dataset(rollup(data, config)),
+		select: (...cols) => selectKeys(data, config, ...cols),
+		// set operations
+		union: (other) => dataset(data.concat(other)),
+		minus: (other) => dataset(data.filter((d) => !other.find((x) => equals(x, d)))),
+		intersect: (other) => dataset(data.filter((d) => other.find((x) => equals(x, d)))),
+		// joins
+		innerJoin: (other, condition) => dataset(innerJoin(data, other.select(), condition)),
+		leftJoin: (other, condition) => dataset(leftJoin(data, other.select(), condition)),
+		rightJoin: (other, condition) => dataset(leftJoin(other.select(), data, condition)),
+		fullJoin: (other, condition) => dataset(fullJoin(data, other.select(), condition)),
+		crossJoin: (other) => dataset(crossJoin(data, other.select())),
+		semiJoin: (other, condition) => dataset(semiJoin(data, other.select(), condition)),
+		antiJoin: (other, condition) => dataset(antiJoin(data, other.select(), condition)),
+		nestedJoin: (other, condition) =>
+			dataset(nestedJoin(data, other.select(), condition, config.children))
 	}
+
+	return actions
 }

package/src/filter.js

@@ -1,5 +1,22 @@
 import { filterOperations } from './constants'
 
+/**
+ * Checks if a row matches the given value based on the specified operator.
+ * Supports both standard and negated operators by checking the operator string
+ * for a leading '!' character, which indicates negation.
+ *
+ * @param {Object} row - The row object in which to search for the value match.
+ * @param {any} value - The value to match against the row's properties.
+ * @param {string} operator - The operator used to compare the row's properties to the value.
+ *                            When operator starts with '!', it negates the result of the comparison.
+ * @returns {boolean} - Returns true if the row matches the condition; otherwise, returns false.
+ */
+function findMatchingRow(row, value, operator) {
+	const op = operator.startsWith('!') ? operator.slice(1) : operator
+	const matched = Object.keys(row).some((key) => filterOperations[op](row[key], value))
+
+	return operator.startsWith('!') ? !matched : matched
+}
 /**
  * Filters an array of objects based on a specified condition defined in the options.
  * If a column is provided, it filters based on the value of that column. Otherwise, it filters
@@ -22,24 +39,6 @@ export function filterObjectArray(data, options) {
 	return data.filter((row) => findMatchingRow(row, value, operator))
 }
 
-/**
- * Checks if a row matches the given value based on the specified operator.
- * Supports both standard and negated operators by checking the operator string
- * for a leading '!' character, which indicates negation.
- *
- * @param {Object} row - The row object in which to search for the value match.
- * @param {any} value - The value to match against the row's properties.
- * @param {string} operator - The operator used to compare the row's properties to the value.
- *                            When operator starts with '!', it negates the result of the comparison.
- * @returns {boolean} - Returns true if the row matches the condition; otherwise, returns false.
- */
-function findMatchingRow(row, value, operator) {
-	const op = operator.startsWith('!') ? operator.slice(1) : operator
-	const matched = Object.keys(row).some((key) => filterOperations[op](row[key], value))
-
-	return operator.startsWith('!') ? !matched : matched
-}
-
 /**
  * Applies multiple filtering conditions to an array of objects. This function iterates through each filter option,
  * successively narrowing down the data.

package/src/formatter.js

@@ -1,20 +1,4 @@
 import { identity } from 'ramda'
-
-const formatterMap = {
-	currency: getCurrencyFormatter,
-	integer: (language) => (val) => val.toLocaleString(language, { maximumFractionDigits: 0 }),
-	number: (language, decimalPlaces) => (val) =>
-		val.toLocaleString(language, {
-			minimumFractionDigits: decimalPlaces,
-			maximumFractionDigits: decimalPlaces
-		}),
-	date: (language) => (val) => val.toLocaleDateString(language),
-	time: (language) => (val) => val.toLocaleTimeString(language),
-	object: () => JSON.stringify,
-	array: () => JSON.stringify, // Combined formatter for 'object' and 'array'
-	ellipsis: () => () => '...' // Static formatter, no need for parameters
-}
-
 /**
  * Returns a currency formatter function that formats a value as a currency string.
  * @param {string} language       - The IETF language tag used for locale-specific formatting.
@@ -39,6 +23,21 @@ function getCurrencyFormatter(language, decimalPlaces) {
 	return formatter
 }
 
+const formatterMap = {
+	currency: getCurrencyFormatter,
+	integer: (language) => (val) => val.toLocaleString(language, { maximumFractionDigits: 0 }),
+	number: (language, decimalPlaces) => (val) =>
+		val.toLocaleString(language, {
+			minimumFractionDigits: decimalPlaces,
+			maximumFractionDigits: decimalPlaces
+		}),
+	date: (language) => (val) => val.toLocaleDateString(language),
+	time: (language) => (val) => val.toLocaleTimeString(language),
+	object: () => JSON.stringify,
+	array: () => JSON.stringify, // Combined formatter for 'object' and 'array'
+	ellipsis: () => () => '...' // Static formatter, no need for parameters
+}
+
 /**
  * Creates a formatter function that formats a value according to the specified type and optional locale settings.
  * Supported types include 'default' (no formatting), 'integer', 'number', 'date', 'time',, 'object', 'array', 'currency' & 'ellipsis''

package/src/infer.js

@@ -7,27 +7,30 @@ import { typeOf } from './utils'
 import { deriveColumnProperties } from './metadata'
 
 /**
- * Derives the sorting information for a column based on the type of the input value.
+ * Validates an array to ensure it can be used to create a sorting configuration.
  *
- * @param {import('./types').SortableColumn} value - The value that determines the sorting behavior of the column.
- * @returns {import('./types').ColumnSorter}         An object containing the 'name' of the column and a 'sorter' function.
- * @throws {Error} Throws an error if the value type is not supported or the value format is invalid.
+ * @param {Array} value - The array to validate.
+ * @throws {Error} Throws an error if the array does not correspond to a [string, boolean] pair.
  */
-export function deriveSortableColumn(value) {
-	const type = typeOf(value)
-
-	const configGenerators = {
-		array: arrayConfigGenerator,
-		object: objectConfigGenerator,
-		string: stringConfigGenerator
+function arrayValidator(value) {
+	if (value.length !== 2 || typeof value[0] !== 'string' || typeof value[1] !== 'boolean') {
+		throw new Error('Array should be a pair of [string, boolean]')
 	}
+}
 
-	const configGenerator = configGenerators[type]
-	if (!configGenerator) {
-		throw new Error(`Invalid value type: ${type}`)
+/**
+ * Validates an object to ensure it has the necessary properties for creating a sorting configuration.
+ *
+ * @param {Object} value - The object to validate.
+ * @throws {Error} Throws an error if the object does not have a 'name' property or has an invalid 'sorter'.
+ */
+function objectValidator(value) {
+	if (typeof value.name !== 'string') {
+		throw new Error('The property "name" is required and must be a string')
+	}
+	if (value.sorter !== undefined && typeof value.sorter !== 'function') {
+		throw new Error('Sorter should be a function')
 	}
-
-	return configGenerator(value)
 }
 
 /**
@@ -63,32 +66,28 @@ function stringConfigGenerator(value) {
 }
 
 /**
- * Validates an array to ensure it can be used to create a sorting configuration.
+ * Derives the sorting information for a column based on the type of the input value.
  *
- * @param {Array} value - The array to validate.
- * @throws {Error} Throws an error if the array does not correspond to a [string, boolean] pair.
+ * @param {import('./types').SortableColumn} value - The value that determines the sorting behavior of the column.
+ * @returns {import('./types').ColumnSorter}         An object containing the 'name' of the column and a 'sorter' function.
+ * @throws {Error} Throws an error if the value type is not supported or the value format is invalid.
  */
-function arrayValidator(value) {
-	if (value.length !== 2 || typeof value[0] !== 'string' || typeof value[1] !== 'boolean') {
-		throw new Error('Array should be a pair of [string, boolean]')
-	}
-}
+export function deriveSortableColumn(value) {
+	const type = typeOf(value)
 
-/**
- * Validates an object to ensure it has the necessary properties for creating a sorting configuration.
- *
- * @param {Object} value - The object to validate.
- * @throws {Error} Throws an error if the object does not have a 'name' property or has an invalid 'sorter'.
- */
-function objectValidator(value) {
-	if (typeof value.name !== 'string') {
-		throw new Error('The property "name" is required and must be a string')
+	const configGenerators = {
+		array: arrayConfigGenerator,
+		object: objectConfigGenerator,
+		string: stringConfigGenerator
 	}
-	if (value.sorter !== undefined && typeof value.sorter !== 'function') {
-		throw new Error('Sorter should be a function')
+
+	const configGenerator = configGenerators[type]
+	if (!configGenerator) {
+		throw new Error(`Invalid value type: ${type}`)
 	}
-}
 
+	return configGenerator(value)
+}
 /**
  * Creates a deep scan sample object that contains a union of all keys from all
  * objects in the array, pulling the values from the last item that contains the key.
@@ -96,7 +95,8 @@ function objectValidator(value) {
  * @param {Array<Object>} data - An array of objects to deep scan and collect sample values.
  * @returns {Object} A sample object consolidating all unique keys with their latest non-null values.
  */
-export function getDeepScanSample(data) {
+export function getDeepScanSample(data, deepScan = true) {
+	if (!deepScan) return [data[0]]
 	return data.reduce(
 		(acc, cur) => ({
 			...acc,
@@ -178,31 +178,6 @@ export function inferDataType(values) {
 	return type
 }
 
-/**
- * Derives column metadata from the data to be used in a tabular component.
- *
- * @param {Array} data - The data to derive column metadata from.
- * @returns {Array<import('./types').ColumnMetadata>} - The derived column metadata.
- */
-export function deriveMetadata(dataArray, options = {}) {
-	let { columns = [] } = options
-	if (dataArray.length === 0) return columns
-	const { actions, language } = { ...defaultViewOptions, ...options }
-
-	if (columns.length === 0) {
-		columns = deriveColumns(dataArray, options)
-	} else {
-		columns.forEach((col) => {
-			// if (col.sortable && !col.order) col.order = 'none'
-			if (!col.fields) col.fields = { text: col.name }
-		})
-	}
-	columns = addFormatters(columns, language)
-	if (actions.length > 0) columns = deriveActions(columns, actions)
-
-	return columns
-}
-
 /**
  * Adds a formatter function to each column in the array based on the column type. If a formatter
  * function is already present, it will not be overwritten. The formatter is created based on the
@@ -261,3 +236,40 @@ export function deriveActions(columns, input) {
 		}))
 	return [...actionColumns, ...columns]
 }
+
+/**
+ * Derives column metadata from the data to be used in a tabular component.
+ * @param {Array<import('./types').ColumnMetadata>} columns
+ * @param {Array} dataArray - The data to derive column metadata from.
+ * @param {Object} [options] - The options to use when deriving column metadata.
+ * @returns {Array<import('./types').ColumnMetadata>} - The derived column metadata.
+ */
+function deriveColumnMetadata(columns, dataArray, options) {
+	if (columns.length === 0) {
+		columns = deriveColumns(dataArray, options)
+	} else {
+		columns.forEach((col) => {
+			// if (col.sortable && !col.order) col.order = 'none'
+			if (!col.fields) col.fields = { text: col.name }
+		})
+	}
+	return columns
+}
+/**
+ * Derives column metadata from the data to be used in a tabular component.
+ *
+ * @param {Array} data - The data to derive column metadata from.
+ * @param {Object} [options] - The options to use when deriving column metadata.
+ * @returns {Array<import('./types').ColumnMetadata>} - The derived column metadata.
+ */
+export function deriveMetadata(dataArray, options = {}) {
+	let { columns = [] } = options
+	if (dataArray.length === 0) return columns
+	const { actions, language } = { ...defaultViewOptions, ...options }
+
+	columns = deriveColumnMetadata(columns, dataArray, options)
+	columns = addFormatters(columns, language)
+	if (actions.length > 0) columns = deriveActions(columns, actions)
+
+	return columns
+}

package/src/model.js

@@ -2,6 +2,50 @@ import { identity, clone as copy } from 'ramda'
 import { getDeepScanSample } from './infer'
 import { typeOf } from './utils'
 
+/**
+ * Derives a model from the input data
+ *
+ * @param {Array|Object} data  - the data to derive the model from
+ * @param {Boolean}      sparse - whether the data set contains sparse data
+ * @returns {Array}             - the derived model
+ */
+function deriveModel(data, sparse = false) {
+	const result = []
+	let item = data
+
+	if (Array.isArray(data)) item = sparse ? getDeepScanSample(data) : data[0]
+
+	const kv = Object.entries(item)
+	kv.forEach(([key, value]) => {
+		result.push({
+			name: key,
+			type: typeOf(value)
+		})
+	})
+	return result
+}
+
+/**
+ * Merges two models, returning a new model
+ *
+ * @param {Array} first      - the first model
+ * @param {Array} second     - the second model
+ * @param {Boolean} override - whether to override the type of the first model
+ * @returns {Array}      - the merged model
+ */
+function mergeModels(first, second, override = false) {
+	second.forEach(({ name, type }) => {
+		const existing = first.find((x) => x.name === name)
+		if (existing) {
+			if (existing.type !== type) existing.mixedTypes = true
+			if (override) existing.type = type
+		} else {
+			first.push({ name, type })
+		}
+	})
+	return first
+}
+
 /**
  * A model is a representation of a dataset
  * @returns an object with methods to manipulate the model
@@ -54,47 +98,3 @@ export function model() {
 	}
 	return actions
 }
-
-/**
- * Derives a model from the input data
- *
- * @param {Array|Object} data  - the data to derive the model from
- * @param {Boolean}      sparse - whether the data set contains sparse data
- * @returns {Array}             - the derived model
- */
-function deriveModel(data, sparse = false) {
-	const result = []
-	let item = data
-
-	if (Array.isArray(data)) item = sparse ? getDeepScanSample(data) : data[0]
-
-	const kv = Object.entries(item)
-	kv.forEach(([key, value]) => {
-		result.push({
-			name: key,
-			type: typeOf(value)
-		})
-	})
-	return result
-}
-
-/**
- * Merges two models, returning a new model
- *
- * @param {Array} first      - the first model
- * @param {Array} second     - the second model
- * @param {Boolean} override - whether to override the type of the first model
- * @returns {Array}      - the merged model
- */
-function mergeModels(first, second, override = false) {
-	second.forEach(({ name, type }) => {
-		const existing = first.find((x) => x.name === name)
-		if (existing) {
-			if (existing.type !== type) existing.mixedTypes = true
-			if (override) existing.type = type
-		} else {
-			first.push({ name, type })
-		}
-	})
-	return first
-}

package/src/parser.js

@@ -28,6 +28,48 @@ export function getRegex() {
 	return new RegExp(pattern, 'gm')
 }
 
+/**
+ * Replaces various shorthand operators with their standardized equivalent for filtering.
+ *
+ * @param {string} operator - The operator to be replaced.
+ * @returns {string} - The replaced operator string.
+ */
+function replaceOperators(operator) {
+	return operator.replace(':', '~*').replace('=>', '>=').replace('=<', '<=')
+}
+
+/**
+ * Removes double quotes from the start and end of a string.
+ *
+ * @param {string} str - The input string from which the surrounding quotes should be removed.
+ * @returns {string} - The unquoted string.
+ */
+function removeQuotes(str) {
+	const quoteMatch = str.match(/^"([^"]+)"$/)
+	return quoteMatch ? quoteMatch[1] : str
+}
+
+/**
+ * Processes the filter value provided, converting it into a format suitable for filtering.
+ * If the operator includes a tilde (~), the value is converted to a RegExp.
+ *
+ * @param {string|number} value - The value to be processed. It could be a string needing quote removal or a number that needs parsing.
+ * @param {string} operator - The operator that determines the type of processing to be applied to the value.
+ * @returns {string|number|RegExp} - The processed value, which may be a RegExp if the operator involves pattern matching.
+ */
+function processValue(value, operator) {
+	// If the value can be parsed as an integer, do so. Otherwise, strip quotes if present.
+
+	value = !isNaN(parseInt(value)) ? parseInt(value) : removeQuotes(value)
+	// If the operator includes a tilde (~), treat the value as a regular expression,
+	// case-insensitive if '*' is present, sensitive otherwise.
+	if (operator.includes('~')) {
+		value = operator.includes('*') ? new RegExp(value, 'i') : new RegExp(value)
+	}
+
+	return value
+}
+
 /**
  * Parses a search string and extracts filters based on a predefined regular expression pattern.
  * Each filter captures column, operator, and value components. Any remaining text that
@@ -67,45 +109,3 @@ export function parseFilters(string) {
 
 	return results
 }
-
-/**
- * Replaces various shorthand operators with their standardized equivalent for filtering.
- *
- * @param {string} operator - The operator to be replaced.
- * @returns {string} - The replaced operator string.
- */
-function replaceOperators(operator) {
-	return operator.replace(':', '~*').replace('=>', '>=').replace('=<', '<=')
-}
-
-/**
- * Processes the filter value provided, converting it into a format suitable for filtering.
- * If the operator includes a tilde (~), the value is converted to a RegExp.
- *
- * @param {string|number} value - The value to be processed. It could be a string needing quote removal or a number that needs parsing.
- * @param {string} operator - The operator that determines the type of processing to be applied to the value.
- * @returns {string|number|RegExp} - The processed value, which may be a RegExp if the operator involves pattern matching.
- */
-function processValue(value, operator) {
-	// If the value can be parsed as an integer, do so. Otherwise, strip quotes if present.
-
-	value = !isNaN(parseInt(value)) ? parseInt(value) : removeQuotes(value)
-	// If the operator includes a tilde (~), treat the value as a regular expression,
-	// case-insensitive if '*' is present, sensitive otherwise.
-	if (operator.includes('~')) {
-		value = operator.includes('*') ? new RegExp(value, 'i') : new RegExp(value)
-	}
-
-	return value
-}
-
-/**
- * Removes double quotes from the start and end of a string.
- *
- * @param {string} str - The input string from which the surrounding quotes should be removed.
- * @returns {string} - The unquoted string.
- */
-function removeQuotes(str) {
-	const quoteMatch = str.match(/^"([^"]+)"$/)
-	return quoteMatch ? quoteMatch[1] : str
-}

package/src/renamer.js

@@ -9,39 +9,25 @@ import { omit, identity } from 'ramda'
  * @property {string} [separator='_'] - The separator to use between the key and the prefix or suffix.
  * @property {Array}  [keys]          - The keys to rename.
  */
-
 /**
- * A generator function that produces a function to rename keys.
- *
- * @param {OptionsToRenameKeys} options - Options to rename keys
- * @returns {Object}                    - A renamer object.
- *
- * Example:
+ * Renames the keys of an object using a lookup table.
  *
- * renamer({ prefix: 'a', keys: ['a', 'b'] }).get()
- * renamer({ prefix: 'a', separator: '-' }).get()
- * renamer().setPrefix('a')
- *          .setSeparator('-')
- *          .setKeys(['a', 'b'])
- *          .get()
- * renamer().setPrefix('a').get()
- * renamer().setSuffix('b').get()
- * renamer().setKeys(['a', 'b']).get()
+ * @param {Object} lookup - The lookup table.
+ * @returns {Function} - A function that takes an object and renames the keys using the lookup table.
  */
-export function renamer(options = {}) {
-	const { prefix, suffix, separator = '_', keys = [] } = options
-	const rename = getRenamer(prefix, suffix, separator)
-	const renameObject = getObjectRenamer(rename, keys)
-
-	return {
-		get: () => ({ rename, renameObject }),
-		setPrefix: (value) => renamer({ ...omit(['suffix'], options), prefix: value }),
-		setSuffix: (value) => renamer({ ...omit(['prefix'], options), suffix: value }),
-		setKeys: (value) => renamer({ ...options, keys: value }),
-		setSeparator: (value) => renamer({ ...options, separator: value })
-	}
+function usingLookup(lookup) {
+	return (row) => Object.keys(row).reduce((acc, key) => ({ ...acc, [lookup[key]]: row[key] }), {})
 }
 
+/**
+ * Renames the keys of an object using a function.
+ *
+ * @param {Function} rename - The function to rename the keys.
+ * @returns {Function} - A function that takes an object and renames the keys using the function.
+ */
+function forObject(rename) {
+	return (row) => Object.keys(row).reduce((acc, key) => ({ ...acc, [rename(key)]: row[key] }), {})
+}
 /**
  * Generates a renamer function which adds a prefix or suffix to a string.
  *
@@ -78,21 +64,33 @@ function getObjectRenamer(rename, keys) {
 }
 
 /**
- * Renames the keys of an object using a lookup table.
+ * A generator function that produces a function to rename keys.
  *
- * @param {Object} lookup - The lookup table.
- * @returns {Function} - A function that takes an object and renames the keys using the lookup table.
- */
-function usingLookup(lookup) {
-	return (row) => Object.keys(row).reduce((acc, key) => ({ ...acc, [lookup[key]]: row[key] }), {})
-}
-
-/**
- * Renames the keys of an object using a function.
+ * @param {OptionsToRenameKeys} options - Options to rename keys
+ * @returns {Object}                    - A renamer object.
  *
- * @param {Function} rename - The function to rename the keys.
- * @returns {Function} - A function that takes an object and renames the keys using the function.
+ * Example:
+ *
+ * renamer({ prefix: 'a', keys: ['a', 'b'] }).get()
+ * renamer({ prefix: 'a', separator: '-' }).get()
+ * renamer().setPrefix('a')
+ *          .setSeparator('-')
+ *          .setKeys(['a', 'b'])
+ *          .get()
+ * renamer().setPrefix('a').get()
+ * renamer().setSuffix('b').get()
+ * renamer().setKeys(['a', 'b']).get()
  */
-function forObject(rename) {
-	return (row) => Object.keys(row).reduce((acc, key) => ({ ...acc, [rename(key)]: row[key] }), {})
+export function renamer(options = {}) {
+	const { prefix, suffix, separator = '_', keys = [] } = options
+	const rename = getRenamer(prefix, suffix, separator)
+	const renameObject = getObjectRenamer(rename, keys)
+
+	return {
+		get: () => ({ rename, renameObject }),
+		setPrefix: (value) => renamer({ ...omit(['suffix'], options), prefix: value }),
+		setSuffix: (value) => renamer({ ...omit(['prefix'], options), suffix: value }),
+		setKeys: (value) => renamer({ ...options, keys: value }),
+		setSeparator: (value) => renamer({ ...options, separator: value })
+	}
 }

package/src/rollup.js

@@ -1,27 +1,5 @@
 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.
  *
@@ -49,6 +27,28 @@ export function addToSummaries(group, row, summaries) {
 	})
 }
 
+/**
+ * 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)
+}
+
 /**
  * Fills grouped data with aligned data if specified in configuration.
  *

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Jerry Thomas
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.