@mis-wis/common 0.1.6 → 0.1.7

package/esm2020/lib/components/datepicker/chronos/locale/locale.defaults.mjs

@@ -0,0 +1,40 @@
+import { defaultDayOfMonthOrdinalParse, defaultLocaleMonths, defaultLocaleMonthsShort, defaultLocaleWeekdays, defaultLocaleWeekdaysMin, defaultLocaleWeekdaysShort, defaultLongDateFormat, defaultOrdinal } from './locale.class';
+import { defaultCalendar } from './calendar';
+export const defaultInvalidDate = 'Invalid date';
+export const defaultLocaleWeek = {
+    dow: 0,
+    doy: 6 // The week that contains Jan 1st is the first week of the year.
+};
+export const defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
+export const defaultRelativeTime = {
+    future: 'in %s',
+    past: '%s ago',
+    s: 'a few seconds',
+    ss: '%d seconds',
+    m: 'a minute',
+    mm: '%d minutes',
+    h: 'an hour',
+    hh: '%d hours',
+    d: 'a day',
+    dd: '%d days',
+    M: 'a month',
+    MM: '%d months',
+    y: 'a year',
+    yy: '%d years'
+};
+export const baseConfig = {
+    calendar: defaultCalendar,
+    longDateFormat: defaultLongDateFormat,
+    invalidDate: defaultInvalidDate,
+    ordinal: defaultOrdinal,
+    dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
+    relativeTime: defaultRelativeTime,
+    months: defaultLocaleMonths,
+    monthsShort: defaultLocaleMonthsShort,
+    week: defaultLocaleWeek,
+    weekdays: defaultLocaleWeekdays,
+    weekdaysMin: defaultLocaleWeekdaysMin,
+    weekdaysShort: defaultLocaleWeekdaysShort,
+    meridiemParse: defaultLocaleMeridiemParse
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/datepicker/chronos/locale/locales.mjs

@@ -0,0 +1,229 @@
+// internal storage for locale config files
+import { Locale } from './locale.class';
+import { baseConfig } from './locale.defaults';
+import { hasOwnProp, isArray, isObject, isString, isUndefined, toInt } from '../utils/type-checks';
+import { compareArrays } from '../utils/compare-arrays';
+import { initWeek } from '../units/week';
+import { initWeekYear } from '../units/week-year';
+import { initYear } from '../units/year';
+import { initTimezone } from '../units/timezone';
+import { initTimestamp } from '../units/timestamp';
+import { initSecond } from '../units/second';
+import { initQuarter } from '../units/quarter';
+import { initOffset } from '../units/offset';
+import { initMinute } from '../units/minute';
+import { initMillisecond } from '../units/millisecond';
+import { initMonth } from '../units/month';
+import { initHour } from '../units/hour';
+import { initDayOfYear } from '../units/day-of-year';
+import { initDayOfWeek } from '../units/day-of-week';
+import { initDayOfMonth } from '../units/day-of-month';
+const locales = {};
+const localeFamilies = {};
+let globalLocale;
+function normalizeLocale(key) {
+    return key ? key.toLowerCase().replace('_', '-') : key;
+}
+// pick the locale from the array
+// try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
+// substring from most specific to least,
+// but move to the next array item if it's a more specific variant than the current root
+function chooseLocale(names) {
+    let next;
+    let locale;
+    let i = 0;
+    while (i < names.length) {
+        const split = normalizeLocale(names[i]).split('-');
+        let j = split.length;
+        next = normalizeLocale(names[i + 1]);
+        next = next ? next.split('-') : null;
+        while (j > 0) {
+            locale = loadLocale(split.slice(0, j).join('-'));
+            if (locale) {
+                return locale;
+            }
+            if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
+                // the next array item is better than a shallower substring of this one
+                break;
+            }
+            j--;
+        }
+        i++;
+    }
+    return null;
+}
+export function mergeConfigs(parentConfig, childConfig) {
+    const res = Object.assign({}, parentConfig);
+    for (const childProp in childConfig) {
+        if (!hasOwnProp(childConfig, childProp)) {
+            continue;
+        }
+        if (isObject(parentConfig[childProp]) && isObject(childConfig[childProp])) {
+            res[childProp] = {};
+            Object.assign(res[childProp], parentConfig[childProp]);
+            Object.assign(res[childProp], childConfig[childProp]);
+        }
+        else if (childConfig[childProp] != null) {
+            res[childProp] = childConfig[childProp];
+        }
+        else {
+            delete res[childProp];
+        }
+    }
+    for (const parentProp in parentConfig) {
+        if (hasOwnProp(parentConfig, parentProp) &&
+            !hasOwnProp(childConfig, parentProp) &&
+            isObject(parentConfig[parentProp])) {
+            // make sure changes to properties don't modify parent config
+            res[parentProp] = Object.assign({}, res[parentProp]);
+        }
+    }
+    return res;
+}
+function loadLocale(name) {
+    // no way!
+    /* var oldLocale = null;
+     // TODO: Find a better way to register and load all the locales in Node
+     if (!locales[name] && (typeof module !== 'undefined') &&
+       module && module.exports) {
+       try {
+         oldLocale = globalLocale._abbr;
+         var aliasedRequire = require;
+         aliasedRequire('./locale/' + name);
+         getSetGlobalLocale(oldLocale);
+       } catch (e) {}
+     }*/
+    if (!locales[name]) {
+        // tslint:disable-next-line
+        console.error(`Khronos locale error: please load locale "${name}" before using it`);
+        // throw new Error(`Khronos locale error: please load locale "${name}" before using it`);
+    }
+    return locales[name];
+}
+// This function will load locale and then set the global locale.  If
+// no arguments are passed in, it will simply return the current global
+// locale key.
+export function getSetGlobalLocale(key, values) {
+    let data;
+    if (key) {
+        if (isUndefined(values)) {
+            data = getLocale(key);
+        }
+        else if (isString(key)) {
+            data = defineLocale(key, values);
+        }
+        if (data) {
+            globalLocale = data;
+        }
+    }
+    return globalLocale && globalLocale._abbr;
+}
+export function defineLocale(name, config) {
+    if (config === null) {
+        // useful for testing
+        delete locales[name];
+        globalLocale = getLocale('en');
+        return null;
+    }
+    if (!config) {
+        return;
+    }
+    let parentConfig = baseConfig;
+    config.abbr = name;
+    if (config.parentLocale != null) {
+        if (locales[config.parentLocale] != null) {
+            parentConfig = locales[config.parentLocale]._config;
+        }
+        else {
+            if (!localeFamilies[config.parentLocale]) {
+                localeFamilies[config.parentLocale] = [];
+            }
+            localeFamilies[config.parentLocale].push({ name, config });
+            return null;
+        }
+    }
+    locales[name] = new Locale(mergeConfigs(parentConfig, config));
+    if (localeFamilies[name]) {
+        localeFamilies[name].forEach(function (x) {
+            defineLocale(x.name, x.config);
+        });
+    }
+    // backwards compat for now: also set the locale
+    // make sure we set the locale AFTER all child locales have been
+    // created, so we won't end up with the child locale set.
+    getSetGlobalLocale(name);
+    return locales[name];
+}
+export function updateLocale(name, config) {
+    let _config = config;
+    if (_config != null) {
+        let parentConfig = baseConfig;
+        // MERGE
+        const tmpLocale = loadLocale(name);
+        if (tmpLocale != null) {
+            parentConfig = tmpLocale._config;
+        }
+        _config = mergeConfigs(parentConfig, _config);
+        const locale = new Locale(_config);
+        locale.parentLocale = locales[name];
+        locales[name] = locale;
+        // backwards compat for now: also set the locale
+        getSetGlobalLocale(name);
+    }
+    else {
+        // pass null for config to unupdate, useful for tests
+        if (locales[name] != null) {
+            if (locales[name].parentLocale != null) {
+                locales[name] = locales[name].parentLocale;
+            }
+            else if (locales[name] != null) {
+                delete locales[name];
+            }
+        }
+    }
+    return locales[name];
+}
+// returns locale data
+export function getLocale(key) {
+    setDefaultLocale();
+    if (!key) {
+        return globalLocale;
+    }
+    // let locale;
+    const _key = isArray(key) ? key : [key];
+    return chooseLocale(_key);
+}
+export function listLocales() {
+    return Object.keys(locales);
+}
+function setDefaultLocale() {
+    if (locales[`en`]) {
+        return undefined;
+    }
+    getSetGlobalLocale('en', {
+        dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
+        ordinal(num) {
+            const b = num % 10;
+            const output = toInt((num % 100) / 10) === 1
+                ? 'th'
+                : b === 1 ? 'st' : b === 2 ? 'nd' : b === 3 ? 'rd' : 'th';
+            return num + output;
+        }
+    });
+    initWeek();
+    initWeekYear();
+    initYear();
+    initTimezone();
+    initTimestamp();
+    initSecond();
+    initQuarter();
+    initOffset();
+    initMonth();
+    initMinute();
+    initMillisecond();
+    initHour();
+    initDayOfYear();
+    initDayOfWeek();
+    initDayOfMonth();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"locales.js","sourceRoot":"","sources":["../../../../../../../../libraries/wis-common/src/lib/components/datepicker/chronos/locale/locales.ts"],"names":[],"mappings":"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","sourcesContent":["// internal storage for locale config files\nimport { Locale, LocaleData } from './locale.class';\nimport { baseConfig } from './locale.defaults';\nimport { hasOwnProp, isArray, isObject, isString, isUndefined, toInt } from '../utils/type-checks';\nimport { compareArrays } from '../utils/compare-arrays';\n\nimport { initWeek } from '../units/week';\nimport { initWeekYear } from '../units/week-year';\nimport { initYear } from '../units/year';\nimport { initTimezone } from '../units/timezone';\nimport { initTimestamp } from '../units/timestamp';\nimport { initSecond } from '../units/second';\nimport { initQuarter } from '../units/quarter';\nimport { initOffset } from '../units/offset';\nimport { initMinute } from '../units/minute';\nimport { initMillisecond } from '../units/millisecond';\nimport { initMonth } from '../units/month';\nimport { initHour } from '../units/hour';\nimport { initDayOfYear } from '../units/day-of-year';\nimport { initDayOfWeek } from '../units/day-of-week';\nimport { initDayOfMonth } from '../units/day-of-month';\n\nconst locales: { [key: string]: Locale } = {};\nconst localeFamilies: { [key: string]: {name: string; config: LocaleData}[] } = {};\nlet globalLocale: Locale;\n\nfunction normalizeLocale(key: string): string {\n  return key ? key.toLowerCase().replace('_', '-') : key;\n}\n\n// pick the locale from the array\n// try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each\n// substring from most specific to least,\n// but move to the next array item if it's a more specific variant than the current root\nfunction chooseLocale(names: string[]): Locale {\n  let next;\n  let locale;\n  let i = 0;\n\n  while (i < names.length) {\n    const split = normalizeLocale(names[i]).split('-');\n    let j = split.length;\n    next = normalizeLocale(names[i + 1]);\n    next = next ? next.split('-') : null;\n    while (j > 0) {\n      locale = loadLocale(split.slice(0, j).join('-'));\n      if (locale) {\n        return locale;\n      }\n      if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {\n        // the next array item is better than a shallower substring of this one\n        break;\n      }\n      j--;\n    }\n    i++;\n  }\n\n  return null;\n}\n\nexport function mergeConfigs(parentConfig: LocaleData,\n                             childConfig: LocaleData) {\n  const res: LocaleData = Object.assign({}, parentConfig);\n\n  for (const childProp in childConfig) {\n    if (!hasOwnProp(childConfig, childProp)) {\n      continue;\n    }\n\n    if (isObject(parentConfig[childProp]) && isObject(childConfig[childProp])) {\n      res[childProp as any] = {};\n      Object.assign(res[childProp], parentConfig[childProp]);\n      Object.assign(res[childProp], childConfig[childProp]);\n    } else if (childConfig[childProp] != null) {\n      res[childProp as any] = childConfig[childProp];\n    } else {\n      delete res[childProp as any];\n    }\n  }\n  for (const parentProp in parentConfig) {\n    if (\n      hasOwnProp(parentConfig, parentProp) &&\n      !hasOwnProp(childConfig, parentProp) &&\n      isObject(parentConfig[parentProp as keyof LocaleData])\n    ) {\n      // make sure changes to properties don't modify parent config\n      res[parentProp as any] = Object.assign({}, res[parentProp as keyof LocaleData]);\n    }\n  }\n\n  return res;\n}\n\n\nfunction loadLocale(name: string): Locale {\n  // no way!\n  /* var oldLocale = null;\n   // TODO: Find a better way to register and load all the locales in Node\n   if (!locales[name] && (typeof module !== 'undefined') &&\n     module && module.exports) {\n     try {\n       oldLocale = globalLocale._abbr;\n       var aliasedRequire = require;\n       aliasedRequire('./locale/' + name);\n       getSetGlobalLocale(oldLocale);\n     } catch (e) {}\n   }*/\n  if (!locales[name]) {\n    // tslint:disable-next-line\n    console.error(`Khronos locale error: please load locale \"${name}\" before using it`);\n    // throw new Error(`Khronos locale error: please load locale \"${name}\" before using it`);\n  }\n\n  return locales[name];\n}\n\n// This function will load locale and then set the global locale.  If\n// no arguments are passed in, it will simply return the current global\n// locale key.\nexport function getSetGlobalLocale(key?: string | string[], values?: LocaleData): string {\n  let data: Locale;\n\n  if (key) {\n    if (isUndefined(values)) {\n      data = getLocale(key);\n    } else if (isString(key)) {\n      data = defineLocale(key, values);\n    }\n\n    if (data) {\n      globalLocale = data;\n    }\n  }\n\n  return globalLocale && globalLocale._abbr;\n}\n\nexport function defineLocale(name: string, config?: LocaleData): Locale {\n  if (config === null) {\n    // useful for testing\n    delete locales[name];\n    globalLocale = getLocale('en');\n\n    return null;\n  }\n\n  if (!config) {\n    return;\n  }\n\n  let parentConfig = baseConfig;\n  config.abbr = name;\n  if (config.parentLocale != null) {\n    if (locales[config.parentLocale] != null) {\n      parentConfig = locales[config.parentLocale]._config;\n    } else {\n      if (!localeFamilies[config.parentLocale]) {\n        localeFamilies[config.parentLocale] = [];\n      }\n      localeFamilies[config.parentLocale].push({ name, config });\n\n      return null;\n    }\n  }\n\n  locales[name] = new Locale(mergeConfigs(parentConfig, config));\n\n  if (localeFamilies[name]) {\n    localeFamilies[name].forEach(function (x) {\n      defineLocale(x.name, x.config);\n    });\n  }\n\n  // backwards compat for now: also set the locale\n  // make sure we set the locale AFTER all child locales have been\n  // created, so we won't end up with the child locale set.\n  getSetGlobalLocale(name);\n\n\n  return locales[name];\n}\n\nexport function updateLocale(name: string, config?: LocaleData): Locale {\n  let _config = config;\n\n  if (_config != null) {\n    let parentConfig = baseConfig;\n    // MERGE\n    const tmpLocale = loadLocale(name);\n    if (tmpLocale != null) {\n      parentConfig = tmpLocale._config;\n    }\n    _config = mergeConfigs(parentConfig, _config);\n    const locale = new Locale(_config);\n    locale.parentLocale = locales[name];\n    locales[name] = locale;\n\n    // backwards compat for now: also set the locale\n    getSetGlobalLocale(name);\n  } else {\n    // pass null for config to unupdate, useful for tests\n    if (locales[name] != null) {\n      if (locales[name].parentLocale != null) {\n        locales[name] = locales[name].parentLocale;\n      } else if (locales[name] != null) {\n        delete locales[name];\n      }\n    }\n  }\n\n  return locales[name];\n}\n\n// returns locale data\nexport function getLocale(key?: string | string[]): Locale {\n  setDefaultLocale();\n\n  if (!key) {\n    return globalLocale;\n  }\n  // let locale;\n  const _key = isArray(key) ? key : [key];\n\n  return chooseLocale(_key);\n}\n\nexport function listLocales(): string[] {\n  return Object.keys(locales);\n}\n\nfunction setDefaultLocale(): void {\n  if (locales[`en`]) {\n\n    return undefined;\n  }\n\n  getSetGlobalLocale('en', {\n    dayOfMonthOrdinalParse: /\\d{1,2}(th|st|nd|rd)/,\n    ordinal(num: number): string {\n      const b = num % 10;\n      const output =\n        toInt((num % 100) / 10) === 1\n          ? 'th'\n          : b === 1 ? 'st' : b === 2 ? 'nd' : b === 3 ? 'rd' : 'th';\n\n      return num + output;\n    }\n  });\n\n  initWeek();\n  initWeekYear();\n  initYear();\n  initTimezone();\n  initTimestamp();\n  initSecond();\n  initQuarter();\n  initOffset();\n  initMonth();\n  initMinute();\n  initMillisecond();\n  initHour();\n  initDayOfYear();\n  initDayOfWeek();\n  initDayOfMonth();\n}\n"]}

package/esm2020/lib/components/datepicker/chronos/moment/add-subtract.mjs

@@ -0,0 +1,35 @@
+import { createDuration } from '../duration/create';
+import { absRound } from '../utils/abs-round';
+import { getDate, getMonth, getTime } from '../utils/date-getters';
+import { setDate, setMonth, setTime } from '../utils/date-setters';
+import { cloneDate } from '../create/clone';
+export function add(date, val, period, isUTC) {
+    const dur = createDuration(val, period);
+    return addSubtract(date, dur, 1, isUTC);
+}
+export function subtract(date, val, period, isUTC) {
+    const dur = createDuration(val, period);
+    return addSubtract(date, dur, -1, isUTC);
+}
+export function addSubtract(date, duration, isAdding, isUTC) {
+    const milliseconds = duration._milliseconds;
+    const days = absRound(duration._days);
+    const months = absRound(duration._months);
+    // todo: add timezones support
+    // const _updateOffset = updateOffset == null ? true : updateOffset;
+    if (months) {
+        setMonth(date, getMonth(date, isUTC) + months * isAdding, isUTC);
+    }
+    if (days) {
+        setDate(date, getDate(date, isUTC) + days * isAdding, isUTC);
+    }
+    if (milliseconds) {
+        setTime(date, getTime(date) + milliseconds * isAdding);
+    }
+    return cloneDate(date);
+    // todo: add timezones support
+    // if (_updateOffset) {
+    //   hooks.updateOffset(date, days || months);
+    // }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/datepicker/chronos/moment/calendar.mjs

@@ -0,0 +1,41 @@
+import { diff } from './diff';
+import { cloneWithOffset } from '../units/offset';
+import { isFunction, isString } from '../utils/type-checks';
+import { cloneDate } from '../create/clone';
+import { startOf } from '../utils/start-end-of';
+import { formatDate } from '../format';
+import { getLocale } from '../locale/locales';
+export function getCalendarFormat(date, now, config) {
+    const _diff = diff(date, now, 'day', true, config);
+    switch (true) {
+        case _diff < -6: return 'sameElse';
+        case _diff < -1: return 'lastWeek';
+        case _diff < 0: return 'lastDay';
+        case _diff < 1: return 'sameDay';
+        case _diff < 2: return 'nextDay';
+        case _diff < 7: return 'nextWeek';
+        default: return 'sameElse';
+    }
+}
+export function calendar(date, time, formats, locale = getLocale(), config = {}) {
+    // We want to compare the start of today, vs this.
+    // Getting start-of-today depends on whether we're local/utc/offset or not.
+    const now = time;
+    const sod = startOf(cloneWithOffset(now, date, config), 'day', config._isUTC);
+    const format = getCalendarFormat(date, sod, { _isUTC: true, _offset: 0 }) || 'sameElse';
+    let output;
+    if (formats) {
+        const _format = formats[format];
+        if (isString(_format)) {
+            output = _format;
+        }
+        if (isFunction(_format)) {
+            output = _format.call(null, date, now);
+        }
+    }
+    if (!output) {
+        output = locale.calendar(format, date, cloneDate(now));
+    }
+    return formatDate(date, output, config._locale._abbr, config._isUTC, config._offset);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/datepicker/chronos/moment/diff.mjs

@@ -0,0 +1,70 @@
+import { cloneWithOffset, getDateOffset, getUTCOffset } from '../units/offset';
+import { absFloor } from '../utils';
+import { isDateValid, isNumber } from '../utils/type-checks';
+import { getFullYear, getMonth } from '../utils/date-getters';
+import { add } from './add-subtract';
+import { cloneDate } from '../create/clone';
+export function diff(date, input, units, asFloat, config = {}) {
+    if (!isDateValid(date)) {
+        return NaN;
+    }
+    const that = cloneWithOffset(input, date, config);
+    if (!isDateValid(that)) {
+        return NaN;
+    }
+    const zoneOffset = (getDateOffset(input) - getDateOffset(date)) * 6e4;
+    const zoneDelta = isNumber(config._zoneDelta)
+        ? config._zoneDelta * 6e4
+        : (getUTCOffset(input, config) - getUTCOffset(date, config)) * 6e4;
+    let output;
+    switch (units) {
+        case 'year':
+            output = monthDiff(date, that) / 12;
+            break;
+        case 'month':
+            output = monthDiff(date, that);
+            break;
+        case 'quarter':
+            output = monthDiff(date, that) / 3;
+            break;
+        case 'seconds':
+            output = (date.valueOf() - that.valueOf()) / 1e3;
+            break; // 1000
+        case 'minutes':
+            output = (date.valueOf() - that.valueOf()) / 6e4;
+            break; // 1000 * 60
+        case 'hours':
+            output = (date.valueOf() - that.valueOf()) / 36e5;
+            break; // 1000 * 60 * 60
+        case 'day':
+            output = (date.valueOf() - that.valueOf() - (zoneDelta === 0 ? zoneOffset : zoneDelta)) / 864e5;
+            break; // 1000 * 60 * 60 * 24, negate dst
+        case 'week':
+            output = (date.valueOf() - that.valueOf() - zoneDelta) / 6048e5;
+            break; // 1000 * 60 * 60 * 24 * 7, negate dst
+        default:
+            output = date.valueOf() - that.valueOf();
+    }
+    return asFloat ? output : absFloor(output);
+}
+function monthDiff(a, b) {
+    // difference in months
+    const wholeMonthDiff = ((getFullYear(b) - getFullYear(a)) * 12) + (getMonth(b) - getMonth(a));
+    // b is in (anchor - 1 month, anchor + 1 month)
+    const anchor = add(cloneDate(a), wholeMonthDiff, 'month');
+    let anchor2;
+    let adjust;
+    if (b.valueOf() - anchor.valueOf() < 0) {
+        anchor2 = add(cloneDate(a), wholeMonthDiff - 1, 'month');
+        // linear across the month
+        adjust = (b.valueOf() - anchor.valueOf()) / (anchor.valueOf() - anchor2.valueOf());
+    }
+    else {
+        anchor2 = add(cloneDate(a), wholeMonthDiff + 1, 'month');
+        // linear across the month
+        adjust = (b.valueOf() - anchor.valueOf()) / (anchor2.valueOf() - anchor.valueOf());
+    }
+    // check for negative zero, return zero if negative zero
+    return -(wholeMonthDiff + adjust) || 0;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"diff.js","sourceRoot":"","sources":["../../../../../../../../libraries/wis-common/src/lib/components/datepicker/chronos/moment/diff.ts"],"names":[],"mappings":"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","sourcesContent":["import { cloneWithOffset, getDateOffset, getUTCOffset } from '../units/offset';\nimport { DateParsingConfig } from '../create/parsing.types';\nimport { UnitOfTime } from '../types';\nimport { absFloor } from '../utils';\nimport { isDateValid, isNumber } from '../utils/type-checks';\nimport { getFullYear, getMonth } from '../utils/date-getters';\nimport { add } from './add-subtract';\nimport { cloneDate } from '../create/clone';\n\nexport function diff(date: Date, input: Date,\n                     units: UnitOfTime, asFloat: boolean,\n                     config: DateParsingConfig = {}\n                     ): number {\n  if (!isDateValid(date)) {\n    return NaN;\n  }\n\n  const that = cloneWithOffset(input, date, config);\n\n  if (!isDateValid(that)) {\n    return NaN;\n  }\n\n  const zoneOffset = (getDateOffset(input) - getDateOffset(date)) * 6e4;\n  const zoneDelta = isNumber(config._zoneDelta)\n    ? config._zoneDelta * 6e4\n    : (getUTCOffset(input, config) - getUTCOffset(date, config)) * 6e4;\n\n  let output;\n  switch (units) {\n    case 'year':\n      output = monthDiff(date, that) / 12;\n      break;\n    case 'month':\n      output = monthDiff(date, that);\n      break;\n    case 'quarter':\n      output = monthDiff(date, that) / 3;\n      break;\n    case 'seconds':\n      output = (date.valueOf() - that.valueOf()) / 1e3;\n      break; // 1000\n    case 'minutes':\n      output = (date.valueOf() - that.valueOf()) / 6e4;\n      break; // 1000 * 60\n    case 'hours':\n      output = (date.valueOf() - that.valueOf()) / 36e5;\n      break; // 1000 * 60 * 60\n    case 'day':\n      output = (date.valueOf() - that.valueOf() - (zoneDelta === 0 ? zoneOffset : zoneDelta)) / 864e5;\n      break; // 1000 * 60 * 60 * 24, negate dst\n    case 'week':\n      output = (date.valueOf() - that.valueOf() - zoneDelta) / 6048e5;\n      break; // 1000 * 60 * 60 * 24 * 7, negate dst\n    default:\n      output = date.valueOf() - that.valueOf();\n  }\n\n  return asFloat ? output : absFloor(output);\n}\n\nfunction monthDiff(a: Date, b: Date): number {\n  // difference in months\n  const wholeMonthDiff = ((getFullYear(b) - getFullYear(a)) * 12) + (getMonth(b) - getMonth(a));\n// b is in (anchor - 1 month, anchor + 1 month)\n  const anchor = add(cloneDate(a), wholeMonthDiff, 'month');\n  let anchor2;\n  let adjust;\n\n\n  if (b.valueOf() - anchor.valueOf() < 0) {\n    anchor2 = add(cloneDate(a), wholeMonthDiff - 1, 'month');\n    // linear across the month\n    adjust = (b.valueOf() - anchor.valueOf()) / (anchor.valueOf() - anchor2.valueOf());\n  } else {\n    anchor2 = add(cloneDate(a), wholeMonthDiff + 1, 'month');\n    // linear across the month\n    adjust = (b.valueOf() - anchor.valueOf()) / (anchor2.valueOf() - anchor.valueOf());\n  }\n\n  // check for negative zero, return zero if negative zero\n  return -(wholeMonthDiff + adjust) || 0;\n}\n"]}

package/esm2020/lib/components/datepicker/chronos/moment/min-max.mjs

@@ -0,0 +1,38 @@
+// Pick a moment m from moments so that m[fn](other) is true for all
+// other. This relies on the function fn to be transitive.
+//
+// moments should either be an array of moment objects or an array, whose
+// first element is an array of moment objects.
+import { isArray, isDateValid } from '../utils/type-checks';
+import { isAfter, isBefore } from '../utils/date-compare';
+function pickBy(fn, dates) {
+    let _dates;
+    const _firstArg = dates[0];
+    if (isArray(_firstArg) && dates.length === 1) {
+        _dates = _firstArg;
+    }
+    else if (isArray(dates)) {
+        _dates = dates;
+    }
+    if (!_dates || !_dates.length) {
+        return new Date();
+    }
+    let res = _dates[0];
+    for (let i = 1; i < _dates.length; ++i) {
+        // if (!moments[i].isValid() || moments[i][fn](res)) {
+        if (!isDateValid(_dates[i]) || fn.call(null, _dates[i], res)) {
+            res = _dates[i];
+        }
+    }
+    return res;
+}
+// TODO: Use [].sort instead?
+export function min(...args) {
+    // const args = [].slice.call(arguments, 0);
+    return pickBy(isBefore, args);
+}
+export function max(...args) {
+    // const args = [].slice.call(arguments, 0);
+    return pickBy(isAfter, args);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/datepicker/chronos/parse/regex.mjs

@@ -0,0 +1,49 @@
+import { hasOwnProp, isFunction } from '../utils/type-checks';
+export const match1 = /\d/; //       0 - 9
+export const match2 = /\d\d/; //      00 - 99
+export const match3 = /\d{3}/; //     000 - 999
+export const match4 = /\d{4}/; //    0000 - 9999
+export const match6 = /[+-]?\d{6}/; // -999999 - 999999
+export const match1to2 = /\d\d?/; //       0 - 99
+export const match3to4 = /\d\d\d\d?/; //     999 - 9999
+export const match5to6 = /\d\d\d\d\d\d?/; //   99999 - 999999
+export const match1to3 = /\d{1,3}/; //       0 - 999
+export const match1to4 = /\d{1,4}/; //       0 - 9999
+export const match1to6 = /[+-]?\d{1,6}/; // -999999 - 999999
+export const matchUnsigned = /\d+/; //       0 - inf
+export const matchSigned = /[+-]?\d+/; //    -inf - inf
+export const matchOffset = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
+export const matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z
+export const matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
+// any word (or two) characters or numbers including two/three word month in arabic.
+// includes scottish gaelic two word and hyphenated months
+// tslint:disable-next-line
+export const matchWord = /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i;
+const regexes = {};
+export function addRegexToken(token, regex, strictRegex) {
+    if (isFunction(regex)) {
+        regexes[token] = regex;
+        return;
+    }
+    regexes[token] = function (isStrict, locale) {
+        return (isStrict && strictRegex) ? strictRegex : regex;
+    };
+}
+export function getParseRegexForToken(token, locale) {
+    const _strict = false;
+    if (!hasOwnProp(regexes, token)) {
+        return new RegExp(unescapeFormat(token));
+    }
+    return regexes[token](_strict, locale);
+}
+// Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
+function unescapeFormat(str) {
+    // tslint:disable-next-line
+    return regexEscape(str
+        .replace('\\', '')
+        .replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, (matched, p1, p2, p3, p4) => p1 || p2 || p3 || p4));
+}
+export function regexEscape(str) {
+    return str.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/datepicker/chronos/parse/token.mjs

@@ -0,0 +1,32 @@
+// tslint:disable:max-line-length
+import { hasOwnProp, isArray, isFunction, isNumber, isString, toInt } from '../utils/type-checks';
+const tokens = {};
+export function addParseToken(token, callback) {
+    const _token = isString(token) ? [token] : token;
+    let func = callback;
+    if (isNumber(callback)) {
+        func = function (input, array, config) {
+            array[callback] = toInt(input);
+            return config;
+        };
+    }
+    if (isArray(_token) && isFunction(func)) {
+        let i;
+        for (i = 0; i < _token.length; i++) {
+            tokens[_token[i]] = func;
+        }
+    }
+}
+export function addWeekParseToken(token, callback) {
+    addParseToken(token, function (input, array, config, _token) {
+        config._w = config._w || {};
+        return callback(input, config._w, config, _token);
+    });
+}
+export function addTimeToArrayFromToken(token, input, config) {
+    if (input != null && hasOwnProp(tokens, token)) {
+        tokens[token](input, config._a, config, token);
+    }
+    return config;
+}
+//# sourceMappingURL=data:application/json;base64,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