@cute-widgets/base 20.0.1

package/sort/index.d.ts

@@ -0,0 +1,334 @@
+import { FocusMonitor, AriaDescriber } from '@angular/cdk/a11y';
+import * as i0 from '@angular/core';
+import { OnChanges, OnDestroy, OnInit, EventEmitter, SimpleChanges, InjectionToken, Optional, AfterViewInit, ChangeDetectorRef, ElementRef } from '@angular/core';
+import { Subject, Observable } from 'rxjs';
+import { AnimationTriggerMetadata } from '@angular/animations';
+import * as i1 from '@angular/common';
+
+type SortDirection = 'asc' | 'desc' | '';
+
+/**
+ * @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).
+ */
+
+/** Position of the arrow that displays when sorted. */
+type SortHeaderArrowPosition = 'before' | 'after';
+/** Interface for a directive that holds sorting state consumed by `MatSortHeader`. */
+interface CuteSortable {
+    /** The id of the column being sorted. */
+    id: string;
+    /** Starting a sort direction. */
+    start: SortDirection;
+    /** Whether to disable clearing the sorting state. */
+    disableClear: boolean;
+}
+/** The current sort state. */
+interface Sort {
+    /** The id of the column being sorted. */
+    active: string;
+    /** The sort direction. */
+    direction: SortDirection;
+}
+/** Default options for `cute-sort`.  */
+interface CuteSortDefaultOptions {
+    /** Whether to disable clearing the sorting state. */
+    disableClear?: boolean;
+    /** Position of the arrow that displays when sorted. */
+    arrowPosition?: SortHeaderArrowPosition;
+}
+/** Injection token to be used to override the default options for `mat-sort`. */
+declare const CUTE_SORT_DEFAULT_OPTIONS: InjectionToken<CuteSortDefaultOptions>;
+/** Container for MatSortables to manage the sort state and provide default sort parameters. */
+declare class CuteSort implements OnChanges, OnDestroy, OnInit {
+    private _defaultOptions?;
+    private _initializedStream;
+    /** Collection of all registered sortables that this directive manages. */
+    sortables: Map<string, CuteSortable>;
+    /** Used to notify any child components listening to state changes. */
+    readonly _stateChanges: Subject<void>;
+    /** The id of the most recently sorted CuteSortable. */
+    active: string | undefined;
+    /**
+     * The direction to set when a CuteSortable is initially sorted.
+     * May be overridden by the CuteSortable's sort start.
+     */
+    start: SortDirection;
+    /** The sort direction of the currently active CuteSortable. */
+    get direction(): SortDirection;
+    set direction(direction: SortDirection);
+    private _direction;
+    /**
+     * Whether to disable the user from clearing the sort by finishing the sort direction cycle.
+     * May be overridden by the CuteSortable's disable clear input.
+     */
+    protected disableClear: boolean;
+    /** Whether the sortable is disabled. */
+    disabled: boolean;
+    /** Event emitted when the user changes either the active sort or sort direction. */
+    readonly sortChange: EventEmitter<Sort>;
+    /** Emits when the paginator is initialized. */
+    initialized$: Observable<void>;
+    constructor(_defaultOptions?: CuteSortDefaultOptions | undefined);
+    /**
+     * Register function to be used by the contained CuteSortables. Adds the CuteSortable to the
+     * collection of CuteSortables.
+     */
+    register(sortable: CuteSortable): void;
+    /**
+     * Unregister function to be used by the contained CuteSortables. Removes the CuteSortable from the
+     * collection of contained CuteSortables.
+     */
+    deregister(sortable: CuteSortable): void;
+    /** Sets the active sort id and determines the new sort direction. */
+    sort(sortable: CuteSortable): void;
+    /** Returns the next sort direction of the active sortable, checking for potential overrides. */
+    getNextSortDirection(sortable: CuteSortable): SortDirection;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteSort, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteSort, "[cuteSort]", ["cuteSort"], { "active": { "alias": "cuteSortActive"; "required": false; }; "start": { "alias": "cuteSortStart"; "required": false; }; "direction": { "alias": "cuteSortDirection"; "required": false; }; "disableClear": { "alias": "cuteSortDisableClear"; "required": false; }; "disabled": { "alias": "cuteSortDisabled"; "required": false; }; }, { "sortChange": "cuteSortChange"; }, never, never, true, never>;
+    static ngAcceptInputType_disableClear: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/**
+ * @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).
+ */
+
+/**
+ * To modify the labels and text displayed, create a new instance of CuteSortHeaderIntl and
+ * include it in a custom provider.
+ */
+declare class CuteSortHeaderIntl {
+    /**
+     * Stream that emits whenever the labels here are changed. Use this to notify
+     * components if the labels have changed after initialization.
+     */
+    readonly changes: Subject<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteSortHeaderIntl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuteSortHeaderIntl>;
+}
+/** @docs-private */
+declare function CUTE_SORT_HEADER_INTL_PROVIDER_FACTORY(parentIntl: CuteSortHeaderIntl): CuteSortHeaderIntl;
+/** @docs-private */
+declare const CUTE_SORT_HEADER_INTL_PROVIDER: {
+    provide: typeof CuteSortHeaderIntl;
+    deps: Optional[][];
+    useFactory: typeof CUTE_SORT_HEADER_INTL_PROVIDER_FACTORY;
+};
+
+/**
+ * @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).
+ */
+
+/**
+ * Valid positions for the arrow to be in for its opacity and translation. If the state is a
+ * sort direction, the position of the arrow will be above/below and opacity 0. If the state is
+ * _hint_, the arrow will be in the center with a slight opacity. _Active_ state means the arrow will
+ * be fully opaque in the center.
+ *
+ * @docs-private
+ * @deprecated No longer being used, to be removed.
+ * @breaking-change 21.0.0
+ */
+type ArrowViewState = SortDirection | 'hint' | 'active';
+/**
+ * States describing the arrow's animated position (animating _fromState_ to _toState_).
+ * If the _fromState_ is not defined, there will be no animated transition to the _toState_.
+ * @docs-private
+ * @deprecated No longer being used, to be removed.
+ * @breaking-change 21.0.0
+ */
+interface ArrowViewStateTransition {
+    fromState?: ArrowViewState;
+    toState?: ArrowViewState;
+}
+/** Column definition associated with a `CuteSortHeader`. */
+interface CuteSortHeaderColumnDef {
+    name: string;
+}
+/**
+ * Applies sorting behavior (click to change sort) and styles to an element, including an
+ * arrow to display the current sort direction.
+ *
+ * Must be provided with an id and contained within a parent `CuteSort` directive.
+ *
+ * If used on header cells in a CdkTable, it will automatically default its id from its containing
+ * column definition.
+ */
+declare class CuteSortHeader implements CuteSortable, OnDestroy, OnInit, AfterViewInit {
+    /**
+     * @deprecated `_intl` parameter isn't being used anymore, and it'll be removed.
+     * @breaking-change 13.0.0
+     */
+    _intl: CuteSortHeaderIntl;
+    private _changeDetectorRef;
+    _sort: CuteSort;
+    _columnDef: CuteSortHeaderColumnDef;
+    private _focusMonitor;
+    private _elementRef;
+    /** @breaking-change 14.0.0 _ariaDescriber will be required. */
+    private _ariaDescriber?;
+    private _rerenderSubscription;
+    /**
+     * The element with role="button" inside this component's view. We need this to apply
+     * a description with AriaDescriber.
+     */
+    private _sortButton;
+    /**
+     * Flag set to true when the indicator should be displayed while the sort is not active. Used to
+     * provide an affordance that the header is sortable by showing on focus and hover.
+     */
+    _showIndicatorHint: boolean;
+    /**
+     * The view transition state of the arrow (translation/ opacity) - indicates its `from` and `to`
+     * position through the animation. If animations are currently disabled, the `fromState` is removed
+     * so that there is no animation displayed.
+     */
+    _viewState: ArrowViewStateTransition;
+    /** The direction the arrow should be facing, according to the current state. */
+    _arrowDirection: SortDirection;
+    /**
+     * Whether the view state animation should show the transition between the `from` and `to` states.
+     */
+    _disableViewStateAnimation: boolean;
+    /**
+     * ID of this sort header. If used within the context of a CdkColumnDef, this will default to
+     * the column's name.
+     */
+    id: string;
+    /** Sets the position of the arrow that displays when sorted. */
+    arrowPosition: SortHeaderArrowPosition;
+    /** Overrides the sort start value of the containing CuteSort for this CuteSortable. */
+    start: SortDirection;
+    /** whether the sort header is disabled. */
+    disabled: boolean;
+    /**
+     * Description applied to MatSortHeader's button element with aria-describedby. This text should
+     * describe the action that will occur when the user clicks the sort header.
+     */
+    get sortActionDescription(): string;
+    set sortActionDescription(value: string);
+    private _sortActionDescription;
+    /** Overrides the disable clear value of the containing CuteSort for this CuteSortable. */
+    disableClear: boolean;
+    constructor(
+    /**
+     * @deprecated `_intl` parameter isn't being used anymore, and it'll be removed.
+     * @breaking-change 13.0.0
+     */
+    _intl: CuteSortHeaderIntl, _changeDetectorRef: ChangeDetectorRef, _sort: CuteSort, _columnDef: CuteSortHeaderColumnDef, _focusMonitor: FocusMonitor, _elementRef: ElementRef<HTMLElement>, 
+    /** @breaking-change 14.0.0 _ariaDescriber will be required. */
+    _ariaDescriber?: (AriaDescriber | null) | undefined, defaultOptions?: CuteSortDefaultOptions);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Sets the "hint" state such that the arrow will be semi-transparently displayed as a hint to the
+     * user showing what the active sort will become. If set to false, the arrow will fade away.
+     */
+    _setIndicatorHintVisible(visible: boolean): void;
+    /**
+     * Sets the animation transition view state for the arrow's position and opacity. If the
+     * `disableViewStateAnimation` flag is set to true, the `fromState` will be ignored so that
+     * no animation appears.
+     */
+    _setAnimationTransitionState(viewState: ArrowViewStateTransition): void;
+    /** Triggers the sort on this sort header and removes the indicator hint. */
+    _toggleOnInteraction(): void;
+    _handleClick(): void;
+    _handleKeydown(event: KeyboardEvent): void;
+    /** Whether this MatSortHeader is currently sorted in either ascending or descending order. */
+    _isSorted(): boolean;
+    /** Returns the animation state for the arrow direction (indicator and pointers). */
+    _getArrowDirectionState(): string;
+    /** Returns the arrow position state (opacity, translation). */
+    _getArrowViewState(): string;
+    /**
+     * Updates the direction the arrow should be pointing. If it is not sorted, the arrow should be
+     * facing the start direction. Otherwise, if it is sorted, the arrow should point in the currently
+     * active sorted direction. The reason this is updated through a function is because the direction
+     * should only be changed at specific times - when deactivated but the hint is displayed and when
+     * the sort is active and the direction changes. Otherwise, the arrow's direction should linger
+     * in cases such as the sort becoming deactivated but we want to animate the arrow away while
+     * preserving its direction, even though the next sort direction is actually different and should
+     * only be changed once the arrow displays again (hint or activation).
+     */
+    _updateArrowDirection(): void;
+    _isDisabled(): boolean;
+    /**
+     * Gets the aria-sort attribute that should be applied to this sort header. If this header
+     * is not sorted, returns null so that the attribute is removed from the host element. Aria spec
+     * says that the aria-sort property should only be present on one header at a time, so removing
+     * ensures this is true.
+     */
+    _getAriaSortAttribute(): "none" | "ascending" | "descending";
+    /** Whether the arrow inside the sort header should be rendered. */
+    _renderArrow(): boolean;
+    private _updateSortActionDescription;
+    /** Handles changes in the sorting state. */
+    private _handleStateChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteSortHeader, [null, null, { optional: true; }, { optional: true; }, null, null, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteSortHeader, "[cute-sort-header]", ["cuteSortHeader"], { "id": { "alias": "cute-sort-header"; "required": false; }; "arrowPosition": { "alias": "arrowPosition"; "required": false; }; "start": { "alias": "start"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "sortActionDescription": { "alias": "sortActionDescription"; "required": false; }; "disableClear": { "alias": "disableClear"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_disableClear: unknown;
+}
+
+/**
+ * @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).
+ */
+
+/**
+ * Animations used by CuteSort.
+ * @docs-private
+ */
+declare const cuteSortAnimations: {
+    readonly indicator: AnimationTriggerMetadata;
+    readonly leftPointer: AnimationTriggerMetadata;
+    readonly rightPointer: AnimationTriggerMetadata;
+    readonly arrowOpacity: AnimationTriggerMetadata;
+    readonly arrowPosition: AnimationTriggerMetadata;
+    readonly allowChildren: AnimationTriggerMetadata;
+};
+
+declare class CuteSortModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteSortModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteSortModule, never, [typeof i1.CommonModule, typeof CuteSort, typeof CuteSortHeader], [typeof CuteSort, typeof CuteSortHeader]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteSortModule>;
+}
+
+export { CUTE_SORT_DEFAULT_OPTIONS, CUTE_SORT_HEADER_INTL_PROVIDER, CUTE_SORT_HEADER_INTL_PROVIDER_FACTORY, CuteSort, CuteSortHeader, CuteSortHeaderIntl, CuteSortModule, cuteSortAnimations };
+export type { ArrowViewState, ArrowViewStateTransition, CuteSortDefaultOptions, CuteSortable, Sort, SortDirection, SortHeaderArrowPosition };

package/spinner/index.d.ts

@@ -0,0 +1,70 @@
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { CuteBaseControl } from '@cute-widgets/base/abstract';
+import { RelativeSize3 } from '@cute-widgets/base/core';
+import { RichThemeColor } 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
+ */
+
+/** Possible mode for a progress spinner. */
+type ProgressSpinnerMode = 'determinate' | 'indeterminate';
+/** Default `cute-progress-spinner` options that can be overridden. */
+interface CuteProgressSpinnerDefaultOptions {
+    /**
+     * Default theme color of the progress spinner. */
+    color?: RichThemeColor;
+    /** Diameter of the spinner. */
+    diameter?: number;
+    /** Relative size of the spinner. */
+    magnitude?: RelativeSize3;
+    /** Width of the spinner's stroke. */
+    strokeWidth?: number;
+}
+/** Injection token to be used to override the default options for `cute-progress-spinner`. */
+declare const CUTE_PROGRESS_SPINNER_DEFAULT_OPTIONS: InjectionToken<CuteProgressSpinnerDefaultOptions>;
+/**
+ * Spinner can be used to indicate the loading state or the execution of some time-consuming process in the project.
+ */
+declare class CuteProgressSpinner extends CuteBaseControl {
+    /** Mode of the progress spinner. Default is `indeterminate`. */
+    mode: ProgressSpinnerMode;
+    /** Value of the progress bar. Defaults to zero. Mirrored to aria-valuenow. */
+    get value(): number;
+    set value(v: number);
+    private _value;
+    /** Switch to grow-type spinner. */
+    growing: boolean;
+    /** Relative size of the spinner */
+    magnitude: RelativeSize3 | undefined;
+    /** Stroke width of the bordered progress spinner. */
+    get strokeWidth(): string | undefined;
+    set strokeWidth(value: string | number | undefined);
+    private _strokeWidth;
+    /** Diameter of the progress spinner. */
+    get diameter(): string | undefined;
+    set diameter(value: string | number | undefined);
+    private _diameter;
+    constructor(...args: unknown[]);
+    protected generateId(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteProgressSpinner, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteProgressSpinner, "cute-progress-spinner, cute-spinner", ["cuteProgressSpinner"], { "mode": { "alias": "mode"; "required": false; }; "value": { "alias": "value"; "required": false; }; "growing": { "alias": "growing"; "required": false; }; "magnitude": { "alias": "magnitude"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "diameter": { "alias": "diameter"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_value: unknown;
+    static ngAcceptInputType_growing: unknown;
+}
+
+declare class CuteProgressSpinnerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteProgressSpinnerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteProgressSpinnerModule, never, [typeof i1.CommonModule, typeof CuteProgressSpinner], [typeof CuteProgressSpinner]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteProgressSpinnerModule>;
+}
+
+export { CUTE_PROGRESS_SPINNER_DEFAULT_OPTIONS, CuteProgressSpinner, CuteProgressSpinnerModule };
+export type { CuteProgressSpinnerDefaultOptions, ProgressSpinnerMode };