@rokkit/core 1.0.0-next.113 → 1.0.0-next.115

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[];

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

@@ -0,0 +1,37 @@
+/**
+ * A generator function that produces a function to rename keys.
+ *
+ * @param {OptionsToRenameKeys} options - Options to rename keys
+ * @returns {Object}                    - A renamer object.
+ *
+ * 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()
+ */
+export function renamer(options?: OptionsToRenameKeys): Object;
+export type OptionsToRenameKeys = {
+    /**
+     * - The prefix to add to the key.
+     */
+    prefix?: string | undefined;
+    /**
+     * - The suffix to add to the key.
+     */
+    suffix?: string | undefined;
+    /**
+     * - The separator to use between the key and the prefix or suffix.
+     */
+    separator?: string | undefined;
+    /**
+     * - The keys to rename.
+     */
+    keys?: any[] | undefined;
+};

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

@@ -0,0 +1,51 @@
+/**
+ * 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: any[]): Object;
+/**
+ * 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: Object, row: Object, summaries: any[]): void;
+/**
+ * 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: any[], groupByKeys: any[], summaries: any[]): Object;
+/**
+ * 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: Object, config: Object, fillRowsFunc: any): any[];
+/**
+ * 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: any[], summaries: any[]): any[];
+/**
+ * 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: Array<Object>, config: Object): Function;