@nocobase/plugin-backup-restore 1.3.38-beta → 1.4.0-alpha

package/dist/node_modules/moment/src/lib/format/format.js

@@ -0,0 +1,104 @@
+import zeroFill from '../utils/zero-fill';
+import isFunction from '../utils/is-function';
+
+var formattingTokens =
+        /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,
+    localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,
+    formatFunctions = {},
+    formatTokenFunctions = {};
+
+export { formattingTokens, formatTokenFunctions };
+
+// token:    'M'
+// padded:   ['MM', 2]
+// ordinal:  'Mo'
+// callback: function () { this.month() + 1 }
+export function addFormatToken(token, padded, ordinal, callback) {
+    var func = callback;
+    if (typeof callback === 'string') {
+        func = function () {
+            return this[callback]();
+        };
+    }
+    if (token) {
+        formatTokenFunctions[token] = func;
+    }
+    if (padded) {
+        formatTokenFunctions[padded[0]] = function () {
+            return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
+        };
+    }
+    if (ordinal) {
+        formatTokenFunctions[ordinal] = function () {
+            return this.localeData().ordinal(
+                func.apply(this, arguments),
+                token
+            );
+        };
+    }
+}
+
+function removeFormattingTokens(input) {
+    if (input.match(/\[[\s\S]/)) {
+        return input.replace(/^\[|\]$/g, '');
+    }
+    return input.replace(/\\/g, '');
+}
+
+function makeFormatFunction(format) {
+    var array = format.match(formattingTokens),
+        i,
+        length;
+
+    for (i = 0, length = array.length; i < length; i++) {
+        if (formatTokenFunctions[array[i]]) {
+            array[i] = formatTokenFunctions[array[i]];
+        } else {
+            array[i] = removeFormattingTokens(array[i]);
+        }
+    }
+
+    return function (mom) {
+        var output = '',
+            i;
+        for (i = 0; i < length; i++) {
+            output += isFunction(array[i])
+                ? array[i].call(mom, format)
+                : array[i];
+        }
+        return output;
+    };
+}
+
+// format date using native date object
+export function formatMoment(m, format) {
+    if (!m.isValid()) {
+        return m.localeData().invalidDate();
+    }
+
+    format = expandFormat(format, m.localeData());
+    formatFunctions[format] =
+        formatFunctions[format] || makeFormatFunction(format);
+
+    return formatFunctions[format](m);
+}
+
+export function expandFormat(format, locale) {
+    var i = 5;
+
+    function replaceLongDateFormatTokens(input) {
+        return locale.longDateFormat(input) || input;
+    }
+
+    localFormattingTokens.lastIndex = 0;
+    while (i >= 0 && localFormattingTokens.test(format)) {
+        format = format.replace(
+            localFormattingTokens,
+            replaceLongDateFormatTokens
+        );
+        localFormattingTokens.lastIndex = 0;
+        i -= 1;
+    }
+
+    return format;
+}

package/dist/node_modules/moment/src/lib/locale/base-config.js

@@ -0,0 +1,41 @@
+import { defaultCalendar } from './calendar';
+import { defaultLongDateFormat } from './formats';
+import { defaultInvalidDate } from './invalid';
+import { defaultOrdinal, defaultDayOfMonthOrdinalParse } from './ordinal';
+import { defaultRelativeTime } from './relative';
+
+// months
+import { defaultLocaleMonths, defaultLocaleMonthsShort } from '../units/month';
+
+// week
+import { defaultLocaleWeek } from '../units/week';
+
+// weekdays
+import {
+    defaultLocaleWeekdays,
+    defaultLocaleWeekdaysMin,
+    defaultLocaleWeekdaysShort,
+} from '../units/day-of-week';
+
+// meridiem
+import { defaultLocaleMeridiemParse } from '../units/hour';
+
+export var 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,
+};

package/dist/node_modules/moment/src/lib/locale/calendar.js

@@ -0,0 +1,15 @@
+export var defaultCalendar = {
+    sameDay: '[Today at] LT',
+    nextDay: '[Tomorrow at] LT',
+    nextWeek: 'dddd [at] LT',
+    lastDay: '[Yesterday at] LT',
+    lastWeek: '[Last] dddd [at] LT',
+    sameElse: 'L',
+};
+
+import isFunction from '../utils/is-function';
+
+export function calendar(key, mom, now) {
+    var output = this._calendar[key] || this._calendar['sameElse'];
+    return isFunction(output) ? output.call(mom, now) : output;
+}

package/dist/node_modules/moment/src/lib/locale/constructor.js

@@ -0,0 +1,5 @@
+export function Locale(config) {
+    if (config != null) {
+        this.set(config);
+    }
+}

package/dist/node_modules/moment/src/lib/locale/en.js

@@ -0,0 +1,39 @@
+import './prototype';
+import { getSetGlobalLocale } from './locales';
+import toInt from '../utils/to-int';
+
+getSetGlobalLocale('en', {
+    eras: [
+        {
+            since: '0001-01-01',
+            until: +Infinity,
+            offset: 1,
+            name: 'Anno Domini',
+            narrow: 'AD',
+            abbr: 'AD',
+        },
+        {
+            since: '0000-12-31',
+            until: -Infinity,
+            offset: 1,
+            name: 'Before Christ',
+            narrow: 'BC',
+            abbr: 'BC',
+        },
+    ],
+    dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
+    ordinal: function (number) {
+        var b = number % 10,
+            output =
+                toInt((number % 100) / 10) === 1
+                    ? 'th'
+                    : b === 1
+                    ? 'st'
+                    : b === 2
+                    ? 'nd'
+                    : b === 3
+                    ? 'rd'
+                    : 'th';
+        return number + output;
+    },
+});

package/dist/node_modules/moment/src/lib/locale/formats.js

@@ -0,0 +1,36 @@
+import { formattingTokens } from '../format/format';
+
+export var defaultLongDateFormat = {
+    LTS: 'h:mm:ss A',
+    LT: 'h:mm A',
+    L: 'MM/DD/YYYY',
+    LL: 'MMMM D, YYYY',
+    LLL: 'MMMM D, YYYY h:mm A',
+    LLLL: 'dddd, MMMM D, YYYY h:mm A',
+};
+
+export function longDateFormat(key) {
+    var format = this._longDateFormat[key],
+        formatUpper = this._longDateFormat[key.toUpperCase()];
+
+    if (format || !formatUpper) {
+        return format;
+    }
+
+    this._longDateFormat[key] = formatUpper
+        .match(formattingTokens)
+        .map(function (tok) {
+            if (
+                tok === 'MMMM' ||
+                tok === 'MM' ||
+                tok === 'DD' ||
+                tok === 'dddd'
+            ) {
+                return tok.slice(1);
+            }
+            return tok;
+        })
+        .join('');
+
+    return this._longDateFormat[key];
+}

package/dist/node_modules/moment/src/lib/locale/invalid.js

@@ -0,0 +1,5 @@
+export var defaultInvalidDate = 'Invalid date';
+
+export function invalidDate() {
+    return this._invalidDate;
+}

package/dist/node_modules/moment/src/lib/locale/lists.js

@@ -0,0 +1,93 @@
+import isNumber from '../utils/is-number';
+import { getLocale } from './locales';
+import { createUTC } from '../create/utc';
+
+function get(format, index, field, setter) {
+    var locale = getLocale(),
+        utc = createUTC().set(setter, index);
+    return locale[field](utc, format);
+}
+
+function listMonthsImpl(format, index, field) {
+    if (isNumber(format)) {
+        index = format;
+        format = undefined;
+    }
+
+    format = format || '';
+
+    if (index != null) {
+        return get(format, index, field, 'month');
+    }
+
+    var i,
+        out = [];
+    for (i = 0; i < 12; i++) {
+        out[i] = get(format, i, field, 'month');
+    }
+    return out;
+}
+
+// ()
+// (5)
+// (fmt, 5)
+// (fmt)
+// (true)
+// (true, 5)
+// (true, fmt, 5)
+// (true, fmt)
+function listWeekdaysImpl(localeSorted, format, index, field) {
+    if (typeof localeSorted === 'boolean') {
+        if (isNumber(format)) {
+            index = format;
+            format = undefined;
+        }
+
+        format = format || '';
+    } else {
+        format = localeSorted;
+        index = format;
+        localeSorted = false;
+
+        if (isNumber(format)) {
+            index = format;
+            format = undefined;
+        }
+
+        format = format || '';
+    }
+
+    var locale = getLocale(),
+        shift = localeSorted ? locale._week.dow : 0,
+        i,
+        out = [];
+
+    if (index != null) {
+        return get(format, (index + shift) % 7, field, 'day');
+    }
+
+    for (i = 0; i < 7; i++) {
+        out[i] = get(format, (i + shift) % 7, field, 'day');
+    }
+    return out;
+}
+
+export function listMonths(format, index) {
+    return listMonthsImpl(format, index, 'months');
+}
+
+export function listMonthsShort(format, index) {
+    return listMonthsImpl(format, index, 'monthsShort');
+}
+
+export function listWeekdays(localeSorted, format, index) {
+    return listWeekdaysImpl(localeSorted, format, index, 'weekdays');
+}
+
+export function listWeekdaysShort(localeSorted, format, index) {
+    return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');
+}
+
+export function listWeekdaysMin(localeSorted, format, index) {
+    return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');
+}

package/dist/node_modules/moment/src/lib/locale/locale.js

@@ -0,0 +1,45 @@
+// Side effect imports
+import './prototype';
+
+import {
+    getSetGlobalLocale,
+    defineLocale,
+    updateLocale,
+    getLocale,
+    listLocales,
+} from './locales';
+
+import {
+    listMonths,
+    listMonthsShort,
+    listWeekdays,
+    listWeekdaysShort,
+    listWeekdaysMin,
+} from './lists';
+
+export {
+    getSetGlobalLocale,
+    defineLocale,
+    updateLocale,
+    getLocale,
+    listLocales,
+    listMonths,
+    listMonthsShort,
+    listWeekdays,
+    listWeekdaysShort,
+    listWeekdaysMin,
+};
+
+import { deprecate } from '../utils/deprecate';
+import { hooks } from '../utils/hooks';
+
+hooks.lang = deprecate(
+    'moment.lang is deprecated. Use moment.locale instead.',
+    getSetGlobalLocale
+);
+hooks.langData = deprecate(
+    'moment.langData is deprecated. Use moment.localeData instead.',
+    getLocale
+);
+
+import './en';

package/dist/node_modules/moment/src/lib/locale/locales.js

@@ -0,0 +1,248 @@
+import isArray from '../utils/is-array';
+import isUndefined from '../utils/is-undefined';
+import { deprecateSimple } from '../utils/deprecate';
+import { mergeConfigs } from './set';
+import { Locale } from './constructor';
+import keys from '../utils/keys';
+
+import { baseConfig } from './base-config';
+
+// internal storage for locale config files
+var locales = {},
+    localeFamilies = {},
+    globalLocale;
+
+function commonPrefix(arr1, arr2) {
+    var i,
+        minl = Math.min(arr1.length, arr2.length);
+    for (i = 0; i < minl; i += 1) {
+        if (arr1[i] !== arr2[i]) {
+            return i;
+        }
+    }
+    return minl;
+}
+
+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) {
+    var i = 0,
+        j,
+        next,
+        locale,
+        split;
+
+    while (i < names.length) {
+        split = normalizeLocale(names[i]).split('-');
+        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 &&
+                commonPrefix(split, next) >= j - 1
+            ) {
+                //the next array item is better than a shallower substring of this one
+                break;
+            }
+            j--;
+        }
+        i++;
+    }
+    return globalLocale;
+}
+
+function isLocaleNameSane(name) {
+    // Prevent names that look like filesystem paths, i.e contain '/' or '\'
+    return name.match('^[^/\\\\]*$') != null;
+}
+
+function loadLocale(name) {
+    var oldLocale = null,
+        aliasedRequire;
+    // TODO: Find a better way to register and load all the locales in Node
+    if (
+        locales[name] === undefined &&
+        typeof module !== 'undefined' &&
+        module &&
+        module.exports &&
+        isLocaleNameSane(name)
+    ) {
+        try {
+            oldLocale = globalLocale._abbr;
+            aliasedRequire = require;
+            aliasedRequire('./locale/' + name);
+            getSetGlobalLocale(oldLocale);
+        } catch (e) {
+            // mark as not found to avoid repeating expensive file require call causing high CPU
+            // when trying to find en-US, en_US, en-us for every format call
+            locales[name] = null; // null means not found
+        }
+    }
+    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) {
+    var data;
+    if (key) {
+        if (isUndefined(values)) {
+            data = getLocale(key);
+        } else {
+            data = defineLocale(key, values);
+        }
+
+        if (data) {
+            // moment.duration._locale = moment._locale = data;
+            globalLocale = data;
+        } else {
+            if (typeof console !== 'undefined' && console.warn) {
+                //warn user if arguments are passed but the locale could not be set
+                console.warn(
+                    'Locale ' + key + ' not found. Did you forget to load it?'
+                );
+            }
+        }
+    }
+
+    return globalLocale._abbr;
+}
+
+export function defineLocale(name, config) {
+    if (config !== null) {
+        var locale,
+            parentConfig = baseConfig;
+        config.abbr = name;
+        if (locales[name] != null) {
+            deprecateSimple(
+                'defineLocaleOverride',
+                'use moment.updateLocale(localeName, config) to change ' +
+                    'an existing locale. moment.defineLocale(localeName, ' +
+                    'config) should only be used for creating a new locale ' +
+                    'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.'
+            );
+            parentConfig = locales[name]._config;
+        } else if (config.parentLocale != null) {
+            if (locales[config.parentLocale] != null) {
+                parentConfig = locales[config.parentLocale]._config;
+            } else {
+                locale = loadLocale(config.parentLocale);
+                if (locale != null) {
+                    parentConfig = locale._config;
+                } else {
+                    if (!localeFamilies[config.parentLocale]) {
+                        localeFamilies[config.parentLocale] = [];
+                    }
+                    localeFamilies[config.parentLocale].push({
+                        name: name,
+                        config: 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];
+    } else {
+        // useful for testing
+        delete locales[name];
+        return null;
+    }
+}
+
+export function updateLocale(name, config) {
+    if (config != null) {
+        var locale,
+            tmpLocale,
+            parentConfig = baseConfig;
+
+        if (locales[name] != null && locales[name].parentLocale != null) {
+            // Update existing child locale in-place to avoid memory-leaks
+            locales[name].set(mergeConfigs(locales[name]._config, config));
+        } else {
+            // MERGE
+            tmpLocale = loadLocale(name);
+            if (tmpLocale != null) {
+                parentConfig = tmpLocale._config;
+            }
+            config = mergeConfigs(parentConfig, config);
+            if (tmpLocale == null) {
+                // updateLocale is called for creating a new locale
+                // Set abbr so it will have a name (getters return
+                // undefined otherwise).
+                config.abbr = name;
+            }
+            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;
+                if (name === getSetGlobalLocale()) {
+                    getSetGlobalLocale(name);
+                }
+            } else if (locales[name] != null) {
+                delete locales[name];
+            }
+        }
+    }
+    return locales[name];
+}
+
+// returns locale data
+export function getLocale(key) {
+    var locale;
+
+    if (key && key._locale && key._locale._abbr) {
+        key = key._locale._abbr;
+    }
+
+    if (!key) {
+        return globalLocale;
+    }
+
+    if (!isArray(key)) {
+        //short-circuit everything else
+        locale = loadLocale(key);
+        if (locale) {
+            return locale;
+        }
+        key = [key];
+    }
+
+    return chooseLocale(key);
+}
+
+export function listLocales() {
+    return keys(locales);
+}

package/dist/node_modules/moment/src/lib/locale/ordinal.js

@@ -0,0 +1,8 @@
+var defaultOrdinal = '%d',
+    defaultDayOfMonthOrdinalParse = /\d{1,2}/;
+
+export { defaultOrdinal, defaultDayOfMonthOrdinalParse };
+
+export function ordinal(number) {
+    return this._ordinal.replace('%d', number);
+}

package/dist/node_modules/moment/src/lib/locale/pre-post-format.js

@@ -0,0 +1,3 @@
+export function preParsePostFormat(string) {
+    return string;
+}