@cute-widgets/base 20.0.1

package/core/option/index.d.ts

@@ -0,0 +1,185 @@
+import * as i0 from '@angular/core';
+import { Signal, InjectionToken, AfterViewChecked, EventEmitter, ElementRef, QueryList } from '@angular/core';
+import { Subject } from 'rxjs';
+import { CuteFocusableControl } from '@cute-widgets/base/abstract';
+import { Highlightable } from '@angular/cdk/a11y';
+import { toTextBgCssClass } from '@cute-widgets/base/core/theming';
+import * as i1 from '@angular/common';
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Describes a parent component that manages a list of options.
+ * Contains properties that the options can inherit.
+ */
+interface CuteOptionParentComponent {
+    disableRipple?: boolean | Signal<boolean>;
+    multiple?: boolean;
+    inertGroups?: boolean;
+    hideSingleSelectionIndicator?: boolean;
+}
+/**
+ * Injection token used to provide the parent component to options.
+ */
+declare const CUTE_OPTION_PARENT_COMPONENT: InjectionToken<CuteOptionParentComponent>;
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Injection token that can be used to reference instances of `CuteOptgroup`. It serves as
+ * an alternative token to the actual `CuteOptgroup` class which could cause unnecessary
+ * retention of the class and its component metadata.
+ */
+declare const CUTE_OPTGROUP: InjectionToken<CuteOptgroup>;
+/**
+ * Component that is used to group instances of `mat-option`.
+ */
+declare class CuteOptgroup {
+    /** Label for the option group. */
+    label: string | undefined;
+    /** whether the option group is disabled. */
+    disabled: boolean;
+    /** Unique id for the underlying label. */
+    _labelId: string;
+    /** Whether the group is in inert a11y mode. */
+    _inert: boolean;
+    constructor(...args: unknown[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteOptgroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteOptgroup, "cute-optgroup", ["cuteOptgroup"], { "label": { "alias": "label"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*", "cute-option, ng-container"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/** Event object emitted by CuteOption when selected or deselected. */
+declare class CuteOptionSelectionChange<T = any> {
+    /** Reference to the option that emitted the event. */
+    source: CuteOption<T>;
+    /** Whether the change in the option's value was a result of a user action. */
+    isUserInput: boolean;
+    constructor(
+    /** Reference to the option that emitted the event. */
+    source: CuteOption<T>, 
+    /** Whether the change in the option's value was a result of a user action. */
+    isUserInput?: boolean);
+}
+/**
+ * Single option inside a `<cute-select>` element.
+ */
+declare class CuteOption<T = any> extends CuteFocusableControl implements Highlightable, AfterViewChecked {
+    private _parent;
+    readonly group: CuteOptgroup | null;
+    private _selected;
+    private _active;
+    private _mostRecentViewValue;
+    /** Whether the wrapping component is in multiple selection mode. */
+    get multiple(): boolean | null | undefined;
+    /** Whether the option is currently selected. */
+    get selected(): boolean;
+    /** Whether ripples for the option are disabled. */
+    get disableRipple(): boolean;
+    /** Whether to display checkmark for single-selection. */
+    get hideSingleSelectionIndicator(): boolean;
+    protected getDisabledState(): boolean;
+    protected generateId(): string;
+    /** The form value of the option. */
+    value: T | undefined;
+    /** Event emitted when the option is selected or deselected. */
+    readonly onSelectionChange: EventEmitter<CuteOptionSelectionChange<T>>;
+    /** Element containing the option's text. */
+    _text: ElementRef<HTMLElement> | undefined;
+    /** Emits when the state of the option changes and any parents have to be notified. */
+    readonly _stateChanges: Subject<void>;
+    constructor(...args: unknown[]);
+    /**
+     * Whether the option is currently active and ready to be selected.
+     * An active option displays styles, as if it is focused, but the
+     * focus is actually retained somewhere else. This comes in handy
+     * for components like autocomplete where focus must remain on the input.
+     */
+    get active(): boolean;
+    /**
+     * The displayed value of the option. It is necessary to show the selected option in the
+     * select's trigger.
+     */
+    get viewValue(): string;
+    /** Selects the option. */
+    select(emitEvent?: boolean): void;
+    /** Deselects the option. */
+    deselect(emitEvent?: boolean): void;
+    /**
+     * This method sets display styles on the option to make it appear
+     * active. This is used by the ActiveDescendantKeyManager so key
+     * events will display the proper options as active on arrow key events.
+     */
+    setActiveStyles(): void;
+    /**
+     * This method removes display styles on the option that made it appear
+     * active. This is used by the ActiveDescendantKeyManager so key
+     * events will display the proper options as active on arrow key events.
+     */
+    setInactiveStyles(): void;
+    /** Gets the label to be used when determining whether the option should be focused. */
+    getLabel(): string;
+    /** Ensures the option is selected when activated from the keyboard. */
+    protected _handleKeydown(event: KeyboardEvent): void;
+    /**
+     * Selects the option while indicating the selection came from the user. Used to
+     * determine if the select's view -> model callback should be invoked.
+     * Used by `CuteSelect` component.
+     */
+    _selectViaInteraction(): void;
+    /** Gets the host DOM element. */
+    _getHostElement(): HTMLElement;
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    /** Emits the selection change event. */
+    private _emitSelectionChangeEvent;
+    protected readonly toTextBgCssClass: typeof toTextBgCssClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteOption<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteOption<any>, "cute-option", ["cuteOption"], { "value": { "alias": "value"; "required": false; }; }, { "onSelectionChange": "onSelectionChange"; }, never, ["cute-icon, i, img, [role=img]", "*"], true, never>;
+}
+/**
+ * Counts the number of option group labels that precede the specified option.
+ * @param optionIndex Index of the option at which to start counting.
+ * @param options Flat list of all the options.
+ * @param optionGroups Flat list of all the option groups.
+ * @docs-private
+ */
+declare function _countGroupLabelsBeforeOption(optionIndex: number, options: QueryList<CuteOption>, optionGroups: QueryList<CuteOptgroup>): number;
+/**
+ * Determines the position to which to scroll a panel in order for an option to be into view.
+ * @param optionOffset Offset of the option from the top of the panel.
+ * @param optionHeight Height of the options.
+ * @param currentScrollPosition Current scroll position of the panel.
+ * @param panelHeight Height of the panel.
+ * @docs-private
+ */
+declare function _getOptionScrollPosition(optionOffset: number, optionHeight: number, currentScrollPosition: number, panelHeight: number): number;
+
+declare class CuteOptionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteOptionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteOptionModule, never, [typeof i1.CommonModule, typeof CuteOption, typeof CuteOptgroup], [typeof CuteOption, typeof CuteOptgroup]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteOptionModule>;
+}
+
+export { CUTE_OPTGROUP, CUTE_OPTION_PARENT_COMPONENT, CuteOptgroup, CuteOption, CuteOptionModule, CuteOptionSelectionChange, _countGroupLabelsBeforeOption, _getOptionScrollPosition };
+export type { CuteOptionParentComponent };

package/core/pipes/index.d.ts

@@ -0,0 +1,53 @@
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { DomSanitizer, SafeValue } from '@angular/platform-browser';
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/**
+ * Bypass security and trust the given value to be a safe resource.
+ * > WARNING: calling this method with untrusted user data exposes your application to XSS security risks!
+ * @example
+ * ```html
+ * <img [src]="item.source | safe:'url'" alt="Item image"/>
+ * ```
+ */
+declare class CuteSafePipe implements PipeTransform {
+    protected sanitizer: DomSanitizer;
+    transform(value: any, type?: 'html' | 'style' | 'script' | 'url' | 'resourceUrl'): SafeValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteSafePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CuteSafePipe, "safe", true>;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/**
+ * Gets a safe value from either a known safe value or a value with unknown safety.
+ *
+ * @example
+ * ```html
+ * <div [innerHTML]="item.htmlContent | sanitize:'html'"></div>
+ * ```
+ */
+declare class CuteSanitizePipe implements PipeTransform {
+    protected sanitizer: DomSanitizer;
+    transform(value: any, context?: 'html' | 'style' | 'script' | 'url' | 'resourceUrl' | 'none'): SafeValue | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteSanitizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CuteSanitizePipe, "sanitize", true>;
+}
+
+export { CuteSafePipe, CuteSanitizePipe };

package/core/ripple/index.d.ts

@@ -0,0 +1,66 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, ElementRef } from '@angular/core';
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+type RippleOptions = {
+    centered?: boolean;
+    color?: string | null;
+    duration?: string | number;
+};
+declare abstract class Ripple {
+    private _active;
+    private _disabled;
+    private readonly _target;
+    protected constructor(target: HTMLElement);
+    get disabled(): boolean;
+    set disabled(v: boolean);
+    isActive: i0.Signal<boolean>;
+    stop(): void;
+    launch(event: MouseEvent, options?: RippleOptions): void;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+declare class RippleManager {
+    private static readonly _ripples;
+    static getInstance(target: HTMLElement): Ripple;
+    static createRipple(target: HTMLElement): Ripple;
+    static removeRipple(target: HTMLElement): void;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+declare class CuteRipple/* extends ... */  implements OnDestroy {
+    private _elemRef;
+    private readonly _ripple;
+    rippleOptions: RippleOptions | undefined;
+    protected onMouseDown(event: MouseEvent): void;
+    constructor(_elemRef: ElementRef<HTMLElement>);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteRipple, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteRipple, "[cuteRipple]", ["cuteRipple"], { "rippleOptions": { "alias": "cuteRipple"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { CuteRipple, Ripple, RippleManager };
+export type { RippleOptions };

package/core/testing/index.d.ts

@@ -0,0 +1,154 @@
+import { DebugElement } from '@angular/core';
+import { ComponentFixture } from '@angular/core/testing';
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/**
+ * Spec helpers for working with the DOM
+ */
+/**
+ * Returns a selector for the `data-testid` attribute with the given attribute value.
+ *
+ * @param testId Test id set by `data-testid`
+ *
+ */
+declare function testIdSelector(testId: string): string;
+/**
+ * Finds a single element inside the Component by the given CSS selector.
+ * Throws an error if no element was found.
+ *
+ * @param fixture Component fixture
+ * @param selector CSS selector
+ *
+ */
+declare function queryByCss<T>(fixture: ComponentFixture<T>, selector: string): DebugElement;
+/**
+ * Finds an element inside the Component by the given `data-testid` attribute.
+ * Throws an error if no element was found.
+ *
+ * @param fixture Component fixture
+ * @param testId Test id set by `data-testid`
+ *
+ */
+declare function findEl<T>(fixture: ComponentFixture<T>, testId: string): DebugElement;
+/**
+ * Finds all elements with the given `data-testid` attribute.
+ *
+ * @param fixture Component fixture
+ * @param testId Test id set by `data-testid`
+ */
+declare function findEls<T>(fixture: ComponentFixture<T>, testId: string): DebugElement[];
+/**
+ * Gets the text content of an element with the given `data-testid` attribute.
+ *
+ * @param fixture Component fixture
+ * @param testId Test id set by `data-testid`
+ */
+declare function getText<T>(fixture: ComponentFixture<T>, testId: string): string;
+/**
+ * Expects that the element with the given `data-testid` attribute
+ * has the given text content.
+ *
+ * @param fixture Component fixture
+ * @param testId Test id set by `data-testid`
+ * @param text Expected text
+ */
+declare function expectText<T>(fixture: ComponentFixture<T>, testId: string, text: string): void;
+/**
+ * Expects that the element with the given `data-testid` attribute
+ * has the given text content.
+ *
+ * @param fixture Component fixture
+ * @param text Expected text
+ */
+declare function expectContainedText<T>(fixture: ComponentFixture<T>, text: string): void;
+/**
+ * Expects that a component has the given text content.
+ * Both the component text content and the expected text are trimmed for reliability.
+ *
+ * @param fixture Component fixture
+ * @param text Expected text
+ */
+declare function expectContent<T>(fixture: ComponentFixture<T>, text: string): void;
+/**
+ * Dispatches a fake event (synthetic event) at the given element.
+ *
+ * @param element Element that is the target of the event
+ * @param type Event name, e.g. `input`
+ * @param bubbles Whether the event bubbles up in the DOM tree
+ */
+declare function dispatchFakeEvent(element: EventTarget, type: string, bubbles?: boolean): void;
+/**
+ * Enters text into a form field (`input`, `textarea` or `select` element).
+ * Triggers appropriate events so Angular takes notice of the change.
+ * If you listen for the `change` event on `input` or `textarea`,
+ * you need to trigger it separately.
+ *
+ * @param element Form field
+ * @param value Form field value
+ */
+declare function setFieldElementValue(element: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement, value: string): void;
+/**
+ * Sets the value of a form field with the given `data-testid` attribute.
+ *
+ * @param fixture Component fixture
+ * @param testId Test id set by `data-testid`
+ * @param value Form field value
+ */
+declare function setFieldValue<T>(fixture: ComponentFixture<T>, testId: string, value: string): void;
+/**
+ * Checks or unchecks a checkbox or radio button.
+ * Triggers appropriate events so Angular takes notice of the change.
+ *
+ * @param fixture Component fixture
+ * @param testId Test id set by `data-testid`
+ * @param checked Whether the checkbox or radio should be checked
+ */
+declare function checkField<T>(fixture: ComponentFixture<T>, testId: string, checked: boolean): void;
+/**
+ * Makes a fake click event that provides the most important properties.
+ * The event can be passed to DebugElement#triggerEventHandler.
+ *
+ * @param target Element that is the target of the click event
+ * @param button (Optional) Button number. Default is Left-Button.
+ */
+declare function makeClickEvent(target: EventTarget, button?: number): Partial<MouseEvent>;
+/** Button events to pass to `DebugElement.triggerEventHandler` */
+declare const ButtonClickEvents: {
+    left: {
+        button: number;
+    };
+    right: {
+        button: number;
+    };
+};
+/**
+ * Emulates a mouse click event on the target element.
+ *
+ * @param elem Element target
+ * @param eventObj (Optional) MouseEvent object. Default is Left-Button click.
+ */
+declare function click(elem: DebugElement | HTMLElement, eventObj?: Partial<MouseEvent>): void;
+/**
+ * Finds a nested Component by its selector, e.g. `app-example`.
+ * Throws an error if no element was found.
+ * Use this only for shallow component testing.
+ * When finding other elements, use `findEl` / `findEls` and `data-testid` attributes.
+ *
+ * @param fixture Fixture of the parent Component
+ * @param selector Element selector, e.g. `app-example`
+ */
+declare function findComponent<T>(fixture: ComponentFixture<T>, selector: string): DebugElement;
+/**
+ * Finds all nested Components by its selector, e.g. `app-example`.
+ */
+declare function findComponents<T>(fixture: ComponentFixture<T>, selector: string): DebugElement[];
+
+export { ButtonClickEvents, checkField, click, dispatchFakeEvent, expectContainedText, expectContent, expectText, findComponent, findComponents, findEl, findEls, getText, makeClickEvent, queryByCss, setFieldElementValue, setFieldValue, testIdSelector };

package/core/theming/index.d.ts

@@ -0,0 +1,118 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnDestroy } from '@angular/core';
+import * as rxjs from 'rxjs';
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+/**
+ * `CuteWidgets` supports standard Bootstrap 5 theme colors - `ThemeColor` type. But to account
+ * miscellaneous use cases of usage this colors in components CuteWidgets add extended definition of
+ * latter - `RichThemeColor`. Rich color is the standard color name plus "-emphasis" or "-contrast" suffix at the end.
+ * Depending on the context of applying color, the result CSS-class can be `.text-*`, `.text-bg-*` or ended with
+ * `-emphasis` or `-subtle` suffixes.
+ */
+
+/** Bootstrap theme colors */
+declare const Palette: readonly ["primary", "secondary", "success", "danger", "warning", "info", "light", "dark", "link", "tertiary"];
+/** Bootstrap’s base color palette. */
+type ThemeColor = typeof Palette[number];
+/** Rich color palette is based on the standard Bootstrap palette but has additional shades. */
+type RichThemeColor = ThemeColor | `${ThemeColor}-emphasis` | `${ThemeColor}-contrast`;
+/** Alias for `ThemeColor` type. */
+type ThemePalette = ThemeColor;
+/** Alias for `ThemeColor` type. */
+type RichThemePalette = RichThemeColor;
+/**
+ * Whether a string is a valid theme color name
+ * @param str Text case-sensitive value
+ * @returns _true_ if `str` is a valid color name, otherwise _false_
+ */
+declare function isThemeColor(str: string | undefined | null): str is ThemeColor;
+/**
+ * Whether a string is a valid rich or base theme color name.
+ * @param str Case-sensitive text value of the color name.
+ * @returns _true_ if `str` is a valid rich color name, otherwise _false_.
+ */
+declare function isRichThemeColor(str: string | undefined | null): str is RichThemeColor;
+/**
+ * Transforms a string to `ThemeColor` type.
+ * @param color Color value to transform
+ * @returns _ThemeColor_'s value or _undefined_, if the `color` has an invalid value.
+ */
+declare function toThemeColor(color: string | undefined | null): ThemeColor | undefined;
+/**
+ * To `_RichThemeColor_` transformer function.
+ * @param color Color value to transform into rich color type.
+ * @returns _RichThemeColor_ value or _undefined_ if `color` is invalid.
+ */
+declare function toRichThemeColor(color: string | undefined | null): RichThemeColor | undefined;
+/**
+ * Returns a valid Bootstrap's `.text-*` CSS class.
+ * @param color Color palette to transform into CSS-class.
+ */
+declare function toTextCssClass(color: string | undefined | null): string;
+/**
+ * Returns a valid Bootstrap's `.bg-*` or `.text-bg-*` CSS class name.
+ * @param color Value to transform into CSS-class.
+ */
+declare function toBgCssClass(color: string | undefined | null): string;
+/**
+ * Set a background color with contrasting foreground color.
+ * @param color Color palette to transform into CSS-class.
+ * @returns A valid Bootstrap's `.text-bg-*` CSS-class
+ */
+declare function toTextBgCssClass(color: string | undefined | null): string;
+/**
+ * Returns a valid Bootstrap's `.text-*` or `.text-bg-*` CSS class.
+ * @param color Color value to transform into CSS-class.
+ */
+declare function toColorCssClass(color: string | undefined | null): string;
+declare const CUTE_THEME_COLOR: InjectionToken<CuteThemeColor>;
+declare class CuteThemeColor {
+    color: RichThemeColor | undefined;
+    colorClass(): string;
+    bgClass(): string;
+    textBgClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteThemeColor, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteThemeColor, "[cuteThemeColor]", ["cuteThemeColor"], { "color": { "alias": "cuteThemeColor"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type CuteTheme = "light" | "dark" | "auto";
+declare class CuteThemeService implements OnDestroy {
+    private _document;
+    private _mediaQueryList;
+    private _mediaChange;
+    /** Observable that can be used to receive `MediaMatcher`'s _change_ event. */
+    readonly change: rxjs.Observable<MediaQueryListEvent>;
+    constructor();
+    private getStoredTheme;
+    private setStoredTheme;
+    /** Returns the user's preferred color mode. */
+    getPreferredTheme(): CuteTheme;
+    /** Returns the browser's color theme. */
+    getCurrentTheme(): CuteTheme;
+    /** Whether is the dark theme currently selected. */
+    isDarkTheme(): boolean;
+    /** Whether is the light theme currently selected. */
+    isLightTheme(): boolean;
+    /** Returns the Bootstrap's color theme. */
+    getTheme(): Omit<CuteTheme, "auto">;
+    /**
+     * Changes the default color mode (theme) of all pages in the website with the opportunity of auto-detection.
+     * @param theme Desired color theme.
+     * @param emitEvent Emulate event emitting. Default is _true_.
+     */
+    setTheme(theme: CuteTheme, emitEvent?: boolean): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuteThemeService>;
+}
+
+export { CUTE_THEME_COLOR, CuteThemeColor, CuteThemeService, isRichThemeColor, isThemeColor, toBgCssClass, toColorCssClass, toRichThemeColor, toTextBgCssClass, toTextCssClass, toThemeColor };
+export type { CuteTheme, RichThemeColor, RichThemePalette, ThemeColor, ThemePalette };

package/core/types/index.d.ts

@@ -0,0 +1,53 @@
+/** A permissive type for a class constructor */
+type Constructor<T = {}> = new (...args: any[]) => T;
+/** A permissive type for abstract class constructors  */
+type AbstractConstructor<T = {}> = abstract new (...args: any[]) => T;
+
+/** Alignment of flex items on the main axis of the flexbox container */
+type ContentAlignment = "start" | "end" | "center" | "between" | "around" | "evenly";
+
+type LayoutBreakpoint = "xs" | "sm" | "md" | "lg" | "xl" | "xxl";
+
+type LayoutDirection = "column" | "row";
+
+type LayoutOrientation = "horizontal" | "vertical";
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+type MouseGeneralCursor = "auto" | "default" | "none";
+type MouseLinkAndStatusCursor = "context-menu" | "help" | "pointer" | "progress" | "wait";
+type MouseSelectionCursor = "cell" | "crosshair" | "text" | "vertical-text";
+type MouseDragAndDropCursor = "alias" | "copy" | "move" | "no-drop" | "not-allowed" | "grab" | "grabbing";
+type MouseResizeAndScrollCursor = "all-scroll" | "col-resize" | "row-resize" | "n-resize" | "e-resize" | "s-resize" | "w-resize" | "ne-resize" | "nw-resize" | "se-resize" | "sw-resize" | "ew-resize" | "ns-resize" | "nesw-resize" | "nwse-resize";
+type MouseZoomingCursor = "zoom-in" | "zoom-out";
+type MouseCursor = MouseGeneralCursor | MouseLinkAndStatusCursor | MouseSelectionCursor | MouseDragAndDropCursor | MouseResizeAndScrollCursor | MouseZoomingCursor;
+
+type MoveDirection = "up" | "down" | "left" | "right";
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+type RelativeSize3 = "middle" | "large" | "small";
+type RelativeSize5 = RelativeSize3 | ("larger" | "smaller");
+type RelativeSize7 = RelativeSize5 | ("largest" | "smallest");
+type RelativeSize = RelativeSize3;
+
+type HorizontalEdge = 'left' | 'right' | 'start' | 'end';
+
+type VerticalEdge = 'top' | 'bottom';
+
+/** Edge of the viewport  */
+type ViewportEdge = VerticalEdge | HorizontalEdge;
+
+export type { AbstractConstructor, Constructor, ContentAlignment, HorizontalEdge, LayoutBreakpoint, LayoutDirection, LayoutOrientation, MouseCursor, MouseDragAndDropCursor, MouseGeneralCursor, MouseLinkAndStatusCursor, MouseResizeAndScrollCursor, MouseSelectionCursor, MouseZoomingCursor, MoveDirection, RelativeSize, RelativeSize3, RelativeSize5, RelativeSize7, VerticalEdge, ViewportEdge };