dasar-ui 2.0.1 → 2.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -3,9 +3,9 @@ import { AfterContentInit, AfterViewInit, ElementRef, EventEmitter, InjectionTok
3
3
  import { ControlValueAccessor } from "@angular/forms";
4
4
  import { ScaleAttributeType } from "@models/type.model";
5
5
  import { SafeHtml } from "@angular/platform-browser";
6
- import { DasarComponentConfig as DasarComponentConfig$1, DasarThemeButton as DasarThemeButton$1, DasarThemeButtonGroup as DasarThemeButtonGroup$1, DasarThemeCalendar as DasarThemeCalendar$1, DasarThemeCard as DasarThemeCard$1, DasarThemeChip as DasarThemeChip$1, DasarThemeCommon as DasarThemeCommon$1, DasarThemeConfig as DasarThemeConfig$1, DasarThemeDatepicker as DasarThemeDatepicker$1, DasarThemeDivider as DasarThemeDivider$1, DasarThemeInput as DasarThemeInput$1, DasarThemeMenu as DasarThemeMenu$1, DasarThemeModal as DasarThemeModal$1, DasarThemeMode as DasarThemeMode$1, DasarThemeOverlay as DasarThemeOverlay$1, DasarThemeSelect as DasarThemeSelect$1, DasarThemeTabs as DasarThemeTabs$1 } from "@models/theme.model";
7
- import { Observable } from "rxjs";
8
6
  import { DasarListConfig as DasarListConfig$1, DasarListItemConfig as DasarListItemConfig$1 } from "@components/dasar-list/dasar-list";
7
+ import { DasarComponentConfig as DasarComponentConfig$1, DasarThemeAlert as DasarThemeAlert$1, DasarThemeButton as DasarThemeButton$1, DasarThemeButtonGroup as DasarThemeButtonGroup$1, DasarThemeCalendar as DasarThemeCalendar$1, DasarThemeCard as DasarThemeCard$1, DasarThemeCheckbox as DasarThemeCheckbox$1, DasarThemeChip as DasarThemeChip$1, DasarThemeCommon as DasarThemeCommon$1, DasarThemeConfig as DasarThemeConfig$1, DasarThemeDatepicker as DasarThemeDatepicker$1, DasarThemeDivider as DasarThemeDivider$1, DasarThemeInput as DasarThemeInput$1, DasarThemeMenu as DasarThemeMenu$1, DasarThemeModal as DasarThemeModal$1, DasarThemeMode as DasarThemeMode$1, DasarThemeOverlay as DasarThemeOverlay$1, DasarThemeRadio as DasarThemeRadio$1, DasarThemeSelect as DasarThemeSelect$1, DasarThemeTabs as DasarThemeTabs$1 } from "@models/theme.model";
8
+ import { Observable } from "rxjs";
9
9
  type ClassType = string | string[] | Set<string> | {
10
10
  [klass: string]: any;
11
11
  } | null | undefined;
@@ -2811,224 +2811,852 @@ export declare class DasarDivider {
2811
2811
  static ngAcceptInputType_vertical: unknown;
2812
2812
  }
2813
2813
  export declare const DasarDividerComponent: readonly [typeof DasarDivider, typeof DasarDividerLabelTemplate];
2814
- export type DasarInputType = 'text' | 'password' | 'email' | 'number' | 'search' | 'url' | 'tel';
2815
- export type DasarInputMaskType = 'thousand' | 'date' | 'decimal' | ((val: string) => string);
2816
- export type DasarInputSizeType = Extract<ScaleAttributeType$1, 'sm' | 'md' | 'lg'>;
2817
- export type DasarInputAppearanceType = 'outline' | 'filled';
2818
- export type DasarInputRadiusType = ScaleAttributeType$1;
2819
- export interface DasarInputConfig {
2820
- appearance?: DasarInputAppearanceType;
2821
- labelRight?: string;
2822
- radius?: DasarInputRadiusType;
2823
- size?: DasarInputSizeType;
2824
- type?: DasarInputType;
2825
- mask?: DasarInputMaskType;
2826
- hint?: string;
2827
- placeholder?: string;
2828
- label?: string;
2829
- fullWidth?: boolean;
2830
- disabled?: boolean;
2831
- readonly?: boolean;
2832
- fluid?: boolean;
2833
- error?: boolean;
2814
+ export type DasarAlertVariantType = 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
2815
+ export interface DasarAlertConfig {
2816
+ variant?: DasarAlertVariantType;
2817
+ bordered?: boolean;
2818
+ closeable?: boolean;
2819
+ iconName?: string | null;
2820
+ closeIconName?: string;
2834
2821
  containerClass?: ClassType;
2835
- inputClass?: ClassType;
2836
- hostClass?: ClassType;
2837
- hintClass?: ClassType;
2838
2822
  containerStyle?: StyleType;
2839
- inputStyle?: StyleType;
2840
- hostStyle?: StyleType;
2841
- hintStyle?: StyleType;
2842
- hideOverflow?: boolean;
2843
- }
2844
- export declare class DasarInputExtraLabelSlot {
2845
- static ɵfac: i0.ɵɵFactoryDeclaration<DasarInputExtraLabelSlot, never>;
2846
- static ɵdir: i0.ɵɵDirectiveDeclaration<DasarInputExtraLabelSlot, "[extra-label-slot]", never, {}, {}, never, never, true, never>;
2823
+ titleClass?: ClassType;
2824
+ titleStyle?: StyleType;
2825
+ contentClass?: ClassType;
2826
+ contentStyle?: StyleType;
2847
2827
  }
2848
- export declare class DasarInputPrefixSlot {
2849
- static ɵfac: i0.ɵɵFactoryDeclaration<DasarInputPrefixSlot, never>;
2850
- static ɵdir: i0.ɵɵDirectiveDeclaration<DasarInputPrefixSlot, "[prefix-slot]", never, {}, {}, never, never, true, never>;
2828
+ export declare class DasarAlertHeaderSlot {
2829
+ static ɵfac: i0.ɵɵFactoryDeclaration<DasarAlertHeaderSlot, never>;
2830
+ static ɵdir: i0.ɵɵDirectiveDeclaration<DasarAlertHeaderSlot, "[header-slot]", never, {}, {}, never, never, true, never>;
2851
2831
  }
2852
- export declare class DasarInputSuffixSlot {
2853
- static ɵfac: i0.ɵɵFactoryDeclaration<DasarInputSuffixSlot, never>;
2854
- static ɵdir: i0.ɵɵDirectiveDeclaration<DasarInputSuffixSlot, "[suffix-slot]", never, {}, {}, never, never, true, never>;
2832
+ export declare class DasarAlertIconSlot {
2833
+ static ɵfac: i0.ɵɵFactoryDeclaration<DasarAlertIconSlot, never>;
2834
+ static ɵdir: i0.ɵɵDirectiveDeclaration<DasarAlertIconSlot, "[icon-slot]", never, {}, {}, never, never, true, never>;
2855
2835
  }
2856
- export declare class DasarInput implements ControlValueAccessor {
2857
- extraLabelSlot?: DasarInputExtraLabelSlot;
2836
+ export declare class DasarAlert implements OnDestroy {
2858
2837
  private themeProvider;
2859
2838
  private themeService;
2860
- private cdr;
2861
- appearance: DasarInputAppearanceType;
2862
- labelRight: string | undefined;
2863
- radius: NonNullable<ScaleAttributeType$1 | undefined>;
2864
- size: NonNullable<DasarInputSizeType | undefined>;
2865
- type: NonNullable<DasarInputType | undefined>;
2866
- mask: NonNullable<DasarInputMaskType | undefined> | undefined;
2867
- hint: string;
2868
- placeholder: string;
2869
- label: string | undefined;
2870
- fullWidth: NonNullable<boolean | undefined>;
2871
- disabled: NonNullable<boolean | undefined>;
2872
- readonly: NonNullable<boolean | undefined>;
2873
- fluid: NonNullable<boolean | undefined>;
2874
- error: NonNullable<boolean | undefined>;
2839
+ private leaveTimer;
2840
+ protected shown: import("@angular/core").WritableSignal<boolean>;
2841
+ protected leaving: import("@angular/core").WritableSignal<boolean>;
2842
+ variant: NonNullable<DasarAlertVariantType | undefined>;
2843
+ bordered: NonNullable<boolean | undefined>;
2844
+ closeable: NonNullable<boolean | undefined>;
2845
+ title: string | null;
2846
+ iconName: string | null;
2847
+ closeIconName: string;
2875
2848
  containerClass: NonNullable<ClassType> | null;
2876
- inputClass: NonNullable<ClassType> | null;
2877
- hostClass: NonNullable<ClassType> | null;
2878
- hintClass: NonNullable<ClassType> | null;
2879
2849
  containerStyle: NonNullable<StyleType | undefined> | null;
2880
- inputStyle: NonNullable<StyleType | undefined> | null;
2881
- hostStyle: NonNullable<StyleType | undefined> | null;
2882
- hintStyle: NonNullable<StyleType | undefined> | null;
2883
- hideOverflow: NonNullable<boolean | undefined>;
2884
- onTouched: any;
2885
- onChange: any;
2886
- private _value;
2887
- get value(): any;
2888
- set value(val: any);
2889
- valueChange: EventEmitter<any>;
2850
+ titleClass: NonNullable<ClassType> | null;
2851
+ titleStyle: NonNullable<StyleType | undefined> | null;
2852
+ contentClass: NonNullable<ClassType> | null;
2853
+ contentStyle: NonNullable<StyleType | undefined> | null;
2854
+ set visible(value: boolean);
2855
+ get visible(): boolean;
2856
+ visibleChange: EventEmitter<boolean>;
2857
+ onClose: EventEmitter<MouseEvent>;
2858
+ onAfterLeave: EventEmitter<void>;
2859
+ headerSlot?: DasarAlertHeaderSlot;
2860
+ iconSlot?: DasarAlertIconSlot;
2890
2861
  get hostClasses(): string;
2891
- private formatValue;
2892
- writeValue(value: any): void;
2893
- registerOnChange(fn: any): void;
2894
- registerOnTouched(fn: any): void;
2895
- setDisabledState(isDisabled: boolean): void;
2896
- onInput(event: Event): void;
2897
- onBlur(): void;
2898
- static ɵfac: i0.ɵɵFactoryDeclaration<DasarInput, never>;
2899
- static ɵcmp: i0.ɵɵComponentDeclaration<DasarInput, "dasar-input", never, {
2900
- "appearance": {
2901
- "alias": "appearance";
2862
+ get role(): string;
2863
+ get hasIcon(): boolean;
2864
+ get hasHeader(): boolean;
2865
+ get containerClasses(): Record<string, boolean>;
2866
+ get titleClasses(): Record<string, boolean>;
2867
+ get contentClasses(): Record<string, boolean>;
2868
+ close(event: MouseEvent): void;
2869
+ onAnimationEnd(event: Event): void;
2870
+ private finishLeave;
2871
+ private clearLeaveTimer;
2872
+ ngOnDestroy(): void;
2873
+ static ɵfac: i0.ɵɵFactoryDeclaration<DasarAlert, never>;
2874
+ static ɵcmp: i0.ɵɵComponentDeclaration<DasarAlert, "dasar-alert", never, {
2875
+ "variant": {
2876
+ "alias": "variant";
2902
2877
  "required": false;
2903
2878
  };
2904
- "labelRight": {
2905
- "alias": "label-right";
2879
+ "bordered": {
2880
+ "alias": "bordered";
2906
2881
  "required": false;
2907
2882
  };
2908
- "radius": {
2909
- "alias": "radius";
2883
+ "closeable": {
2884
+ "alias": "closeable";
2910
2885
  "required": false;
2911
2886
  };
2912
- "size": {
2913
- "alias": "size";
2887
+ "title": {
2888
+ "alias": "title";
2914
2889
  "required": false;
2915
2890
  };
2916
- "type": {
2917
- "alias": "type";
2891
+ "iconName": {
2892
+ "alias": "icon-name";
2918
2893
  "required": false;
2919
2894
  };
2920
- "mask": {
2921
- "alias": "mask";
2895
+ "closeIconName": {
2896
+ "alias": "close-icon-name";
2922
2897
  "required": false;
2923
2898
  };
2924
- "hint": {
2925
- "alias": "hint";
2899
+ "containerClass": {
2900
+ "alias": "container-class";
2926
2901
  "required": false;
2927
2902
  };
2928
- "placeholder": {
2929
- "alias": "placeholder";
2903
+ "containerStyle": {
2904
+ "alias": "container-style";
2930
2905
  "required": false;
2931
2906
  };
2932
- "label": {
2933
- "alias": "label";
2907
+ "titleClass": {
2908
+ "alias": "title-class";
2934
2909
  "required": false;
2935
2910
  };
2936
- "fullWidth": {
2937
- "alias": "full-width";
2911
+ "titleStyle": {
2912
+ "alias": "title-style";
2938
2913
  "required": false;
2939
2914
  };
2940
- "disabled": {
2941
- "alias": "disabled";
2915
+ "contentClass": {
2916
+ "alias": "content-class";
2942
2917
  "required": false;
2943
2918
  };
2944
- "readonly": {
2945
- "alias": "readonly";
2919
+ "contentStyle": {
2920
+ "alias": "content-style";
2946
2921
  "required": false;
2947
2922
  };
2948
- "fluid": {
2949
- "alias": "fluid";
2923
+ "visible": {
2924
+ "alias": "visible";
2925
+ "required": false;
2926
+ };
2927
+ }, {
2928
+ "visibleChange": "visibleChange";
2929
+ "onClose": "onClose";
2930
+ "onAfterLeave": "onAfterLeave";
2931
+ }, ["headerSlot", "iconSlot"], ["[icon-slot]", "[header-slot]", "*"], true, never>;
2932
+ static ngAcceptInputType_bordered: unknown;
2933
+ static ngAcceptInputType_closeable: unknown;
2934
+ static ngAcceptInputType_visible: unknown;
2935
+ }
2936
+ export declare const DasarAlertComponent: readonly [typeof DasarAlert, typeof DasarAlertHeaderSlot, typeof DasarAlertIconSlot];
2937
+ export type DasarCheckboxSizeType = Extract<ScaleAttributeType$1, 'sm' | 'md' | 'lg'>;
2938
+ export interface DasarCheckboxGroupState {
2939
+ checked: boolean;
2940
+ disabled: boolean;
2941
+ error?: boolean;
2942
+ size?: DasarCheckboxSizeType | null;
2943
+ }
2944
+ export interface DasarCheckboxConfig {
2945
+ size?: DasarCheckboxSizeType;
2946
+ disabled?: boolean;
2947
+ error?: boolean;
2948
+ hint?: string;
2949
+ label?: string;
2950
+ checkedValue?: any;
2951
+ uncheckedValue?: any;
2952
+ containerClass?: ClassType;
2953
+ containerStyle?: StyleType;
2954
+ boxClass?: ClassType;
2955
+ boxStyle?: StyleType;
2956
+ labelClass?: ClassType;
2957
+ labelStyle?: StyleType;
2958
+ hintClass?: ClassType;
2959
+ hintStyle?: StyleType;
2960
+ }
2961
+ export declare const isEqualValue: (first: any, second: any) => boolean;
2962
+ export declare class DasarCheckbox implements ControlValueAccessor {
2963
+ private themeProvider;
2964
+ private themeService;
2965
+ private groupToggleFn;
2966
+ private ownValue;
2967
+ private ownDisabled;
2968
+ private groupState;
2969
+ onTouched: () => void;
2970
+ onChange: (value: any) => void;
2971
+ size: NonNullable<DasarCheckboxSizeType | undefined>;
2972
+ label: string;
2973
+ hint: string;
2974
+ error: NonNullable<boolean | undefined>;
2975
+ set disabled(value: boolean);
2976
+ get disabled(): boolean;
2977
+ checkedValue: any;
2978
+ uncheckedValue: any;
2979
+ set value(val: any);
2980
+ get value(): any;
2981
+ containerClass: NonNullable<ClassType> | null;
2982
+ containerStyle: NonNullable<StyleType | undefined> | null;
2983
+ boxClass: NonNullable<ClassType> | null;
2984
+ boxStyle: NonNullable<StyleType | undefined> | null;
2985
+ labelClass: NonNullable<ClassType> | null;
2986
+ labelStyle: NonNullable<StyleType | undefined> | null;
2987
+ hintClass: NonNullable<ClassType> | null;
2988
+ hintStyle: NonNullable<StyleType | undefined> | null;
2989
+ valueChange: EventEmitter<any>;
2990
+ onUpdate: EventEmitter<any>;
2991
+ get hostClasses(): string;
2992
+ get currentSize(): DasarCheckboxSizeType;
2993
+ get hasError(): boolean;
2994
+ get isDisabled(): boolean;
2995
+ get isChecked(): boolean;
2996
+ get containerClasses(): Record<string, boolean>;
2997
+ get boxClasses(): Record<string, boolean>;
2998
+ get labelClasses(): Record<string, boolean>;
2999
+ get hintClasses(): Record<string, boolean>;
3000
+ applyGroupState(state: DasarCheckboxGroupState | null, toggle: ((cb: DasarCheckbox) => void) | null): void;
3001
+ toggle(event?: Event): void;
3002
+ writeValue(value: any): void;
3003
+ registerOnChange(fn: any): void;
3004
+ registerOnTouched(fn: any): void;
3005
+ setDisabledState(isDisabled: boolean): void;
3006
+ static ɵfac: i0.ɵɵFactoryDeclaration<DasarCheckbox, never>;
3007
+ static ɵcmp: i0.ɵɵComponentDeclaration<DasarCheckbox, "dasar-checkbox", never, {
3008
+ "size": {
3009
+ "alias": "size";
3010
+ "required": false;
3011
+ };
3012
+ "label": {
3013
+ "alias": "label";
3014
+ "required": false;
3015
+ };
3016
+ "hint": {
3017
+ "alias": "hint";
2950
3018
  "required": false;
2951
3019
  };
2952
3020
  "error": {
2953
3021
  "alias": "error";
2954
3022
  "required": false;
2955
3023
  };
2956
- "containerClass": {
2957
- "alias": "container-class";
3024
+ "disabled": {
3025
+ "alias": "disabled";
2958
3026
  "required": false;
2959
3027
  };
2960
- "inputClass": {
2961
- "alias": "input-class";
3028
+ "checkedValue": {
3029
+ "alias": "checked-value";
2962
3030
  "required": false;
2963
3031
  };
2964
- "hostClass": {
2965
- "alias": "host-class";
3032
+ "uncheckedValue": {
3033
+ "alias": "unchecked-value";
2966
3034
  "required": false;
2967
3035
  };
2968
- "hintClass": {
2969
- "alias": "hint-class";
3036
+ "value": {
3037
+ "alias": "value";
3038
+ "required": false;
3039
+ };
3040
+ "containerClass": {
3041
+ "alias": "container-class";
2970
3042
  "required": false;
2971
3043
  };
2972
3044
  "containerStyle": {
2973
3045
  "alias": "container-style";
2974
3046
  "required": false;
2975
3047
  };
2976
- "inputStyle": {
2977
- "alias": "input-style";
3048
+ "boxClass": {
3049
+ "alias": "box-class";
2978
3050
  "required": false;
2979
3051
  };
2980
- "hostStyle": {
2981
- "alias": "host-style";
3052
+ "boxStyle": {
3053
+ "alias": "box-style";
2982
3054
  "required": false;
2983
3055
  };
2984
- "hintStyle": {
2985
- "alias": "hint-style";
3056
+ "labelClass": {
3057
+ "alias": "label-class";
2986
3058
  "required": false;
2987
3059
  };
2988
- "hideOverflow": {
2989
- "alias": "hide-overflow";
3060
+ "labelStyle": {
3061
+ "alias": "label-style";
2990
3062
  "required": false;
2991
3063
  };
2992
- "value": {
2993
- "alias": "value";
3064
+ "hintClass": {
3065
+ "alias": "hint-class";
3066
+ "required": false;
3067
+ };
3068
+ "hintStyle": {
3069
+ "alias": "hint-style";
2994
3070
  "required": false;
2995
3071
  };
2996
3072
  }, {
2997
3073
  "valueChange": "valueChange";
2998
- }, ["extraLabelSlot"], ["[extra-label-slot]", "[prefix-slot]", "[suffix-slot]"], true, never>;
2999
- static ngAcceptInputType_fullWidth: unknown;
3000
- static ngAcceptInputType_disabled: unknown;
3001
- static ngAcceptInputType_readonly: unknown;
3002
- static ngAcceptInputType_fluid: unknown;
3074
+ "onUpdate": "onUpdate";
3075
+ }, never, ["*"], true, never>;
3003
3076
  static ngAcceptInputType_error: unknown;
3004
- static ngAcceptInputType_hideOverflow: unknown;
3077
+ static ngAcceptInputType_disabled: unknown;
3005
3078
  }
3006
- export declare const DasarInputComponent: readonly [typeof DasarInput, typeof DasarInputExtraLabelSlot, typeof DasarInputPrefixSlot, typeof DasarInputSuffixSlot];
3007
- export type DasarModalSize = Extract<ScaleAttributeType$1, 'sm' | 'md' | 'lg'>;
3008
- export type DasarModalAppearance = 'outline' | 'borderless' | 'elevated';
3009
- export type DasarModalSpacing = 'normal' | 'compact';
3010
- export type DasarModalRadius = ScaleAttributeType$1;
3011
- export interface DasarModalConfig {
3012
- appearance?: DasarModalAppearance;
3013
- spacing?: DasarModalSpacing;
3014
- radius?: DasarModalRadius;
3015
- size?: DasarModalSize;
3016
- label?: string;
3017
- width?: string;
3018
- containerStyle?: StyleType;
3019
- headerStyle?: StyleType;
3020
- closeStyle?: StyleType;
3021
- bodyStyle?: StyleType;
3022
- actionStyle?: StyleType;
3079
+ export declare const DasarCheckboxComponent: readonly [typeof DasarCheckbox];
3080
+ export type DasarCheckboxGroupDirectionType = 'horizontal' | 'vertical';
3081
+ export interface DasarCheckboxGroupConfig {
3082
+ direction?: DasarCheckboxGroupDirectionType;
3083
+ size?: DasarCheckboxSizeType | null;
3084
+ disabled?: boolean;
3085
+ error?: boolean;
3086
+ hint?: string;
3087
+ valueField?: string | null;
3023
3088
  containerClass?: ClassType;
3024
- headerClass?: ClassType;
3025
- closeClass?: ClassType;
3026
- bodyClass?: ClassType;
3027
- actionClass?: ClassType;
3028
- headerFluid?: boolean;
3029
- bodyFluid?: boolean;
3030
- actionFluid?: boolean;
3031
- fullWidth?: boolean;
3089
+ containerStyle?: StyleType;
3090
+ hintClass?: ClassType;
3091
+ hintStyle?: StyleType;
3092
+ }
3093
+ export declare class DasarCheckboxGroup implements ControlValueAccessor {
3094
+ private themeProvider;
3095
+ private themeService;
3096
+ private checkboxes;
3097
+ private ownDisabled;
3098
+ private ownError;
3099
+ private ownSize;
3100
+ private values;
3101
+ onTouched: () => void;
3102
+ onChange: (value: any[]) => void;
3103
+ constructor();
3104
+ direction: NonNullable<DasarCheckboxGroupDirectionType | undefined>;
3105
+ set size(value: DasarCheckboxSizeType | null);
3106
+ get size(): DasarCheckboxSizeType | null;
3107
+ set disabled(value: boolean);
3108
+ get disabled(): boolean;
3109
+ set error(value: boolean);
3110
+ get error(): boolean;
3111
+ hint: string;
3112
+ valueField: string | null;
3113
+ set value(val: any);
3114
+ get value(): any[];
3115
+ containerClass: NonNullable<ClassType> | null;
3116
+ containerStyle: NonNullable<StyleType | undefined> | null;
3117
+ hintClass: NonNullable<ClassType> | null;
3118
+ hintStyle: NonNullable<StyleType | undefined> | null;
3119
+ valueChange: EventEmitter<any[]>;
3120
+ onUpdate: EventEmitter<any[]>;
3121
+ get hostClasses(): string;
3122
+ get role(): string;
3123
+ onFocusOut(): void;
3124
+ get containerClasses(): Record<string, boolean>;
3125
+ get hintClasses(): Record<string, boolean>;
3126
+ private toggleChild;
3127
+ writeValue(value: any): void;
3128
+ registerOnChange(fn: any): void;
3129
+ registerOnTouched(fn: any): void;
3130
+ setDisabledState(isDisabled: boolean): void;
3131
+ ngOnDestroy(): void;
3132
+ static ɵfac: i0.ɵɵFactoryDeclaration<DasarCheckboxGroup, never>;
3133
+ static ɵcmp: i0.ɵɵComponentDeclaration<DasarCheckboxGroup, "dasar-checkbox-group", never, {
3134
+ "direction": {
3135
+ "alias": "direction";
3136
+ "required": false;
3137
+ };
3138
+ "size": {
3139
+ "alias": "size";
3140
+ "required": false;
3141
+ };
3142
+ "disabled": {
3143
+ "alias": "disabled";
3144
+ "required": false;
3145
+ };
3146
+ "error": {
3147
+ "alias": "error";
3148
+ "required": false;
3149
+ };
3150
+ "hint": {
3151
+ "alias": "hint";
3152
+ "required": false;
3153
+ };
3154
+ "valueField": {
3155
+ "alias": "value-field";
3156
+ "required": false;
3157
+ };
3158
+ "value": {
3159
+ "alias": "value";
3160
+ "required": false;
3161
+ };
3162
+ "containerClass": {
3163
+ "alias": "container-class";
3164
+ "required": false;
3165
+ };
3166
+ "containerStyle": {
3167
+ "alias": "container-style";
3168
+ "required": false;
3169
+ };
3170
+ "hintClass": {
3171
+ "alias": "hint-class";
3172
+ "required": false;
3173
+ };
3174
+ "hintStyle": {
3175
+ "alias": "hint-style";
3176
+ "required": false;
3177
+ };
3178
+ }, {
3179
+ "valueChange": "valueChange";
3180
+ "onUpdate": "onUpdate";
3181
+ }, ["checkboxes"], ["*"], true, never>;
3182
+ static ngAcceptInputType_disabled: unknown;
3183
+ static ngAcceptInputType_error: unknown;
3184
+ }
3185
+ export declare const DasarCheckboxGroupComponent: readonly [typeof DasarCheckboxGroup];
3186
+ export type DasarRadioSizeType = Extract<ScaleAttributeType$1, 'sm' | 'md' | 'lg'>;
3187
+ export interface DasarRadioGroupState {
3188
+ checked: boolean;
3189
+ disabled: boolean;
3190
+ error?: boolean;
3191
+ size?: DasarRadioSizeType | null;
3192
+ name: string;
3193
+ }
3194
+ export interface DasarRadioConfig {
3195
+ size?: DasarRadioSizeType;
3196
+ disabled?: boolean;
3197
+ error?: boolean;
3198
+ hint?: string;
3199
+ label?: string;
3200
+ containerClass?: ClassType;
3201
+ containerStyle?: StyleType;
3202
+ circleClass?: ClassType;
3203
+ circleStyle?: StyleType;
3204
+ labelClass?: ClassType;
3205
+ labelStyle?: StyleType;
3206
+ hintClass?: ClassType;
3207
+ hintStyle?: StyleType;
3208
+ }
3209
+ export declare class DasarRadio implements ControlValueAccessor {
3210
+ private themeProvider;
3211
+ private themeService;
3212
+ private groupSelectFn;
3213
+ private ownValue;
3214
+ private ownDisabled;
3215
+ private groupState;
3216
+ onTouched: () => void;
3217
+ onChange: (value: any) => void;
3218
+ size: NonNullable<DasarRadioSizeType | undefined>;
3219
+ label: string;
3220
+ hint: string;
3221
+ name: string | null;
3222
+ error: NonNullable<boolean | undefined>;
3223
+ set disabled(value: boolean);
3224
+ get disabled(): boolean;
3225
+ checkedValue: any;
3226
+ set value(val: any);
3227
+ get value(): any;
3228
+ containerClass: NonNullable<ClassType> | null;
3229
+ containerStyle: NonNullable<StyleType | undefined> | null;
3230
+ circleClass: NonNullable<ClassType> | null;
3231
+ circleStyle: NonNullable<StyleType | undefined> | null;
3232
+ labelClass: NonNullable<ClassType> | null;
3233
+ labelStyle: NonNullable<StyleType | undefined> | null;
3234
+ hintClass: NonNullable<ClassType> | null;
3235
+ hintStyle: NonNullable<StyleType | undefined> | null;
3236
+ valueChange: EventEmitter<any>;
3237
+ onUpdate: EventEmitter<any>;
3238
+ get hostClasses(): string;
3239
+ get currentSize(): DasarRadioSizeType;
3240
+ get currentName(): string | null;
3241
+ get isDisabled(): boolean;
3242
+ get hasError(): boolean;
3243
+ get isChecked(): boolean;
3244
+ get containerClasses(): Record<string, boolean>;
3245
+ get circleClasses(): Record<string, boolean>;
3246
+ get labelClasses(): Record<string, boolean>;
3247
+ get hintClasses(): Record<string, boolean>;
3248
+ applyGroupState(state: DasarRadioGroupState | null, select: ((radio: DasarRadio) => void) | null): void;
3249
+ select(event?: Event): void;
3250
+ writeValue(value: any): void;
3251
+ registerOnChange(fn: any): void;
3252
+ registerOnTouched(fn: any): void;
3253
+ setDisabledState(isDisabled: boolean): void;
3254
+ static ɵfac: i0.ɵɵFactoryDeclaration<DasarRadio, never>;
3255
+ static ɵcmp: i0.ɵɵComponentDeclaration<DasarRadio, "dasar-radio", never, {
3256
+ "size": {
3257
+ "alias": "size";
3258
+ "required": false;
3259
+ };
3260
+ "label": {
3261
+ "alias": "label";
3262
+ "required": false;
3263
+ };
3264
+ "hint": {
3265
+ "alias": "hint";
3266
+ "required": false;
3267
+ };
3268
+ "name": {
3269
+ "alias": "name";
3270
+ "required": false;
3271
+ };
3272
+ "error": {
3273
+ "alias": "error";
3274
+ "required": false;
3275
+ };
3276
+ "disabled": {
3277
+ "alias": "disabled";
3278
+ "required": false;
3279
+ };
3280
+ "checkedValue": {
3281
+ "alias": "checked-value";
3282
+ "required": false;
3283
+ };
3284
+ "value": {
3285
+ "alias": "value";
3286
+ "required": false;
3287
+ };
3288
+ "containerClass": {
3289
+ "alias": "container-class";
3290
+ "required": false;
3291
+ };
3292
+ "containerStyle": {
3293
+ "alias": "container-style";
3294
+ "required": false;
3295
+ };
3296
+ "circleClass": {
3297
+ "alias": "circle-class";
3298
+ "required": false;
3299
+ };
3300
+ "circleStyle": {
3301
+ "alias": "circle-style";
3302
+ "required": false;
3303
+ };
3304
+ "labelClass": {
3305
+ "alias": "label-class";
3306
+ "required": false;
3307
+ };
3308
+ "labelStyle": {
3309
+ "alias": "label-style";
3310
+ "required": false;
3311
+ };
3312
+ "hintClass": {
3313
+ "alias": "hint-class";
3314
+ "required": false;
3315
+ };
3316
+ "hintStyle": {
3317
+ "alias": "hint-style";
3318
+ "required": false;
3319
+ };
3320
+ }, {
3321
+ "valueChange": "valueChange";
3322
+ "onUpdate": "onUpdate";
3323
+ }, never, ["*"], true, never>;
3324
+ static ngAcceptInputType_error: unknown;
3325
+ static ngAcceptInputType_disabled: unknown;
3326
+ }
3327
+ export declare const DasarRadioComponent: readonly [typeof DasarRadio];
3328
+ export type DasarRadioGroupDirectionType = 'horizontal' | 'vertical';
3329
+ export interface DasarRadioGroupConfig {
3330
+ direction?: DasarRadioGroupDirectionType;
3331
+ size?: DasarRadioSizeType | null;
3332
+ disabled?: boolean;
3333
+ error?: boolean;
3334
+ hint?: string;
3335
+ valueField?: string | null;
3336
+ containerClass?: ClassType;
3337
+ containerStyle?: StyleType;
3338
+ hintClass?: ClassType;
3339
+ hintStyle?: StyleType;
3340
+ }
3341
+ export declare class DasarRadioGroup implements ControlValueAccessor {
3342
+ private themeProvider;
3343
+ private themeService;
3344
+ private radios;
3345
+ private ownDisabled;
3346
+ private ownError;
3347
+ private ownSize;
3348
+ private ownName;
3349
+ private selected;
3350
+ private groupName;
3351
+ onTouched: () => void;
3352
+ onChange: (value: any) => void;
3353
+ constructor();
3354
+ direction: NonNullable<DasarRadioGroupDirectionType | undefined>;
3355
+ set size(value: DasarRadioSizeType | null);
3356
+ get size(): DasarRadioSizeType | null;
3357
+ set disabled(value: boolean);
3358
+ get disabled(): boolean;
3359
+ set error(value: boolean);
3360
+ get error(): boolean;
3361
+ set name(value: string | null);
3362
+ get name(): string | null;
3363
+ hint: string;
3364
+ valueField: string | null;
3365
+ set value(val: any);
3366
+ get value(): any;
3367
+ containerClass: NonNullable<ClassType> | null;
3368
+ containerStyle: NonNullable<StyleType | undefined> | null;
3369
+ hintClass: NonNullable<ClassType> | null;
3370
+ hintStyle: NonNullable<StyleType | undefined> | null;
3371
+ valueChange: EventEmitter<any>;
3372
+ onUpdate: EventEmitter<any>;
3373
+ get hostClasses(): string;
3374
+ get role(): string;
3375
+ onFocusOut(): void;
3376
+ get containerClasses(): Record<string, boolean>;
3377
+ get hintClasses(): Record<string, boolean>;
3378
+ private selectChild;
3379
+ writeValue(value: any): void;
3380
+ registerOnChange(fn: any): void;
3381
+ registerOnTouched(fn: any): void;
3382
+ setDisabledState(isDisabled: boolean): void;
3383
+ ngOnDestroy(): void;
3384
+ static ɵfac: i0.ɵɵFactoryDeclaration<DasarRadioGroup, never>;
3385
+ static ɵcmp: i0.ɵɵComponentDeclaration<DasarRadioGroup, "dasar-radio-group", never, {
3386
+ "direction": {
3387
+ "alias": "direction";
3388
+ "required": false;
3389
+ };
3390
+ "size": {
3391
+ "alias": "size";
3392
+ "required": false;
3393
+ };
3394
+ "disabled": {
3395
+ "alias": "disabled";
3396
+ "required": false;
3397
+ };
3398
+ "error": {
3399
+ "alias": "error";
3400
+ "required": false;
3401
+ };
3402
+ "name": {
3403
+ "alias": "name";
3404
+ "required": false;
3405
+ };
3406
+ "hint": {
3407
+ "alias": "hint";
3408
+ "required": false;
3409
+ };
3410
+ "valueField": {
3411
+ "alias": "value-field";
3412
+ "required": false;
3413
+ };
3414
+ "value": {
3415
+ "alias": "value";
3416
+ "required": false;
3417
+ };
3418
+ "containerClass": {
3419
+ "alias": "container-class";
3420
+ "required": false;
3421
+ };
3422
+ "containerStyle": {
3423
+ "alias": "container-style";
3424
+ "required": false;
3425
+ };
3426
+ "hintClass": {
3427
+ "alias": "hint-class";
3428
+ "required": false;
3429
+ };
3430
+ "hintStyle": {
3431
+ "alias": "hint-style";
3432
+ "required": false;
3433
+ };
3434
+ }, {
3435
+ "valueChange": "valueChange";
3436
+ "onUpdate": "onUpdate";
3437
+ }, ["radios"], ["*"], true, never>;
3438
+ static ngAcceptInputType_disabled: unknown;
3439
+ static ngAcceptInputType_error: unknown;
3440
+ }
3441
+ export declare const DasarRadioGroupComponent: readonly [typeof DasarRadioGroup];
3442
+ export type DasarInputType = 'text' | 'password' | 'email' | 'number' | 'search' | 'url' | 'tel';
3443
+ export type DasarInputMaskType = 'thousand' | 'date' | 'decimal' | ((val: string) => string);
3444
+ export type DasarInputSizeType = Extract<ScaleAttributeType$1, 'sm' | 'md' | 'lg'>;
3445
+ export type DasarInputAppearanceType = 'outline' | 'filled';
3446
+ export type DasarInputRadiusType = ScaleAttributeType$1;
3447
+ export interface DasarInputConfig {
3448
+ appearance?: DasarInputAppearanceType;
3449
+ labelRight?: string;
3450
+ radius?: DasarInputRadiusType;
3451
+ size?: DasarInputSizeType;
3452
+ type?: DasarInputType;
3453
+ mask?: DasarInputMaskType;
3454
+ hint?: string;
3455
+ placeholder?: string;
3456
+ label?: string;
3457
+ fullWidth?: boolean;
3458
+ disabled?: boolean;
3459
+ readonly?: boolean;
3460
+ fluid?: boolean;
3461
+ error?: boolean;
3462
+ containerClass?: ClassType;
3463
+ inputClass?: ClassType;
3464
+ hostClass?: ClassType;
3465
+ hintClass?: ClassType;
3466
+ containerStyle?: StyleType;
3467
+ inputStyle?: StyleType;
3468
+ hostStyle?: StyleType;
3469
+ hintStyle?: StyleType;
3470
+ hideOverflow?: boolean;
3471
+ }
3472
+ export declare class DasarInputExtraLabelSlot {
3473
+ static ɵfac: i0.ɵɵFactoryDeclaration<DasarInputExtraLabelSlot, never>;
3474
+ static ɵdir: i0.ɵɵDirectiveDeclaration<DasarInputExtraLabelSlot, "[extra-label-slot]", never, {}, {}, never, never, true, never>;
3475
+ }
3476
+ export declare class DasarInputPrefixSlot {
3477
+ static ɵfac: i0.ɵɵFactoryDeclaration<DasarInputPrefixSlot, never>;
3478
+ static ɵdir: i0.ɵɵDirectiveDeclaration<DasarInputPrefixSlot, "[prefix-slot]", never, {}, {}, never, never, true, never>;
3479
+ }
3480
+ export declare class DasarInputSuffixSlot {
3481
+ static ɵfac: i0.ɵɵFactoryDeclaration<DasarInputSuffixSlot, never>;
3482
+ static ɵdir: i0.ɵɵDirectiveDeclaration<DasarInputSuffixSlot, "[suffix-slot]", never, {}, {}, never, never, true, never>;
3483
+ }
3484
+ export declare class DasarInput implements ControlValueAccessor {
3485
+ extraLabelSlot?: DasarInputExtraLabelSlot;
3486
+ private themeProvider;
3487
+ private themeService;
3488
+ private cdr;
3489
+ appearance: DasarInputAppearanceType;
3490
+ labelRight: string | undefined;
3491
+ radius: NonNullable<ScaleAttributeType$1 | undefined>;
3492
+ size: NonNullable<DasarInputSizeType | undefined>;
3493
+ type: NonNullable<DasarInputType | undefined>;
3494
+ mask: NonNullable<DasarInputMaskType | undefined> | undefined;
3495
+ hint: string;
3496
+ placeholder: string;
3497
+ label: string | undefined;
3498
+ fullWidth: NonNullable<boolean | undefined>;
3499
+ disabled: NonNullable<boolean | undefined>;
3500
+ readonly: NonNullable<boolean | undefined>;
3501
+ fluid: NonNullable<boolean | undefined>;
3502
+ error: NonNullable<boolean | undefined>;
3503
+ containerClass: NonNullable<ClassType> | null;
3504
+ inputClass: NonNullable<ClassType> | null;
3505
+ hostClass: NonNullable<ClassType> | null;
3506
+ hintClass: NonNullable<ClassType> | null;
3507
+ containerStyle: NonNullable<StyleType | undefined> | null;
3508
+ inputStyle: NonNullable<StyleType | undefined> | null;
3509
+ hostStyle: NonNullable<StyleType | undefined> | null;
3510
+ hintStyle: NonNullable<StyleType | undefined> | null;
3511
+ hideOverflow: NonNullable<boolean | undefined>;
3512
+ onTouched: any;
3513
+ onChange: any;
3514
+ private _value;
3515
+ get value(): any;
3516
+ set value(val: any);
3517
+ valueChange: EventEmitter<any>;
3518
+ get hostClasses(): string;
3519
+ private formatValue;
3520
+ writeValue(value: any): void;
3521
+ registerOnChange(fn: any): void;
3522
+ registerOnTouched(fn: any): void;
3523
+ setDisabledState(isDisabled: boolean): void;
3524
+ onInput(event: Event): void;
3525
+ onBlur(): void;
3526
+ static ɵfac: i0.ɵɵFactoryDeclaration<DasarInput, never>;
3527
+ static ɵcmp: i0.ɵɵComponentDeclaration<DasarInput, "dasar-input", never, {
3528
+ "appearance": {
3529
+ "alias": "appearance";
3530
+ "required": false;
3531
+ };
3532
+ "labelRight": {
3533
+ "alias": "label-right";
3534
+ "required": false;
3535
+ };
3536
+ "radius": {
3537
+ "alias": "radius";
3538
+ "required": false;
3539
+ };
3540
+ "size": {
3541
+ "alias": "size";
3542
+ "required": false;
3543
+ };
3544
+ "type": {
3545
+ "alias": "type";
3546
+ "required": false;
3547
+ };
3548
+ "mask": {
3549
+ "alias": "mask";
3550
+ "required": false;
3551
+ };
3552
+ "hint": {
3553
+ "alias": "hint";
3554
+ "required": false;
3555
+ };
3556
+ "placeholder": {
3557
+ "alias": "placeholder";
3558
+ "required": false;
3559
+ };
3560
+ "label": {
3561
+ "alias": "label";
3562
+ "required": false;
3563
+ };
3564
+ "fullWidth": {
3565
+ "alias": "full-width";
3566
+ "required": false;
3567
+ };
3568
+ "disabled": {
3569
+ "alias": "disabled";
3570
+ "required": false;
3571
+ };
3572
+ "readonly": {
3573
+ "alias": "readonly";
3574
+ "required": false;
3575
+ };
3576
+ "fluid": {
3577
+ "alias": "fluid";
3578
+ "required": false;
3579
+ };
3580
+ "error": {
3581
+ "alias": "error";
3582
+ "required": false;
3583
+ };
3584
+ "containerClass": {
3585
+ "alias": "container-class";
3586
+ "required": false;
3587
+ };
3588
+ "inputClass": {
3589
+ "alias": "input-class";
3590
+ "required": false;
3591
+ };
3592
+ "hostClass": {
3593
+ "alias": "host-class";
3594
+ "required": false;
3595
+ };
3596
+ "hintClass": {
3597
+ "alias": "hint-class";
3598
+ "required": false;
3599
+ };
3600
+ "containerStyle": {
3601
+ "alias": "container-style";
3602
+ "required": false;
3603
+ };
3604
+ "inputStyle": {
3605
+ "alias": "input-style";
3606
+ "required": false;
3607
+ };
3608
+ "hostStyle": {
3609
+ "alias": "host-style";
3610
+ "required": false;
3611
+ };
3612
+ "hintStyle": {
3613
+ "alias": "hint-style";
3614
+ "required": false;
3615
+ };
3616
+ "hideOverflow": {
3617
+ "alias": "hide-overflow";
3618
+ "required": false;
3619
+ };
3620
+ "value": {
3621
+ "alias": "value";
3622
+ "required": false;
3623
+ };
3624
+ }, {
3625
+ "valueChange": "valueChange";
3626
+ }, ["extraLabelSlot"], ["[extra-label-slot]", "[prefix-slot]", "[suffix-slot]"], true, never>;
3627
+ static ngAcceptInputType_fullWidth: unknown;
3628
+ static ngAcceptInputType_disabled: unknown;
3629
+ static ngAcceptInputType_readonly: unknown;
3630
+ static ngAcceptInputType_fluid: unknown;
3631
+ static ngAcceptInputType_error: unknown;
3632
+ static ngAcceptInputType_hideOverflow: unknown;
3633
+ }
3634
+ export declare const DasarInputComponent: readonly [typeof DasarInput, typeof DasarInputExtraLabelSlot, typeof DasarInputPrefixSlot, typeof DasarInputSuffixSlot];
3635
+ export type DasarModalSize = Extract<ScaleAttributeType$1, 'sm' | 'md' | 'lg'>;
3636
+ export type DasarModalAppearance = 'outline' | 'borderless' | 'elevated';
3637
+ export type DasarModalSpacing = 'normal' | 'compact';
3638
+ export type DasarModalRadius = ScaleAttributeType$1;
3639
+ export interface DasarModalConfig {
3640
+ appearance?: DasarModalAppearance;
3641
+ spacing?: DasarModalSpacing;
3642
+ radius?: DasarModalRadius;
3643
+ size?: DasarModalSize;
3644
+ label?: string;
3645
+ width?: string;
3646
+ containerStyle?: StyleType;
3647
+ headerStyle?: StyleType;
3648
+ closeStyle?: StyleType;
3649
+ bodyStyle?: StyleType;
3650
+ actionStyle?: StyleType;
3651
+ containerClass?: ClassType;
3652
+ headerClass?: ClassType;
3653
+ closeClass?: ClassType;
3654
+ bodyClass?: ClassType;
3655
+ actionClass?: ClassType;
3656
+ headerFluid?: boolean;
3657
+ bodyFluid?: boolean;
3658
+ actionFluid?: boolean;
3659
+ fullWidth?: boolean;
3032
3660
  closable?: boolean;
3033
3661
  closeOnOverlay?: boolean;
3034
3662
  closeOnEscape?: boolean;
@@ -3265,78 +3893,14 @@ export declare class DasarOverlay {
3265
3893
  static ngAcceptInputType_closeOnClick: unknown;
3266
3894
  }
3267
3895
  export declare const DasarOverlayComponent: readonly [typeof DasarOverlay];
3268
- export declare const DASAR_THEME_PROVIDER: InjectionToken<DasarThemeProviderComponent>;
3269
- export declare const defaultLightCommonTokens: DasarThemeCommon$1;
3270
- export declare const defaultDarkCommonTokens: DasarThemeCommon$1;
3271
- export declare class DasarThemeProviderComponent implements OnChanges {
3272
- private el;
3273
- private parentProvider;
3274
- activeMode: import("@angular/core").WritableSignal<DasarThemeMode$1>;
3275
- private previouslyInjectedVars;
3276
- componentConfig?: DasarComponentConfig$1;
3277
- tokenConfig?: DasarThemeConfig$1['tokens'];
3278
- colorConfig?: DasarThemeConfig$1['colors'];
3279
- mode: DasarThemeMode$1;
3280
- constructor(el: ElementRef);
3281
- ngOnChanges(changes: SimpleChanges): void;
3282
- getResolvedCommonTokens(mode: DasarThemeMode$1): DasarThemeCommon$1;
3283
- private applyTokenConfig;
3284
- private injectMappedTokens;
3285
- private injectColors;
3286
- static ɵfac: i0.ɵɵFactoryDeclaration<DasarThemeProviderComponent, never>;
3287
- static ɵcmp: i0.ɵɵComponentDeclaration<DasarThemeProviderComponent, "dasar-theme-provider", never, {
3288
- "componentConfig": {
3289
- "alias": "componentConfig";
3290
- "required": false;
3291
- };
3292
- "tokenConfig": {
3293
- "alias": "tokenConfig";
3294
- "required": false;
3295
- };
3296
- "colorConfig": {
3297
- "alias": "colorConfig";
3298
- "required": false;
3299
- };
3300
- "mode": {
3301
- "alias": "mode";
3302
- "required": false;
3303
- };
3304
- }, {}, never, ["*"], true, never>;
3305
- }
3306
- export declare const commonMap: Record<keyof DasarThemeCommon$1, string>;
3307
- export declare const buttonMap: Record<keyof DasarThemeButton$1, string>;
3308
- export declare const buttonGroupMap: Record<keyof DasarThemeButtonGroup$1, string>;
3309
- export declare const inputMap: Record<keyof DasarThemeInput$1, string>;
3310
- export declare const calendarMap: Record<keyof DasarThemeCalendar$1, string>;
3311
- export declare const datepickerMap: Record<keyof DasarThemeDatepicker$1, string>;
3312
- export declare const chipMap: Record<keyof DasarThemeChip$1, string>;
3313
- export declare const dividerMap: Record<keyof DasarThemeDivider$1, string>;
3314
- export declare const selectMap: Record<keyof DasarThemeSelect$1, string>;
3315
- export declare const cardMap: Record<keyof DasarThemeCard$1, string>;
3316
- export declare const menuMap: Record<keyof DasarThemeMenu$1, string>;
3317
- export declare const tableMap: Record<string, string>;
3318
- export declare const listMap: Record<string, string>;
3319
- export declare const tabsMap: Record<keyof DasarThemeTabs$1, string>;
3320
- export declare const overlayMap: Record<keyof DasarThemeOverlay$1, string>;
3321
- export declare const modalMap: Record<keyof DasarThemeModal$1, string>;
3322
- export declare class DasarThemeService {
3323
- private themeState;
3324
- theme$: Observable<DasarThemeConfig$1>;
3325
- private initialConfig;
3326
- private platformId;
3327
- private document;
3328
- private renderer;
3329
- constructor(rendererFactory: RendererFactory2);
3330
- setGlobalTheme(config: DasarThemeConfig$1, targetElement?: HTMLElement): void;
3331
- themeVariable(): DasarThemeConfig$1;
3332
- rawThemeVariable(): DasarThemeConfig$1;
3333
- private injectMappedTokens;
3334
- private injectColors;
3335
- static ɵfac: i0.ɵɵFactoryDeclaration<DasarThemeService, never>;
3336
- static ɵprov: i0.ɵɵInjectableDeclaration<any>;
3337
- }
3338
- export declare function fieldIconSize(size: string | number | null | undefined): number;
3339
3896
  export type DasarThemeMode = 'light' | 'dark';
3897
+ export type DasarBreakpointName = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
3898
+ export interface DasarThemeBreakpoints {
3899
+ sm?: number;
3900
+ md?: number;
3901
+ lg?: number;
3902
+ xl?: number;
3903
+ }
3340
3904
  export interface DasarThemeScale {
3341
3905
  50?: string;
3342
3906
  100?: string;
@@ -3514,6 +4078,78 @@ export interface DasarThemeButtonGroup {
3514
4078
  dividerColor?: string;
3515
4079
  focusZIndex?: string;
3516
4080
  }
4081
+ export interface DasarThemeAlert {
4082
+ padding?: string;
4083
+ gap?: string;
4084
+ radius?: string;
4085
+ borderWidth?: string;
4086
+ fontSize?: string;
4087
+ titleFontSize?: string;
4088
+ titleFontWeight?: string;
4089
+ titleGap?: string;
4090
+ closePadding?: string;
4091
+ closeHoverBg?: string;
4092
+ leaveDuration?: string;
4093
+ primaryBg?: string;
4094
+ primaryColor?: string;
4095
+ primaryBorder?: string;
4096
+ primaryIconColor?: string;
4097
+ secondaryBg?: string;
4098
+ secondaryColor?: string;
4099
+ secondaryBorder?: string;
4100
+ secondaryIconColor?: string;
4101
+ successBg?: string;
4102
+ successColor?: string;
4103
+ successBorder?: string;
4104
+ successIconColor?: string;
4105
+ warningBg?: string;
4106
+ warningColor?: string;
4107
+ warningBorder?: string;
4108
+ warningIconColor?: string;
4109
+ dangerBg?: string;
4110
+ dangerColor?: string;
4111
+ dangerBorder?: string;
4112
+ dangerIconColor?: string;
4113
+ }
4114
+ export interface DasarThemeCheckbox {
4115
+ gap?: string;
4116
+ hintGap?: string;
4117
+ sizeSm?: string;
4118
+ sizeMd?: string;
4119
+ sizeLg?: string;
4120
+ radius?: string;
4121
+ borderWidth?: string;
4122
+ borderColor?: string;
4123
+ bg?: string;
4124
+ checkedBg?: string;
4125
+ checkColor?: string;
4126
+ focusColor?: string;
4127
+ errorColor?: string;
4128
+ disabledOpacity?: string;
4129
+ labelColor?: string;
4130
+ hintColor?: string;
4131
+ hintFontSize?: string;
4132
+ groupGap?: string;
4133
+ }
4134
+ export interface DasarThemeRadio {
4135
+ gap?: string;
4136
+ hintGap?: string;
4137
+ sizeSm?: string;
4138
+ sizeMd?: string;
4139
+ sizeLg?: string;
4140
+ dotSize?: string;
4141
+ borderWidth?: string;
4142
+ borderColor?: string;
4143
+ bg?: string;
4144
+ checkedColor?: string;
4145
+ focusColor?: string;
4146
+ errorColor?: string;
4147
+ disabledOpacity?: string;
4148
+ labelColor?: string;
4149
+ hintColor?: string;
4150
+ hintFontSize?: string;
4151
+ groupGap?: string;
4152
+ }
3517
4153
  export interface DasarThemeDivider {
3518
4154
  color?: string;
3519
4155
  thickness?: string;
@@ -4020,6 +4656,12 @@ export type DasarComponentConfig = {
4020
4656
  card?: DasarCardConfig;
4021
4657
  chip?: DasarChipConfig;
4022
4658
  divider?: DasarDividerConfig;
4659
+ alert?: DasarAlertConfig;
4660
+ checkbox?: DasarCheckboxConfig;
4661
+ checkboxGroup?: DasarCheckboxGroupConfig;
4662
+ radio?: DasarRadioConfig;
4663
+ radioGroup?: DasarRadioGroupConfig;
4664
+ breakpoint?: DasarBreakpointConfig;
4023
4665
  modal?: DasarModalConfig;
4024
4666
  overlay?: DasarOverlayConfig;
4025
4667
  icon?: DasarIconConfig;
@@ -4033,6 +4675,7 @@ export interface DasarThemeConfig {
4033
4675
  mode: DasarThemeMode;
4034
4676
  colors?: DasarThemeColors;
4035
4677
  components?: DasarComponentConfig;
4678
+ breakpoints?: DasarThemeBreakpoints;
4036
4679
  tokens?: {
4037
4680
  light?: {
4038
4681
  common?: DasarThemeCommon;
@@ -4043,6 +4686,9 @@ export interface DasarThemeConfig {
4043
4686
  datepicker?: DasarThemeDatepicker;
4044
4687
  chip?: DasarThemeChip;
4045
4688
  divider?: DasarThemeDivider;
4689
+ alert?: DasarThemeAlert;
4690
+ checkbox?: DasarThemeCheckbox;
4691
+ radio?: DasarThemeRadio;
4046
4692
  select?: DasarThemeSelect;
4047
4693
  card?: DasarThemeCard;
4048
4694
  menu?: DasarThemeMenu;
@@ -4061,6 +4707,9 @@ export interface DasarThemeConfig {
4061
4707
  datepicker?: DasarThemeDatepicker;
4062
4708
  chip?: DasarThemeChip;
4063
4709
  divider?: DasarThemeDivider;
4710
+ alert?: DasarThemeAlert;
4711
+ checkbox?: DasarThemeCheckbox;
4712
+ radio?: DasarThemeRadio;
4064
4713
  select?: DasarThemeSelect;
4065
4714
  card?: DasarThemeCard;
4066
4715
  menu?: DasarThemeMenu;
@@ -4072,4 +4721,181 @@ export interface DasarThemeConfig {
4072
4721
  };
4073
4722
  };
4074
4723
  }
4724
+ export interface DasarBreakpointThresholds {
4725
+ sm: number;
4726
+ md: number;
4727
+ lg: number;
4728
+ xl: number;
4729
+ }
4730
+ export interface DasarBreakpointState {
4731
+ width: number;
4732
+ height: number;
4733
+ name: DasarBreakpointName;
4734
+ xs: boolean;
4735
+ sm: boolean;
4736
+ md: boolean;
4737
+ lg: boolean;
4738
+ xl: boolean;
4739
+ smAndDown: boolean;
4740
+ mdAndDown: boolean;
4741
+ lgAndDown: boolean;
4742
+ xlAndDown: boolean;
4743
+ smAndUp: boolean;
4744
+ mdAndUp: boolean;
4745
+ lgAndUp: boolean;
4746
+ xlAndUp: boolean;
4747
+ }
4748
+ export declare const DASAR_DEFAULT_BREAKPOINTS: DasarBreakpointThresholds;
4749
+ export declare const computeBreakpointState: (width: number, height: number, thresholds: DasarBreakpointThresholds) => DasarBreakpointState;
4750
+ export declare const isBreakpointMatch: (name: DasarBreakpointName, list: DasarBreakpointName[]) => boolean;
4751
+ export declare class DasarBreakpointService {
4752
+ private platformId;
4753
+ private destroyRef;
4754
+ private themeService;
4755
+ private isBrowser;
4756
+ private thresholds;
4757
+ private rafId;
4758
+ private onResize;
4759
+ private innerWidth;
4760
+ private innerHeight;
4761
+ readonly width: import("@angular/core").Signal<number>;
4762
+ readonly height: import("@angular/core").Signal<number>;
4763
+ readonly state: import("@angular/core").Signal<DasarBreakpointState>;
4764
+ readonly name: import("@angular/core").Signal<DasarBreakpointName>;
4765
+ readonly xs: import("@angular/core").Signal<boolean>;
4766
+ readonly sm: import("@angular/core").Signal<boolean>;
4767
+ readonly md: import("@angular/core").Signal<boolean>;
4768
+ readonly lg: import("@angular/core").Signal<boolean>;
4769
+ readonly xl: import("@angular/core").Signal<boolean>;
4770
+ readonly smAndDown: import("@angular/core").Signal<boolean>;
4771
+ readonly mdAndDown: import("@angular/core").Signal<boolean>;
4772
+ readonly lgAndDown: import("@angular/core").Signal<boolean>;
4773
+ readonly xlAndDown: import("@angular/core").Signal<boolean>;
4774
+ readonly smAndUp: import("@angular/core").Signal<boolean>;
4775
+ readonly mdAndUp: import("@angular/core").Signal<boolean>;
4776
+ readonly lgAndUp: import("@angular/core").Signal<boolean>;
4777
+ readonly xlAndUp: import("@angular/core").Signal<boolean>;
4778
+ constructor();
4779
+ setBreakpoints(partial: DasarThemeBreakpoints): void;
4780
+ private readWindow;
4781
+ static ɵfac: i0.ɵɵFactoryDeclaration<DasarBreakpointService, never>;
4782
+ static ɵprov: i0.ɵɵInjectableDeclaration<any>;
4783
+ }
4784
+ export interface DasarBreakpointConfig {
4785
+ hiddenAt?: DasarBreakpointName[] | null;
4786
+ showAt?: DasarBreakpointName[] | null;
4787
+ }
4788
+ export declare const normalizeBreakpointList: (value: DasarBreakpointName[] | string | null | undefined) => DasarBreakpointName[];
4789
+ export declare class DasarBreakpoint {
4790
+ private themeProvider;
4791
+ private themeService;
4792
+ private breakpoint;
4793
+ private isBrowser;
4794
+ private hiddenList;
4795
+ private showList;
4796
+ private lastName;
4797
+ private lastVisible;
4798
+ readonly visible: import("@angular/core").Signal<boolean>;
4799
+ constructor();
4800
+ set hiddenAt(value: DasarBreakpointName[] | string | null);
4801
+ get hiddenAt(): DasarBreakpointName[];
4802
+ set showAt(value: DasarBreakpointName[] | string | null);
4803
+ get showAt(): DasarBreakpointName[];
4804
+ onMediaUpdate: EventEmitter<DasarBreakpointState>;
4805
+ onHidden: EventEmitter<DasarBreakpointState>;
4806
+ onShow: EventEmitter<DasarBreakpointState>;
4807
+ get hostClasses(): string;
4808
+ get hiddenAttr(): string | null;
4809
+ private warnOnConflict;
4810
+ static ɵfac: i0.ɵɵFactoryDeclaration<DasarBreakpoint, never>;
4811
+ static ɵcmp: i0.ɵɵComponentDeclaration<DasarBreakpoint, "dasar-breakpoint", never, {
4812
+ "hiddenAt": {
4813
+ "alias": "hidden-at";
4814
+ "required": false;
4815
+ };
4816
+ "showAt": {
4817
+ "alias": "show-at";
4818
+ "required": false;
4819
+ };
4820
+ }, {
4821
+ "onMediaUpdate": "onMediaUpdate";
4822
+ "onHidden": "onHidden";
4823
+ "onShow": "onShow";
4824
+ }, never, ["*"], true, never>;
4825
+ }
4826
+ export declare const DasarBreakpointComponent: readonly [typeof DasarBreakpoint];
4827
+ export declare const DASAR_THEME_PROVIDER: InjectionToken<DasarThemeProviderComponent>;
4828
+ export declare const defaultLightCommonTokens: DasarThemeCommon$1;
4829
+ export declare const defaultDarkCommonTokens: DasarThemeCommon$1;
4830
+ export declare class DasarThemeProviderComponent implements OnChanges {
4831
+ private el;
4832
+ private parentProvider;
4833
+ activeMode: import("@angular/core").WritableSignal<DasarThemeMode$1>;
4834
+ private previouslyInjectedVars;
4835
+ componentConfig?: DasarComponentConfig$1;
4836
+ tokenConfig?: DasarThemeConfig$1['tokens'];
4837
+ colorConfig?: DasarThemeConfig$1['colors'];
4838
+ mode: DasarThemeMode$1;
4839
+ constructor(el: ElementRef);
4840
+ ngOnChanges(changes: SimpleChanges): void;
4841
+ getResolvedCommonTokens(mode: DasarThemeMode$1): DasarThemeCommon$1;
4842
+ private applyTokenConfig;
4843
+ private injectMappedTokens;
4844
+ private injectColors;
4845
+ static ɵfac: i0.ɵɵFactoryDeclaration<DasarThemeProviderComponent, never>;
4846
+ static ɵcmp: i0.ɵɵComponentDeclaration<DasarThemeProviderComponent, "dasar-theme-provider", never, {
4847
+ "componentConfig": {
4848
+ "alias": "componentConfig";
4849
+ "required": false;
4850
+ };
4851
+ "tokenConfig": {
4852
+ "alias": "tokenConfig";
4853
+ "required": false;
4854
+ };
4855
+ "colorConfig": {
4856
+ "alias": "colorConfig";
4857
+ "required": false;
4858
+ };
4859
+ "mode": {
4860
+ "alias": "mode";
4861
+ "required": false;
4862
+ };
4863
+ }, {}, never, ["*"], true, never>;
4864
+ }
4865
+ export declare const commonMap: Record<keyof DasarThemeCommon$1, string>;
4866
+ export declare const buttonMap: Record<keyof DasarThemeButton$1, string>;
4867
+ export declare const buttonGroupMap: Record<keyof DasarThemeButtonGroup$1, string>;
4868
+ export declare const inputMap: Record<keyof DasarThemeInput$1, string>;
4869
+ export declare const calendarMap: Record<keyof DasarThemeCalendar$1, string>;
4870
+ export declare const datepickerMap: Record<keyof DasarThemeDatepicker$1, string>;
4871
+ export declare const chipMap: Record<keyof DasarThemeChip$1, string>;
4872
+ export declare const dividerMap: Record<keyof DasarThemeDivider$1, string>;
4873
+ export declare const alertMap: Record<keyof DasarThemeAlert$1, string>;
4874
+ export declare const checkboxMap: Record<keyof DasarThemeCheckbox$1, string>;
4875
+ export declare const radioMap: Record<keyof DasarThemeRadio$1, string>;
4876
+ export declare const selectMap: Record<keyof DasarThemeSelect$1, string>;
4877
+ export declare const cardMap: Record<keyof DasarThemeCard$1, string>;
4878
+ export declare const menuMap: Record<keyof DasarThemeMenu$1, string>;
4879
+ export declare const tableMap: Record<string, string>;
4880
+ export declare const listMap: Record<string, string>;
4881
+ export declare const tabsMap: Record<keyof DasarThemeTabs$1, string>;
4882
+ export declare const overlayMap: Record<keyof DasarThemeOverlay$1, string>;
4883
+ export declare const modalMap: Record<keyof DasarThemeModal$1, string>;
4884
+ export declare class DasarThemeService {
4885
+ private themeState;
4886
+ theme$: Observable<DasarThemeConfig$1>;
4887
+ private initialConfig;
4888
+ private platformId;
4889
+ private document;
4890
+ private renderer;
4891
+ constructor(rendererFactory: RendererFactory2);
4892
+ setGlobalTheme(config: DasarThemeConfig$1, targetElement?: HTMLElement): void;
4893
+ themeVariable(): DasarThemeConfig$1;
4894
+ rawThemeVariable(): DasarThemeConfig$1;
4895
+ private injectMappedTokens;
4896
+ private injectColors;
4897
+ static ɵfac: i0.ɵɵFactoryDeclaration<DasarThemeService, never>;
4898
+ static ɵprov: i0.ɵɵInjectableDeclaration<any>;
4899
+ }
4900
+ export declare function fieldIconSize(size: string | number | null | undefined): number;
4075
4901
  export {};