@cute-widgets/base 20.0.1

package/radio/index.d.ts

@@ -0,0 +1,259 @@
+import * as i0 from '@angular/core';
+import { DoCheck, ElementRef, EventEmitter, InjectionToken, AfterContentInit, OnDestroy, QueryList } from '@angular/core';
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { RelativeSize, ThemeColor } from '@cute-widgets/base/core';
+import { CuteInputControl } from '@cute-widgets/base/abstract';
+import { ControlValueAccessor } from '@angular/forms';
+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).
+ */
+
+/** Change an event object emitted by radio button and radio group. */
+declare class CuteRadioChange<T = any> {
+    /** The radio button that emits the change event. */
+    source: CuteRadioButton;
+    /** The value of the radio button. */
+    value: T;
+    constructor(
+    /** The radio button that emits the change event. */
+    source: CuteRadioButton, 
+    /** The value of the radio button. */
+    value: T);
+}
+interface CuteRadioDefaultOptions {
+    color: ThemeColor;
+    /** Whether disabled radio buttons should be interactive. */
+    disabledInteractive?: boolean;
+}
+declare const CUTE_RADIO_DEFAULT_OPTIONS: InjectionToken<CuteRadioDefaultOptions>;
+declare class CuteRadioButton extends CuteInputControl implements DoCheck {
+    private _ngZone;
+    private _injector;
+    private _destroyRef;
+    private readonly _radioDispatcher;
+    private _defaultOptions;
+    private _cleanupClick;
+    /** The parent radio group. May or may not be present. */
+    private readonly radioGroup;
+    /** Unregister function for _radioDispatcher */
+    private _removeUniqueSelectionListener;
+    /** Previous value of the input's tabindex. */
+    private _previousTabIndex;
+    /** The native `<input type=radio>` element */
+    readonly _inputElement: ElementRef<HTMLInputElement> | undefined;
+    /** Whether this radio button is checked. */
+    get checked(): boolean;
+    set checked(value: boolean);
+    private _checked;
+    /** Group radios on the same horizontal row */
+    inline: boolean;
+    /** Whether the label should appear after or before the radio button. Defaults to 'after' */
+    get labelPosition(): 'before' | 'after';
+    set labelPosition(value: "before" | "after");
+    private _labelPosition;
+    /** The value of this radio button. */
+    get value(): any;
+    set value(value: any);
+    private _value;
+    /** Whether the radio button should remain interactive when it is disabled. */
+    get disabledInteractive(): boolean;
+    set disabledInteractive(value: boolean);
+    private _disabledInteractive;
+    /** Relative size of the radio icon. */
+    iconSize: RelativeSize;
+    /**
+     * Event emitted when the checked state of this radio button changes.
+     * Change events are only emitted when the value changes due to user interaction with
+     * the radio button (the same behavior as `<input type-"radio">`).
+     */
+    readonly change: EventEmitter<CuteRadioChange>;
+    generateId(): string;
+    constructor(...args: unknown[]);
+    /** Focuses the radio button. */
+    focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    /**
+     * Marks the radio button as needing checking for change detection.
+     * This method is exposed because the parent radio group will directly
+     * update bound properties of the radio button.
+     */
+    _markForCheck(): void;
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /** Dispatch change event with current value. */
+    private _emitChangeEvent;
+    protected _preventBubblingFromLabel(event: Event): void;
+    /** Triggered when the radio button receives an interaction from the user. */
+    _onInputInteraction(event: Event): void;
+    /** Triggered when the user clicks on the touch target. */
+    _onTouchTargetClick(event: Event): void;
+    /** Called when the input is clicked. */
+    private _onInputClick;
+    /** Gets the tabindex for the underlying input element. */
+    private _updateTabIndex;
+    writeValue(obj: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteRadioButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteRadioButton, "cute-radio-button", ["cuteRadioButton"], { "checked": { "alias": "checked"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabledInteractive": { "alias": "disabledInteractive"; "required": false; }; "iconSize": { "alias": "iconSize"; "required": false; }; }, { "change": "change"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_checked: unknown;
+    static ngAcceptInputType_inline: unknown;
+    static ngAcceptInputType_disabledInteractive: 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).
+ */
+
+/**
+ * Provider Expression that allows `cute-radio-group` to register as a `ControlValueAccessor`. This
+ * allows it to support `[(ngModel)]` and `ngControl`.
+ */
+declare const CUTE_RADIO_GROUP_CONTROL_VALUE_ACCESSOR: any;
+/**
+ * Injection token that can be used to inject instances of `CuteRadioGroup`. It serves as
+ * an alternative token to the actual `CuteRadioGroup` class which could cause unnecessary
+ * retention of the class and its component metadata.
+ */
+declare const CUTE_RADIO_GROUP: InjectionToken<CuteRadioGroup>;
+/**
+ * A group of radio buttons. May contain one or more `<cute-radio-button>` elements.
+ */
+declare class CuteRadioGroup implements AfterContentInit, OnDestroy, ControlValueAccessor {
+    private _changeDetector;
+    /** Selected value for the radio group. */
+    private _value;
+    /** The HTML name attribute applied to radio buttons in this group. */
+    private _name;
+    /** The currently selected radio button. Should match value. */
+    private _selected;
+    /** Whether the `value` has been set to its initial value. */
+    private _isInitialized;
+    /** Whether the labels should appear after or before the radio-buttons. Defaults to 'after' */
+    private _labelPosition;
+    /** Whether the radio group is disabled. */
+    private _disabled;
+    /** Whether the radio group is required. */
+    private _required;
+    /** Subscription to changes in number of radio buttons. */
+    private _buttonChanges;
+    /** The method to be called in order to update ngModel */
+    _controlValueAccessorChangeFn: (value: any) => void;
+    /**
+     * onTouch function registered via registerOnTouch (ControlValueAccessor).
+     * @docs-private
+     */
+    onTouched: () => any;
+    /**
+     * Event emitted when the group value changes.
+     * Change events are only emitted when the value changes due to user interaction with
+     * a radio button (the same behavior as `<input type-"radio">`).
+     */
+    readonly change: EventEmitter<CuteRadioChange>;
+    /** Child radio buttons. */
+    _radios: QueryList<CuteRadioButton> | undefined;
+    /** Theme color for all the radio buttons in the group. */
+    color: ThemeColor | undefined;
+    /** Name of the radio button group. All radio buttons inside this group will use this name. */
+    get name(): string;
+    set name(value: string);
+    /** Whether the labels should appear after or before the radio-buttons. Defaults to 'after' */
+    get labelPosition(): 'before' | 'after';
+    set labelPosition(v: "before" | "after");
+    /**
+     * Value for the radio-group. Should equal the value of the selected radio button if there is
+     * a corresponding radio button with a matching value. If there is not such a corresponding
+     * radio button, this value persists to be applied in case a new radio button is added with a
+     * matching value.
+     */
+    get value(): any;
+    set value(newValue: any);
+    _checkSelectedRadioButton(): void;
+    /**
+     * The currently selected radio button. If set to a new radio button, the radio group value
+     * will be updated to match the new selected button.
+     */
+    get selected(): CuteRadioButton | null;
+    set selected(selected: CuteRadioButton | null);
+    /** Whether the radio group is disabled */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /** Whether the radio group is required */
+    get required(): boolean;
+    set required(value: boolean);
+    /** Whether buttons in the group should be interactive while they're disabled. */
+    get disabledInteractive(): boolean;
+    set disabledInteractive(value: boolean);
+    private _disabledInteractive;
+    constructor(...args: unknown[]);
+    /**
+     * Initialize properties once content children are available.
+     * This allows us to propagate relevant attributes to associated buttons.
+     */
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Mark this group as being "touched" (for ngModel). Meant to be called by the contained
+     * radio buttons upon their blur.
+     */
+    _touch(): void;
+    private _updateRadioButtonNames;
+    /** Updates the `selected` radio button from the internal _value state. */
+    private _updateSelectedRadioFromValue;
+    /** Dispatch change event with current selection and group value. */
+    _emitChangeEvent(): void;
+    _markRadiosForCheck(): void;
+    /**
+     * Sets the model value. Implemented as part of ControlValueAccessor.
+     * @param value
+     */
+    writeValue(value: any): void;
+    /**
+     * Registers a callback to be triggered when the model value changes.
+     * Implemented as part of ControlValueAccessor.
+     * @param fn Callback to be registered.
+     */
+    registerOnChange(fn: (value: any) => void): void;
+    /**
+     * Registers a callback to be triggered when the control is touched.
+     * Implemented as part of ControlValueAccessor.
+     * @param fn Callback to be registered.
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Sets the disabled state of the control. Implemented as a part of ControlValueAccessor.
+     * @param isDisabled Whether the control should be disabled.
+     */
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteRadioGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteRadioGroup, "cute-radio-group", ["cuteRadioGroup"], { "color": { "alias": "color"; "required": false; }; "name": { "alias": "name"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "value": { "alias": "value"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabledInteractive": { "alias": "disabledInteractive"; "required": false; }; }, { "change": "change"; }, ["_radios"], never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_disabledInteractive: unknown;
+}
+
+declare class CuteRadioModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteRadioModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteRadioModule, never, [typeof i1.CommonModule, typeof CuteRadioButton, typeof CuteRadioGroup], [typeof CuteRadioButton, typeof CuteRadioGroup]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteRadioModule>;
+}
+
+export { CUTE_RADIO_DEFAULT_OPTIONS, CUTE_RADIO_GROUP, CUTE_RADIO_GROUP_CONTROL_VALUE_ACCESSOR, CuteRadioButton, CuteRadioChange, CuteRadioGroup, CuteRadioModule };
+export type { CuteRadioDefaultOptions };