@rokkit/core 1.0.2 → 1.0.3

package/LICENSE

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

package/dist/calendar.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Get the days in the month.
+ *
+ * @param {Date}    value
+ * @param {Array}   holidays
+ * @param {boolean} fixed
+ * @returns {import('./types').CalendarDay[]}
+ */
+export function getCalendarDays(value: Date, holidays?: any[], fixed?: boolean): import("./types").CalendarDay[];
+export const weekdays: string[];

package/dist/colors/index.d.ts

@@ -0,0 +1,47 @@
+import type { PresetMiniColors } from '@unocss/preset-mini/colors';
+import extraColors from './extra.json';
+export declare const shades: number[];
+export declare const defaultPalette: string[];
+export declare const syntaxColors: {
+    "one-dark": {
+        dark: {
+            "--tab-size": string;
+            "--code-fill": string;
+            "--code-normal": string;
+            "--code-string": string;
+            "--code-number": string;
+            "--code-atrule": string;
+            "--code-keyword": string;
+            "--code-comment": string;
+            "--code-property": string;
+            "--code-selector": string;
+            "--code-operator": string;
+            "--code-function": string;
+            "--code-gutter-marker": string;
+            "--code-gutter-z2": string;
+            "--code-cursor": string;
+            "--code-cursor-block": string;
+            "--code-linenumbers": string;
+        };
+        light: {
+            "--tab-size": string;
+            "--code-fill": string;
+            "--code-normal": string;
+            "--code-string": string;
+            "--code-number": string;
+            "--code-atrule": string;
+            "--code-keyword": string;
+            "--code-comment": string;
+            "--code-property": string;
+            "--code-selector": string;
+            "--code-operator": string;
+            "--code-function": string;
+            "--code-gutter-marker": string;
+            "--code-gutter-z2": string;
+            "--code-cursor": string;
+            "--code-cursor-block": string;
+            "--code-linenumbers": string;
+        };
+    };
+};
+export declare const defaultColors: PresetMiniColors & typeof extraColors;

package/dist/connector.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Constructs an array of line types for tree visualization
+ * @param {boolean} hasChildren - Whether the node has children
+ * @param {import('./types').LineType[]} parentTypes - Types from parent nodes
+ * @param {import('./types').LineType} position - Current position type
+ * @returns {import('./types').LineType[]} Array of line types
+ */
+export function getLineTypes(hasChildren?: boolean, parentTypes?: import("./types").LineType[], position?: import("./types").LineType): import("./types").LineType[];

package/dist/constants.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Generate a state icon mapping from a list of icon names
+ *
+ * @param {string[]} icons
+ * @returns {import('./types').StateIcons}
+ */
+export function stateIconsFromNames(icons: string[]): import("./types").StateIcons;
+export const DATA_IMAGE_REGEX: RegExp;
+export const ITEM_SNIPPET: "itemContent";
+export const GROUP_SNIPPET: "groupContent";
+/**
+ * @deprecated Use BASE_FIELDS from @rokkit/core instead.
+ * Retained for legacy ListController/FieldMapper/Proxy consumers (Toolbar, Table).
+ * Will be removed when those components migrate to Wrapper+Navigator.
+ * @type {import('./types).FieldMapping} Fields
+ */
+export const DEFAULT_FIELDS: any;
+export namespace BASE_FIELDS {
+    let id: string;
+    let value: string;
+    let label: string;
+    let icon: string;
+    let avatar: string;
+    let subtext: string;
+    let tooltip: string;
+    let badge: string;
+    let shortcut: string;
+    let children: string;
+    let type: string;
+    let snippet: string;
+    let href: string;
+    let hrefTarget: string;
+    let disabled: string;
+    let expanded: string;
+    let selected: string;
+}
+export const DEFAULT_ICONS: string[];
+export namespace DEFAULT_OPTIONS {
+    let id_1: string;
+    export { id_1 as id };
+    let label_1: string;
+    export { label_1 as label };
+    let value_1: string;
+    export { value_1 as value };
+    export let checked: string;
+}
+export namespace DEFAULT_KEYMAP {
+    let ArrowRight: string;
+    let ArrowLeft: string;
+    let ArrowDown: string;
+    let ArrowUp: string;
+    let Enter: string;
+    let Escape: string;
+}
+export namespace DEFAULT_THEME_MAPPING {
+    let surface: string;
+    let primary: string;
+    let secondary: string;
+    let accent: string;
+    let success: string;
+    let warning: string;
+    let danger: string;
+    let error: string;
+    let info: string;
+}
+export namespace TONE_MAP {
+    let z0: number;
+    let z1: number;
+    let z2: number;
+    let z3: number;
+    let z4: number;
+    let z5: number;
+    let z6: number;
+    let z7: number;
+    let z8: number;
+    let z9: number;
+    let z10: number;
+}
+export const DEFAULT_STATE_ICONS: any;
+export { defaultColors, syntaxColors, shades, defaultPalette } from "./colors/index";

package/dist/events.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Creates an emitter object from the given properties.
+ *
+ * - Filters attributes that start with 'on' and are functions,
+ * - Returns an object with keys that are the event names (without the 'on' prefix)
+ * - If a default event is not present in the props, it will be set to a no-op function.
+ *
+ * @param {Object}        props    - The properties object to filter.
+ * @param {Array<string>} defaults - An array of default events.
+ * @returns {import('./types.js').EventHandlers} The emitter object.
+ */
+export function createEmitter(props: Object, defaults?: Array<string>): import("./types.js").EventHandlers;

package/dist/field-mapper.d.ts

@@ -0,0 +1,60 @@
+export class FieldMapper {
+    constructor(fields?: any);
+    hasIcon: ((obj: unknown) => obj is {
+        [x: string]: unknown;
+    }) | undefined;
+    hasImage: ((obj: unknown) => obj is {
+        [x: string]: unknown;
+    }) | undefined;
+    hasValue: ((obj: unknown) => obj is {
+        [x: string]: unknown;
+    }) | undefined;
+    hasLabel: ((obj: unknown) => obj is {
+        [x: string]: unknown;
+    }) | undefined;
+    hasComponent: ((obj: unknown) => obj is {
+        [x: string]: unknown;
+    }) | undefined;
+    hasCurrency: ((obj: unknown) => obj is {
+        [x: string]: unknown;
+    }) | undefined;
+    withPrefix: ((x: any) => string) | undefined;
+    excludeFlags: (<U extends Partial<Record<any, any>>>(obj: any extends keyof U ? U : never) => any extends keyof U ? Omit<U, any> : never) | undefined;
+    getChildMapper(): null;
+    /**
+     * @private
+     */
+    private prop;
+    /**
+     * Gets a mapped attribute from the original item
+     *
+     * @param {string} fieldName - Name of the field to get
+     * @returns {any|null} - The attribute value or null if not found
+     */
+    get(fieldName: string, value: any, defaultValue?: null): any | null;
+    set fields(fields: any);
+    get fields(): any;
+    getIcon(value: any): string | null;
+    getValue(value: any): any;
+    getFormattedText(value: any, formatter: any): any;
+    hasChildren(item: any): item is never;
+    isNested(items: any): boolean;
+    getChildren(item: any): never[];
+    /**
+     * Finds children by an index path
+     *
+     * @param {Array<Object>} items
+     * @param {Array<number>} path
+     * @returns {Array<Object>}
+     */
+    getChildrenByPath(items: Array<Object>, path?: Array<number>): Array<Object>;
+    /**
+     * Finds an item by an index path
+     *
+     * @param {Array<Object>} items
+     * @param {Array<number>} path
+     * @returns {Object|null}
+     */
+    getItemByPath(items: Array<Object>, path?: Array<number>): Object | null;
+    #private;
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./types.js";
+export * from "./constants.js";
+export * from "./utils.js";
+export * from "./nested.js";
+export * from "./string.js";
+export * from "./theme.js";
+export { FieldMapper } from "./field-mapper.js";
+export { createEmitter } from "./events.js";
+export { getLineTypes } from "./connector.js";
+export { generateTicks } from "./ticks.js";
+export { getNestedFields } from "./mapping.js";
+export { getItemAtIndex, getIndexForItem } from "./mapped-items.js";
+export { weekdays, getCalendarDays } from "./calendar.js";

package/dist/key-event-map.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Class to manage key event mappings.
+ */
+export class KeyEventMap {
+    mapping: {};
+    /**
+     * Add a new key mapping.
+     * @param {string}               eventName - The event name.
+     * @param {Array<string>|RegExp} keys      - The keys to match.
+     */
+    add(eventName: string, keys: Array<string> | RegExp): void;
+    /**
+     * Get the event name for a given key.
+     * @param {string} key - The key to match.
+     * @returns {string|null} - The event name or null if no match is found.
+     */
+    getEventForKey(key: string): string | null;
+}

package/dist/mapped-items.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Get an item at a specific index
+ * @param {Array<any>} items
+ * @param {any} index
+ * @returns
+ */
+export function getItemAtIndex(items: Array<any>, index: any): any;
+/**
+ *  Get the index for an item in an array
+ * @param {Array<any} items
+ * @param {any} item
+ * @returns
+ */
+export function getIndexForItem(items: Array<any>, item: any): number;

package/dist/mapping.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Gets the attribute from the node
+ * @param {*}      node
+ * @param {string} attr
+ * @returns {*}
+ */
+export function getAttribute(node: any, attr: string): any;
+/**
+ * Fetches the fieldmapping for a child node
+ *
+ * @param {import('./types').FieldMapping} fields
+ * @returns {import('./types').FieldMapping}
+ */
+export function getNestedFields(fields: import("./types").FieldMapping): import("./types").FieldMapping;

package/dist/nested.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Flattens a nested list of items
+ *
+ * @param {Array}                         items
+ * @param {import('./types).FieldMapping} fields
+ * @param {number}                        level
+ * @returns {Array}
+ */
+export function flattenNestedList(items: any[], fields?: any, level?: number): any[];

package/dist/string.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Capitalizes the first letter of input string
+ *
+ * @param {String} str
+ * @returns {String}
+ */
+export function toInitCapCase(text: any): string;
+/**
+ * Convert a hyphen separated string to PascalCase
+ *
+ * @param {String} text
+ * @returns
+ */
+export function toPascalCase(text: string): string;
+/**
+ * Convert a PascalCase string to snake case with separator as hyphen
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+export function toHyphenCase(text: string): string;
+/**
+ * Simple comparison for two strings
+ *
+ * @param {String} a
+ * @param {String} b
+ * @returns
+ */
+export function compareStrings(a: string, b: string): 1 | 0 | -1;
+/**
+ * Sort by splitting hyphen separated strings while keeping strings with same number of parts together
+ *
+ * @param {String} a hyphen separates string
+ * @param {String} b hyphen separates string
+ * @param {string} separator - separator to split the string
+ * @returns {Number} -1, 0, 1 based on comparison
+ */
+export function sortByParts(a: string, b: string, separator?: string): number;
+/**
+ * Generates a unique id from current timestamp
+ *
+ * @returns {String} timestamp based unique id
+ */
+export function uniqueId(prefix?: string, separator?: string): string;
+/**
+ * Removes undefined and null values from the input object.
+ *
+ * @param {Object} obj
+ * @returns {Object}
+ */
+export function compact(obj: Object): Object;
+/**
+ * Converts an input number into it's hexadecimal representation, with optional left padded zeroes based on the `size`
+ *
+ * @param {number} value
+ * @param {number} size
+ * @returns
+ */
+export function toHexString(value: number, size?: number): string;

package/dist/theme.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Generate shades for a color using css varuable
+ *
+ * @param {string} name
+ * @param {string} modifier
+ * @returns
+ */
+export declare function shadesOf(name: any, modifier?: string): {
+    DEFAULT: any;
+};
+/**
+ * Constructs and returns the light and dark theme variants based on provided color mapping and color definitions.
+ *
+ * @param {Object} [mapping=DEFAULT_THEME_MAPPING] - 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 declare function themeRules(mapping?: {
+    surface: string;
+    primary: string;
+    secondary: string;
+    accent: string;
+    success: string;
+    warning: string;
+    danger: string;
+    error: string;
+    info: string;
+}, colors?: any): {};
+/**
+ * Generates UnoCSS shortcut definitions for semantic tones with bg, border, text.
+ * @param {string} name - Color name (e.g., 'primary')
+ * @returns {Array} Array of shortcut definitions
+ */
+export declare function semanticShortcuts(name: any): (string[] | (RegExp | (([, variant, end]: [any, any, any]) => string))[] | (RegExp | (([, end]: [any, any]) => string))[])[];
+/**
+ * Generates "on-color" text shortcuts for readable text on colored backgrounds.
+ *
+ * - `text-on-{name}` → high contrast text for use on z5+ backgrounds (always light text)
+ * - `text-on-{name}-muted` → slightly muted but still readable on z5+ backgrounds
+ *
+ * @param {string} name - Color name (e.g., 'primary', 'surface')
+ * @returns {Array} Array of shortcut definitions
+ */
+export declare function contrastShortcuts(name: any): (RegExp | (([, end]: [any, any]) => string))[][];
+/**
+ * Theme class for managing color palettes, mappings, and semantic shortcuts.
+ */
+export declare class Theme {
+    #private;
+    /**
+     *
+     * @param {import('./types.js').ColorTheme} param0
+     */
+    constructor({ colors, mapping }?: {
+        colors?: any;
+        mapping?: {
+            surface: string;
+            primary: string;
+            secondary: string;
+            accent: string;
+            success: string;
+            warning: string;
+            danger: string;
+            error: string;
+            info: string;
+        } | undefined;
+    });
+    get colors(): any;
+    set colors(colors: any);
+    get mapping(): {
+        surface: string;
+        primary: string;
+        secondary: string;
+        accent: string;
+        success: string;
+        warning: string;
+        danger: string;
+        error: string;
+        info: string;
+    };
+    set mapping(mapping: {
+        surface: string;
+        primary: string;
+        secondary: string;
+        accent: string;
+        success: string;
+        warning: string;
+        danger: string;
+        error: string;
+        info: string;
+    });
+    mapVariant(color: any, variant: any): {};
+    getColorRules(mapping?: null): {};
+    getPalette(mapping?: null): {};
+    getShortcuts(name: any): (string[] | (RegExp | (([, variant, end]: [any, any, any]) => string))[] | (RegExp | (([, end]: [any, any]) => string))[])[];
+    /**
+     * Generates CSS custom property declarations for the semantic z0–z10 tone scale.
+     *
+     * Returns a CSS string with two blocks:
+     * - `:root` — light-mode aliases (z0=50 … z10=950)
+     * - `[data-mode="dark"]` — dark-mode aliases (z0=950 … z10=50)
+     *
+     * These let consumers write `var(--color-primary-z5)` instead of hardcoding
+     * numeric shades, and the value automatically adapts to the active mode.
+     */
+    getZScaleCSS(): string;
+}

package/dist/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/types.d.ts

@@ -0,0 +1,300 @@
+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;
+};
+export type ColorPalette = {
+    /**
+     * 50 - The color for the 50 shade.
+     */
+    "": string;
+};
+export type ColorCollection = {
+    [x: string]: ColorPalette;
+};
+export type ColorMapping = {
+    /**
+     * - The primary color.
+     */
+    primary?: string | undefined;
+    /**
+     * - The secondary color.
+     */
+    secondary?: string | undefined;
+    /**
+     * - The tertiary color.
+     */
+    tertiary?: string | undefined;
+    /**
+     * - The surface color.
+     */
+    surface?: string | undefined;
+    /**
+     * - The info color.
+     */
+    info?: string | undefined;
+    /**
+     * - The success color.
+     */
+    success?: string | undefined;
+    /**
+     * - The warning color.
+     */
+    warning?: string | undefined;
+    /**
+     * - The error color.
+     */
+    error?: string | undefined;
+};
+export type ColorTheme = {
+    /**
+     * - The color mapping.
+     */
+    mapping?: ColorMapping | undefined;
+    /**
+     * - The color collection.
+     */
+    colors?: {
+        [x: string]: ColorPalette;
+    } | undefined;
+};

package/dist/utils.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Detects text direction based on HTML lang attribute
+ * @returns {'ltr' | 'rtl'}
+ */
+export function detectDirection(): "ltr" | "rtl";
+/**
+ * Checks if current document direction is RTL
+ * @returns {boolean}
+ */
+export function isRTL(): boolean;
+/**
+ * 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(prefix?: string): 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 resolveSnippet(snippets: any, proxy: any, fallback?: string): Function | null;
+/**
+ * convert hex string to `{r} {g} {b}`
+ * @param {string} hex
+ * @return {string}
+ */
+export function hex2rgb(hex: string): string;
+/**
+ * Convert a CSS color value to r,g,b for use in CSS variables.
+ * Hex values (#rrggbb) are converted to "r,g,b" for rgba() support.
+ * All other CSS color formats (oklch, hsl, named) are returned as-is.
+ * Non-string values are returned unchanged.
+ * Note: non-hex values will NOT work with UnoCSS opacity utilities like bg-primary/50.
+ *
+ * @param {unknown} value
+ * @returns {unknown}
+ */
+export function colorToRgb(value: unknown): unknown;
+/**
+ * A utility function that detects if a string is an image URL or image data (base64)
+ *
+ * @param {string} str - The string to check
+ * @returns {string|null} - Returns the original string if it's an image URL or image data, otherwise null
+ */
+export function getImage(str: string): string | null;

package/dist/vite/icon-collections.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Creates icon collection loaders for UnoCSS presetIcons from a simple config.
+ *
+ * This function transforms a map of collection names to JSON package paths
+ * into the format expected by UnoCSS's presetIcons.
+ *
+ * Supports three types of paths:
+ * - Package paths (e.g., '@rokkit/icons/ui.json') - resolved via require
+ * - Absolute paths (e.g., '/path/to/icons.json') - used directly
+ * - Relative paths (e.g., './static/icons.json') - resolved from process.cwd()
+ *
+ * @example
+ * // uno.config.js
+ * import { iconCollections } from '@rokkit/core/vite'
+ *
+ * export default defineConfig({
+ *   presets: [
+ *     presetIcons({
+ *       collections: iconCollections({
+ *         rokkit: '@rokkit/icons/ui.json',
+ *         logo: '@rokkit/icons/auth.json',
+ *         solar: '@iconify-json/solar/icons.json',
+ *         custom: './static/icons/custom.json'
+ *       })
+ *     })
+ *   ]
+ * })
+ *
+ * @param {Record<string, string>} config - Map of collection alias to JSON path
+ * @returns {Record<string, () => any>} Collections object for presetIcons
+ */
+export function iconCollections(config: Record<string, string>): Record<string, () => any>;

package/dist/vite/index.d.ts

@@ -0,0 +1 @@
+export { iconCollections } from "./icon-collections.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rokkit/core",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Contains core utility functions and classes that can be used in various components.",
   "repository": {
     "type": "git",
@@ -46,6 +46,6 @@
     "ramda": "^0.32.0"
   },
   "devDependencies": {
-    "@rokkit/icons": "1.0.2"
+    "@rokkit/icons": "1.0.3"
   }
 }