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

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

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

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

@@ -0,0 +1,6 @@
+/**
+ * Derive the type of a value
+ * @param {any} value
+ * @returns {string}
+ */
+export function typeOf(value: any): string;

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

@@ -0,0 +1,35 @@
+/**
+ * Sorts a hierarchy based on a group of sorters.
+ *
+ * @param {Array<Object>} hierarchy - The hierarchy to sort.
+ * @param {Array<Array<string, boolean>>} sortGroup - The group of sorters to apply.
+ */
+export function groupSort(hierarchy: Array<Object>, sortGroup: Array<Array<string, boolean>>): void;
+/**
+ * Determines the selected state of a group of children in the hierarchy.
+ * If all children are checked, returns 'checked'.
+ * If all children are unchecked, returns 'unchecked'.
+ * Otherwise, returns 'indeterminate'.
+ *
+ * @param {Array<Object>} children - The array of child objects with a 'selected' property.
+ * @returns {string} The determined selected state: 'checked', 'unchecked', or 'indeterminate'.
+ */
+export function determineSelectedState(children: Array<Object>): string;
+/**
+ * Toggles the selection state of a node in the hierarchy.
+ * Depending on whether the node to toggle is a parent or child,
+ * it will either select or deselect all children, or update the parent's selection state based on its children's states.
+ *
+ * @param {import('./types').Hierarchy} item - The node to toggle.
+ *
+ */
+export function toggleSelection(item: import("./types").Hierarchy): void;
+/**
+ * Creates a view object for managing data presentation with metadata and hierarchy structures,
+ * as well as providing methods for sorting, selection, and toggling of data expansion.
+ *
+ * @param {Array<Object>} data    - The source data array to be presented by the view.
+ * @param {Object}        options - The configuration options used for deriving metadata and hierarchy from the data.
+ * @returns {import('svelte/store').Writable} An object representing the view, providing methods to manipulate and query the presentation state.
+ */
+export function dataview(data: Array<Object>, options: Object): import("svelte/store").Writable<any>;

package/dist/packages/helpers/src/components/index.d.ts

@@ -0,0 +1,2 @@
+export { default as MockItem } from "./MockItem.svelte";
+export { default as StaticContent } from "./StaticContent.svelte";

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

@@ -0,0 +1 @@
+export * from "./simulators/touch";

package/dist/packages/helpers/src/matchers/action.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Checks if all the given events are registered by the action and cleaned up on destroy.
+ *
+ * @param {*} action
+ * @param {Object<string,any>} options
+ * @param {string|Array<string>} events
+ * @returns
+ */
+export function toUseHandlersFor(action: any, options: {
+    [x: string]: any;
+}, events: string | Array<string>): {
+    message: () => string;
+    pass: boolean;
+};
+/**
+ * Verifies that only the specified events are triggered. Expects an object of spies with key as event names.
+ *
+ * @param {Object<string,any>} handler : Object with keys as event names and values as spies
+ * @param {string|Array<string>} events : An event name or an array of event names
+ * @returns
+ */
+export function toOnlyTrigger(handler: {
+    [x: string]: any;
+}, events: string | Array<string>): {
+    message: () => string;
+    pass: boolean;
+};

package/dist/packages/helpers/src/matchers/array.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Verify that an array contains all of the expected values
+ *
+ * @param {Array} received - the array to inspect
+ * @param {Array} expected - the values to check for
+ */
+export function toIncludeAll(received: any[], expected: any[]): {
+    message: () => string;
+    pass: boolean;
+};

package/dist/packages/helpers/src/matchers/dataset.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Check if the element has valid data attributes
+ *
+ * @param {HTMLElement} received - HTML element to be checked
+ * @param {Object}      expected - data to be compared
+ */
+export function toHaveValidData(received: HTMLElement, expected: Object): {
+    message: () => string;
+    pass: boolean;
+};

package/dist/packages/helpers/src/matchers/event.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Verify that a spy event has been dispatched with data in event detail
+ *
+ * @param {Function} spy  - the event handler to inspect
+ * @param {Object}   data - data expected inthe event detail
+ */
+export function toHaveBeenDispatchedWith(spy: Function, data: Object): {
+    message: () => string;
+    pass: boolean;
+};

package/dist/packages/helpers/src/matchers/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./array";
+export * from "./action";
+export * from "./dataset";
+export * from "./event";

package/dist/packages/helpers/src/matchers/internal.d.ts

@@ -0,0 +1 @@
+export function getMessage(actual: any, expected: any, pass: any, condition?: string): string;

package/dist/packages/helpers/src/mocks/animate.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/packages/helpers/src/mocks/element.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Creates an array of elements with the specified size
+ *
+ * @param {number} count
+ * @param {number} size
+ * @param {string} [prop='offsetHeight']
+ * @returns {Array<Object<string, number>>}
+ */
+export function elementsWithSize(count: number, size: number, prop?: string): Array<{
+    [x: string]: number;
+}>;
+/**
+ * Creates an array of elements with mixed sizes
+ *
+ * @param {Array<{count: number, size: number}>} data
+ * @param {string} prop
+ * @returns {Array<Object<string, number>>}
+ */
+export function mixedSizeElements(data: Array<{
+    count: number;
+    size: number;
+}>, prop: string): Array<{
+    [x: string]: number;
+}>;
+/**
+ * Creates a mock node with functions to add and remove event handlers
+ *
+ * @param {Array<string} events
+ * @returns {{node: HTMLElement, listeners: Object<string, integer>}}
+ */
+export function getMockNode(events: Array<string>): {
+    node: HTMLElement;
+    listeners: {
+        [x: string]: integer;
+    };
+};
+/**
+ * @typedef {Object} NestedItem
+ * @property {string} name
+ * @property {string} [dataPath]
+ * @property {string} [id]
+ * @property {Array<NestedItem>} [children]
+ */
+/**
+ * Creates a nested HTML element structure using the provided data
+ *
+ * @param {NestedItem} item
+ * @returns {HTMLElement}
+ */
+export function createNestedElement(item: NestedItem): HTMLElement;
+/**
+ * Mocks the requestSubmit function for HTMLFormElement which is not implemented by JSDOM
+ */
+export function mockFormRequestSubmit(): boolean;
+export type NestedItem = {
+    name: string;
+    dataPath?: string | undefined;
+    id?: string | undefined;
+    children?: NestedItem[] | undefined;
+};

package/dist/packages/helpers/src/mocks/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./match-media";
+export * from "./element";

package/dist/packages/helpers/src/mocks/match-media.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Updates the media query matches
+ * @returns {void}
+ */
+export function updateMedia(): void;
+/**
+ * Mocks the window.matchMedia function
+ * @param {string} query
+ * @returns {Object}
+ */
+export const matchMediaMock: import("vitest").Mock<(...args: any[]) => any>;
+export type MediaQuery = {
+    "min-width"?: integer;
+    "max-width"?: integer;
+    "min-height"?: integer;
+    "max-height"?: integer;
+    width?: integer;
+    height?: integer;
+    orientation?: integer;
+    "aspect-ratio"?: integer;
+    "min-aspect-ratio"?: integer;
+    "max-aspect-ratio"?: integer;
+    resolution?: integer;
+    "min-resolution"?: integer;
+    "max-resolution"?: integer;
+    scan?: integer;
+    grid?: integer;
+    update?: integer;
+    "overflow-block"?: integer;
+};

package/dist/packages/helpers/src/mocks/resize-observer.d.ts

@@ -0,0 +1,9 @@
+export class ResizeObserver {
+    constructor(callback: any);
+    callback: any;
+    elements: Map<any, any>;
+    observe(element: any): void;
+    unobserve(element: any): void;
+    disconnect(): void;
+    simulateResize(element: any, contentRect: any): void;
+}

package/dist/packages/helpers/src/simulators/index.d.ts

@@ -0,0 +1 @@
+export * from "./touch";

package/dist/packages/helpers/src/simulators/touch.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Simulates a mouse event on a given node.
+ * @param {number} x
+ * @param {number} y
+ * @returns
+ */
+export function simulateMouseEvent(x: number, y: number): {
+    clientX: number;
+    clientY: number;
+    stopPropagation: import("vitest").Mock<(...args: any[]) => any>;
+    preventDefault: import("vitest").Mock<(...args: any[]) => any>;
+};
+/**
+ * Simulates a touch event on a given node.
+ * @param {number} clientX
+ * @param {number} clientY
+ * @returns
+ */
+export function simulateTouchEvent(clientX: number, clientY: number): {
+    touches: {
+        clientX: number;
+        clientY: number;
+    }[];
+    preventDefault: import("vitest").Mock<(...args: any[]) => any>;
+    stopPropagation: import("vitest").Mock<(...args: any[]) => any>;
+};
+/**
+ * Simulates a touch swipe on a given node.
+ * @param {HTMLElement} node
+ * @param {number} distance
+ * @param {number} [delay=0]
+ */
+export function simulateTouchSwipe(node: HTMLElement, distance: number, delay?: number): void;
+/**
+ * Simulates a mouse swipe on a given node.
+ * @param {HTMLElement} node
+ * @param {number} distance
+ * @param {number} [delay=0]
+ */
+export function simulateMouseSwipe(node: HTMLElement, distance: number, delay?: number): void;

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

@@ -0,0 +1,22 @@
+/**
+ * Clean up and optimise SVG icon
+ *
+ * @param {string} svg SVG code
+ * @param {boolean} color True if color should be preserved
+ */
+export function cleanAndOptimizeIcon(svg: string, color: boolean): void;
+/**
+ * Process icons
+ *
+ * @param {IconifyTools} iconSet Icon set
+ * @param {boolean} color True if color should be preserved
+ */
+export function processIcons(iconSet: IconifyTools, color: boolean): void;
+/**
+ * Convert icons
+ *
+ * @param {string} folder Folder with icons
+ * @param {string} prefix Prefix for icon set
+ * @param {boolean} color True if color should be preserved
+ */
+export function convert(folder: string, prefix: string, color?: boolean): Promise<void>;

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

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

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

@@ -0,0 +1,18 @@
+export { default as InputCheckbox } from "./InputCheckbox.svelte";
+export { default as InputColor } from "./InputColor.svelte";
+export { default as InputDate } from "./InputDate.svelte";
+export { default as InputDateTime } from "./InputDateTime.svelte";
+export { default as InputEmail } from "./InputEmail.svelte";
+export { default as InputFile } from "./InputFile.svelte";
+export { default as InputMonth } from "./InputMonth.svelte";
+export { default as InputNumber } from "./InputNumber.svelte";
+export { default as InputPassword } from "./InputPassword.svelte";
+export { default as InputRadio } from "./InputRadio.svelte";
+export { default as InputRange } from "./InputRange.svelte";
+export { default as InputSelect } from "./InputSelect.svelte";
+export { default as InputTel } from "./InputTel.svelte";
+export { default as InputText } from "./InputText.svelte";
+export { default as InputTextArea } from "./InputTextArea.svelte";
+export { default as InputTime } from "./InputTime.svelte";
+export { default as InputUrl } from "./InputUrl.svelte";
+export { default as InputWeek } from "./InputWeek.svelte";