easy-three-utils 0.0.335 → 0.0.337

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

@@ -0,0 +1,356 @@
+import { MILLISECONDS_A_DAY, MILLISECONDS_A_HOUR, MILLISECONDS_A_MINUTE, MILLISECONDS_A_SECOND, MILLISECONDS_A_WEEK, REGEX_FORMAT } from '../../constant';
+var MILLISECONDS_A_YEAR = MILLISECONDS_A_DAY * 365;
+var MILLISECONDS_A_MONTH = MILLISECONDS_A_YEAR / 12;
+var durationRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
+var unitToMS = {
+  years: MILLISECONDS_A_YEAR,
+  months: MILLISECONDS_A_MONTH,
+  days: MILLISECONDS_A_DAY,
+  hours: MILLISECONDS_A_HOUR,
+  minutes: MILLISECONDS_A_MINUTE,
+  seconds: MILLISECONDS_A_SECOND,
+  milliseconds: 1,
+  weeks: MILLISECONDS_A_WEEK
+};
+
+var isDuration = function isDuration(d) {
+  return d instanceof Duration;
+}; // eslint-disable-line no-use-before-define
+
+
+var $d;
+var $u;
+
+var wrapper = function wrapper(input, instance, unit) {
+  return new Duration(input, unit, instance.$l);
+}; // eslint-disable-line no-use-before-define
+
+
+var prettyUnit = function prettyUnit(unit) {
+  return $u.p(unit) + "s";
+};
+
+var isNegative = function isNegative(number) {
+  return number < 0;
+};
+
+var roundNumber = function roundNumber(number) {
+  return isNegative(number) ? Math.ceil(number) : Math.floor(number);
+};
+
+var absolute = function absolute(number) {
+  return Math.abs(number);
+};
+
+var getNumberUnitFormat = function getNumberUnitFormat(number, unit) {
+  if (!number) {
+    return {
+      negative: false,
+      format: ''
+    };
+  }
+
+  if (isNegative(number)) {
+    return {
+      negative: true,
+      format: "" + absolute(number) + unit
+    };
+  }
+
+  return {
+    negative: false,
+    format: "" + number + unit
+  };
+};
+
+var Duration = /*#__PURE__*/function () {
+  function Duration(input, unit, locale) {
+    var _this = this;
+
+    this.$d = {};
+    this.$l = locale;
+
+    if (input === undefined) {
+      this.$ms = 0;
+      this.parseFromMilliseconds();
+    }
+
+    if (unit) {
+      return wrapper(input * unitToMS[prettyUnit(unit)], this);
+    }
+
+    if (typeof input === 'number') {
+      this.$ms = input;
+      this.parseFromMilliseconds();
+      return this;
+    }
+
+    if (typeof input === 'object') {
+      Object.keys(input).forEach(function (k) {
+        _this.$d[prettyUnit(k)] = input[k];
+      });
+      this.calMilliseconds();
+      return this;
+    }
+
+    if (typeof input === 'string') {
+      var d = input.match(durationRegex);
+
+      if (d) {
+        var properties = d.slice(2);
+        var numberD = properties.map(function (value) {
+          return value != null ? Number(value) : 0;
+        });
+        this.$d.years = numberD[0];
+        this.$d.months = numberD[1];
+        this.$d.weeks = numberD[2];
+        this.$d.days = numberD[3];
+        this.$d.hours = numberD[4];
+        this.$d.minutes = numberD[5];
+        this.$d.seconds = numberD[6];
+        this.calMilliseconds();
+        return this;
+      }
+    }
+
+    return this;
+  }
+
+  var _proto = Duration.prototype;
+
+  _proto.calMilliseconds = function calMilliseconds() {
+    var _this2 = this;
+
+    this.$ms = Object.keys(this.$d).reduce(function (total, unit) {
+      return total + (_this2.$d[unit] || 0) * unitToMS[unit];
+    }, 0);
+  };
+
+  _proto.parseFromMilliseconds = function parseFromMilliseconds() {
+    var $ms = this.$ms;
+    this.$d.years = roundNumber($ms / MILLISECONDS_A_YEAR);
+    $ms %= MILLISECONDS_A_YEAR;
+    this.$d.months = roundNumber($ms / MILLISECONDS_A_MONTH);
+    $ms %= MILLISECONDS_A_MONTH;
+    this.$d.days = roundNumber($ms / MILLISECONDS_A_DAY);
+    $ms %= MILLISECONDS_A_DAY;
+    this.$d.hours = roundNumber($ms / MILLISECONDS_A_HOUR);
+    $ms %= MILLISECONDS_A_HOUR;
+    this.$d.minutes = roundNumber($ms / MILLISECONDS_A_MINUTE);
+    $ms %= MILLISECONDS_A_MINUTE;
+    this.$d.seconds = roundNumber($ms / MILLISECONDS_A_SECOND);
+    $ms %= MILLISECONDS_A_SECOND;
+    this.$d.milliseconds = $ms;
+  };
+
+  _proto.toISOString = function toISOString() {
+    var Y = getNumberUnitFormat(this.$d.years, 'Y');
+    var M = getNumberUnitFormat(this.$d.months, 'M');
+    var days = +this.$d.days || 0;
+
+    if (this.$d.weeks) {
+      days += this.$d.weeks * 7;
+    }
+
+    var D = getNumberUnitFormat(days, 'D');
+    var H = getNumberUnitFormat(this.$d.hours, 'H');
+    var m = getNumberUnitFormat(this.$d.minutes, 'M');
+    var seconds = this.$d.seconds || 0;
+
+    if (this.$d.milliseconds) {
+      seconds += this.$d.milliseconds / 1000;
+      seconds = Math.round(seconds * 1000) / 1000;
+    }
+
+    var S = getNumberUnitFormat(seconds, 'S');
+    var negativeMode = Y.negative || M.negative || D.negative || H.negative || m.negative || S.negative;
+    var T = H.format || m.format || S.format ? 'T' : '';
+    var P = negativeMode ? '-' : '';
+    var result = P + "P" + Y.format + M.format + D.format + T + H.format + m.format + S.format;
+    return result === 'P' || result === '-P' ? 'P0D' : result;
+  };
+
+  _proto.toJSON = function toJSON() {
+    return this.toISOString();
+  };
+
+  _proto.format = function format(formatStr) {
+    var str = formatStr || 'YYYY-MM-DDTHH:mm:ss';
+    var matches = {
+      Y: this.$d.years,
+      YY: $u.s(this.$d.years, 2, '0'),
+      YYYY: $u.s(this.$d.years, 4, '0'),
+      M: this.$d.months,
+      MM: $u.s(this.$d.months, 2, '0'),
+      D: this.$d.days,
+      DD: $u.s(this.$d.days, 2, '0'),
+      H: this.$d.hours,
+      HH: $u.s(this.$d.hours, 2, '0'),
+      m: this.$d.minutes,
+      mm: $u.s(this.$d.minutes, 2, '0'),
+      s: this.$d.seconds,
+      ss: $u.s(this.$d.seconds, 2, '0'),
+      SSS: $u.s(this.$d.milliseconds, 3, '0')
+    };
+    return str.replace(REGEX_FORMAT, function (match, $1) {
+      return $1 || String(matches[match]);
+    });
+  };
+
+  _proto.as = function as(unit) {
+    return this.$ms / unitToMS[prettyUnit(unit)];
+  };
+
+  _proto.get = function get(unit) {
+    var base = this.$ms;
+    var pUnit = prettyUnit(unit);
+
+    if (pUnit === 'milliseconds') {
+      base %= 1000;
+    } else if (pUnit === 'weeks') {
+      base = roundNumber(base / unitToMS[pUnit]);
+    } else {
+      base = this.$d[pUnit];
+    }
+
+    return base || 0; // a === 0 will be true on both 0 and -0
+  };
+
+  _proto.add = function add(input, unit, isSubtract) {
+    var another;
+
+    if (unit) {
+      another = input * unitToMS[prettyUnit(unit)];
+    } else if (isDuration(input)) {
+      another = input.$ms;
+    } else {
+      another = wrapper(input, this).$ms;
+    }
+
+    return wrapper(this.$ms + another * (isSubtract ? -1 : 1), this);
+  };
+
+  _proto.subtract = function subtract(input, unit) {
+    return this.add(input, unit, true);
+  };
+
+  _proto.locale = function locale(l) {
+    var that = this.clone();
+    that.$l = l;
+    return that;
+  };
+
+  _proto.clone = function clone() {
+    return wrapper(this.$ms, this);
+  };
+
+  _proto.humanize = function humanize(withSuffix) {
+    return $d().add(this.$ms, 'ms').locale(this.$l).fromNow(!withSuffix);
+  };
+
+  _proto.valueOf = function valueOf() {
+    return this.asMilliseconds();
+  };
+
+  _proto.milliseconds = function milliseconds() {
+    return this.get('milliseconds');
+  };
+
+  _proto.asMilliseconds = function asMilliseconds() {
+    return this.as('milliseconds');
+  };
+
+  _proto.seconds = function seconds() {
+    return this.get('seconds');
+  };
+
+  _proto.asSeconds = function asSeconds() {
+    return this.as('seconds');
+  };
+
+  _proto.minutes = function minutes() {
+    return this.get('minutes');
+  };
+
+  _proto.asMinutes = function asMinutes() {
+    return this.as('minutes');
+  };
+
+  _proto.hours = function hours() {
+    return this.get('hours');
+  };
+
+  _proto.asHours = function asHours() {
+    return this.as('hours');
+  };
+
+  _proto.days = function days() {
+    return this.get('days');
+  };
+
+  _proto.asDays = function asDays() {
+    return this.as('days');
+  };
+
+  _proto.weeks = function weeks() {
+    return this.get('weeks');
+  };
+
+  _proto.asWeeks = function asWeeks() {
+    return this.as('weeks');
+  };
+
+  _proto.months = function months() {
+    return this.get('months');
+  };
+
+  _proto.asMonths = function asMonths() {
+    return this.as('months');
+  };
+
+  _proto.years = function years() {
+    return this.get('years');
+  };
+
+  _proto.asYears = function asYears() {
+    return this.as('years');
+  };
+
+  return Duration;
+}();
+
+var manipulateDuration = function manipulateDuration(date, duration, k) {
+  return date.add(duration.years() * k, 'y').add(duration.months() * k, 'M').add(duration.days() * k, 'd').add(duration.hours() * k, 'h').add(duration.minutes() * k, 'm').add(duration.seconds() * k, 's').add(duration.milliseconds() * k, 'ms');
+};
+
+export default (function (option, Dayjs, dayjs) {
+  $d = dayjs;
+  $u = dayjs().$utils();
+
+  dayjs.duration = function (input, unit) {
+    var $l = dayjs.locale();
+    return wrapper(input, {
+      $l: $l
+    }, unit);
+  };
+
+  dayjs.isDuration = isDuration;
+  var oldAdd = Dayjs.prototype.add;
+  var oldSubtract = Dayjs.prototype.subtract;
+
+  Dayjs.prototype.add = function (value, unit) {
+    if (isDuration(value)) {
+      return manipulateDuration(this, value, 1);
+    }
+
+    return oldAdd.bind(this)(value, unit);
+  };
+
+  Dayjs.prototype.subtract = function (value, unit) {
+    if (isDuration(value)) {
+      return manipulateDuration(this, value, -1);
+    }
+
+    return oldSubtract.bind(this)(value, unit);
+  };
+});

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

@@ -0,0 +1,10 @@
+import { PluginFunc, ConfigType, OpUnitType } from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin
+
+declare module 'dayjs/esm' {
+  interface Dayjs {
+    isBetween(a: ConfigType, b: ConfigType, c?: OpUnitType | null, d?: '()' | '[]' | '[)' | '(]'): boolean
+  }
+}

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

@@ -0,0 +1,10 @@
+export default (function (o, c, d) {
+  c.prototype.isBetween = function (a, b, u, i) {
+    var dA = d(a);
+    var dB = d(b);
+    i = i || '()';
+    var dAi = i[0] === '(';
+    var dBi = i[1] === ')';
+    return (dAi ? this.isAfter(dA, u) : !this.isBefore(dA, u)) && (dBi ? this.isBefore(dB, u) : !this.isAfter(dB, u)) || (dAi ? this.isBefore(dA, u) : !this.isAfter(dA, u)) && (dBi ? this.isAfter(dB, u) : !this.isBefore(dB, u));
+  };
+});

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

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

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

@@ -0,0 +1,7 @@
+export default (function (o, c) {
+  var proto = c.prototype;
+
+  proto.isLeapYear = function () {
+    return this.$y % 4 === 0 && this.$y % 100 !== 0 || this.$y % 400 === 0;
+  };
+});

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

@@ -0,0 +1,10 @@
+import { PluginFunc } from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin
+
+declare module 'dayjs/esm' {
+
+  export function isMoment(input: any): boolean
+
+}

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

@@ -0,0 +1,5 @@
+export default (function (o, c, f) {
+  f.isMoment = function (input) {
+    return f.isDayjs(input);
+  };
+});

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

@@ -0,0 +1,10 @@
+import { PluginFunc, ConfigType, OpUnitType } from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin
+
+declare module 'dayjs/esm' {
+  interface Dayjs {
+    isSameOrAfter(date?: ConfigType, unit?: OpUnitType): boolean
+  }
+}

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

@@ -0,0 +1,5 @@
+export default (function (o, c) {
+  c.prototype.isSameOrAfter = function (that, units) {
+    return this.isSame(that, units) || this.isAfter(that, units);
+  };
+});

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

@@ -0,0 +1,10 @@
+import { PluginFunc, ConfigType, OpUnitType } from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin
+
+declare module 'dayjs/esm' {
+  interface Dayjs {
+    isSameOrBefore(date?: ConfigType, unit?: OpUnitType): boolean
+  }
+}

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

@@ -0,0 +1,5 @@
+export default (function (o, c) {
+  c.prototype.isSameOrBefore = function (that, units) {
+    return this.isSame(that, units) || this.isBefore(that, units);
+  };
+});

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

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

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

@@ -0,0 +1,9 @@
+export default (function (o, c, d) {
+  var proto = c.prototype;
+
+  proto.isToday = function () {
+    var comparisonTemplate = 'YYYY-MM-DD';
+    var now = d();
+    return this.format(comparisonTemplate) === now.format(comparisonTemplate);
+  };
+});

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

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

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

@@ -0,0 +1,9 @@
+export default (function (o, c, d) {
+  var proto = c.prototype;
+
+  proto.isTomorrow = function () {
+    var comparisonTemplate = 'YYYY-MM-DD';
+    var tomorrow = d().add(1, 'day');
+    return this.format(comparisonTemplate) === tomorrow.format(comparisonTemplate);
+  };
+});

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

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

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

@@ -0,0 +1,9 @@
+export default (function (o, c, d) {
+  var proto = c.prototype;
+
+  proto.isYesterday = function () {
+    var comparisonTemplate = 'YYYY-MM-DD';
+    var yesterday = d().subtract(1, 'day');
+    return this.format(comparisonTemplate) === yesterday.format(comparisonTemplate);
+  };
+});

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

@@ -0,0 +1,27 @@
+import { PluginFunc, OpUnitType, ConfigType } from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin
+
+type ISOUnitType = OpUnitType | 'isoWeek';
+
+declare module 'dayjs/esm' {
+  interface Dayjs {
+    isoWeekYear(): number
+    isoWeek(): number
+    isoWeek(value: number): Dayjs
+
+    isoWeekday(): number
+    isoWeekday(value: number): Dayjs
+
+    startOf(unit: ISOUnitType): Dayjs
+
+    endOf(unit: ISOUnitType): Dayjs
+
+    isSame(date?: ConfigType, unit?: ISOUnitType): boolean
+
+    isBefore(date?: ConfigType, unit?: ISOUnitType): boolean
+
+    isAfter(date?: ConfigType, unit?: ISOUnitType): boolean
+  }
+}

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

@@ -0,0 +1,57 @@
+import { D, W, Y } from '../../constant';
+var isoWeekPrettyUnit = 'isoweek';
+export default (function (o, c, d) {
+  var getYearFirstThursday = function getYearFirstThursday(year, isUtc) {
+    var yearFirstDay = (isUtc ? d.utc : d)().year(year).startOf(Y);
+    var addDiffDays = 4 - yearFirstDay.isoWeekday();
+
+    if (yearFirstDay.isoWeekday() > 4) {
+      addDiffDays += 7;
+    }
+
+    return yearFirstDay.add(addDiffDays, D);
+  };
+
+  var getCurrentWeekThursday = function getCurrentWeekThursday(ins) {
+    return ins.add(4 - ins.isoWeekday(), D);
+  };
+
+  var proto = c.prototype;
+
+  proto.isoWeekYear = function () {
+    var nowWeekThursday = getCurrentWeekThursday(this);
+    return nowWeekThursday.year();
+  };
+
+  proto.isoWeek = function (week) {
+    if (!this.$utils().u(week)) {
+      return this.add((week - this.isoWeek()) * 7, D);
+    }
+
+    var nowWeekThursday = getCurrentWeekThursday(this);
+    var diffWeekThursday = getYearFirstThursday(this.isoWeekYear(), this.$u);
+    return nowWeekThursday.diff(diffWeekThursday, W) + 1;
+  };
+
+  proto.isoWeekday = function (week) {
+    if (!this.$utils().u(week)) {
+      return this.day(this.day() % 7 ? week : week - 7);
+    }
+
+    return this.day() || 7;
+  };
+
+  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 === isoWeekPrettyUnit) {
+      return isStartOf ? this.date(this.date() - (this.isoWeekday() - 1)).startOf('day') : this.date(this.date() - 1 - (this.isoWeekday() - 1) + 7).endOf('day');
+    }
+
+    return oldStartOf.bind(this)(units, startOf);
+  };
+});

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

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

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

@@ -0,0 +1,15 @@
+export default (function (o, c) {
+  var proto = c.prototype;
+
+  proto.isoWeeksInYear = function () {
+    var isLeapYear = this.isLeapYear();
+    var last = this.endOf('y');
+    var day = last.day();
+
+    if (day === 4 || isLeapYear && day === 5) {
+      return 53;
+    }
+
+    return 52;
+  };
+});

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

@@ -0,0 +1,44 @@
+import { PluginFunc } from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin
+
+declare module 'dayjs/esm' {
+  type WeekdayNames = [string, string, string, string, string, string, string];
+  type MonthNames = [string, string, string, string, string, string, string, string, string, string, string, string];
+
+  interface InstanceLocaleDataReturn {
+    firstDayOfWeek(): number;
+    weekdays(instance?: Dayjs): WeekdayNames;
+    weekdaysShort(instance?: Dayjs): WeekdayNames;
+    weekdaysMin(instance?: Dayjs): WeekdayNames;
+    months(instance?: Dayjs): MonthNames;
+    monthsShort(instance?: Dayjs): MonthNames;
+    longDateFormat(format: string): string;
+    meridiem(hour?: number, minute?: number, isLower?: boolean): string;
+    ordinal(n: number): string
+  }
+
+  interface GlobalLocaleDataReturn {
+    firstDayOfWeek(): number;
+    weekdays(): WeekdayNames;
+    weekdaysShort(): WeekdayNames;
+    weekdaysMin(): WeekdayNames;
+    months(): MonthNames;
+    monthsShort(): MonthNames;
+    longDateFormat(format: string): string;
+    meridiem(hour?: number, minute?: number, isLower?: boolean): string;
+    ordinal(n: number): string
+  }
+
+  interface Dayjs {
+    localeData(): InstanceLocaleDataReturn;
+  }
+
+  export function weekdays(localOrder?: boolean): WeekdayNames;
+  export function weekdaysShort(localOrder?: boolean): WeekdayNames;
+  export function weekdaysMin(localOrder?: boolean): WeekdayNames;
+  export function monthsShort(): MonthNames;
+  export function months(): MonthNames;
+  export function localeData(): GlobalLocaleDataReturn;
+}