@react-fabric/date 1.0.0-beta.6 → 1.0.0-beta.60

package/dist/cjs/hijri/HijriDate.js

@@ -0,0 +1,531 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _typeof = require('@babel/runtime/helpers/typeof');
+var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
+var _createClass = require('@babel/runtime/helpers/createClass');
+var DateConverter = require('./DateConverter.js');
+var initializer = require('./initializer.js');
+var FormatDate = require('./FormatDate.js');
+var locales = require('./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__ = DateConverter.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 || DateConverter.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__ = DateConverter.HijriToGreg(this);
+      return this;
+    }
+
+    /**
+     * TODO
+     */
+  }, {
+    key: "toGregorian",
+    value: function toGregorian() {
+      return this.__proxy__;
+    }
+
+    /**
+     * TODO
+     */
+  }, {
+    key: "format",
+    value: function format(mask, options) {
+      return FormatDate.default.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: locales.ar,
+  en: locales.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'];
+
+exports.dateProps = dateProps;
+exports.default = HijriDate;

package/dist/cjs/hijri/StringDateParser.js

@@ -0,0 +1,74 @@
+'use strict';
+
+var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
+var _createClass = require('@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;
+    }
+  }]);
+}();
+
+module.exports = StringDateParser;