@react-fabric/date 1.0.0-beta.9 → 1.0.1

package/dist/esm/hijri/FormatDate.js

@@ -0,0 +1,113 @@
+'use client';
+
+import HijriDate from './HijriDate.js';
+
+var dateFormat = function () {
+  var token = /P{1,4}|p{1,4}|d{1,2}|e{3,6}|M{1,4}|yy(?:yy)?|([Hhms])\1?|[a]{1,4}|[LloSZ]|('at')|"[^"]*"|'[^']*'/g,
+    pad = function pad(val, len) {
+      val = String(val);
+      len = len || 2;
+      while (val.length < len) val = "0" + val;
+      return val;
+    };
+
+  // Regexes and supporting functions are cached through closure
+  return function (date, mask) {
+    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+      utc: false
+    };
+    var locales = HijriDate.locales,
+      defaultLocale = HijriDate.defaultLocale;
+    options.locale = options.locale || defaultLocale;
+    if (!locales[options.locale]) {
+      throw new Error("Locale ".concat(options.locale, " is not supported yet .\n          Please, try to extend \"HijriDate.locales\" :\n             i.e: HijriDate.locales.").concat(options.locale, " = {dayNames:[..14 items..], monthNames:[..24 items..]}\n        "));
+    }
+    // You can't provide utc if you skip other args (use the "UTC:" mask prefix)
+    if (arguments.length == 1 && Object.prototype.toString.call(date) == "[object String]" && !/\d/.test(date)) {
+      mask = date;
+      date = undefined;
+    }
+    mask = String(masks[mask] || mask || masks["default"]);
+
+    // Allow setting the utc argument via the mask
+    if (mask.slice(0, 4) == "UTC:") {
+      mask = mask.slice(4);
+      options.utc = true;
+    }
+    var _ = options.utc ? "getUTC" : "get",
+      d = date[_ + "Date"](),
+      D = date[_ + "Day"](),
+      M = date[_ + "Month"](),
+      mIndex = date[_ + "MonthIndex"](),
+      y = date[_ + "FullYear"](),
+      H = date[_ + "Hours"](),
+      m = date[_ + "Minutes"](),
+      s = date[_ + "Seconds"](),
+      L = date[_ + "Milliseconds"](),
+      o = options.utc ? 0 : date.getTimezoneOffset(),
+      flags = {
+        d: d,
+        dd: pad(d),
+        ddd: locales[options.locale].dayNames[D === 7 ? 0 : D + 1],
+        dddd: locales[options.locale].dayNames[(D === 7 ? 0 : D + 1) + 7],
+        ee: locales[options.locale].dayNames[D],
+        eee: locales[options.locale].dayNames[D + 7],
+        eeee: locales[options.locale].dayNames[D + 14],
+        eeeeee: locales[options.locale].dayNames[D],
+        M: M,
+        MM: pad(M),
+        MMM: locales[options.locale].monthNames[mIndex],
+        MMMM: locales[options.locale].monthNames[mIndex + 12],
+        yy: String(y).slice(2),
+        yyyy: y,
+        h: H % 12 || 12,
+        hh: pad(H % 12 || 12),
+        H: H,
+        HH: pad(H),
+        m: m,
+        mm: pad(m),
+        s: s,
+        ss: pad(s),
+        l: pad(L, 3),
+        L: pad(L > 99 ? Math.round(L / 10) : L),
+        a: H < 12 ? locales[options.locale].am : locales[options.locale].pm,
+        aa: H < 12 ? locales[options.locale].am : locales[options.locale].pm,
+        aaa: H < 12 ? locales[options.locale].am : locales[options.locale].pm,
+        aaaa: H < 12 ? locales[options.locale].am : locales[options.locale].pm,
+        aaaaa: H < 12 ? locales[options.locale].am : locales[options.locale].pm,
+        "'at'": locales[options.locale].separator,
+        t: H < 12 ? "a" : "p",
+        tt: H < 12 ? "am" : "pm",
+        T: H < 12 ? "A" : "P",
+        TT: H < 12 ? "AM" : "PM",
+        //  Z: options.utc ? "UTC" : (String(date).match(timezone) || [""]).pop().replace(timezoneClip, ""),
+        o: (o > 0 ? "-" : "+") + pad(Math.floor(Math.abs(o) / 60) * 100 + Math.abs(o) % 60, 4),
+        S: ["th", "st", "nd", "rd"][d % 10 > 3 ? 0 : (d % 100 - d % 10 != 10) * d % 10]
+      };
+    return mask.replace(token, function ($0) {
+      if ($0 === "P") return "".concat(flags.d, "/").concat(flags.M, "/").concat(flags.yyyy, " ");
+      if ($0.startsWith("PP")) return "".concat(flags.MMM, " ").concat(flags.dd, ", ").concat(flags.yyyy, " ");
+      if ($0 === "p") return "".concat(flags.h, ":").concat(flags.m, " ").concat(flags.a);
+      if ($0.startsWith("pp")) return "".concat(flags.hh, ":").concat(flags.mm, ":").concat(flags.ss, " ").concat(flags.a);
+      return $0 in flags ? flags[$0] : $0.slice(1, $0.length - 1);
+    });
+  };
+}();
+
+// Some common format strings
+var masks = {
+  "default": "ddd MMM dd yyyy HH:mm:ss",
+  shortDate: "M/d/yy",
+  mediumDate: "MMM d, yyyy",
+  longDate: "MMMM d, yyyy",
+  fullDate: "dddd, MMMM d, yyyy",
+  shortTime: "h:mm TT",
+  mediumTime: "h:mm:ss TT",
+  longTime: "h:mm:ss TT Z",
+  isoDate: "yyyy-MM-dd",
+  isoTime: "HH:mm:ss",
+  isoDateTime: "yyyy-MM-dd'T'HH:mm:ss",
+  isoUtcDateTime: "UTC:yyyy-MM-dd'T'HH:mm:ss'Z'"
+};
+
+export { dateFormat as default, masks };

package/dist/esm/hijri/HijriDate.js

@@ -0,0 +1,528 @@
+'use client';
+
+import _typeof from '@babel/runtime/helpers/typeof';
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import { HijriToGreg, weekDay } from './DateConverter.js';
+import Initializer from './initializer.js';
+import dateFormat from './FormatDate.js';
+import { en, ar } from './locales.js';
+
+/**
+  The class which handles Hijri 🌙 instances
+
+  @example  new HijriDate(); //now
+            new HijriDate(1438, 12, 10) ; // يوم عيد الأضحى لسنة ١٤٣٨
+            new HijriDate(1438,7, 20, 18, 50, 44, 333); //  Monday Rajab 20 1438 18:50:44
+            new HijriDate({year:1355, hours:17}); // Tue Muharram 01 1355 17:00:00
+            new HijriDate(1484408713014);
+
+
+            new HijriDate().toGregorian(); //  === new Date();
+            new Date().toHijri(); //  === new HijriDate();
+ */
+var HijriDate = /*#__PURE__*/function () {
+  /**
+   *
+   * @param {number} time numeric value of the specified date as the number of milliseconds since Shawwal 23, 1389, 00:00:00 UTC (January 1, 1970, 00:00:00 UTC)
+   * @example new HijriDate(1435454346342) // Sunday Ramadan 12 1436 04:19:06
+   */
+
+  /**
+   * @param {number} year the hijri year .
+   * @param {number} month  [1, 12] range .
+   * @param {number} [date=1] the date of the month🌔 ∈ {1, 30} .
+   * @param {number} [hours=0] ⏰ ∈ {0, 23} .
+   * @param {number} [minutes=0] 🕔 ∈ {0,59} .
+   * @param {number} [seconds=0] 🕰 ∈ {0,59} .
+   * @param {number} [milliseconds 0] 🕰 ∈ {0,999} .
+   *
+   * @example  new HijriDate(1450, 3) ; //Sun Rabee1 01 1450 00:00:00
+               new HijriDate(1450, 3, 5) ; //Thu Rabee1 05 1450 00:00:00
+               new HijriDate(1450, 3, 5, 17) ; //Thu Rabee1 05 1450 17:00:00
+               new HijriDate(1450, 3, 5, 16, 44) ; //Thu Rabee1 05 1450 16:44:00
+               new HijriDate(1450, 3, 5, 16, 44, 58) ; //Thu Rabee1 05 1450 16:44:58
+   */
+
+  /**
+   * @param {string} date stringified date
+   * @param {string} [format = 'yyyy/mm/dd'] a compatible format with the date passed as string in the 1ˢᵗ argument.
+   * @example    new HijriDate('10-09-1538', 'dd-mm-yyyy'); // Thu Rmdn 10 1538 00:00:00
+                 new HijriDate('100 years since 04-1348','100 years since mm-yyyy' ); // Wed Rab2 01 1338 00:00:00
+   */
+  /**
+  * @param {Object} dateProps literal object contains date properties .
+  * @param {number} dateProps.year  the year is required .
+  * @param {number} [dateProps.month = 1]  [1, 12] range .
+  * @param {number} [dateProps.date = 1] the date of the month🌔 ∈ {1, 30} .
+  * @param {number} [dateProps.hours = 0] ⏰ ∈ {0, 23} .
+  * @param {number} [dateProps.minutes = 0] 🕔 ∈ {0,59} .
+  * @param {number} [dateProps.seconds = 0] 🕰 ∈ {0,59} .
+  * @param {number} [dateProps.milliseconds = 0] 🕰 ∈ {0,999} .
+  *
+  * @example    new HijriDate({year: 1430, minutes: 54}) // 01-01-1430 00:54:00
+                new HijriDate({year: 1504, hours: 17, seconds:44}) // 01-01-1504 17:00:44
+   */
+  function HijriDate() {
+    _classCallCheck(this, HijriDate);
+    return this.init.apply(this, arguments);
+  }
+  return _createClass(HijriDate, [{
+    key: "init",
+    value: function init() {
+      var _this = this;
+      var props = {};
+      if (!arguments.length) {
+        props = Initializer.initDefault();
+      } else {
+        try {
+          var methodNameSuffix = Array.from(arguments).map(function (arg) {
+            return _typeof(arg);
+          }).join('_');
+          props = Initializer['init_' + methodNameSuffix].apply(Initializer, arguments);
+        } catch (e) {
+          throw new TypeError(hijriTypeErrorMessage + '\n--- Details:\n' + e);
+        }
+      }
+      Object.keys(props).forEach(function (prop) {
+        _this['_' + prop] = props[prop];
+      });
+      this.__proxy__ = HijriToGreg(this);
+      this.initDayOfWeek();
+      return this;
+    }
+  }, {
+    key: "initDayOfWeek",
+    value: function initDayOfWeek() {
+      if (!this.__proxy__) return;
+      this._day = this._day || this.__proxy__.getDay();
+      this._dayName = this._dayName || weekDay(this._day);
+    }
+    /**
+     * Get the year
+     * @returns {number} the year
+     */
+  }, {
+    key: "year",
+    get: function get() {
+      return this._year;
+    }
+
+    /**
+     * Set the year
+     * @param {number} newYear year modifier of the instance.
+     * @returns {undefined} nothing
+     *
+     * @example   const d1 = new HijriDate(1399, 10, 25);
+                  d1.year += 2;
+                  assertEqual(d1.year === 1401);
+     */,
+    set: function set(newYear) {
+      this._year = newYear;
+      this.updateProxy();
+    }
+  }, {
+    key: "month",
+    get: function get() {
+      return this._month;
+    },
+    set: function set(newMonth) {
+      this._month = newMonth;
+      this.updateProxy();
+    }
+  }, {
+    key: "date",
+    get: function get() {
+      return this._date;
+    },
+    set: function set(newDate) {
+      this._date = newDate;
+      this.updateProxy();
+    }
+    //---time getters and setters
+  }, {
+    key: "time",
+    get: function get() {
+      return this.__proxy__.getTime();
+    },
+    set: function set(newTime) {
+      var _this2 = this;
+      var props = Initializer.init_number(newTime);
+      Object.keys(props).forEach(function (prop) {
+        _this2['_' + prop] = props[prop];
+      });
+      this.__proxy__ = new Date(newTime);
+    }
+  }, {
+    key: "hours",
+    get: function get() {
+      return this._hours || 0;
+    },
+    set: function set(hours) {
+      this._hours = hours;
+      this.updateProxy();
+    }
+  }, {
+    key: "minutes",
+    get: function get() {
+      return this._minutes || 0;
+    },
+    set: function set(minutes) {
+      this._minutes = minutes;
+      this.updateProxy();
+    }
+  }, {
+    key: "seconds",
+    get: function get() {
+      return this._seconds || 0;
+    },
+    set: function set(seconds) {
+      this._seconds = seconds;
+      this.updateProxy();
+    }
+  }, {
+    key: "milliseconds",
+    get: function get() {
+      return this._milliseconds || 0;
+    },
+    set: function set(milliseconds) {
+      this._milliseconds = milliseconds;
+      this.updateProxy();
+    }
+  }, {
+    key: "timezoneOffset",
+    get: function get() {
+      return this.__proxy__.getTimezoneOffset();
+    }
+  }, {
+    key: "day",
+    get: function get() {
+      return this._day;
+    }
+  }, {
+    key: "dayName",
+    get: function get() {
+      return this._dayName;
+    }
+  }, {
+    key: "getFullYear",
+    value: function getFullYear() {
+      return this.year;
+    }
+  }, {
+    key: "getMonthIndex",
+    value: function getMonthIndex() {
+      return this.month - 1;
+    }
+  }, {
+    key: "getMonth",
+    value: function getMonth() {
+      return this.month;
+    }
+  }, {
+    key: "getDate",
+    value: function getDate() {
+      return this.date;
+    }
+  }, {
+    key: "getDay",
+    value: function getDay() {
+      return this.day;
+    }
+  }, {
+    key: "getHours",
+    value: function getHours() {
+      return this.hours;
+    }
+  }, {
+    key: "getMinutes",
+    value: function getMinutes() {
+      return this.minutes;
+    }
+  }, {
+    key: "getSeconds",
+    value: function getSeconds() {
+      return this.seconds;
+    }
+  }, {
+    key: "getMilliseconds",
+    value: function getMilliseconds() {
+      return this.milliseconds;
+    }
+  }, {
+    key: "getTime",
+    value: function getTime() {
+      return this.time;
+    }
+  }, {
+    key: "getTimezoneOffset",
+    value: function getTimezoneOffset() {
+      return this.timezoneOffset;
+    }
+
+    /**
+     * This method adds 1 day (24 hours) to the instance.
+     * @returns {HijriDate} the instance itself after adding 1 day.
+     */
+  }, {
+    key: "addDay",
+    value: function addDay() {
+      return this.addHours(24);
+    }
+    /**
+     * This method adds n day(s) to the instance.
+     * @param {number} days number of days to add .
+     * @returns {HijriDate} the instance itself after adding n day(s).
+     */
+  }, {
+    key: "addDays",
+    value: function addDays(days) {
+      var _this3 = this;
+      if (typeof days === 'number') Array.from({
+        length: days
+      }, function (v, k) {
+        return k + 1;
+      }).forEach(function (i) {
+        return _this3.addDay();
+      });
+      return this;
+    }
+    /**
+     * TODO
+     */
+  }, {
+    key: "addHours",
+    value: function addHours(n) {
+      return this.addMinutes(n * 60);
+    }
+
+    /**
+     * TODO
+     */
+  }, {
+    key: "addMinutes",
+    value: function addMinutes(n) {
+      return this.addSeconds(n * 60);
+    }
+
+    /**
+     * TODO
+     */
+  }, {
+    key: "addSeconds",
+    value: function addSeconds(n) {
+      return this.addMilliseconds(1000 * n);
+    }
+
+    /**
+     * TODO
+     */
+  }, {
+    key: "addMilliseconds",
+    value: function addMilliseconds(n) {
+      this.time += n;
+      return this;
+    }
+
+    /**
+     * TODO
+     */
+  }, {
+    key: "subtractDays",
+    value: function subtractDays(days) {
+      var _this4 = this;
+      Array.from({
+        length: days
+      }, function (v, k) {
+        return k + 1;
+      }).forEach(function (i) {
+        return _this4.subtractDay();
+      });
+      return this;
+    }
+
+    /**
+     * TODO
+     */
+  }, {
+    key: "subtractDay",
+    value: function subtractDay() {
+      return this.subtractHours(24);
+    }
+
+    /**
+     * TODO
+     */
+  }, {
+    key: "subtractHours",
+    value: function subtractHours(n) {
+      return this.subtractMinutes(n * 60);
+    }
+
+    /**
+     * TODO
+     */
+  }, {
+    key: "subtractMinutes",
+    value: function subtractMinutes(n) {
+      return this.subtractSeconds(n * 60);
+    }
+
+    /**
+     * TODO
+     */
+  }, {
+    key: "subtractSeconds",
+    value: function subtractSeconds(n) {
+      return this.subtractMilliseconds(1000 * n);
+    }
+
+    /**
+     * TODO
+     */
+  }, {
+    key: "subtractMilliseconds",
+    value: function subtractMilliseconds(n) {
+      return this.addMilliseconds(-n);
+    }
+
+    /**
+     * TODO
+     */
+  }, {
+    key: "updateProxy",
+    value: function updateProxy() {
+      this.__proxy__ = HijriToGreg(this);
+      return this;
+    }
+
+    /**
+     * TODO
+     */
+  }, {
+    key: "toGregorian",
+    value: function toGregorian() {
+      return this.__proxy__;
+    }
+
+    /**
+     * TODO
+     */
+  }, {
+    key: "format",
+    value: function format(mask, options) {
+      return dateFormat.apply(void 0, [this].concat(Array.prototype.slice.call(arguments)));
+    }
+
+    /**
+     * TODO
+     */
+  }, {
+    key: "ignoreTime",
+    value: function ignoreTime() {
+      this.hours = 0;
+      this.minutes = 0;
+      this.seconds = 0;
+      this.milliseconds = 0;
+      this.updateProxy();
+      return this;
+    }
+
+    /**
+     * TODO
+     */
+  }, {
+    key: "clone",
+    value: function clone() {
+      return new HijriDate(this.time);
+    }
+
+    /**
+     * TODO
+     */
+  }, {
+    key: "is",
+    value: function is() {
+      var _arguments = arguments,
+        _this5 = this;
+      if (!arguments.length) throw new Error("function cannot be called without arguments");
+      if (arguments.length === 1 && _typeof(arguments[0]) === 'object' && Object.keys(arguments[0]).length) return Object.keys(arguments[0]).every(function (prop) {
+        return parseInt(_arguments[0][prop]) === parseInt(_this5[prop]);
+      });
+      return Array.from(arguments).every(function (arg, i) {
+        return arg === _this5[dateProps[i]];
+      });
+    }
+
+    /**
+     * TODO
+     */
+  }, {
+    key: "isToday",
+    value: function isToday() {
+      return HijriDate.today().time == this.clone().ignoreTime().time;
+    }
+
+    /**
+     * TODO
+     */
+  }, {
+    key: "isYesterday",
+    value: function isYesterday() {
+      return HijriDate.yesterday().time == this.clone().ignoreTime().time;
+    }
+
+    /**
+     * TODO
+     */
+  }, {
+    key: "isTomorrow",
+    value: function isTomorrow() {
+      return HijriDate.tomorrow().time == this.clone().ignoreTime().time;
+    }
+  }, {
+    key: "valueOf",
+    value: function valueOf() {
+      return this.getTime();
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return this.format('default');
+    }
+  }], [{
+    key: "now",
+    value: function now() {
+      return Date.now();
+    }
+  }, {
+    key: "today",
+    value: function today() {
+      return new HijriDate().ignoreTime();
+    }
+  }, {
+    key: "yesterday",
+    value: function yesterday() {
+      return this.today().subtractDay();
+    }
+  }, {
+    key: "tomorrow",
+    value: function tomorrow() {
+      return this.today().addDay();
+    }
+
+    ////TODO
+    // static addDay() {
+    //
+    // }
+  }]);
+}();
+HijriDate.locales = {
+  ar: ar,
+  en: en
+};
+HijriDate.defaultLocale = 'ar';
+var hijriTypeErrorMessage = "\n  Wrong call of constructor !\n  Please, try to use of the following constructors:\n    \u21E2 new HijriDate() ; //current date\n      or\n    \u21E2 new HijriDate(year, month, day [, hour][, minutes][, seconds][, milliseconds]);\n         .i.e: new HijriDate(1438, 12, 23)\n      or\n    \u21E2 new HijriDate(date[, format])\n         .i.e: new HijriDate('1438-12-23', 'yyyy-mm-dd')\n  ";
+var dateProps = ['year', 'month', 'date', 'hours', 'minutes', 'seconds', 'milliseconds'];
+
+export { dateProps, HijriDate as default };

package/dist/esm/hijri/StringDateParser.js

@@ -0,0 +1,74 @@
+'use client';
+
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+
+var StringDateParser = /*#__PURE__*/function () {
+  function StringDateParser() {
+    _classCallCheck(this, StringDateParser);
+  }
+  return _createClass(StringDateParser, null, [{
+    key: "extract",
+    value: function extract(string, format, formatChunk) {
+      var ignoreCase = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+      var targetFormat = ignoreCase ? format.toLowerCase() : format;
+      if (targetFormat.includes(formatChunk)) {
+        return parseInt(string.substr(targetFormat.indexOf(formatChunk), formatChunk.length));
+      }
+    }
+  }, {
+    key: "extractYear",
+    value: function extractYear(dateString, format) {
+      var year = this.extract.apply(this, Array.prototype.slice.call(arguments).concat(['yyyy']));
+      if (!year) {
+        year = this.extract.apply(this, Array.prototype.slice.call(arguments).concat(['yy']));
+        if (year) year = Number('14' + year);
+      }
+      return year;
+    }
+  }, {
+    key: "extractMonth",
+    value: function extractMonth(dateString, format) {
+      var month = this.extract.apply(this, Array.prototype.slice.call(arguments).concat(['mm', false]));
+      if (month) return month;
+      return 1;
+    }
+  }, {
+    key: "extractDate",
+    value: function extractDate(dateString, format) {
+      var date = this.extract.apply(this, Array.prototype.slice.call(arguments).concat(['dd', false]));
+      if (date) return date;
+      return 1;
+    }
+  }, {
+    key: "extractHours",
+    value: function extractHours(dateString, format) {
+      var hours = this.extract.apply(this, Array.prototype.slice.call(arguments).concat(['hh']));
+      if (hours) return hours;
+      return 0;
+    }
+  }, {
+    key: "extractMinutes",
+    value: function extractMinutes(dateString, format) {
+      var minutes = this.extract.apply(this, Array.prototype.slice.call(arguments).concat(['MM', false]));
+      if (minutes) return minutes;
+      return 0;
+    }
+  }, {
+    key: "extractSeconds",
+    value: function extractSeconds(dateString, format) {
+      var seconds = this.extract.apply(this, Array.prototype.slice.call(arguments).concat(['ss', false]));
+      if (seconds) return seconds;
+      return 0;
+    }
+  }, {
+    key: "extractMilliseconds",
+    value: function extractMilliseconds(dateString, format) {
+      var milliseconds = this.extract.apply(this, Array.prototype.slice.call(arguments).concat(['SS', false]));
+      if (milliseconds) return milliseconds;
+      return 0;
+    }
+  }]);
+}();
+
+export { StringDateParser as default };