easy-three-utils 0.0.335 → 0.0.337

package/cesium/modules/dayjs/esm/plugin/localeData/index.js

@@ -0,0 +1,114 @@
+import { t } from '../localizedFormat/utils';
+export default (function (o, c, dayjs) {
+  // locale needed later
+  var proto = c.prototype;
+
+  var getLocalePart = function getLocalePart(part) {
+    return part && (part.indexOf ? part : part.s);
+  };
+
+  var getShort = function getShort(ins, target, full, num, localeOrder) {
+    var locale = ins.name ? ins : ins.$locale();
+    var targetLocale = getLocalePart(locale[target]);
+    var fullLocale = getLocalePart(locale[full]);
+    var result = targetLocale || fullLocale.map(function (f) {
+      return f.slice(0, num);
+    });
+    if (!localeOrder) return result;
+    var weekStart = locale.weekStart;
+    return result.map(function (_, index) {
+      return result[(index + (weekStart || 0)) % 7];
+    });
+  };
+
+  var getDayjsLocaleObject = function getDayjsLocaleObject() {
+    return dayjs.Ls[dayjs.locale()];
+  };
+
+  var getLongDateFormat = function getLongDateFormat(l, format) {
+    return l.formats[format] || t(l.formats[format.toUpperCase()]);
+  };
+
+  var localeData = function localeData() {
+    var _this = this;
+
+    return {
+      months: function months(instance) {
+        return instance ? instance.format('MMMM') : getShort(_this, 'months');
+      },
+      monthsShort: function monthsShort(instance) {
+        return instance ? instance.format('MMM') : getShort(_this, 'monthsShort', 'months', 3);
+      },
+      firstDayOfWeek: function firstDayOfWeek() {
+        return _this.$locale().weekStart || 0;
+      },
+      weekdays: function weekdays(instance) {
+        return instance ? instance.format('dddd') : getShort(_this, 'weekdays');
+      },
+      weekdaysMin: function weekdaysMin(instance) {
+        return instance ? instance.format('dd') : getShort(_this, 'weekdaysMin', 'weekdays', 2);
+      },
+      weekdaysShort: function weekdaysShort(instance) {
+        return instance ? instance.format('ddd') : getShort(_this, 'weekdaysShort', 'weekdays', 3);
+      },
+      longDateFormat: function longDateFormat(format) {
+        return getLongDateFormat(_this.$locale(), format);
+      },
+      meridiem: this.$locale().meridiem,
+      ordinal: this.$locale().ordinal
+    };
+  };
+
+  proto.localeData = function () {
+    return localeData.bind(this)();
+  };
+
+  dayjs.localeData = function () {
+    var localeObject = getDayjsLocaleObject();
+    return {
+      firstDayOfWeek: function firstDayOfWeek() {
+        return localeObject.weekStart || 0;
+      },
+      weekdays: function weekdays() {
+        return dayjs.weekdays();
+      },
+      weekdaysShort: function weekdaysShort() {
+        return dayjs.weekdaysShort();
+      },
+      weekdaysMin: function weekdaysMin() {
+        return dayjs.weekdaysMin();
+      },
+      months: function months() {
+        return dayjs.months();
+      },
+      monthsShort: function monthsShort() {
+        return dayjs.monthsShort();
+      },
+      longDateFormat: function longDateFormat(format) {
+        return getLongDateFormat(localeObject, format);
+      },
+      meridiem: localeObject.meridiem,
+      ordinal: localeObject.ordinal
+    };
+  };
+
+  dayjs.months = function () {
+    return getShort(getDayjsLocaleObject(), 'months');
+  };
+
+  dayjs.monthsShort = function () {
+    return getShort(getDayjsLocaleObject(), 'monthsShort', 'months', 3);
+  };
+
+  dayjs.weekdays = function (localeOrder) {
+    return getShort(getDayjsLocaleObject(), 'weekdays', null, null, localeOrder);
+  };
+
+  dayjs.weekdaysShort = function (localeOrder) {
+    return getShort(getDayjsLocaleObject(), 'weekdaysShort', 'weekdays', 3, localeOrder);
+  };
+
+  dayjs.weekdaysMin = function (localeOrder) {
+    return getShort(getDayjsLocaleObject(), 'weekdaysMin', 'weekdays', 2, localeOrder);
+  };
+});

package/cesium/modules/dayjs/esm/plugin/localizedFormat/index.d.ts

@@ -0,0 +1,4 @@
+import { PluginFunc } from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin

package/cesium/modules/dayjs/esm/plugin/localizedFormat/index.js

@@ -0,0 +1,20 @@
+import { FORMAT_DEFAULT } from '../../constant';
+import { u, englishFormats } from './utils';
+export default (function (o, c, d) {
+  var proto = c.prototype;
+  var oldFormat = proto.format;
+  d.en.formats = englishFormats;
+
+  proto.format = function (formatStr) {
+    if (formatStr === void 0) {
+      formatStr = FORMAT_DEFAULT;
+    }
+
+    var _this$$locale = this.$locale(),
+        _this$$locale$formats = _this$$locale.formats,
+        formats = _this$$locale$formats === void 0 ? {} : _this$$locale$formats;
+
+    var result = u(formatStr, formats);
+    return oldFormat.call(this, result);
+  };
+});

package/cesium/modules/dayjs/esm/plugin/localizedFormat/utils.js

@@ -0,0 +1,20 @@
+// eslint-disable-next-line import/prefer-default-export
+export var t = function t(format) {
+  return format.replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g, function (_, a, b) {
+    return a || b.slice(1);
+  });
+};
+export var englishFormats = {
+  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 var u = function u(formatStr, formats) {
+  return formatStr.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g, function (_, a, b) {
+    var B = b && b.toUpperCase();
+    return a || formats[b] || englishFormats[b] || t(formats[B]);
+  });
+};

package/cesium/modules/dayjs/esm/plugin/minMax/index.d.ts

@@ -0,0 +1,22 @@
+import { PluginFunc } from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin
+
+declare module 'dayjs/esm' {
+  export function max(dayjs: [Dayjs, ...Dayjs[]]): Dayjs
+  export function max(noDates: never[]): null
+  export function max(maybeDates: Dayjs[]): Dayjs | null
+
+  export function max(...dayjs: [Dayjs, ...Dayjs[]]): Dayjs
+  export function max(...noDates: never[]): null
+  export function max(...maybeDates: Dayjs[]): Dayjs | null
+
+  export function min(dayjs: [Dayjs, ...Dayjs[]]): Dayjs
+  export function min(noDates: never[]): null
+  export function min(maybeDates: Dayjs[]): Dayjs | null
+
+  export function min(...dayjs: [Dayjs, ...Dayjs[]]): Dayjs
+  export function min(...noDates: never[]): null
+  export function min(...maybeDates: Dayjs[]): Dayjs | null
+}

package/cesium/modules/dayjs/esm/plugin/minMax/index.js

@@ -0,0 +1,39 @@
+export default (function (o, c, d) {
+  var sortBy = function sortBy(method, dates) {
+    if (!dates || !dates.length || dates.length === 1 && !dates[0] || dates.length === 1 && Array.isArray(dates[0]) && !dates[0].length) {
+      return null;
+    }
+
+    if (dates.length === 1 && dates[0].length > 0) {
+      var _dates = dates;
+      dates = _dates[0];
+    }
+
+    dates = dates.filter(function (date) {
+      return date;
+    });
+    var result;
+    var _dates2 = dates;
+    result = _dates2[0];
+
+    for (var i = 1; i < dates.length; i += 1) {
+      if (!dates[i].isValid() || dates[i][method](result)) {
+        result = dates[i];
+      }
+    }
+
+    return result;
+  };
+
+  d.max = function () {
+    var args = [].slice.call(arguments, 0); // eslint-disable-line prefer-rest-params
+
+    return sortBy('isAfter', args);
+  };
+
+  d.min = function () {
+    var args = [].slice.call(arguments, 0); // eslint-disable-line prefer-rest-params
+
+    return sortBy('isBefore', args);
+  };
+});

package/cesium/modules/dayjs/esm/plugin/negativeYear/index.d.ts

@@ -0,0 +1,4 @@
+import {PluginFunc} from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin

package/cesium/modules/dayjs/esm/plugin/negativeYear/index.js

@@ -0,0 +1,36 @@
+export default (function (_, c, dayjs) {
+  var proto = c.prototype;
+
+  var parseDate = function parseDate(cfg) {
+    var date = cfg.date,
+        utc = cfg.utc;
+
+    if (typeof date === 'string' && date.charAt(0) === '-') {
+      var normalData = date.slice(1);
+      var newDate = dayjs(normalData);
+
+      if (utc) {
+        newDate = dayjs.utc(normalData);
+      } else {
+        newDate = dayjs(normalData);
+      }
+
+      var fullYear = newDate.year();
+
+      if (date.indexOf("-" + fullYear) !== -1) {
+        return dayjs(newDate).subtract(fullYear * 2, 'year').toDate();
+      }
+
+      return date;
+    }
+
+    return date;
+  };
+
+  var oldParse = proto.parse;
+
+  proto.parse = function (cfg) {
+    cfg.date = parseDate.bind(this)(cfg);
+    oldParse.bind(this)(cfg);
+  };
+});

package/cesium/modules/dayjs/esm/plugin/objectSupport/index.d.ts

@@ -0,0 +1,48 @@
+import { PluginFunc } from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin
+
+declare module 'dayjs/esm' {
+    interface Dayjs {
+        set(argument: object): Dayjs
+        add(argument: object): Dayjs
+        subtract(argument: object): Dayjs
+    }
+
+    interface ConfigTypeMap {
+        objectSupport: {
+            years?: number | string;
+            year?: number | string;
+            y?: number | string;
+
+            months?: number | string;
+            month?: number | string;
+            M?: number | string;
+
+            days?: number | string;
+            day?: number | string;
+            d?: number | string;
+
+            dates?: number | string;
+            date?: number | string;
+            D?: number | string;
+
+            hours?: number | string;
+            hour?: number | string;
+            h?: number | string;
+
+            minutes?: number | string;
+            minute?: number | string;
+            m?: number | string;
+
+            seconds?: number | string;
+            second?: number | string;
+            s?: number | string;
+
+            milliseconds?: number | string;
+            millisecond?: number | string;
+            ms?: number | string;
+        }
+    }
+}

package/cesium/modules/dayjs/esm/plugin/objectSupport/index.js

@@ -0,0 +1,97 @@
+export default (function (o, c, dayjs) {
+  var proto = c.prototype;
+
+  var isObject = function isObject(obj) {
+    return obj !== null && !(obj instanceof Date) && !(obj instanceof Array) && !proto.$utils().u(obj) && obj.constructor.name === 'Object';
+  };
+
+  var prettyUnit = function prettyUnit(u) {
+    var unit = proto.$utils().p(u);
+    return unit === 'date' ? 'day' : unit;
+  };
+
+  var parseDate = function parseDate(cfg) {
+    var date = cfg.date,
+        utc = cfg.utc;
+    var $d = {};
+
+    if (isObject(date)) {
+      if (!Object.keys(date).length) {
+        return new Date();
+      }
+
+      var now = utc ? dayjs.utc() : dayjs();
+      Object.keys(date).forEach(function (k) {
+        $d[prettyUnit(k)] = date[k];
+      });
+      var d = $d.day || (!$d.year && !($d.month >= 0) ? now.date() : 1);
+      var y = $d.year || now.year();
+      var M = $d.month >= 0 ? $d.month : !$d.year && !$d.day ? now.month() : 0; // eslint-disable-line no-nested-ternary,max-len
+
+      var h = $d.hour || 0;
+      var m = $d.minute || 0;
+      var s = $d.second || 0;
+      var ms = $d.millisecond || 0;
+
+      if (utc) {
+        return new Date(Date.UTC(y, M, d, h, m, s, ms));
+      }
+
+      return new Date(y, M, d, h, m, s, ms);
+    }
+
+    return date;
+  };
+
+  var oldParse = proto.parse;
+
+  proto.parse = function (cfg) {
+    cfg.date = parseDate.bind(this)(cfg);
+    oldParse.bind(this)(cfg);
+  };
+
+  var oldSet = proto.set;
+  var oldAdd = proto.add;
+  var oldSubtract = proto.subtract;
+
+  var callObject = function callObject(call, argument, string, offset) {
+    if (offset === void 0) {
+      offset = 1;
+    }
+
+    var keys = Object.keys(argument);
+    var chain = this;
+    keys.forEach(function (key) {
+      chain = call.bind(chain)(argument[key] * offset, key);
+    });
+    return chain;
+  };
+
+  proto.set = function (unit, value) {
+    value = value === undefined ? unit : value;
+
+    if (unit.constructor.name === 'Object') {
+      return callObject.bind(this)(function (i, s) {
+        return oldSet.bind(this)(s, i);
+      }, value, unit);
+    }
+
+    return oldSet.bind(this)(unit, value);
+  };
+
+  proto.add = function (value, unit) {
+    if (value.constructor.name === 'Object') {
+      return callObject.bind(this)(oldAdd, value, unit);
+    }
+
+    return oldAdd.bind(this)(value, unit);
+  };
+
+  proto.subtract = function (value, unit) {
+    if (value.constructor.name === 'Object') {
+      return callObject.bind(this)(oldAdd, value, unit, -1);
+    }
+
+    return oldSubtract.bind(this)(value, unit);
+  };
+});

package/cesium/modules/dayjs/esm/plugin/pluralGetSet/index.d.ts

@@ -0,0 +1,44 @@
+import { PluginFunc, UnitType, ConfigType } from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin
+
+declare module 'dayjs/esm' {
+  interface Dayjs {
+    years(): number
+
+    years(value: number): Dayjs
+
+    months(): number
+
+    months(value: number): Dayjs
+
+    dates(): number
+
+    dates(value: number): Dayjs
+
+    weeks(): number
+
+    weeks(value: number): Dayjs
+
+    days(): number
+
+    days(value: number): Dayjs
+
+    hours(): number
+
+    hours(value: number): Dayjs
+
+    minutes(): number
+
+    minutes(value: number): Dayjs
+
+    seconds(): number
+
+    seconds(value: number): Dayjs
+
+    milliseconds(): number
+
+    milliseconds(value: number): Dayjs
+  }
+}

package/cesium/modules/dayjs/esm/plugin/pluralGetSet/index.js

@@ -0,0 +1,7 @@
+export default (function (o, c) {
+  var proto = c.prototype;
+  var pluralAliases = ['milliseconds', 'seconds', 'minutes', 'hours', 'days', 'weeks', 'isoWeeks', 'months', 'quarters', 'years', 'dates'];
+  pluralAliases.forEach(function (alias) {
+    proto[alias] = proto[alias.replace(/s$/, '')];
+  });
+});

package/cesium/modules/dayjs/esm/plugin/preParsePostFormat/index.d.ts

@@ -0,0 +1,4 @@
+import { PluginFunc } from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin

package/cesium/modules/dayjs/esm/plugin/preParsePostFormat/index.js

@@ -0,0 +1,40 @@
+// Plugin template from https://day.js.org/docs/en/plugin/plugin
+export default (function (option, dayjsClass) {
+  var oldParse = dayjsClass.prototype.parse;
+
+  dayjsClass.prototype.parse = function (cfg) {
+    if (typeof cfg.date === 'string') {
+      var locale = this.$locale();
+      cfg.date = locale && locale.preparse ? locale.preparse(cfg.date) : cfg.date;
+    } // original parse result
+
+
+    return oldParse.bind(this)(cfg);
+  }; // // overriding existing API
+  // // e.g. extend dayjs().format()
+
+
+  var oldFormat = dayjsClass.prototype.format;
+
+  dayjsClass.prototype.format = function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    // original format result
+    var result = oldFormat.call.apply(oldFormat, [this].concat(args)); // return modified result
+
+    var locale = this.$locale();
+    return locale && locale.postformat ? locale.postformat(result) : result;
+  };
+
+  var oldFromTo = dayjsClass.prototype.fromToBase;
+
+  if (oldFromTo) {
+    dayjsClass.prototype.fromToBase = function (input, withoutSuffix, instance, isFrom) {
+      var locale = this.$locale() || instance.$locale(); // original format result
+
+      return oldFromTo.call(this, input, withoutSuffix, instance, isFrom, locale && locale.postformat);
+    };
+  }
+});

package/cesium/modules/dayjs/esm/plugin/quarterOfYear/index.d.ts

@@ -0,0 +1,26 @@
+import { PluginFunc, ConfigType, QUnitType, OpUnitType } from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin
+
+declare module 'dayjs/esm' {
+  interface Dayjs {
+    quarter(): number
+
+    quarter(quarter: number): Dayjs
+
+    add(value: number, unit: QUnitType): Dayjs
+
+    subtract(value: number, unit: QUnitType): Dayjs
+
+    startOf(unit: QUnitType | OpUnitType): Dayjs
+
+    endOf(unit: QUnitType | OpUnitType): Dayjs
+
+    isSame(date?: ConfigType, unit?: QUnitType): boolean
+
+    isBefore(date?: ConfigType, unit?: QUnitType): boolean
+
+    isAfter(date?: ConfigType, unit?: QUnitType): boolean
+  }
+}

package/cesium/modules/dayjs/esm/plugin/quarterOfYear/index.js

@@ -0,0 +1,41 @@
+import { Q, M, D } from '../../constant';
+export default (function (o, c) {
+  var proto = c.prototype;
+
+  proto.quarter = function (quarter) {
+    if (!this.$utils().u(quarter)) {
+      return this.month(this.month() % 3 + (quarter - 1) * 3);
+    }
+
+    return Math.ceil((this.month() + 1) / 3);
+  };
+
+  var oldAdd = proto.add;
+
+  proto.add = function (number, units) {
+    number = Number(number); // eslint-disable-line no-param-reassign
+
+    var unit = this.$utils().p(units);
+
+    if (unit === Q) {
+      return this.add(number * 3, M);
+    }
+
+    return oldAdd.bind(this)(number, units);
+  };
+
+  var oldStartOf = proto.startOf;
+
+  proto.startOf = function (units, startOf) {
+    var utils = this.$utils();
+    var isStartOf = !utils.u(startOf) ? startOf : true;
+    var unit = utils.p(units);
+
+    if (unit === Q) {
+      var quarter = this.quarter() - 1;
+      return isStartOf ? this.month(quarter * 3).startOf(M).startOf(D) : this.month(quarter * 3 + 2).endOf(M).endOf(D);
+    }
+
+    return oldStartOf.bind(this)(units, startOf);
+  };
+});

package/cesium/modules/dayjs/esm/plugin/relativeTime/index.d.ts

@@ -0,0 +1,24 @@
+import { PluginFunc, ConfigType } from 'dayjs/esm'
+
+declare interface RelativeTimeThreshold {
+  l: string
+  r?: number
+  d?: string
+}
+
+declare interface RelativeTimeOptions {
+  rounding?: (num: number) => number
+  thresholds?: RelativeTimeThreshold[]
+}
+
+declare const plugin: PluginFunc<RelativeTimeOptions>
+export = plugin
+
+declare module 'dayjs/esm' {
+  interface Dayjs {
+    fromNow(withoutSuffix?: boolean): string
+    from(compared: ConfigType, withoutSuffix?: boolean): string
+    toNow(withoutSuffix?: boolean): string
+    to(compared: ConfigType, withoutSuffix?: boolean): string
+  }
+}