@ardium-pl/ui 5.0.0-alpha.106

package/lib/slider/abstract-slider.d.ts

@@ -0,0 +1,96 @@
+import { Overlay, ScrollStrategyOptions } from '@angular/cdk/overlay';
+import { ElementRef, Renderer2, Signal, ViewContainerRef, WritableSignal } from '@angular/core';
+import { BooleanLike, NumberLike } from '@ardium-ui/devkit';
+import { _NgModelComponentBase, _NgModelComponentDefaults } from '../_internal/ngmodel-component';
+import { SimpleComponentColor } from '../types/colors.types';
+import { ArdRangeSelectionBehavior } from './range-slider/range-slider.types';
+import { ArdSliderTooltipDirective } from './slider.directive';
+import { SliderDecorationPosition, SliderLabelObject, SliderTooltipBehavior, SliderTooltipFormatFn, _InternalSliderLabelObject } from './slider.types';
+import * as i0 from "@angular/core";
+export interface _AsbtractSliderDefaults extends _NgModelComponentDefaults {
+    noTooltip: boolean;
+    showValueTicks: boolean;
+    formatTooltipFn: SliderTooltipFormatFn;
+    min: number;
+    max: number;
+    step: number;
+    shiftMultiplier: number;
+    labelPosition: SliderDecorationPosition;
+    labels: SliderLabelObject[] | number[] | null;
+    color: SimpleComponentColor;
+    compact: boolean;
+    tooltipPosition: SliderDecorationPosition;
+    tooltipBehavior: SliderTooltipBehavior;
+    selectionBehavior: ArdRangeSelectionBehavior;
+    minimumDistance: number;
+    emitTouchedOnEveryChange: boolean;
+}
+export declare const _asbtractSliderDefaults: _AsbtractSliderDefaults;
+export declare abstract class _AbstractSlider<T> extends _NgModelComponentBase {
+    abstract readonly componentId: string;
+    abstract readonly componentName: string;
+    protected readonly _DEFAULTS: _AsbtractSliderDefaults;
+    readonly elementRef: Signal<ElementRef<HTMLElement> | undefined>;
+    protected readonly document: Document;
+    protected readonly renderer: Renderer2;
+    protected readonly overlay: Overlay;
+    protected readonly scrollStrategyOpts: ScrollStrategyOptions;
+    protected readonly viewContainerRef: ViewContainerRef;
+    readonly min: import("@angular/core").InputSignalWithTransform<number, NumberLike>;
+    readonly max: import("@angular/core").InputSignalWithTransform<number, NumberLike>;
+    readonly step: import("@angular/core").InputSignalWithTransform<number, NumberLike>;
+    readonly minMaxStepValueCleanup: import("@angular/core").EffectRef;
+    readonly minMaxErrorCheck: import("@angular/core").EffectRef;
+    readonly shiftMultiplier: import("@angular/core").InputSignalWithTransform<number, NumberLike>;
+    protected readonly _stepSizeComputed: Signal<number>;
+    readonly showValueTicks: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    protected readonly _tickArray: Signal<string[]>;
+    private _transformLabelInput;
+    readonly labelPosition: import("@angular/core").InputSignal<SliderDecorationPosition>;
+    readonly labels: import("@angular/core").InputSignalWithTransform<SliderLabelObject[], string | number[] | SliderLabelObject[] | null | undefined>;
+    readonly labelObjects: Signal<_InternalSliderLabelObject[]>;
+    readonly color: import("@angular/core").InputSignal<SimpleComponentColor>;
+    readonly compact: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly ngClasses: Signal<string>;
+    readonly sliderTransition: Signal<string>;
+    private readonly _totalSteps;
+    protected abstract readonly _value: WritableSignal<T>;
+    set value(newValue: T);
+    get value(): T;
+    readonly valueChange: import("@angular/core").OutputEmitterRef<T>;
+    abstract writeValue(v: any): void;
+    abstract cleanupValueAfterMinMaxStepChange(): void;
+    abstract reset(): void;
+    protected _offset(offset: number, hasShift: boolean, handleId?: number): void;
+    protected _decrement(event: KeyboardEvent, forceShift?: boolean): void;
+    protected _increment(event: KeyboardEvent, forceShift?: boolean): void;
+    protected _clampValue(v: number): number;
+    protected _valueToPercent(v: number): number;
+    protected _emitChange(): void;
+    readonly noTooltip: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly tooltipFormatFn: import("@angular/core").InputSignal<SliderTooltipFormatFn>;
+    readonly tooltipTemplate: Signal<ArdSliderTooltipDirective | undefined>;
+    readonly tooltipPosition: import("@angular/core").InputSignal<SliderDecorationPosition>;
+    readonly tooltipBehavior: import("@angular/core").InputSignal<SliderTooltipBehavior>;
+    protected readonly _grabbedHandleId: WritableSignal<number | null>;
+    protected _shouldCheckForMovement: boolean;
+    protected _bodyHasClass: boolean;
+    readonly emitTouchedOnEveryChange: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly isSliderHandleGrabbed: Signal<boolean>;
+    readonly grabbedHandleEffect: import("@angular/core").EffectRef;
+    abstract onTrackHitboxPointerDown(event: MouseEvent | TouchEvent): void;
+    onPointerDownOnHandle(event: MouseEvent | TouchEvent, handleId?: number): void;
+    abstract onPointerMove(event: MouseEvent | TouchEvent): void;
+    onPointerUp(): void;
+    protected abstract readonly _handlePositions: Signal<[number, number]>;
+    readonly handlePositionsPercent: Signal<[string, string]>;
+    protected _setValueFromPercent(percent: number, handleId?: number | null): void;
+    protected _writeValueFromEvent(event: MouseEvent | TouchEvent, handleId?: number | null): void;
+    protected abstract _percentValueToValue(percent: number, handleId?: number): T;
+    protected _getElementRect(): DOMRect;
+    protected _clampPercentValue(percent: number): number;
+    protected _getPercentValueFromEvent(event: MouseEvent | TouchEvent): number;
+    onKeyPress(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_AbstractSlider<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<_AbstractSlider<any>, never, never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "shiftMultiplier": { "alias": "shiftMultiplier"; "required": false; "isSignal": true; }; "showValueTicks": { "alias": "showValueTicks"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; }; "noTooltip": { "alias": "noTooltip"; "required": false; "isSignal": true; }; "tooltipFormatFn": { "alias": "tooltipFormatFn"; "required": false; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "tooltipBehavior": { "alias": "tooltipBehavior"; "required": false; "isSignal": true; }; "emitTouchedOnEveryChange": { "alias": "emitTouchedOnEveryChange"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, ["tooltipTemplate"], never, true, never>;
+}

package/lib/slider/index.d.ts

@@ -0,0 +1,8 @@
+export * from './range-slider/range-slider.component';
+export * from './range-slider/range-slider.module';
+export * from './range-slider/range-slider.types';
+export * from './slider.component';
+export * from './slider.defaults';
+export * from './slider.directive';
+export * from './slider.module';
+export * from './slider.types';

package/lib/slider/range-slider/range-slider.component.d.ts

@@ -0,0 +1,37 @@
+import { OnInit } from '@angular/core';
+import { NumberLike } from '@ardium-ui/devkit';
+import { _AbstractSlider } from '../abstract-slider';
+import { ArdSliderDefaults } from '../slider.defaults';
+import { SliderRange, SliderTooltipContext } from '../slider.types';
+import { ArdRangeSelectionBehavior } from './range-slider.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumRangeSliderComponent extends _AbstractSlider<SliderRange> implements OnInit {
+    readonly componentId = "106";
+    readonly componentName = "range-slider";
+    protected readonly _DEFAULTS: ArdSliderDefaults;
+    constructor(defaults: ArdSliderDefaults);
+    protected readonly _value: import("@angular/core").WritableSignal<SliderRange<number>>;
+    private _isValidObject;
+    private _isValidTuple;
+    private _normalizeSliderRange;
+    writeValue(v: any): void;
+    get value(): SliderRange;
+    set value(v: any);
+    cleanupValueAfterMinMaxStepChange(): void;
+    readonly selectionBehavior: import("@angular/core").InputSignal<ArdRangeSelectionBehavior>;
+    readonly minimumDistance: import("@angular/core").InputSignalWithTransform<number, NumberLike>;
+    protected readonly _tooltipValue: import("@angular/core").Signal<SliderRange<string>>;
+    readonly tooltipContexts: import("@angular/core").Signal<SliderRange<SliderTooltipContext>>;
+    reset(): void;
+    readonly trackOverlayLeft: import("@angular/core").Signal<string>;
+    readonly trackOverlayWidth: import("@angular/core").Signal<string>;
+    onTrackHitboxPointerDown(event: MouseEvent | TouchEvent): void;
+    onPointerMove(event: MouseEvent | TouchEvent): void;
+    protected _percentValueToValue(percent: number, handleId: number): SliderRange;
+    protected readonly _handlePositions: import("@angular/core").Signal<[number, number]>;
+    readonly currentHandle: import("@angular/core").WritableSignal<1 | 2 | null>;
+    onHandleFocus(event: FocusEvent, handleId: 1 | 2): void;
+    onBlur(event: FocusEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumRangeSliderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumRangeSliderComponent, "ard-range-slider", never, { "selectionBehavior": { "alias": "selectionBehavior"; "required": false; "isSignal": true; }; "minimumDistance": { "alias": "minimumDistance"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}

package/lib/slider/range-slider/range-slider.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./range-slider.component";
+import * as i2 from "@angular/common";
+export declare class ArdiumRangeSliderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumRangeSliderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArdiumRangeSliderModule, [typeof i1.ArdiumRangeSliderComponent], [typeof i2.CommonModule], [typeof i1.ArdiumRangeSliderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArdiumRangeSliderModule>;
+}

package/lib/slider/range-slider/range-slider.types.d.ts

@@ -0,0 +1,6 @@
+export declare const ArdRangeSelectionBehavior: {
+    readonly Push: "push";
+    readonly Allow: "allow";
+    readonly Block: "block";
+};
+export type ArdRangeSelectionBehavior = typeof ArdRangeSelectionBehavior[keyof typeof ArdRangeSelectionBehavior];

package/lib/slider/slider.component.d.ts

@@ -0,0 +1,24 @@
+import { _AbstractSlider } from './abstract-slider';
+import { ArdSliderDefaults } from './slider.defaults';
+import { SliderTooltipContext } from './slider.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumSliderComponent extends _AbstractSlider<number> {
+    readonly componentId = "105";
+    readonly componentName = "slider";
+    protected readonly _DEFAULTS: ArdSliderDefaults;
+    constructor(defaults: ArdSliderDefaults);
+    protected readonly _value: import("@angular/core").WritableSignal<number>;
+    protected readonly _tooltipValue: import("@angular/core").Signal<string>;
+    readonly tooltipContext: import("@angular/core").Signal<SliderTooltipContext>;
+    writeValue(v: any): void;
+    cleanupValueAfterMinMaxStepChange(): void;
+    reset(): void;
+    increment(steps?: number): void;
+    decrement(steps?: number): void;
+    onTrackHitboxPointerDown(event: MouseEvent | TouchEvent): void;
+    onPointerMove(event: MouseEvent | TouchEvent): void;
+    protected _percentValueToValue(percent: number): number;
+    protected readonly _handlePositions: import("@angular/core").Signal<[number, number]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumSliderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumSliderComponent, "ard-slider", never, {}, {}, never, never, false, never>;
+}

package/lib/slider/slider.defaults.d.ts

@@ -0,0 +1,6 @@
+import { InjectionToken, Provider } from '@angular/core';
+import { _AsbtractSliderDefaults } from './abstract-slider';
+export interface ArdSliderDefaults extends _AsbtractSliderDefaults {
+}
+export declare const ARD_SLIDER_DEFAULTS: InjectionToken<ArdSliderDefaults>;
+export declare function provideSliderDefaults(config: Partial<ArdSliderDefaults>): Provider;

package/lib/slider/slider.directive.d.ts

@@ -0,0 +1,9 @@
+import { TemplateRef } from '@angular/core';
+import { SliderTooltipContext } from './slider.types';
+import * as i0 from "@angular/core";
+export declare class ArdSliderTooltipDirective {
+    template: TemplateRef<SliderTooltipContext>;
+    constructor(template: TemplateRef<SliderTooltipContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdSliderTooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdSliderTooltipDirective, "ng-template[ard-slider-tooltip-tmp]", never, {}, {}, never, never, false, never>;
+}

package/lib/slider/slider.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./slider.component";
+import * as i2 from "./slider.directive";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/cdk/overlay";
+export declare class ArdiumSliderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumSliderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArdiumSliderModule, [typeof i1.ArdiumSliderComponent, typeof i2.ArdSliderTooltipDirective], [typeof i3.CommonModule, typeof i4.OverlayModule], [typeof i1.ArdiumSliderComponent, typeof i2.ArdSliderTooltipDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArdiumSliderModule>;
+}

package/lib/slider/slider.types.d.ts

@@ -0,0 +1,28 @@
+export interface SliderTooltipContext {
+    value: string | number;
+    $implicit: string | number;
+}
+export declare const SliderTooltipBehavior: {
+    readonly Always: "always";
+    readonly Auto: "auto";
+    readonly Never: "never";
+};
+export type SliderTooltipBehavior = (typeof SliderTooltipBehavior)[keyof typeof SliderTooltipBehavior];
+export declare const SliderDecorationPosition: {
+    readonly Top: "top";
+    readonly Bottom: "bottom";
+};
+export type SliderDecorationPosition = (typeof SliderDecorationPosition)[keyof typeof SliderDecorationPosition];
+export interface SliderLabelObject {
+    label: string | number;
+    value: number;
+}
+export interface _InternalSliderLabelObject {
+    label: string;
+    positionPercent: string;
+}
+export interface SliderRange<T = number> {
+    from: T;
+    to: T;
+}
+export type SliderTooltipFormatFn = (value: number) => string | number;

package/lib/snackbar/index.d.ts

@@ -0,0 +1,4 @@
+export * from './snackbar.service';
+export * from './snackbar.token';
+export * from './snackbar.types';
+export { ArdSnackbarRef, ARD_SNACKBAR_DATA } from './snackbar-ref';

package/lib/snackbar/snackbar-ref.d.ts

@@ -0,0 +1,69 @@
+import { OverlayRef } from '@angular/cdk/overlay';
+import { ComponentType } from '@angular/cdk/portal';
+import { InjectionToken } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { ComponentColor } from '../types/colors.types';
+import { ArdSnackbarData, ArdSnackbarOptions, ArdSnackbarType } from './snackbar.types';
+export declare const ARD_SNACKBAR_DATA: InjectionToken<ArdSnackbarData>;
+export declare const ARD_SNACKBAR_COLOR: InjectionToken<ComponentColor>;
+export declare const ARD_SNACKBAR_TYPE: InjectionToken<ArdSnackbarType>;
+export declare class _ArdSnackbarRefInternal<T> {
+    component: ComponentType<T>;
+    options: Required<ArdSnackbarOptions>;
+    constructor(component: ComponentType<T>, options: Required<ArdSnackbarOptions>, dismiss: (withAction?: boolean) => void);
+    readonly publicRef: ArdSnackbarRef<T>;
+    timeout: any;
+    overlay: OverlayRef;
+    private readonly _onOpen;
+    private readonly _onCloseStart;
+    markAsOpened(): void;
+    markAsStartingToClose(withAction?: boolean): void;
+}
+/**
+ * Reference to an opened snackbar.
+ * Provides methods for closing the snackbar programmatically, and observables for subscribing to open, close, and action events.
+ */
+export declare class ArdSnackbarRef<T = unknown> {
+    private readonly dismiss;
+    private readonly _onOpen;
+    private readonly _onCloseStart;
+    constructor(dismiss: (withAction?: boolean) => void, _onOpen: Subject<void>, _onCloseStart: BehaviorSubject<boolean>);
+    private readonly _onClose;
+    private readonly _onAction;
+    /**
+     * Observable that emits when the snackbar is opened. Completes after emitting the first value.
+     */
+    readonly onOpen: import("rxjs").Observable<void>;
+    /**
+     * Observable that emits when the snackbar is closed and all animations have finished. Emits a boolean value indicating whether the snackbar was closed as a result of the user clicking the action button (true) or not (false). Completes after emitting the first value.
+     */
+    readonly onClose: import("rxjs").Observable<boolean>;
+    /**
+     * Observable that emits when the snackbar action is triggered, before the snackbar starts closing. Completes when the snackbar is closed, regardless of whether any value was emitted.
+     */
+    readonly onAction: import("rxjs").Observable<void>;
+    /**
+     * Observable that emits when the snackbar starts the closing process. Emits a boolean value indicating whether the closing was triggered by the user clicking the action button (true) or not (false). Completes after emitting the first value.
+     */
+    readonly onCloseStart: import("rxjs").Observable<boolean>;
+    /**
+     * The instance of the component rendered inside the snackbar.
+     */
+    readonly instance: T;
+    /**
+     * Closes the snackbar, optionally indicating that the action was triggered.
+     * @param withAction A boolean value indicating whether the snackbar is being closed as a result of the user clicking the action button (true) or not (false).
+     */
+    close(withAction?: boolean): void;
+    /**
+     * Marks the snackbar as closed after the closing animation has finished.
+     * @param withAction
+     * @returns
+     */
+    markAsClosed(withAction?: boolean): void;
+    private _isClosed;
+    /**
+     * Indicates whether the snackbar has been closed and the closing animation has finished.
+     */
+    get isClosed(): boolean;
+}

package/lib/snackbar/snackbar.component.d.ts

@@ -0,0 +1,16 @@
+import { ArdSnackbarRef } from './snackbar-ref';
+import { ArdSnackbarType } from './snackbar.types';
+import * as i0 from "@angular/core";
+export declare class _ArdSimpleSnackbarComponent {
+    readonly snackbarRef: ArdSnackbarRef<any>;
+    readonly data: import("./snackbar.types").ArdSnackbarData;
+    readonly color: import("@ardium-pl/ui").ComponentColor;
+    readonly type: ArdSnackbarType;
+    readonly typeIcon: string | null;
+    closeWithAction(): void;
+    get hasAction(): boolean;
+    private _getTypeIcon;
+    get colorClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_ArdSimpleSnackbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<_ArdSimpleSnackbarComponent, "ard-simple-snackbar", never, {}, {}, never, never, true, never>;
+}

package/lib/snackbar/snackbar.service.d.ts

@@ -0,0 +1,57 @@
+import { ComponentType } from '@angular/cdk/overlay';
+import { OnDestroy } from '@angular/core';
+import { ArdSnackbarRef } from './snackbar-ref';
+import { _ArdSimpleSnackbarComponent } from './snackbar.component';
+import { ArdSnackbarOptions } from './snackbar.types';
+import * as i0 from "@angular/core";
+/**
+ * Service for opening snackbars. Provides methods for opening snackbars with either a simple message and action, or with a custom component. Manages a queue of snackbars to be displayed, and handles the display and dismissal of snackbars according to the specified options. Also provides methods for retrieving and clearing the snackbar queue.
+ */
+export declare class ArdiumSnackbarService implements OnDestroy {
+    private readonly _snackbarQueue;
+    private _openedSnackbar?;
+    private readonly _DEFAULTS;
+    private readonly _animationLength;
+    private readonly _overlay;
+    private readonly _injector;
+    /**
+     * Opens a snackbar with the given message, action and options.
+     * @param message The message to display in the snackbar.
+     * @param action The label for the snackbar action. If provided, the snackbar will have an action button with this label.
+     *               When the action button is clicked, the snackbar will emit a close event with `withAction` set to `true`.
+     * @param options Additional options for configuring the snackbar.
+     * @returns A reference to the opened snackbar.
+     */
+    open(message: string, action?: string, options?: ArdSnackbarOptions): ArdSnackbarRef<_ArdSimpleSnackbarComponent>;
+    /**
+     * Opens a snackbar with a custom component, passing the given options.
+     * @param component The component to display inside the snackbar. This component will be instantiated and inserted into the snackbar overlay.
+     * @param options Additional options for configuring the snackbar, such as data to pass to the component, placement, styling, etc.
+     * @returns A reference to the opened snackbar, with the generic type of the component instance. You can use this reference to subscribe to open/close events, and to close the snackbar programmatically.
+     */
+    openFromComponent<T>(component: ComponentType<T>, options: ArdSnackbarOptions): ArdSnackbarRef<T>;
+    private _handleQueue;
+    private _mergeOptions;
+    private _openNext;
+    private _createOverlay;
+    /**
+     * Dismisses the currently opened snackbar, if any. If `withAction` is true, it indicates that the snackbar is being dismissed as a result of the user clicking the action button (if it has one). This will cause the snackbar to emit a close event with `withAction` set to true, allowing you to differentiate between automatic dismissal and user-initiated dismissal via the action button.
+     * @param withAction Optional boolean indicating whether the dismissal is due to the user clicking the action button. Defaults to false. If true, the snackbar's close event will emit with `withAction` set to true, allowing you to handle this case differently if needed.
+     */
+    dismissCurrent(withAction?: boolean): void;
+    /**
+     * Returns an array of references to the snackbars currently in the queue, in the order they will be opened. Note that this does not include the currently opened snackbar, if any.
+     */
+    getQueue(): ArdSnackbarRef<unknown>[];
+    /**
+     * Clears all pending snackbars from the queue. Does not affect the currently opened snackbar, if any. Use with caution, as this will remove all pending snackbars that have not yet been displayed, and they will not be shown at all.
+     */
+    clearQueue(): void;
+    /**
+     * @deprecated Internal implementation detail, do not use directly.
+     */
+    ngOnDestroy(): void;
+    private _createInjector;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumSnackbarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ArdiumSnackbarService>;
+}

package/lib/snackbar/snackbar.token.d.ts

@@ -0,0 +1,5 @@
+import { InjectionToken, Provider } from '@angular/core';
+import { ArdSnackbarOptions } from './snackbar.types';
+export declare const ARD_SNACKBAR_DEFAULTS: InjectionToken<Required<ArdSnackbarOptions>>;
+export declare function provideSnackbarDefaults(config: Partial<ArdSnackbarOptions>): Provider;
+export declare const ARD_SNACKBAR_ANIMATION_LENGTH: InjectionToken<number>;

package/lib/snackbar/snackbar.types.d.ts

@@ -0,0 +1,84 @@
+import { ElementRef } from '@angular/core';
+import { ComponentColor } from '../types/colors.types';
+export declare const ArdSnackbarAlignment: {
+    readonly TopLeft: "top-left";
+    readonly TopCenter: "top-center";
+    readonly TopRight: "top-right";
+    readonly BottomLeft: "bottom-left";
+    readonly BottomCenter: "bottom-center";
+    readonly BottomRight: "bottom-right";
+};
+export type ArdSnackbarAlignment = (typeof ArdSnackbarAlignment)[keyof typeof ArdSnackbarAlignment];
+export declare const ArdSnackbarOriginRelation: {
+    readonly Inside: "inside";
+    readonly Outside: "outside";
+};
+export type ArdSnackbarOriginRelation = (typeof ArdSnackbarOriginRelation)[keyof typeof ArdSnackbarOriginRelation];
+export declare const ArdSnackbarQueueHandling: {
+    readonly Default: "default";
+    readonly Skip: "skip";
+    readonly Overwrite: "overwrite";
+};
+export type ArdSnackbarQueueHandling = (typeof ArdSnackbarQueueHandling)[keyof typeof ArdSnackbarQueueHandling];
+export type ArdSnackbarOrigin<T = any> = HTMLElement | ElementRef<T>;
+export declare const ArdSnackbarType: {
+    readonly None: "none";
+    readonly Danger: "danger";
+    readonly Warning: "warn";
+    readonly Success: "success";
+    readonly Info: "info";
+};
+export type ArdSnackbarType = (typeof ArdSnackbarType)[keyof typeof ArdSnackbarType];
+export interface ArdSnackbarData {
+    message: string;
+    action?: string;
+}
+/**
+ * Options for configuring the behavior and appearance of a snackbar.
+ */
+export interface ArdSnackbarOptions {
+    /**
+     * Message and action text data to be passed to the snackbar component
+     */
+    data?: ArdSnackbarData;
+    /**
+     * Placement options for the snackbar. If not provided, the snackbar will be centered at the bottom of the screen.
+     */
+    placement?: {
+        /**
+         * The alignment of the snackbar in relation to the origin element. If not provided, it will default to 'bottom-center'.
+         */
+        align?: ArdSnackbarAlignment;
+        /**
+         * The origin element to which the snackbar is attached. If not provided, it will default to 'document.body'.
+         */
+        origin?: ArdSnackbarOrigin;
+        /**
+         * The relation of the snackbar to the origin element. If not provided, it will default to 'outside'.
+         */
+        originRelation?: ArdSnackbarOriginRelation;
+    };
+    /**
+     * Duration in milliseconds for which the snackbar should be visible. If not provided, it will default to 3000ms. Set to `Infinity` for a persistent snackbar that must be dismissed manually.
+     */
+    duration?: number;
+    /**
+     * Color of the snackbar. This will apply a corresponding color class to the snackbar element, which can be used to style the snackbar based on the chosen color. If not provided, it will default to 'primary'.
+     */
+    color?: ComponentColor;
+    /**
+     * Type of the snackbar, which can be used to apply specific styles or icons based on the type. If not provided, it will default to 'none'.
+     */
+    type?: ArdSnackbarType;
+    /**
+     * Defines how the snackbar should behave when there are multiple snackbars in the queue. If not provided, it will default to 'default'.
+     * - 'default': New snackbars will be added to the end of the queue and displayed after the currently opened snackbar is dismissed.
+     * - 'skip': The new snackbar will be added to the start of the queue and displayed after the current snackbar is dismissed.
+     * - 'overwrite': If there is already an opened snackbar, it will be immediately dismissed and replaced with the new snackbar.
+     */
+    queueHandling?: ArdSnackbarQueueHandling;
+    /**
+     * Additional CSS class or classes to apply to the snackbar panel.
+     */
+    panelClass?: string | string[];
+}

package/lib/spinner/index.d.ts

@@ -0,0 +1,3 @@
+export * from './spinner.component';
+export * from './spinner.defaults';
+export * from './spinner.module';

package/lib/spinner/spinner.component.d.ts

@@ -0,0 +1,9 @@
+import { SimpleComponentColor } from '../types/colors.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumSpinnerComponent {
+    protected readonly _DEFAULTS: import("./spinner.defaults").ArdSpinnerDefaults;
+    readonly color: import("@angular/core").InputSignal<SimpleComponentColor>;
+    readonly ngClasses: import("@angular/core").Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumSpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumSpinnerComponent, "ard-spinner", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}

package/lib/spinner/spinner.defaults.d.ts

@@ -0,0 +1,7 @@
+import { InjectionToken, Provider } from '@angular/core';
+import { SimpleComponentColor } from './../types/colors.types';
+export interface ArdSpinnerDefaults {
+    color: SimpleComponentColor;
+}
+export declare const ARD_SPINNER_DEFAULTS: InjectionToken<ArdSpinnerDefaults>;
+export declare function provideSpinnerDefaults(config: Partial<ArdSpinnerDefaults>): Provider;

package/lib/spinner/spinner.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./spinner.component";
+import * as i2 from "@angular/common";
+export declare class ArdiumSpinnerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumSpinnerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArdiumSpinnerModule, [typeof i1.ArdiumSpinnerComponent], [typeof i2.CommonModule], [typeof i1.ArdiumSpinnerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArdiumSpinnerModule>;
+}

package/lib/stack/index.d.ts

@@ -0,0 +1,3 @@
+export * from './stack.component';
+export * from './stack.defaults';
+export * from './stack.module';

package/lib/stack/stack.component.d.ts

@@ -0,0 +1,26 @@
+import { ArdBreakpointsConfig } from '../breakpoints/breakpoints';
+import { ArdGridAlign, ArdGridDirection, ArdGridJustify, ArdGridWrap } from '../grid';
+import * as i0 from "@angular/core";
+export declare class ArdiumStackComponent {
+    private readonly _componentId;
+    protected readonly _DEFAULTS: import("./stack.defaults").ArdStackDefaults;
+    private readonly _breakpointService;
+    readonly direction: import("@angular/core").InputSignalWithTransform<Required<ArdBreakpointsConfig<ArdGridDirection>>, string | ArdBreakpointsConfig<ArdGridDirection>>;
+    readonly justifyContent: import("@angular/core").InputSignalWithTransform<Required<ArdBreakpointsConfig<ArdGridJustify>>, string | ArdBreakpointsConfig<ArdGridJustify>>;
+    readonly alignItems: import("@angular/core").InputSignalWithTransform<Required<ArdBreakpointsConfig<ArdGridAlign>>, string | ArdBreakpointsConfig<ArdGridAlign>>;
+    readonly spacing: import("@angular/core").InputSignalWithTransform<Required<ArdBreakpointsConfig<string | number>>, string | number | ArdBreakpointsConfig<string | number>>;
+    readonly columnSpacing: import("@angular/core").InputSignalWithTransform<ArdBreakpointsConfig<string | number> | null, string | number | ArdBreakpointsConfig<string | number> | null>;
+    readonly rowSpacing: import("@angular/core").InputSignalWithTransform<ArdBreakpointsConfig<string | number> | null, string | number | ArdBreakpointsConfig<string | number> | null>;
+    readonly wrap: import("@angular/core").InputSignalWithTransform<Required<ArdBreakpointsConfig<ArdGridWrap>>, string | ArdBreakpointsConfig<ArdGridWrap>>;
+    readonly finalColumnSpacing: import("@angular/core").Signal<ArdBreakpointsConfig<string | number>>;
+    readonly finalRowSpacing: import("@angular/core").Signal<ArdBreakpointsConfig<string | number>>;
+    readonly currentDirection: import("@angular/core").Signal<ArdGridDirection | undefined>;
+    readonly currentJustifyContent: import("@angular/core").Signal<ArdGridJustify | undefined>;
+    readonly currentAlignItems: import("@angular/core").Signal<ArdGridAlign | undefined>;
+    readonly currentColumnSpacing: import("@angular/core").Signal<string | number | undefined>;
+    readonly currentRowSpacing: import("@angular/core").Signal<string | number | undefined>;
+    readonly currentWrap: import("@angular/core").Signal<ArdGridWrap | undefined>;
+    readonly currentStyle: import("@angular/core").Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumStackComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumStackComponent, "ard-stack", never, { "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "justifyContent": { "alias": "justifyContent"; "required": false; "isSignal": true; }; "alignItems": { "alias": "alignItems"; "required": false; "isSignal": true; }; "spacing": { "alias": "spacing"; "required": false; "isSignal": true; }; "columnSpacing": { "alias": "columnSpacing"; "required": false; "isSignal": true; }; "rowSpacing": { "alias": "rowSpacing"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
+}

package/lib/stack/stack.defaults.d.ts

@@ -0,0 +1,14 @@
+import { InjectionToken, Provider } from '@angular/core';
+import { ArdBreakpointsConfig } from '../breakpoints';
+import { ArdGridAlign, ArdGridDirection, ArdGridJustify, ArdGridWrap } from '../grid';
+export interface ArdStackDefaults {
+    direction: ArdGridDirection | ArdBreakpointsConfig<ArdGridDirection>;
+    justifyContent: ArdGridJustify | ArdBreakpointsConfig<ArdGridJustify>;
+    alignItems: ArdGridAlign | ArdBreakpointsConfig<ArdGridAlign>;
+    spacing: number | string | ArdBreakpointsConfig<number | string>;
+    columnSpacing: null | number | string | ArdBreakpointsConfig<number | string>;
+    rowSpacing: null | number | string | ArdBreakpointsConfig<number | string>;
+    wrap: ArdGridWrap | ArdBreakpointsConfig<ArdGridWrap>;
+}
+export declare const ARD_STACK_DEFAULTS: InjectionToken<ArdStackDefaults>;
+export declare function provideStackDefaults(config: Partial<ArdStackDefaults>): Provider;

package/lib/stack/stack.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./stack.component";
+export declare class ArdiumStackModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumStackModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArdiumStackModule, [typeof i1.ArdiumStackComponent], never, [typeof i1.ArdiumStackComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArdiumStackModule>;
+}

package/lib/star/index.d.ts

@@ -0,0 +1,5 @@
+export * from './star.component';
+export * from './star.defaults';
+export * from './star.directives';
+export * from './star.module';
+export * from './star.types';

package/lib/star/rating-display/index.d.ts

@@ -0,0 +1,5 @@
+export * from './rating-display.component';
+export * from './rating-display.defaults';
+export * from './rating-display.directives';
+export * from './rating-display.module';
+export * from './rating-display.types';

package/lib/star/rating-display/rating-display.component.d.ts

@@ -0,0 +1,18 @@
+import { NumberLike } from '@ardium-ui/devkit';
+import { StarColor, StarFillMode } from './../star.types';
+import { ArdRatingDisplayStarTemplateDirective } from './rating-display.directives';
+import { ArdRatingDisplayStarTemplateContext } from './rating-display.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumRatingDisplayComponent {
+    readonly wrapperClasses: import("@angular/core").InputSignal<string>;
+    protected readonly _DEFAULTS: import("./rating-display.defaults").ArdRatingDisplayDefaults;
+    readonly color: import("@angular/core").InputSignal<StarColor>;
+    readonly ngClasses: import("@angular/core").Signal<string>;
+    readonly max: import("@angular/core").InputSignalWithTransform<number, NumberLike>;
+    readonly value: import("@angular/core").InputSignalWithTransform<number | StarFillMode[], string | number | StarFillMode[]>;
+    readonly starArray: import("@angular/core").Signal<StarFillMode[]>;
+    readonly starTemplate: import("@angular/core").Signal<ArdRatingDisplayStarTemplateDirective | undefined>;
+    readonly getStarTemplateContext: import("@angular/core").Signal<(fillMode: StarFillMode, index: number) => ArdRatingDisplayStarTemplateContext>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumRatingDisplayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumRatingDisplayComponent, "ard-rating-display", never, { "wrapperClasses": { "alias": "wrapperClasses"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, ["starTemplate"], never, false, never>;
+}