easy-three-utils 0.0.335 → 0.0.337

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

@@ -0,0 +1,130 @@
+import * as C from '../../constant';
+export default (function (o, c, d) {
+  o = o || {};
+  var proto = c.prototype;
+  var relObj = {
+    future: 'in %s',
+    past: '%s ago',
+    s: 'a few 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'
+  };
+  d.en.relativeTime = relObj;
+
+  proto.fromToBase = function (input, withoutSuffix, instance, isFrom, postFormat) {
+    var loc = instance.$locale().relativeTime || relObj;
+    var T = o.thresholds || [{
+      l: 's',
+      r: 44,
+      d: C.S
+    }, {
+      l: 'm',
+      r: 89
+    }, {
+      l: 'mm',
+      r: 44,
+      d: C.MIN
+    }, {
+      l: 'h',
+      r: 89
+    }, {
+      l: 'hh',
+      r: 21,
+      d: C.H
+    }, {
+      l: 'd',
+      r: 35
+    }, {
+      l: 'dd',
+      r: 25,
+      d: C.D
+    }, {
+      l: 'M',
+      r: 45
+    }, {
+      l: 'MM',
+      r: 10,
+      d: C.M
+    }, {
+      l: 'y',
+      r: 17
+    }, {
+      l: 'yy',
+      d: C.Y
+    }];
+    var Tl = T.length;
+    var result;
+    var out;
+    var isFuture;
+
+    for (var i = 0; i < Tl; i += 1) {
+      var t = T[i];
+
+      if (t.d) {
+        result = isFrom ? d(input).diff(instance, t.d, true) : instance.diff(input, t.d, true);
+      }
+
+      var abs = (o.rounding || Math.round)(Math.abs(result));
+      isFuture = result > 0;
+
+      if (abs <= t.r || !t.r) {
+        if (abs <= 1 && i > 0) t = T[i - 1]; // 1 minutes -> a minute, 0 seconds -> 0 second
+
+        var format = loc[t.l];
+
+        if (postFormat) {
+          abs = postFormat("" + abs);
+        }
+
+        if (typeof format === 'string') {
+          out = format.replace('%d', abs);
+        } else {
+          out = format(abs, withoutSuffix, t.l, isFuture);
+        }
+
+        break;
+      }
+    }
+
+    if (withoutSuffix) return out;
+    var pastOrFuture = isFuture ? loc.future : loc.past;
+
+    if (typeof pastOrFuture === 'function') {
+      return pastOrFuture(out);
+    }
+
+    return pastOrFuture.replace('%s', out);
+  };
+
+  function fromTo(input, withoutSuffix, instance, isFrom) {
+    return proto.fromToBase(input, withoutSuffix, instance, isFrom);
+  }
+
+  proto.to = function (input, withoutSuffix) {
+    return fromTo(input, withoutSuffix, this, true);
+  };
+
+  proto.from = function (input, withoutSuffix) {
+    return fromTo(input, withoutSuffix, this);
+  };
+
+  var makeNow = function makeNow(thisDay) {
+    return thisDay.$u ? d.utc() : d();
+  };
+
+  proto.toNow = function (withoutSuffix) {
+    return this.to(makeNow(this), withoutSuffix);
+  };
+
+  proto.fromNow = function (withoutSuffix) {
+    return this.from(makeNow(this), withoutSuffix);
+  };
+});

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

@@ -0,0 +1,20 @@
+import { PluginFunc, ConfigType } from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin
+
+declare module 'dayjs/esm' {
+  interface Dayjs {
+    tz(timezone?: string, keepLocalTime?: boolean): Dayjs
+    offsetName(type?: 'short' | 'long'): string | undefined
+  }
+
+  interface DayjsTimezone {
+    (date?: ConfigType, timezone?: string): Dayjs
+    (date: ConfigType, format: string, timezone?: string): Dayjs
+    guess(): string
+    setDefault(timezone?: string): void
+  }
+
+  const tz: DayjsTimezone
+}

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

@@ -0,0 +1,198 @@
+import { MIN, MS } from '../../constant';
+var typeToPos = {
+  year: 0,
+  month: 1,
+  day: 2,
+  hour: 3,
+  minute: 4,
+  second: 5
+}; // Cache time-zone lookups from Intl.DateTimeFormat,
+// as it is a *very* slow method.
+
+var dtfCache = {};
+
+var getDateTimeFormat = function getDateTimeFormat(timezone, options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  var timeZoneName = options.timeZoneName || 'short';
+  var key = timezone + "|" + timeZoneName;
+  var dtf = dtfCache[key];
+
+  if (!dtf) {
+    dtf = new Intl.DateTimeFormat('en-US', {
+      hour12: false,
+      timeZone: timezone,
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit',
+      timeZoneName: timeZoneName
+    });
+    dtfCache[key] = dtf;
+  }
+
+  return dtf;
+};
+
+export default (function (o, c, d) {
+  var defaultTimezone;
+
+  var makeFormatParts = function makeFormatParts(timestamp, timezone, options) {
+    if (options === void 0) {
+      options = {};
+    }
+
+    var date = new Date(timestamp);
+    var dtf = getDateTimeFormat(timezone, options);
+    return dtf.formatToParts(date);
+  };
+
+  var tzOffset = function tzOffset(timestamp, timezone) {
+    var formatResult = makeFormatParts(timestamp, timezone);
+    var filled = [];
+
+    for (var i = 0; i < formatResult.length; i += 1) {
+      var _formatResult$i = formatResult[i],
+          type = _formatResult$i.type,
+          value = _formatResult$i.value;
+      var pos = typeToPos[type];
+
+      if (pos >= 0) {
+        filled[pos] = parseInt(value, 10);
+      }
+    }
+
+    var hour = filled[3]; // Workaround for the same behavior in different node version
+    // https://github.com/nodejs/node/issues/33027
+
+    /* istanbul ignore next */
+
+    var fixedHour = hour === 24 ? 0 : hour;
+    var utcString = filled[0] + "-" + filled[1] + "-" + filled[2] + " " + fixedHour + ":" + filled[4] + ":" + filled[5] + ":000";
+    var utcTs = d.utc(utcString).valueOf();
+    var asTS = +timestamp;
+    var over = asTS % 1000;
+    asTS -= over;
+    return (utcTs - asTS) / (60 * 1000);
+  }; // find the right offset a given local time. The o input is our guess, which determines which
+  // offset we'll pick in ambiguous cases (e.g. there are two 3 AMs b/c Fallback DST)
+  // https://github.com/moment/luxon/blob/master/src/datetime.js#L76
+
+
+  var fixOffset = function fixOffset(localTS, o0, tz) {
+    // Our UTC time is just a guess because our offset is just a guess
+    var utcGuess = localTS - o0 * 60 * 1000; // Test whether the zone matches the offset for this ts
+
+    var o2 = tzOffset(utcGuess, tz); // If so, offset didn't change and we're done
+
+    if (o0 === o2) {
+      return [utcGuess, o0];
+    } // If not, change the ts by the difference in the offset
+
+
+    utcGuess -= (o2 - o0) * 60 * 1000; // If that gives us the local time we want, we're done
+
+    var o3 = tzOffset(utcGuess, tz);
+
+    if (o2 === o3) {
+      return [utcGuess, o2];
+    } // If it's different, we're in a hole time.
+    // The offset has changed, but the we don't adjust the time
+
+
+    return [localTS - Math.min(o2, o3) * 60 * 1000, Math.max(o2, o3)];
+  };
+
+  var proto = c.prototype;
+
+  proto.tz = function (timezone, keepLocalTime) {
+    if (timezone === void 0) {
+      timezone = defaultTimezone;
+    }
+
+    var oldOffset = this.utcOffset();
+    var date = this.toDate();
+    var target = date.toLocaleString('en-US', {
+      timeZone: timezone
+    });
+    var diff = Math.round((date - new Date(target)) / 1000 / 60);
+    var offset = -Math.round(date.getTimezoneOffset() / 15) * 15 - diff;
+    var isUTC = !Number(offset);
+    var ins;
+
+    if (isUTC) {
+      // if utcOffset is 0, turn it to UTC mode
+      ins = this.utcOffset(0, keepLocalTime);
+    } else {
+      ins = d(target, {
+        locale: this.$L
+      }).$set(MS, this.$ms).utcOffset(offset, true);
+
+      if (keepLocalTime) {
+        var newOffset = ins.utcOffset();
+        ins = ins.add(oldOffset - newOffset, MIN);
+      }
+    }
+
+    ins.$x.$timezone = timezone;
+    return ins;
+  };
+
+  proto.offsetName = function (type) {
+    // type: short(default) / long
+    var zone = this.$x.$timezone || d.tz.guess();
+    var result = makeFormatParts(this.valueOf(), zone, {
+      timeZoneName: type
+    }).find(function (m) {
+      return m.type.toLowerCase() === 'timezonename';
+    });
+    return result && result.value;
+  };
+
+  var oldStartOf = proto.startOf;
+
+  proto.startOf = function (units, startOf) {
+    if (!this.$x || !this.$x.$timezone) {
+      return oldStartOf.call(this, units, startOf);
+    }
+
+    var withoutTz = d(this.format('YYYY-MM-DD HH:mm:ss:SSS'), {
+      locale: this.$L
+    });
+    var startOfWithoutTz = oldStartOf.call(withoutTz, units, startOf);
+    return startOfWithoutTz.tz(this.$x.$timezone, true);
+  };
+
+  d.tz = function (input, arg1, arg2) {
+    var parseFormat = arg2 && arg1;
+    var timezone = arg2 || arg1 || defaultTimezone;
+    var previousOffset = tzOffset(+d(), timezone);
+
+    if (typeof input !== 'string') {
+      // timestamp number || js Date || Day.js
+      return d(input).tz(timezone);
+    }
+
+    var localTs = d.utc(input, parseFormat).valueOf();
+
+    var _fixOffset = fixOffset(localTs, previousOffset, timezone),
+        targetTs = _fixOffset[0],
+        targetOffset = _fixOffset[1];
+
+    var ins = d(targetTs).utcOffset(targetOffset);
+    ins.$x.$timezone = timezone;
+    return ins;
+  };
+
+  d.tz.guess = function () {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+  };
+
+  d.tz.setDefault = function (timezone) {
+    defaultTimezone = timezone;
+  };
+});

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

@@ -0,0 +1,10 @@
+import { PluginFunc } from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin
+
+declare module 'dayjs/esm' {
+  interface Dayjs {
+    toArray(): number[]
+  }
+}

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

@@ -0,0 +1,7 @@
+export default (function (o, c) {
+  var proto = c.prototype;
+
+  proto.toArray = function () {
+    return [this.$y, this.$M, this.$D, this.$H, this.$m, this.$s, this.$ms];
+  };
+});

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

@@ -0,0 +1,20 @@
+import { PluginFunc } from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin
+
+interface DayjsObject {
+  years: number
+  months: number
+  date: number
+  hours: number
+  minutes: number
+  seconds: number
+  milliseconds: number
+}
+
+declare module 'dayjs/esm' {
+  interface Dayjs {
+    toObject(): DayjsObject
+  }
+}

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

@@ -0,0 +1,15 @@
+export default (function (o, c) {
+  var proto = c.prototype;
+
+  proto.toObject = function () {
+    return {
+      years: this.$y,
+      months: this.$M,
+      date: this.$D,
+      hours: this.$H,
+      minutes: this.$m,
+      seconds: this.$s,
+      milliseconds: this.$ms
+    };
+  };
+});

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

@@ -0,0 +1,8 @@
+import { PluginFunc } from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin
+
+declare module 'dayjs/esm' {
+  export function updateLocale(localeName: string, customConfig: Record<string, unknown>): Record<string, unknown>
+}

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

@@ -0,0 +1,12 @@
+export default (function (option, Dayjs, dayjs) {
+  dayjs.updateLocale = function (locale, customConfig) {
+    var localeList = dayjs.Ls;
+    var localeConfig = localeList[locale];
+    if (!localeConfig) return;
+    var customConfigKeys = customConfig ? Object.keys(customConfig) : [];
+    customConfigKeys.forEach(function (c) {
+      localeConfig[c] = customConfig[c];
+    });
+    return localeConfig; // eslint-disable-line consistent-return
+  };
+});

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

@@ -0,0 +1,19 @@
+import { PluginFunc, ConfigType } from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin
+
+declare module 'dayjs/esm' {
+  interface Dayjs {
+    
+    utc(keepLocalTime?: boolean): Dayjs
+    
+    local(): Dayjs
+
+    isUTC(): boolean
+
+    utcOffset(offset: number | string, keepLocalTime?: boolean): Dayjs
+  }
+
+  export function utc(config?: ConfigType, format?: string, strict?: boolean): Dayjs
+}

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

@@ -0,0 +1,188 @@
+import { MILLISECONDS_A_MINUTE, MIN } from '../../constant';
+var REGEX_VALID_OFFSET_FORMAT = /[+-]\d\d(?::?\d\d)?/g;
+var REGEX_OFFSET_HOURS_MINUTES_FORMAT = /([+-]|\d\d)/g;
+
+function offsetFromString(value) {
+  if (value === void 0) {
+    value = '';
+  }
+
+  var offset = value.match(REGEX_VALID_OFFSET_FORMAT);
+
+  if (!offset) {
+    return null;
+  }
+
+  var _ref = ("" + offset[0]).match(REGEX_OFFSET_HOURS_MINUTES_FORMAT) || ['-', 0, 0],
+      indicator = _ref[0],
+      hoursOffset = _ref[1],
+      minutesOffset = _ref[2];
+
+  var totalOffsetInMinutes = +hoursOffset * 60 + +minutesOffset;
+
+  if (totalOffsetInMinutes === 0) {
+    return 0;
+  }
+
+  return indicator === '+' ? totalOffsetInMinutes : -totalOffsetInMinutes;
+}
+
+export default (function (option, Dayjs, dayjs) {
+  var proto = Dayjs.prototype;
+
+  dayjs.utc = function (date) {
+    var cfg = {
+      date: date,
+      utc: true,
+      args: arguments
+    }; // eslint-disable-line prefer-rest-params
+
+    return new Dayjs(cfg); // eslint-disable-line no-use-before-define
+  };
+
+  proto.utc = function (keepLocalTime) {
+    var ins = dayjs(this.toDate(), {
+      locale: this.$L,
+      utc: true
+    });
+
+    if (keepLocalTime) {
+      return ins.add(this.utcOffset(), MIN);
+    }
+
+    return ins;
+  };
+
+  proto.local = function () {
+    return dayjs(this.toDate(), {
+      locale: this.$L,
+      utc: false
+    });
+  };
+
+  var oldParse = proto.parse;
+
+  proto.parse = function (cfg) {
+    if (cfg.utc) {
+      this.$u = true;
+    }
+
+    if (!this.$utils().u(cfg.$offset)) {
+      this.$offset = cfg.$offset;
+    }
+
+    oldParse.call(this, cfg);
+  };
+
+  var oldInit = proto.init;
+
+  proto.init = function () {
+    if (this.$u) {
+      var $d = this.$d;
+      this.$y = $d.getUTCFullYear();
+      this.$M = $d.getUTCMonth();
+      this.$D = $d.getUTCDate();
+      this.$W = $d.getUTCDay();
+      this.$H = $d.getUTCHours();
+      this.$m = $d.getUTCMinutes();
+      this.$s = $d.getUTCSeconds();
+      this.$ms = $d.getUTCMilliseconds();
+    } else {
+      oldInit.call(this);
+    }
+  };
+
+  var oldUtcOffset = proto.utcOffset;
+
+  proto.utcOffset = function (input, keepLocalTime) {
+    var _this$$utils = this.$utils(),
+        u = _this$$utils.u;
+
+    if (u(input)) {
+      if (this.$u) {
+        return 0;
+      }
+
+      if (!u(this.$offset)) {
+        return this.$offset;
+      }
+
+      return oldUtcOffset.call(this);
+    }
+
+    if (typeof input === 'string') {
+      input = offsetFromString(input);
+
+      if (input === null) {
+        return this;
+      }
+    }
+
+    var offset = Math.abs(input) <= 16 ? input * 60 : input;
+
+    if (offset === 0) {
+      return this.utc(keepLocalTime);
+    }
+
+    var ins = this.clone();
+
+    if (keepLocalTime) {
+      ins.$offset = offset;
+      ins.$u = false;
+      return ins;
+    }
+
+    var localTimezoneOffset = this.$u ? this.toDate().getTimezoneOffset() : -1 * this.utcOffset();
+    ins = this.local().add(offset + localTimezoneOffset, MIN);
+    ins.$offset = offset;
+    ins.$x.$localOffset = localTimezoneOffset;
+    return ins;
+  };
+
+  var oldFormat = proto.format;
+  var UTC_FORMAT_DEFAULT = 'YYYY-MM-DDTHH:mm:ss[Z]';
+
+  proto.format = function (formatStr) {
+    var str = formatStr || (this.$u ? UTC_FORMAT_DEFAULT : '');
+    return oldFormat.call(this, str);
+  };
+
+  proto.valueOf = function () {
+    var addedOffset = !this.$utils().u(this.$offset) ? this.$offset + (this.$x.$localOffset || this.$d.getTimezoneOffset()) : 0;
+    return this.$d.valueOf() - addedOffset * MILLISECONDS_A_MINUTE;
+  };
+
+  proto.isUTC = function () {
+    return !!this.$u;
+  };
+
+  proto.toISOString = function () {
+    return this.toDate().toISOString();
+  };
+
+  proto.toString = function () {
+    return this.toDate().toUTCString();
+  };
+
+  var oldToDate = proto.toDate;
+
+  proto.toDate = function (type) {
+    if (type === 's' && this.$offset) {
+      return dayjs(this.format('YYYY-MM-DD HH:mm:ss:SSS')).toDate();
+    }
+
+    return oldToDate.call(this);
+  };
+
+  var oldDiff = proto.diff;
+
+  proto.diff = function (input, units, _float) {
+    if (input && this.$u === input.$u) {
+      return oldDiff.call(this, input, units, _float);
+    }
+
+    var localThis = this.local();
+    var localInput = dayjs(input).local();
+    return oldDiff.call(localThis, localInput, units, _float);
+  };
+});

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

@@ -0,0 +1,12 @@
+import { PluginFunc } from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin
+
+declare module 'dayjs/esm' {
+  interface Dayjs {
+    week(): number
+
+    week(value : number): Dayjs
+  }
+}

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

@@ -0,0 +1,44 @@
+import { MS, Y, D, W } from '../../constant';
+export default (function (o, c, d) {
+  var proto = c.prototype;
+
+  proto.week = function (week) {
+    if (week === void 0) {
+      week = null;
+    }
+
+    if (week !== null) {
+      return this.add((week - this.week()) * 7, D);
+    }
+
+    var yearStart = this.$locale().yearStart || 1;
+
+    if (this.month() === 11 && this.date() > 25) {
+      // d(this) is for badMutable
+      var nextYearStartDay = d(this).startOf(Y).add(1, Y).date(yearStart);
+      var thisEndOfWeek = d(this).endOf(W);
+
+      if (nextYearStartDay.isBefore(thisEndOfWeek)) {
+        return 1;
+      }
+    }
+
+    var yearStartDay = d(this).startOf(Y).date(yearStart);
+    var yearStartWeek = yearStartDay.startOf(W).subtract(1, MS);
+    var diffInWeek = this.diff(yearStartWeek, W, true);
+
+    if (diffInWeek < 0) {
+      return d(this).startOf('week').week();
+    }
+
+    return Math.ceil(diffInWeek);
+  };
+
+  proto.weeks = function (week) {
+    if (week === void 0) {
+      week = null;
+    }
+
+    return this.week(week);
+  };
+});

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

@@ -0,0 +1,10 @@
+import { PluginFunc } from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin
+
+declare module 'dayjs/esm' {
+  interface Dayjs {
+    weekYear(): number
+  }
+}