mis-crystal-design-system 14.0.55-test-v3 → 14.0.55-test-v5

package/esm2020/datepicker/chronos/create/from-array.mjs

@@ -0,0 +1,136 @@
+import { DATE, HOUR, MILLISECOND, MINUTE, MONTH, SECOND, YEAR } from '../units/constants';
+import { daysInYear } from '../units/year';
+import { getParsingFlags } from './parsing-flags';
+import { createUTCDate } from './date-from-array';
+import { createDate } from './date-from-array';
+import { dayOfYearFromWeeks, weekOfYear, weeksInYear } from '../units/week-calendar-utils';
+import { defaults } from '../utils/defaults';
+function currentDateArray(config) {
+    const nowValue = new Date();
+    if (config._useUTC) {
+        return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];
+    }
+    return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
+}
+// convert an array to a date.
+// the array should mirror the parameters below
+// note: all values past the year are optional and will default to the lowest possible value.
+// [year, month, day , hour, minute, second, millisecond]
+export function configFromArray(config) {
+    const input = [];
+    let i;
+    let date;
+    let currentDate;
+    let expectedWeekday;
+    let yearToUse;
+    if (config._d) {
+        return config;
+    }
+    currentDate = currentDateArray(config);
+    // compute day of the year from weeks and weekdays
+    if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
+        dayOfYearFromWeekInfo(config);
+    }
+    // if the day of the year is set, figure out what it is
+    if (config._dayOfYear != null) {
+        yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
+        if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {
+            getParsingFlags(config)._overflowDayOfYear = true;
+        }
+        date = new Date(Date.UTC(yearToUse, 0, config._dayOfYear));
+        config._a[MONTH] = date.getUTCMonth();
+        config._a[DATE] = date.getUTCDate();
+    }
+    // Default to current date.
+    // * if no year, month, day of month are given, default to today
+    // * if day of month is given, default month and year
+    // * if month is given, default only year
+    // * if year is given, don't default anything
+    for (i = 0; i < 3 && config._a[i] == null; ++i) {
+        config._a[i] = input[i] = currentDate[i];
+    }
+    // Zero out whatever was not defaulted, including time
+    for (; i < 7; i++) {
+        config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
+    }
+    // Check for 24:00:00.000
+    if (config._a[HOUR] === 24 &&
+        config._a[MINUTE] === 0 &&
+        config._a[SECOND] === 0 &&
+        config._a[MILLISECOND] === 0) {
+        config._nextDay = true;
+        config._a[HOUR] = 0;
+    }
+    config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
+    expectedWeekday = config._useUTC ? config._d.getUTCDay() : config._d.getDay();
+    // Apply timezone offset from input. The actual utcOffset can be changed
+    // with parseZone.
+    if (config._tzm != null) {
+        config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
+    }
+    if (config._nextDay) {
+        config._a[HOUR] = 24;
+    }
+    // check for mismatching day of week
+    if (config._w && typeof config._w.d !== 'undefined' && config._w.d !== expectedWeekday) {
+        getParsingFlags(config).weekdayMismatch = true;
+    }
+    return config;
+}
+function dayOfYearFromWeekInfo(config) {
+    let w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;
+    w = config._w;
+    if (w.GG != null || w.W != null || w.E != null) {
+        dow = 1;
+        doy = 4;
+        // TODO: We need to take the current isoWeekYear, but that depends on
+        // how we interpret now (local, utc, fixed offset). So create
+        // a now version of current config (take local/utc/offset flags, and
+        // create now).
+        weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(new Date(), 1, 4).year);
+        week = defaults(w.W, 1);
+        weekday = defaults(w.E, 1);
+        if (weekday < 1 || weekday > 7) {
+            weekdayOverflow = true;
+        }
+    }
+    else {
+        dow = config._locale._week.dow;
+        doy = config._locale._week.doy;
+        const curWeek = weekOfYear(new Date(), dow, doy);
+        weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
+        // Default to current week.
+        week = defaults(w.w, curWeek.week);
+        if (w.d != null) {
+            // weekday -- low day numbers are considered next week
+            weekday = w.d;
+            if (weekday < 0 || weekday > 6) {
+                weekdayOverflow = true;
+            }
+        }
+        else if (w.e != null) {
+            // local weekday -- counting starts from begining of week
+            weekday = w.e + dow;
+            if (w.e < 0 || w.e > 6) {
+                weekdayOverflow = true;
+            }
+        }
+        else {
+            // default to begining of week
+            weekday = dow;
+        }
+    }
+    if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
+        getParsingFlags(config)._overflowWeeks = true;
+    }
+    else if (weekdayOverflow != null) {
+        getParsingFlags(config)._overflowWeekday = true;
+    }
+    else {
+        temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
+        config._a[YEAR] = temp.year;
+        config._dayOfYear = temp.dayOfYear;
+    }
+    return config;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"from-array.js","sourceRoot":"","sources":["../../../../../../projects/mis-components/datepicker/chronos/create/from-array.ts"],"names":[],"mappings":"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","sourcesContent":["import { DateParsingConfig } from './parsing.types';\nimport { DateArray } from '../types';\nimport { DATE, HOUR, MILLISECOND, MINUTE, MONTH, SECOND, YEAR } from '../units/constants';\nimport { daysInYear } from '../units/year';\nimport { getParsingFlags } from './parsing-flags';\nimport { createUTCDate } from './date-from-array';\nimport { createDate } from './date-from-array';\nimport { dayOfYearFromWeeks, weekOfYear, weeksInYear } from '../units/week-calendar-utils';\nimport { defaults } from '../utils/defaults';\n\nfunction currentDateArray(config: DateParsingConfig): DateArray {\n  const nowValue = new Date();\n\n  if (config._useUTC) {\n    return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];\n  }\n\n  return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];\n}\n\n// convert an array to a date.\n// the array should mirror the parameters below\n// note: all values past the year are optional and will default to the lowest possible value.\n// [year, month, day , hour, minute, second, millisecond]\nexport function configFromArray(config: DateParsingConfig): DateParsingConfig {\n  const input = [];\n  let i;\n  let date;\n  let currentDate;\n  let expectedWeekday;\n  let yearToUse;\n\n  if (config._d) {\n    return config;\n  }\n\n  currentDate = currentDateArray(config);\n\n  // compute day of the year from weeks and weekdays\n  if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {\n    dayOfYearFromWeekInfo(config);\n  }\n\n  // if the day of the year is set, figure out what it is\n  if (config._dayOfYear != null) {\n    yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);\n\n    if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {\n      getParsingFlags(config)._overflowDayOfYear = true;\n    }\n\n    date = new Date(Date.UTC(yearToUse, 0, config._dayOfYear));\n    config._a[MONTH] = date.getUTCMonth();\n    config._a[DATE] = date.getUTCDate();\n  }\n\n  // Default to current date.\n  // * if no year, month, day of month are given, default to today\n  // * if day of month is given, default month and year\n  // * if month is given, default only year\n  // * if year is given, don't default anything\n  for (i = 0; i < 3 && config._a[i] == null; ++i) {\n    config._a[i] = input[i] = currentDate[i];\n  }\n\n  // Zero out whatever was not defaulted, including time\n  for (; i < 7; i++) {\n    config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];\n  }\n\n  // Check for 24:00:00.000\n  if (config._a[HOUR] === 24 &&\n    config._a[MINUTE] === 0 &&\n    config._a[SECOND] === 0 &&\n    config._a[MILLISECOND] === 0) {\n    config._nextDay = true;\n    config._a[HOUR] = 0;\n  }\n\n  config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);\n  expectedWeekday = config._useUTC ? config._d.getUTCDay() : config._d.getDay();\n\n  // Apply timezone offset from input. The actual utcOffset can be changed\n  // with parseZone.\n  if (config._tzm != null) {\n    config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);\n  }\n\n  if (config._nextDay) {\n    config._a[HOUR] = 24;\n  }\n\n  // check for mismatching day of week\n  if (config._w && typeof config._w.d !== 'undefined' && config._w.d !== expectedWeekday) {\n    getParsingFlags(config).weekdayMismatch = true;\n  }\n\n  return config;\n}\n\nfunction dayOfYearFromWeekInfo(config: DateParsingConfig): DateParsingConfig {\n  let w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;\n\n  w = config._w;\n  if (w.GG != null || w.W != null || w.E != null) {\n    dow = 1;\n    doy = 4;\n\n    // TODO: We need to take the current isoWeekYear, but that depends on\n    // how we interpret now (local, utc, fixed offset). So create\n    // a now version of current config (take local/utc/offset flags, and\n    // create now).\n    weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(new Date(), 1, 4).year);\n    week = defaults(w.W, 1);\n    weekday = defaults(w.E, 1);\n    if (weekday < 1 || weekday > 7) {\n      weekdayOverflow = true;\n    }\n  } else {\n    dow = config._locale._week.dow;\n    doy = config._locale._week.doy;\n\n    const curWeek = weekOfYear(new Date(), dow, doy);\n\n    weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);\n\n    // Default to current week.\n    week = defaults(w.w, curWeek.week);\n\n    if (w.d != null) {\n      // weekday -- low day numbers are considered next week\n      weekday = w.d;\n      if (weekday < 0 || weekday > 6) {\n        weekdayOverflow = true;\n      }\n    } else if (w.e != null) {\n      // local weekday -- counting starts from begining of week\n      weekday = w.e + dow;\n      if (w.e < 0 || w.e > 6) {\n        weekdayOverflow = true;\n      }\n    } else {\n      // default to begining of week\n      weekday = dow;\n    }\n  }\n  if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {\n    getParsingFlags(config)._overflowWeeks = true;\n  } else if (weekdayOverflow != null) {\n    getParsingFlags(config)._overflowWeekday = true;\n  } else {\n    temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);\n    config._a[YEAR] = temp.year;\n    config._dayOfYear = temp.dayOfYear;\n  }\n\n  return config;\n}\n"]}

package/esm2020/datepicker/chronos/create/from-object.mjs

@@ -0,0 +1,17 @@
+import { normalizeObjectUnits } from '../units/aliases';
+import { configFromArray } from './from-array';
+import { isObject, isString } from '../utils/type-checks';
+export function configFromObject(config) {
+    if (config._d) {
+        return config;
+    }
+    const input = config._i;
+    if (isObject(input)) {
+        const i = normalizeObjectUnits(input);
+        config._a = [i.year, i.month, i.day, i.hours, i.minutes, i.seconds, i.milliseconds]
+            // todo: obsolete -> remove it
+            .map(obj => isString(obj) ? parseInt(obj, 10) : obj);
+    }
+    return configFromArray(config);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/datepicker/chronos/create/from-string-and-array.mjs

@@ -0,0 +1,38 @@
+import { createInvalid, isValid } from './valid';
+import { getParsingFlags } from './parsing-flags';
+import { configFromStringAndFormat } from './from-string-and-format';
+// date from string and array of format strings
+export function configFromStringAndArray(config) {
+    let tempConfig;
+    let bestMoment;
+    let scoreToBeat;
+    let currentScore;
+    if (!config._f || config._f.length === 0) {
+        getParsingFlags(config).invalidFormat = true;
+        return createInvalid(config);
+    }
+    let i;
+    for (i = 0; i < config._f.length; i++) {
+        currentScore = 0;
+        tempConfig = Object.assign({}, config);
+        if (config._useUTC != null) {
+            tempConfig._useUTC = config._useUTC;
+        }
+        tempConfig._f = config._f[i];
+        configFromStringAndFormat(tempConfig);
+        if (!isValid(tempConfig)) {
+            continue;
+        }
+        // if there is any input that was not parsed add a penalty for that format
+        currentScore += getParsingFlags(tempConfig).charsLeftOver;
+        // or tokens
+        currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
+        getParsingFlags(tempConfig).score = currentScore;
+        if (scoreToBeat == null || currentScore < scoreToBeat) {
+            scoreToBeat = currentScore;
+            bestMoment = tempConfig;
+        }
+    }
+    return Object.assign(config, bestMoment || tempConfig);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnJvbS1zdHJpbmctYW5kLWFycmF5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbWlzLWNvbXBvbmVudHMvZGF0ZXBpY2tlci9jaHJvbm9zL2NyZWF0ZS9mcm9tLXN0cmluZy1hbmQtYXJyYXkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLGFBQWEsRUFBRSxPQUFPLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFDakQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQ2xELE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRXJFLCtDQUErQztBQUMvQyxNQUFNLFVBQVUsd0JBQXdCLENBQUMsTUFBeUI7SUFDaEUsSUFBSSxVQUFVLENBQUM7SUFDZixJQUFJLFVBQVUsQ0FBQztJQUNmLElBQUksV0FBVyxDQUFDO0lBQ2hCLElBQUksWUFBWSxDQUFDO0lBRWpCLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRSxJQUFJLE1BQU0sQ0FBQyxFQUFFLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRTtRQUN4QyxlQUFlLENBQUMsTUFBTSxDQUFDLENBQUMsYUFBYSxHQUFHLElBQUksQ0FBQztRQUU3QyxPQUFPLGFBQWEsQ0FBQyxNQUFNLENBQUMsQ0FBQztLQUM5QjtJQUVELElBQUksQ0FBQyxDQUFDO0lBQ04sS0FBSyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxNQUFNLENBQUMsRUFBRSxDQUFDLE1BQU0sRUFBRSxDQUFDLEVBQUUsRUFBRTtRQUNyQyxZQUFZLEdBQUcsQ0FBQyxDQUFDO1FBQ2pCLFVBQVUsR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDLEVBQUUsRUFBRSxNQUFNLENBQUMsQ0FBQztRQUN2QyxJQUFJLE1BQU0sQ0FBQyxPQUFPLElBQUksSUFBSSxFQUFFO1lBQzFCLFVBQVUsQ0FBQyxPQUFPLEdBQUcsTUFBTSxDQUFDLE9BQU8sQ0FBQztTQUNyQztRQUNELFVBQVUsQ0FBQyxFQUFFLEdBQUcsTUFBTSxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUM3Qix5QkFBeUIsQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUV0QyxJQUFJLENBQUMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxFQUFFO1lBQ3hCLFNBQVM7U0FDVjtRQUVELDBFQUEwRTtRQUMxRSxZQUFZLElBQUksZUFBZSxDQUFDLFVBQVUsQ0FBQyxDQUFDLGFBQWEsQ0FBQztRQUUxRCxZQUFZO1FBQ1osWUFBWSxJQUFJLGVBQWUsQ0FBQyxVQUFVLENBQUMsQ0FBQyxZQUFZLENBQUMsTUFBTSxHQUFHLEVBQUUsQ0FBQztRQUVyRSxlQUFlLENBQUMsVUFBVSxDQUFDLENBQUMsS0FBSyxHQUFHLFlBQVksQ0FBQztRQUVqRCxJQUFJLFdBQVcsSUFBSSxJQUFJLElBQUksWUFBWSxHQUFHLFdBQVcsRUFBRTtZQUNyRCxXQUFXLEdBQUcsWUFBWSxDQUFDO1lBQzNCLFVBQVUsR0FBRyxVQUFVLENBQUM7U0FDekI7S0FDRjtJQUVELE9BQU8sTUFBTSxDQUFDLE1BQU0sQ0FBQyxNQUFNLEVBQUUsVUFBVSxJQUFJLFVBQVUsQ0FBQyxDQUFDO0FBQ3pELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEYXRlUGFyc2luZ0NvbmZpZyB9IGZyb20gJy4vcGFyc2luZy50eXBlcyc7XG5pbXBvcnQgeyBjcmVhdGVJbnZhbGlkLCBpc1ZhbGlkIH0gZnJvbSAnLi92YWxpZCc7XG5pbXBvcnQgeyBnZXRQYXJzaW5nRmxhZ3MgfSBmcm9tICcuL3BhcnNpbmctZmxhZ3MnO1xuaW1wb3J0IHsgY29uZmlnRnJvbVN0cmluZ0FuZEZvcm1hdCB9IGZyb20gJy4vZnJvbS1zdHJpbmctYW5kLWZvcm1hdCc7XG5cbi8vIGRhdGUgZnJvbSBzdHJpbmcgYW5kIGFycmF5IG9mIGZvcm1hdCBzdHJpbmdzXG5leHBvcnQgZnVuY3Rpb24gY29uZmlnRnJvbVN0cmluZ0FuZEFycmF5KGNvbmZpZzogRGF0ZVBhcnNpbmdDb25maWcpOiBEYXRlUGFyc2luZ0NvbmZpZyB7XG4gIGxldCB0ZW1wQ29uZmlnO1xuICBsZXQgYmVzdE1vbWVudDtcbiAgbGV0IHNjb3JlVG9CZWF0O1xuICBsZXQgY3VycmVudFNjb3JlO1xuXG4gIGlmICghY29uZmlnLl9mIHx8IGNvbmZpZy5fZi5sZW5ndGggPT09IDApIHtcbiAgICBnZXRQYXJzaW5nRmxhZ3MoY29uZmlnKS5pbnZhbGlkRm9ybWF0ID0gdHJ1ZTtcblxuICAgIHJldHVybiBjcmVhdGVJbnZhbGlkKGNvbmZpZyk7XG4gIH1cblxuICBsZXQgaTtcbiAgZm9yIChpID0gMDsgaSA8IGNvbmZpZy5fZi5sZW5ndGg7IGkrKykge1xuICAgIGN1cnJlbnRTY29yZSA9IDA7XG4gICAgdGVtcENvbmZpZyA9IE9iamVjdC5hc3NpZ24oe30sIGNvbmZpZyk7XG4gICAgaWYgKGNvbmZpZy5fdXNlVVRDICE9IG51bGwpIHtcbiAgICAgIHRlbXBDb25maWcuX3VzZVVUQyA9IGNvbmZpZy5fdXNlVVRDO1xuICAgIH1cbiAgICB0ZW1wQ29uZmlnLl9mID0gY29uZmlnLl9mW2ldO1xuICAgIGNvbmZpZ0Zyb21TdHJpbmdBbmRGb3JtYXQodGVtcENvbmZpZyk7XG5cbiAgICBpZiAoIWlzVmFsaWQodGVtcENvbmZpZykpIHtcbiAgICAgIGNvbnRpbnVlO1xuICAgIH1cblxuICAgIC8vIGlmIHRoZXJlIGlzIGFueSBpbnB1dCB0aGF0IHdhcyBub3QgcGFyc2VkIGFkZCBhIHBlbmFsdHkgZm9yIHRoYXQgZm9ybWF0XG4gICAgY3VycmVudFNjb3JlICs9IGdldFBhcnNpbmdGbGFncyh0ZW1wQ29uZmlnKS5jaGFyc0xlZnRPdmVyO1xuXG4gICAgLy8gb3IgdG9rZW5zXG4gICAgY3VycmVudFNjb3JlICs9IGdldFBhcnNpbmdGbGFncyh0ZW1wQ29uZmlnKS51bnVzZWRUb2tlbnMubGVuZ3RoICogMTA7XG5cbiAgICBnZXRQYXJzaW5nRmxhZ3ModGVtcENvbmZpZykuc2NvcmUgPSBjdXJyZW50U2NvcmU7XG5cbiAgICBpZiAoc2NvcmVUb0JlYXQgPT0gbnVsbCB8fCBjdXJyZW50U2NvcmUgPCBzY29yZVRvQmVhdCkge1xuICAgICAgc2NvcmVUb0JlYXQgPSBjdXJyZW50U2NvcmU7XG4gICAgICBiZXN0TW9tZW50ID0gdGVtcENvbmZpZztcbiAgICB9XG4gIH1cblxuICByZXR1cm4gT2JqZWN0LmFzc2lnbihjb25maWcsIGJlc3RNb21lbnQgfHwgdGVtcENvbmZpZyk7XG59XG4iXX0=

package/esm2020/datepicker/chronos/create/from-string-and-format.mjs

@@ -0,0 +1,106 @@
+import { configFromISO, configFromRFC2822 } from './from-string';
+import { expandFormat } from '../format';
+import { formattingTokens, formatTokenFunctions } from '../format/format';
+import { isArray } from '../utils/type-checks';
+import { getParseRegexForToken } from '../parse/regex';
+import { addTimeToArrayFromToken } from '../parse/token';
+import { HOUR } from '../units/constants';
+import { configFromArray } from './from-array';
+import { getParsingFlags } from './parsing-flags';
+import { checkOverflow } from './check-overflow';
+// constant that refers to the ISO standard
+// hooks.ISO_8601 = function () {};
+export const ISO_8601 = 'ISO_8601';
+// constant that refers to the RFC 2822 form
+// hooks.RFC_2822 = function () {};
+export const RFC_2822 = 'RFC_2822';
+// date from string and format string
+export function configFromStringAndFormat(config) {
+    // TODO: Move this to another part of the creation flow to prevent circular deps
+    if (config._f === ISO_8601) {
+        return configFromISO(config);
+    }
+    if (config._f === RFC_2822) {
+        return configFromRFC2822(config);
+    }
+    config._a = [];
+    getParsingFlags(config).empty = true;
+    if (isArray(config._f) || (!config._i && config._i !== 0)) {
+        return config;
+    }
+    // This array is used to make a Date, either with `new Date` or `Date.UTC`
+    let input = config._i.toString();
+    let totalParsedInputLength = 0;
+    const inputLength = input.length;
+    const tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
+    let i;
+    let token;
+    let parsedInput;
+    let skipped;
+    for (i = 0; i < tokens.length; i++) {
+        token = tokens[i];
+        parsedInput = (input.match(getParseRegexForToken(token, config._locale)) || [])[0];
+        if (parsedInput) {
+            skipped = input.substr(0, input.indexOf(parsedInput));
+            if (skipped.length > 0) {
+                getParsingFlags(config).unusedInput.push(skipped);
+            }
+            input = input.slice(input.indexOf(parsedInput) + parsedInput.length);
+            totalParsedInputLength += parsedInput.length;
+        }
+        // don't parse if it's not a known token
+        if (formatTokenFunctions[token]) {
+            if (parsedInput) {
+                getParsingFlags(config).empty = false;
+            }
+            else {
+                getParsingFlags(config).unusedTokens.push(token);
+            }
+            addTimeToArrayFromToken(token, parsedInput, config);
+        }
+        else if (config._strict && !parsedInput) {
+            getParsingFlags(config).unusedTokens.push(token);
+        }
+    }
+    // add remaining unparsed input length to the string
+    getParsingFlags(config).charsLeftOver = inputLength - totalParsedInputLength;
+    if (input.length > 0) {
+        getParsingFlags(config).unusedInput.push(input);
+    }
+    // clear _12h flag if hour is <= 12
+    if (config._a[HOUR] <= 12 &&
+        getParsingFlags(config).bigHour === true &&
+        config._a[HOUR] > 0) {
+        getParsingFlags(config).bigHour = void 0;
+    }
+    getParsingFlags(config).parsedDateParts = config._a.slice(0);
+    getParsingFlags(config).meridiem = config._meridiem;
+    // handle meridiem
+    config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
+    configFromArray(config);
+    return checkOverflow(config);
+}
+function meridiemFixWrap(locale, _hour, meridiem) {
+    let hour = _hour;
+    if (meridiem == null) {
+        // nothing to do
+        return hour;
+    }
+    if (locale.meridiemHour != null) {
+        return locale.meridiemHour(hour, meridiem);
+    }
+    if (locale.isPM == null) {
+        // this is not supposed to happen
+        return hour;
+    }
+    // Fallback
+    const isPm = locale.isPM(meridiem);
+    if (isPm && hour < 12) {
+        hour += 12;
+    }
+    if (!isPm && hour === 12) {
+        hour = 0;
+    }
+    return hour;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"from-string-and-format.js","sourceRoot":"","sources":["../../../../../../projects/mis-components/datepicker/chronos/create/from-string-and-format.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC1E,OAAO,EAAE,OAAO,EAAY,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGjD,2CAA2C;AAC3C,mCAAmC;AACnC,MAAM,CAAC,MAAM,QAAQ,GAAG,UAAU,CAAC;AAEnC,4CAA4C;AAC5C,mCAAmC;AACnC,MAAM,CAAC,MAAM,QAAQ,GAAG,UAAU,CAAC;AAEnC,qCAAqC;AACrC,MAAM,UAAU,yBAAyB,CAAC,MAAyB;IACjE,gFAAgF;IAChF,IAAI,MAAM,CAAC,EAAE,KAAK,QAAQ,EAAE;QAC1B,OAAO,aAAa,CAAC,MAAM,CAAC,CAAC;KAC9B;IACD,IAAI,MAAM,CAAC,EAAE,KAAK,QAAQ,EAAE;QAC1B,OAAO,iBAAiB,CAAC,MAAM,CAAC,CAAC;KAClC;IACD,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC;IACf,eAAe,CAAC,MAAM,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC;IAErC,IAAI,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE;QACzD,OAAO,MAAM,CAAC;KACf;IAED,0EAA0E;IAE1E,IAAI,KAAK,GAAG,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC;IACjC,IAAI,sBAAsB,GAAG,CAAC,CAAC;IAC/B,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,CAAC;IACjC,MAAM,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC;IAErF,IAAI,CAAC,CAAC;IACN,IAAI,KAAK,CAAC;IACV,IAAI,WAAW,CAAC;IAChB,IAAI,OAAO,CAAC;IACZ,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QAClC,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QAClB,WAAW,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,qBAAqB,CAAC,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACnF,IAAI,WAAW,EAAE;YACf,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC;YACtD,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;gBACtB,eAAe,CAAC,MAAM,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;aACnD;YACD,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;YACrE,sBAAsB,IAAI,WAAW,CAAC,MAAM,CAAC;SAC9C;QACD,wCAAwC;QACxC,IAAI,oBAAoB,CAAC,KAAK,CAAC,EAAE;YAC/B,IAAI,WAAW,EAAE;gBACf,eAAe,CAAC,MAAM,CAAC,CAAC,KAAK,GAAG,KAAK,CAAC;aACvC;iBAAM;gBACL,eAAe,CAAC,MAAM,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;aAClD;YAED,uBAAuB,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;SACrD;aAAM,IAAI,MAAM,CAAC,OAAO,IAAI,CAAC,WAAW,EAAE;YACzC,eAAe,CAAC,MAAM,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SAClD;KACF;IAED,oDAAoD;IACpD,eAAe,CAAC,MAAM,CAAC,CAAC,aAAa,GAAG,WAAW,GAAG,sBAAsB,CAAC;IAC7E,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;QACpB,eAAe,CAAC,MAAM,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;KACjD;IAED,mCAAmC;IACnC,IAAI,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE;QACvB,eAAe,CAAC,MAAM,CAAC,CAAC,OAAO,KAAK,IAAI;QACxC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;QACrB,eAAe,CAAC,MAAM,CAAC,CAAC,OAAO,GAAG,KAAK,CAAC,CAAC;KAC1C;IAED,eAAe,CAAC,MAAM,CAAC,CAAC,eAAe,GAAG,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC7D,eAAe,CAAC,MAAM,CAAC,CAAC,QAAQ,GAAG,MAAM,CAAC,SAAS,CAAC;IACpD,kBAAkB;IAClB,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,eAAe,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC;IAErF,eAAe,CAAC,MAAM,CAAC,CAAC;IAExB,OAAO,aAAa,CAAC,MAAM,CAAC,CAAC;AAC/B,CAAC;AAGD,SAAS,eAAe,CAAC,MAAc,EAAE,KAAa,EAAE,QAAgB;IACtE,IAAI,IAAI,GAAG,KAAK,CAAC;IAEjB,IAAI,QAAQ,IAAI,IAAI,EAAE;QACpB,gBAAgB;QAChB,OAAO,IAAI,CAAC;KACb;IAED,IAAI,MAAM,CAAC,YAAY,IAAI,IAAI,EAAE;QAC/B,OAAO,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;KAC5C;IAED,IAAI,MAAM,CAAC,IAAI,IAAI,IAAI,EAAE;QACvB,iCAAiC;QACjC,OAAO,IAAI,CAAC;KACb;IACD,WAAW;IACX,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACnC,IAAI,IAAI,IAAI,IAAI,GAAG,EAAE,EAAE;QACrB,IAAI,IAAI,EAAE,CAAC;KACZ;IAED,IAAI,CAAC,IAAI,IAAI,IAAI,KAAK,EAAE,EAAE;QACxB,IAAI,GAAG,CAAC,CAAC;KACV;IAED,OAAO,IAAI,CAAC;AACd,CAAC","sourcesContent":["import { DateParsingConfig } from './parsing.types';\nimport { configFromISO, configFromRFC2822 } from './from-string';\nimport { expandFormat } from '../format';\nimport { formattingTokens, formatTokenFunctions } from '../format/format';\nimport { isArray, isString } from '../utils/type-checks';\nimport { getParseRegexForToken } from '../parse/regex';\nimport { addTimeToArrayFromToken } from '../parse/token';\nimport { HOUR } from '../units/constants';\nimport { configFromArray } from './from-array';\nimport { getParsingFlags } from './parsing-flags';\nimport { checkOverflow } from './check-overflow';\nimport { Locale } from '../locale/locale.class';\n\n// constant that refers to the ISO standard\n// hooks.ISO_8601 = function () {};\nexport const ISO_8601 = 'ISO_8601';\n\n// constant that refers to the RFC 2822 form\n// hooks.RFC_2822 = function () {};\nexport const RFC_2822 = 'RFC_2822';\n\n// date from string and format string\nexport function configFromStringAndFormat(config: DateParsingConfig): DateParsingConfig {\n  // TODO: Move this to another part of the creation flow to prevent circular deps\n  if (config._f === ISO_8601) {\n    return configFromISO(config);\n  }\n  if (config._f === RFC_2822) {\n    return configFromRFC2822(config);\n  }\n  config._a = [];\n  getParsingFlags(config).empty = true;\n\n  if (isArray(config._f) || (!config._i && config._i !== 0)) {\n    return config;\n  }\n\n  // This array is used to make a Date, either with `new Date` or `Date.UTC`\n\n  let input = config._i.toString();\n  let totalParsedInputLength = 0;\n  const inputLength = input.length;\n  const tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];\n\n  let i;\n  let token;\n  let parsedInput;\n  let skipped;\n  for (i = 0; i < tokens.length; i++) {\n    token = tokens[i];\n    parsedInput = (input.match(getParseRegexForToken(token, config._locale)) || [])[0];\n    if (parsedInput) {\n      skipped = input.substr(0, input.indexOf(parsedInput));\n      if (skipped.length > 0) {\n        getParsingFlags(config).unusedInput.push(skipped);\n      }\n      input = input.slice(input.indexOf(parsedInput) + parsedInput.length);\n      totalParsedInputLength += parsedInput.length;\n    }\n    // don't parse if it's not a known token\n    if (formatTokenFunctions[token]) {\n      if (parsedInput) {\n        getParsingFlags(config).empty = false;\n      } else {\n        getParsingFlags(config).unusedTokens.push(token);\n      }\n\n      addTimeToArrayFromToken(token, parsedInput, config);\n    } else if (config._strict && !parsedInput) {\n      getParsingFlags(config).unusedTokens.push(token);\n    }\n  }\n\n  // add remaining unparsed input length to the string\n  getParsingFlags(config).charsLeftOver = inputLength - totalParsedInputLength;\n  if (input.length > 0) {\n    getParsingFlags(config).unusedInput.push(input);\n  }\n\n  // clear _12h flag if hour is <= 12\n  if (config._a[HOUR] <= 12 &&\n    getParsingFlags(config).bigHour === true &&\n    config._a[HOUR] > 0) {\n    getParsingFlags(config).bigHour = void 0;\n  }\n\n  getParsingFlags(config).parsedDateParts = config._a.slice(0);\n  getParsingFlags(config).meridiem = config._meridiem;\n  // handle meridiem\n  config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);\n\n  configFromArray(config);\n\n  return checkOverflow(config);\n}\n\n\nfunction meridiemFixWrap(locale: Locale, _hour: number, meridiem: string): number {\n  let hour = _hour;\n\n  if (meridiem == null) {\n    // nothing to do\n    return hour;\n  }\n\n  if (locale.meridiemHour != null) {\n    return locale.meridiemHour(hour, meridiem);\n  }\n\n  if (locale.isPM == null) {\n    // this is not supposed to happen\n    return hour;\n  }\n  // Fallback\n  const isPm = locale.isPM(meridiem);\n  if (isPm && hour < 12) {\n    hour += 12;\n  }\n\n  if (!isPm && hour === 12) {\n    hour = 0;\n  }\n\n  return hour;\n}\n"]}

package/esm2020/datepicker/chronos/create/from-string.mjs

@@ -0,0 +1,227 @@
+// tslint:disable-next-line
+import { defaultLocaleMonthsShort, defaultLocaleWeekdaysShort } from '../locale/locale.class';
+import { isString } from '../utils/type-checks';
+import { configFromStringAndFormat } from './from-string-and-format';
+import { createUTCDate } from './date-from-array';
+import { createInvalid, markInvalid } from './valid';
+import { getParsingFlags } from './parsing-flags';
+// iso 8601 regex
+// 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)
+// tslint:disable-next-line
+const extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;
+// tslint:disable-next-line
+const basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;
+const tzRegex = /Z|[+-]\d\d(?::?\d\d)?/;
+const isoDates = [
+    ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/, true],
+    ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/, true],
+    ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/, true],
+    ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
+    ['YYYY-DDD', /\d{4}-\d{3}/, true],
+    ['YYYY-MM', /\d{4}-\d\d/, false],
+    ['YYYYYYMMDD', /[+-]\d{10}/, true],
+    ['YYYYMMDD', /\d{8}/, true],
+    // YYYYMM is NOT allowed by the standard
+    ['GGGG[W]WWE', /\d{4}W\d{3}/, true],
+    ['GGGG[W]WW', /\d{4}W\d{2}/, false],
+    ['YYYYDDD', /\d{7}/, true]
+];
+// iso time formats and regexes
+const isoTimes = [
+    ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
+    ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
+    ['HH:mm:ss', /\d\d:\d\d:\d\d/],
+    ['HH:mm', /\d\d:\d\d/],
+    ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
+    ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
+    ['HHmmss', /\d\d\d\d\d\d/],
+    ['HHmm', /\d\d\d\d/],
+    ['HH', /\d\d/]
+];
+const aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
+const obsOffsets = {
+    UT: 0,
+    GMT: 0,
+    EDT: -4 * 60,
+    EST: -5 * 60,
+    CDT: -5 * 60,
+    CST: -6 * 60,
+    MDT: -6 * 60,
+    MST: -7 * 60,
+    PDT: -7 * 60,
+    PST: -8 * 60
+};
+// RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
+// tslint:disable-next-line
+const rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/;
+// date from iso format
+export function configFromISO(config) {
+    if (!isString(config._i)) {
+        return config;
+    }
+    const input = config._i;
+    const match = extendedIsoRegex.exec(input) || basicIsoRegex.exec(input);
+    let allowTime;
+    let dateFormat;
+    let timeFormat;
+    let tzFormat;
+    if (!match) {
+        config._isValid = false;
+        return config;
+    }
+    // getParsingFlags(config).iso = true;
+    let i;
+    let l;
+    for (i = 0, l = isoDates.length; i < l; i++) {
+        if (isoDates[i][1].exec(match[1])) {
+            dateFormat = isoDates[i][0];
+            allowTime = isoDates[i][2] !== false;
+            break;
+        }
+    }
+    if (dateFormat == null) {
+        config._isValid = false;
+        return config;
+    }
+    if (match[3]) {
+        for (i = 0, l = isoTimes.length; i < l; i++) {
+            if (isoTimes[i][1].exec(match[3])) {
+                // match[2] should be 'T' or space
+                timeFormat = (match[2] || ' ') + isoTimes[i][0];
+                break;
+            }
+        }
+        if (timeFormat == null) {
+            config._isValid = false;
+            return config;
+        }
+    }
+    if (!allowTime && timeFormat != null) {
+        config._isValid = false;
+        return config;
+    }
+    if (match[4]) {
+        if (tzRegex.exec(match[4])) {
+            tzFormat = 'Z';
+        }
+        else {
+            config._isValid = false;
+            return config;
+        }
+    }
+    config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
+    return configFromStringAndFormat(config);
+}
+// tslint:disable-next-line
+function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {
+    const result = [
+        untruncateYear(yearStr),
+        defaultLocaleMonthsShort.indexOf(monthStr),
+        parseInt(dayStr, 10),
+        parseInt(hourStr, 10),
+        parseInt(minuteStr, 10)
+    ];
+    if (secondStr) {
+        result.push(parseInt(secondStr, 10));
+    }
+    return result;
+}
+function untruncateYear(yearStr) {
+    const year = parseInt(yearStr, 10);
+    return year <= 49 ? year + 2000 : year;
+}
+function preprocessRFC2822(str) {
+    // Remove comments and folding whitespace and replace multiple-spaces with a single space
+    return str
+        .replace(/\([^)]*\)|[\n\t]/g, ' ')
+        .replace(/(\s\s+)/g, ' ').trim();
+}
+function checkWeekday(weekdayStr, parsedInput, config) {
+    if (weekdayStr) {
+        // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.
+        const weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr);
+        const weekdayActual = new Date(parsedInput[0], parsedInput[1], parsedInput[2]).getDay();
+        if (weekdayProvided !== weekdayActual) {
+            getParsingFlags(config).weekdayMismatch = true;
+            config._isValid = false;
+            return false;
+        }
+    }
+    return true;
+}
+function calculateOffset(obsOffset, militaryOffset, numOffset) {
+    if (obsOffset) {
+        return obsOffsets[obsOffset];
+    }
+    else if (militaryOffset) {
+        // the only allowed military tz is Z
+        return 0;
+    }
+    else {
+        const hm = parseInt(numOffset, 10);
+        const m = hm % 100;
+        const h = (hm - m) / 100;
+        return h * 60 + m;
+    }
+}
+// date and time from ref 2822 format
+export function configFromRFC2822(config) {
+    if (!isString(config._i)) {
+        return config;
+    }
+    const match = rfc2822.exec(preprocessRFC2822(config._i));
+    if (!match) {
+        return markInvalid(config);
+    }
+    const parsedArray = extractFromRFC2822Strings(match[4], match[3], match[2], match[5], match[6], match[7]);
+    if (!checkWeekday(match[1], parsedArray, config)) {
+        return config;
+    }
+    config._a = parsedArray;
+    config._tzm = calculateOffset(match[8], match[9], match[10]);
+    config._d = createUTCDate.apply(null, config._a);
+    config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
+    getParsingFlags(config).rfc2822 = true;
+    return config;
+}
+// date from iso format or fallback
+export function configFromString(config) {
+    if (!isString(config._i)) {
+        return config;
+    }
+    const matched = aspNetJsonRegex.exec(config._i);
+    if (matched !== null) {
+        config._d = new Date(+matched[1]);
+        return config;
+    }
+    // todo: update logic processing
+    // isISO -> configFromISO
+    // isRFC -> configFromRFC
+    configFromISO(config);
+    if (config._isValid === false) {
+        delete config._isValid;
+    }
+    else {
+        return config;
+    }
+    configFromRFC2822(config);
+    if (config._isValid === false) {
+        delete config._isValid;
+    }
+    else {
+        return config;
+    }
+    // Final attempt, use Input Fallback
+    // hooks.createFromInputFallback(config);
+    return createInvalid(config);
+}
+// hooks.createFromInputFallback = deprecate(
+//     'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +
+//     'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +
+//     'discouraged and will be removed in an upcoming major release. Please refer to ' +
+//     'http://momentjs.com/guides/#/warnings/js-date/ for more info.',
+//     function (config) {
+//         config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
+//     }
+// );
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"from-string.js","sourceRoot":"","sources":["../../../../../../projects/mis-components/datepicker/chronos/create/from-string.ts"],"names":[],"mappings":"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","sourcesContent":["// tslint:disable-next-line\nimport { defaultLocaleMonthsShort, defaultLocaleWeekdaysShort } from '../locale/locale.class';\nimport { DateArray } from '../types';\nimport { DateParsingConfig } from './parsing.types';\nimport { isString } from '../utils/type-checks';\nimport { configFromStringAndFormat } from './from-string-and-format';\nimport { createUTCDate } from './date-from-array';\nimport { createInvalid, markInvalid } from './valid';\nimport { getParsingFlags } from './parsing-flags';\n\n// iso 8601 regex\n// 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)\n// tslint:disable-next-line\nconst extendedIsoRegex = /^\\s*((?:[+-]\\d{6}|\\d{4})-(?:\\d\\d-\\d\\d|W\\d\\d-\\d|W\\d\\d|\\d\\d\\d|\\d\\d))(?:(T| )(\\d\\d(?::\\d\\d(?::\\d\\d(?:[.,]\\d+)?)?)?)([\\+\\-]\\d\\d(?::?\\d\\d)?|\\s*Z)?)?$/;\n// tslint:disable-next-line\nconst basicIsoRegex = /^\\s*((?:[+-]\\d{6}|\\d{4})(?:\\d\\d\\d\\d|W\\d\\d\\d|W\\d\\d|\\d\\d\\d|\\d\\d))(?:(T| )(\\d\\d(?:\\d\\d(?:\\d\\d(?:[.,]\\d+)?)?)?)([\\+\\-]\\d\\d(?::?\\d\\d)?|\\s*Z)?)?$/;\n\nconst tzRegex = /Z|[+-]\\d\\d(?::?\\d\\d)?/;\n\nconst isoDates: [string, RegExp, boolean][] = [\n  ['YYYYYY-MM-DD', /[+-]\\d{6}-\\d\\d-\\d\\d/, true],\n  ['YYYY-MM-DD', /\\d{4}-\\d\\d-\\d\\d/, true],\n  ['GGGG-[W]WW-E', /\\d{4}-W\\d\\d-\\d/, true],\n  ['GGGG-[W]WW', /\\d{4}-W\\d\\d/, false],\n  ['YYYY-DDD', /\\d{4}-\\d{3}/, true],\n  ['YYYY-MM', /\\d{4}-\\d\\d/, false],\n  ['YYYYYYMMDD', /[+-]\\d{10}/, true],\n  ['YYYYMMDD', /\\d{8}/, true],\n  // YYYYMM is NOT allowed by the standard\n  ['GGGG[W]WWE', /\\d{4}W\\d{3}/, true],\n  ['GGGG[W]WW', /\\d{4}W\\d{2}/, false],\n  ['YYYYDDD', /\\d{7}/, true]\n];\n\n// iso time formats and regexes\nconst isoTimes: [string, RegExp][] = [\n  ['HH:mm:ss.SSSS', /\\d\\d:\\d\\d:\\d\\d\\.\\d+/],\n  ['HH:mm:ss,SSSS', /\\d\\d:\\d\\d:\\d\\d,\\d+/],\n  ['HH:mm:ss', /\\d\\d:\\d\\d:\\d\\d/],\n  ['HH:mm', /\\d\\d:\\d\\d/],\n  ['HHmmss.SSSS', /\\d\\d\\d\\d\\d\\d\\.\\d+/],\n  ['HHmmss,SSSS', /\\d\\d\\d\\d\\d\\d,\\d+/],\n  ['HHmmss', /\\d\\d\\d\\d\\d\\d/],\n  ['HHmm', /\\d\\d\\d\\d/],\n  ['HH', /\\d\\d/]\n];\n\nconst aspNetJsonRegex = /^\\/?Date\\((\\-?\\d+)/i;\n\nconst obsOffsets: { [key: string]: number } = {\n  UT: 0,\n  GMT: 0,\n  EDT: -4 * 60,\n  EST: -5 * 60,\n  CDT: -5 * 60,\n  CST: -6 * 60,\n  MDT: -6 * 60,\n  MST: -7 * 60,\n  PDT: -7 * 60,\n  PST: -8 * 60\n};\n\n// RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3\n// tslint:disable-next-line\nconst rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\\s)?(\\d{1,2})\\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\\s(\\d{2,4})\\s(\\d\\d):(\\d\\d)(?::(\\d\\d))?\\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\\d{4}))$/;\n\n// date from iso format\nexport function configFromISO(config: DateParsingConfig): DateParsingConfig {\n  if (!isString(config._i)) {\n    return config;\n  }\n\n  const input = config._i;\n  const match = extendedIsoRegex.exec(input) || basicIsoRegex.exec(input);\n\n\n  let allowTime;\n  let dateFormat;\n  let timeFormat;\n  let tzFormat;\n\n  if (!match) {\n    config._isValid = false;\n\n    return config;\n  }\n\n  // getParsingFlags(config).iso = true;\n  let i;\n  let l;\n  for (i = 0, l = isoDates.length; i < l; i++) {\n    if (isoDates[i][1].exec(match[1])) {\n      dateFormat = isoDates[i][0];\n      allowTime = isoDates[i][2] !== false;\n      break;\n    }\n  }\n\n  if (dateFormat == null) {\n    config._isValid = false;\n\n    return config;\n  }\n\n  if (match[3]) {\n    for (i = 0, l = isoTimes.length; i < l; i++) {\n      if (isoTimes[i][1].exec(match[3])) {\n        // match[2] should be 'T' or space\n        timeFormat = (match[2] || ' ') + isoTimes[i][0];\n        break;\n      }\n    }\n\n    if (timeFormat == null) {\n      config._isValid = false;\n\n      return config;\n    }\n\n  }\n  if (!allowTime && timeFormat != null) {\n    config._isValid = false;\n\n    return config;\n  }\n\n  if (match[4]) {\n    if (tzRegex.exec(match[4])) {\n      tzFormat = 'Z';\n    } else {\n      config._isValid = false;\n\n      return config;\n    }\n  }\n\n  config._f = dateFormat + (timeFormat || '') + (tzFormat || '');\n\n  return configFromStringAndFormat(config);\n}\n\n// tslint:disable-next-line\nfunction extractFromRFC2822Strings(yearStr: string, monthStr: string, dayStr: string, hourStr: string, minuteStr: string, secondStr: string): DateArray {\n  const result = [\n    untruncateYear(yearStr),\n    defaultLocaleMonthsShort.indexOf(monthStr),\n    parseInt(dayStr, 10),\n    parseInt(hourStr, 10),\n    parseInt(minuteStr, 10)\n  ];\n\n  if (secondStr) {\n    result.push(parseInt(secondStr, 10));\n  }\n\n  return result;\n}\n\nfunction untruncateYear(yearStr: string): number {\n  const year = parseInt(yearStr, 10);\n\n  return year <= 49 ? year + 2000 : year;\n}\n\nfunction preprocessRFC2822(str: string): string {\n  // Remove comments and folding whitespace and replace multiple-spaces with a single space\n  return str\n    .replace(/\\([^)]*\\)|[\\n\\t]/g, ' ')\n    .replace(/(\\s\\s+)/g, ' ').trim();\n}\n\nfunction checkWeekday(weekdayStr: string, parsedInput: DateArray, config: DateParsingConfig): boolean {\n  if (weekdayStr) {\n    // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.\n    const weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr);\n    const weekdayActual = new Date(parsedInput[0], parsedInput[1], parsedInput[2]).getDay();\n    if (weekdayProvided !== weekdayActual) {\n      getParsingFlags(config).weekdayMismatch = true;\n      config._isValid = false;\n\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction calculateOffset(obsOffset: string, militaryOffset: string, numOffset: string) {\n  if (obsOffset) {\n    return obsOffsets[obsOffset];\n  } else if (militaryOffset) {\n    // the only allowed military tz is Z\n    return 0;\n  } else {\n    const hm = parseInt(numOffset, 10);\n    const m = hm % 100;\n    const h = (hm - m) / 100;\n\n    return h * 60 + m;\n  }\n}\n\n// date and time from ref 2822 format\nexport function configFromRFC2822(config: DateParsingConfig): DateParsingConfig {\n  if (!isString(config._i)) {\n    return config;\n  }\n\n  const match = rfc2822.exec(preprocessRFC2822(config._i));\n\n  if (!match) {\n    return markInvalid(config);\n  }\n\n  const parsedArray = extractFromRFC2822Strings(match[4], match[3], match[2], match[5], match[6], match[7]);\n  if (!checkWeekday(match[1], parsedArray, config)) {\n    return config;\n  }\n\n  config._a = parsedArray;\n  config._tzm = calculateOffset(match[8], match[9], match[10]);\n\n  config._d = createUTCDate.apply(null, config._a);\n  config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);\n\n  getParsingFlags(config).rfc2822 = true;\n\n  return config;\n}\n\n// date from iso format or fallback\nexport function configFromString(config: DateParsingConfig): DateParsingConfig {\n  if (!isString(config._i)) {\n    return config;\n  }\n\n  const matched = aspNetJsonRegex.exec(config._i);\n\n  if (matched !== null) {\n    config._d = new Date(+matched[1]);\n\n    return config;\n  }\n\n  // todo: update logic processing\n  // isISO -> configFromISO\n  // isRFC -> configFromRFC\n\n  configFromISO(config);\n  if (config._isValid === false) {\n    delete config._isValid;\n  } else {\n    return config;\n  }\n\n  configFromRFC2822(config);\n  if (config._isValid === false) {\n    delete config._isValid;\n  } else {\n    return config;\n  }\n\n  // Final attempt, use Input Fallback\n  // hooks.createFromInputFallback(config);\n  return createInvalid(config);\n}\n\n// hooks.createFromInputFallback = deprecate(\n//     'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +\n//     'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +\n//     'discouraged and will be removed in an upcoming major release. Please refer to ' +\n//     'http://momentjs.com/guides/#/warnings/js-date/ for more info.',\n//     function (config) {\n//         config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));\n//     }\n// );\n"]}

package/esm2020/datepicker/chronos/create/local.mjs

@@ -0,0 +1,16 @@
+import { createLocalOrUTC } from './from-anything';
+import { isDate } from '../utils/type-checks';
+export function parseDate(input, format, localeKey, strict, isUTC) {
+    if (isDate(input)) {
+        return input;
+    }
+    const config = createLocalOrUTC(input, format, localeKey, strict, isUTC);
+    return config._d;
+}
+export function utcAsLocal(date) {
+    if (!(date instanceof Date)) {
+        return null;
+    }
+    return new Date(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.getUTCMilliseconds());
+}
+//# sourceMappingURL=data:application/json;base64,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