@cute-widgets/base 20.0.1

package/input/index.d.ts

@@ -0,0 +1,256 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import { Platform } from '@angular/cdk/platform';
+import * as i0 from '@angular/core';
+import { InjectionToken, OnChanges, OnDestroy, AfterViewInit, DoCheck, ElementRef, SimpleChanges, WritableSignal } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { ErrorStateMatcher } from '@cute-widgets/base/core/error';
+import * as i3 from '@cute-widgets/base/form-field';
+import { CuteFormFieldControl } from '@cute-widgets/base/form-field';
+import { RelativeSize3 } from '@cute-widgets/base/core';
+import { CuteInputControl } from '@cute-widgets/base/abstract';
+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).
+ */
+
+/** Object that can be used to configure the default options for the input. */
+interface CuteInputConfig {
+    /** Whether disabled inputs should be interactive. */
+    disabledInteractive?: boolean;
+}
+/** Injection token that can be used to provide the default options for the input. */
+declare const CUTE_INPUT_CONFIG: InjectionToken<CuteInputConfig>;
+/**
+ * We must check whether the agent is Android because composition events
+ * behave differently between iOS and Android.
+ */
+declare class CuteInput extends CuteInputControl implements CuteFormFieldControl<any>, OnChanges, OnDestroy, AfterViewInit, DoCheck {
+    protected _elementRef: ElementRef<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>;
+    protected _platform: Platform;
+    readonly ngControl: NgControl;
+    private _autofillMonitor;
+    private _ngZone;
+    private _formField?;
+    private _valueFormatter?;
+    private _inputValuePredecessor;
+    protected _previousNativeValue: any;
+    private _inputValueAccessor;
+    private readonly _signalBasedValueAccessor?;
+    private _previousPlaceholder;
+    private _errorStateTracker;
+    private _config;
+    private _cleanupIosKeyup;
+    private _cleanupWebkitWheel;
+    private _destroyed$;
+    private readonly _compositionMode;
+    /** Whether the user is creating a composition string (IME events). */
+    private _composing;
+    /** `aria-describedby` IDs assigned by the form field. */
+    private _formFieldDescribedBy;
+    /** Whether the component is being rendered on the server. */
+    protected readonly _isServer: boolean;
+    /** Whether the component is a native HTML select. */
+    protected readonly _isNativeSelect: boolean;
+    /** Whether the component is a textarea. */
+    protected readonly _isTextarea: boolean;
+    /** Whether the input is inside a form field. */
+    protected readonly _isInFormField: boolean;
+    /** Implemented as part of CuteFormFieldControl. */
+    focused: boolean;
+    /** Implemented as part of CuteFormFieldControl. */
+    controlType: string;
+    /** Implemented as part of CuteFormFieldControl. */
+    get controlElementRef(): ElementRef;
+    /** Implemented as part of CuteFormFieldControl. */
+    autofilled: boolean;
+    protected generateId(): string;
+    protected get classList(): string;
+    /** Implemented as part of CuteFormFieldControl. */
+    setDisabledState(value: boolean | BooleanInput): boolean;
+    /** Implemented as part of CuteFormFieldControl. */
+    placeholder: string | undefined;
+    /** Implemented as part of CuteFormFieldControl. */
+    get required(): boolean;
+    set required(value: BooleanInput);
+    /** Input element's relative size */
+    magnitude: RelativeSize3 | undefined;
+    /** Input type of the element. */
+    get type(): string;
+    set type(value: string);
+    protected _type: string;
+    /** An object used to control when error messages are shown. */
+    get errorStateMatcher(): ErrorStateMatcher;
+    set errorStateMatcher(value: ErrorStateMatcher);
+    /** Implemented as part of CuteFormFieldControl. */
+    userAriaDescribedBy: string | undefined;
+    /** Implemented as part of CuteFormFieldControl. */
+    get value(): string;
+    set value(value: any);
+    /** Whether the element is readonly. */
+    get readonly(): boolean;
+    set readonly(value: BooleanInput);
+    private _readonly;
+    /** Whether the input should remain interactive when it is disabled. */
+    disabledInteractive: boolean;
+    /** Whether the input control is styled as a plain text. Use it with `readonly` property. */
+    get plainText(): boolean;
+    set plainText(value: boolean);
+    private _plainText;
+    /** Whether the input is in an error state. */
+    get errorState(): boolean;
+    set errorState(value: boolean);
+    /** Returns bootstrap's size suffix for CSS classes */
+    get cssClassSizeSuffix(): string;
+    protected _neverEmptyInputTypes: string[];
+    constructor(...args: unknown[]);
+    registerOnChange(fn: (value: any) => void): void;
+    writeValue(newValue: any): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    ngDoCheck(): void;
+    /** Refreshes the error state of the input. */
+    updateErrorState(): void;
+    /** Callback for the cases where the focused state of the input changes. */
+    protected _focusChanged(isFocused: boolean): void;
+    protected _onInput(event: InputEvent): void;
+    /** Does some manual dirty checking on the native input `value` property. */
+    protected _dirtyCheckNativeValue(): void;
+    /** Does some manual dirty checking on the native input `placeholder` attribute. */
+    private _dirtyCheckPlaceholder;
+    /** Gets the current placeholder of the form field. */
+    protected _getPlaceholder(): string | null;
+    /** Make sure the input is a supported type. */
+    protected _validateType(): void;
+    /** Checks whether the input type is one of the types that are never empty. */
+    protected _isNeverEmpty(): boolean;
+    /** Checks whether the input is invalid based on the native validation. */
+    protected _isBadInput(): boolean;
+    /**
+     * Implemented as part of CuteFormFieldControl.
+     */
+    get empty(): boolean;
+    /**
+     * Implemented as part of CuteFormFieldControl.
+     */
+    get shouldLabelFloat(): boolean;
+    /**
+     * Implemented as part of CuteFormFieldControl.
+     */
+    setDescribedByIds(ids: string[]): void;
+    /**
+     * Implemented as part of CuteFormFieldControl.
+     */
+    onContainerClick(): void;
+    /** Whether the form control is native select that is displayed inline. */
+    _isInlineSelect(): boolean;
+    private _iOSKeyupListener;
+    private _webkitBlinkWheelListener;
+    /**
+     * In blink and webkit browsers, a focused number input does not increment or decrement its value
+     * on mouse wheel interaction unless a wheel event listener is attached to it or one of its ancestors or a passive-wheel listener is attached somewhere in the DOM.
+     * For example, Hitting a tooltip once enables the mouse wheel input for all number inputs as long as it exists.
+     * In order to get reliable and intuitive behavior, we apply a wheel event on our own,
+     * thus making sure increment and decrement by mouse wheel works every time.
+     * @docs-private
+     */
+    private _ensureWheelDefaultBehavior;
+    /** Gets the value to set on the `readonly` attribute. */
+    protected _getReadonlyAttribute(): string | null;
+    /**
+     * This handler is only needed if DefaultValueAccessor is not applied.
+     * @internal
+     */
+    protected _compositionStart(): void;
+    /**
+     * This handler is only needed if DefaultValueAccessor is not applied.
+     * @internal
+     */
+    protected _compositionEnd(value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteInput, "        input[cuteInput],        textarea[cuteInput],        select[cuteNativeControl],        input[cuteNativeControl],        textarea[cuteNativeControl],    ", ["cuteInput"], { "placeholder": { "alias": "placeholder"; "required": false; }; "magnitude": { "alias": "magnitude"; "required": false; }; "type": { "alias": "type"; "required": false; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; }; "userAriaDescribedBy": { "alias": "aria-describedby"; "required": false; }; "value": { "alias": "value"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "disabledInteractive": { "alias": "disabledInteractive"; "required": false; }; "plainText": { "alias": "plainText"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_disabledInteractive: unknown;
+    static ngAcceptInputType_plainText: 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).
+ */
+
+/**
+ * This token is used to inject the object whose value should be set into `CuteInput`. If none is
+ * provided, the native `HTMLInputElement` is used. Directives like `CuteDatepickerInput` can provide
+ * themselves for this token, in order to make `CuteInput` delegate the getting and setting of the
+ * value to them.
+ */
+declare const CUTE_INPUT_VALUE_ACCESSOR: InjectionToken<{
+    value: any | WritableSignal<any>;
+}>;
+
+/**
+ * @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
+ */
+
+/** Object that can be used to format the current value of the input. */
+interface CuteInputValueFormatter {
+    /**
+     * Applies some formatting to the original value
+     * @param value Value to format
+     * @param args  Any number of arguments
+     * @returns The final transformed or unchanged value
+     */
+    format(value: any, ...args: any[]): any;
+}
+/** This token is used to inject an object that will be applied to format a raw input value */
+declare const CUTE_INPUT_VALUE_FORMATTER: InjectionToken<CuteInputValueFormatter>;
+
+/**
+ * @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
+ */
+
+interface CuteInputValuePredecessor {
+    beforeWriteValue(value: any): string;
+    beforeOnChange(value: string): any;
+}
+/**
+ * This token is used to inject an object with special methods that will be invoked before _ControlValueAccessor_'s methods do.
+ * The typical example of such object is a _CuteEditMask_, that needs to get masked value before assign it to the view and
+ * get cleaned value before send it to the model (form control).
+ */
+declare const CUTE_INPUT_VALUE_PREDECESSOR: InjectionToken<CuteInputValuePredecessor>;
+
+declare class CuteInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteInputModule, never, [typeof i1.CommonModule, typeof CuteInput, typeof i3.CuteFormFieldModule], [typeof CuteInput, typeof i3.CuteFormFieldModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteInputModule>;
+}
+
+export { CUTE_INPUT_CONFIG, CUTE_INPUT_VALUE_ACCESSOR, CUTE_INPUT_VALUE_FORMATTER, CUTE_INPUT_VALUE_PREDECESSOR, CuteInput, CuteInputModule };
+export type { CuteInputConfig, CuteInputValueFormatter, CuteInputValuePredecessor };

package/layout/container/index.d.ts

@@ -0,0 +1,31 @@
+import { CuteLayoutControl } from '@cute-widgets/base/abstract';
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+
+/**
+ * A responsive, fixed-width container, meaning its `max-width` changes when the `breakpoint` input parameter is specified.
+ * After the breakpoint is reached, the content will scale up to the higher breakpoint(s).
+ */
+declare class CuteContainer extends CuteLayoutControl {
+    /** A full width container, spanning the entire width of the viewport. */
+    fluid: boolean;
+    constructor();
+    protected generateId(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteContainer, "cute-container", ["cuteContainer"], { "fluid": { "alias": "fluid"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_fluid: unknown;
+}
+
+declare class CutePageHeader {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CutePageHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CutePageHeader, "cute-page-header", ["cutePageHeader"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class CuteContainerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteContainerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteContainerModule, never, [typeof i1.CommonModule, typeof CuteContainer, typeof CutePageHeader], [typeof CuteContainer, typeof CutePageHeader]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteContainerModule>;
+}
+
+export { CuteContainer, CuteContainerModule, CutePageHeader };

package/layout/index.d.ts

@@ -0,0 +1,78 @@
+import { LayoutDirection } from '@cute-widgets/base/core';
+import { CuteLayoutControl } from '@cute-widgets/base/abstract';
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+
+/**
+ * Stacks offer a shortcut for applying a number of flexbox properties to quickly and easily create flex layouts.
+ */
+declare class CuteStack extends CuteLayoutControl {
+    /** Direction of the child components. */
+    get direction(): LayoutDirection;
+    set direction(value: LayoutDirection);
+    protected _direction: LayoutDirection;
+    /** Spacing level (0..5) between the child components. */
+    get gap(): number;
+    set gap(value: number);
+    private _gap;
+    constructor();
+    protected setDirection(value: LayoutDirection): void;
+    protected generateId(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteStack, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteStack, "cute-stack", ["cuteStack"], { "direction": { "alias": "direction"; "required": false; }; "gap": { "alias": "gap"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_gap: unknown;
+}
+
+/**
+ * Use for horizontal layouts. Stacked items are vertically centered by default and only take up their necessary width.
+ */
+declare class CuteHStack extends CuteStack {
+    constructor();
+    protected setDirection(value: LayoutDirection): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteHStack, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteHStack, "cute-hstack", ["cuteStack"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Use to create vertical layouts. Stacked items are full-width by default.
+ */
+declare class CuteVStack extends CuteStack {
+    constructor();
+    protected setDirection(value: LayoutDirection): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteVStack, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteVStack, "cute-vstack", ["cuteStack"], {}, {}, never, never, true, never>;
+}
+
+declare class CuteStackModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteStackModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteStackModule, never, [typeof i1.CommonModule, typeof CuteStack, typeof CuteVStack, typeof CuteHStack], [typeof CuteStack, typeof CuteVStack, typeof CuteHStack]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteStackModule>;
+}
+
+/**
+ * A responsive, fixed-width container, meaning its `max-width` changes when the `breakpoint` input parameter is specified.
+ * After the breakpoint is reached, the content will scale up to the higher breakpoint(s).
+ */
+declare class CuteContainer extends CuteLayoutControl {
+    /** A full width container, spanning the entire width of the viewport. */
+    fluid: boolean;
+    constructor();
+    protected generateId(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteContainer, "cute-container", ["cuteContainer"], { "fluid": { "alias": "fluid"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_fluid: unknown;
+}
+
+declare class CutePageHeader {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CutePageHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CutePageHeader, "cute-page-header", ["cutePageHeader"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class CuteContainerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteContainerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteContainerModule, never, [typeof i1.CommonModule, typeof CuteContainer, typeof CutePageHeader], [typeof CuteContainer, typeof CutePageHeader]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteContainerModule>;
+}
+
+export { CuteContainer, CuteContainerModule, CuteHStack, CutePageHeader, CuteStack, CuteStackModule, CuteVStack };

package/layout/stack/index.d.ts

@@ -0,0 +1,52 @@
+import { LayoutDirection } from '@cute-widgets/base/core';
+import { CuteLayoutControl } from '@cute-widgets/base/abstract';
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+
+/**
+ * Stacks offer a shortcut for applying a number of flexbox properties to quickly and easily create flex layouts.
+ */
+declare class CuteStack extends CuteLayoutControl {
+    /** Direction of the child components. */
+    get direction(): LayoutDirection;
+    set direction(value: LayoutDirection);
+    protected _direction: LayoutDirection;
+    /** Spacing level (0..5) between the child components. */
+    get gap(): number;
+    set gap(value: number);
+    private _gap;
+    constructor();
+    protected setDirection(value: LayoutDirection): void;
+    protected generateId(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteStack, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteStack, "cute-stack", ["cuteStack"], { "direction": { "alias": "direction"; "required": false; }; "gap": { "alias": "gap"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_gap: unknown;
+}
+
+/**
+ * Use for horizontal layouts. Stacked items are vertically centered by default and only take up their necessary width.
+ */
+declare class CuteHStack extends CuteStack {
+    constructor();
+    protected setDirection(value: LayoutDirection): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteHStack, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteHStack, "cute-hstack", ["cuteStack"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Use to create vertical layouts. Stacked items are full-width by default.
+ */
+declare class CuteVStack extends CuteStack {
+    constructor();
+    protected setDirection(value: LayoutDirection): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteVStack, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteVStack, "cute-vstack", ["cuteStack"], {}, {}, never, never, true, never>;
+}
+
+declare class CuteStackModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteStackModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteStackModule, never, [typeof i1.CommonModule, typeof CuteStack, typeof CuteVStack, typeof CuteHStack], [typeof CuteStack, typeof CuteVStack, typeof CuteHStack]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteStackModule>;
+}
+
+export { CuteHStack, CuteStack, CuteStackModule, CuteVStack };