@skbkontur/react-ui 0.0.0-e66a3400ba → 0.0.0-ecefada396

package/lib/date/InternalDateTransformer/InternalDateTransformer.js

@@ -0,0 +1,179 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { CHAR_PAD, defaultDateComponentsOrder, defaultDateComponentsSeparator, emptyDateComponents, LENGTH_DATE, LENGTH_MONTH, LENGTH_SEPARATOR, LENGTH_YEAR, RE_ORDER_DMY, RE_ORDER_MDY, RE_ORDER_YMD } from "../constants";
+import { InternalDateValidator } from "../InternalDateValidator";
+import { InternalDateComponentType, InternalDateOrder, InternalDateSeparator } from "../types";
+export var InternalDateTransformer = /*#__PURE__*/function () {
+  function InternalDateTransformer() {}
+
+  InternalDateTransformer.dateToFragments = function dateToFragments(components, settings) {
+    if (settings === void 0) {
+      settings = {};
+    }
+
+    var _settings = settings,
+        _settings$order = _settings.order,
+        order = _settings$order === void 0 ? defaultDateComponentsOrder : _settings$order,
+        _settings$separator = _settings.separator,
+        separator = _settings$separator === void 0 ? defaultDateComponentsSeparator : _settings$separator,
+        _settings$withSeparat = _settings.withSeparator,
+        withSeparator = _settings$withSeparat === void 0 ? false : _settings$withSeparat,
+        _settings$withPad = _settings.withPad,
+        withPad = _settings$withPad === void 0 ? false : _settings$withPad,
+        pad = _settings.pad;
+    var year = {
+      type: InternalDateComponentType.Year,
+      value: components.year,
+      length: LENGTH_YEAR
+    };
+    var month = {
+      type: InternalDateComponentType.Month,
+      value: components.month,
+      length: LENGTH_MONTH
+    };
+    var date = {
+      type: InternalDateComponentType.Date,
+      value: components.date,
+      length: LENGTH_DATE
+    };
+    var fragments = [];
+
+    if (order === InternalDateOrder.YMD) {
+      fragments.push(year, month, date);
+    } else if (order === InternalDateOrder.MDY) {
+      fragments.push(month, date, year);
+    } else if (order === InternalDateOrder.DMY) {
+      fragments.push(date, month, year);
+    }
+
+    if (withPad) {
+      year.valueWithPad = InternalDateTransformer.padYear(year.value, pad);
+      month.valueWithPad = InternalDateTransformer.padMonth(month.value, pad);
+      date.valueWithPad = InternalDateTransformer.padDate(date.value, pad);
+    }
+
+    year.isValid = InternalDateValidator.testParseToNumber(year.value);
+    month.isValid = InternalDateValidator.testParseToNumber(month.value);
+    date.isValid = InternalDateValidator.testParseToNumber(date.value);
+
+    if (withSeparator) {
+      var separatorFragment = {
+        type: InternalDateComponentType.Separator,
+        value: separator,
+        length: LENGTH_SEPARATOR
+      };
+      fragments.splice(1, 0, separatorFragment);
+      fragments.splice(3, 0, separatorFragment);
+    }
+
+    return fragments;
+  };
+
+  InternalDateTransformer.parseValueToDate = function parseValueToDate(value, order) {
+    if (order === void 0) {
+      order = defaultDateComponentsOrder;
+    }
+
+    if (!value) {
+      return null;
+    }
+
+    var re = order === InternalDateOrder.MDY ? RE_ORDER_MDY : order === InternalDateOrder.DMY ? RE_ORDER_DMY : RE_ORDER_YMD;
+
+    if (!re.test(value)) {
+      return null;
+    }
+
+    var match = re.exec(value);
+
+    var dateComponents = _extends({}, emptyDateComponents);
+
+    if (match) {
+      var matchFinished = match.slice(1).map(function (item) {
+        return InternalDateValidator.testParseToNumber(item) ? Number(item) : null;
+      });
+
+      if (order === InternalDateOrder.YMD) {
+        dateComponents.year = matchFinished[0];
+        dateComponents.month = matchFinished[1];
+        dateComponents.date = matchFinished[2];
+      } else if (order === InternalDateOrder.MDY) {
+        dateComponents.year = matchFinished[2];
+        dateComponents.month = matchFinished[0];
+        dateComponents.date = matchFinished[1];
+      } else if (order === InternalDateOrder.DMY) {
+        dateComponents.year = matchFinished[2];
+        dateComponents.month = matchFinished[1];
+        dateComponents.date = matchFinished[0];
+      }
+    }
+
+    return dateComponents;
+  };
+
+  InternalDateTransformer.dateComponentsStringToNumber = function dateComponentsStringToNumber(componentsRaw) {
+    if (componentsRaw === null) {
+      return {
+        year: 0,
+        month: 0,
+        date: 0
+      };
+    }
+
+    var year = componentsRaw.year,
+        month = componentsRaw.month,
+        date = componentsRaw.date;
+    return {
+      year: Number(year),
+      month: Number(month),
+      date: Number(date)
+    };
+  };
+
+  InternalDateTransformer.dateToInternalString = function dateToInternalString(components) {
+    return InternalDateTransformer.dateToFragments(components, {
+      withPad: true,
+      withSeparator: false,
+      order: InternalDateOrder.DMY
+    }).filter(function (_ref) {
+      var value = _ref.value;
+      return value !== null;
+    }).map(function (_ref2) {
+      var valueWithPad = _ref2.valueWithPad;
+      return valueWithPad;
+    }).join(InternalDateSeparator.Dot);
+  };
+
+  return InternalDateTransformer;
+}();
+
+InternalDateTransformer.padStart = function (value, length, pad) {
+  if (pad === void 0) {
+    pad = CHAR_PAD;
+  }
+
+  return String(value || '').padStart(length, pad);
+};
+
+InternalDateTransformer.padYear = function (year, pad) {
+  return InternalDateTransformer.padStart(year, LENGTH_YEAR, pad);
+};
+
+InternalDateTransformer.padMonth = function (month, pad) {
+  return InternalDateTransformer.padStart(month, LENGTH_MONTH, pad);
+};
+
+InternalDateTransformer.padDate = function (date, pad) {
+  return InternalDateTransformer.padStart(date, LENGTH_DATE, pad);
+};
+
+InternalDateTransformer.padDateComponent = function (type, value, pad) {
+  if (type === InternalDateComponentType.Year) {
+    return InternalDateTransformer.padYear(value, pad);
+  } else if (type === InternalDateComponentType.Month) {
+    return InternalDateTransformer.padMonth(value, pad);
+  } else if (type === InternalDateComponentType.Date) {
+    return InternalDateTransformer.padDate(value, pad);
+  }
+
+  return '';
+};

package/lib/date/InternalDateTransformer/InternalDateTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["InternalDateTransformer.ts"],"names":["CHAR_PAD","defaultDateComponentsOrder","defaultDateComponentsSeparator","emptyDateComponents","LENGTH_DATE","LENGTH_MONTH","LENGTH_SEPARATOR","LENGTH_YEAR","RE_ORDER_DMY","RE_ORDER_MDY","RE_ORDER_YMD","InternalDateValidator","InternalDateComponentType","InternalDateOrder","InternalDateSeparator","InternalDateTransformer","dateToFragments","components","settings","order","separator","withSeparator","withPad","pad","year","type","Year","value","length","month","Month","date","Date","fragments","YMD","push","MDY","DMY","valueWithPad","padYear","padMonth","padDate","isValid","testParseToNumber","separatorFragment","Separator","splice","parseValueToDate","re","test","match","exec","dateComponents","matchFinished","slice","map","item","Number","dateComponentsStringToNumber","componentsRaw","dateToInternalString","filter","join","Dot","padStart","String","padDateComponent"],"mappings":"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","sourcesContent":["import {\n  CHAR_PAD,\n  defaultDateComponentsOrder,\n  defaultDateComponentsSeparator,\n  emptyDateComponents,\n  LENGTH_DATE,\n  LENGTH_MONTH,\n  LENGTH_SEPARATOR,\n  LENGTH_YEAR,\n  RE_ORDER_DMY,\n  RE_ORDER_MDY,\n  RE_ORDER_YMD,\n} from './constants';\nimport { InternalDateValidator } from './InternalDateValidator';\nimport {\n  InternalDateComponentRaw,\n  InternalDateComponents,\n  InternalDateComponentsNumber,\n  InternalDateComponentsRaw,\n  InternalDateComponentType,\n  InternalDateFragment,\n  InternalDateOrder,\n  InternalDateSeparator,\n  InternalDateToFragmentsSettings,\n} from './types';\n\nexport class InternalDateTransformer {\n  public static padStart = (value: InternalDateComponentRaw, length: number, pad: string = CHAR_PAD): string =>\n    String(value || '').padStart(length, pad);\n\n  public static padYear = (year: InternalDateComponentRaw, pad?: string): string =>\n    InternalDateTransformer.padStart(year, LENGTH_YEAR, pad);\n  public static padMonth = (month: InternalDateComponentRaw, pad?: string): string =>\n    InternalDateTransformer.padStart(month, LENGTH_MONTH, pad);\n  public static padDate = (date: InternalDateComponentRaw, pad?: string): string =>\n    InternalDateTransformer.padStart(date, LENGTH_DATE, pad);\n\n  public static padDateComponent = (\n    type: InternalDateComponentType | null,\n    value: InternalDateComponentRaw,\n    pad?: string,\n  ): string => {\n    if (type === InternalDateComponentType.Year) {\n      return InternalDateTransformer.padYear(value, pad);\n    } else if (type === InternalDateComponentType.Month) {\n      return InternalDateTransformer.padMonth(value, pad);\n    } else if (type === InternalDateComponentType.Date) {\n      return InternalDateTransformer.padDate(value, pad);\n    }\n    return '';\n  };\n\n  public static dateToFragments(\n    components: InternalDateComponentsRaw,\n    settings: InternalDateToFragmentsSettings = {},\n  ): InternalDateFragment[] {\n    const {\n      order = defaultDateComponentsOrder,\n      separator = defaultDateComponentsSeparator,\n      withSeparator = false,\n      withPad = false,\n      pad,\n    } = settings;\n    const year: InternalDateFragment = {\n      type: InternalDateComponentType.Year,\n      value: components.year,\n      length: LENGTH_YEAR,\n    };\n    const month: InternalDateFragment = {\n      type: InternalDateComponentType.Month,\n      value: components.month,\n      length: LENGTH_MONTH,\n    };\n    const date: InternalDateFragment = {\n      type: InternalDateComponentType.Date,\n      value: components.date,\n      length: LENGTH_DATE,\n    };\n\n    const fragments: InternalDateFragment[] = [];\n    if (order === InternalDateOrder.YMD) {\n      fragments.push(year, month, date);\n    } else if (order === InternalDateOrder.MDY) {\n      fragments.push(month, date, year);\n    } else if (order === InternalDateOrder.DMY) {\n      fragments.push(date, month, year);\n    }\n\n    if (withPad) {\n      year.valueWithPad = InternalDateTransformer.padYear(year.value, pad);\n      month.valueWithPad = InternalDateTransformer.padMonth(month.value, pad);\n      date.valueWithPad = InternalDateTransformer.padDate(date.value, pad);\n    }\n\n    year.isValid = InternalDateValidator.testParseToNumber(year.value);\n    month.isValid = InternalDateValidator.testParseToNumber(month.value);\n    date.isValid = InternalDateValidator.testParseToNumber(date.value);\n\n    if (withSeparator) {\n      const separatorFragment: InternalDateFragment = {\n        type: InternalDateComponentType.Separator,\n        value: separator,\n        length: LENGTH_SEPARATOR,\n      };\n      fragments.splice(1, 0, separatorFragment);\n      fragments.splice(3, 0, separatorFragment);\n    }\n\n    return fragments;\n  }\n\n  public static parseValueToDate(\n    value: string | null,\n    order: InternalDateOrder = defaultDateComponentsOrder,\n  ): InternalDateComponents | null {\n    if (!value) {\n      return null;\n    }\n\n    const re =\n      order === InternalDateOrder.MDY ? RE_ORDER_MDY : order === InternalDateOrder.DMY ? RE_ORDER_DMY : RE_ORDER_YMD;\n    if (!re.test(value)) {\n      return null;\n    }\n    const match = re.exec(value);\n    const dateComponents: InternalDateComponents = { ...emptyDateComponents };\n\n    if (match) {\n      const matchFinished = match\n        .slice(1)\n        .map((item) => (InternalDateValidator.testParseToNumber(item) ? Number(item) : null));\n      if (order === InternalDateOrder.YMD) {\n        ({ 0: dateComponents.year, 1: dateComponents.month, 2: dateComponents.date } = matchFinished);\n      } else if (order === InternalDateOrder.MDY) {\n        ({ 2: dateComponents.year, 0: dateComponents.month, 1: dateComponents.date } = matchFinished);\n      } else if (order === InternalDateOrder.DMY) {\n        ({ 2: dateComponents.year, 1: dateComponents.month, 0: dateComponents.date } = matchFinished);\n      }\n    }\n    return dateComponents;\n  }\n\n  public static dateComponentsStringToNumber(\n    componentsRaw: InternalDateComponentsRaw | null,\n  ): InternalDateComponentsNumber {\n    if (componentsRaw === null) {\n      return { year: 0, month: 0, date: 0 };\n    }\n    const { year, month, date } = componentsRaw;\n    return { year: Number(year), month: Number(month), date: Number(date) };\n  }\n\n  public static dateToInternalString(components: InternalDateComponentsRaw): string {\n    return InternalDateTransformer.dateToFragments(components, {\n      withPad: true,\n      withSeparator: false,\n      order: InternalDateOrder.DMY,\n    })\n      .filter(({ value }) => value !== null)\n      .map(({ valueWithPad }) => valueWithPad)\n      .join(InternalDateSeparator.Dot);\n  }\n}\n"]}

package/lib/date/InternalDateTransformer/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../../cjs/lib/date/InternalDateTransformer.js",
+  "module": "InternalDateTransformer",
+  "types": "../InternalDateTransformer.d.ts",
+  "sideEffects": false
+}

package/lib/date/InternalDateTransformer.d.ts

@@ -1,12 +1,12 @@
-import { InternalDateComponents, InternalDateComponentsNumber, InternalDateComponentsRaw, InternalDateComponentType, InternalDateFragment, InternalDateOrder, InternalDateToFragmentsSettings } from './types';
-export default class InternalDateTransformer {
-    static padStart: (value: string | number | null, length: number, pad?: string) => string;
-    static padYear: (year: string | number | null, pad?: string | undefined) => string;
-    static padMonth: (month: string | number | null, pad?: string | undefined) => string;
-    static padDate: (date: string | number | null, pad?: string | undefined) => string;
-    static padDateComponent: (type: InternalDateComponentType | null, value: string | number | null, pad?: string | undefined) => string;
-    static dateToFragments(components: InternalDateComponentsRaw, settings?: InternalDateToFragmentsSettings): InternalDateFragment[];
-    static parseValueToDate(value: string | null, order?: InternalDateOrder): InternalDateComponents | null;
-    static dateComponentsStringToNumber(componentsRaw: InternalDateComponentsRaw | null): InternalDateComponentsNumber;
-    static dateToInternalString(components: InternalDateComponentsRaw): string;
-}
+import { InternalDateComponentRaw, InternalDateComponents, InternalDateComponentsNumber, InternalDateComponentsRaw, InternalDateComponentType, InternalDateFragment, InternalDateOrder, InternalDateToFragmentsSettings } from './types';
+export declare class InternalDateTransformer {
+    static padStart: (value: InternalDateComponentRaw, length: number, pad?: string) => string;
+    static padYear: (year: InternalDateComponentRaw, pad?: string | undefined) => string;
+    static padMonth: (month: InternalDateComponentRaw, pad?: string | undefined) => string;
+    static padDate: (date: InternalDateComponentRaw, pad?: string | undefined) => string;
+    static padDateComponent: (type: InternalDateComponentType | null, value: InternalDateComponentRaw, pad?: string | undefined) => string;
+    static dateToFragments(components: InternalDateComponentsRaw, settings?: InternalDateToFragmentsSettings): InternalDateFragment[];
+    static parseValueToDate(value: string | null, order?: InternalDateOrder): InternalDateComponents | null;
+    static dateComponentsStringToNumber(componentsRaw: InternalDateComponentsRaw | null): InternalDateComponentsNumber;
+    static dateToInternalString(components: InternalDateComponentsRaw): string;
+}

package/lib/date/InternalDateValidator/InternalDateValidator.js

@@ -0,0 +1,106 @@
+import { InternalDateGetter } from "../InternalDateGetter";
+import { InternalDateComponentType } from "../types";
+export var InternalDateValidator = /*#__PURE__*/function () {
+  function InternalDateValidator() {}
+
+  InternalDateValidator.checkForNull = function checkForNull(_ref, type) {
+    var year = _ref.year,
+        month = _ref.month,
+        date = _ref.date;
+
+    if (type !== undefined) {
+      if (type === InternalDateComponentType.Year) {
+        return year !== null;
+      } else if (type === InternalDateComponentType.Month) {
+        return month !== null;
+      } else if (type === InternalDateComponentType.All) {
+        return year !== null && month !== null && date !== null;
+      }
+
+      return date !== null;
+    }
+
+    return !(year === null || month === null || date === null);
+  };
+
+  InternalDateValidator.checkLimits = function checkLimits(_ref2, type) {
+    var year = _ref2.year,
+        month = _ref2.month,
+        date = _ref2.date;
+
+    if (type !== undefined) {
+      var value = type === InternalDateComponentType.Year ? year : type === InternalDateComponentType.Month ? month : date;
+      return value >= InternalDateGetter.getDefaultMin(type) && value <= InternalDateGetter.getDefaultMax(type);
+    }
+
+    return year >= InternalDateGetter.getDefaultMin(InternalDateComponentType.Year) && year <= InternalDateGetter.getDefaultMax(InternalDateComponentType.Year) && month >= InternalDateGetter.getDefaultMin(InternalDateComponentType.Month) && month <= InternalDateGetter.getDefaultMax(InternalDateComponentType.Month) && date >= InternalDateGetter.getDefaultMin(InternalDateComponentType.Date) && date <= InternalDateGetter.getDefaultMax(InternalDateComponentType.Date);
+  };
+
+  InternalDateValidator.compareWithNativeDate = function compareWithNativeDate(_ref3) {
+    var year = _ref3.year,
+        month = _ref3.month,
+        date = _ref3.date;
+    var nativeDate = new Date(Date.UTC(year, month - 1, date));
+    return nativeDate.getUTCFullYear() === year && nativeDate.getUTCMonth() + 1 === month && nativeDate.getUTCDate() === date;
+  };
+
+  InternalDateValidator.checkRangeFully = function checkRangeFully(date, startDate, endDate) {
+    if (startDate === null && endDate === null) {
+      return true;
+    }
+
+    startDate = startDate || -Infinity;
+    endDate = endDate || Infinity;
+    return date >= startDate && date <= endDate;
+  };
+
+  InternalDateValidator.checkRangePiecemeal = function checkRangePiecemeal(type, _ref4, startComponents, endComponents) {
+    var year = _ref4.year,
+        month = _ref4.month,
+        date = _ref4.date;
+
+    if (startComponents === null && endComponents === null) {
+      return true;
+    }
+
+    var _ref5 = startComponents || {},
+        _ref5$year = _ref5.year,
+        startYear = _ref5$year === void 0 ? -Infinity : _ref5$year,
+        _ref5$month = _ref5.month,
+        startMonth = _ref5$month === void 0 ? -Infinity : _ref5$month,
+        _ref5$date = _ref5.date,
+        startDate = _ref5$date === void 0 ? -Infinity : _ref5$date;
+
+    var _ref6 = endComponents || {},
+        _ref6$year = _ref6.year,
+        endYear = _ref6$year === void 0 ? Infinity : _ref6$year,
+        _ref6$month = _ref6.month,
+        endMonth = _ref6$month === void 0 ? Infinity : _ref6$month,
+        _ref6$date = _ref6.date,
+        endDate = _ref6$date === void 0 ? Infinity : _ref6$date;
+
+    if (type === InternalDateComponentType.Year) {
+      return !(year < startYear || year > endYear);
+    } else if (type === InternalDateComponentType.Month) {
+      return !(year === startYear && month < startMonth || year === endYear && month > endMonth);
+    } else if (type === InternalDateComponentType.Date) {
+      return !(year === startYear && month === startMonth && date < startDate || year === endYear && month === endMonth && date > endDate);
+    }
+
+    return true;
+  };
+
+  InternalDateValidator.testParseToNumber = function testParseToNumber(value) {
+    return value !== null && (typeof value === 'number' || !Number.isNaN(parseInt(value, 10)));
+  };
+
+  InternalDateValidator.isEqualDateValues = function isEqualDateValues(a, b) {
+    return a.toInternalString() === b.toInternalString();
+  };
+
+  InternalDateValidator.isEqualDateFormats = function isEqualDateFormats(a, b) {
+    return a.getOrder() === b.getOrder() && a.getSeparator() === b.getSeparator();
+  };
+
+  return InternalDateValidator;
+}();

package/lib/date/InternalDateValidator/InternalDateValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["InternalDateValidator.ts"],"names":["InternalDateGetter","InternalDateComponentType","InternalDateValidator","checkForNull","type","year","month","date","undefined","Year","Month","All","checkLimits","value","getDefaultMin","getDefaultMax","Date","compareWithNativeDate","nativeDate","UTC","getUTCFullYear","getUTCMonth","getUTCDate","checkRangeFully","startDate","endDate","Infinity","checkRangePiecemeal","startComponents","endComponents","startYear","startMonth","endYear","endMonth","testParseToNumber","Number","isNaN","parseInt","isEqualDateValues","a","b","toInternalString","isEqualDateFormats","getOrder","getSeparator"],"mappings":"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","sourcesContent":["import { InternalDate } from './InternalDate';\nimport { InternalDateGetter } from './InternalDateGetter';\nimport {\n  InternalDateComponentRaw,\n  InternalDateComponentsNumber,\n  InternalDateComponentsRaw,\n  InternalDateComponentType,\n} from './types';\n\nexport class InternalDateValidator {\n  public static checkForNull({ year, month, date }: InternalDateComponentsRaw, type?: InternalDateComponentType) {\n    if (type !== undefined) {\n      if (type === InternalDateComponentType.Year) {\n        return year !== null;\n      } else if (type === InternalDateComponentType.Month) {\n        return month !== null;\n      } else if (type === InternalDateComponentType.All) {\n        return year !== null && month !== null && date !== null;\n      }\n      return date !== null;\n    }\n    return !(year === null || month === null || date === null);\n  }\n\n  public static checkLimits(\n    { year, month, date }: InternalDateComponentsNumber,\n    type?: InternalDateComponentType,\n  ): boolean {\n    if (type !== undefined) {\n      const value =\n        type === InternalDateComponentType.Year ? year : type === InternalDateComponentType.Month ? month : date;\n\n      return value >= InternalDateGetter.getDefaultMin(type) && value <= InternalDateGetter.getDefaultMax(type);\n    }\n    return (\n      year >= InternalDateGetter.getDefaultMin(InternalDateComponentType.Year) &&\n      year <= InternalDateGetter.getDefaultMax(InternalDateComponentType.Year) &&\n      month >= InternalDateGetter.getDefaultMin(InternalDateComponentType.Month) &&\n      month <= InternalDateGetter.getDefaultMax(InternalDateComponentType.Month) &&\n      date >= InternalDateGetter.getDefaultMin(InternalDateComponentType.Date) &&\n      date <= InternalDateGetter.getDefaultMax(InternalDateComponentType.Date)\n    );\n  }\n\n  public static compareWithNativeDate({ year, month, date }: InternalDateComponentsNumber): boolean {\n    const nativeDate: Date = new Date(Date.UTC(year, month - 1, date));\n    return (\n      nativeDate.getUTCFullYear() === year && nativeDate.getUTCMonth() + 1 === month && nativeDate.getUTCDate() === date\n    );\n  }\n\n  public static checkRangeFully(date: number, startDate: number | null, endDate: number | null): boolean {\n    if (startDate === null && endDate === null) {\n      return true;\n    }\n    startDate = startDate || -Infinity;\n    endDate = endDate || Infinity;\n    return date >= startDate && date <= endDate;\n  }\n\n  public static checkRangePiecemeal(\n    type: InternalDateComponentType,\n    { year, month, date }: InternalDateComponentsNumber,\n    startComponents: InternalDateComponentsNumber | null,\n    endComponents: InternalDateComponentsNumber | null,\n  ): boolean {\n    if (startComponents === null && endComponents === null) {\n      return true;\n    }\n    const {\n      year: startYear = -Infinity,\n      month: startMonth = -Infinity,\n      date: startDate = -Infinity,\n    } = startComponents || {};\n    const { year: endYear = Infinity, month: endMonth = Infinity, date: endDate = Infinity } = endComponents || {};\n\n    if (type === InternalDateComponentType.Year) {\n      return !(year < startYear || year > endYear);\n    } else if (type === InternalDateComponentType.Month) {\n      return !((year === startYear && month < startMonth) || (year === endYear && month > endMonth));\n    } else if (type === InternalDateComponentType.Date) {\n      return !(\n        (year === startYear && month === startMonth && date < startDate) ||\n        (year === endYear && month === endMonth && date > endDate)\n      );\n    }\n    return true;\n  }\n\n  public static testParseToNumber(value: InternalDateComponentRaw): boolean {\n    return value !== null && (typeof value === 'number' || !Number.isNaN(parseInt(value, 10)));\n  }\n\n  public static isEqualDateValues(a: InternalDate, b: InternalDate): boolean {\n    return a.toInternalString() === b.toInternalString();\n  }\n\n  public static isEqualDateFormats(a: InternalDate, b: InternalDate): boolean {\n    return a.getOrder() === b.getOrder() && a.getSeparator() === b.getSeparator();\n  }\n}\n"]}

package/lib/date/InternalDateValidator/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../../cjs/lib/date/InternalDateValidator.js",
+  "module": "InternalDateValidator",
+  "types": "../InternalDateValidator.d.ts",
+  "sideEffects": false
+}

package/lib/date/InternalDateValidator.d.ts

@@ -1,9 +1,12 @@
-import { InternalDateComponentRaw, InternalDateComponentsNumber, InternalDateComponentsRaw, InternalDateComponentType } from './types';
-export default class InternalDateValidator {
-    static checkForNull({ year, month, date }: InternalDateComponentsRaw, type?: InternalDateComponentType): boolean;
-    static checkLimits({ year, month, date }: InternalDateComponentsNumber, type?: InternalDateComponentType): boolean;
-    static compareWithNativeDate({ year, month, date }: InternalDateComponentsNumber): boolean;
-    static checkRangeFully(date: number, startDate: number | null, endDate: number | null): boolean;
-    static checkRangePiecemeal(type: InternalDateComponentType, { year, month, date }: InternalDateComponentsNumber, startComponents: InternalDateComponentsNumber | null, endComponents: InternalDateComponentsNumber | null): boolean;
-    static testParseToNumber(value: InternalDateComponentRaw): boolean;
-}
+import { InternalDate } from './InternalDate';
+import { InternalDateComponentRaw, InternalDateComponentsNumber, InternalDateComponentsRaw, InternalDateComponentType } from './types';
+export declare class InternalDateValidator {
+    static checkForNull({ year, month, date }: InternalDateComponentsRaw, type?: InternalDateComponentType): boolean;
+    static checkLimits({ year, month, date }: InternalDateComponentsNumber, type?: InternalDateComponentType): boolean;
+    static compareWithNativeDate({ year, month, date }: InternalDateComponentsNumber): boolean;
+    static checkRangeFully(date: number, startDate: number | null, endDate: number | null): boolean;
+    static checkRangePiecemeal(type: InternalDateComponentType, { year, month, date }: InternalDateComponentsNumber, startComponents: InternalDateComponentsNumber | null, endComponents: InternalDateComponentsNumber | null): boolean;
+    static testParseToNumber(value: InternalDateComponentRaw): boolean;
+    static isEqualDateValues(a: InternalDate, b: InternalDate): boolean;
+    static isEqualDateFormats(a: InternalDate, b: InternalDate): boolean;
+}

package/lib/date/constants/constants.js

@@ -0,0 +1,28 @@
+import { InternalDateFirstDayWeek, InternalDateOrder, InternalDateSeparator } from "../types";
+export var MIN_YEAR = 0;
+export var MAX_YEAR = 9999;
+export var MIN_MONTH = 1;
+export var MAX_MONTH = 12;
+export var MIN_DATE = 1;
+export var MAX_DATE = 31;
+export var MIN_FULLDATE = '01.01.1900';
+export var MAX_FULLDATE = '31.12.2099';
+export var LENGTH_YEAR = 4;
+export var LENGTH_MONTH = 2;
+export var LENGTH_DATE = 2;
+export var LENGTH_SEPARATOR = 1;
+export var LENGTH_FULLDATE = LENGTH_YEAR + LENGTH_MONTH + LENGTH_DATE + LENGTH_SEPARATOR * 2;
+export var CHAR_PAD = '0';
+export var CHAR_MASK = '_';
+export var SEPARATOR = "(?:\\.|\\/|\\-|\\s|\\,)";
+export var RE_ORDER_MDY = new RegExp("^(\\d{1," + LENGTH_MONTH + "})?" + SEPARATOR + "?(\\d{1," + LENGTH_DATE + "})?" + SEPARATOR + "?(\\d{1," + LENGTH_YEAR + "})?$");
+export var RE_ORDER_DMY = new RegExp("^(\\d{1," + LENGTH_DATE + "})?" + SEPARATOR + "?(\\d{1," + LENGTH_MONTH + "})?" + SEPARATOR + "?(\\d{1," + LENGTH_YEAR + "})?$");
+export var RE_ORDER_YMD = new RegExp("^(\\d{1," + LENGTH_YEAR + "})?" + SEPARATOR + "?(\\d{1," + LENGTH_MONTH + "})?" + SEPARATOR + "?(\\d{1," + LENGTH_DATE + "})?$");
+export var emptyDateComponents = {
+  year: null,
+  month: null,
+  date: null
+};
+export var defaultDateComponentsOrder = InternalDateOrder.DMY;
+export var defaultDateComponentsSeparator = InternalDateSeparator.Dot;
+export var defaultFirstDayWeek = InternalDateFirstDayWeek.Monday;

package/lib/date/constants/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["constants.ts"],"names":["InternalDateFirstDayWeek","InternalDateOrder","InternalDateSeparator","MIN_YEAR","MAX_YEAR","MIN_MONTH","MAX_MONTH","MIN_DATE","MAX_DATE","MIN_FULLDATE","MAX_FULLDATE","LENGTH_YEAR","LENGTH_MONTH","LENGTH_DATE","LENGTH_SEPARATOR","LENGTH_FULLDATE","CHAR_PAD","CHAR_MASK","SEPARATOR","RE_ORDER_MDY","RegExp","RE_ORDER_DMY","RE_ORDER_YMD","emptyDateComponents","year","month","date","defaultDateComponentsOrder","DMY","defaultDateComponentsSeparator","Dot","defaultFirstDayWeek","Monday"],"mappings":"AAAA,SAASA,wBAAT,EAAmCC,iBAAnC,EAAsDC,qBAAtD,QAAmF,SAAnF;;AAEA,OAAO,IAAMC,QAAQ,GAAG,CAAjB;AACP,OAAO,IAAMC,QAAQ,GAAG,IAAjB;AACP,OAAO,IAAMC,SAAS,GAAG,CAAlB;AACP,OAAO,IAAMC,SAAS,GAAG,EAAlB;AACP,OAAO,IAAMC,QAAQ,GAAG,CAAjB;AACP,OAAO,IAAMC,QAAQ,GAAG,EAAjB;AACP,OAAO,IAAMC,YAAY,GAAG,YAArB;AACP,OAAO,IAAMC,YAAY,GAAG,YAArB;AACP,OAAO,IAAMC,WAAW,GAAG,CAApB;AACP,OAAO,IAAMC,YAAY,GAAG,CAArB;AACP,OAAO,IAAMC,WAAW,GAAG,CAApB;AACP,OAAO,IAAMC,gBAAgB,GAAG,CAAzB;AACP,OAAO,IAAMC,eAAe,GAAGJ,WAAW,GAAGC,YAAd,GAA6BC,WAA7B,GAA2CC,gBAAgB,GAAG,CAAtF;AACP,OAAO,IAAME,QAAQ,GAAG,GAAjB;AACP,OAAO,IAAMC,SAAS,GAAG,GAAlB;AACP,OAAO,IAAMC,SAAS,4BAAf;AACP,OAAO,IAAMC,YAAY,GAAG,IAAIC,MAAJ;AACfR,YADe,WACGM,SADH,gBACuBL,WADvB,WACwCK,SADxC,gBAC4DP,WAD5D,UAArB;;AAGP,OAAO,IAAMU,YAAY,GAAG,IAAID,MAAJ;AACfP,WADe,WACEK,SADF,gBACsBN,YADtB,WACwCM,SADxC,gBAC4DP,WAD5D,UAArB;;AAGP,OAAO,IAAMW,YAAY,GAAG,IAAIF,MAAJ;AACfT,WADe,WACEO,SADF,gBACsBN,YADtB,WACwCM,SADxC,gBAC4DL,WAD5D,UAArB;;AAGP,OAAO,IAAMU,mBAAmB,GAAG;AACjCC,EAAAA,IAAI,EAAE,IAD2B;AAEjCC,EAAAA,KAAK,EAAE,IAF0B;AAGjCC,EAAAA,IAAI,EAAE,IAH2B,EAA5B;;AAKP,OAAO,IAAMC,0BAA0B,GAAG1B,iBAAiB,CAAC2B,GAArD;AACP,OAAO,IAAMC,8BAA8B,GAAG3B,qBAAqB,CAAC4B,GAA7D;AACP,OAAO,IAAMC,mBAAmB,GAAG/B,wBAAwB,CAACgC,MAArD","sourcesContent":["import { InternalDateFirstDayWeek, InternalDateOrder, InternalDateSeparator } from './types';\n\nexport const MIN_YEAR = 0;\nexport const MAX_YEAR = 9999;\nexport const MIN_MONTH = 1;\nexport const MAX_MONTH = 12;\nexport const MIN_DATE = 1;\nexport const MAX_DATE = 31;\nexport const MIN_FULLDATE = '01.01.1900';\nexport const MAX_FULLDATE = '31.12.2099';\nexport const LENGTH_YEAR = 4;\nexport const LENGTH_MONTH = 2;\nexport const LENGTH_DATE = 2;\nexport const LENGTH_SEPARATOR = 1;\nexport const LENGTH_FULLDATE = LENGTH_YEAR + LENGTH_MONTH + LENGTH_DATE + LENGTH_SEPARATOR * 2;\nexport const CHAR_PAD = '0';\nexport const CHAR_MASK = '_';\nexport const SEPARATOR = `(?:\\\\.|\\\\/|\\\\-|\\\\s|\\\\,)`;\nexport const RE_ORDER_MDY = new RegExp(\n  `^(\\\\d{1,${LENGTH_MONTH}})?${SEPARATOR}?(\\\\d{1,${LENGTH_DATE}})?${SEPARATOR}?(\\\\d{1,${LENGTH_YEAR}})?$`,\n);\nexport const RE_ORDER_DMY = new RegExp(\n  `^(\\\\d{1,${LENGTH_DATE}})?${SEPARATOR}?(\\\\d{1,${LENGTH_MONTH}})?${SEPARATOR}?(\\\\d{1,${LENGTH_YEAR}})?$`,\n);\nexport const RE_ORDER_YMD = new RegExp(\n  `^(\\\\d{1,${LENGTH_YEAR}})?${SEPARATOR}?(\\\\d{1,${LENGTH_MONTH}})?${SEPARATOR}?(\\\\d{1,${LENGTH_DATE}})?$`,\n);\nexport const emptyDateComponents = {\n  year: null,\n  month: null,\n  date: null,\n};\nexport const defaultDateComponentsOrder = InternalDateOrder.DMY;\nexport const defaultDateComponentsSeparator = InternalDateSeparator.Dot;\nexport const defaultFirstDayWeek = InternalDateFirstDayWeek.Monday;\n"]}

package/lib/date/constants/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../../cjs/lib/date/constants.js",
+  "module": "constants",
+  "types": "../constants.d.ts",
+  "sideEffects": false
+}

package/lib/date/constants.d.ts

@@ -1,26 +1,28 @@
-import { InternalDateFirstDayWeek, InternalDateOrder, InternalDateSeparator } from './types';
-export declare const MIN_YEAR = 1900;
-export declare const MAX_YEAR = 2099;
-export declare const MIN_MONTH = 1;
-export declare const MAX_MONTH = 12;
-export declare const MIN_DATE = 1;
-export declare const MAX_DATE = 31;
-export declare const LENGTH_YEAR = 4;
-export declare const LENGTH_MONTH = 2;
-export declare const LENGTH_DATE = 2;
-export declare const LENGTH_SEPARATOR = 1;
-export declare const CHAR_PAD = "0";
-export declare const CHAR_MASK = "_";
-export declare const DELIMITERS: string[];
-export declare const SEPARATOR = "(?:\\.|\\/|\\-|\\s|\\,)";
-export declare const RE_ORDER_MDY: RegExp;
-export declare const RE_ORDER_DMY: RegExp;
-export declare const RE_ORDER_YMD: RegExp;
-export declare const emptyDateComponents: {
-    year: null;
-    month: null;
-    date: null;
-};
-export declare const defaultDateComponentsOrder = InternalDateOrder.DMY;
-export declare const defaultDateComponentsSeparator = InternalDateSeparator.Dot;
-export declare const defaultFirstDayWeek = InternalDateFirstDayWeek.Monday;
+import { InternalDateFirstDayWeek, InternalDateOrder, InternalDateSeparator } from './types';
+export declare const MIN_YEAR = 0;
+export declare const MAX_YEAR = 9999;
+export declare const MIN_MONTH = 1;
+export declare const MAX_MONTH = 12;
+export declare const MIN_DATE = 1;
+export declare const MAX_DATE = 31;
+export declare const MIN_FULLDATE = "01.01.1900";
+export declare const MAX_FULLDATE = "31.12.2099";
+export declare const LENGTH_YEAR = 4;
+export declare const LENGTH_MONTH = 2;
+export declare const LENGTH_DATE = 2;
+export declare const LENGTH_SEPARATOR = 1;
+export declare const LENGTH_FULLDATE: number;
+export declare const CHAR_PAD = "0";
+export declare const CHAR_MASK = "_";
+export declare const SEPARATOR = "(?:\\.|\\/|\\-|\\s|\\,)";
+export declare const RE_ORDER_MDY: RegExp;
+export declare const RE_ORDER_DMY: RegExp;
+export declare const RE_ORDER_YMD: RegExp;
+export declare const emptyDateComponents: {
+    year: null;
+    month: null;
+    date: null;
+};
+export declare const defaultDateComponentsOrder = InternalDateOrder.DMY;
+export declare const defaultDateComponentsSeparator = InternalDateSeparator.Dot;
+export declare const defaultFirstDayWeek = InternalDateFirstDayWeek.Monday;

package/lib/date/localeSets/localeSets.js

@@ -0,0 +1,17 @@
+var _internalDateLocale;
+
+import { LangCodes } from "../../locale";
+import { InternalDateDayWeek, InternalDateFirstDayWeek, InternalDateOrder, InternalDateSeparator } from "../types";
+var DateCustomSet_DMY_Dot_Monday_6_7 = {
+  order: InternalDateOrder.DMY,
+  separator: InternalDateSeparator.Dot,
+  firstDayWeek: InternalDateFirstDayWeek.Monday,
+  notWorkingDays: [InternalDateDayWeek.Saturday, InternalDateDayWeek.Sunday]
+};
+var DateCustomSet_DMY_Slash_Sunday_6_7 = {
+  order: InternalDateOrder.DMY,
+  separator: InternalDateSeparator.Slash,
+  firstDayWeek: InternalDateFirstDayWeek.Sunday,
+  notWorkingDays: [InternalDateDayWeek.Saturday, InternalDateDayWeek.Sunday]
+};
+export var internalDateLocale = (_internalDateLocale = {}, _internalDateLocale[LangCodes.ru_RU] = DateCustomSet_DMY_Dot_Monday_6_7, _internalDateLocale[LangCodes.en_GB] = DateCustomSet_DMY_Slash_Sunday_6_7, _internalDateLocale);

package/lib/date/localeSets/localeSets.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["localeSets.ts"],"names":["LangCodes","InternalDateDayWeek","InternalDateFirstDayWeek","InternalDateOrder","InternalDateSeparator","DateCustomSet_DMY_Dot_Monday_6_7","order","DMY","separator","Dot","firstDayWeek","Monday","notWorkingDays","Saturday","Sunday","DateCustomSet_DMY_Slash_Sunday_6_7","Slash","internalDateLocale","ru_RU","en_GB"],"mappings":"wBAAA,SAASA,SAAT,QAA0B,WAA1B;;AAEA;AACEC,mBADF;AAEEC,wBAFF;;AAIEC,iBAJF;AAKEC,qBALF;AAMO,SANP;;AAQA,IAAMC,gCAAuD,GAAG;AAC9DC,EAAAA,KAAK,EAAEH,iBAAiB,CAACI,GADqC;AAE9DC,EAAAA,SAAS,EAAEJ,qBAAqB,CAACK,GAF6B;AAG9DC,EAAAA,YAAY,EAAER,wBAAwB,CAACS,MAHuB;AAI9DC,EAAAA,cAAc,EAAE,CAACX,mBAAmB,CAACY,QAArB,EAA+BZ,mBAAmB,CAACa,MAAnD,CAJ8C,EAAhE;;;AAOA,IAAMC,kCAAyD,GAAG;AAChET,EAAAA,KAAK,EAAEH,iBAAiB,CAACI,GADuC;AAEhEC,EAAAA,SAAS,EAAEJ,qBAAqB,CAACY,KAF+B;AAGhEN,EAAAA,YAAY,EAAER,wBAAwB,CAACY,MAHyB;AAIhEF,EAAAA,cAAc,EAAE,CAACX,mBAAmB,CAACY,QAArB,EAA+BZ,mBAAmB,CAACa,MAAnD,CAJgD,EAAlE;;;AAOA,OAAO,IAAMG,kBAEZ;;;AACEjB,SAAS,CAACkB,KADZ,IACoBb,gCADpB;AAEEL,SAAS,CAACmB,KAFZ,IAEoBJ,kCAFpB,sBAFM","sourcesContent":["import { LangCodes } from '../locale';\n\nimport {\n  InternalDateDayWeek,\n  InternalDateFirstDayWeek,\n  InternalDateLocaleSet,\n  InternalDateOrder,\n  InternalDateSeparator,\n} from './types';\n\nconst DateCustomSet_DMY_Dot_Monday_6_7: InternalDateLocaleSet = {\n  order: InternalDateOrder.DMY,\n  separator: InternalDateSeparator.Dot,\n  firstDayWeek: InternalDateFirstDayWeek.Monday,\n  notWorkingDays: [InternalDateDayWeek.Saturday, InternalDateDayWeek.Sunday],\n};\n\nconst DateCustomSet_DMY_Slash_Sunday_6_7: InternalDateLocaleSet = {\n  order: InternalDateOrder.DMY,\n  separator: InternalDateSeparator.Slash,\n  firstDayWeek: InternalDateFirstDayWeek.Sunday,\n  notWorkingDays: [InternalDateDayWeek.Saturday, InternalDateDayWeek.Sunday],\n};\n\nexport const internalDateLocale: {\n  [key in LangCodes]: InternalDateLocaleSet;\n} = {\n  [LangCodes.ru_RU]: DateCustomSet_DMY_Dot_Monday_6_7,\n  [LangCodes.en_GB]: DateCustomSet_DMY_Slash_Sunday_6_7,\n};\n"]}

package/lib/date/localeSets/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../../cjs/lib/date/localeSets.js",
+  "module": "localeSets",
+  "types": "../localeSets.d.ts",
+  "sideEffects": false
+}

package/lib/date/localeSets.d.ts

@@ -1,5 +1,5 @@
-import { InternalDateLocaleSet } from '../../components/DatePicker/locale';
-import { LangCodes } from '../../components/LocaleProvider';
-export declare const internalDateLocale: {
-    [key in LangCodes]: InternalDateLocaleSet;
-};
+import { LangCodes } from '../locale';
+import { InternalDateLocaleSet } from './types';
+export declare const internalDateLocale: {
+    [key in LangCodes]: InternalDateLocaleSet;
+};

package/lib/date/types/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../../cjs/lib/date/types.js",
+  "module": "types",
+  "types": "../types.d.ts",
+  "sideEffects": false
+}

package/lib/date/types/types.js

@@ -0,0 +1,59 @@
+export var InternalDateOrder;
+
+(function (InternalDateOrder) {
+  InternalDateOrder["DMY"] = "DMY";
+  InternalDateOrder["YMD"] = "YMD";
+  InternalDateOrder["MDY"] = "MDY";
+})(InternalDateOrder || (InternalDateOrder = {}));
+
+export var InternalDateSeparator;
+
+(function (InternalDateSeparator) {
+  InternalDateSeparator["Slash"] = "/";
+  InternalDateSeparator["Dot"] = ".";
+  InternalDateSeparator["Dash"] = "-";
+  InternalDateSeparator["Space"] = " ";
+})(InternalDateSeparator || (InternalDateSeparator = {}));
+
+export var InternalDateComponentType;
+
+(function (InternalDateComponentType) {
+  InternalDateComponentType[InternalDateComponentType["Date"] = 0] = "Date";
+  InternalDateComponentType[InternalDateComponentType["Month"] = 1] = "Month";
+  InternalDateComponentType[InternalDateComponentType["Year"] = 2] = "Year";
+  InternalDateComponentType[InternalDateComponentType["All"] = 3] = "All";
+  InternalDateComponentType[InternalDateComponentType["Separator"] = 4] = "Separator";
+})(InternalDateComponentType || (InternalDateComponentType = {}));
+
+export var InternalDateValidateCheck;
+
+(function (InternalDateValidateCheck) {
+  InternalDateValidateCheck[InternalDateValidateCheck["NotNull"] = 0] = "NotNull";
+  InternalDateValidateCheck[InternalDateValidateCheck["Number"] = 1] = "Number";
+  InternalDateValidateCheck[InternalDateValidateCheck["Limits"] = 2] = "Limits";
+  InternalDateValidateCheck[InternalDateValidateCheck["Native"] = 3] = "Native";
+  InternalDateValidateCheck[InternalDateValidateCheck["Range"] = 4] = "Range";
+})(InternalDateValidateCheck || (InternalDateValidateCheck = {}));
+
+export function isInternalDateValidateCheck(value) {
+  return typeof value === 'number' && Object.values(InternalDateValidateCheck).includes(value);
+}
+export var InternalDateFirstDayWeek;
+
+(function (InternalDateFirstDayWeek) {
+  InternalDateFirstDayWeek[InternalDateFirstDayWeek["Monday"] = 0] = "Monday";
+  InternalDateFirstDayWeek[InternalDateFirstDayWeek["Sunday"] = 1] = "Sunday";
+  InternalDateFirstDayWeek[InternalDateFirstDayWeek["Saturday"] = 2] = "Saturday";
+})(InternalDateFirstDayWeek || (InternalDateFirstDayWeek = {}));
+
+export var InternalDateDayWeek;
+
+(function (InternalDateDayWeek) {
+  InternalDateDayWeek[InternalDateDayWeek["Monday"] = 1] = "Monday";
+  InternalDateDayWeek[InternalDateDayWeek["Tuesday"] = 2] = "Tuesday";
+  InternalDateDayWeek[InternalDateDayWeek["Wednesday"] = 3] = "Wednesday";
+  InternalDateDayWeek[InternalDateDayWeek["Thursday"] = 4] = "Thursday";
+  InternalDateDayWeek[InternalDateDayWeek["Friday"] = 5] = "Friday";
+  InternalDateDayWeek[InternalDateDayWeek["Sunday"] = 6] = "Sunday";
+  InternalDateDayWeek[InternalDateDayWeek["Saturday"] = 7] = "Saturday";
+})(InternalDateDayWeek || (InternalDateDayWeek = {}));

package/lib/date/types/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["types.ts"],"names":["InternalDateOrder","InternalDateSeparator","InternalDateComponentType","InternalDateValidateCheck","isInternalDateValidateCheck","value","Object","values","includes","InternalDateFirstDayWeek","InternalDateDayWeek"],"mappings":";;AAEA,WAAYA,iBAAZ,C,WAAYA,iB,GAAAA,iB,gBAAAA,iB,gBAAAA,iB,mBAAAA,iB,KAAAA,iB;;;;;;AAMZ,WAAYC,qBAAZ,C,WAAYA,qB,GAAAA,qB,gBAAAA,qB,cAAAA,qB,eAAAA,qB,mBAAAA,qB,KAAAA,qB;;;;;;;AAOZ,WAAYC,yBAAZ,C,WAAYA,yB,GAAAA,yB,CAAAA,yB,uBAAAA,yB,CAAAA,yB,yBAAAA,yB,CAAAA,yB,uBAAAA,yB,CAAAA,yB,qBAAAA,yB,CAAAA,yB,oCAAAA,yB,KAAAA,yB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2DZ,WAAYC,yBAAZ,C,WAAYA,yB,GAAAA,yB,CAAAA,yB,6BAAAA,yB,CAAAA,yB,2BAAAA,yB,CAAAA,yB,2BAAAA,yB,CAAAA,yB,2BAAAA,yB,CAAAA,yB,4BAAAA,yB,KAAAA,yB;;;;;;;;AAQZ,OAAO,SAASC,2BAAT,CAAqCC,KAArC,EAAyF;AAC9F,SAAO,OAAOA,KAAP,KAAiB,QAAjB,IAA6BC,MAAM,CAACC,MAAP,CAAcJ,yBAAd,EAAyCK,QAAzC,CAAkDH,KAAlD,CAApC;AACD;;AAED,WAAYI,wBAAZ,C,WAAYA,wB,GAAAA,wB,CAAAA,wB,2BAAAA,wB,CAAAA,wB,2BAAAA,wB,CAAAA,wB,kCAAAA,wB,KAAAA,wB;;;;;;AAMZ,WAAYC,mBAAZ,C,WAAYA,mB,GAAAA,mB,CAAAA,mB,2BAAAA,mB,CAAAA,mB,6BAAAA,mB,CAAAA,mB,iCAAAA,mB,CAAAA,mB,+BAAAA,mB,CAAAA,mB,2BAAAA,mB,CAAAA,mB,2BAAAA,mB,CAAAA,mB,kCAAAA,mB,KAAAA,mB","sourcesContent":["import { LangCodes } from '../locale';\n\nexport enum InternalDateOrder {\n  DMY = 'DMY',\n  YMD = 'YMD',\n  MDY = 'MDY',\n}\n\nexport enum InternalDateSeparator {\n  Slash = '/',\n  Dot = '.',\n  Dash = '-',\n  Space = ' ',\n}\n\nexport enum InternalDateComponentType {\n  Date = 0,\n  Month = 1,\n  Year = 2,\n  All = 3,\n  Separator = 4,\n}\n\nexport type InternalDateTypesOrder = [InternalDateComponentType, InternalDateComponentType, InternalDateComponentType];\nexport type InternalDateComponent = number | null;\nexport type InternalDateComponentRaw = number | string | null;\n\nexport interface InternalDateFragment {\n  type: InternalDateComponentType;\n  value: InternalDateComponentRaw | InternalDateSeparator;\n  length: number;\n  valueWithPad?: string;\n  isValid?: boolean;\n}\n\nexport interface InternalDateComponents {\n  year: InternalDateComponent;\n  month: InternalDateComponent;\n  date: InternalDateComponent;\n}\n\nexport interface InternalDateComponentsRaw {\n  year: InternalDateComponentRaw;\n  month: InternalDateComponentRaw;\n  date: InternalDateComponentRaw;\n}\n\nexport interface InternalDateComponentsNumber {\n  year: number;\n  month: number;\n  date: number;\n}\n\nexport interface InternalDateToFragmentsSettings {\n  order?: InternalDateOrder;\n  separator?: InternalDateSeparator;\n  withSeparator?: boolean;\n  withPad?: boolean;\n  pad?: string;\n}\n\nexport interface InternalDateChangeSettings {\n  isLoop?: boolean;\n  isRange?: boolean;\n  isCutFeb?: boolean;\n}\n\nexport interface InternalDateConstructorProps {\n  order?: InternalDateOrder;\n  separator?: InternalDateSeparator;\n  langCode?: LangCodes;\n  value?: string;\n}\n\nexport enum InternalDateValidateCheck {\n  NotNull,\n  Number,\n  Limits,\n  Native,\n  Range,\n}\n\nexport function isInternalDateValidateCheck(value: unknown): value is InternalDateValidateCheck {\n  return typeof value === 'number' && Object.values(InternalDateValidateCheck).includes(value);\n}\n\nexport enum InternalDateFirstDayWeek {\n  Monday = 0,\n  Sunday = 1,\n  Saturday = 2,\n}\n\nexport enum InternalDateDayWeek {\n  Monday = 1,\n  Tuesday = 2,\n  Wednesday = 3,\n  Thursday = 4,\n  Friday = 5,\n  Sunday = 6,\n  Saturday = 7,\n}\n\nexport interface InternalDateLocaleSet {\n  order: InternalDateOrder;\n  separator: InternalDateSeparator;\n  firstDayWeek: InternalDateFirstDayWeek;\n  notWorkingDays: InternalDateDayWeek[];\n}\n"]}