@cute-widgets/base 20.0.1

package/dialog/index.d.ts

@@ -0,0 +1,484 @@
+import * as i0 from '@angular/core';
+import { ViewContainerRef, Injector, OnDestroy, EventEmitter, ComponentRef, OnInit, TemplateRef, InjectionToken, OnChanges, ElementRef, SimpleChanges } from '@angular/core';
+import { HorizontalEdge, LayoutBreakpoint } from '@cute-widgets/base/core/types';
+import { DragAxis, CdkDrag } from '@angular/cdk/drag-drop';
+import { Direction } from '@angular/cdk/bidi';
+import { ScrollStrategy, OverlayRef, ComponentType } from '@angular/cdk/overlay';
+import { DialogConfig, CdkDialogContainer, DialogRef, Dialog } from '@angular/cdk/dialog';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { Observable, Subject } from 'rxjs';
+import * as i1 from '@angular/common';
+
+declare class CuteDialogBody {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteDialogBody, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteDialogBody, "cute-dialog-body, [cute-dialog-body], [cuteDialogBody],             cute-dialog-content, [cute-dialog-content], [cuteDialogContent]  ", ["cuteDialogBody"], {}, {}, never, never, true, never>;
+}
+
+declare class CuteDialogFooter {
+    /** Horizontal alignment of the footer's content */
+    align: HorizontalEdge | 'center';
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteDialogFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteDialogFooter, "cute-dialog-footer, [cute-dialog-footer], [cuteDialogFooter],             cute-dialog-actions, [cute-dialog-actions], [cuteDialogActions]  ", ["cuteDialogFooter", "cuteDialogActions"], { "align": { "alias": "align"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @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).
+ */
+
+/** Options for where to set focus to automatically on dialog open */
+type AutoFocusTarget = 'dialog' | 'first-tabbable' | 'first-heading';
+/** Valid ARIA roles for a dialog element. */
+type DialogRole = 'dialog' | 'alertdialog';
+/** Full-screen strategy for a dialog element */
+type DialogFullScreenStrategy = 'fullscreen' | `fullscreen-${LayoutBreakpoint}`;
+/** Possible overrides for a dialog's position. */
+interface DialogPosition {
+    /** Override for the dialog's top position. */
+    top?: string;
+    /** Override for the dialog's bottom position. */
+    bottom?: string;
+    /** Override for the dialog's left position. */
+    left?: string;
+    /** Override for the dialog's right position. */
+    right?: string;
+}
+/**
+ * Configuration for opening a modal dialog with the `CuteDialog` service.
+ */
+declare class CuteDialogConfig<D = any> {
+    /**
+     * Where the attached component should live in an Angular *logical* component tree.
+     * This affects what is available for injection and the change detection order for the
+     * component instantiated inside the dialog. This does not affect where the dialog
+     * content will be rendered.
+     */
+    viewContainerRef?: ViewContainerRef;
+    /**
+     * Injector used for the instantiation of the component to be attached. If provided,
+     * take precedence over the injector indirectly provided by `ViewContainerRef`.
+     */
+    injector?: Injector;
+    /** ID for the dialog. If omitted, a unique one will be generated. */
+    id?: string;
+    /** The ARIA role of the dialog element. */
+    role?: DialogRole;
+    /** Custom class for the overlay pane. */
+    panelClass?: string | string[];
+    /** Whether the dialog has a backdrop. */
+    hasBackdrop?: boolean;
+    /** Custom class for the backdrop. */
+    backdropClass?: string | string[];
+    /** Whether the user can use escape or clicking on the backdrop to close the modal. */
+    disableClose?: boolean;
+    /** Function used to determine whether the dialog is allowed to close. */
+    closePredicate?: <Result = unknown, Component = unknown, Config extends DialogConfig = CuteDialogConfig>(result: Result | undefined, config: Config, componentInstance: Component | null) => boolean;
+    /** Width of the dialog. */
+    width?: string;
+    /** Height of the dialog. */
+    height?: string;
+    /** Min-width of the dialog. If a number is provided, assumes pixel units. */
+    minWidth?: number | string;
+    /** Min-height of the dialog. If a number is provided, assumes pixel units. */
+    minHeight?: number | string;
+    /** Max-width of the dialog. If a number is provided, assumes pixel units. Defaults to 80vw. */
+    maxWidth?: number | string;
+    /** Max-height of the dialog. If a number is provided, assumes pixel units. */
+    maxHeight?: number | string;
+    /** Position overrides. */
+    position?: DialogPosition;
+    /** Full-screen strategy to be used for the dialog. */
+    fullscreenStrategy?: DialogFullScreenStrategy;
+    /** Whether the dialog can be dragged at runtime and optionally restrict dragging to a specific axis */
+    draggable?: boolean | `${DragAxis}-axis`;
+    /** Data being injected into the child component. */
+    data?: D | null;
+    /** Layout direction for the dialog's content. */
+    direction?: Direction;
+    /** ID of the element that describes the dialog. */
+    ariaDescribedBy?: string | null;
+    /** ID of the element that labels the dialog. */
+    ariaLabelledBy?: string | null;
+    /** Aria label to assign to the dialog element. */
+    ariaLabel?: string | null;
+    /** Whether this is a modal dialog. Used to set the `aria-modal` attribute. */
+    ariaModal?: boolean;
+    /**
+     * Where the dialog should focus on open.
+     */
+    autoFocus?: AutoFocusTarget | string;
+    /**
+     * Whether the dialog should restore focus to the
+     * previously focused element, after it's closed.
+     */
+    restoreFocus?: boolean;
+    /** Whether to wait for the opening animation to finish before trapping focus. */
+    delayFocusTrap?: boolean;
+    /** Scroll strategy to be used for the dialog. */
+    scrollStrategy?: ScrollStrategy;
+    /**
+     * Whether the dialog should close when the user goes backwards/forwards in history.
+     * Note that this usually doesn't include clicking on links (unless the user is using
+     * the `HashLocationStrategy`).
+     */
+    closeOnNavigation?: boolean;
+    /**
+     * Duration of the entered animation in ms.
+     */
+    enterAnimationDuration?: number;
+    /**
+     * Duration of the exit animation in ms.
+     */
+    exitAnimationDuration?: number;
+}
+
+/**
+ * @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).
+ */
+
+/** Event that captures the state of dialog container animations. */
+interface LegacyDialogAnimationEvent {
+    state: 'opened' | 'opening' | 'closing' | 'closed';
+    totalTime: number;
+}
+declare class CuteDialogContainer extends CdkDialogContainer<CuteDialogConfig> implements OnDestroy {
+    /** Emits when an animation state changes. */
+    _animationStateChanged: EventEmitter<LegacyDialogAnimationEvent>;
+    /** Whether animations are enabled. */
+    _animationsEnabled: boolean;
+    protected _overlayRef: OverlayRef;
+    /** Number of actions projected in the dialog. */
+    protected _actionSectionCount: number;
+    /** Host element of the dialog container component. */
+    private _hostElement;
+    /** Duration of the dialog open animation. */
+    private _enterAnimationDuration;
+    /** Duration of the dialog close animation. */
+    private _exitAnimationDuration;
+    /** Current timer for dialog animations. */
+    private _animationTimer;
+    constructor();
+    /**
+     * Whether the Dialog box is opened to the full screen
+     */
+    isFullScreenDialog(): boolean;
+    protected _contentAttached(): void;
+    /** Starts the dialog open animation if enabled. */
+    private _startOpenAnimation;
+    /**
+     * Starts the exit animation of the dialog if enabled. This method is
+     * called by the dialog ref.
+     */
+    _startExitAnimation(): void;
+    /**
+     * Updates the number action sections.
+     * @param delta Increase/decrease in the number of sections.
+     */
+    _updateActionSectionCount(delta: number): void;
+    /**
+     * Completes the dialog open by clearing potential animation classes, trapping
+     * focus and emitting an opened event.
+     */
+    private _finishDialogOpen;
+    /**
+     * Completes the dialog close by clearing potential animation classes, restoring
+     * focus and emitting a closed event.
+     */
+    private _finishDialogClose;
+    /** Clears all dialog animation classes. */
+    private _clearAnimationClasses;
+    private _waitForAnimationToComplete;
+    /** Runs a callback in `requestAnimationFrame`, if available. */
+    private _requestAnimationFrame;
+    protected _captureInitialFocus(): void;
+    /**
+     * Callback for when the open dialog animation has finished. Intended to
+     * be called by sub-classes that use different animation implementations.
+     */
+    protected _openAnimationDone(totalTime: number): void;
+    ngOnDestroy(): void;
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteDialogContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteDialogContainer, "cute-dialog-container", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @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).
+ */
+
+declare class CuteDialogHeader implements OnInit {
+    protected container: CuteDialogContainer;
+    protected cdkDragEl: CdkDrag | undefined;
+    protected config: CuteDialogConfig;
+    protected isMouseDown: boolean;
+    /**
+     * Whether it is possible to drag the `Dialog` by grabbing the header section.
+     * The default value is the value of the `draggable` property from the `CuteDialogConfig` object,
+     * or _false_ if the value is not defined.
+     */
+    get draggable(): boolean;
+    set draggable(value: boolean);
+    private _draggable;
+    constructor(container: CuteDialogContainer);
+    protected getCursorStyle(): string;
+    protected onMouseDown(event: MouseEvent): void;
+    protected onMouseUp(event: MouseEvent): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteDialogHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteDialogHeader, "cute-dialog-header", ["cuteDialogHeader"], { "draggable": { "alias": "draggable"; "required": false; }; }, {}, never, ["[cute-dialog-title], [cuteDialogTitle]", "*"], true, never>;
+    static ngAcceptInputType_draggable: unknown;
+}
+
+declare class CuteDialogTitle {
+    id: unknown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteDialogTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteDialogTitle, "[cute-dialog-title], [cuteDialogTitle]", ["cuteDialogTitle"], { "id": { "alias": "id"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @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).
+ */
+/** Possible states of the lifecycle of a dialog. */
+
+declare enum CuteDialogState {
+    OPEN = 0,
+    CLOSING = 1,
+    CLOSED = 2
+}
+/**
+ * Reference to a dialog opened via the CuteDialog service.
+ */
+declare class CuteDialogRef<T, R = any> {
+    private _ref;
+    private _config;
+    protected _containerInstance: CuteDialogContainer;
+    /** The instance of component opened into the dialog. */
+    componentInstance: T | undefined;
+    /**
+     * `ComponentRef` of the component opened into the dialog. Will be
+     * null when the dialog is opened using a `TemplateRef`.
+     */
+    readonly componentRef: ComponentRef<T> | null;
+    /** Whether the user is allowed to close the dialog. */
+    disableClose: boolean | undefined;
+    /** Unique ID for the dialog. */
+    id: string;
+    /** Subject for notifying the user that the dialog has finished opening. */
+    private readonly _afterOpened;
+    /** Subject for notifying the user that the dialog has started closing. */
+    private readonly _beforeClosed;
+    /** Result to be passed to afterClosed. */
+    private _result;
+    /** Handle to the timeout that's running as a fallback in case the exit animation doesn't fire. */
+    private _closeFallbackTimeout;
+    /** Current state of the dialog. */
+    private _state;
+    /** Interaction that caused the dialog to close. */
+    private _closeInteractionType;
+    constructor(_ref: DialogRef<R, T>, _config: CuteDialogConfig, _containerInstance: CuteDialogContainer);
+    /**
+     * Close the dialog.
+     * @param dialogResult Optional result to return to the dialog opener.
+     */
+    close(dialogResult?: R): void;
+    /**
+     * Gets an observable notified when the dialog is finished opening.
+     */
+    afterOpened(): Observable<void>;
+    /**
+     * Gets an observable notified when the dialog is finished closing.
+     */
+    afterClosed(): Observable<R | undefined>;
+    /**
+     * Gets an observable notified when the dialog has started closing.
+     */
+    beforeClosed(): Observable<R | undefined>;
+    /**
+     * Gets an observable that emits when the overlay's backdrop has been clicked.
+     */
+    backdropClick(): Observable<MouseEvent>;
+    /**
+     * Gets an observable that emits when keydown events are targeted on the overlay.
+     */
+    keydownEvents(): Observable<KeyboardEvent>;
+    /**
+     * Updates the dialog's position.
+     * @param position New dialog position.
+     */
+    updatePosition(position?: DialogPosition): this;
+    /**
+     * Updates the dialog's width and height.
+     * @param width New width of the dialog.
+     * @param height New height of the dialog.
+     */
+    updateSize(width?: string, height?: string): this;
+    /** Add a CSS class or an array of classes to the overlay pane. */
+    addPanelClass(classes: string | string[]): this;
+    /** Remove a CSS class or an array of classes from the overlay pane. */
+    removePanelClass(classes: string | string[]): this;
+    /** Checks if the panel contains the specified CSS class */
+    hasPanelClass(className: string): boolean;
+    /** Gets the current state of the dialog's lifecycle. */
+    getState(): CuteDialogState;
+    /**
+     * Finishes the dialog close by updating the state of the dialog
+     * and disposing the overlay.
+     */
+    private _finishDialogClose;
+}
+/**
+ * Closes the dialog with the specified interaction type. This is currently not part of
+ * `CuteDialogRef` as that would conflict with custom dialog ref mocks provided in tests.
+ * More details. See: https://github.com/angular/components/pull/9257#issuecomment-651342226.
+ */
+declare function _closeDialogVia<R>(ref: CuteDialogRef<R>, interactionType: FocusOrigin, result?: R): 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
+ *
+ * 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 access the data that was passed in to a dialog. */
+declare const CUTE_DIALOG_DATA: InjectionToken<any>;
+/** Injection token that can be used to specify default dialog options. */
+declare const CUTE_DIALOG_DEFAULT_OPTIONS: InjectionToken<CuteDialogConfig<any>>;
+/** Injection token that determines the scroll handling while the dialog is open. */
+declare const CUTE_DIALOG_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+/**
+ * Service to open `Bootstrap` modal controls
+ */
+declare class CuteDialog implements OnDestroy {
+    private _overlay;
+    private _defaultOptions;
+    private _scrollStrategy;
+    private _parentDialog;
+    protected _dialog: Dialog;
+    private readonly _openDialogsAtThisLevel;
+    private readonly _afterAllClosedAtThisLevel;
+    private readonly _afterOpenedAtThisLevel;
+    private readonly _dialogRefConstructor;
+    private readonly _dialogContainerType;
+    private readonly _dialogDataToken;
+    protected dialogConfigClass: typeof CuteDialogConfig;
+    /** Keeps track of the currently open dialogs. */
+    get openDialogs(): CuteDialogRef<any>[];
+    /** Stream that emits when a dialog has been opened. */
+    get afterOpened(): Subject<CuteDialogRef<any>>;
+    private _getAfterAllClosed;
+    /**
+     * Stream that emits when all open dialogs have finished closing.
+     * Will emit on subscribing if there are no open dialogs to begin with.
+     */
+    readonly afterAllClosed: Observable<void>;
+    constructor(...args: unknown[]);
+    /**
+     * Opens a modal dialog containing the given component.
+     * @param component Type of the component to load into the dialog.
+     * @param config Extra configuration options.
+     * @returns Reference to the newly opened dialog.
+     */
+    open<T, D = any, R = any>(component: ComponentType<T>, config?: CuteDialogConfig<D>): CuteDialogRef<T, R>;
+    /**
+     * Opens a modal dialog containing the given template.
+     * @param template TemplateRef to instantiate as the dialog content.
+     * @param config Extra configuration options.
+     * @returns Reference to the newly opened dialog.
+     */
+    open<T, D = any, R = any>(template: TemplateRef<T>, config?: CuteDialogConfig<D>): CuteDialogRef<T, R>;
+    open<T, D = any, R = any>(template: ComponentType<T> | TemplateRef<T>, config?: CuteDialogConfig<D>): CuteDialogRef<T, R>;
+    /**
+     * Closes all the currently open dialogs.
+     */
+    closeAll(): void;
+    /**
+     * Finds an open dialog by its id.
+     * @param id ID to use when looking up the dialog.
+     */
+    getDialogById(id: string): CuteDialogRef<any> | undefined;
+    ngOnDestroy(): void;
+    private _closeDialogs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteDialog, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuteDialog>;
+}
+
+/**
+ * @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).
+ */
+
+/**
+ * Button that will close the current dialog.
+ */
+declare class CuteDialogClose implements OnInit, OnChanges {
+    dialogRef: CuteDialogRef<any>;
+    private _elementRef;
+    private _dialog;
+    /** Screen-reader label for the button. */
+    ariaLabel: string | undefined;
+    /** Default to "button" to prevent accidental form submits. */
+    type: 'submit' | 'button' | 'reset';
+    /** Dialog close input. */
+    dialogResult: any;
+    _cuteDialogClose: any;
+    constructor(dialogRef: CuteDialogRef<any>, _elementRef: ElementRef<HTMLElement>, _dialog: CuteDialog);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    protected _onButtonClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteDialogClose, [{ optional: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteDialogClose, "[cute-dialog-close], [cuteDialogClose]", ["cuteDialogClose"], { "ariaLabel": { "alias": "aria-label"; "required": false; }; "type": { "alias": "type"; "required": false; }; "dialogResult": { "alias": "cute-dialog-close"; "required": false; }; "_cuteDialogClose": { "alias": "cuteDialogClose"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class CuteDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteDialogModule, never, [typeof i1.CommonModule, typeof CuteDialogBody, typeof CuteDialogClose, typeof CuteDialogFooter, typeof CuteDialogHeader, typeof CuteDialogTitle, typeof CuteDialogContainer], [typeof CuteDialogBody, typeof CuteDialogClose, typeof CuteDialogFooter, typeof CuteDialogHeader, typeof CuteDialogTitle, typeof CuteDialogContainer]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteDialogModule>;
+}
+
+export { CUTE_DIALOG_DATA, CUTE_DIALOG_DEFAULT_OPTIONS, CUTE_DIALOG_SCROLL_STRATEGY, CuteDialog, CuteDialogBody, CuteDialogClose, CuteDialogConfig, CuteDialogContainer, CuteDialogFooter, CuteDialogHeader, CuteDialogModule, CuteDialogRef, CuteDialogState, CuteDialogTitle, _closeDialogVia };
+export type { AutoFocusTarget, DialogFullScreenStrategy, DialogPosition, DialogRole };

package/divider/index.d.ts

@@ -0,0 +1,24 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+
+declare class CuteDivider {
+    /** Divider's line style. */
+    lineStyle: "solid" | "double" | "dotted" | "dashed" | "shelf" | "blurry" | "washed" | "gradient";
+    /** Whether the divider is vertically aligned. */
+    vertical: boolean;
+    /** Whether the divider is an inset divider. */
+    inset: boolean;
+    get classBinding(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteDivider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteDivider, "cute-divider", never, { "lineStyle": { "alias": "lineStyle"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; "inset": { "alias": "inset"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_vertical: unknown;
+    static ngAcceptInputType_inset: unknown;
+}
+
+declare class CuteDividerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteDividerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteDividerModule, never, [typeof i1.CommonModule, typeof CuteDivider], [typeof CuteDivider]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteDividerModule>;
+}
+
+export { CuteDivider, CuteDividerModule };

package/expansion/README.md

@@ -0,0 +1,8 @@
+An `cute-accordion` is a component with one or more expandable sections implemented as
+`cute-expansion-panel` components.
+
+The source code of this package is a revised version of the eponymous package in the 
+_Angular Material_ library. The source MIT-style license file at https://angular.dev/license.
+
+Copyright(c) ALEXANDER STRELKOV, All Rights Reserved.
+Apache license, Version 2.0.