@datarailsshared/datarailsshared 1.6.361 → 1.6.365

package/esm2022/lib/dr-cron-field/dr-cron-field.editor.mjs

@@ -0,0 +1,303 @@
+import { map as _map, sortBy as _sortBy } from 'lodash';
+import { getGMTLabel, LOCAL_TIME_ZONE_OFFSET } from '../dr-inputs';
+export var CronEditorPeriod;
+(function (CronEditorPeriod) {
+    CronEditorPeriod["HOUR"] = "hour";
+    CronEditorPeriod["DAY"] = "day";
+    CronEditorPeriod["WEEK"] = "week";
+    CronEditorPeriod["MONTH"] = "month";
+    CronEditorPeriod["QUARTER"] = "quarter";
+    CronEditorPeriod["YEAR"] = "year";
+})(CronEditorPeriod || (CronEditorPeriod = {}));
+export const dateFormatToCronPeriod = (format) => {
+    const upperFormat = format.toUpperCase();
+    if (upperFormat.includes('H')) {
+        return CronEditorPeriod.HOUR;
+    }
+    if (upperFormat.includes('D') && !upperFormat.includes('W')) {
+        return CronEditorPeriod.DAY;
+    }
+    if (upperFormat.includes('W')) {
+        return CronEditorPeriod.WEEK;
+    }
+    if (upperFormat.includes('M') && upperFormat !== 'YYYY') {
+        return CronEditorPeriod.MONTH;
+    }
+    if (upperFormat.includes('Q')) {
+        return CronEditorPeriod.QUARTER;
+    }
+    return CronEditorPeriod.YEAR;
+};
+export const getInitialQuarterArray = (fiscalYear = 1, monthArr = [1, 4, 7, 10]) => {
+    const fiscalOffset = fiscalYear - 1;
+    if (fiscalOffset) {
+        monthArr = _map(monthArr, (month) => {
+            const val = month + fiscalOffset;
+            return val > 12 ? val - 12 : val;
+        });
+        monthArr = _sortBy(monthArr);
+    }
+    return monthArr;
+};
+export const getStartMonthInQuarter = (fiscalYear = 1, monthArr = [1, 4, 7, 10]) => {
+    const fiscalOffset = fiscalYear - 1;
+    let quarterMonth = monthArr[0] || 1;
+    // By default select first value in array since it can be only 1-3
+    // Value must be recalculated if fiscal year doesn't start from first month
+    // In month[] we have UTC values, we need to show fiscal month in selection.
+    // Example: We want to start task in 3rd month on each fiscal quarter.
+    // If fiscal_year_starts_from = 3 Then month should be [2,5,8,11].
+    // First fiscal quarter will be finished in month 5, 2-8, 3-11, 4-2(next year).
+    // Fiscal month = [12,3,6,9]. Presented value for user: 3.
+    if (fiscalOffset) {
+        monthArr = _map(monthArr, (item) => {
+            const val = item - fiscalOffset;
+            return val < 1 ? val + 12 : val;
+        });
+        monthArr = _sortBy(monthArr);
+        quarterMonth = monthArr[0];
+    }
+    return quarterMonth;
+};
+export const getQuarterStringByMonthInQuarter = (fiscalYear = 1, month) => {
+    if (!month) {
+        return '*';
+    }
+    let monthArr = [month, month + 3, month + 6, month + 9];
+    const fiscalOffset = fiscalYear - 1;
+    if (fiscalOffset) {
+        monthArr = _map(monthArr, (month) => {
+            const val = month + fiscalOffset;
+            return val > 12 ? val - 12 : val;
+        });
+        monthArr = _sortBy(monthArr);
+    }
+    return monthArr.join(',');
+};
+export const CronEditorDefaultConfigByPeriod = {
+    [CronEditorPeriod.HOUR]: (fY) => `0 12/1 * * * ${LOCAL_TIME_ZONE_OFFSET}`,
+    [CronEditorPeriod.DAY]: (fY) => `0 12 * * * ${LOCAL_TIME_ZONE_OFFSET}`,
+    [CronEditorPeriod.WEEK]: (fY) => `0 12 * * 0 ${LOCAL_TIME_ZONE_OFFSET}`,
+    [CronEditorPeriod.MONTH]: (fY) => `0 12 1 * * ${LOCAL_TIME_ZONE_OFFSET}`,
+    [CronEditorPeriod.QUARTER]: (fY) => `0 12 1 ${getInitialQuarterArray(fY).join(',')} * ${LOCAL_TIME_ZONE_OFFSET}`,
+    [CronEditorPeriod.YEAR]: (fY) => `0 12 1 1 * ${LOCAL_TIME_ZONE_OFFSET}`,
+};
+export const getCronTypeAsPeriodLabel = (type) => type === CronEditorPeriod.DAY ? 'Daily' : type + 'ly';
+export var CronTimePeriod;
+(function (CronTimePeriod) {
+    CronTimePeriod["AM"] = "AM";
+    CronTimePeriod["PM"] = "PM";
+})(CronTimePeriod || (CronTimePeriod = {}));
+export const HOURS_DIVISIBLE_INTO_DAY = [
+    { label: '1', value: 1 },
+    { label: '2', value: 2 },
+    { label: '3', value: 3 },
+    { label: '4', value: 4 },
+    { label: '6', value: 6 },
+    { label: '8', value: 8 },
+    { label: '12', value: 12 },
+];
+export const MONTH_OF_YEAR_ARRAY = [
+    { label: 'January', value: 1 },
+    { label: 'February', value: 2 },
+    { label: 'March', value: 3 },
+    { label: 'April', value: 4 },
+    { label: 'May', value: 5 },
+    { label: 'June', value: 6 },
+    { label: 'July', value: 7 },
+    { label: 'August', value: 8 },
+    { label: 'September', value: 9 },
+    { label: 'October', value: 10 },
+    { label: 'November', value: 11 },
+    { label: 'December', value: 12 },
+];
+export const DAY_OF_WEEK_ARRAY = [
+    { label: 'Sunday', value: 0 },
+    { label: 'Monday', value: 1 },
+    { label: 'Tuesday', value: 2 },
+    { label: 'Wednesday', value: 3 },
+    { label: 'Thursday', value: 4 },
+    { label: 'Friday', value: 5 },
+    { label: 'Saturday', value: 6 },
+];
+export const MONTH_OF_QUARTER_ARRAY = [
+    { label: '1st', value: 1 },
+    { label: '2nd', value: 2 },
+    { label: '3rd', value: 3 },
+];
+export const ALLOWED_PERIODS = Object.values(CronEditorPeriod);
+export const addOrdinalSuffix = (num) => {
+    const suffixes = ['th', 'st', 'nd', 'rd'];
+    const v = num % 100;
+    return num + (suffixes[(v - 20) % 10] || suffixes[v] || suffixes[0]);
+};
+export const DAY_OF_MONTH_ARRAY = new Array(28).fill(null).map((v, i) => ({
+    label: addOrdinalSuffix(i + 1),
+    value: i + 1,
+}));
+export class CronEditor {
+    set value(value) {
+        this.parseCronString(value);
+    }
+    get value() {
+        return this.cronEditorObjectToString();
+    }
+    set valueObject(valueObject) {
+        if (!valueObject) {
+            return;
+        }
+        this.every = valueObject.every;
+        this.minute = valueObject.minute;
+        this.hour = valueObject.hour;
+        this.dayOfMonth = valueObject.dayOfMonth;
+        this.month = valueObject.month;
+        this.dayOfWeek = valueObject.dayOfWeek;
+        this.timePeriod = valueObject.timePeriod;
+        this.timeZone = valueObject.timeZone;
+        this.everyXHours = valueObject.everyXHours;
+    }
+    get valueObject() {
+        return {
+            every: this.every,
+            minute: this.minute,
+            hour: this.hour,
+            dayOfMonth: this.dayOfMonth,
+            month: this.month,
+            dayOfWeek: this.dayOfWeek,
+            timePeriod: this.timePeriod,
+            timeZone: this.timeZone,
+            everyXHours: this.everyXHours,
+        };
+    }
+    constructor(value, fiscalYearStart = 1, period) {
+        this._fiscalYearStart = 1;
+        this.everyXHours = 1;
+        this.dayOfMonth = 1;
+        this.dayOfWeek = 1;
+        this.every = CronEditorPeriod.YEAR;
+        this.hour = 12;
+        this.minute = 0;
+        this.month = 1;
+        this.timePeriod = CronTimePeriod.PM;
+        this.timeZone = LOCAL_TIME_ZONE_OFFSET;
+        this._fiscalYearStart = fiscalYearStart;
+        this._period = period;
+        if (value) {
+            this.value = value;
+        }
+    }
+    parseCronString(value) {
+        let [minute, hour, dayOfMonth, month, dayOfWeek, timeZone] = value.split(' ');
+        minute = minute !== '*' ? Number(minute.split(',')[0]) : 0;
+        let everyXHours;
+        if (typeof hour === 'string' && hour.includes('/')) {
+            // Case 1: If `hour` includes / to indicate step change
+            everyXHours = Number(hour.split('/')[1]);
+            hour = [Number(hour.split('/')[0])];
+        }
+        else if (hour !== '*') {
+            // Case 2: If `hour` is a single number (but not "*"), ensure it's a number
+            hour = [Number(hour.split(',')[0])];
+        }
+        else {
+            // Case 3: If `hour` is "*", set it to 0
+            hour = [0];
+        }
+        dayOfMonth = this.parseCronArray(dayOfMonth);
+        month = this.parseCronArray(month);
+        dayOfWeek = this.parseCronArray(dayOfWeek);
+        timeZone = timeZone ? Number(timeZone) : 0;
+        let type;
+        if (this._period) {
+            type = this._period;
+        }
+        else if (month?.length > 1) {
+            type = CronEditorPeriod.QUARTER;
+        }
+        else if (month?.length) {
+            type = CronEditorPeriod.YEAR;
+        }
+        else if (dayOfMonth?.length) {
+            type = CronEditorPeriod.MONTH;
+        }
+        else if (dayOfWeek?.length) {
+            type = CronEditorPeriod.WEEK;
+        }
+        else if (everyXHours) {
+            type = CronEditorPeriod.HOUR;
+        }
+        else {
+            type = CronEditorPeriod.DAY;
+        }
+        this.every = type;
+        this.everyXHours = everyXHours ? everyXHours : 1;
+        this.minute = minute;
+        this.hour = hour[0] % 12 || 12;
+        this.dayOfMonth = dayOfMonth?.[0] || null;
+        this.month =
+            type === CronEditorPeriod.QUARTER ? getStartMonthInQuarter(this._fiscalYearStart, month) : month?.[0] || null;
+        this.dayOfWeek = typeof dayOfWeek?.[0] === 'number' ? dayOfWeek[0] : null;
+        this.timePeriod = hour[0] >= 12 ? CronTimePeriod.PM : CronTimePeriod.AM;
+        this.timeZone = timeZone;
+    }
+    parseCronArray(str) {
+        return str !== '*' ? str.split(',').map((v) => Number(v)) : null;
+    }
+    cronEditorObjectToString(excludeTimezone = false) {
+        const minute = this.minute || 0;
+        let hour = this.hour || 0;
+        hour = this.hoursTo24Format(hour);
+        let hourOrHours = hour;
+        const dayOfMonth = this.dayOfMonth || '*';
+        const month = this._period === CronEditorPeriod.QUARTER || this.every === CronEditorPeriod.QUARTER
+            ? getQuarterStringByMonthInQuarter(this._fiscalYearStart, this.month)
+            : this.month || '*';
+        const dayOfWeek = typeof this.dayOfWeek === 'number' ? this.dayOfWeek : '*';
+        if (this.every === CronEditorPeriod.HOUR) {
+            hourOrHours = `${hour}/${this.everyXHours}`;
+        }
+        return `${minute} ${hourOrHours} ${dayOfMonth} ${month} ${dayOfWeek}${!excludeTimezone ? ` ${this.timeZone}` : ''}`;
+    }
+    hoursTo24Format(hour) {
+        if (this.timePeriod === CronTimePeriod.PM && hour < 12) {
+            hour += 12;
+        }
+        else if (this.timePeriod === CronTimePeriod.AM && hour === 12) {
+            hour = 0;
+        }
+        return hour;
+    }
+    getReadableString() {
+        let visibleString = 'Every ';
+        switch (this.every) {
+            case CronEditorPeriod.YEAR:
+                visibleString += `${MONTH_OF_YEAR_ARRAY[this.month - 1].label} ${DAY_OF_MONTH_ARRAY[this.dayOfMonth - 1].label} `;
+                break;
+            case CronEditorPeriod.QUARTER:
+                const month = MONTH_OF_QUARTER_ARRAY[this.month - 1].label;
+                const day = DAY_OF_MONTH_ARRAY[this.dayOfMonth - 1].label;
+                visibleString += `quarter on the ${month} month of the quarter on ${day} day `;
+                break;
+            case CronEditorPeriod.MONTH:
+                visibleString += `month on day ${this.dayOfMonth} `;
+                break;
+            case CronEditorPeriod.WEEK:
+                const dow = typeof this.dayOfWeek === 'number' ? this.dayOfWeek : 0;
+                const dayIndex = dow >= 7 ? 0 : dow;
+                visibleString += `${DAY_OF_WEEK_ARRAY[dayIndex].label} `;
+                break;
+            case CronEditorPeriod.DAY:
+                visibleString += `day `;
+                break;
+            case CronEditorPeriod.HOUR:
+                visibleString += `${this.everyXHours} hour${this.everyXHours > 1 ? 's' : ''} `;
+                break;
+        }
+        const minutePrefix = this.minute < 10 ? '0' : '';
+        const hourPrefix = this.hour < 10 ? '0' : '';
+        visibleString += `at ${hourPrefix + this.hour}:${minutePrefix + this.minute}${this.timePeriod}`;
+        visibleString += ` (${LOCAL_TIME_ZONE_OFFSET === this.timeZone ? 'Local Time' : getGMTLabel(-this.timeZone)})`;
+        return visibleString;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dr-cron-field.editor.js","sourceRoot":"","sources":["../../../../../projects/datarailsshared/src/lib/dr-cron-field/dr-cron-field.editor.ts"],"names":[],"mappings":"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","sourcesContent":["import { map as _map, sortBy as _sortBy } from 'lodash';\nimport { getGMTLabel, LOCAL_TIME_ZONE_OFFSET } from '../dr-inputs';\n\nexport interface ICronEditor {\n    everyXHours: number; // 1,2,3,4,6,8,12 (not including 24 because every 24 hours is just daily)\n    every: CronEditorPeriod;\n    minute: number;\n    hour: number;\n    dayOfMonth: number; // \"1-28\"\n    month: number; // \"1-12\"\n    dayOfWeek: number; // \"0-7\"\n    timePeriod: CronTimePeriod;\n    timeZone: number; // -14 - +12\n}\n\nexport enum CronEditorPeriod {\n    HOUR = 'hour',\n    DAY = 'day',\n    WEEK = 'week',\n    MONTH = 'month',\n    QUARTER = 'quarter',\n    YEAR = 'year',\n}\n\nexport type TCronEditorPeriod = 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';\n\nexport const dateFormatToCronPeriod = (format: string): CronEditorPeriod => {\n    const upperFormat = format.toUpperCase();\n\n    if (upperFormat.includes('H')) {\n        return CronEditorPeriod.HOUR;\n    }\n\n    if (upperFormat.includes('D') && !upperFormat.includes('W')) {\n        return CronEditorPeriod.DAY;\n    }\n\n    if (upperFormat.includes('W')) {\n        return CronEditorPeriod.WEEK;\n    }\n\n    if (upperFormat.includes('M') && upperFormat !== 'YYYY') {\n        return CronEditorPeriod.MONTH;\n    }\n\n    if (upperFormat.includes('Q')) {\n        return CronEditorPeriod.QUARTER;\n    }\n\n    return CronEditorPeriod.YEAR;\n};\n\nexport const getInitialQuarterArray = (fiscalYear = 1, monthArr = [1, 4, 7, 10]): number[] => {\n    const fiscalOffset = fiscalYear - 1;\n\n    if (fiscalOffset) {\n        monthArr = _map(monthArr, (month) => {\n            const val = month + fiscalOffset;\n            return val > 12 ? val - 12 : val;\n        });\n        monthArr = _sortBy(monthArr);\n    }\n\n    return monthArr;\n};\n\nexport const getStartMonthInQuarter = (fiscalYear = 1, monthArr: number[] = [1, 4, 7, 10]): number => {\n    const fiscalOffset = fiscalYear - 1;\n    let quarterMonth = monthArr[0] || 1;\n\n    // By default select first value in array since it can be only 1-3\n    // Value must be recalculated if fiscal year doesn't start from first month\n    // In month[] we have UTC values, we need to show fiscal month in selection.\n    // Example: We want to start task in 3rd month on each fiscal quarter.\n    // If fiscal_year_starts_from = 3 Then month should be [2,5,8,11].\n    // First fiscal quarter will be finished in month 5, 2-8, 3-11, 4-2(next year).\n    // Fiscal month = [12,3,6,9]. Presented value for user: 3.\n    if (fiscalOffset) {\n        monthArr = _map(monthArr, (item) => {\n            const val = item - fiscalOffset;\n            return val < 1 ? val + 12 : val;\n        });\n        monthArr = _sortBy(monthArr);\n        quarterMonth = monthArr[0];\n    }\n\n    return quarterMonth;\n};\n\nexport const getQuarterStringByMonthInQuarter = (fiscalYear = 1, month: number): string => {\n    if (!month) {\n        return '*';\n    }\n\n    let monthArr = [month, month + 3, month + 6, month + 9];\n    const fiscalOffset = fiscalYear - 1;\n\n    if (fiscalOffset) {\n        monthArr = _map(monthArr, (month) => {\n            const val = month + fiscalOffset;\n            return val > 12 ? val - 12 : val;\n        });\n        monthArr = _sortBy(monthArr);\n    }\n\n    return monthArr.join(',');\n};\n\nexport const CronEditorDefaultConfigByPeriod = {\n    [CronEditorPeriod.HOUR]: (fY?: number) => `0 12/1 * * * ${LOCAL_TIME_ZONE_OFFSET}`,\n    [CronEditorPeriod.DAY]: (fY?: number) => `0 12 * * * ${LOCAL_TIME_ZONE_OFFSET}`,\n    [CronEditorPeriod.WEEK]: (fY?: number) => `0 12 * * 0 ${LOCAL_TIME_ZONE_OFFSET}`,\n    [CronEditorPeriod.MONTH]: (fY?: number) => `0 12 1 * * ${LOCAL_TIME_ZONE_OFFSET}`,\n    [CronEditorPeriod.QUARTER]: (fY?: number) => `0 12 1 ${getInitialQuarterArray(fY).join(',')} * ${LOCAL_TIME_ZONE_OFFSET}`,\n    [CronEditorPeriod.YEAR]: (fY?: number) => `0 12 1 1 * ${LOCAL_TIME_ZONE_OFFSET}`,\n};\n\nexport const getCronTypeAsPeriodLabel = (type: CronEditorPeriod): string =>\n    type === CronEditorPeriod.DAY ? 'Daily' : type + 'ly';\n\nexport enum CronTimePeriod {\n    AM = 'AM',\n    PM = 'PM',\n}\n\nexport const HOURS_DIVISIBLE_INTO_DAY = [\n    { label: '1', value: 1 },\n    { label: '2', value: 2 },\n    { label: '3', value: 3 },\n    { label: '4', value: 4 },\n    { label: '6', value: 6 },\n    { label: '8', value: 8 },\n    { label: '12', value: 12 },\n];\n\nexport const MONTH_OF_YEAR_ARRAY = [\n    { label: 'January', value: 1 },\n    { label: 'February', value: 2 },\n    { label: 'March', value: 3 },\n    { label: 'April', value: 4 },\n    { label: 'May', value: 5 },\n    { label: 'June', value: 6 },\n    { label: 'July', value: 7 },\n    { label: 'August', value: 8 },\n    { label: 'September', value: 9 },\n    { label: 'October', value: 10 },\n    { label: 'November', value: 11 },\n    { label: 'December', value: 12 },\n];\n\nexport const DAY_OF_WEEK_ARRAY = [\n    { label: 'Sunday', value: 0 },\n    { label: 'Monday', value: 1 },\n    { label: 'Tuesday', value: 2 },\n    { label: 'Wednesday', value: 3 },\n    { label: 'Thursday', value: 4 },\n    { label: 'Friday', value: 5 },\n    { label: 'Saturday', value: 6 },\n];\n\nexport const MONTH_OF_QUARTER_ARRAY = [\n    { label: '1st', value: 1 },\n    { label: '2nd', value: 2 },\n    { label: '3rd', value: 3 },\n];\n\nexport const ALLOWED_PERIODS = Object.values(CronEditorPeriod);\n\nexport const addOrdinalSuffix = (num: number): string => {\n    const suffixes = ['th', 'st', 'nd', 'rd'];\n    const v = num % 100;\n\n    return num + (suffixes[(v - 20) % 10] || suffixes[v] || suffixes[0]);\n};\n\nexport const DAY_OF_MONTH_ARRAY = new Array(28).fill(null).map((v, i) => ({\n    label: addOrdinalSuffix(i + 1),\n    value: i + 1,\n}));\n\nexport class CronEditor implements ICronEditor {\n    private _fiscalYearStart = 1;\n    private _period: TCronEditorPeriod;\n\n    everyXHours: number = 1;\n    dayOfMonth: number = 1;\n    dayOfWeek: number = 1;\n    every: CronEditorPeriod = CronEditorPeriod.YEAR;\n    hour: number = 12;\n    minute: number = 0;\n    month: number = 1;\n    timePeriod: CronTimePeriod = CronTimePeriod.PM;\n    timeZone: number = LOCAL_TIME_ZONE_OFFSET;\n\n    public set value(value: string) {\n        this.parseCronString(value);\n    }\n\n    public get value(): string {\n        return this.cronEditorObjectToString();\n    }\n\n    public set valueObject(valueObject: ICronEditor) {\n        if (!valueObject) {\n            return;\n        }\n\n        this.every = valueObject.every;\n        this.minute = valueObject.minute;\n        this.hour = valueObject.hour;\n        this.dayOfMonth = valueObject.dayOfMonth;\n        this.month = valueObject.month;\n        this.dayOfWeek = valueObject.dayOfWeek;\n        this.timePeriod = valueObject.timePeriod;\n        this.timeZone = valueObject.timeZone;\n        this.everyXHours = valueObject.everyXHours;\n    }\n\n    public get valueObject(): ICronEditor {\n        return {\n            every: this.every,\n            minute: this.minute,\n            hour: this.hour,\n            dayOfMonth: this.dayOfMonth,\n            month: this.month,\n            dayOfWeek: this.dayOfWeek,\n            timePeriod: this.timePeriod,\n            timeZone: this.timeZone,\n            everyXHours: this.everyXHours,\n        };\n    }\n\n    constructor(value?: string, fiscalYearStart: number = 1, period?: TCronEditorPeriod) {\n        this._fiscalYearStart = fiscalYearStart;\n        this._period = period;\n\n        if (value) {\n            this.value = value;\n        }\n    }\n\n    private parseCronString(value: string): void {\n        let [minute, hour, dayOfMonth, month, dayOfWeek, timeZone]: any = value.split(' ');\n\n        minute = minute !== '*' ? Number(minute.split(',')[0]) : 0;\n        let everyXHours;\n        if (typeof hour === 'string' && hour.includes('/')) {\n            // Case 1: If `hour` includes / to indicate step change\n            everyXHours = Number(hour.split('/')[1]);\n            hour = [Number(hour.split('/')[0])];\n        } else if (hour !== '*') {\n            // Case 2: If `hour` is a single number (but not \"*\"), ensure it's a number\n            hour = [Number(hour.split(',')[0])];\n        } else {\n            // Case 3: If `hour` is \"*\", set it to 0\n            hour = [0];\n        }\n\n        dayOfMonth = this.parseCronArray(dayOfMonth);\n        month = this.parseCronArray(month);\n        dayOfWeek = this.parseCronArray(dayOfWeek);\n        timeZone = timeZone ? Number(timeZone) : 0;\n\n        let type;\n\n        if (this._period) {\n            type = this._period;\n        } else if (month?.length > 1) {\n            type = CronEditorPeriod.QUARTER;\n        } else if (month?.length) {\n            type = CronEditorPeriod.YEAR;\n        } else if (dayOfMonth?.length) {\n            type = CronEditorPeriod.MONTH;\n        } else if (dayOfWeek?.length) {\n            type = CronEditorPeriod.WEEK;\n        } else if (everyXHours) {\n            type = CronEditorPeriod.HOUR;\n        } else {\n            type = CronEditorPeriod.DAY;\n        }\n\n        this.every = type;\n        this.everyXHours = everyXHours ? everyXHours : 1;\n        this.minute = minute;\n        this.hour = hour[0] % 12 || 12;\n        this.dayOfMonth = dayOfMonth?.[0] || null;\n        this.month =\n            type === CronEditorPeriod.QUARTER ? getStartMonthInQuarter(this._fiscalYearStart, month) : month?.[0] || null;\n        this.dayOfWeek = typeof dayOfWeek?.[0] === 'number' ? dayOfWeek[0] : null;\n        this.timePeriod = hour[0] >= 12 ? CronTimePeriod.PM : CronTimePeriod.AM;\n        this.timeZone = timeZone;\n    }\n\n    private parseCronArray(str: string): number[] | null {\n        return str !== '*' ? str.split(',').map((v) => Number(v)) : null;\n    }\n\n    public cronEditorObjectToString(excludeTimezone: boolean = false): string {\n        const minute = this.minute || 0;\n        let hour = this.hour || 0;\n        hour = this.hoursTo24Format(hour);\n        let hourOrHours: string | number = hour;\n        const dayOfMonth = this.dayOfMonth || '*';\n        const month =\n            this._period === CronEditorPeriod.QUARTER || this.every === CronEditorPeriod.QUARTER\n                ? getQuarterStringByMonthInQuarter(this._fiscalYearStart, this.month)\n                : this.month || '*';\n        const dayOfWeek = typeof this.dayOfWeek === 'number' ? this.dayOfWeek : '*';\n\n        if (this.every === CronEditorPeriod.HOUR) {\n            hourOrHours = `${hour}/${this.everyXHours}`;\n        }\n        return `${minute} ${hourOrHours} ${dayOfMonth} ${month} ${dayOfWeek}${!excludeTimezone ? ` ${this.timeZone}` : ''}`;\n    }\n\n    public hoursTo24Format(hour: number): number {\n        if (this.timePeriod === CronTimePeriod.PM && hour < 12) {\n            hour += 12;\n        } else if (this.timePeriod === CronTimePeriod.AM && hour === 12) {\n            hour = 0;\n        }\n        return hour;\n    }\n\n    public getReadableString(): string {\n        let visibleString = 'Every ';\n\n        switch (this.every) {\n            case CronEditorPeriod.YEAR:\n                visibleString += `${MONTH_OF_YEAR_ARRAY[this.month - 1].label} ${DAY_OF_MONTH_ARRAY[this.dayOfMonth - 1].label} `;\n                break;\n            case CronEditorPeriod.QUARTER:\n                const month = MONTH_OF_QUARTER_ARRAY[this.month - 1].label;\n                const day = DAY_OF_MONTH_ARRAY[this.dayOfMonth - 1].label;\n                visibleString += `quarter on the ${month} month of the quarter on ${day} day `;\n                break;\n            case CronEditorPeriod.MONTH:\n                visibleString += `month on day ${this.dayOfMonth} `;\n                break;\n            case CronEditorPeriod.WEEK:\n                const dow = typeof this.dayOfWeek === 'number' ? this.dayOfWeek : 0;\n                const dayIndex = dow >= 7 ? 0 : dow;\n                visibleString += `${DAY_OF_WEEK_ARRAY[dayIndex].label} `;\n                break;\n            case CronEditorPeriod.DAY:\n                visibleString += `day `;\n                break;\n            case CronEditorPeriod.HOUR:\n                visibleString += `${this.everyXHours} hour${this.everyXHours > 1 ? 's' : ''} `;\n                break;\n        }\n\n        const minutePrefix = this.minute < 10 ? '0' : '';\n        const hourPrefix = this.hour < 10 ? '0' : '';\n        visibleString += `at ${hourPrefix + this.hour}:${minutePrefix + this.minute}${this.timePeriod}`;\n        visibleString += ` (${LOCAL_TIME_ZONE_OFFSET === this.timeZone ? 'Local Time' : getGMTLabel(-this.timeZone)})`;\n        return visibleString;\n    }\n}\n"]}

package/esm2022/lib/dr-cron-field/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './dr-cron-field.component';
+export * from './dr-cron-field.editor';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2RhdGFyYWlsc3NoYXJlZC9zcmMvbGliL2RyLWNyb24tZmllbGQvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsd0JBQXdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RyLWNyb24tZmllbGQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZHItY3Jvbi1maWVsZC5lZGl0b3InO1xuIl19

package/esm2022/lib/dr-dialog/dialog.module.mjs

@@ -9,6 +9,7 @@ import { ReactiveFormsModule } from '@angular/forms';
 import { DrTooltipModule } from '../dr-tooltip/dr-tooltip.module';
 import { DrDetailsListModule } from '../dr-details-list/dr-details-list.module';
 import * as i0 from "@angular/core";
+/** @deprecated use DrModalModule instead */
 export class DrDialogModule {
     /** @nocollapse */ static { this.ɵfac = function DrDialogModule_Factory(t) { return new (t || DrDialogModule)(); }; }
     /** @nocollapse */ static { this.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: DrDialogModule }); }
@@ -24,4 +25,4 @@ export class DrDialogModule {
             }]
     }], null, null); })();
 (function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(DrDialogModule, { declarations: [DialogWrapperComponent, DialogModalWrapperComponent], imports: [CommonModule, MatDialogModule, DrInputsModule, ReactiveFormsModule, DrTooltipModule, DrDetailsListModule], exports: [DialogWrapperComponent, DialogModalWrapperComponent] }); })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/dr-dialog/services/dialog.service.mjs

@@ -6,12 +6,15 @@ import * as i0 from "@angular/core";
 import * as i1 from "@angular/material/legacy-dialog";
 const DEFAULT_PANE_CLASS_NAME = 'wrapper-dialog';
 const DEFAULT_CONFIRM_THEME = { themeSize: 'small-modal' };
+/** @deprecated use DrModalService instead */
 export class DialogService {
     constructor(dialog) {
         this.dialog = dialog;
     }
     /**
      * Function to open modal with custom form
+     *
+     * @deprecated use DrModalService.open instead
      */
     openDialogWrapper(componentTypeChild, dialogData, componentTypeWrapper) {
         if (!componentTypeWrapper)
@@ -28,6 +31,8 @@ export class DialogService {
     }
     /**
      * Function to open confirmation modal
+     *
+     * @deprecated use DrModalService.confirm instead
      */
     openConfirmDialog(confirmDialogData) {
         const dialogData = {
@@ -43,6 +48,8 @@ export class DialogService {
     }
     /**
      * Function to open confirmation modal with inputs
+     *
+     * @deprecated use DrModalService.confirm instead
      */
     openConfirmDialogModal(confirmDialogData) {
         const dialogData = {
@@ -88,4 +95,4 @@ export class DialogService {
                 providedIn: 'root',
             }]
     }], function () { return [{ type: i1.MatLegacyDialog }]; }, null); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.service.js","sourceRoot":"","sources":["../../../../../../projects/datarailsshared/src/lib/dr-dialog/services/dialog.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentType } from '@angular/cdk/portal';\nimport { Injectable } from '@angular/core';\nimport { MatLegacyDialog as MatDialog, MatLegacyDialogRef as MatDialogRef } from '@angular/material/legacy-dialog';\nimport { ConfirmDialogData, DataProp, DialogData, DialogTheme } from '../interfaces/dialog-data';\nimport { DialogWrapperComponent } from '../components/dialog-wrapper/dialog-wrapper.component';\nimport { DialogModalWrapperComponent } from '../components/dialog-modal-wrapper/dialog-modal-wrapper.component';\n\nconst DEFAULT_PANE_CLASS_NAME = 'wrapper-dialog';\n\nconst DEFAULT_CONFIRM_THEME: DialogTheme = { themeSize: 'small-modal' };\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class DialogService {\n    private wrapperComponent: MatDialogRef<any>;\n\n    constructor(private dialog: MatDialog) {}\n\n    /**\n     * Function to open modal with custom form\n     */\n    openDialogWrapper<T, D = any, R = any>(\n        componentTypeChild: ComponentType<T>,\n        dialogData: DialogData<T>,\n        componentTypeWrapper?: ComponentType<D>,\n    ) {\n        if (!componentTypeWrapper) componentTypeWrapper = DialogWrapperComponent as any;\n\n        dialogData.data.child = componentTypeChild;\n\n        if (dialogData.panelClass instanceof Array) {\n            dialogData.panelClass.push(DEFAULT_PANE_CLASS_NAME);\n        } else {\n            dialogData.panelClass = [dialogData.panelClass || '', DEFAULT_PANE_CLASS_NAME];\n        }\n\n        this.wrapperComponent = this.openDialog<D, R, T>(componentTypeWrapper, dialogData);\n        return this.wrapperComponent;\n    }\n\n    /**\n     * Function to open confirmation modal\n     */\n    openConfirmDialog<R = any>(confirmDialogData: ConfirmDialogData): MatDialogRef<DialogWrapperComponent, R> {\n        const dialogData: DialogData = {\n            panelClass: DEFAULT_PANE_CLASS_NAME,\n            ariaLabel: confirmDialogData.title || null,\n            data: null,\n        };\n        Object.assign(dialogData, { data: confirmDialogData });\n        if (!dialogData.data.theme) dialogData.data.theme = DEFAULT_CONFIRM_THEME;\n        dialogData.data.theme.isConfirmation = true;\n        return this.openDialog<DialogWrapperComponent, R, ConfirmDialogData>(DialogWrapperComponent, dialogData);\n    }\n\n    /**\n     * Function to open confirmation modal with inputs\n     */\n    openConfirmDialogModal<R = any>(confirmDialogData: ConfirmDialogData): MatDialogRef<DialogModalWrapperComponent, R> {\n        const dialogData: DialogData = {\n            panelClass: DEFAULT_PANE_CLASS_NAME,\n            ariaLabel: confirmDialogData.title || null,\n            data: null,\n        };\n        Object.assign(dialogData, { data: confirmDialogData });\n        if (!dialogData.data.theme) dialogData.data.theme = DEFAULT_CONFIRM_THEME;\n        return this.openDialog<DialogModalWrapperComponent, R, ConfirmDialogData>(DialogModalWrapperComponent, dialogData);\n    }\n\n    /**\n     * @deprecated use closeDialog function within a concrete component\n     */\n    close(params?: any): void {\n        this.wrapperComponent.close(params);\n    }\n\n    closeAll(): void {\n        this.dialog.closeAll();\n    }\n\n    getDialogById(id: string) {\n        return this.dialog.getDialogById(id);\n    }\n\n    /**\n     * @deprecated\n     */\n    enableAcceptButton(): void {\n        this.wrapperComponent.componentInstance.enableAcceptButton();\n    }\n\n    changeDialogThemeSize(theme: string): void {\n        this.wrapperComponent.componentInstance.class = theme;\n    }\n\n    private openDialog<WrapperType, ReturnType = any, D = any>(\n        componentType: ComponentType<WrapperType>,\n        dialogData: DialogData<D>,\n    ): MatDialogRef<WrapperType, ReturnType> {\n        return this.dialog.open<WrapperType, DataProp<D>, ReturnType>(componentType, dialogData);\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.service.js","sourceRoot":"","sources":["../../../../../../projects/datarailsshared/src/lib/dr-dialog/services/dialog.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentType } from '@angular/cdk/portal';\nimport { Injectable } from '@angular/core';\nimport { MatLegacyDialog as MatDialog, MatLegacyDialogRef as MatDialogRef } from '@angular/material/legacy-dialog';\nimport { ConfirmDialogData, DataProp, DialogData, DialogTheme } from '../interfaces/dialog-data';\nimport { DialogWrapperComponent } from '../components/dialog-wrapper/dialog-wrapper.component';\nimport { DialogModalWrapperComponent } from '../components/dialog-modal-wrapper/dialog-modal-wrapper.component';\n\nconst DEFAULT_PANE_CLASS_NAME = 'wrapper-dialog';\n\nconst DEFAULT_CONFIRM_THEME: DialogTheme = { themeSize: 'small-modal' };\n\n/** @deprecated use DrModalService instead */\n@Injectable({\n    providedIn: 'root',\n})\nexport class DialogService {\n    private wrapperComponent: MatDialogRef<any>;\n\n    constructor(private dialog: MatDialog) {}\n\n    /**\n     * Function to open modal with custom form\n     *\n     * @deprecated use DrModalService.open instead\n     */\n    openDialogWrapper<T, D = any, R = any>(\n        componentTypeChild: ComponentType<T>,\n        dialogData: DialogData<T>,\n        componentTypeWrapper?: ComponentType<D>,\n    ) {\n        if (!componentTypeWrapper) componentTypeWrapper = DialogWrapperComponent as any;\n\n        dialogData.data.child = componentTypeChild;\n\n        if (dialogData.panelClass instanceof Array) {\n            dialogData.panelClass.push(DEFAULT_PANE_CLASS_NAME);\n        } else {\n            dialogData.panelClass = [dialogData.panelClass || '', DEFAULT_PANE_CLASS_NAME];\n        }\n\n        this.wrapperComponent = this.openDialog<D, R, T>(componentTypeWrapper, dialogData);\n        return this.wrapperComponent;\n    }\n\n    /**\n     * Function to open confirmation modal\n     *\n     * @deprecated use DrModalService.confirm instead\n     */\n    openConfirmDialog<R = any>(confirmDialogData: ConfirmDialogData): MatDialogRef<DialogWrapperComponent, R> {\n        const dialogData: DialogData = {\n            panelClass: DEFAULT_PANE_CLASS_NAME,\n            ariaLabel: confirmDialogData.title || null,\n            data: null,\n        };\n        Object.assign(dialogData, { data: confirmDialogData });\n        if (!dialogData.data.theme) dialogData.data.theme = DEFAULT_CONFIRM_THEME;\n        dialogData.data.theme.isConfirmation = true;\n        return this.openDialog<DialogWrapperComponent, R, ConfirmDialogData>(DialogWrapperComponent, dialogData);\n    }\n\n    /**\n     * Function to open confirmation modal with inputs\n     *\n     * @deprecated use DrModalService.confirm instead\n     */\n    openConfirmDialogModal<R = any>(confirmDialogData: ConfirmDialogData): MatDialogRef<DialogModalWrapperComponent, R> {\n        const dialogData: DialogData = {\n            panelClass: DEFAULT_PANE_CLASS_NAME,\n            ariaLabel: confirmDialogData.title || null,\n            data: null,\n        };\n        Object.assign(dialogData, { data: confirmDialogData });\n        if (!dialogData.data.theme) dialogData.data.theme = DEFAULT_CONFIRM_THEME;\n        return this.openDialog<DialogModalWrapperComponent, R, ConfirmDialogData>(DialogModalWrapperComponent, dialogData);\n    }\n\n    /**\n     * @deprecated use closeDialog function within a concrete component\n     */\n    close(params?: any): void {\n        this.wrapperComponent.close(params);\n    }\n\n    closeAll(): void {\n        this.dialog.closeAll();\n    }\n\n    getDialogById(id: string) {\n        return this.dialog.getDialogById(id);\n    }\n\n    /**\n     * @deprecated\n     */\n    enableAcceptButton(): void {\n        this.wrapperComponent.componentInstance.enableAcceptButton();\n    }\n\n    changeDialogThemeSize(theme: string): void {\n        this.wrapperComponent.componentInstance.class = theme;\n    }\n\n    private openDialog<WrapperType, ReturnType = any, D = any>(\n        componentType: ComponentType<WrapperType>,\n        dialogData: DialogData<D>,\n    ): MatDialogRef<WrapperType, ReturnType> {\n        return this.dialog.open<WrapperType, DataProp<D>, ReturnType>(componentType, dialogData);\n    }\n}\n"]}

package/esm2022/lib/dr-inputs/button/button.component.mjs

@@ -34,12 +34,13 @@ export class DrButtonComponent {
         this.disabled = false;
         this.isLoading = false;
         this.isActive = false;
+        this.type = 'submit'; // default HTML button type
     }
     /** @nocollapse */ static { this.ɵfac = function DrButtonComponent_Factory(t) { return new (t || DrButtonComponent)(); }; }
     /** @nocollapse */ static { this.ɵcmp = /** @pureOrBreakMyCode */ i0.ɵɵdefineComponent({ type: DrButtonComponent, selectors: [["dr-button"]], hostVars: 12, hostBindings: function DrButtonComponent_HostBindings(rf, ctx) { if (rf & 2) {
             i0.ɵɵclassMap(ctx.theme);
             i0.ɵɵclassProp("with-icon", ctx.icon)("with-icon-after", ctx.iconAfter)("disabled", ctx.disabled)("loading", ctx.isLoading)("active", ctx.isActive);
-        } }, inputs: { theme: "theme", icon: "icon", iconColor: "iconColor", iconSize: "iconSize", iconAfter: "iconAfter", iconAfterColor: "iconAfterColor", iconAfterSize: "iconAfterSize", disabled: "disabled", isLoading: "isLoading", isActive: "isActive" }, standalone: true, features: [i0.ɵɵStandaloneFeature], ngContentSelectors: _c0, decls: 5, vars: 4, consts: [[3, "disabled"], ["class", "dr-button__icon", 3, "class", "font-size", "color", 4, "ngIf"], ["class", "dr-button__spinner", 4, "ngIf"], ["class", "dr-button__icon dr-button__icon--after", 3, "class", "font-size", "color", 4, "ngIf"], [1, "dr-button__icon"], [1, "dr-button__spinner"], [1, "dr-icon-load"], [1, "dr-button__icon", "dr-button__icon--after"]], template: function DrButtonComponent_Template(rf, ctx) { if (rf & 1) {
+        } }, inputs: { theme: "theme", icon: "icon", iconColor: "iconColor", iconSize: "iconSize", iconAfter: "iconAfter", iconAfterColor: "iconAfterColor", iconAfterSize: "iconAfterSize", disabled: "disabled", isLoading: "isLoading", isActive: "isActive", type: "type" }, standalone: true, features: [i0.ɵɵStandaloneFeature], ngContentSelectors: _c0, decls: 5, vars: 5, consts: [[3, "disabled", "type"], ["class", "dr-button__icon", 3, "class", "font-size", "color", 4, "ngIf"], ["class", "dr-button__spinner", 4, "ngIf"], ["class", "dr-button__icon dr-button__icon--after", 3, "class", "font-size", "color", 4, "ngIf"], [1, "dr-button__icon"], [1, "dr-button__spinner"], [1, "dr-icon-load"], [1, "dr-button__icon", "dr-button__icon--after"]], template: function DrButtonComponent_Template(rf, ctx) { if (rf & 1) {
             i0.ɵɵprojectionDef();
             i0.ɵɵelementStart(0, "button", 0);
             i0.ɵɵtemplate(1, DrButtonComponent_i_1_Template, 1, 6, "i", 1);
@@ -48,7 +49,7 @@ export class DrButtonComponent {
             i0.ɵɵtemplate(4, DrButtonComponent_i_4_Template, 1, 6, "i", 3);
             i0.ɵɵelementEnd();
         } if (rf & 2) {
-            i0.ɵɵproperty("disabled", ctx.disabled);
+            i0.ɵɵproperty("disabled", ctx.disabled)("type", ctx.type);
             i0.ɵɵadvance(1);
             i0.ɵɵproperty("ngIf", ctx.icon);
             i0.ɵɵadvance(2);
@@ -59,7 +60,7 @@ export class DrButtonComponent {
 }
 (function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DrButtonComponent, [{
         type: Component,
-        args: [{ selector: 'dr-button', standalone: true, imports: [CommonModule], template: "<button [disabled]=\"disabled\">\n    <i *ngIf=\"icon\" class=\"dr-button__icon\" [class]=\"icon\" [style.font-size]=\"iconSize\" [style.color]=\"iconColor || 'inherit'\">\n    </i>\n    <ng-content></ng-content>\n    <div *ngIf=\"isLoading\" class=\"dr-button__spinner\">\n        <i [style.font-size]=\"iconSize\" class=\"dr-icon-load\"></i>\n    </div>\n    <i\n        *ngIf=\"iconAfter\"\n        class=\"dr-button__icon dr-button__icon--after\"\n        [class]=\"iconAfter\"\n        [style.font-size]=\"iconAfterSize\"\n        [style.color]=\"iconAfterColor || 'inherit'\">\n    </i>\n</button>\n", styles: [":host{display:inline-block}:host.disabled,:host.loading{pointer-events:none}:host button{font-size:14px;line-height:24px;font-weight:400;position:relative;display:flex;align-items:center;flex-wrap:nowrap;cursor:pointer;border-radius:16px;padding:4px 16px;height:32px;border:1px solid}:host button .dr-button__spinner{display:flex;align-items:center;justify-content:center;position:absolute;inset:0;background:inherit;border-radius:inherit}:host button .dr-button__spinner i{animation-name:rotate;animation-iteration-count:infinite;animation-duration:1s}:host.with-icon button{padding-left:8px}:host.with-icon button i:first-child{margin-right:4px}:host.with-icon-after button{padding-right:8px}:host.with-icon-after button i:last-child{margin-left:4px}:host.split-primary-first button,:host.split-secondary-first button{border-bottom-right-radius:0;border-top-right-radius:0;padding-right:8px}:host.help button{padding:4px 16px 4px 8px;color:#333;height:28px;border:none;min-width:84px}:host.help button i{min-width:4px}:host.split-primary-last button,:host.split-secondary-last button{border-bottom-left-radius:0;border-top-left-radius:0;padding-right:8px;padding-left:4px;border-left:none}:host.split-primary-last button i,:host.split-secondary-last button i{margin:0!important}:host.primary button,:host.split-primary-first button,:host.split-primary-last button{color:#fff;background:#4646ce;border-color:#4646ce}:host.primary button:hover,:host.split-primary-first button:hover,:host.split-primary-last button:hover{background:linear-gradient(96.89deg,#25258c,#4646ce);border-color:linear-gradient(96.89deg,#25258c 0%,#4646ce 100%)}:host.primary.active button,:host.primary button:active,:host.split-primary-first.active button,:host.split-primary-first button:active,:host.split-primary-last.active button,:host.split-primary-last button:active{background:#25258c;border-color:#25258c}:host.primary.disabled button,:host.split-primary-first.disabled button,:host.split-primary-last.disabled button{color:#aeabac;background:#f0f1f4;border-color:#f0f1f4}:host.split-primary-first button{border-right-color:#dfe0e3}:host.split-primary-first.disabled button{border-right-color:#aeabac}:host.secondary button,:host.split-secondary-first button,:host.split-secondary-last button{color:#4646ce;background:#fff;border-color:#4646ce}:host.secondary button:hover,:host.split-secondary-first button:hover,:host.split-secondary-last button:hover{background:#f5f5f5;box-shadow:0 4px 14px #0000001a}:host.secondary.active button,:host.secondary button:active,:host.split-secondary-first.active button,:host.split-secondary-first button:active,:host.split-secondary-last.active button,:host.split-secondary-last button:active{background:#eaeaff;box-shadow:none}:host.secondary.disabled button,:host.split-secondary-first.disabled button,:host.split-secondary-last.disabled button{color:#aeabac;border-color:#aeabac}:host.secondary-white button{color:#fff;background:transparent;border-color:#fff}:host.secondary-white button:hover{background:#ffffff1a;box-shadow:0 4px 14px #0000001a}:host.secondary-white.active button,:host.secondary-white button:active{background:transparent;box-shadow:none}:host.secondary-white.disabled button{color:#aeabac;border-color:#aeabac}:host.split-secondary-first button{border-right-color:#4646ce}:host.split-secondary-first.disabled button{border-right-color:#aeabac}:host.icon button,:host.icon-primary button,:host.icon-secondary button{width:28px;height:28px;padding:0;justify-content:center}:host.icon button i,:host.icon-primary button i,:host.icon-secondary button i{margin:0!important}:host.icon button{background:transparent;border-color:transparent;color:#6d6e6f}:host.icon button:hover{color:#333;background:#dfe0e3;border-color:#dfe0e3}:host.icon.active button,:host.icon button:active{color:#4646ce;background:#eaeaff;border-color:#eaeaff}:host.icon.disabled button{color:#aeabac;background:transparent;border-color:transparent}:host.icon-primary button{color:#fff;background:#4646ce;border-color:#4646ce}:host.icon-primary button:hover{color:#fff;background:linear-gradient(96.89deg,#25258c,#4646ce);border-color:linear-gradient(96.89deg,#25258c 0%,#4646ce 100%)}:host.icon-primary.active button,:host.icon-primary button:active{color:#fff;background:#25258c;border-color:#25258c}:host.icon-primary.disabled button{color:#aeabac;background:#f0f1f4;border-color:#f0f1f4}:host.icon-secondary button{color:#4646ce;background:#fff;border-color:#4646ce}:host.icon-secondary button:hover{color:#4646ce;background:#f5f5f5;border-color:#4646ce}:host.icon-secondary.active button,:host.icon-secondary button:active{color:#4646ce;background:#eaeaff;border-color:#4646ce}:host.icon-secondary.disabled button{color:#aeabac;background:#f0f1f4;border-color:#f0f1f4}:host.ghost button{border-radius:4px;padding:4px;background:transparent;border-color:transparent;color:#6d6e6f}:host.ghost button .dr-button__spinner{color:#4646ce;background:#fff}:host.ghost button:hover{color:#333;background:#f5f5f5;border-color:#f5f5f5}:host.ghost.active button,:host.ghost button:active{color:#4646ce;background:#eaeaff;border-color:#eaeaff}:host.ghost.disabled button{color:#aeabac;background:transparent;border-color:transparent}:host.highlight button{border:none;background:none;color:#4646ce;padding:0 4px;text-decoration:none}:host.highlight button:hover,:host.highlight.active button,:host.highlight button:active{text-decoration:underline}:host.highlight.disabled button{color:#aeabac}:host.dropdown button,:host.selection button{font-size:12px;line-height:16px;font-weight:400;border:1px solid #dfe0e3;border-radius:6px;padding:6px 8px;color:#6d6e6f;background-color:#fff}:host.dropdown button:hover,:host.selection button:hover{background-color:#f5f5f5;border-color:#4e566c}:host.dropdown.active button,:host.selection.active button{color:#4646ce}:host.dropdown.active button i:last-child,:host.selection.active button i:last-child{color:#333}:host.dropdown button:active,:host.selection button:active{border-color:#4646ce}:host.dropdown.disabled button,:host.selection.disabled button{background-color:#f0f1f4;color:#aeabac}:host.dropdown.disabled button i:last-child,:host.selection.disabled button i:last-child{color:#aeabac}:host.danger button{color:#fff;background:#bf1d30;border-color:#bf1d30}:host.danger button:hover{background:#981440;border-color:#981440}:host.danger.active button,:host.danger button:active{background:#680325;border-color:#680325}:host.danger.disabled button{color:#aeabac;background:#f0f1f4;border-color:#f0f1f4}:host.ai-primary button{color:#fff;border:none;background:linear-gradient(266deg,#6969ff 25.2%,#4eb7df 90.24%)}:host.ai-primary button:hover{background:linear-gradient(0deg,#4d4dcd66 0% 100%),linear-gradient(266deg,#6969ff 25.2%,#4eb7df 90.24%)}:host.ai-primary.active button,:host.ai-primary button:active{background:linear-gradient(0deg,#4d4dcd66 0% 100%),linear-gradient(266deg,#6969ff 25.2%,#4eb7df 90.24%)}:host.ai-primary.disabled button{color:#aeabac;background:#f0f1f4;border-color:#f0f1f4}:host.ai-secondary button{color:#4646ce;border:none!important;z-index:1;background:linear-gradient(269.57deg,#6969ff -4.23%,#4eb7df 103.6%)!important}:host.ai-secondary button:before{content:\"\";position:absolute;inset:1px;border-radius:15px;background-color:#fff;z-index:-1}:host.ai-secondary button:hover{box-shadow:0 4px 14px #0000001a}:host.ai-secondary.active button,:host.ai-secondary button:active{box-shadow:none}:host.ai-secondary.active button:before,:host.ai-secondary button:active:before{background:linear-gradient(270deg,#6969ff33 -4.23%,#4eb7df33 103.6%),#fff}:host.ai-secondary.disabled button{color:#aeabac;background:#f0f1f4!important;border:1px solid #aeabac!important}:host.ai-secondary.disabled button:before{display:none}:host.marketing button{color:#fff;background:#f93576;border-color:#f93576}:host.marketing button:hover,:host.marketing.active button,:host.marketing button:active{background:#c9245b;border-color:#c9245b}:host.marketing.disabled button{color:#aeabac;background:#f0f1f4;border-color:#f0f1f4}@keyframes rotate{0%{transform:rotate(0)}to{transform:rotate(360deg)}}\n"] }]
+        args: [{ selector: 'dr-button', standalone: true, imports: [CommonModule], template: "<button [disabled]=\"disabled\" [type]=\"type\">\n    <i *ngIf=\"icon\" class=\"dr-button__icon\" [class]=\"icon\" [style.font-size]=\"iconSize\" [style.color]=\"iconColor || 'inherit'\">\n    </i>\n    <ng-content></ng-content>\n    <div *ngIf=\"isLoading\" class=\"dr-button__spinner\">\n        <i [style.font-size]=\"iconSize\" class=\"dr-icon-load\"></i>\n    </div>\n    <i\n        *ngIf=\"iconAfter\"\n        class=\"dr-button__icon dr-button__icon--after\"\n        [class]=\"iconAfter\"\n        [style.font-size]=\"iconAfterSize\"\n        [style.color]=\"iconAfterColor || 'inherit'\">\n    </i>\n</button>\n", styles: [":host{display:inline-block}:host.disabled,:host.loading{pointer-events:none}:host button{font-size:14px;line-height:24px;font-weight:400;position:relative;display:flex;align-items:center;flex-wrap:nowrap;cursor:pointer;border-radius:16px;padding:4px 16px;height:32px;border:1px solid}:host button .dr-button__spinner{display:flex;align-items:center;justify-content:center;position:absolute;inset:0;background:inherit;border-radius:inherit}:host button .dr-button__spinner i{animation-name:rotate;animation-iteration-count:infinite;animation-duration:1s}:host.with-icon button{padding-left:8px}:host.with-icon button i:first-child{margin-right:4px}:host.with-icon-after button{padding-right:8px}:host.with-icon-after button i:last-child{margin-left:4px}:host.split-primary-first button,:host.split-secondary-first button{border-bottom-right-radius:0;border-top-right-radius:0;padding-right:8px}:host.help button{padding:4px 16px 4px 8px;color:#333;height:28px;border:none;min-width:84px}:host.help button i{min-width:4px}:host.split-primary-last button,:host.split-secondary-last button{border-bottom-left-radius:0;border-top-left-radius:0;padding-right:8px;padding-left:4px;border-left:none}:host.split-primary-last button i,:host.split-secondary-last button i{margin:0!important}:host.primary button,:host.split-primary-first button,:host.split-primary-last button{color:#fff;background:#4646ce;border-color:#4646ce}:host.primary button:hover,:host.split-primary-first button:hover,:host.split-primary-last button:hover{background:linear-gradient(96.89deg,#25258c,#4646ce);border-color:linear-gradient(96.89deg,#25258c 0%,#4646ce 100%)}:host.primary.active button,:host.primary button:active,:host.split-primary-first.active button,:host.split-primary-first button:active,:host.split-primary-last.active button,:host.split-primary-last button:active{background:#25258c;border-color:#25258c}:host.primary.disabled button,:host.split-primary-first.disabled button,:host.split-primary-last.disabled button{color:#aeabac;background:#f0f1f4;border-color:#f0f1f4}:host.split-primary-first button{border-right-color:#dfe0e3}:host.split-primary-first.disabled button{border-right-color:#aeabac}:host.secondary button,:host.split-secondary-first button,:host.split-secondary-last button{color:#4646ce;background:#fff;border-color:#4646ce}:host.secondary button:hover,:host.split-secondary-first button:hover,:host.split-secondary-last button:hover{background:#f5f5f5;box-shadow:0 4px 14px #0000001a}:host.secondary.active button,:host.secondary button:active,:host.split-secondary-first.active button,:host.split-secondary-first button:active,:host.split-secondary-last.active button,:host.split-secondary-last button:active{background:#eaeaff;box-shadow:none}:host.secondary.disabled button,:host.split-secondary-first.disabled button,:host.split-secondary-last.disabled button{color:#aeabac;border-color:#aeabac}:host.secondary-white button{color:#fff;background:transparent;border-color:#fff}:host.secondary-white button:hover{background:#ffffff1a;box-shadow:0 4px 14px #0000001a}:host.secondary-white.active button,:host.secondary-white button:active{background:transparent;box-shadow:none}:host.secondary-white.disabled button{color:#aeabac;border-color:#aeabac}:host.split-secondary-first button{border-right-color:#4646ce}:host.split-secondary-first.disabled button{border-right-color:#aeabac}:host.icon button,:host.icon-primary button,:host.icon-secondary button{width:28px;height:28px;padding:0;justify-content:center}:host.icon button i,:host.icon-primary button i,:host.icon-secondary button i{margin:0!important}:host.icon button{background:transparent;border-color:transparent;color:#6d6e6f}:host.icon button:hover{color:#333;background:#dfe0e3;border-color:#dfe0e3}:host.icon.active button,:host.icon button:active{color:#4646ce;background:#eaeaff;border-color:#eaeaff}:host.icon.disabled button{color:#aeabac;background:transparent;border-color:transparent}:host.icon-primary button{color:#fff;background:#4646ce;border-color:#4646ce}:host.icon-primary button:hover{color:#fff;background:linear-gradient(96.89deg,#25258c,#4646ce);border-color:linear-gradient(96.89deg,#25258c 0%,#4646ce 100%)}:host.icon-primary.active button,:host.icon-primary button:active{color:#fff;background:#25258c;border-color:#25258c}:host.icon-primary.disabled button{color:#aeabac;background:#f0f1f4;border-color:#f0f1f4}:host.icon-secondary button{color:#4646ce;background:#fff;border-color:#4646ce}:host.icon-secondary button:hover{color:#4646ce;background:#f5f5f5;border-color:#4646ce}:host.icon-secondary.active button,:host.icon-secondary button:active{color:#4646ce;background:#eaeaff;border-color:#4646ce}:host.icon-secondary.disabled button{color:#aeabac;background:#f0f1f4;border-color:#f0f1f4}:host.ghost button{border-radius:4px;padding:4px;background:transparent;border-color:transparent;color:#6d6e6f}:host.ghost button .dr-button__spinner{color:#4646ce;background:#fff}:host.ghost button:hover{color:#333;background:#f5f5f5;border-color:#f5f5f5}:host.ghost.active button,:host.ghost button:active{color:#4646ce;background:#eaeaff;border-color:#eaeaff}:host.ghost.disabled button{color:#aeabac;background:transparent;border-color:transparent}:host.highlight button{border:none;background:none;color:#4646ce;padding:0 4px;text-decoration:none}:host.highlight button:hover,:host.highlight.active button,:host.highlight button:active{text-decoration:underline}:host.highlight.disabled button{color:#aeabac}:host.dropdown button,:host.selection button{font-size:12px;line-height:16px;font-weight:400;border:1px solid #dfe0e3;border-radius:6px;padding:6px 8px;color:#6d6e6f;background-color:#fff}:host.dropdown button:hover,:host.selection button:hover{background-color:#f5f5f5;border-color:#4e566c}:host.dropdown.active button,:host.selection.active button{color:#4646ce}:host.dropdown.active button i:last-child,:host.selection.active button i:last-child{color:#333}:host.dropdown button:active,:host.selection button:active{border-color:#4646ce}:host.dropdown.disabled button,:host.selection.disabled button{background-color:#f0f1f4;color:#aeabac}:host.dropdown.disabled button i:last-child,:host.selection.disabled button i:last-child{color:#aeabac}:host.danger button{color:#fff;background:#bf1d30;border-color:#bf1d30}:host.danger button:hover{background:#981440;border-color:#981440}:host.danger.active button,:host.danger button:active{background:#680325;border-color:#680325}:host.danger.disabled button{color:#aeabac;background:#f0f1f4;border-color:#f0f1f4}:host.ai-primary button{color:#fff;border:none;background:linear-gradient(266deg,#6969ff 25.2%,#4eb7df 90.24%)}:host.ai-primary button:hover{background:linear-gradient(0deg,#4d4dcd66 0% 100%),linear-gradient(266deg,#6969ff 25.2%,#4eb7df 90.24%)}:host.ai-primary.active button,:host.ai-primary button:active{background:linear-gradient(0deg,#4d4dcd66 0% 100%),linear-gradient(266deg,#6969ff 25.2%,#4eb7df 90.24%)}:host.ai-primary.disabled button{color:#aeabac;background:#f0f1f4;border-color:#f0f1f4}:host.ai-secondary button{color:#4646ce;border:none!important;z-index:1;background:linear-gradient(269.57deg,#6969ff -4.23%,#4eb7df 103.6%)!important}:host.ai-secondary button:before{content:\"\";position:absolute;inset:1px;border-radius:15px;background-color:#fff;z-index:-1}:host.ai-secondary button:hover{box-shadow:0 4px 14px #0000001a}:host.ai-secondary.active button,:host.ai-secondary button:active{box-shadow:none}:host.ai-secondary.active button:before,:host.ai-secondary button:active:before{background:linear-gradient(270deg,#6969ff33 -4.23%,#4eb7df33 103.6%),#fff}:host.ai-secondary.disabled button{color:#aeabac;background:#f0f1f4!important;border:1px solid #aeabac!important}:host.ai-secondary.disabled button:before{display:none}:host.marketing button{color:#fff;background:#f93576;border-color:#f93576}:host.marketing button:hover,:host.marketing.active button,:host.marketing button:active{background:#c9245b;border-color:#c9245b}:host.marketing.disabled button{color:#aeabac;background:#f0f1f4;border-color:#f0f1f4}@keyframes rotate{0%{transform:rotate(0)}to{transform:rotate(360deg)}}\n"] }]
     }], null, { theme: [{
             type: Input
         }, {
@@ -98,5 +99,7 @@ export class DrButtonComponent {
         }, {
             type: HostBinding,
             args: ['class.active']
+        }], type: [{
+            type: Input
         }] }); })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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