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

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

@@ -0,0 +1,52 @@
+/**
+ * Generate shades for a color using css varuable
+ *
+ * @param {string} name
+ * @param {string} modifier
+ * @returns
+ */
+export function shadesOf(name: string, modifier?: string): {
+    DEFAULT: any;
+    base: any;
+    inset: any;
+    subtle: any;
+    muted: any;
+    raised: any;
+    elevated: any;
+    floating: any;
+    contrast: any;
+    overlay: any;
+};
+/**
+ * Generate shades for a color using css varuable
+ *
+ * @param {string} name
+ * @param {string} modifier
+ * @returns {object}
+ */
+export function stateColors(name: string, modifier?: string): object;
+/**
+ *
+ * @param {string} modifier
+ * @returns
+ */
+export function themeColors(modifier?: string): {};
+/**
+ * Generates contrast colors for light and dark modes based on a given palette. Each color variant in the
+ * palette is mapped to either a light or dark contrast color depending on the shade's value.
+ *
+ * @param {string} [light='#ffffff'] - The default light color used when the shade is >= 500 in light mode or <= 500 in dark mode.
+ * @param {string} [dark='#000000'] - The default dark color used when the shade is < 500 in light mode or > 500 in dark mode.
+ * @param {Array<string>} [palette=defaultPalette] - An array of color variant names to generate contrast colors for.
+ * @returns {Array<Object>} An array containing contrast color rules organized by light and dark modes for each variant in the palette.
+ */
+export function contrastColors(light?: string, dark?: string, palette?: Array<string>): Array<Object>;
+/**
+ * Constructs and returns the light and dark theme variants based on provided color mapping and color definitions.
+ *
+ * @param {string} name                          - The base name for the theme, defaults to 'rokkit' if not provided.
+ * @param {Object} [mapping=defaultThemeMapping] - An object mapping variant names to color property names.
+ * @param {Object} [colors=defaultColors]        - The object containing default color definitions.
+ * @returns {Array<Array>} An array containing two arrays, one for the light theme variant and another for the dark theme.
+ */
+export function themeRules(name?: string, mapping?: Object, colors?: Object): Array<any[]>;

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

@@ -0,0 +1,10 @@
+/**
+ * Generates an array of tick marks for a range of values.
+ *
+ * @param {number} lowerBound                            - The lower bound of the range.
+ * @param {number} upperBound                            - The upper bound of the range.
+ * @param {number} [minorTickStep=upperBound-lowerBound] - The step size for minor ticks.
+ * @param {number} [majorTickStep=1]                     - The step size for major ticks.
+ * @returns {import('./types').TickMark[]>} An array of tick mark objects.
+ */
+export function generateTicks(lowerBound: number, upperBound: number, minorTickStep?: number, majorTickStep?: number): import("./types").TickMark[];

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

@@ -0,0 +1,245 @@
+declare const _default: {};
+export default _default;
+export type LineType = "child" | "last" | "sibling" | "empty" | "icon";
+/**
+ * An object where keys are event names and values are event handler functions.
+ */
+export type EventHandlers = {
+    [x: string]: Function;
+};
+/**
+ * Component map to be used to render the item.
+ */
+export type ComponentMap = {
+    [x: string]: import("svelte").SvelteComponent<Record<string, any>, any, any>;
+};
+/**
+ * Options for the sort order of the column.
+ */
+export type SortOptions = "ascending" | "descending" | "none";
+export type SelectionState = "checked" | "unchecked" | "indeterminate";
+/**
+ * Options for the horizontal alignment of the column content.
+ */
+export type HorizontalAlignOptions = "left" | "middle" | "right";
+/**
+ * Options for the action type of the column.
+ */
+export type ActionTypes = "select" | "edit" | "delete";
+/**
+ * Structure to map custom fields for rendering. This is used to identofy the attributes for various purposes.
+ */
+export type FieldMapping = {
+    /**
+     * Unique id for the item
+     */
+    id?: string | undefined;
+    /**
+     * the text to render
+     */
+    text?: string | undefined;
+    /**
+     * the value associated with the item
+     */
+    value?: string | undefined;
+    /**
+     * a URL
+     */
+    url?: string | undefined;
+    /**
+     * icon to render
+     */
+    icon?: string | undefined;
+    /**
+     * the image to render
+     */
+    image?: string | undefined;
+    /**
+     * children of the item
+     */
+    children?: string | undefined;
+    /**
+     * summary of the item
+     */
+    summary?: string | undefined;
+    /**
+     * notes for the item
+     */
+    notes?: string | undefined;
+    /**
+     * additional properties
+     */
+    props?: string | undefined;
+    /**
+     * item is open or closed
+     */
+    isOpen?: string | undefined;
+    /**
+     * level of item
+     */
+    level?: string | undefined;
+    /**
+     * item is a parent
+     */
+    parent?: string | undefined;
+    /**
+     * {string} [isDeleted='_deleted'] item is deleted
+     */
+    currency?: string | undefined;
+    /**
+     * Field mapping to be used on children in the next level
+     */
+    fields?: FieldMapping | undefined;
+};
+/**
+ * Column metadata for the table.
+ */
+export type ColumnMetadata = {
+    /**
+     * - The name of the column.
+     */
+    name: string;
+    /**
+     * - The data type of the column (e.g., "string", "number", "date").
+     */
+    dataType: string;
+    /**
+     * - Additional attributes for the column.
+     */
+    fields?: FieldMapping | undefined;
+    /**
+     * - The number of digits for numeric values (defaults to 0).
+     */
+    digits?: number | undefined;
+    /**
+     * - A function to format the column value.
+     */
+    formatter: Function;
+    /**
+     * - Indicates if the column is virtual (true/false).
+     */
+    virtual?: boolean | undefined;
+    /**
+     * - Indicates if the column is sortable (true/false).
+     */
+    sortable?: boolean | undefined;
+    /**
+     * - The sort order of the column.
+     */
+    sortOrder?: SortOptions | undefined;
+    /**
+     * - The alignment of the column content.
+     */
+    align?: HorizontalAlignOptions | undefined;
+    /**
+     * - Action attribute for action columns.
+     */
+    action?: ActionTypes | undefined;
+};
+/**
+ * Track the state of a row in the table.
+ */
+export type RowState = {
+    /**
+     * - The index of the node in the flat list.
+     */
+    index: number;
+    /**
+     * - The depth of the node in the hierarchy.
+     */
+    depth: number;
+    /**
+     * - The value of the hierarchy node.
+     */
+    value?: string | undefined;
+    /**
+     * - Indicates whether the node is visible (true/false).
+     */
+    isHidden?: boolean | undefined;
+    /**
+     * - Indicates if this node is a parent (true/false).
+     */
+    isParent?: boolean | undefined;
+    /**
+     * - Indicates whether the node is expanded (true/false).
+     */
+    isExpanded?: boolean | undefined;
+    /**
+     * - The index of the parent node in the flat list.
+     */
+    parentIndex?: number | undefined;
+    /**
+     * - Indicates whether the node is selected (true/false/indeterminate).
+     */
+    selected?: SelectionState | undefined;
+    /**
+     * - The indices of the children in the flat list.
+     */
+    childred: Array<number>;
+};
+/**
+ * Track the state of all rows in the table.
+ */
+export type RowStateMap = {
+    /**
+     * - Flat list of hierarchy nodes.
+     */
+    rows: RowState[];
+};
+/**
+ * Shade mapping for color variables
+ */
+export type ShadeMapping = {
+    /**
+     * - the variable name to be used
+     */
+    key: string;
+    /**
+     * - the value to be used
+     */
+    value: string;
+    /**
+     * - light or dark mode
+     */
+    mode: string;
+};
+export type TickMark = {
+    /**
+     * - The value of the tick mark.
+     */
+    value: number;
+    /**
+     * - The label for the tick mark.
+     */
+    label: string;
+    /**
+     * - Indicates if the tick mark is a major tick.
+     */
+    major: boolean;
+};
+export type CalendarDay = {
+    /**
+     * - The day of the month.
+     */
+    day: number;
+    /**
+     * - indicates the offset for positioning
+     */
+    offset: number;
+    /**
+     * - Datevalue for the day.
+     */
+    date: date;
+    /**
+     * - formatted text for the day.
+     */
+    text: string;
+    /**
+     * - Indicates if the day is a holiday.
+     */
+    holiday: boolean;
+    /**
+     * - Indicates if the day is on the weekend.
+     */
+    weekend: boolean;
+};

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