@wlcm/angular 19.2.6 → 22.0.1

package/forms/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@wlcm/angular/forms",
+  "version": "0.0.1",
+  "peerDependencies": {
+    "@angular/common": "^22.0.0",
+    "@angular/core": "^22.0.0",
+    "@angular/forms": "^22.0.0",
+    "@angular/material": "^22.0.0",
+    "rxjs": "~7.8.1",
+    "@wlcm/angular/core": "0.0.1",
+    "@wlcm/common": "^1.0.2",
+    "lodash-es": "^4.17.21",
+    "@angular/cdk": "^22.0.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/wlcm-angular-forms.mjs",
+  "typings": "types/wlcm-angular-forms.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/wlcm-angular-forms.d.ts",
+      "default": "./fesm2022/wlcm-angular-forms.mjs"
+    }
+  },
+  "type": "module"
+}

package/forms/types/wlcm-angular-forms.d.ts

@@ -0,0 +1,365 @@
+import * as i0 from '@angular/core';
+import { ElementRef, AfterViewInit, OnInit, InputSignal, TemplateRef, OutputEmitterRef, WritableSignal, Signal, AfterContentInit, InjectionToken, Provider } from '@angular/core';
+import { AbstractControl, ControlValueAccessor, Validator, FormControl, ValidationErrors } from '@angular/forms';
+import { Observable, Subject } from 'rxjs';
+import { WlcmAutocompleteOption, WlcmSelectOptionFormat, WlcmIconName, WlcmOption } from '@wlcm/angular/core';
+import { WlcmQueryParams, WlcmPaginatedData } from '@wlcm/common';
+import { MatCheckboxChange } from '@angular/material/checkbox';
+import { MatSelectConfig, MatOption, MatSelectChange, MatSelect } from '@angular/material/select';
+import * as i13 from '@angular/material/radio';
+
+declare class WlcmFormFieldCustomContainerDirective {
+    elementRef: ElementRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WlcmFormFieldCustomContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WlcmFormFieldCustomContainerDirective, "[wlcmFormFieldCustomContainer]", never, {}, {}, never, never, true, never>;
+}
+
+declare class WlcmFormFieldPrefixDirective {
+    handlerClick: (event: MouseEvent) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WlcmFormFieldPrefixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WlcmFormFieldPrefixDirective, "[wlcmFormFieldPrefix]", never, {}, {}, never, never, true, never>;
+}
+
+declare class WlcmFormFieldSuffixDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<WlcmFormFieldSuffixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WlcmFormFieldSuffixDirective, "[wlcmFormFieldSuffix]", never, {}, {}, never, never, true, never>;
+}
+
+declare class WlcmFormFieldComponent implements AfterViewInit {
+    displayErrorMessages: i0.InputSignal<boolean>;
+    private ngControl;
+    private controlContainer;
+    private _inputRef;
+    protected prefix: i0.Signal<WlcmFormFieldPrefixDirective | undefined>;
+    protected suffix: i0.Signal<WlcmFormFieldSuffixDirective | undefined>;
+    protected customContainer: i0.Signal<WlcmFormFieldCustomContainerDirective | undefined>;
+    protected defaultContainer: i0.Signal<ElementRef<HTMLElement> | undefined>;
+    get isFocused(): boolean;
+    get isRequired(): boolean | undefined;
+    get isInvalid(): boolean | undefined;
+    get isTouched(): boolean | undefined;
+    get isDisabled(): boolean | undefined;
+    private parentFormMember;
+    private changeDetectorRef;
+    private destroyRef;
+    ngAfterViewInit(): void;
+    focus(): void;
+    get control(): AbstractControl | null;
+    get inputContainer(): ElementRef<HTMLElement>;
+    private handleStateChanges;
+    private get inputRef();
+    private get controlEvents();
+    static ɵfac: i0.ɵɵFactoryDeclaration<WlcmFormFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WlcmFormFieldComponent, "wlcm-form-field", never, { "displayErrorMessages": { "alias": "displayErrorMessages"; "required": false; "isSignal": true; }; }, {}, ["ngControl", "controlContainer", "_inputRef", "prefix", "suffix", "customContainer"], ["wlcm-label", "[wlcmFormFieldCustomContainer]", "[wlcmFormFieldPrefix]", "[wlcmInput]", "[wlcmFormFieldSuffix]", "[wlcmFormFieldHint]"], true, never>;
+}
+
+type WlcmAutocompleteValue = WlcmAutocompleteOption | string | null;
+declare abstract class WlcmAutocomplete {
+    abstract loading$: Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WlcmAutocomplete, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WlcmAutocomplete, never, never, {}, {}, never, never, true, never>;
+}
+
+interface WlcmInputGetter {
+    get: () => WlcmFormFieldInput;
+}
+interface WlcmInputBinder {
+    bind: () => WlcmFormFieldInput;
+}
+interface WlcmFormFieldInput {
+    focus$: Observable<unknown>;
+    blur$: Observable<unknown>;
+    isFocused(): boolean;
+    focus(): void;
+}
+
+type Option = WlcmAutocompleteOption;
+declare class WlcmAutocompleteComponent extends WlcmAutocomplete implements OnInit, ControlValueAccessor, Validator, AfterViewInit, WlcmFormFieldInput {
+    fetchPaginatedOptions: InputSignal<(params: WlcmQueryParams) => Observable<WlcmPaginatedData<Option>>>;
+    label: InputSignal<string>;
+    required: InputSignal<boolean>;
+    placeholder: InputSignal<string>;
+    optionTemplate: InputSignal<TemplateRef<{
+        $implicit: WlcmAutocompleteOption;
+    }> | undefined>;
+    queryParams: i0.InputSignalWithTransform<WlcmQueryParams, WlcmQueryParams>;
+    private _queryParams;
+    selectOptionFormat: InputSignal<WlcmSelectOptionFormat>;
+    noResultsTemplate: InputSignal<TemplateRef<{
+        $implicit: WlcmAutocompleteValue;
+        loading: boolean;
+    }> | undefined>;
+    selected: OutputEmitterRef<WlcmAutocompleteValue>;
+    readonly control: FormControl<WlcmAutocompleteValue>;
+    private readonly _loadMore$;
+    readonly options: WritableSignal<Option[]>;
+    protected readonly closed$: Subject<void>;
+    private readonly _focusStream$;
+    private readonly _blurStream$;
+    readonly loading: WritableSignal<boolean>;
+    loading$: Observable<boolean>;
+    focus$: Observable<unknown>;
+    blur$: Observable<unknown>;
+    private _changed?;
+    private _touched?;
+    private _onValidatorChange?;
+    private adjustedValue$;
+    private _paginatedData;
+    private _reloadOptions$;
+    private viewReady$;
+    inputElement: Signal<ElementRef<HTMLInputElement> | undefined>;
+    private autocompleteTrigger;
+    private autocomplete;
+    private injector;
+    private formField;
+    private destroyRef;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    displayWith(value: Option | string): string;
+    focus(): void;
+    isFocused(): boolean;
+    loadMore(): void;
+    writeValue(value: WlcmAutocompleteValue): void;
+    registerOnChange(callback: (value: WlcmAutocompleteValue) => void): void;
+    registerOnTouched(callback: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    reloadOptions(): void;
+    blured(): void;
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    private prepareValueForPatch;
+    private loadOptions;
+    private handleLoadMoreEvent;
+    private handleControlValueChanges;
+    private attachFocusBlurListeners;
+    private handleAdjustedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WlcmAutocompleteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WlcmAutocompleteComponent, "wlcm-autocomplete", ["wlcmAutocomplete"], { "fetchPaginatedOptions": { "alias": "fetchPaginatedOptions"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "optionTemplate": { "alias": "optionTemplate"; "required": false; "isSignal": true; }; "queryParams": { "alias": "queryParams"; "required": false; "isSignal": true; }; "selectOptionFormat": { "alias": "selectOptionFormat"; "required": false; "isSignal": true; }; "noResultsTemplate": { "alias": "noResultsTemplate"; "required": false; "isSignal": true; }; }, { "selected": "selected"; }, never, never, true, never>;
+}
+
+declare class WlcmAutocompleteSuffixComponent {
+    autocomplete: InputSignal<WlcmAutocomplete>;
+    readonly WlcmIconName: typeof WlcmIconName;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WlcmAutocompleteSuffixComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WlcmAutocompleteSuffixComponent, "wlcm-autocomplete-suffix", never, { "autocomplete": { "alias": "autocomplete"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class WlcmCheckboxComponent implements ControlValueAccessor, Validator {
+    private changeDetectorRef;
+    private parentFormMember;
+    private destroyRef;
+    value: InputSignal<string | undefined>;
+    changed: OutputEmitterRef<boolean>;
+    private _changed?;
+    private _touched?;
+    private _validatorChanged?;
+    protected control: FormControl;
+    constructor();
+    handleChange(value: MatCheckboxChange): void;
+    writeValue(value: boolean): void;
+    validate: () => ValidationErrors | null;
+    registerOnChange(callback: (value: boolean) => void): void;
+    registerOnTouched(callback: () => void): void;
+    registerOnValidatorChange(callback: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    get checked(): boolean;
+    set checked(value: boolean);
+    private handleStateChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WlcmCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WlcmCheckboxComponent, "wlcm-checkbox", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, never, ["*"], true, never>;
+}
+
+declare class WlcmCheckboxGroupComponent implements AfterContentInit, ControlValueAccessor, Validator {
+    private destroyRef;
+    checkboxes: Signal<readonly WlcmCheckboxComponent[]>;
+    private checkboxesMap;
+    private values;
+    private checkboxesListUpdated;
+    private _changed?;
+    private _touched?;
+    private _validatorChanged?;
+    constructor();
+    ngAfterContentInit(): void;
+    writeValue(value: string[]): void;
+    validate: () => ValidationErrors | null;
+    registerOnChange(callback: (value: string[]) => void): void;
+    registerOnTouched(callback: () => void): void;
+    registerOnValidatorChange(callback: () => void): void;
+    private updateControl;
+    private updateCheckboxes;
+    private handleCheckboxesToggle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WlcmCheckboxGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WlcmCheckboxGroupComponent, "wlcm-checkbox-group", never, {}, {}, ["checkboxes"], ["wlcm-checkbox"], true, never>;
+}
+
+type WlcmFormErrors = {
+    [key: string]: WlcmFormErrorFn;
+};
+type WlcmFormErrorFn = (error: ValidationErrors) => string;
+
+interface WlcmForm {
+    updateFormState(): void;
+}
+interface WlcmFormControl {
+    readonly stateChanges$: Observable<void>;
+}
+interface WlcmFormField {
+    get inputContainer(): ElementRef<HTMLElement>;
+}
+
+type WlcmSelectValue = WlcmOption[] | WlcmOption | string[] | string;
+type IsOptionDisabledFn = (option: WlcmOption | string) => boolean;
+interface WlcmSelectConfig extends MatSelectConfig {
+    overlayPanelClass?: string[];
+}
+type WlcmCanSelectFn = (value: WlcmSelectValue) => Observable<boolean> | boolean;
+
+declare class WlcmSelectInputBinderDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<WlcmSelectInputBinderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WlcmSelectInputBinderDirective, "[wlcmSelectInputBinder]", never, {}, {}, never, never, true, never>;
+}
+
+type OptionTemplateContext = TemplateRef<{
+    $implicit: WlcmOption;
+}>;
+declare class WlcmSelectComponent implements WlcmFormFieldInput, ControlValueAccessor, Validator, AfterViewInit {
+    multiple: InputSignal<boolean>;
+    placeholder: InputSignal<string>;
+    fetchPaginatedOptions: InputSignal<((params: WlcmQueryParams) => Observable<WlcmPaginatedData<WlcmOption>>) | undefined>;
+    canSelect: InputSignal<WlcmCanSelectFn>;
+    queryParams: InputSignal<WlcmQueryParams>;
+    protected _queryParams: WritableSignal<WlcmQueryParams>;
+    paginated: InputSignal<boolean>;
+    options: InputSignal<WlcmOption[]>;
+    paginatedOptions: WritableSignal<WlcmOption[]>;
+    selectOptionFormat: InputSignal<WlcmSelectOptionFormat>;
+    optionTemplate: InputSignal<TemplateRef<OptionTemplateContext> | null>;
+    triggerTemplate: InputSignal<TemplateRef<MatOption | MatOption[]> | undefined>;
+    isOptionDisabled: InputSignal<IsOptionDisabledFn>;
+    selectionChange: OutputEmitterRef<MatSelectChange>;
+    opened: OutputEmitterRef<void>;
+    closed: OutputEmitterRef<void>;
+    readonly value: WritableSignal<WlcmSelectValue | null>;
+    readonly disabled: WritableSignal<boolean>;
+    readonly WlcmIconName: typeof WlcmIconName;
+    private _changed?;
+    private _touched?;
+    private _validatorChanged?;
+    private _paginatedData;
+    private _previousValue;
+    private _optionsCache;
+    computedOptions: Signal<WlcmOption[]>;
+    prefilledOptions: WritableSignal<WlcmOption[]>;
+    matSelect: Signal<MatSelect | undefined>;
+    openPanel(): void;
+    protected matOptions: Signal<ReadonlyArray<MatOption>>;
+    private readonly _focusStream$;
+    private readonly _blurStream$;
+    focus$: Observable<unknown>;
+    blur$: Observable<unknown>;
+    private adjustedValue$;
+    private viewReady$;
+    private selected$;
+    private changeDetectorRef;
+    private scrollDetectionApi;
+    private formField;
+    private parentFormMember;
+    private destroyRef;
+    constructor();
+    ngAfterViewInit(): void;
+    private setPreferredOverlayOrigin;
+    compareWith: (optionA: WlcmOption | string, optionB: WlcmOption | string) => boolean;
+    focus: () => void;
+    isFocused: () => boolean;
+    select(event: MatSelectChange): void;
+    private areOptionsEqual;
+    private revertPreviousValue;
+    private updateValue;
+    private validateSelectedOption;
+    protected panelOpened(): void;
+    protected panelClosed(): void;
+    updateOptionsStatus(): void;
+    writeValue(value: WlcmSelectValue): void;
+    registerOnChange(callback: (value: WlcmSelectValue) => void): void;
+    registerOnTouched(callback: () => void): void;
+    registerOnValidatorChange(callback: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    validate(): ValidationErrors | null;
+    get isOpen(): boolean;
+    private prepareValueForPatch;
+    private formatValue;
+    private formatOption;
+    private loadPaginatedOptions;
+    private loadMorePaginatedOptions;
+    private cacheOptions;
+    private syncPrefilledOptions;
+    private prefillOptions;
+    private handleScrollDown;
+    private handleStateChange;
+    private handleAdjustedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WlcmSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WlcmSelectComponent, "wlcm-select", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "fetchPaginatedOptions": { "alias": "fetchPaginatedOptions"; "required": false; "isSignal": true; }; "canSelect": { "alias": "canSelect"; "required": false; "isSignal": true; }; "queryParams": { "alias": "queryParams"; "required": false; "isSignal": true; }; "paginated": { "alias": "paginated"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "selectOptionFormat": { "alias": "selectOptionFormat"; "required": false; "isSignal": true; }; "optionTemplate": { "alias": "optionTemplate"; "required": false; "isSignal": true; }; "triggerTemplate": { "alias": "triggerTemplate"; "required": false; "isSignal": true; }; "isOptionDisabled": { "alias": "isOptionDisabled"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; "opened": "opened"; "closed": "closed"; }, never, never, true, [{ directive: typeof WlcmSelectInputBinderDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class WlcmLabelComponent {
+    required: i0.InputSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WlcmLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WlcmLabelComponent, "wlcm-label", never, { "required": { "alias": "required"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class WlcmInputDirective implements WlcmFormFieldInput {
+    private _elementRef;
+    constructor();
+    focus: () => void;
+    isFocused: () => boolean;
+    focus$: Observable<unknown>;
+    blur$: Observable<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WlcmInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WlcmInputDirective, "[wlcmInput]", never, {}, {}, never, never, true, never>;
+}
+
+declare class WlcmFormFieldHintDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<WlcmFormFieldHintDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WlcmFormFieldHintDirective, "[wlcmFormFieldHint]", never, {}, {}, never, never, true, never>;
+}
+
+declare class WlcmFormsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<WlcmFormsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<WlcmFormsModule, never, [typeof WlcmFormFieldComponent, typeof WlcmAutocompleteComponent, typeof WlcmAutocompleteSuffixComponent, typeof WlcmCheckboxGroupComponent, typeof WlcmCheckboxComponent, typeof WlcmSelectComponent, typeof WlcmLabelComponent, typeof WlcmInputDirective, typeof WlcmFormFieldCustomContainerDirective, typeof WlcmFormFieldSuffixDirective, typeof WlcmFormFieldPrefixDirective, typeof WlcmFormFieldHintDirective, typeof i13.MatRadioModule], [typeof WlcmFormFieldComponent, typeof WlcmAutocompleteComponent, typeof WlcmAutocompleteSuffixComponent, typeof WlcmCheckboxGroupComponent, typeof WlcmCheckboxComponent, typeof WlcmSelectComponent, typeof WlcmLabelComponent, typeof WlcmInputDirective, typeof WlcmFormFieldCustomContainerDirective, typeof WlcmFormFieldSuffixDirective, typeof WlcmFormFieldPrefixDirective, typeof WlcmFormFieldHintDirective, typeof i13.MatRadioModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<WlcmFormsModule>;
+}
+
+declare const WLCM_ERRORS: InjectionToken<WlcmFormErrors>;
+declare const WLCM_PRIORITY_ERRORS: InjectionToken<Set<string>>;
+
+declare const WLCM_INPUT: InjectionToken<WlcmInputGetter>;
+declare const WLCM_INPUT_BINDER: InjectionToken<WlcmInputBinder>;
+declare const WLCM_FORM_FIELD: InjectionToken<WlcmFormField>;
+
+declare const WLCM_FORM: InjectionToken<WlcmForm>;
+declare const WLCM_FORM_PROVIDER: Provider;
+declare const WLCM_FORM_CONTROL: InjectionToken<WlcmFormControl>;
+declare const WLCM_FORM_CONTROL_PROVIDER: Provider;
+
+declare const WLCM_SELECT_CONFIG: InjectionToken<WlcmSelectConfig>;
+
+declare const WLCM_MAPS_API_ERROR = "Google Maps JavaScript API not loaded. Please ensure the following script is included in your HTML: <script src=\"https://maps.googleapis.com/maps/api/js?key=[apiKey]&libraries=places\"></script>";
+
+declare const WLCM_FORM_FIELD_INPUT_CLASS = "wlcm-form-field-input";
+
+declare abstract class WlcmPlacesApi {
+    abstract getPlacesPaginated(query: string): Observable<WlcmPaginatedData<WlcmAutocompleteOption>>;
+    abstract get placesService(): google.maps.places.PlacesService;
+    abstract get autocompleteService(): google.maps.places.AutocompleteService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WlcmPlacesApi, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WlcmPlacesApi>;
+}
+
+declare class WlcmErrorComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<WlcmErrorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WlcmErrorComponent, "wlcm-error", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { WLCM_ERRORS, WLCM_FORM, WLCM_FORM_CONTROL, WLCM_FORM_CONTROL_PROVIDER, WLCM_FORM_FIELD, WLCM_FORM_FIELD_INPUT_CLASS, WLCM_FORM_PROVIDER, WLCM_INPUT, WLCM_INPUT_BINDER, WLCM_MAPS_API_ERROR, WLCM_PRIORITY_ERRORS, WLCM_SELECT_CONFIG, WlcmAutocomplete, WlcmAutocompleteComponent, WlcmAutocompleteSuffixComponent, WlcmCheckboxComponent, WlcmCheckboxGroupComponent, WlcmErrorComponent, WlcmFormFieldComponent, WlcmFormFieldCustomContainerDirective, WlcmFormFieldHintDirective, WlcmFormFieldPrefixDirective, WlcmFormFieldSuffixDirective, WlcmFormsModule, WlcmInputDirective, WlcmLabelComponent, WlcmPlacesApi, WlcmSelectComponent, WlcmSelectInputBinderDirective };
+export type { IsOptionDisabledFn, WlcmAutocompleteValue, WlcmCanSelectFn, WlcmForm, WlcmFormControl, WlcmFormErrorFn, WlcmFormErrors, WlcmFormField, WlcmFormFieldInput, WlcmInputBinder, WlcmInputGetter, WlcmSelectConfig, WlcmSelectValue };

package/package.json

@@ -1,102 +1,83 @@
 {
   "name": "@wlcm/angular",
-  "version": "19.2.6",
+  "version": "22.0.1",
   "license": "MIT",
   "type": "module",
   "module": "./index.mjs",
   "typings": "./index.d.ts",
+  "sideEffects": false,
   "private": false,
   "exports": {
     ".": {
+      "types": "./index.d.ts",
       "sass": "./styles/_index.scss",
       "esm": "./index.mjs",
-      "types": "./index.d.ts",
       "default": "./index.mjs"
     },
     "./core": {
-      "types": "./core/index.d.ts",
-      "esm2022": "./core/esm2022/wlcm-angular-core.mjs",
-      "fesm2022": "./core/fesm2022/wlcm-angular-core.mjs",
+      "types": "./core/types/wlcm-angular-core.d.ts",
       "default": "./core/fesm2022/wlcm-angular-core.mjs"
     },
     "./button": {
-      "types": "./button/index.d.ts",
-      "esm2022": "./button/esm2022/wlcm-angular-button.mjs",
-      "fesm2022": "./button/fesm2022/wlcm-angular-button.mjs",
+      "types": "./button/types/wlcm-angular-button.d.ts",
       "default": "./button/fesm2022/wlcm-angular-button.mjs"
     },
     "./filters": {
-      "types": "./filters/index.d.ts",
-      "esm2022": "./filters/esm2022/wlcm-angular-filters.mjs",
-      "fesm2022": "./filters/fesm2022/wlcm-angular-filters.mjs",
+      "types": "./filters/types/wlcm-angular-filters.d.ts",
       "default": "./filters/fesm2022/wlcm-angular-filters.mjs"
     },
     "./forms": {
-      "types": "./forms/index.d.ts",
-      "esm2022": "./forms/esm2022/wlcm-angular-forms.mjs",
-      "fesm2022": "./forms/fesm2022/wlcm-angular-forms.mjs",
+      "types": "./forms/types/wlcm-angular-forms.d.ts",
       "default": "./forms/fesm2022/wlcm-angular-forms.mjs"
     },
     "./search-field": {
-      "types": "./search-field/index.d.ts",
-      "esm2022": "./search-field/esm2022/wlcm-angular-search-field.mjs",
-      "fesm2022": "./search-field/fesm2022/wlcm-angular-search-field.mjs",
+      "types": "./search-field/types/wlcm-angular-search-field.d.ts",
       "default": "./search-field/fesm2022/wlcm-angular-search-field.mjs"
     },
     "./datepicker": {
-      "types": "./datepicker/index.d.ts",
-      "esm2022": "./datepicker/esm2022/wlcm-angular-datepicker.mjs",
-      "fesm2022": "./datepicker/fesm2022/wlcm-angular-datepicker.mjs",
+      "types": "./datepicker/types/wlcm-angular-datepicker.d.ts",
       "default": "./datepicker/fesm2022/wlcm-angular-datepicker.mjs"
     },
     "./phone-input": {
-      "types": "./phone-input/index.d.ts",
-      "esm2022": "./phone-input/esm2022/wlcm-angular-phone-input.mjs",
-      "fesm2022": "./phone-input/fesm2022/wlcm-angular-phone-input.mjs",
+      "types": "./phone-input/types/wlcm-angular-phone-input.d.ts",
       "default": "./phone-input/fesm2022/wlcm-angular-phone-input.mjs"
     },
     "./stepper": {
-      "types": "./stepper/index.d.ts",
-      "esm2022": "./stepper/esm2022/wlcm-angular-stepper.mjs",
-      "fesm2022": "./stepper/fesm2022/wlcm-angular-stepper.mjs",
+      "types": "./stepper/types/wlcm-angular-stepper.d.ts",
       "default": "./stepper/fesm2022/wlcm-angular-stepper.mjs"
     },
     "./table": {
-      "types": "./table/index.d.ts",
-      "esm2022": "./table/esm2022/wlcm-angular-table.mjs",
-      "fesm2022": "./table/fesm2022/wlcm-angular-table.mjs",
+      "types": "./table/types/wlcm-angular-table.d.ts",
       "default": "./table/fesm2022/wlcm-angular-table.mjs"
     }
   },
   "dependencies": {
-    "@ngneat/until-destroy": "^10.0.0",
-    "@rx-angular/template": "^19.2.1",
     "@types/google.maps": "^3.58.1",
-    "@types/lodash-es": "^4.17.12",
     "@wlcm/common": "^1.0.2",
     "countries-list": "^3.1.1",
     "date-fns": "^4.1.0",
     "imask": "^7.6.1",
-    "@nx/angular": "^20.5.0",
     "libphonenumber-js": "^1.11.18",
     "lodash-es": "^4.17.21",
     "rxjs": "~7.8.1",
     "tslib": "^2.8.1",
-    "uuid": "^11.0.5",
-    "zone.js": "0.15.0"
+    "uuid": "^11.0.5"
   },
   "peerDependencies": {
-    "@angular/animations": "^19.2.0",
-    "@angular/cdk": "^19.2.0",
-    "@angular/common": "^19.2.0",
-    "@angular/compiler": "^19.2.0",
-    "@angular/core": "^19.2.0",
-    "@angular/forms": "^19.2.0",
-    "@angular/material": "^19.2.0",
-    "@angular/material-date-fns-adapter": "^19.2.0",
-    "@angular/platform-browser": "^19.2.0",
-    "@angular/platform-browser-dynamic": "^19.2.0",
-    "@angular/router": "^19.2.0"
+    "@angular/animations": "^22.0.0",
+    "@angular/cdk": "^22.0.0",
+    "@angular/common": "^22.0.0",
+    "@angular/compiler": "^22.0.0",
+    "@angular/core": "^22.0.0",
+    "@angular/forms": "^22.0.0",
+    "@angular/material": "^22.0.0",
+    "@angular/material-date-fns-adapter": "^22.0.0",
+    "@angular/platform-browser": "^22.0.0",
+    "@angular/platform-browser-dynamic": "^22.0.0",
+    "@angular/router": "^22.0.0"
+  },
+  "engines": {
+    "node": ">=22.12.0"
   },
   "devDependencies": {}
 }