@ardium-ui/ui 1.0.0

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 type 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 type SliderLabelObject = {
+    label: string | number;
+    for: number;
+};
+export type _InternalSliderLabelObject = {
+    label: string;
+    positionPercent: string;
+};
+export type SliderRange<T = number> = {
+    low: T;
+    high: 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,37 @@
+/// <reference types="node" />
+import { ComponentType } from '@angular/cdk/portal';
+import { InjectionToken } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { ArdSnackbarData, ArdSnackbarOptions, ArdSnackbarType } from './snackbar.types';
+import { OverlayRef } from '@angular/cdk/overlay';
+import { ComponentColor } from '../types/colors.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: NodeJS.Timeout;
+    overlay: OverlayRef;
+    private readonly _onOpen;
+    private readonly _onCloseStart;
+    markAsOpened(): void;
+    markAsStartingToClose(): void;
+}
+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;
+    readonly onOpen: import("rxjs").Observable<void>;
+    readonly onClose: import("rxjs").Observable<boolean>;
+    readonly onCloseStart: import("rxjs").Observable<boolean>;
+    instance: T;
+    close(withAction?: boolean): void;
+    markAsClosed(withAction?: boolean): void;
+    private _isClosed;
+    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 _ArdSimpleSnackbar {
+    readonly snackbarRef: ArdSnackbarRef<any>;
+    readonly data: import("./snackbar.types").ArdSnackbarData;
+    readonly color: import("@ardium-ui/ui").ComponentColor;
+    readonly type: ArdSnackbarType;
+    readonly typeIcon: string | null;
+    closeWithAction(): void;
+    get hasAction(): boolean;
+    private _getTypeIcon;
+    get colorClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_ArdSimpleSnackbar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<_ArdSimpleSnackbar, "_ard-simple-snackbar", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,31 @@
+import { ComponentType } from '@angular/cdk/overlay';
+import { OnDestroy } from '@angular/core';
+import { ArdSnackbarRef } from './snackbar-ref';
+import { _ArdSimpleSnackbar } from './snackbar.component';
+import { ArdSnackbarOptions } from './snackbar.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumSnackbarService implements OnDestroy {
+    private readonly _snackbarQueue;
+    private _openedSnackbar?;
+    private readonly _defaultOptionsStatic;
+    private readonly _defaultOptions;
+    private readonly _animationLength;
+    private readonly _overlay;
+    private readonly _injector;
+    open(message: string, action?: string, options?: ArdSnackbarOptions): ArdSnackbarRef<_ArdSimpleSnackbar>;
+    openFromComponent<T>(component: ComponentType<T>, options: ArdSnackbarOptions): ArdSnackbarRef<T>;
+    private _handleQueue;
+    private _mergeOptions;
+    private _openNext;
+    private _createOverlay;
+    dismissCurrent(withAction?: boolean): void;
+    getQueue(): ArdSnackbarRef<unknown>[];
+    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 } from '@angular/core';
+import { ArdSnackbarOptions } from './snackbar.types';
+export declare const _DEFAULT_OPTIONS_STATIC: Required<ArdSnackbarOptions>;
+export declare const ARD_SNACKBAR_DEFAULT_OPTIONS: InjectionToken<Required<ArdSnackbarOptions>>;
+export declare const ARD_SNACKBAR_ANIMATION_LENGTH: InjectionToken<number>;

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

@@ -0,0 +1,48 @@
+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 type ArdSnackbarData = {
+    message: string;
+    action?: string;
+};
+export type ArdSnackbarOptions = {
+    data?: ArdSnackbarData;
+    placement?: {
+        align?: ArdSnackbarAlignment;
+        origin?: ArdSnackbarOrigin;
+        originRelation?: ArdSnackbarOriginRelation;
+    };
+    duration?: number;
+    color?: ComponentColor;
+    type?: ArdSnackbarType;
+    queueHandling?: ArdSnackbarQueueHandling;
+    panelClass?: string | string[];
+};

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

@@ -0,0 +1,8 @@
+import { SimpleComponentColor } from '../types/colors.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumSpinnerComponent {
+    color: SimpleComponentColor;
+    get ngClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumSpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumSpinnerComponent, "ard-spinner", never, { "color": { "alias": "color"; "required": false; }; }, {}, never, never, false, never>;
+}

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/star/star-button/star-button.component.d.ts

@@ -0,0 +1,16 @@
+import { ControlValueAccessor } from '@angular/forms';
+import { ClickStrategy } from '../../types/utility.types';
+import { _BooleanComponentBase } from '../../_internal/boolean-component';
+import { StarColor } from '../star.types';
+import { StarFillMode } from './../star.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumStarButtonComponent extends _BooleanComponentBase implements ControlValueAccessor {
+    wrapperClasses: string;
+    clickStrategy: ClickStrategy;
+    color: StarColor;
+    get ngClasses(): string;
+    get starFillState(): StarFillMode;
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumStarButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumStarButtonComponent, "ard-star-button", never, { "wrapperClasses": { "alias": "wrapperClasses"; "required": false; }; "clickStrategy": { "alias": "clickStrategy"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/star/star-button/star-button.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./star-button.component";
+import * as i2 from "@angular/common";
+import * as i3 from "../star.module";
+export declare class ArdiumStarButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumStarButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArdiumStarButtonModule, [typeof i1.ArdiumStarButtonComponent], [typeof i2.CommonModule, typeof i3.ArdiumStarModule], [typeof i1.ArdiumStarButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArdiumStarButtonModule>;
+}

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

@@ -0,0 +1,16 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import { StarColor, StarFillMode } from './../star.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumStarDisplayComponent implements OnChanges {
+    wrapperClasses: string;
+    color: StarColor;
+    get ngClasses(): string;
+    starArray: StarFillMode[];
+    max: number;
+    value: number | StarFillMode[];
+    setStarArrayFromArray(starArr: StarFillMode[]): void;
+    setStarArrayFromNumber(stars: number): StarFillMode[];
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumStarDisplayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumStarDisplayComponent, "ard-star-display", never, { "wrapperClasses": { "alias": "wrapperClasses"; "required": false; }; "color": { "alias": "color"; "required": false; }; "max": { "alias": "max"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/star/star-display/star-display.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./star-display.component";
+import * as i2 from "@angular/common";
+import * as i3 from "../star.module";
+export declare class ArdiumStarDisplayModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumStarDisplayModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArdiumStarDisplayModule, [typeof i1.ArdiumStarDisplayComponent], [typeof i2.CommonModule, typeof i3.ArdiumStarModule], [typeof i1.ArdiumStarDisplayComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArdiumStarDisplayModule>;
+}

package/lib/star/star-input/star-input.component.d.ts

@@ -0,0 +1,51 @@
+import { EventEmitter, OnChanges, SimpleChanges, QueryList } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { ArdiumStarButtonComponent } from '../star-button/star-button.component';
+import { _NgModelComponentBase } from './../../_internal/ngmodel-component';
+import { StarColor } from './../star.types';
+import * as i0 from "@angular/core";
+type StarInputObject = {
+    filled: boolean;
+    isInValue: boolean;
+};
+export declare class ArdiumStarInputComponent extends _NgModelComponentBase implements OnChanges, ControlValueAccessor {
+    wrapperClasses: string;
+    color: StarColor;
+    get ngClasses(): string;
+    starButtonInstances: QueryList<ArdiumStarButtonComponent>;
+    changeEvent: EventEmitter<number>;
+    highlightEvent: EventEmitter<number>;
+    value: number;
+    valueChange: EventEmitter<number>;
+    max: number;
+    starArray: StarInputObject[];
+    setStarArrayFromNumber(targetIndex: number): void;
+    createFirstStarArray(): StarInputObject[];
+    ngOnChanges(changes: SimpleChanges): void;
+    writeValue(v: number): void;
+    onStarClick(index: number): void;
+    private _currentHoverIndex;
+    onStarHighlight(index: number): void;
+    setDisplayToValue(): void;
+    protected _emitChange(): void;
+    private _isFocusEventSuppressed;
+    private _isBlurEventSuppressed;
+    private _wasComponentBlurred;
+    private _currentFocusIndex;
+    onStarButtonFocus(index: number): void;
+    onStarButtonBlur(): void;
+    focusStarButtonByIndex(index: number): void;
+    focusNextStarButton(offset: number): void;
+    private _suppressFocusEvents;
+    focus(): void;
+    blur(): void;
+    onKeyPress(event: KeyboardEvent): void;
+    private _onArrowRightPress;
+    private _onArrowLeftPress;
+    private _onHomePress;
+    private _onEndPress;
+    private _onTabPress;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumStarInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumStarInputComponent, "ard-star-input", never, { "wrapperClasses": { "alias": "wrapperClasses"; "required": false; }; "color": { "alias": "color"; "required": false; }; "value": { "alias": "value"; "required": false; }; "max": { "alias": "max"; "required": false; }; }, { "changeEvent": "change"; "highlightEvent": "highlight"; "valueChange": "valueChange"; }, never, never, false, never>;
+}
+export {};

package/lib/star/star-input/star-input.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./star-input.component";
+import * as i2 from "@angular/common";
+import * as i3 from "../star-button/star-button.module";
+export declare class ArdiumStarInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumStarInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArdiumStarInputModule, [typeof i1.ArdiumStarInputComponent], [typeof i2.CommonModule, typeof i3.ArdiumStarButtonModule], [typeof i1.ArdiumStarInputComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArdiumStarInputModule>;
+}

package/lib/star/star.component.d.ts

@@ -0,0 +1,10 @@
+import { StarColor, StarFillMode } from './star.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumStarComponent {
+    wrapperClasses: string;
+    fill: StarFillMode;
+    color: StarColor;
+    get ngClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumStarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumStarComponent, "ard-star", never, { "wrapperClasses": { "alias": "wrapperClasses"; "required": false; }; "fill": { "alias": "fill"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/star/star.module.d.ts

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

package/lib/star/star.types.d.ts

@@ -0,0 +1,30 @@
+export declare const StarFillMode: {
+    /**
+     * The star is not filled, just an outline.
+     */
+    readonly None: "none";
+    /**
+     * Half of the star is filled.
+     */
+    readonly Half: "half";
+    /**
+     * The star is fully filled.
+     */
+    readonly Filled: "filled";
+};
+export type StarFillMode = (typeof StarFillMode)[keyof typeof StarFillMode];
+export declare const StarColor: {
+    /**
+     * THe app's color set for all stars. Usually gold or yellow-gold.
+     */
+    readonly Star: "star";
+    readonly CurrentColor: "currentColor";
+    readonly None: "none";
+    readonly Primary: "primary";
+    readonly Secondary: "secondary";
+    readonly Warning: "warn";
+    readonly Danger: "danger";
+    readonly Success: "success";
+    readonly Info: "info";
+};
+export type StarColor = (typeof StarColor)[keyof typeof StarColor];

package/lib/statebox/statebox.component.d.ts

@@ -0,0 +1,31 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { _NgModelComponentBase } from './../_internal/ngmodel-component';
+import { StateboxState, StateboxValue, _StateboxInternalState } from './statebox.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumStateboxComponent extends _NgModelComponentBase implements ControlValueAccessor, OnChanges {
+    _states: _StateboxInternalState[];
+    states?: StateboxState[];
+    manualStateHandling: boolean;
+    wrapperClasses: string;
+    get ngClasses(): string;
+    changeEvent: EventEmitter<StateboxValue>;
+    clickEvent: EventEmitter<MouseEvent>;
+    private _state;
+    private _stateIndex;
+    set state(v: StateboxValue);
+    get state(): StateboxValue;
+    stateChange: EventEmitter<StateboxValue>;
+    writeValue(v: StateboxValue): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private _stateMapFn;
+    get defaultState(): _StateboxInternalState;
+    onClick(event: MouseEvent): void;
+    protected _emitChange(): void;
+    get currState(): _StateboxInternalState;
+    get ngStyle(): {
+        [klass: string]: any;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumStateboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumStateboxComponent, "ard-statebox", never, { "states": { "alias": "states"; "required": false; }; "manualStateHandling": { "alias": "manualStateHandling"; "required": false; }; "wrapperClasses": { "alias": "wrapperClasses"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "changeEvent": "change"; "clickEvent": "click"; "stateChange": "stateChange"; }, never, never, false, never>;
+}

package/lib/statebox/statebox.module.d.ts

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

package/lib/statebox/statebox.types.d.ts

@@ -0,0 +1,22 @@
+import { ComponentColor } from '../types/colors.types';
+export type StateboxValue = string | boolean | number | null | undefined;
+export type StateboxState = {
+    value: StateboxValue;
+    icon?: string;
+    character?: string;
+    color?: ComponentColor;
+    customColor?: string;
+    colorOnCustomColor?: string;
+    fillMode?: boolean;
+    keepFrame?: boolean;
+};
+export type _StateboxInternalState = {
+    value: StateboxValue;
+    display: string;
+    displayAsIcon: boolean;
+    color: string;
+    useCustomColor: boolean;
+    colorOnCustomColor?: string;
+    fillMode: boolean;
+    keepFrame: boolean;
+};