@rokkit/data 1.0.0-next.119 → 1.0.0-next.120

package/dist/packages/core/src/utils.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Finds the closest ancestor of the given element that has the given attribute.
+ *
+ * @param {HTMLElement} element
+ * @param {string} attribute
+ * @returns {HTMLElement|null}
+ */
+export function getClosestAncestorWithAttribute(element: HTMLElement, attribute: string): HTMLElement | null;
+/**
+ * A function that performs no operations.
+ */
+export function noop(): void;
+/**
+ * Generates a random id
+ *
+ * @returns {string} A random id
+ */
+export function id(): string;
+/**
+ * Check if a value is a json object
+ *
+ * @param {*} val
+ * @returns {boolean}
+ */
+export function isObject(val: any): boolean;
+/**
+ * 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: any): string;
+/**
+ * Generates icon shortcuts for a collection of icons
+ *
+ * @param {string[]} icons
+ * @param {string} collection
+ * @param {string} variants
+ * @returns {Object}
+ */
+export function iconShortcuts(icons: string[], collection: string, variants: string): Object;
+/**
+ * Scales the path by the size
+ *
+ * @param {number} size
+ * @param {string|number} x
+ * @returns {string|number}
+ */
+export function scaledPath(size: number, x: string | number): string | number;
+/**
+ * Gets a key string from path
+ * @param {string[]} path
+ * @returns {string}
+ */
+export function getKeyFromPath(path: string[]): string;
+/**
+ * Gets a path array from key string
+ * @param {string} key
+ * @returns {string[]}
+ */
+export function getPathFromKey(key: string): string[];
+/**
+ * Get snippet function from an object
+ * @param {Object} obj
+ * @param {string} key
+ * @param {null|Function} defaultSnippet
+ * @returns {Function|undefined}
+ */
+export function getSnippet(obj: Object, key: string, defaultSnippet?: null | Function): Function | undefined;
+export function importIcons(icons: Object): Object;

package/dist/packages/data/src/aggregators.d.ts

@@ -0,0 +1,2 @@
+export function counter(values: any[]): number;
+export function violin(values: number[]): Object;

package/dist/packages/data/src/constants.d.ts

@@ -0,0 +1,46 @@
+export const pickAllowedConfig: <U extends Partial<Record<"children" | "actual_flag", any>>>(obj: "children" | "actual_flag" extends keyof U ? U : never) => "children" | "actual_flag" extends keyof U ? Pick<U, keyof U & ("children" | "actual_flag")> : never;
+/** @type {import('./types').DataFrameConfig */
+export const defaultConfig: import("./types").DataFrameConfig;
+export namespace defaultPathOptions {
+    let path: null;
+    let separator: string;
+    let currencySuffix: string;
+}
+export namespace defaultViewOptions {
+    let expanded: boolean;
+    let actions: never[];
+    let language: string;
+    let scanMode: string;
+}
+export namespace defaultActionOrder {
+    export let select: number;
+    export let edit: number;
+    let _delete: number;
+    export { _delete as delete };
+}
+/**
+ * Returns the default properties for a column
+ * @param {string} key - the key to use for the column
+ * @returns {Object} the default properties for a column
+ */
+export const filterOperations: {
+    '=': (value: any, pattern: any) => boolean;
+    '<': (value: any, pattern: any) => boolean;
+    '>': (value: any, pattern: any) => boolean;
+    '<=': (value: any, pattern: any) => boolean;
+    '>=': (value: any, pattern: any) => boolean;
+    '~*': (value: any, pattern: any) => any;
+    '~': (value: any, pattern: any) => any;
+    '!=': (value: any, pattern: any) => boolean;
+    '!~*': (value: any, pattern: any) => boolean;
+    '!~': (value: any, pattern: any) => boolean;
+};
+export namespace typeConverters {
+    export function string(value: any): string;
+    export function number(value: any): number;
+    export function boolean(value: any): boolean;
+    export function date(value: any): Date;
+    export { identity as mixed };
+}
+export function includeAll(): boolean;
+import { identity } from 'ramda';

package/dist/packages/data/src/convert.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Converts an array of objects into a columnar structure, returning an object with two attributes:
+ *
+ * - columns, which contains an array of column names
+ * - data, which is an object with column names as keys and arrays as values.
+ *
+ * @param {Array<Object>} input
+ * @returns {import('./types').Dataframe}
+ */
+export function fromArray(input: Array<Object>): import("./types").Dataframe;

package/dist/packages/data/src/dataset.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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: Object): Object;
+export function dataset(data: any, options?: {}): DataSet;
+export class DataSet {
+    constructor(data: any);
+    set data(values: any[]);
+    get data(): any[];
+    set config(props: any);
+    override(props: any): this;
+    where(condition: any): this;
+    groupBy(...fields: any[]): this;
+    alignBy(...fields: any[]): this;
+    usingTemplate(template: any): this;
+    summarize(from: any, fields: any): this;
+    rename(how: any): this;
+    drop(...fields: any[]): DataSet;
+    sortBy(...fields: any[]): this;
+    remove(): this;
+    update(value: any): this;
+    fillNA(value: any): this;
+    apply(callback: any): this;
+    rollup(): DataSet;
+    select(...cols: any[]): any[];
+    union(other: any): DataSet;
+    minus(other: any): DataSet;
+    intersect(other: any): DataSet;
+    innerJoin(other: any, condition: any): DataSet;
+    leftJoin(other: any, condition: any): DataSet;
+    rightJoin(other: any, condition: any): DataSet;
+    fullJoin(other: any, condition: any): DataSet;
+    crossJoin(other: any): DataSet;
+    semiJoin(other: any, condition: any): DataSet;
+    antiJoin(other: any, condition: any): DataSet;
+    nestedJoin(other: any, condition: any): DataSet;
+    #private;
+}

package/dist/packages/data/src/filter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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
+ * based on a value present in any of the object's properties.
+ *
+ * @param {Object[]} data - The array of objects to filter.
+ * @param {Object} options - The filtering options that define the condition.
+ * @param {string} [options.column] - The property name in the objects to filter by. If omitted, all properties are considered.
+ * @param {string|number} [options.value] - The value to compare against when filtering.
+ * @param {string} [options.operator] - The operator to use for comparison, should match a key in the filterOperations object.
+ * @returns {Object[]} - The filtered array of objects.
+ */
+export function filterObjectArray(data: Object[], options: {
+    column?: string | undefined;
+    value?: string | number | undefined;
+    operator?: string | undefined;
+}): Object[];
+/**
+ * Applies multiple filtering conditions to an array of objects. This function iterates through each filter option,
+ * successively narrowing down the data.
+ *
+ * @param {Object[]} data - The array of objects to filter.
+ * @param {Object[]} filters - An array of filtering options to apply to the data.
+ * @returns {Object[]} - The filtered array of objects that meet all conditions specified by the filters.
+ */
+export function filterData(data: Object[], filters: Object[]): Object[];

package/dist/packages/data/src/formatter.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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''
+ *
+ * @param {string} type               - The type of the formatter to use (e.g., 'integer', 'number', 'date', 'time', 'currency').
+ * @param {string} [language='en-US'] - Optional IETF language tag used for locale-specific formatting.
+ * @param {number} [decimalPlaces=2]  - Optional number of decimal places to show with number and currency formatting.
+ * @returns {*}                       - A format function that takes a value and returns a formatted string.
+ */
+export function createFormatter(type: string, language?: string, decimalPlaces?: number): any;

package/dist/packages/data/src/hierarchy.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Removes objects from an array where the parent attribute is not null.
+ * @param {Array<Object>} arr - The array of objects.
+ */
+export function removeChildren(arr: Array<Object>): void;
+/**
+ * Flatten nested children arrays within an array of objects.
+ * @param {Array<Object>} arr - The array of objects.
+ */
+export function flattenNestedChildren(arr: Array<Object>): void;
+/**
+ * Applies a hierarchical filter to an array of objects.
+ * @param {Array<Object>} arr - The array of objects.
+ * @param {Function} filterFn - The filter function to apply on each object.
+ */
+export function hierarchicalFilter(arr: Array<Object>, filterFn: Function): void;
+/**
+ * Derives the hierarchy from the data.
+ *
+ * @param {Array} data - The data to derive the hierarchy from.
+ * @param {string} path - The column name to be used as hierarchical path.
+ * @param {string} separator - The separator to be used in the path.
+ * @returns {Array<import('./types').Hierarchy>} - The derived hierarchy.
+ */
+export function deriveHierarchy(data: any[], options: any): Array<import("./types").Hierarchy>;
+/**
+ * Toggles the expansion state of a node and updates the visibility of its children accordingly.
+ * If the node is a parent (has child nodes), it will invert its 'isExpanded' property and call
+ * 'changeVisibilityForChildren' to reflect changes to its child nodes.
+ *
+ * @param {Object} node - The node to toggle expansion for. The node is expected to have an
+ *                        'isParent' property indicating if the node has children, an
+ *                        'isExpanded' property indicating if the node is expanded, and an array
+ *                        of child nodes under the 'children' property if it is a parent.
+ */
+export function toggleExpansion(node: Object): void;

package/dist/packages/data/src/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./types";
+export { typeOf } from "./utils";
+export { renamer } from "./renamer";
+export { model } from "./model";
+export { dataset } from "./dataset";
+export { dataview } from "./view";
+export { innerJoin, leftJoin, rightJoin, fullJoin, crossJoin, antiJoin, semiJoin } from "./join";

package/dist/packages/data/src/infer.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Derives the sorting information for a column based on the type of the input value.
+ *
+ * @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.
+ */
+export function deriveSortableColumn(value: import("./types").SortableColumn): import("./types").ColumnSorter;
+/**
+ * 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.
+ *
+ * @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 getSample(data: Array<Object>, deepScan?: boolean): Object;
+/**
+ * Derives a unique list of column names from an array of data objects.
+ * Each data object represents a row and this function compiles a list of all unique property keys
+ * present across these objects.
+ *
+ * @param {Object[]} data - The array of data objects to analyze for column names.
+ * @returns {string[]} - An array of strings representing the unique column names found across all data objects.
+ */
+export function deriveColumns(data: Object[], options: any): string[];
+/**
+ * Derives the data types of columns based on the data provided in an array of objects.
+ * The function assumes that all values of a single field (column) are of the same type. It uses
+ * the first object in the data array as a reference for the field names. Each field is categorized
+ * as either 'string' or 'number' based on whether any of the field values in the data set are non-numeric.
+ *
+ * @param {Object[]} data - The array of data objects to assess for column data types.
+ * @returns {Object} - An object with keys being the data types ('string' & 'number') and values
+ *                     being arrays of field names that correspond to that data type.
+ */
+export function deriveDataTypes(data: Object[]): Object;
+/**
+ * Infers the data type of a set of values by examining the values in the array.
+ * Assumes all values in the array should have the same type, unless they are 'null'.
+ * If multiple types are detected (excluding 'null'), the function will return 'mixed'.
+ * If all values are 'null', it returns 'null', and it returns 'undefined' for an empty array.
+ *
+ * @param {Array} values - An array of values for which the data type is to be inferred.
+ * @returns {string} - A string representing the inferred data type. Possible values are
+ *                     'undefined', 'null', 'mixed', or any data type returned by the getType function.
+ */
+export function inferDataType(values: any[]): string;
+/**
+ * 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
+ * override formatter if present, or the column type and language.
+ *
+ * @param {Array<import('./types').ColumnMetadata>} columns - The array of column metadata to add formatters to.
+ * @param {string} language - The language to use for formatting.
+ * @returns {Array<import('./types').ColumnMetadata>} - The array of column metadata with formatters added.
+ */
+export function addFormatters(columns: Array<import("./types").ColumnMetadata>, language: string): Array<import("./types").ColumnMetadata>;
+/**
+ * Converts an array of action names to an array of action objects.
+ *
+ * @param {Array<string|import('./types').Action>} input - The input to convert to actions.
+ * @returns {Array<import('./types').Action>} - The converted actions.
+ */
+export function convertToActions(input: Array<string | import("./types").Action>): Array<import("./types").Action>;
+/**
+ * Adds actions to the column metadata. This function updates the columns array in place.
+ *
+ * @param {Array<import('./types').ColumnMetadata>} columns - The column metadata to update.
+ * @param {Array<string|import('./types').Action>}  input   - The actions to add to the column metadata.
+ * @returns {Array<import('./types').ColumnMetadata>} - The updated column metadata.
+ */
+export function deriveActions(columns: Array<import("./types").ColumnMetadata>, input: Array<string | import("./types").Action>): Array<import("./types").ColumnMetadata>;
+/**
+ * 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: any, options?: Object): Array<import("./types").ColumnMetadata>;

package/dist/packages/data/src/join.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Filters the results of the first dataset based on the condition using the second dataset.
+ *
+ * @param {Array<Object>}    first     - The first dataset to filter.
+ * @param {Array<Object>}    second    - The second dataset to filter by.
+ * @param {Function}        condition - The condition to filter the first dataset by.
+ * @returns {Array<Object>}            - The filtered dataset.
+ */
+export function antiJoin(first: Array<Object>, second: Array<Object>, condition: Function): Array<Object>;
+/**
+ * Joins two datasets together based on a condition. Result includes all rows from the first
+ * dataset and matching rows from the second dataset. In case of multiple matches, all
+ * combinations are returned. When combining the rows, the columns from the first dataset take
+ * precedence.
+ *
+ * @param {Array<Object>}    first     - The first dataset to join.
+ * @param {Array<Object>}    second    - The second dataset to join.
+ * @param {Function}      condition - The condition to join the datasets on.
+ * @returns {Array<Object>}            - The joined dataset.
+ */
+export function innerJoin(first: Array<Object>, second: Array<Object>, condition: Function): Array<Object>;
+/**
+ * Performs a left join on two datasets based on a condition.
+ *
+ * - Result includes all rows from the first dataset and matching rows from the second dataset.
+ * - In case of multiple matches, all combinations are returned.
+ * - When combining the rows, the columns from the first dataset take precedence.
+ * - If there is no match in the second dataset, only the row from the first dataset is returned.
+ *
+ * This can be used to perform a right join by swapping the datasets.
+ *
+ * @param {Array<Object>}    first     - The first dataset to join.
+ * @param {Array<Object>}    second    - The second dataset to join.
+ * @param {Function}         condition - The condition to join the datasets on.
+ * @returns {Array<Object>}            - The joined dataset.
+ */
+export function leftJoin(first: Array<Object>, second: Array<Object>, condition: Function): Array<Object>;
+/**
+ * Performs a right join on two datasets based on a condition.
+ *
+ * - Result includes all rows from both datasets.
+ * - In case of multiple matches, all combinations are returned.
+ * - When combining the rows, the columns from the second dataset take precedence.
+ * - If there is no match in the first dataset, only the row from the second dataset is returned.
+ *
+ * @param {Array<Object>}    first     - The first dataset to join.
+ * @param {Array<Object>}    second    - The second dataset to join.
+ * @param {Function}   condition - The condition to join the datasets on.
+ * @returns {Array<Object>}            - The joined dataset.
+ */
+export function rightJoin(first: Array<Object>, second: Array<Object>, condition: Function): Array<Object>;
+/**
+ * Performs a full join on two datasets based on a condition.
+ *
+ * - Result includes all rows from both datasets.
+ * - In case of multiple matches, all combinations are returned.
+ * - When combining the rows, the columns from the second dataset take precedence.
+ * - If there is no match in the first dataset, only the row from the second dataset is returned.
+ *
+ * @param {Array<Object>}    first     - The first dataset to join.
+ * @param {Array<Object>}    second    - The second dataset to join.
+ * @param {Function}         condition - The condition to join the datasets on.
+ * @returns {Array<Object>}            - The joined dataset.
+ */
+export function fullJoin(first: Array<Object>, second: Array<Object>, condition: Function): Array<Object>;
+/**
+ * Performs a cross join on two datasets. Result includes all combinations of rows from both datasets.
+ *
+ * @param {Array<Object>} first  - The first dataset to join.
+ * @param {Array<Object>} second - The second dataset to join.
+ * @returns {Array<Object>}      - The joined dataset.
+ */
+export function crossJoin(first: Array<Object>, second: Array<Object>): Array<Object>;
+/**
+ * Performs a semi join on two datasets based on a condition. Result includes all rows from the first
+ * dataset that have a match in the second dataset.
+ *
+ * @param {Array<Object>}    first     - The first dataset to join.
+ * @param {Array<Object>}    second    - The second dataset to join.
+ * @param {Function}     condition - The condition to join the datasets on.
+ * @returns {Array<Object>}            - The joined dataset.
+ */
+export function semiJoin(first: Array<Object>, second: Array<Object>, condition: Function): Array<Object>;
+/**
+ * Performs a nested join on two datasets based on a condition. Result includes all rows from the first
+ * dataset that have a match in the second dataset. The result is nested with the matching rows from the
+ * second dataset.
+ *
+ * @param {Array<Object>}    first            - The first dataset to join.
+ * @param {Array<Object>}    second           - The second dataset to join.
+ * @param {Function}         condition        - The condition to join the datasets on.
+ * @param {String}   [key='children'] - The key to nest the matching rows under.
+ * @returns {Array<Object>}            - The joined dataset.
+ */
+export function nestedJoin(first: Array<Object>, second: Array<Object>, condition: Function, key?: string): Array<Object>;

package/dist/packages/data/src/list.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Compares two items for sorting. When grouped, uses group comparison before item comparison
+ *
+ * @param {*} a first item
+ * @param {*} b second item
+ * @param {*} data
+ * @returns
+ */
+export function compare(a: any, b: any, data: any): number;
+/**
+ * Search the data for existence of string in the data
+ *
+ * @param {List} data
+ * @param {string} value
+ * @returns
+ */
+export function quickSearch(data: List, value: string): object[];
+/**
+ * Create a new list
+ *
+ * @param {Array<object>} data
+ * @returns
+ */
+export function list(data: Array<object>): List;
+/**
+ * Implements a list containing data and functionality for sorting, filtering, and grouping.
+ */
+export class List {
+    /**
+     * Creates a List instance with initial data and default settings for keys and functions.
+     * @param {Array<object>} data - The initial array of objects to populate the list.
+     */
+    constructor(data: Array<object>);
+    data: object[];
+    primaryKey: string;
+    filterKey: string | undefined;
+    sortKey: string | undefined;
+    groupKey: string | undefined;
+    lookup: {};
+    searchText: string;
+    filterUsing: Function | undefined;
+    sortUsing: Function | undefined;
+    filtered: import("svelte/store").Writable<object[]>;
+    /**
+     * Sets a primary key attribute for list items and assigns a unique identifier if not present.
+     *
+     * @param {string} value - The property name to be set as the primary key.
+     * @returns {List} This list instance for method chaining.
+     */
+    key(value: string): List;
+    /**
+     * Configures sorting by a given key and sorting function.
+     *
+     * @param {string} key - The property name to sort by.
+     * @param {Function} [using=compare] - The function used to sort the list items.
+     * @returns {List} This list instance for method chaining.
+     */
+    sortBy(key: string, using?: Function): List;
+    /**
+     * Groups list items by a given key and maps group keys for display using an optional lookup object.
+     *
+     * @param {string} key - The property name to group by.
+     * @param {object|null} [lookup=null] - An object mapping group keys to display names.
+     * @returns {List} This list instance for method chaining.
+     */
+    groupBy(key: string, lookup?: object | null): List;
+    /**
+     * Sets the key and function for filtering list items.
+     *
+     * @param {string} key - The property name to filter by.
+     * @param {Function} [using=quickSearch] - The function used to filter the list items.
+     * @returns {List} This list instance for method chaining.
+     */
+    filterBy(key: string, using?: Function): List;
+    /**
+     * Sorts the list based on the configured sorting function.
+     *
+     * @returns {List} This list instance for method chaining.
+     */
+    sort(): List;
+    /**
+     * Adds a new item to the list, assigning a primary key if necessary, and then sorts and refreshes the list.
+     *
+     * @param {object} item - The item to add to the list.
+     * @returns {List} This list instance for method chaining.
+     */
+    add(item: object): List;
+    /**
+     * Removes an item from the list by primary key and refreshes the list.
+     *
+     * @param {object} item - The item to remove from the list.
+     * @returns {List} This list instance for method chaining.
+     */
+    remove(item: object): List;
+    /**
+     * Modifies an existing item in the list, identified by primary key, and then sorts and refreshes the list.
+     *
+     * @param {object} item - The item to modify in the list.
+     * @returns {List} This list instance for method chaining.
+     */
+    modify(item: object): List;
+    /**
+     * Sets the text to search for in the list's items and then refreshes the list.
+     *
+     * @param {string} text - The text to search for.
+     * @returns {List} This list instance for method chaining.
+     */
+    search(text: string): List;
+    /**
+     * Refreshes the list based on current sorting, grouping, and filtering configuration.
+     *
+     * @returns {List} This list instance for method chaining.
+     */
+    refresh(): List;
+    /**
+     * Gets the current state of the filtered list data.
+     *
+     * @returns {Array<object>} The current filtered data of the list.
+     */
+    current(): Array<object>;
+}

package/dist/packages/data/src/metadata.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Adds a path modifier to column definitions that match a specific path.
+ *
+ * @param {Array<Object>} columns - The original array of column definitions.
+ * @param {string|null} path - The path used to identify columns that require path modifiers.
+ * @param {string} separator - The separator used in conjunction with the path.
+ * @returns {Array<Object>} The array of column definitions with path modifiers added as needed.
+ */
+export function addPathModifier(columns: Array<Object>, path: string | null, separator: string): Array<Object>;
+/**
+ * Derives column properties for a given sample and options.
+ *
+ * @param {Object} sample - The sample object used to derive column properties.
+ * @param {Object} options - The options used to modify column properties.
+ *        It can specify path, separator, and currencySuffix for column customization.
+ * @returns {Array<Object>} An array of derived column definitions.
+ */
+export function deriveColumnProperties(sample: Object, options: Object): Array<Object>;
+/**
+ * Derives the column metadata from the provided data and options.
+ *
+ * @param {Array} data                       - The data to derive the column metadata from.
+ * @param {Object} [options]                 - Optional parameters to control the metadata derivation.
+ * @param {Array} [options.metadata]         - The metadata to use instead of deriving it from the data.
+ * @param {boolean} [options.deepScan=false] - Determines if the metadata derivation should perform a deep scan of the data.
+ *
+ * @returns {import('./types').Metadata} The derived column metadata.
+ */
+export function deriveColumnMetadata(data: any[], options?: {
+    metadata?: any[] | undefined;
+    deepScan?: boolean | undefined;
+}): import("./types").Metadata;

package/dist/packages/data/src/model.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A model is a representation of a dataset
+ * @returns an object with methods to manipulate the model
+ */
+export function model(): {
+    get: () => any[];
+    clone: (other: any) => /*elided*/ any;
+    /**
+     * Renames the reference names using a renamer
+     * @param {Function} rename - the renamer function
+     */
+    renameUsing: (rename?: Function) => /*elided*/ any;
+    /**
+     * Analyzes the input data and derives a model from it
+     *
+     * @param {Array|Object} value      - the data to derive the model from
+     * @param {boolean}      sparseData - indicates that rows may have missing attributes
+     * @returns {Object}     this
+     */
+    from: (value: any[] | Object, sparseData: boolean) => Object;
+    /**
+     * Merges the model with another model
+     *
+     * @param {Array}   other    - the model to merge with
+     * @param {Boolean} override - whether to override the type of the first model
+     * @returns {Object} this
+     */
+    merge: (other: any[], override?: boolean) => Object;
+};

package/dist/packages/data/src/parser.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Constructs a regular expression pattern for matching search filter strings.
+ * The pattern captures "column", "operator", and "value" groups for filter expressions.
+ * Supported operators include common comparison and wildcard operators.
+ *
+ * Examples of valid expressions this regex can match:
+ * - "username:john_doe"
+ * - "age>30"
+ * - "status!=active"
+ * - "title~\"Product Manager\""
+ * - "completed!~*yes"
+ *
+ * The "column" group matches one or more word characters.
+ * The "operator" group matches one among the specified comparison or wildcard operators:
+ * :, >, <, >=, <=, =<, =>, =, !=, ~, ~*, !~, !~*.
+ * The "value" group matches either a double-quoted string or a single unquoted word
+ * that doesn't include whitespace or any of the operator characters.
+ *
+ * @returns {RegExp} - The regular expression pattern to identify search filter elements.
+ */
+export function getRegex(): RegExp;
+/**
+ * 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
+ * does not fit the pattern is considered a general search term.
+ *
+ * @param {string} string - The search string to parse for filters.
+ * @returns {Object[]} - An array of filter objects each containing the column, operator, and value,
+ *                       plus an additional object for general search if there is remaining text.
+ */
+export function parseFilters(string: string): Object[];