/common.date_utils.js
Secret
Created Feb 16, 2013
Date API wrapper around Moment.js
| /*jshint asi: false, bitwise: true, boss: false, curly: true, eqeqeq: true, eqnull: false, evil: false, forin: false, immed: true, laxbreak: false, newcap: true, noarg: true, noempty: true, nonew: false, nomen: false, onevar: true, plusplus: false, regexp: false, undef: true, sub: false, strict: false, white: false */ | |
| /*jshint browser: true, maxerr: 50, passfail: false */ | |
| /*global createModule: false */ | |
| /** | |
| * A set of utilities for working with Moments and Durations, which are | |
| * sugar wrappers around Date and ms, respectively. | |
| * | |
| * This module calls out to vendor.moment, which provides the logic for working | |
| * with dates and durations, but has a poor API. This wraps that API to be more | |
| * to Gilt's library standards. | |
| * | |
| * @module common.date_utils | |
| */ | |
| createModule( | |
| 'common.date_utils', | |
| [ | |
| 'vendor.moment' | |
| ], | |
| function (moment) { | |
| var | |
| Moment, | |
| Duration, | |
| addDurations, | |
| subtractDurations, | |
| diffDurations, | |
| addToMoment, | |
| subtractFromMoment, | |
| diffMoments, | |
| utcFilter, | |
| mutateDuration, | |
| makeMoment, | |
| makeDuration; | |
| /** | |
| * Constructs a wrapper around a fixed "moment" in time. | |
| * | |
| * @constructor Moment | |
| * @public | |
| * | |
| * @param {Mixed} [d] Any of: 1. ms from the epoch; 2. Date object; 3. A Date object parseable string; 4. subset of ISO-8601 String; 5. nothing | |
| * | |
| * @example | |
| * new Moment(); | |
| * new Moment(443768400000); | |
| * new Moment(new Date(443768400000)); | |
| * new Moment('Fri, 12 Oct 2012 19:15:56 UTC'); | |
| * new Moment('1984-01-24'); | |
| * new Moment('1984-01-24T00:00:00'); | |
| * new Moment('1984-01-24T00:00:00 Z-08:00'); | |
| */ | |
| Moment = function (d) { | |
| if (!d) { | |
| /* it is nothing */ | |
| this._moment = moment(); | |
| } else if (typeof d === 'number' || Object.prototype.toString.call(d) === '[object Date]') { | |
| /* it is a ms number or a date object */ | |
| this._moment = moment(d); | |
| } else if (typeof d === 'string' && d.match(/\d{4}\-\d{2}\-\d{2}(T{2}:{2}:{2})?([\s\w\-\:]+)?/)) { | |
| /* it is a string YYYY-MM-DDTHH:mm:ss z */ | |
| this._moment = moment(d); | |
| } else if (typeof d === 'string') { | |
| /* We'll try date parsing it as a last resort */ | |
| this._moment = moment(new Date(d)); | |
| } | |
| }; | |
| Moment.prototype = { | |
| /** | |
| * Returns a clone of a given Moment instance. | |
| * | |
| * @method clone | |
| * @public | |
| * | |
| * @return {Moment} A new Moment instance cloning the original | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * n = m.clone(); | |
| */ | |
| clone : function () { | |
| return new Moment(this.toDate().valueOf()); | |
| }, | |
| /** | |
| * Adds a Duration to the Moment instance. | |
| * | |
| * @method add | |
| * @public | |
| * | |
| * @param {Duration|Mixed} duration A Duration object to add, or something that can construct a Duration | |
| * | |
| * @return {Moment} The same Moment instance, adjusted with the added Duration | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.add(new Duration(1000)); // The moment is now 1 second in the future | |
| * m.add(1000); // The moment is now 1 second in the future | |
| */ | |
| add : function (duration) { | |
| duration = makeDuration(duration); | |
| this._moment.add(duration.getAsMilliseconds()); | |
| return this; | |
| }, | |
| /** | |
| * Subtracts a Duration from the Moment instance. | |
| * | |
| * @method subtract | |
| * @public | |
| * | |
| * @param {Duration|Mixed} duration A Duration object to subtract, or something that can construct a Duration | |
| * | |
| * @return {Moment} The same Moment instance, adjusted with the subtracted Duration | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.subtract(new Duration(1000)); // The moment is now 1 second in the past | |
| * m.subtract(1000); // The moment is now 1 second in the past | |
| */ | |
| subtract : function (duration) { | |
| duration = makeDuration(duration); | |
| this._moment.subtract(duration.getAsMilliseconds()); | |
| return this; | |
| }, | |
| /** | |
| * Converts the current Moment instance to its JS Date representation. | |
| * | |
| * @method toDate | |
| * @public | |
| * | |
| * @return {Date} The JS Date representation of this Moment instance | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.toDate(); // Date object for now | |
| */ | |
| toDate : function () { | |
| return new Date(this._moment.valueOf()); | |
| }, | |
| /** | |
| * The timezone offset of this Moment instance in minutes. | |
| * | |
| * @method getTimezoneOffset | |
| * @public | |
| * | |
| * @param {Object} [opts] Options hash | |
| * @param {Boolean} [opts.utc] Whether or not to return the timezone offset in UTC (which of course would be 0) | |
| * | |
| * @return {Number} The offset of this Moment's time in minutes, opposite negative symbol of the UTC offset (360 = '-06:00') | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.getTimezoneOffset(); // e.g. 360 (equal to -06:00) | |
| * m.getTimezoneOffset({ utc : true }); // 0 | |
| */ | |
| getTimezoneOffset : function (opts) { | |
| var that = this; | |
| return utcFilter(that._moment, opts, function () { | |
| return that._moment.zone(); | |
| }); | |
| }, | |
| /** | |
| * Whether or not this Moment instance is in daylight saving time. | |
| * | |
| * @method isDst | |
| * @public | |
| * | |
| * @param {Object} [opts] Options hash | |
| * @param {Boolean} [opts.utc] Whether or not to return the DST status in UTC (because UTC could bump it into a date outside the local date's DST) | |
| * | |
| * @return {Boolean} Whether this Moment instance is in daylight saving time | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.isDst(); // True, it's October 2 now! | |
| * m.isDst({ utc : true }); // Might push time to non-dst if converted to utc | |
| */ | |
| isDst : function (opts) { | |
| var that = this; | |
| return utcFilter(that._moment, opts, function () { | |
| return that._moment.isDST(); | |
| }); | |
| }, | |
| /** | |
| * Whether or not this Moment instance is in a leap year. | |
| * | |
| * @method isLeapYear | |
| * @public | |
| * | |
| * @param {Object} [opts] Options hash | |
| * @param {Boolean} [opts.utc] Whether or not to return the leap year status in UTC (because UTC could bump it into a different year) | |
| * | |
| * @return {Boolean} Whether this Moment instance is in a leap year | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.isLeapYear(); // True, it's 2012 now! | |
| * m.isLeapYear({ utc : true }); // Could push the time to a non-leap year | |
| */ | |
| isLeapYear : function (opts) { | |
| var that = this; | |
| return utcFilter(that._moment, opts, function () { | |
| return that._moment.isLeapYear(); | |
| }); | |
| }, | |
| /** | |
| * Gets the days in the current Moment instance's month. | |
| * | |
| * @method getDaysInMonth | |
| * @public | |
| * | |
| * @param {Object} [opts] Options hash | |
| * @param {Boolean} [opts.utc] Whether or not to return the days in this month in UTC (because UTC could bump it into a different month) | |
| * | |
| * @return {Number} The days of the month for this Moment instance | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.getDaysInMonth(); // 31, it's October now! | |
| * m.getDaysInMonth({ utc : true }); // Could bump to the next month | |
| */ | |
| getDaysInMonth : function (opts) { | |
| var that = this; | |
| return utcFilter(that._moment, opts, function () { | |
| return that._moment.daysInMonth(); | |
| }); | |
| }, | |
| /** | |
| * Returns the milliseconds (0-9999) of a given Moment instance (Not | |
| * passing through UTC filter because the result will not change). | |
| * | |
| * @method getMilliseconds | |
| * @public | |
| * | |
| * @return {Number} The milliseconds of this Moment instance | |
| * | |
| * @example | |
| * m = new Moment(1234567890); | |
| * m.getMilliseconds(); // 890 | |
| */ | |
| getMilliseconds : function () { | |
| return this._moment.milliseconds(); | |
| }, | |
| /** | |
| * Sets the milliseconds (0-9999) of a given Moment instance. | |
| * | |
| * @method setMilliseconds | |
| * @public | |
| * | |
| * @param {Number} ms The milliseconds (0-9999) to set | |
| * | |
| * @return {Moment} The Moment instance | |
| * | |
| * @example | |
| * m = new Moment(1234567890); | |
| * m.setMilliseconds(999); // 1234567999 | |
| */ | |
| setMilliseconds : function (ms) { | |
| this._moment.milliseconds(ms); | |
| return this; | |
| }, | |
| /** | |
| * Returns the seconds (0-59) of a given Moment instance (Not passing | |
| * through UTC filter because the result will not change). | |
| * | |
| * @method getSeconds | |
| * | |
| * @return {Number} The seconds of this Moment instance | |
| * | |
| * @example | |
| * m = new Moment('2012-10-02'); | |
| * m.getSeconds(); // 0 | |
| */ | |
| getSeconds : function () { | |
| return this._moment.seconds(); | |
| }, | |
| /** | |
| * Sets the seconds (0-59) of a given Moment instance. | |
| * | |
| * @method setSeconds | |
| * @public | |
| * | |
| * @param {Number} s The seconds (0-59) to set | |
| * | |
| * @return {Moment} The Moment instance | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.setSeconds(59); | |
| */ | |
| setSeconds : function (s) { | |
| this._moment.seconds(s); | |
| return this; | |
| }, | |
| /** | |
| * Returns the minutes (0-59) of a given Moment instance. Yes, UTC is | |
| * relevant in the case of Newfoundland and other off-by-half-hour | |
| * timezones. | |
| * | |
| * @method getMinutes | |
| * @public | |
| * | |
| * @param {Object} [opts] Options hash | |
| * @param {Boolean} [opts.utc] Whether or not to return the minutes in UTC | |
| * | |
| * @return {Number} The minutes of this Moment instance | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.getMinutes(); // 30, assume we are in Newfoundland | |
| * m.getMinutes({ utc : true }); // 0 | |
| */ | |
| getMinutes : function (opts) { | |
| var that = this; | |
| return utcFilter(that._moment, opts, function () { | |
| return that._moment.minutes(); | |
| }); | |
| }, | |
| /** | |
| * Sets the minutes (0-59) of a given Moment instance. | |
| * | |
| * @method setMinutes | |
| * @public | |
| * | |
| * @param {Number} m The minutes (0-59) to set | |
| * | |
| * @return {Moment} The Moment instance | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.setMinutes(59); | |
| */ | |
| setMinutes : function (m) { | |
| this._moment.minutes(m); | |
| return this; | |
| }, | |
| /** | |
| * Returns the time hour (0-23) of a given Moment instance. | |
| * | |
| * @method getHours | |
| * @public | |
| * | |
| * @param {Object} [opts] Options hash | |
| * @param {Boolean} [opts.utc] Whether or not to return the hours in UTC | |
| * | |
| * @return {Number} The hour (0-23) of this Moment instance | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.getHours(); | |
| * m.getHours({ utc : true }); | |
| */ | |
| getHours : function (opts) { | |
| var that = this; | |
| return utcFilter(that._moment, opts, function () { | |
| return that._moment.hours(); | |
| }); | |
| }, | |
| /** | |
| * Sets the hours (0-23) of a given Moment instance. | |
| * | |
| * @method setHours | |
| * @public | |
| * | |
| * @param {Number} h The hours (0-23) to set | |
| * | |
| * @return {Moment} The Moment instance | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.setHours(23); | |
| */ | |
| setHours : function (h) { | |
| this._moment.hours(h); | |
| return this; | |
| }, | |
| /** | |
| * Returns the day of the week (0-6) of a given Moment instance. | |
| * | |
| * @method getDay | |
| * @public | |
| * | |
| * @param {Object} [opts] Options hash | |
| * @param {Boolean} [opts.utc] Whether or not to return the day in UTC | |
| * | |
| * @return {Number} The day of the week (0-6) of this Moment instance | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.getDay(); // 0 through 6 | |
| * m.getDay({ utc : true }); // UTC can move it into a different day | |
| */ | |
| getDay : function (opts) { // Sunday 0, Saturday 6 | |
| var that = this; | |
| return utcFilter(that._moment, opts, function () { | |
| return that._moment.day(); | |
| }); | |
| }, | |
| /** | |
| * Returns the date (1-31) of a given Moment instance. | |
| * | |
| * @method getDate | |
| * @public | |
| * | |
| * @param {Object} [opts] Options hash | |
| * @param {Boolean} [opts.utc] Whether or not to return the date in UTC | |
| * | |
| * @return {Number} The date (1-31) of this Moment instance | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.getDate(); // 1 through 31 | |
| * m.getDate({ utc : true }); // UTC could move it into the next date | |
| */ | |
| getDate : function (opts) { | |
| var that = this; | |
| return utcFilter(that._moment, opts, function () { | |
| return that._moment.date(); | |
| }); | |
| }, | |
| /** | |
| * Sets the date (1-31) of a given Moment instance. Note that moment.js | |
| * will set Feb 31 to be Mar 2. We choose to allow this as a side effect | |
| * rather than suppressing this behavior, allowing setDate to work without | |
| * concerning itself with the end of the month. | |
| * | |
| * @method setDate | |
| * @public | |
| * | |
| * @param {Number} d The date (1-31) to set | |
| * | |
| * @return {Moment} The Moment instance | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.setDate(23); | |
| * m.setDate(29 + n); // In September, if n is 2, the new date will be October 1. | |
| */ | |
| setDate : function (d) { | |
| this._moment.date(d); | |
| return this; | |
| }, | |
| /** | |
| * Returns the month of a given Moment instance. | |
| * | |
| * @method getMonth | |
| * @public | |
| * | |
| * @param {Object} [opts] Options hash | |
| * @param {Boolean} [opts.utc] Whether or not to return the month in UTC | |
| * | |
| * @return {Number} The month of this Moment instance | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.getMonth(); // 0 through 11 | |
| * m.getMonth({ utc : true }); // UTC could move it to the next month | |
| */ | |
| getMonth : function (opts) { | |
| var that = this; | |
| return utcFilter(that._moment, opts, function () { | |
| return that._moment.month(); | |
| }); | |
| }, | |
| /** | |
| * Sets the month (0-11) of a given Moment instance. If the month is | |
| * greater than 11, the Moment will switch over to the next year, for | |
| * convenience and because moment.js has this behavior natively. | |
| * | |
| * @method setMonth | |
| * @public | |
| * | |
| * @param {Number} m The month (0-11) to set, or greater than 11 to roll over to the next year | |
| * | |
| * @return {Moment} The Moment instance | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.setMonth(0); | |
| * m.setMonth(11); | |
| */ | |
| setMonth : function (m) { | |
| this._moment.month(m); | |
| return this; | |
| }, | |
| /** | |
| * Returns the year of a given Moment instance. | |
| * | |
| * @method getYear | |
| * @public | |
| * | |
| * @param {Object} [opts] Options hash | |
| * @param {Boolean} [opts.utc] Whether or not to return the year in UTC | |
| * | |
| * @return {Number} The year of this Moment instance | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.getYear(); | |
| * m.getYear({ utc : true }); // UTC could move it to the next year | |
| */ | |
| getYear : function (opts) { | |
| var that = this; | |
| return utcFilter(that._moment, opts, function () { | |
| return that._moment.year(); | |
| }); | |
| }, | |
| /** | |
| * Sets the year of the current Moment instance. | |
| * | |
| * @method setYear | |
| * @public | |
| * | |
| * @param {Number} y A year to set | |
| * | |
| * @return {Moment} The Moment instance | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.setYear(1984); | |
| */ | |
| setYear : function (y) { | |
| this._moment.year(y); | |
| return this; | |
| }, | |
| /** | |
| * Sets the current Moment instance to the start of a time period. | |
| * | |
| * @method setToStartOf | |
| * @public | |
| * | |
| * @param {String} param Any of 'day', 'month', 'year', 'minute', 'second', 'hour' | |
| * | |
| * @return {Moment} The Moment instance | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.setToStartOf('year'); // first millisecond in year | |
| */ | |
| setToStartOf : function (param) { // 'day', 'month', 'year', etc | |
| this._moment.startOf(param); | |
| return this; | |
| }, | |
| /** | |
| * Sets the current Moment instance to the end of a time period. | |
| * | |
| * @method setToEndOf | |
| * @public | |
| * | |
| * @param {String} param Any of 'day', 'month', 'year', 'minute', 'second', 'hour' | |
| * | |
| * @return {Moment} The Moment instance | |
| * | |
| * @example | |
| * m = new Moment(); | |
| * m.setToEndOf('month'); // last millisecond in month | |
| */ | |
| setToEndOf : function (param) { // 'day', 'month', 'year' | |
| this._moment.endOf(param); | |
| return this; | |
| } | |
| }; | |
| /** | |
| * A wrapper around a length of time. Getters intentionally do not provide | |
| * weeks, since weeks and days overlap. If you need weeks, do the math | |
| * yourself. Also, you can construct a negative Duration with a number of ms, | |
| * but not with an ISO string. | |
| * | |
| * @constructor Duration | |
| * @public | |
| * | |
| * @param {Mixed} d Any of: 1. ms to wrap; 2. subset of ISO-8601 duration (but allowing spaces) | |
| * | |
| * @todo Optimize the regexes for matching durations. | |
| */ | |
| Duration = function (d) { | |
| var | |
| p, | |
| t, | |
| durationMatches = {}; | |
| if (typeof d === 'number') { | |
| /* It's a number, hopefully a number of milliseconds, because that's what we're assuming */ | |
| this._duration = moment.duration(d); | |
| } else if (typeof d === 'string' && d.match(/^P/)) { | |
| /* It's a string, hopefully iso P3Y6M4DT12H30M5S P 3Y 6M 4D T 12H 30M 5S */ | |
| d = d.split('T'); | |
| p = d[0].substring(1); /* can be empty string */ | |
| t = d[1] || ''; /* can be empty string */ | |
| durationMatches = { | |
| seconds : t.match(/(\d+)S/) || [], | |
| minutes : t.match(/(\d+)M/) || [], | |
| hours : t.match(/(\d+)H/) || [], | |
| days : p.match(/(\d+)D/) || [], | |
| months : p.match(/(\d+)M/) || [], | |
| years : p.match(/(\d+)Y/) || [] | |
| }; | |
| this._duration = moment.duration({ | |
| seconds : parseInt(durationMatches.seconds[1], 10) || 0, | |
| minutes : parseInt(durationMatches.minutes[1], 10) || 0, | |
| hours : parseInt(durationMatches.hours[1], 10) || 0, | |
| days : parseInt(durationMatches.days[1], 10) || 0, | |
| months : parseInt(durationMatches.months[1], 10) || 0, | |
| years : parseInt(durationMatches.years[1], 10) || 0 | |
| }); | |
| } | |
| }; | |
| Duration.prototype = { | |
| /** | |
| * Returns a clone of a given Duration instance. | |
| * | |
| * @method clone | |
| * @public | |
| * | |
| * @return {Duration} A new Duration instance cloning the original | |
| * | |
| * @example | |
| * d = new Duration(1000); dd = d.clone(); | |
| */ | |
| clone : function () { | |
| return new Duration(this.getAsMilliseconds()); | |
| }, | |
| /** | |
| * Adds a Duration to this Duration. | |
| * | |
| * @method add | |
| * @public | |
| * | |
| * @param {Duration|Mixed} duration A Duration to add to this one, or something that can construct a Duration | |
| * | |
| * @return {Duration} This Duration | |
| * | |
| * @example | |
| * d = new Duration(1000); d.add(new Duration(2000)); | |
| * d.getAsMilliseconds(); // 3000 | |
| * d.add('PT 2S'); | |
| * d.getAsMilliseconds(); // 5000 | |
| */ | |
| add : function (duration) { | |
| duration = makeDuration(duration); | |
| var ms = duration.getAsMilliseconds(); | |
| return mutateDuration(this, (this.getAsMilliseconds() + ms)); | |
| }, | |
| /** | |
| * Subtracts a Duration from this Duration. | |
| * | |
| * @method subtract | |
| * @public | |
| * | |
| * @param {Duration|Mixed} duration A Duration to subtract from this one, or something that can construct a Duration | |
| * | |
| * @return {Duration} This Duration | |
| * | |
| * @example | |
| * d = new Duration(2000); d.subtract(new Duration(1000)); | |
| * d.getAsMilliseconds(); // 1000 | |
| * d.subtract(500); | |
| * d.getAsMilliseconds(); // 500 | |
| */ | |
| subtract : function (duration) { | |
| duration = makeDuration(duration); | |
| var ms = duration.getAsMilliseconds(); | |
| return mutateDuration(this, (this.getAsMilliseconds() - ms)); | |
| }, | |
| /** | |
| * Returns the milliseconds (0-9999) of a given Duration instance. | |
| * | |
| * @method getMilliseconds | |
| * @public | |
| * | |
| * @return {Number} The milliseconds of this Duration instance | |
| * | |
| * @example | |
| * d = new Duration(1000); e = new Duration(1002); | |
| * d.getMilliseconds(); // 0 | |
| * e.getMilliseconds(); // 2 | |
| */ | |
| getMilliseconds : function () { | |
| return this._duration.milliseconds(); | |
| }, | |
| /** | |
| * Returns the given Duration instance expressed as milliseconds. | |
| * | |
| * @method getAsMilliseconds | |
| * @public | |
| * | |
| * @return {Number} This Duration instance in milliseconds | |
| * | |
| * @example | |
| * d = new Duration(1000); e = new Duration(1002); | |
| * d.getAsMilliseconds(); // 1000 | |
| * e.getAsMilliseconds(); // 1002 | |
| */ | |
| getAsMilliseconds : function () { | |
| return this._duration.asMilliseconds(); | |
| }, | |
| /** | |
| * Returns the seconds (0-59) of a given Duration instance. | |
| * | |
| * @method getSeconds | |
| * @public | |
| * | |
| * @return {Number} The seconds of this Duration instance | |
| * | |
| * @example | |
| * d = new Duration('PT3M 22S'); e = new Duration('PT1M'); | |
| * d.getSeconds(); // 22 | |
| * e.getSeconds(); // 0 | |
| */ | |
| getSeconds : function () { | |
| return this._duration.seconds(); | |
| }, | |
| /** | |
| * This Duration instance expressed as seconds. | |
| * | |
| * @method getAsSeconds | |
| * @public | |
| * | |
| * @return {Number} This Duration instance in seconds | |
| * | |
| * @example | |
| * d = new Duration('PT3M 22S'); e = new Duration('PT1M'); | |
| * d.getAsSeconds(); // 202 | |
| * e.getAsSeconds(); // 60 | |
| */ | |
| getAsSeconds : function () { | |
| return this._duration.asSeconds(); | |
| }, | |
| /** | |
| * Returns the minutes (0-59) of a given Duration instance. | |
| * | |
| * @method getMinutes | |
| * @public | |
| * | |
| * @return {Number} The minutes of this Duration instance | |
| * | |
| * @example | |
| * d = new Duration('PT2H 3M'); e = new Duration('PT2H'); | |
| * d.getMinutes(); // 3 | |
| * e.getMinutes(); // 0 | |
| */ | |
| getMinutes : function () { | |
| return this._duration.minutes(); | |
| }, | |
| /** | |
| * This Duration instance expressed as minutes. | |
| * | |
| * @method getAsMinutes | |
| * @public | |
| * | |
| * @return {Number} This Duration instance in minutes | |
| * | |
| * @example | |
| * d = new Duration('PT2H 3M'); e = new Duration('PT2H'); | |
| * d.getAsMinutes(); // 123 | |
| * e.getAsMinutes(); // 120 | |
| */ | |
| getAsMinutes : function () { | |
| return this._duration.asMinutes(); | |
| }, | |
| /** | |
| * Returns the time hour (0-23) of a given Duration instance. | |
| * | |
| * @method getHours | |
| * @public | |
| * | |
| * @return {Number} The hours (0-23) of this Duration instance | |
| * | |
| * @example | |
| * d = new Duration('P1DT3H'); e = new Duration('P1D'); | |
| * d.getHours(); // 3 | |
| * e.getHours(); // 0 | |
| */ | |
| getHours : function () { | |
| return this._duration.hours(); | |
| }, | |
| /** | |
| * This Duration instance expressed as hours. | |
| * | |
| * @method getAsHours | |
| * @public | |
| * | |
| * @return {Number} This Duration instance in hours | |
| * | |
| * @example | |
| * d = new Duration('P1DT3H'); e = new Duration('P1D'); | |
| * d.getAsHours(); // 27 | |
| * e.getAsHours(); // 24 | |
| */ | |
| getAsHours : function () { | |
| return this._duration.asHours(); | |
| }, | |
| /** | |
| * The days in this Duration instance. | |
| * | |
| * @method getDays | |
| * @public | |
| * | |
| * @return {Number} The days in this Duration instance | |
| * | |
| * @example | |
| * d = new Duration('P1M 3D'); e = new Duration('P1M'); | |
| * d.getDays(); // 3 | |
| * e.getDays(); // 0 | |
| */ | |
| getDays : function () { | |
| return this._duration.days(); | |
| }, | |
| /** | |
| * This Duration instance expressed as days. | |
| * | |
| * @method getAsDays | |
| * @public | |
| * | |
| * @return {Number} This Duration instance as days | |
| * | |
| * @example | |
| * d = new Duration('P1M 3D'); e = new Duration('P1M'); | |
| * d.getAsDays(); // 33 | |
| * e.getAsDays(); // 30 | |
| */ | |
| getAsDays : function () { | |
| return this._duration.asDays(); | |
| }, | |
| /** | |
| * Returns the months in this Duration instance. | |
| * | |
| * @method getMonths | |
| * @public | |
| * | |
| * @return {Number} The months of this Duration instance | |
| * | |
| * @example | |
| * d = new Duration('P1Y 4M'); e = new Duration('P1Y'); | |
| * d.getMonths(); // 4 | |
| * e.getMonths(); // 0 | |
| */ | |
| getMonths : function () { | |
| return this._duration.months(); | |
| }, | |
| /** | |
| * Returns this Duration instance expressed as months. | |
| * | |
| * @method getAsMonths | |
| * @public | |
| * | |
| * @return {Number} This Duration instance in months | |
| * | |
| * @example | |
| * d = new Duration('P1Y 4M'); e = new Duration('P1Y'); | |
| * d.getAsMonths(); // 16 | |
| * e.getAsMonths(); // 12 | |
| */ | |
| getAsMonths : function () { | |
| return this._duration.asMonths(); | |
| }, | |
| /** | |
| * Returns the years of this Duration instance. | |
| * | |
| * @method getYears | |
| * @public | |
| * | |
| * @return {Number} The years in this Duration instance | |
| * | |
| * @example | |
| * d = new Duration('P3Y 3M'); e = new Duration('P10Y'); | |
| * d.getYears(); // 3 | |
| * e.getYears(); // 10 | |
| */ | |
| getYears : function () { | |
| return this._duration.years(); | |
| }, | |
| /** | |
| * This Duration instance expressed as years. | |
| * | |
| * @method getAsYears | |
| * @public | |
| * | |
| * @return {Number} This Duration instance in years | |
| * | |
| * @example | |
| * d = new Duration('P3Y 3M'); e = new Duration('P10Y'); | |
| * d.getAsYears(); // 3.25 | |
| * e.getAsYears(); // 10 | |
| */ | |
| getAsYears : function () { | |
| return this._duration.asYears(); | |
| } | |
| }; | |
| /** | |
| * Runs the requested function while temporarily setting the Moment instance | |
| * to UTC. This is not public, so there's no param shifting. If there are no | |
| * opts, the callback still needs to be the third param. | |
| * | |
| * @method utcFilter | |
| * @private | |
| * | |
| * @param {Moment} m The current Moment instance | |
| * @param {Object} [opts] Options hash | |
| * @param {Boolean} [opts.utc] Whether to run the provided function in utc mode | |
| * @param {Function} callback The function to run on the given Moment instance | |
| * | |
| * @return {Mixed} The result of the callback function in the requested UTC or local mode | |
| */ | |
| utcFilter = function (m, opts, callback) { | |
| var ret = ''; | |
| if (opts && opts.utc) { | |
| m.utc(); | |
| ret = callback(); | |
| m.local(); | |
| } else { | |
| ret = callback(); | |
| } | |
| return ret; | |
| }; | |
| /** | |
| * Changes the properties of a moment.js Duration object, to allow it to be | |
| * mutated. | |
| * | |
| * @method mutateDuration | |
| * @private | |
| * | |
| * @param {Duration} duration A Duration object to change the ms of | |
| * @param {Number} newMs The new number for the Duration's ms | |
| * | |
| * @return {Duration} The provided duration, mutated to a new value | |
| */ | |
| mutateDuration = function (duration, newMs) { | |
| var | |
| toSet = duration._duration._data, | |
| tmpDuration = new Duration(newMs), | |
| toGet = tmpDuration._duration; | |
| duration._duration._milliseconds = newMs; | |
| toSet.days = toGet.days(); | |
| toSet.hours = toGet.hours(); | |
| toSet.milliseconds = toGet.milliseconds(); | |
| toSet.minutes = toGet.minutes(); | |
| toSet.months = toGet.months(); | |
| toSet.seconds = toGet.seconds(); | |
| toSet.years = toGet.years(); | |
| tmpDuration = null; | |
| return duration; | |
| }; | |
| /** | |
| * Returns a Duration, given either a Duration or something that can be used | |
| * to construct a Duration | |
| * | |
| * @method makeDuration | |
| * @private | |
| * | |
| * @param {Mixed} d Anything that can be used to make a Duration, or a Duration itself | |
| * | |
| * @return {Duration} A Duration instance | |
| */ | |
| makeDuration = function (d) { | |
| if (!d.getAsMilliseconds) { | |
| d = new Duration(d); | |
| } | |
| return d; | |
| }; | |
| /** | |
| * Returns a Moment, given either a Moment or something that can be used to | |
| * construct a Moment. | |
| * | |
| * @method makeMoment | |
| * @private | |
| * | |
| * @param {Mixed} m Anything that can be used to make a Moment, or a Moment itself | |
| * | |
| * @return {Moment} A Moment instance | |
| */ | |
| makeMoment = function (m) { | |
| if (!m.add) { | |
| m = new Moment(m); | |
| } | |
| return m; | |
| }; | |
| /** | |
| * Adds two durations, for now does not overload to create durations if the | |
| * params are not Duration instances already. Commutative. | |
| * | |
| * @method addDurations | |
| * @public | |
| * | |
| * @param {Duration|Mixed} left One Duration instance, or something that can construct a Duration | |
| * @param {Duration|Mixed} right Another Duration instance, or something that can construct a Duration, to be added to the first | |
| * | |
| * @return {Duration} The sum of the params, as a new Duration | |
| * | |
| * @example | |
| * addDurations(new Duration(1000), new Duration(3000)); // Duration representing 4s | |
| * addDurations(new Duration(2000), new Duration(-3000)); // Duration representing -1s | |
| * addDurations(1000, 4000); // Duration representing 5s | |
| * addDurations(1000, new Duration(1000)); // Duration representing 2s | |
| */ | |
| addDurations = function (left, right) { | |
| left = makeDuration(left); | |
| right = makeDuration(right); | |
| var res = left.getAsMilliseconds() + right.getAsMilliseconds(); | |
| return new Duration(res); | |
| }; | |
| /** | |
| * Subtracts two durations, for now does not overload to create durations if | |
| * the params are not Duration instances already. | |
| * | |
| * @method subtractDurations | |
| * @public | |
| * | |
| * @param {Duration|Mixed} left One Duration instance, or something that can construct a Duration | |
| * @param {Duration|Mixed} right Another Duration instance, or something that can construct a Duration, to be subtracted from the first | |
| * | |
| * @return {Duration} The result of subtraction on the params | |
| * | |
| * @example | |
| * subtractDurations(new Duration(1000), new Duration(2000)); // Duration representing -1s | |
| * subtractDurations(new Duration(3000), new Duration(1000)); // Duration representing 2s | |
| * subtractDurations(1000, 2000); // Duration representing -1s | |
| * subtractDurations(new Duration(3000), 1000); // Duration representing 2s | |
| */ | |
| subtractDurations = function (left, right) { | |
| left = makeDuration(left); | |
| right = makeDuration(right); | |
| var res = left.getAsMilliseconds() - right.getAsMilliseconds(); | |
| return new Duration(res); | |
| }; | |
| /** | |
| * Finds the absolute value difference between two Durations, | |
| * a commutative operation. | |
| * | |
| * @method diffDurations | |
| * @public | |
| * | |
| * @param {Duration|Mixed} first One Duration instance | |
| * @param {Duration|Mixed} second Another duration instance | |
| * | |
| * @return {Duration} A new Duration representing the difference between the params | |
| * | |
| * @example | |
| * diffDurations(new Duration(1000), new Duration(2000)); // Duration representing 1000ms | |
| * diffDurations(new Duration(2000), new Duration(-4000)); // Duration representing 6000ms | |
| * diffDurations('PT 2S', 'PT 4S'); // Duration representing 6000ms | |
| * diffDurations(3000, 'PT 2S'); // Duration representing 1000ms | |
| */ | |
| diffDurations = function (first, second) { | |
| first = makeDuration(first); | |
| second = makeDuration(second); | |
| var res = first.getAsMilliseconds() - second.getAsMilliseconds(); | |
| return new Duration(Math.abs(res)); | |
| }; | |
| /** | |
| * Adds a Duration to a provided Moment object, returning a new Moment. | |
| * Because of readability, it is preferable to use the constructors | |
| * explicitly, but the overloading is provided for situations where a | |
| * service response is providing something constructable; in this case | |
| * it is hoped that the var with the server response is readable. | |
| * | |
| * @method addToMoment | |
| * @public | |
| * | |
| * @param {Moment|Mixed} moment A Moment object to start from, or something that can construct a Moment | |
| * @param {Duration|Mixed} duration A Duration object, or something that can construct a Duration, to add to the Moment | |
| * | |
| * @return {Moment} The resulting new Moment | |
| * | |
| * @example | |
| * addToMoment(new Moment(), new Duration(1000)); // Moment one second in the future | |
| * addToMoment(new Moment(), 1000); // Moment one second in the future | |
| * // Try to avoid using constructable args, for readability, unless: | |
| * addToMoment(expirationTime, 'PT 10M'); // assuming expirationTime is a Moment-parsable string, date, etc | |
| */ | |
| addToMoment = function (moment, duration) { | |
| moment = makeMoment(moment); | |
| duration = makeDuration(duration); | |
| var res = moment.clone(); | |
| res._moment.add('ms', duration.getAsMilliseconds()); | |
| return res; | |
| }; | |
| /** | |
| * Subtracts a Duration from a provided Moment object, returning a new | |
| * Moment. | |
| * | |
| * @method subtractFromMoment | |
| * @public | |
| * | |
| * @param {Moment|Mixed} moment A Moment object to start from, or something that can construct a Moment | |
| * @param {Duration|Mixed} duration A Duration object, or something that can construct a Duration, to subtract from the Moment | |
| * @return {Moment} The resulting new Moment | |
| * | |
| * @example | |
| * subtractFromMoment(new Moment(), new Duration(1000)); // Moment one second ago | |
| * subtractFromMoment(new Moment(), 1000); // Moment one second in the past | |
| * // Try to avoid using constructable args, for readability, unless: | |
| * subtractFromMoment(expirationTime, 'PT 10M'); // assuming expirationTime is a Moment-parsable string, date, etc | |
| */ | |
| subtractFromMoment = function (moment, duration) { | |
| moment = makeMoment(moment); | |
| duration = makeDuration(duration); | |
| var res = moment.clone(); | |
| res._moment.subtract('ms', duration.getAsMilliseconds()); | |
| return res; | |
| }; | |
| /** | |
| * Finds the Duration between two Moments. This is not commutative, since the | |
| * diff will be positive or negative in terms of the first Moment. | |
| * If the second moment is after the first, the diff will be negative. | |
| * (18,19 === -1; 19,18 === 1) | |
| * | |
| * @method diffMoments | |
| * @public | |
| * | |
| * @param {Moment|Mixed} first A Moment object to start from, or something that can construct a Moment | |
| * @param {Moment|Mixed} second Another Moment object, or something that can construct a Moment, to find the diff from the first | |
| * | |
| * @return {Duration} The Duration diff between the two provided Moments | |
| * | |
| * @example | |
| * diffMoments(new Moment(), new Moment()); // Duration of (probably) 0 | |
| * diffMoments(momentYesterday, momentToday); // Duration of negative one day | |
| * diffMoments(momentToday, momentYesterday); // Duration of one day | |
| * diffMoments('2012-01-03', '2012-01-01'); // Duration of plus two days | |
| * diffMoments('2012-01-01', '2012-01-03'); // Duration of minus two days | |
| */ | |
| diffMoments = function (first, second) { | |
| first = makeMoment(first); | |
| second = makeMoment(second); | |
| var res = first.clone()._moment.diff(second._moment, true); | |
| return new Duration(res); | |
| }; | |
| return { | |
| version : '$$PACKAGE_VERSION$$', | |
| Moment : Moment, | |
| Duration : Duration, | |
| addDurations : addDurations, | |
| subtractDurations : subtractDurations, | |
| diffDurations : diffDurations, | |
| addToMoment : addToMoment, | |
| subtractFromMoment : subtractFromMoment, | |
| diffMoments : diffMoments | |
| }; | |
| } | |
| ); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment