@libs-ui/components-datetime-dropdown 0.1.1-1

package/README.md

@@ -0,0 +1,3 @@
+# datetime-dropdown
+
+This library was generated with [Nx](https://nx.dev).

package/defines/date-dropdown.define.d.ts

@@ -0,0 +1,40 @@
+import { TranslateService } from '@ngx-translate/core';
+import { TYPE_DATE_FORMAT, TYPE_DROPDOWN_MONTH_ID } from '../interfaces/date-dropdown.interface';
+import { IHttpRequestConfig } from '@libs-ui/services-http-request';
+export declare const convertGetValue: (type: TYPE_DATE_FORMAT, item: {
+    label: string;
+}, translate: TranslateService) => any;
+export declare const convertItemSelectedDefine: (type: TYPE_DATE_FORMAT, item: {
+    id: number;
+    label: string;
+    labelDisplay: string;
+}, translate: TranslateService, getItemYearDisplay?: (label: string) => void, ignoreConvertYearSelected?: boolean) => any;
+export declare const LIST_MONTHS_DEFAULT: () => Array<{
+    id: number;
+    label: string;
+}>;
+export declare const CompareDate: (dateCompare: Array<{
+    from: number | undefined;
+    to: number | undefined;
+}>, ignoreAllowTimeSame: boolean) => boolean;
+export declare const getConfigHttpRequestDetailDate: (data: Array<{
+    id: number;
+    label: string;
+}>) => IHttpRequestConfig;
+export declare const getConfigHttpRequestListDate: (data: Array<{
+    id: number;
+    label: string;
+}>) => IHttpRequestConfig;
+export declare const buildListDataByTypeDate: (type: TYPE_DATE_FORMAT, dataYear: {
+    minYear?: number;
+    maxYear?: number;
+    reverseYear?: boolean;
+}, keyMonth: any) => Array<{
+    id: number;
+    label: string;
+}>;
+export declare const defaultMonths: () => Array<{
+    id: TYPE_DROPDOWN_MONTH_ID;
+    label: string;
+    maxDays: number;
+}>;

package/directive/date-dropdown.directive.d.ts

@@ -0,0 +1,11 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class LibsUiComponentsDatetimeDropdownDirective implements OnInit, OnDestroy {
+    private resizeObserver;
+    private elementRef;
+    readonly outChangeWidth: import("@angular/core").OutputEmitterRef<number>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LibsUiComponentsDatetimeDropdownDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LibsUiComponentsDatetimeDropdownDirective, "[LibsUiComponentsDatetimeDropdownDirective]", never, {}, { "outChangeWidth": "outChangeWidth"; }, never, never, true, never>;
+}

package/dropdown.component.d.ts

@@ -0,0 +1,89 @@
+import { AfterViewInit, OnInit } from '@angular/core';
+import { ILabel } from '@libs-ui/components-label';
+import { IFlagMouse } from '@libs-ui/components-popover';
+import { IDateDropdownDisableKeys, IFromAndToDateLabel, IHiddenDate, TYPE_DATE_FORMAT } from './interfaces/date-dropdown.interface';
+import { IEmitMultiDateDropdown, IEmitSingleDateDropdown } from './interfaces/emit-dropdown.interface';
+import { IDateDropdownFunctionControlEvent, IDateDropdownItemFunctionControlEvent } from './interfaces/functions-control-event.interface';
+import { IValidDateDropdown } from './interfaces/valid.interface';
+import * as i0 from "@angular/core";
+export declare class LibsUiComponentsDatetimeDropdownComponent implements OnInit, AfterViewInit {
+    protected width: import("@angular/core").WritableSignal<number>;
+    protected widthElement: import("@angular/core").WritableSignal<number | undefined>;
+    protected widthLabel: import("@angular/core").WritableSignal<number | undefined>;
+    protected widthLabelFrom: import("@angular/core").WritableSignal<number>;
+    protected widthLabelTo: import("@angular/core").WritableSignal<number>;
+    protected isErrorCompareDate: import("@angular/core").WritableSignal<boolean | undefined>;
+    protected chooseDate: import("@angular/core").WritableSignal<IEmitMultiDateDropdown | undefined>;
+    protected isResponsive: import("@angular/core").WritableSignal<boolean | undefined>;
+    protected arrayFormat: import("@angular/core").Signal<TYPE_DATE_FORMAT[]>;
+    protected changeType: import("@angular/core").WritableSignal<boolean | undefined>;
+    private cacheWidthLabel;
+    private timeOut;
+    private onDestroy;
+    private functionsControl;
+    readonly labelConfig: import("@angular/core").InputSignal<ILabel | undefined>;
+    readonly widthDropdown: import("@angular/core").InputSignalWithTransform<number, number>;
+    readonly zIndex: import("@angular/core").InputSignalWithTransform<number, number>;
+    readonly maxYear: import("@angular/core").InputSignal<number>;
+    readonly minYear: import("@angular/core").InputSignal<number>;
+    readonly minWidth: import("@angular/core").InputSignal<number | undefined>;
+    readonly disable: import("@angular/core").InputSignal<boolean>;
+    readonly readonly: import("@angular/core").InputSignal<boolean>;
+    readonly isMultiple: import("@angular/core").InputSignal<boolean>;
+    readonly reverseYear: import("@angular/core").InputSignal<boolean | undefined>;
+    readonly isBorderError: import("@angular/core").InputSignal<boolean>;
+    readonly ignoreWidth100: import("@angular/core").InputSignal<boolean>;
+    readonly widthByElement: import("@angular/core").InputSignal<boolean>;
+    readonly disableSecond: import("@angular/core").InputSignal<boolean>;
+    readonly typeFormat: import("@angular/core").InputSignalWithTransform<string, string>;
+    readonly fromAndToDateLabel: import("@angular/core").InputSignal<IFromAndToDateLabel>;
+    readonly listHasButtonUnSelectOption: import("@angular/core").InputSignal<boolean>;
+    readonly selectedDateTime: import("@angular/core").InputSignal<IEmitMultiDateDropdown | undefined>;
+    readonly isEmitAfterChanged: import("@angular/core").InputSignal<boolean>;
+    readonly getItemYearDisplay: import("@angular/core").InputSignal<((year: string) => string) | undefined>;
+    readonly ignoreFromAndToDateLabel: import("@angular/core").InputSignal<boolean>;
+    readonly classIncludeTextDisplayWhenNoSelect: import("@angular/core").InputSignal<string | undefined>;
+    readonly hiddenDate: import("@angular/core").InputSignal<IHiddenDate | undefined>;
+    readonly listMaxItemShow: import("@angular/core").InputSignal<{
+        year?: number;
+        month?: number;
+        quarter?: number;
+        day?: number;
+    } | undefined>;
+    readonly ignoreConvertYearSelected: import("@angular/core").InputSignal<boolean>;
+    readonly listKeysDisable: import("@angular/core").InputSignal<IDateDropdownDisableKeys | undefined>;
+    readonly ignoreAllowTimeEqual: import("@angular/core").InputSignalWithTransform<boolean, boolean>;
+    readonly ignoreValidTimeCompare: import("@angular/core").InputSignalWithTransform<boolean, boolean>;
+    readonly isCheckErrorWhenSelectItem: import("@angular/core").InputSignalWithTransform<boolean, boolean>;
+    readonly ignoreRequiredValueSecondWhenNotValidRequired: import("@angular/core").InputSignal<boolean>;
+    readonly validRequired: import("@angular/core").InputSignal<IValidDateDropdown | undefined>;
+    readonly outFunctionsControl: import("@angular/core").OutputEmitterRef<IDateDropdownFunctionControlEvent>;
+    readonly outSelectedDropdown: import("@angular/core").OutputEmitterRef<IEmitMultiDateDropdown | IEmitSingleDateDropdown>;
+    readonly outChooseMultiDate: import("@angular/core").OutputEmitterRef<IEmitMultiDateDropdown>;
+    readonly outChooseSingleDate: import("@angular/core").OutputEmitterRef<IEmitSingleDateDropdown>;
+    readonly outChangStageFlagMouse: import("@angular/core").OutputEmitterRef<IFlagMouse>;
+    private containerRef;
+    private labelFromRef;
+    private labelToRef;
+    private translate;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    get FunctionsControl(): IDateDropdownFunctionControlEvent;
+    protected checkResponsive(): void;
+    protected handlerChangeSelectedKey(event: IEmitSingleDateDropdown, type: 'from' | 'to'): void;
+    private resetDropdown;
+    private resetError;
+    private setWidthDate;
+    protected handlerFunctionControl(event: IDateDropdownItemFunctionControlEvent, type: 'from' | 'to'): void;
+    protected checkValid(): Promise<boolean>;
+    private setError;
+    private compareDate;
+    private validate;
+    private checkCondition;
+    protected applyDate(): void;
+    protected handlerChangeWidthLabel(width: number): void;
+    protected handlerChangStageFlagMouse(flagMouse: IFlagMouse): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LibsUiComponentsDatetimeDropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LibsUiComponentsDatetimeDropdownComponent, "libs_ui-components-datetime-dropdown", never, { "labelConfig": { "alias": "labelConfig"; "required": false; "isSignal": true; }; "widthDropdown": { "alias": "widthDropdown"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "maxYear": { "alias": "maxYear"; "required": false; "isSignal": true; }; "minYear": { "alias": "minYear"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "disable": { "alias": "disable"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "isMultiple": { "alias": "isMultiple"; "required": false; "isSignal": true; }; "reverseYear": { "alias": "reverseYear"; "required": false; "isSignal": true; }; "isBorderError": { "alias": "isBorderError"; "required": false; "isSignal": true; }; "ignoreWidth100": { "alias": "ignoreWidth100"; "required": false; "isSignal": true; }; "widthByElement": { "alias": "widthByElement"; "required": false; "isSignal": true; }; "disableSecond": { "alias": "disableSecond"; "required": false; "isSignal": true; }; "typeFormat": { "alias": "typeFormat"; "required": false; "isSignal": true; }; "fromAndToDateLabel": { "alias": "fromAndToDateLabel"; "required": false; "isSignal": true; }; "listHasButtonUnSelectOption": { "alias": "listHasButtonUnSelectOption"; "required": false; "isSignal": true; }; "selectedDateTime": { "alias": "selectedDateTime"; "required": false; "isSignal": true; }; "isEmitAfterChanged": { "alias": "isEmitAfterChanged"; "required": false; "isSignal": true; }; "getItemYearDisplay": { "alias": "getItemYearDisplay"; "required": false; "isSignal": true; }; "ignoreFromAndToDateLabel": { "alias": "ignoreFromAndToDateLabel"; "required": false; "isSignal": true; }; "classIncludeTextDisplayWhenNoSelect": { "alias": "classIncludeTextDisplayWhenNoSelect"; "required": false; "isSignal": true; }; "hiddenDate": { "alias": "hiddenDate"; "required": false; "isSignal": true; }; "listMaxItemShow": { "alias": "listMaxItemShow"; "required": false; "isSignal": true; }; "ignoreConvertYearSelected": { "alias": "ignoreConvertYearSelected"; "required": false; "isSignal": true; }; "listKeysDisable": { "alias": "listKeysDisable"; "required": false; "isSignal": true; }; "ignoreAllowTimeEqual": { "alias": "ignoreAllowTimeEqual"; "required": false; "isSignal": true; }; "ignoreValidTimeCompare": { "alias": "ignoreValidTimeCompare"; "required": false; "isSignal": true; }; "isCheckErrorWhenSelectItem": { "alias": "isCheckErrorWhenSelectItem"; "required": false; "isSignal": true; }; "ignoreRequiredValueSecondWhenNotValidRequired": { "alias": "ignoreRequiredValueSecondWhenNotValidRequired"; "required": false; "isSignal": true; }; "validRequired": { "alias": "validRequired"; "required": false; "isSignal": true; }; }, { "outFunctionsControl": "outFunctionsControl"; "outSelectedDropdown": "outSelectedDropdown"; "outChooseMultiDate": "outChooseMultiDate"; "outChooseSingleDate": "outChooseSingleDate"; "outChangStageFlagMouse": "outChangStageFlagMouse"; }, never, never, true, never>;
+}

package/esm2022/defines/date-dropdown.define.mjs

@@ -0,0 +1,246 @@
+import { returnDetailObject, returnListObject } from '@libs-ui/services-http-request';
+import { UtilsHttpParamsRequest } from '@libs-ui/utils';
+import { DEFAULT_MAX_YEAR, DEFAULT_MIN_YEAR } from '@libs-ui/components-datetime-picker';
+export const convertGetValue = (type, item, translate) => {
+    switch (type) {
+        case 'day':
+            return translate.instant('i18n_day_param', { day: item.label });
+        case 'month':
+            return translate.instant(item.label || ' ', { year: '' });
+        case 'year':
+            return translate.instant('i18n_year_param', { year: item.label });
+        case 'quarter':
+            return translate.instant('i18n_quarter', { quarter: item.label });
+    }
+};
+export const convertItemSelectedDefine = (type, item, translate, getItemYearDisplay, ignoreConvertYearSelected) => {
+    switch (type) {
+        case 'day':
+            return translate.instant('i18n_day_param', { day: item.label });
+        case 'month':
+            return translate.instant(item.label || ' ', { year: '' });
+        case 'year': {
+            let labelDisplay = ignoreConvertYearSelected ? item.label : translate.instant('i18n_year_param', { year: item.label });
+            if (getItemYearDisplay) {
+                labelDisplay = getItemYearDisplay(item.label);
+            }
+            return labelDisplay;
+        }
+        case 'quarter':
+            return translate.instant('i18n_quarter', { quarter: item.label });
+    }
+};
+export const LIST_MONTHS_DEFAULT = () => {
+    return [
+        {
+            id: 1,
+            label: 'i18n_january',
+        },
+        {
+            id: 2,
+            label: 'i18n_february',
+        },
+        {
+            id: 3,
+            label: 'i18n_march',
+        },
+        {
+            id: 4,
+            label: 'i18n_april',
+        },
+        {
+            id: 5,
+            label: 'i18n_may',
+        },
+        {
+            id: 6,
+            label: 'i18n_june',
+        },
+        {
+            id: 7,
+            label: 'i18n_july',
+        },
+        {
+            id: 8,
+            label: 'i18n_august',
+        },
+        {
+            id: 9,
+            label: 'i18n_september',
+        },
+        {
+            id: 10,
+            label: 'i18n_october',
+        },
+        {
+            id: 11,
+            label: 'i18n_november',
+        },
+        {
+            id: 12,
+            label: 'i18n_december',
+        },
+    ];
+};
+export const CompareDate = (dateCompare, ignoreAllowTimeSame) => {
+    const dateNumberOne = dateCompare[0];
+    if (dateCompare.length === 2) {
+        const dateNumberTow = dateCompare[1];
+        if (!dateNumberOne.from || !dateNumberOne.to || !dateNumberTow.from || !dateNumberTow.to) {
+            return false;
+        }
+        if (ignoreAllowTimeSame ? dateNumberOne.from > dateNumberOne.to : dateNumberOne.from >= dateNumberOne.to) {
+            return true;
+        }
+        if (dateNumberOne.from === dateNumberOne.to && (ignoreAllowTimeSame ? dateNumberTow.from > dateNumberTow.to : dateNumberTow.from >= dateNumberTow.to)) {
+            return true;
+        }
+        return false;
+    }
+    if (!dateNumberOne.from || !dateNumberOne.to) {
+        return false;
+    }
+    if (ignoreAllowTimeSame ? dateNumberOne.from > dateNumberOne.to : dateNumberOne.from >= dateNumberOne.to) {
+        return true;
+    }
+    return false;
+};
+export const getConfigHttpRequestDetailDate = (data) => {
+    return {
+        objectInstance: returnDetailObject(new UtilsHttpParamsRequest({ fromObject: { fieldKey: 'id' } }), data),
+        functionName: 'detailByData',
+        argumentsValue: [],
+        guideAutoUpdateArgumentsValue: {
+            paging: {},
+            detailById: {
+                subFieldUpdate: 'id',
+                fieldUpdate: '[0]',
+                fieldGetValue: '',
+            },
+        },
+    };
+};
+export const getConfigHttpRequestListDate = (data) => {
+    return {
+        objectInstance: returnListObject(data),
+        functionName: 'list',
+        argumentsValue: [],
+    };
+};
+export const buildListDataByTypeDate = (type, dataYear, keyMonth) => {
+    switch (type) {
+        case 'day':
+            return convertDay(keyMonth);
+        case 'month':
+            return LIST_MONTHS_DEFAULT();
+        case 'year':
+            return convertYear(dataYear.minYear, dataYear.maxYear, dataYear.reverseYear);
+        case 'quarter': {
+            const listQuarter = [];
+            for (let i = 1; i <= 4; i++) {
+                listQuarter.push({
+                    id: i,
+                    label: `${i}`,
+                });
+            }
+            return listQuarter;
+        }
+    }
+};
+export const defaultMonths = () => {
+    return [
+        {
+            id: 1,
+            label: 'i18n_january',
+            maxDays: 31,
+        },
+        {
+            id: 2,
+            label: 'i18n_february',
+            maxDays: 29,
+        },
+        {
+            id: 3,
+            label: 'i18n_march',
+            maxDays: 31,
+        },
+        {
+            id: 4,
+            label: 'i18n_april',
+            maxDays: 30,
+        },
+        {
+            id: 5,
+            label: 'i18n_may',
+            maxDays: 31,
+        },
+        {
+            id: 6,
+            label: 'i18n_june',
+            maxDays: 30,
+        },
+        {
+            id: 7,
+            label: 'i18n_july',
+            maxDays: 31,
+        },
+        {
+            id: 8,
+            label: 'i18n_august',
+            maxDays: 31,
+        },
+        {
+            id: 9,
+            label: 'i18n_september',
+            maxDays: 30,
+        },
+        {
+            id: 10,
+            label: 'i18n_october',
+            maxDays: 31,
+        },
+        {
+            id: 11,
+            label: 'i18n_november',
+            maxDays: 30,
+        },
+        {
+            id: 12,
+            label: 'i18n_december',
+            maxDays: 31,
+        },
+    ];
+};
+const convertYear = (minYear, maxYear, reverseYear) => {
+    const listYear = [];
+    const minYears = minYear ? minYear : DEFAULT_MIN_YEAR;
+    const maxYears = maxYear ? maxYear : DEFAULT_MAX_YEAR;
+    for (let i = minYears; i <= maxYears; i++) {
+        listYear.push({
+            id: i,
+            label: `${i}`,
+        });
+    }
+    if (reverseYear) {
+        listYear.reverse();
+    }
+    return listYear;
+};
+const convertDay = (key) => {
+    if (!key || isNaN(Number(key))) {
+        return [];
+    }
+    const dayDefault = defaultMonths().find((item) => Number(item.id) === Number(key));
+    if (!dayDefault) {
+        return [];
+    }
+    const listDay = [];
+    for (let i = 1; i <= dayDefault.maxDays; i++) {
+        listDay.push({
+            id: i,
+            label: `${i}`,
+        });
+    }
+    return listDay;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-dropdown.define.js","sourceRoot":"","sources":["../../../../../../../libs-ui/components/datetime/dropdown/src/defines/date-dropdown.define.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { TranslateService } from '@ngx-translate/core';\nimport { TYPE_DATE_FORMAT, TYPE_DROPDOWN_MONTH_ID } from '../interfaces/date-dropdown.interface';\nimport { IHttpRequestConfig, returnDetailObject, returnListObject } from '@libs-ui/services-http-request';\nimport { UtilsHttpParamsRequest } from '@libs-ui/utils';\nimport { DEFAULT_MAX_YEAR, DEFAULT_MIN_YEAR } from '@libs-ui/components-datetime-picker';\n\nexport const convertGetValue = (type: TYPE_DATE_FORMAT, item: { label: string }, translate: TranslateService) => {\n  switch (type) {\n    case 'day':\n      return translate.instant('i18n_day_param', { day: item.label });\n\n    case 'month':\n      return translate.instant(item.label || ' ', { year: '' });\n\n    case 'year':\n      return translate.instant('i18n_year_param', { year: item.label });\n\n    case 'quarter':\n      return translate.instant('i18n_quarter', { quarter: item.label });\n  }\n};\n\nexport const convertItemSelectedDefine = (type: TYPE_DATE_FORMAT, item: { id: number; label: string; labelDisplay: string }, translate: TranslateService, getItemYearDisplay?: (label: string) => void, ignoreConvertYearSelected?: boolean) => {\n  switch (type) {\n    case 'day':\n      return translate.instant('i18n_day_param', { day: item.label });\n\n    case 'month':\n      return translate.instant(item.label || ' ', { year: '' });\n\n    case 'year': {\n      let labelDisplay = ignoreConvertYearSelected ? item.label : translate.instant('i18n_year_param', { year: item.label });\n\n      if (getItemYearDisplay) {\n        labelDisplay = getItemYearDisplay(item.label);\n      }\n\n      return labelDisplay;\n    }\n\n    case 'quarter':\n      return translate.instant('i18n_quarter', { quarter: item.label });\n  }\n};\n\nexport const LIST_MONTHS_DEFAULT = (): Array<{ id: number; label: string }> => {\n  return [\n    {\n      id: 1,\n      label: 'i18n_january',\n    },\n    {\n      id: 2,\n      label: 'i18n_february',\n    },\n    {\n      id: 3,\n      label: 'i18n_march',\n    },\n    {\n      id: 4,\n      label: 'i18n_april',\n    },\n    {\n      id: 5,\n      label: 'i18n_may',\n    },\n    {\n      id: 6,\n      label: 'i18n_june',\n    },\n    {\n      id: 7,\n      label: 'i18n_july',\n    },\n    {\n      id: 8,\n      label: 'i18n_august',\n    },\n    {\n      id: 9,\n      label: 'i18n_september',\n    },\n    {\n      id: 10,\n      label: 'i18n_october',\n    },\n    {\n      id: 11,\n      label: 'i18n_november',\n    },\n    {\n      id: 12,\n      label: 'i18n_december',\n    },\n  ];\n};\n\nexport const CompareDate = (dateCompare: Array<{ from: number | undefined; to: number | undefined }>, ignoreAllowTimeSame: boolean): boolean => {\n  const dateNumberOne = dateCompare[0];\n\n  if (dateCompare.length === 2) {\n    const dateNumberTow = dateCompare[1];\n\n    if (!dateNumberOne.from || !dateNumberOne.to || !dateNumberTow.from || !dateNumberTow.to) {\n      return false;\n    }\n    if (ignoreAllowTimeSame ? dateNumberOne.from > dateNumberOne.to : dateNumberOne.from >= dateNumberOne.to) {\n      return true;\n    }\n    if (dateNumberOne.from === dateNumberOne.to && (ignoreAllowTimeSame ? dateNumberTow.from > dateNumberTow.to : dateNumberTow.from >= dateNumberTow.to)) {\n      return true;\n    }\n\n    return false;\n  }\n\n  if (!dateNumberOne.from || !dateNumberOne.to) {\n    return false;\n  }\n  if (ignoreAllowTimeSame ? dateNumberOne.from > dateNumberOne.to : dateNumberOne.from >= dateNumberOne.to) {\n    return true;\n  }\n\n  return false;\n};\n\nexport const getConfigHttpRequestDetailDate = (data: Array<{ id: number; label: string }>): IHttpRequestConfig => {\n  return {\n    objectInstance: returnDetailObject(new UtilsHttpParamsRequest({ fromObject: { fieldKey: 'id' } }), data),\n    functionName: 'detailByData',\n    argumentsValue: [],\n    guideAutoUpdateArgumentsValue: {\n      paging: {},\n      detailById: {\n        subFieldUpdate: 'id',\n        fieldUpdate: '[0]',\n        fieldGetValue: '',\n      },\n    },\n  };\n};\n\nexport const getConfigHttpRequestListDate = (data: Array<{ id: number; label: string }>): IHttpRequestConfig => {\n  return {\n    objectInstance: returnListObject(data),\n    functionName: 'list',\n    argumentsValue: [],\n  };\n};\n\nexport const buildListDataByTypeDate = (type: TYPE_DATE_FORMAT, dataYear: { minYear?: number; maxYear?: number; reverseYear?: boolean }, keyMonth: any): Array<{ id: number; label: string }> => {\n  switch (type) {\n    case 'day':\n      return convertDay(keyMonth);\n\n    case 'month':\n      return LIST_MONTHS_DEFAULT();\n\n    case 'year':\n      return convertYear(dataYear.minYear, dataYear.maxYear, dataYear.reverseYear);\n\n    case 'quarter': {\n      const listQuarter = [];\n\n      for (let i = 1; i <= 4; i++) {\n        listQuarter.push({\n          id: i,\n          label: `${i}`,\n        });\n      }\n\n      return listQuarter;\n    }\n  }\n};\n\nexport const defaultMonths = (): Array<{ id: TYPE_DROPDOWN_MONTH_ID; label: string; maxDays: number }> => {\n  return [\n    {\n      id: 1,\n      label: 'i18n_january',\n      maxDays: 31,\n    },\n    {\n      id: 2,\n      label: 'i18n_february',\n      maxDays: 29,\n    },\n    {\n      id: 3,\n      label: 'i18n_march',\n      maxDays: 31,\n    },\n    {\n      id: 4,\n      label: 'i18n_april',\n      maxDays: 30,\n    },\n    {\n      id: 5,\n      label: 'i18n_may',\n      maxDays: 31,\n    },\n    {\n      id: 6,\n      label: 'i18n_june',\n      maxDays: 30,\n    },\n    {\n      id: 7,\n      label: 'i18n_july',\n      maxDays: 31,\n    },\n    {\n      id: 8,\n      label: 'i18n_august',\n      maxDays: 31,\n    },\n    {\n      id: 9,\n      label: 'i18n_september',\n      maxDays: 30,\n    },\n    {\n      id: 10,\n      label: 'i18n_october',\n      maxDays: 31,\n    },\n    {\n      id: 11,\n      label: 'i18n_november',\n      maxDays: 30,\n    },\n    {\n      id: 12,\n      label: 'i18n_december',\n      maxDays: 31,\n    },\n  ];\n};\n\nconst convertYear = (minYear?: number, maxYear?: number, reverseYear?: boolean) => {\n  const listYear = [];\n  const minYears = minYear ? minYear : DEFAULT_MIN_YEAR;\n  const maxYears = maxYear ? maxYear : DEFAULT_MAX_YEAR;\n\n  for (let i = minYears; i <= maxYears; i++) {\n    listYear.push({\n      id: i,\n      label: `${i}`,\n    });\n  }\n  if (reverseYear) {\n    listYear.reverse();\n  }\n\n  return listYear;\n};\n\nconst convertDay = (key: any) => {\n  if (!key || isNaN(Number(key))) {\n    return [];\n  }\n  const dayDefault = defaultMonths().find((item) => Number(item.id) === Number(key));\n\n  if (!dayDefault) {\n    return [];\n  }\n  const listDay = [];\n\n  for (let i = 1; i <= dayDefault.maxDays; i++) {\n    listDay.push({\n      id: i,\n      label: `${i}`,\n    });\n  }\n\n  return listDay;\n};\n"]}

package/esm2022/directive/date-dropdown.directive.mjs

@@ -0,0 +1,33 @@
+import { Directive, ElementRef, inject, output, signal } from '@angular/core';
+import * as i0 from "@angular/core";
+export class LibsUiComponentsDatetimeDropdownDirective {
+    resizeObserver = signal(undefined);
+    elementRef = inject(ElementRef);
+    outChangeWidth = output();
+    ngOnInit() {
+        this.resizeObserver.set(new ResizeObserver((entries) => {
+            for (const entry of entries) {
+                if (entry.target === this.elementRef.nativeElement) {
+                    this.outChangeWidth.emit(entry.contentRect.width);
+                }
+            }
+        }));
+        this.resizeObserver()?.observe(this.elementRef.nativeElement);
+    }
+    ngOnDestroy() {
+        if (this.resizeObserver()) {
+            this.resizeObserver()?.disconnect();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LibsUiComponentsDatetimeDropdownDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: LibsUiComponentsDatetimeDropdownDirective, isStandalone: true, selector: "[LibsUiComponentsDatetimeDropdownDirective]", outputs: { outChangeWidth: "outChangeWidth" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LibsUiComponentsDatetimeDropdownDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[LibsUiComponentsDatetimeDropdownDirective]',
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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