pax_global_header 0000666 0000000 0000000 00000000064 13426151457 0014522 g ustar 00root root 0000000 0000000 52 comment=66cd41437e4957fef3d8f36591498aa4f4370af9
d3-time-1.0.11/ 0000775 0000000 0000000 00000000000 13426151457 0013044 5 ustar 00root root 0000000 0000000 d3-time-1.0.11/.eslintrc.json 0000664 0000000 0000000 00000000342 13426151457 0015637 0 ustar 00root root 0000000 0000000 {
"extends": "eslint:recommended",
"parserOptions": {
"sourceType": "module",
"ecmaVersion": 8
},
"env": {
"es6": true,
"node": true,
"browser": true
},
"rules": {
"no-cond-assign": 0
}
}
d3-time-1.0.11/.gitignore 0000664 0000000 0000000 00000000077 13426151457 0015040 0 ustar 00root root 0000000 0000000 *.sublime-workspace
.DS_Store
dist/
node_modules
npm-debug.log
d3-time-1.0.11/.npmignore 0000664 0000000 0000000 00000000042 13426151457 0015037 0 ustar 00root root 0000000 0000000 *.sublime-*
dist/*.zip
img/
test/
d3-time-1.0.11/LICENSE 0000664 0000000 0000000 00000002703 13426151457 0014053 0 ustar 00root root 0000000 0000000 Copyright 2010-2016 Mike Bostock
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the author nor the names of contributors may be used to
endorse or promote products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
d3-time-1.0.11/README.md 0000664 0000000 0000000 00000062046 13426151457 0014333 0 ustar 00root root 0000000 0000000 # d3-time
When visualizing time series data, analyzing temporal patterns, or working with time in general, the irregularities of conventional time units quickly become apparent. In the [Gregorian calendar](https://en.wikipedia.org/wiki/Gregorian_calendar), for example, most months have 31 days but some have 28, 29 or 30; most years have 365 days but [leap years](https://en.wikipedia.org/wiki/Leap_year) have 366; and with [daylight saving](https://en.wikipedia.org/wiki/Daylight_saving_time), most days have 24 hours but some have 23 or 25. Adding to complexity, daylight saving conventions vary around the world.
As a result of these temporal peculiarities, it can be difficult to perform seemingly-trivial tasks. For example, if you want to compute the number of days that have passed between two dates, you can’t simply subtract and divide by 24 hours (86,400,000 ms):
```js
var start = new Date(2015, 02, 01), // Sun Mar 01 2015 00:00:00 GMT-0800 (PST)
end = new Date(2015, 03, 01); // Wed Apr 01 2015 00:00:00 GMT-0700 (PDT)
(end - start) / 864e5; // 30.958333333333332, oops!
```
You can, however, use [d3.timeDay](#timeDay).[count](#interval_count):
```js
d3.timeDay.count(start, end); // 31
```
The [day](#day) [interval](#api-reference) is one of several provided by d3-time. Each interval represents a conventional unit of time—[hours](#timeHour), [weeks](#timeWeek), [months](#timeMonth), *etc.*—and has methods to calculate boundary dates. For example, [d3.timeDay](#timeDay) computes midnight (typically 12:00 AM local time) of the corresponding day. In addition to [rounding](#interval_round) and [counting](#interval_count), intervals can also be used to generate arrays of boundary dates. For example, to compute each Sunday in the current month:
```js
var now = new Date;
d3.timeWeek.range(d3.timeMonth.floor(now), d3.timeMonth.ceil(now));
// [Sun Jun 07 2015 00:00:00 GMT-0700 (PDT),
// Sun Jun 14 2015 00:00:00 GMT-0700 (PDT),
// Sun Jun 21 2015 00:00:00 GMT-0700 (PDT),
// Sun Jun 28 2015 00:00:00 GMT-0700 (PDT)]
```
The d3-time module does not implement its own calendaring system; it merely implements a convenient API for calendar math on top of ECMAScript [Date](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date). Thus, it ignores leap seconds and can only work with the local time zone and [Coordinated Universal Time](https://en.wikipedia.org/wiki/Coordinated_Universal_Time) (UTC).
This module is used by D3’s time scales to generate sensible ticks, by D3’s time format, and can also be used directly to do things like [calendar layouts](http://bl.ocks.org/mbostock/4063318).
## Installing
If you use NPM, `npm install d3-time`. Otherwise, download the [latest release](https://github.com/d3/d3-time/releases/latest). You can also load directly from [d3js.org](https://d3js.org), either as a [standalone library](https://d3js.org/d3-time.v1.min.js) or as part of [D3 4.0](https://github.com/d3/d3). AMD, CommonJS, and vanilla environments are supported. In vanilla, a `d3` global is exported:
```html
```
[Try d3-time in your browser.](https://tonicdev.com/npm/d3-time)
## API Reference
# interval(date) [<>](https://github.com/d3/d3-time/blob/master/src/interval.js#L6 "Source")
Alias for [*interval*.floor](#interval_floor). For example, [d3.timeYear](#timeYear)(*date*) and d3.timeYear.floor(*date*) are equivalent.
# interval.floor(date) [<>](https://github.com/d3/d3-time/blob/master/src/interval.js#L10 "Source")
Returns a new date representing the latest interval boundary date before or equal to *date*. For example, [d3.timeDay](#timeDay).floor(*date*) typically returns 12:00 AM local time on the given *date*.
This method is idempotent: if the specified *date* is already floored to the current interval, a new date with an identical time is returned. Furthermore, the returned date is the minimum expressible value of the associated interval, such that *interval*.floor(*interval*.floor(*date*) - 1) returns the preceeding interval boundary date.
Note that the `==` and `===` operators do not compare by value with [Date](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date) objects, and thus you cannot use them to tell whether the specified *date* has already been floored. Instead, coerce to a number and then compare:
```js
// Returns true if the specified date is a day boundary.
function isDay(date) {
return +d3.timeDay.floor(date) === +date;
}
```
This is more reliable than testing whether the time is 12:00 AM, as in some time zones midnight may not exist due to daylight saving.
# interval.round(date) [<>](https://github.com/d3/d3-time/blob/master/src/interval.js#L16 "Source")
Returns a new date representing the closest interval boundary date to *date*. For example, [d3.timeDay](#timeDay).round(*date*) typically returns 12:00 AM local time on the given *date* if it is on or before noon, and 12:00 AM of the following day if it is after noon.
This method is idempotent: if the specified *date* is already rounded to the current interval, a new date with an identical time is returned.
# interval.ceil(date) [<>](https://github.com/d3/d3-time/blob/master/src/interval.js#L12 "Source")
Returns a new date representing the earliest interval boundary date after or equal to *date*. For example, [d3.timeDay](#timeDay).ceil(*date*) typically returns 12:00 AM local time on the date following the given *date*.
This method is idempotent: if the specified *date* is already ceilinged to the current interval, a new date with an identical time is returned. Furthermore, the returned date is the maximum expressible value of the associated interval, such that *interval*.ceil(*interval*.ceil(*date*) + 1) returns the following interval boundary date.
# interval.offset(date[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/interval.js#L22 "Source")
Returns a new date equal to *date* plus *step* intervals. If *step* is not specified it defaults to 1. If *step* is negative, then the returned date will be before the specified *date*; if *step* is zero, then a copy of the specified *date* is returned; if *step* is not an integer, it is [floored](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor). This method does not round the specified *date* to the interval. For example, if *date* is today at 5:34 PM, then [d3.timeDay](#timeDay).offset(*date*, 1) returns 5:34 PM tomorrow (even if daylight saving changes!).
# interval.range(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/interval.js#L26 "Source")
Returns an array of dates representing every interval boundary after or equal to *start* (inclusive) and before *stop* (exclusive). If *step* is specified, then every *step*th boundary will be returned; for example, for the [d3.timeDay](#timeDay) interval a *step* of 2 will return every other day. If *step* is not an integer, it is [floored](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor).
The first date in the returned array is the earliest boundary after or equal to *start*; subsequent dates are [offset](#interval_offset) by *step* intervals and [floored](#interval_floor). Thus, two overlapping ranges may be consistent. For example, this range contains odd days:
```js
d3.timeDay.range(new Date(2015, 0, 1), new Date(2015, 0, 7), 2);
// [Thu Jan 01 2015 00:00:00 GMT-0800 (PST),
// Sat Jan 03 2015 00:00:00 GMT-0800 (PST),
// Mon Jan 05 2015 00:00:00 GMT-0800 (PST)]
```
While this contains even days:
```js
d3.timeDay.range(new Date(2015, 0, 2), new Date(2015, 0, 8), 2);
// [Fri Jan 02 2015 00:00:00 GMT-0800 (PST),
// Sun Jan 04 2015 00:00:00 GMT-0800 (PST),
// Tue Jan 06 2015 00:00:00 GMT-0800 (PST)]
```
To make ranges consistent when a *step* is specified, use [*interval*.every](#interval_every) instead.
# interval.filter(test) [<>](https://github.com/d3/d3-time/blob/master/src/interval.js#L35 "Source")
Returns a new interval that is a filtered subset of this interval using the specified *test* function. The *test* function is passed a date and should return true if and only if the specified date should be considered part of the interval. For example, to create an interval that returns the 1st, 11th, 21th and 31th (if it exists) of each month:
```js
var i = d3.timeDay.filter(function(d) { return (d.getDate() - 1) % 10 === 0; });
```
The returned filtered interval does not support [*interval*.count](#interval_count). See also [*interval*.every](#interval_every).
# interval.every(step) [<>](https://github.com/d3/d3-time/blob/master/src/interval.js#L50 "Source")
Returns a [filtered](#interval_filter) view of this interval representing every *step*th date. The meaning of *step* is dependent on this interval’s parent interval as defined by the field function. For example, [d3.timeMinute](#timeMinute).every(15) returns an interval representing every fifteen minutes, starting on the hour: :00, :15, :30, :45, etc. Note that for some intervals, the resulting dates may not be uniformly-spaced; [d3.timeDay](#timeDay)’s parent interval is [d3.timeMonth](#timeMonth), and thus the interval number resets at the start of each month. If *step* is not valid, returns null. If *step* is one, returns this interval.
This method can be used in conjunction with [*interval*.range](#interval_range) to ensure that two overlapping ranges are consistent. For example, this range contains odd days:
```js
d3.timeDay.every(2).range(new Date(2015, 0, 1), new Date(2015, 0, 7));
// [Thu Jan 01 2015 00:00:00 GMT-0800 (PST),
// Sat Jan 03 2015 00:00:00 GMT-0800 (PST),
// Mon Jan 05 2015 00:00:00 GMT-0800 (PST)]
```
As does this one:
```js
d3.timeDay.every(2).range(new Date(2015, 0, 2), new Date(2015, 0, 8));
// [Sat Jan 03 2015 00:00:00 GMT-0800 (PST),
// Mon Jan 05 2015 00:00:00 GMT-0800 (PST),
// Wed Jan 07 2015 00:00:00 GMT-0800 (PST)]
```
The returned filtered interval does not support [*interval*.count](#interval_count). See also [*interval*.filter](#interval_filter).
# interval.count(start, end) [<>](https://github.com/d3/d3-time/blob/master/src/interval.js#L44 "Source")
Returns the number of interval boundaries after *start* (exclusive) and before or equal to *end* (inclusive). Note that this behavior is slightly different than [*interval*.range](#interval_range) because its purpose is to return the zero-based number of the specified *end* date relative to the specified *start* date. For example, to compute the current zero-based day-of-year number:
```js
var now = new Date;
d3.timeDay.count(d3.timeYear(now), now); // 177
```
Likewise, to compute the current zero-based week-of-year number for weeks that start on Sunday:
```js
d3.timeSunday.count(d3.timeYear(now), now); // 25
```
# d3.timeInterval(floor, offset[, count[, field]]) [<>](https://github.com/d3/d3-time/blob/master/src/interval.js#L4 "Source")
Constructs a new custom interval given the specified *floor* and *offset* functions and an optional *count* function.
The *floor* function takes a single date as an argument and rounds it down to the nearest interval boundary.
The *offset* function takes a date and an integer step as arguments and advances the specified date by the specified number of boundaries; the step may be positive, negative or zero.
The optional *count* function takes a start date and an end date, already floored to the current interval, and returns the number of boundaries between the start (exclusive) and end (inclusive). If a *count* function is not specified, the returned interval does not expose [*interval*.count](#interval_count) or [*interval*.every](#interval_every) methods. Note: due to an internal optimization, the specified *count* function must not invoke *interval*.count on other time intervals.
The optional *field* function takes a date, already floored to the current interval, and returns the field value of the specified date, corresponding to the number of boundaries between this date (exclusive) and the latest previous parent boundary. For example, for the [d3.timeDay](#timeDay) interval, this returns the number of days since the start of the month. If a *field* function is not specified, it defaults to counting the number of interval boundaries since the UNIX epoch of January 1, 1970 UTC. The *field* function defines the behavior of [*interval*.every](#interval_every).
### Intervals
The following intervals are provided:
# d3.timeMillisecond [<>](https://github.com/d3/d3-time/blob/master/src/millisecond.js "Source")
# d3.utcMillisecond
Milliseconds; the shortest available time unit.
# d3.timeSecond [<>](https://github.com/d3/d3-time/blob/master/src/second.js "Source")
# d3.utcSecond
Seconds (e.g., 01:23:45.0000 AM); 1,000 milliseconds.
# d3.timeMinute [<>](https://github.com/d3/d3-time/blob/master/src/minute.js "Source")
# d3.utcMinute [<>](https://github.com/d3/d3-time/blob/master/src/utcMinute.js "Source")
Minutes (e.g., 01:02:00 AM); 60 seconds. Note that ECMAScript [ignores leap seconds](http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.1).
# d3.timeHour [<>](https://github.com/d3/d3-time/blob/master/src/hour.js "Source")
# d3.utcHour [<>](https://github.com/d3/d3-time/blob/master/src/utcHour.js "Source")
Hours (e.g., 01:00 AM); 60 minutes. Note that advancing time by one hour in local time can return the same hour or skip an hour due to daylight saving.
# d3.timeDay [<>](https://github.com/d3/d3-time/blob/master/src/day.js "Source")
# d3.utcDay [<>](https://github.com/d3/d3-time/blob/master/src/utcDay.js "Source")
Days (e.g., February 7, 2012 at 12:00 AM); typically 24 hours. Days in local time may range from 23 to 25 hours due to daylight saving.
# d3.timeWeek [<>](https://github.com/d3/d3-time/blob/master/src/week.js "Source")
# d3.utcWeek [<>](https://github.com/d3/d3-time/blob/master/src/utcWeek.js "Source")
Alias for [d3.timeSunday](#timeSunday); 7 days and typically 168 hours. Weeks in local time may range from 167 to 169 hours due on daylight saving.
# d3.timeSunday [<>](https://github.com/d3/d3-time/blob/master/src/week.js#L15 "Source")
# d3.utcSunday [<>](https://github.com/d3/d3-time/blob/master/src/utcWeek.js#L15 "Source")
Sunday-based weeks (e.g., February 5, 2012 at 12:00 AM).
# d3.timeMonday [<>](https://github.com/d3/d3-time/blob/master/src/week.js#L16 "Source")
# d3.utcMonday [<>](https://github.com/d3/d3-time/blob/master/src/utcWeek.js#L16 "Source")
Monday-based weeks (e.g., February 6, 2012 at 12:00 AM).
# d3.timeTuesday [<>](https://github.com/d3/d3-time/blob/master/src/week.js#L17 "Source")
# d3.utcTuesday [<>](https://github.com/d3/d3-time/blob/master/src/utcWeek.js#L17 "Source")
Tuesday-based weeks (e.g., February 7, 2012 at 12:00 AM).
# d3.timeWednesday [<>](https://github.com/d3/d3-time/blob/master/src/week.js#L18 "Source")
# d3.utcWednesday [<>](https://github.com/d3/d3-time/blob/master/src/utcWeek.js#L18 "Source")
Wednesday-based weeks (e.g., February 8, 2012 at 12:00 AM).
# d3.timeThursday [<>](https://github.com/d3/d3-time/blob/master/src/week.js#L19 "Source")
# d3.utcThursday [<>](https://github.com/d3/d3-time/blob/master/src/utcWeek.js#L19 "Source")
Thursday-based weeks (e.g., February 9, 2012 at 12:00 AM).
# d3.timeFriday [<>](https://github.com/d3/d3-time/blob/master/src/week.js#L20 "Source")
# d3.utcFriday [<>](https://github.com/d3/d3-time/blob/master/src/utcWeek.js#L20 "Source")
Friday-based weeks (e.g., February 10, 2012 at 12:00 AM).
# d3.timeSaturday [<>](https://github.com/d3/d3-time/blob/master/src/week.js#L21 "Source")
# d3.utcSaturday [<>](https://github.com/d3/d3-time/blob/master/src/utcWeek.js#L21 "Source")
Saturday-based weeks (e.g., February 11, 2012 at 12:00 AM).
# d3.timeMonth [<>](https://github.com/d3/d3-time/blob/master/src/month.js "Source")
# d3.utcMonth [<>](https://github.com/d3/d3-time/blob/master/src/utcMonth.js "Source")
Months (e.g., February 1, 2012 at 12:00 AM); ranges from 28 to 31 days.
# d3.timeYear [<>](https://github.com/d3/d3-time/blob/master/src/year.js "Source")
# d3.utcYear [<>](https://github.com/d3/d3-time/blob/master/src/utcYear.js "Source")
Years (e.g., January 1, 2012 at 12:00 AM); ranges from 365 to 366 days.
### Ranges
For convenience, aliases for [*interval*.range](#interval_range) are also provided as plural forms of the corresponding interval.
# d3.timeMilliseconds(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/millisecond.js#L26 "Source")
# d3.utcMilliseconds(start, stop[, step])
Aliases for [d3.timeMillisecond](#timeMillisecond).[range](#interval_range) and [d3.utcMillisecond](#timeMillisecond).[range](#interval_range).
# d3.timeSeconds(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/second.js#L15 "Source")
# d3.utcSeconds(start, stop[, step])
Aliases for [d3.timeSecond](#timeSecond).[range](#interval_range) and [d3.utcSecond](#timeSecond).[range](#interval_range).
# d3.timeMinutes(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/minute.js#L15 "Source")
# d3.utcMinutes(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/utcMinute.js#L15 "Source")
Aliases for [d3.timeMinute](#timeMinute).[range](#interval_range) and [d3.utcMinute](#timeMinute).[range](#interval_range).
# d3.timeHours(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/hour.js#L17 "Source")
# d3.utcHours(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/utcHour.js#L15 "Source")
Aliases for [d3.timeHour](#timeHour).[range](#interval_range) and [d3.utcHour](#timeHour).[range](#interval_range).
# d3.timeDays(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/day.js#L15 "Source")
# d3.utcDays(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/utcDay.js#L15 "Source")
Aliases for [d3.timeDay](#timeDay).[range](#interval_range) and [d3.utcDay](#timeDay).[range](#interval_range).
# d3.timeWeeks(start, stop[, step])
# d3.utcWeeks(start, stop[, step])
Aliases for [d3.timeWeek](#timeWeek).[range](#interval_range) and [d3.utcWeek](#timeWeek).[range](#interval_range).
# d3.timeSundays(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/week.js#L23 "Source")
# d3.utcSundays(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/utcWeek.js#L23 "Source")
Aliases for [d3.timeSunday](#timeSunday).[range](#interval_range) and [d3.utcSunday](#timeSunday).[range](#interval_range).
# d3.timeMondays(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/week.js#L24 "Source")
# d3.utcMondays(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/utcWeek.js#L24 "Source")
Aliases for [d3.timeMonday](#timeMonday).[range](#interval_range) and [d3.utcMonday](#timeMonday).[range](#interval_range).
# d3.timeTuesdays(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/week.js#L25 "Source")
# d3.utcTuesdays(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/utcWeek.js#L25 "Source")
Aliases for [d3.timeTuesday](#timeTuesday).[range](#interval_range) and [d3.utcTuesday](#timeTuesday).[range](#interval_range).
# d3.timeWednesdays(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/week.js#L26 "Source")
# d3.utcWednesdays(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/utcWeek.js#L26 "Source")
Aliases for [d3.timeWednesday](#timeWednesday).[range](#interval_range) and [d3.utcWednesday](#timeWednesday).[range](#interval_range).
# d3.timeThursdays(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/week.js#L27 "Source")
# d3.utcThursdays(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/utcWeek.js#L27 "Source")
Aliases for [d3.timeThursday](#timeThursday).[range](#interval_range) and [d3.utcThursday](#timeThursday).[range](#interval_range).
# d3.timeFridays(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/week.js#L28 "Source")
# d3.utcFridays(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/utcWeek.js#L28 "Source")
Aliases for [d3.timeFriday](#timeFriday).[range](#interval_range) and [d3.utcFriday](#timeFriday).[range](#interval_range).
# d3.timeSaturdays(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/week.js#L29 "Source")
# d3.utcSaturdays(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/utcWeek.js#L29 "Source")
Aliases for [d3.timeSaturday](#timeSaturday).[range](#interval_range) and [d3.utcSaturday](#timeSaturday).[range](#interval_range).
# d3.timeMonths(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/month.js#L15 "Source")
# d3.utcMonths(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/utcMonth.js#L15 "Source")
Aliases for [d3.timeMonth](#timeMonth).[range](#interval_range) and [d3.utcMonth](#timeMonth).[range](#interval_range).
# d3.timeYears(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/year.js#L26 "Source")
# d3.utcYears(start, stop[, step]) [<>](https://github.com/d3/d3-time/blob/master/src/utcYear.js#L26 "Source")
Aliases for [d3.timeYear](#timeYear).[range](#interval_range) and [d3.utcYear](#timeYear).[range](#interval_range).
d3-time-1.0.11/d3-time.sublime-project 0000664 0000000 0000000 00000000524 13426151457 0017335 0 ustar 00root root 0000000 0000000 {
"folders": [
{
"path": ".",
"file_exclude_patterns": ["*.sublime-workspace"],
"folder_exclude_patterns": ["dist"]
}
],
"build_systems": [
{
"name": "yarn test",
"cmd": ["yarn", "test"],
"file_regex": "\\((...*?):([0-9]*):([0-9]*)\\)",
"working_dir": "$project_path"
}
]
}
d3-time-1.0.11/package.json 0000664 0000000 0000000 00000002753 13426151457 0015341 0 ustar 00root root 0000000 0000000 {
"name": "d3-time",
"version": "1.0.11",
"description": "A calculator for humanity’s peculiar conventions of time.",
"keywords": [
"d3",
"d3-module",
"time",
"interval",
"calendar"
],
"homepage": "https://d3js.org/d3-time/",
"license": "BSD-3-Clause",
"author": {
"name": "Mike Bostock",
"url": "http://bost.ocks.org/mike"
},
"main": "dist/d3-time.js",
"unpkg": "dist/d3-time.min.js",
"jsdelivr": "dist/d3-time.min.js",
"module": "src/index.js",
"repository": {
"type": "git",
"url": "https://github.com/d3/d3-time.git"
},
"scripts": {
"pretest": "rollup -c",
"test": "TZ=America/Los_Angeles tape 'test/**/*-test.js' && eslint src",
"prepublishOnly": "rm -rf dist && yarn test",
"postpublish": "git push && git push --tags && cd ../d3.github.com && git pull && cp ../${npm_package_name}/dist/${npm_package_name}.js ${npm_package_name}.v${npm_package_version%%.*}.js && cp ../${npm_package_name}/dist/${npm_package_name}.min.js ${npm_package_name}.v${npm_package_version%%.*}.min.js && git add ${npm_package_name}.v${npm_package_version%%.*}.js ${npm_package_name}.v${npm_package_version%%.*}.min.js && git commit -m \"${npm_package_name} ${npm_package_version}\" && git push && cd - && zip -j dist/${npm_package_name}.zip -- LICENSE README.md dist/${npm_package_name}.js dist/${npm_package_name}.min.js"
},
"devDependencies": {
"eslint": "5",
"rollup": "0.64",
"rollup-plugin-terser": "1",
"tape": "4"
}
}
d3-time-1.0.11/rollup.config.js 0000664 0000000 0000000 00000001545 13426151457 0016170 0 ustar 00root root 0000000 0000000 import {terser} from "rollup-plugin-terser";
import * as meta from "./package.json";
const config = {
input: "src/index.js",
external: Object.keys(meta.dependencies || {}).filter(key => /^d3-/.test(key)),
output: {
file: `dist/${meta.name}.js`,
name: "d3",
format: "umd",
indent: false,
extend: true,
banner: `// ${meta.homepage} v${meta.version} Copyright ${(new Date).getFullYear()} ${meta.author.name}`,
globals: Object.assign({}, ...Object.keys(meta.dependencies || {}).filter(key => /^d3-/.test(key)).map(key => ({[key]: "d3"})))
},
plugins: []
};
export default [
config,
{
...config,
output: {
...config.output,
file: `dist/${meta.name}.min.js`
},
plugins: [
...config.plugins,
terser({
output: {
preamble: config.output.banner
}
})
]
}
];
d3-time-1.0.11/src/ 0000775 0000000 0000000 00000000000 13426151457 0013633 5 ustar 00root root 0000000 0000000 d3-time-1.0.11/src/day.js 0000664 0000000 0000000 00000000716 13426151457 0014752 0 ustar 00root root 0000000 0000000 import interval from "./interval";
import {durationDay, durationMinute} from "./duration";
var day = interval(function(date) {
date.setHours(0, 0, 0, 0);
}, function(date, step) {
date.setDate(date.getDate() + step);
}, function(start, end) {
return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationDay;
}, function(date) {
return date.getDate() - 1;
});
export default day;
export var days = day.range;
d3-time-1.0.11/src/duration.js 0000664 0000000 0000000 00000000244 13426151457 0016016 0 ustar 00root root 0000000 0000000 export var durationSecond = 1e3;
export var durationMinute = 6e4;
export var durationHour = 36e5;
export var durationDay = 864e5;
export var durationWeek = 6048e5;
d3-time-1.0.11/src/hour.js 0000664 0000000 0000000 00000000772 13426151457 0015154 0 ustar 00root root 0000000 0000000 import interval from "./interval";
import {durationHour, durationMinute, durationSecond} from "./duration";
var hour = interval(function(date) {
date.setTime(date - date.getMilliseconds() - date.getSeconds() * durationSecond - date.getMinutes() * durationMinute);
}, function(date, step) {
date.setTime(+date + step * durationHour);
}, function(start, end) {
return (end - start) / durationHour;
}, function(date) {
return date.getHours();
});
export default hour;
export var hours = hour.range;
d3-time-1.0.11/src/index.js 0000664 0000000 0000000 00000003764 13426151457 0015312 0 ustar 00root root 0000000 0000000 export {
default as timeInterval
} from "./interval";
export {
default as timeMillisecond,
milliseconds as timeMilliseconds,
default as utcMillisecond,
milliseconds as utcMilliseconds
} from "./millisecond";
export {
default as timeSecond,
seconds as timeSeconds,
default as utcSecond,
seconds as utcSeconds
} from "./second";
export {
default as timeMinute,
minutes as timeMinutes
} from "./minute";
export {
default as timeHour,
hours as timeHours
} from "./hour";
export {
default as timeDay,
days as timeDays
} from "./day";
export {
sunday as timeWeek,
sundays as timeWeeks,
sunday as timeSunday,
sundays as timeSundays,
monday as timeMonday,
mondays as timeMondays,
tuesday as timeTuesday,
tuesdays as timeTuesdays,
wednesday as timeWednesday,
wednesdays as timeWednesdays,
thursday as timeThursday,
thursdays as timeThursdays,
friday as timeFriday,
fridays as timeFridays,
saturday as timeSaturday,
saturdays as timeSaturdays
} from "./week";
export {
default as timeMonth,
months as timeMonths
} from "./month";
export {
default as timeYear,
years as timeYears
} from "./year";
export {
default as utcMinute,
utcMinutes as utcMinutes
} from "./utcMinute";
export {
default as utcHour,
utcHours as utcHours
} from "./utcHour";
export {
default as utcDay,
utcDays as utcDays
} from "./utcDay";
export {
utcSunday as utcWeek,
utcSundays as utcWeeks,
utcSunday as utcSunday,
utcSundays as utcSundays,
utcMonday as utcMonday,
utcMondays as utcMondays,
utcTuesday as utcTuesday,
utcTuesdays as utcTuesdays,
utcWednesday as utcWednesday,
utcWednesdays as utcWednesdays,
utcThursday as utcThursday,
utcThursdays as utcThursdays,
utcFriday as utcFriday,
utcFridays as utcFridays,
utcSaturday as utcSaturday,
utcSaturdays as utcSaturdays
} from "./utcWeek";
export {
default as utcMonth,
utcMonths as utcMonths
} from "./utcMonth";
export {
default as utcYear,
utcYears as utcYears
} from "./utcYear";
d3-time-1.0.11/src/interval.js 0000664 0000000 0000000 00000004023 13426151457 0016014 0 ustar 00root root 0000000 0000000 var t0 = new Date,
t1 = new Date;
export default function newInterval(floori, offseti, count, field) {
function interval(date) {
return floori(date = new Date(+date)), date;
}
interval.floor = interval;
interval.ceil = function(date) {
return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date;
};
interval.round = function(date) {
var d0 = interval(date),
d1 = interval.ceil(date);
return date - d0 < d1 - date ? d0 : d1;
};
interval.offset = function(date, step) {
return offseti(date = new Date(+date), step == null ? 1 : Math.floor(step)), date;
};
interval.range = function(start, stop, step) {
var range = [], previous;
start = interval.ceil(start);
step = step == null ? 1 : Math.floor(step);
if (!(start < stop) || !(step > 0)) return range; // also handles Invalid Date
do range.push(previous = new Date(+start)), offseti(start, step), floori(start);
while (previous < start && start < stop);
return range;
};
interval.filter = function(test) {
return newInterval(function(date) {
if (date >= date) while (floori(date), !test(date)) date.setTime(date - 1);
}, function(date, step) {
if (date >= date) {
if (step < 0) while (++step <= 0) {
while (offseti(date, -1), !test(date)) {} // eslint-disable-line no-empty
} else while (--step >= 0) {
while (offseti(date, +1), !test(date)) {} // eslint-disable-line no-empty
}
}
});
};
if (count) {
interval.count = function(start, end) {
t0.setTime(+start), t1.setTime(+end);
floori(t0), floori(t1);
return Math.floor(count(t0, t1));
};
interval.every = function(step) {
step = Math.floor(step);
return !isFinite(step) || !(step > 0) ? null
: !(step > 1) ? interval
: interval.filter(field
? function(d) { return field(d) % step === 0; }
: function(d) { return interval.count(0, d) % step === 0; });
};
}
return interval;
}
d3-time-1.0.11/src/millisecond.js 0000664 0000000 0000000 00000001234 13426151457 0016473 0 ustar 00root root 0000000 0000000 import interval from "./interval";
var millisecond = interval(function() {
// noop
}, function(date, step) {
date.setTime(+date + step);
}, function(start, end) {
return end - start;
});
// An optimized implementation for this simple case.
millisecond.every = function(k) {
k = Math.floor(k);
if (!isFinite(k) || !(k > 0)) return null;
if (!(k > 1)) return millisecond;
return interval(function(date) {
date.setTime(Math.floor(date / k) * k);
}, function(date, step) {
date.setTime(+date + step * k);
}, function(start, end) {
return (end - start) / k;
});
};
export default millisecond;
export var milliseconds = millisecond.range;
d3-time-1.0.11/src/minute.js 0000664 0000000 0000000 00000000725 13426151457 0015476 0 ustar 00root root 0000000 0000000 import interval from "./interval";
import {durationMinute, durationSecond} from "./duration";
var minute = interval(function(date) {
date.setTime(date - date.getMilliseconds() - date.getSeconds() * durationSecond);
}, function(date, step) {
date.setTime(+date + step * durationMinute);
}, function(start, end) {
return (end - start) / durationMinute;
}, function(date) {
return date.getMinutes();
});
export default minute;
export var minutes = minute.range;
d3-time-1.0.11/src/month.js 0000664 0000000 0000000 00000000636 13426151457 0015323 0 ustar 00root root 0000000 0000000 import interval from "./interval";
var month = interval(function(date) {
date.setDate(1);
date.setHours(0, 0, 0, 0);
}, function(date, step) {
date.setMonth(date.getMonth() + step);
}, function(start, end) {
return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12;
}, function(date) {
return date.getMonth();
});
export default month;
export var months = month.range;
d3-time-1.0.11/src/second.js 0000664 0000000 0000000 00000000643 13426151457 0015447 0 ustar 00root root 0000000 0000000 import interval from "./interval";
import {durationSecond} from "./duration";
var second = interval(function(date) {
date.setTime(date - date.getMilliseconds());
}, function(date, step) {
date.setTime(+date + step * durationSecond);
}, function(start, end) {
return (end - start) / durationSecond;
}, function(date) {
return date.getUTCSeconds();
});
export default second;
export var seconds = second.range;
d3-time-1.0.11/src/utcDay.js 0000664 0000000 0000000 00000000615 13426151457 0015424 0 ustar 00root root 0000000 0000000 import interval from "./interval";
import {durationDay} from "./duration";
var utcDay = interval(function(date) {
date.setUTCHours(0, 0, 0, 0);
}, function(date, step) {
date.setUTCDate(date.getUTCDate() + step);
}, function(start, end) {
return (end - start) / durationDay;
}, function(date) {
return date.getUTCDate() - 1;
});
export default utcDay;
export var utcDays = utcDay.range;
d3-time-1.0.11/src/utcHour.js 0000664 0000000 0000000 00000000617 13426151457 0015626 0 ustar 00root root 0000000 0000000 import interval from "./interval";
import {durationHour} from "./duration";
var utcHour = interval(function(date) {
date.setUTCMinutes(0, 0, 0);
}, function(date, step) {
date.setTime(+date + step * durationHour);
}, function(start, end) {
return (end - start) / durationHour;
}, function(date) {
return date.getUTCHours();
});
export default utcHour;
export var utcHours = utcHour.range;
d3-time-1.0.11/src/utcMinute.js 0000664 0000000 0000000 00000000634 13426151457 0016151 0 ustar 00root root 0000000 0000000 import interval from "./interval";
import {durationMinute} from "./duration";
var utcMinute = interval(function(date) {
date.setUTCSeconds(0, 0);
}, function(date, step) {
date.setTime(+date + step * durationMinute);
}, function(start, end) {
return (end - start) / durationMinute;
}, function(date) {
return date.getUTCMinutes();
});
export default utcMinute;
export var utcMinutes = utcMinute.range;
d3-time-1.0.11/src/utcMonth.js 0000664 0000000 0000000 00000000705 13426151457 0015774 0 ustar 00root root 0000000 0000000 import interval from "./interval";
var utcMonth = interval(function(date) {
date.setUTCDate(1);
date.setUTCHours(0, 0, 0, 0);
}, function(date, step) {
date.setUTCMonth(date.getUTCMonth() + step);
}, function(start, end) {
return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12;
}, function(date) {
return date.getUTCMonth();
});
export default utcMonth;
export var utcMonths = utcMonth.range;
d3-time-1.0.11/src/utcWeek.js 0000664 0000000 0000000 00000001723 13426151457 0015603 0 ustar 00root root 0000000 0000000 import interval from "./interval";
import {durationWeek} from "./duration";
function utcWeekday(i) {
return interval(function(date) {
date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i) % 7);
date.setUTCHours(0, 0, 0, 0);
}, function(date, step) {
date.setUTCDate(date.getUTCDate() + step * 7);
}, function(start, end) {
return (end - start) / durationWeek;
});
}
export var utcSunday = utcWeekday(0);
export var utcMonday = utcWeekday(1);
export var utcTuesday = utcWeekday(2);
export var utcWednesday = utcWeekday(3);
export var utcThursday = utcWeekday(4);
export var utcFriday = utcWeekday(5);
export var utcSaturday = utcWeekday(6);
export var utcSundays = utcSunday.range;
export var utcMondays = utcMonday.range;
export var utcTuesdays = utcTuesday.range;
export var utcWednesdays = utcWednesday.range;
export var utcThursdays = utcThursday.range;
export var utcFridays = utcFriday.range;
export var utcSaturdays = utcSaturday.range;
d3-time-1.0.11/src/utcYear.js 0000664 0000000 0000000 00000001450 13426151457 0015605 0 ustar 00root root 0000000 0000000 import interval from "./interval";
var utcYear = interval(function(date) {
date.setUTCMonth(0, 1);
date.setUTCHours(0, 0, 0, 0);
}, function(date, step) {
date.setUTCFullYear(date.getUTCFullYear() + step);
}, function(start, end) {
return end.getUTCFullYear() - start.getUTCFullYear();
}, function(date) {
return date.getUTCFullYear();
});
// An optimized implementation for this simple case.
utcYear.every = function(k) {
return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : interval(function(date) {
date.setUTCFullYear(Math.floor(date.getUTCFullYear() / k) * k);
date.setUTCMonth(0, 1);
date.setUTCHours(0, 0, 0, 0);
}, function(date, step) {
date.setUTCFullYear(date.getUTCFullYear() + step * k);
});
};
export default utcYear;
export var utcYears = utcYear.range;
d3-time-1.0.11/src/week.js 0000664 0000000 0000000 00000001703 13426151457 0015125 0 ustar 00root root 0000000 0000000 import interval from "./interval";
import {durationMinute, durationWeek} from "./duration";
function weekday(i) {
return interval(function(date) {
date.setDate(date.getDate() - (date.getDay() + 7 - i) % 7);
date.setHours(0, 0, 0, 0);
}, function(date, step) {
date.setDate(date.getDate() + step * 7);
}, function(start, end) {
return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationWeek;
});
}
export var sunday = weekday(0);
export var monday = weekday(1);
export var tuesday = weekday(2);
export var wednesday = weekday(3);
export var thursday = weekday(4);
export var friday = weekday(5);
export var saturday = weekday(6);
export var sundays = sunday.range;
export var mondays = monday.range;
export var tuesdays = tuesday.range;
export var wednesdays = wednesday.range;
export var thursdays = thursday.range;
export var fridays = friday.range;
export var saturdays = saturday.range;
d3-time-1.0.11/src/year.js 0000664 0000000 0000000 00000001362 13426151457 0015133 0 ustar 00root root 0000000 0000000 import interval from "./interval";
var year = interval(function(date) {
date.setMonth(0, 1);
date.setHours(0, 0, 0, 0);
}, function(date, step) {
date.setFullYear(date.getFullYear() + step);
}, function(start, end) {
return end.getFullYear() - start.getFullYear();
}, function(date) {
return date.getFullYear();
});
// An optimized implementation for this simple case.
year.every = function(k) {
return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : interval(function(date) {
date.setFullYear(Math.floor(date.getFullYear() / k) * k);
date.setMonth(0, 1);
date.setHours(0, 0, 0, 0);
}, function(date, step) {
date.setFullYear(date.getFullYear() + step * k);
});
};
export default year;
export var years = year.range;
d3-time-1.0.11/test/ 0000775 0000000 0000000 00000000000 13426151457 0014023 5 ustar 00root root 0000000 0000000 d3-time-1.0.11/test/date.js 0000664 0000000 0000000 00000002200 13426151457 0015270 0 ustar 00root root 0000000 0000000 exports.local = function(year, month, day, hours, minutes, seconds, milliseconds) {
if (year == null) year = 0;
if (month == null) month = 0;
if (day == null) day = 1;
if (hours == null) hours = 0;
if (minutes == null) minutes = 0;
if (seconds == null) seconds = 0;
if (milliseconds == null) milliseconds = 0;
if (0 <= year && year < 100) {
var date = new Date(-1, month, day, hours, minutes, seconds, milliseconds);
date.setFullYear(year);
return date;
}
return new Date(year, month, day, hours, minutes, seconds, milliseconds);
};
exports.utc = function(year, month, day, hours, minutes, seconds, milliseconds) {
if (year == null) year = 0;
if (month == null) month = 0;
if (day == null) day = 1;
if (hours == null) hours = 0;
if (minutes == null) minutes = 0;
if (seconds == null) seconds = 0;
if (milliseconds == null) milliseconds = 0;
if (0 <= year && year < 100) {
var date = new Date(Date.UTC(-1, month, day, hours, minutes, seconds, milliseconds));
date.setUTCFullYear(year);
return date;
}
return new Date(Date.UTC(year, month, day, hours, minutes, seconds, milliseconds));
};
d3-time-1.0.11/test/day-test.js 0000664 0000000 0000000 00000030403 13426151457 0016113 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("timeDays in an alias for timeDay.range", function(test) {
test.equal(time.timeDays, time.timeDay.range);
test.end();
});
tape("timeDay is an alias for timeDay.floor", function(test) {
test.equal(time.timeDay, time.timeDay.floor);
test.end();
});
tape("timeDay.floor(date) returns days", function(test) {
test.deepEqual(time.timeDay.floor(date.local(2010, 11, 31, 23)), date.local(2010, 11, 31));
test.deepEqual(time.timeDay.floor(date.local(2011, 00, 01, 00)), date.local(2011, 00, 01));
test.deepEqual(time.timeDay.floor(date.local(2011, 00, 01, 01)), date.local(2011, 00, 01));
test.end();
});
tape("timeDay.floor(date) observes daylight saving", function(test) {
test.deepEqual(time.timeDay.floor(date.utc(2011, 02, 13, 07)), date.local(2011, 02, 12));
test.deepEqual(time.timeDay.floor(date.utc(2011, 02, 13, 08)), date.local(2011, 02, 13));
test.deepEqual(time.timeDay.floor(date.utc(2011, 02, 13, 09)), date.local(2011, 02, 13));
test.deepEqual(time.timeDay.floor(date.utc(2011, 02, 13, 10)), date.local(2011, 02, 13));
test.deepEqual(time.timeDay.floor(date.utc(2011, 10, 06, 07)), date.local(2011, 10, 06));
test.deepEqual(time.timeDay.floor(date.utc(2011, 10, 06, 08)), date.local(2011, 10, 06));
test.deepEqual(time.timeDay.floor(date.utc(2011, 10, 06, 09)), date.local(2011, 10, 06));
test.deepEqual(time.timeDay.floor(date.utc(2011, 10, 06, 10)), date.local(2011, 10, 06));
test.end();
});
tape("timeDay.floor(date) handles years in the first century", function(test) {
test.deepEqual(time.timeDay.floor(date.local(0011, 10, 06, 07)), date.local(0011, 10, 06));
test.end();
});
tape("timeDay.round(date) returns days", function(test) {
test.deepEqual(time.timeDay.round(date.local(2010, 11, 30, 13)), date.local(2010, 11, 31));
test.deepEqual(time.timeDay.round(date.local(2010, 11, 30, 11)), date.local(2010, 11, 30));
test.end();
});
tape("timeDay.round(date) observes daylight saving", function(test) {
test.deepEqual(time.timeDay.round(date.utc(2011, 02, 13, 07)), date.local(2011, 02, 13));
test.deepEqual(time.timeDay.round(date.utc(2011, 02, 13, 08)), date.local(2011, 02, 13));
test.deepEqual(time.timeDay.round(date.utc(2011, 02, 13, 09)), date.local(2011, 02, 13));
test.deepEqual(time.timeDay.round(date.utc(2011, 02, 13, 20)), date.local(2011, 02, 14));
test.deepEqual(time.timeDay.round(date.utc(2011, 10, 06, 07)), date.local(2011, 10, 06));
test.deepEqual(time.timeDay.round(date.utc(2011, 10, 06, 08)), date.local(2011, 10, 06));
test.deepEqual(time.timeDay.round(date.utc(2011, 10, 06, 09)), date.local(2011, 10, 06));
test.deepEqual(time.timeDay.round(date.utc(2011, 10, 06, 20)), date.local(2011, 10, 07));
test.end();
});
tape("timeDay.round(date) handles midnight in leap years", function(test) {
test.deepEqual(time.timeDay.round(date.utc(2012, 02, 01, 00)), date.local(2012, 02, 01));
test.deepEqual(time.timeDay.round(date.utc(2012, 02, 01, 00)), date.local(2012, 02, 01));
test.end();
});
tape("timeDay.ceil(date) returns days", function(test) {
test.deepEqual(time.timeDay.ceil(date.local(2010, 11, 30, 23)), date.local(2010, 11, 31));
test.deepEqual(time.timeDay.ceil(date.local(2010, 11, 31, 00)), date.local(2010, 11, 31));
test.deepEqual(time.timeDay.ceil(date.local(2010, 11, 31, 01)), date.local(2011, 00, 01));
test.end();
});
tape("timeDay.ceil(date) observes start of daylight saving", function(test) {
test.deepEqual(time.timeDay.ceil(date.utc(2011, 02, 13, 07)), date.local(2011, 02, 13));
test.deepEqual(time.timeDay.ceil(date.utc(2011, 02, 13, 08)), date.local(2011, 02, 13));
test.deepEqual(time.timeDay.ceil(date.utc(2011, 02, 13, 09)), date.local(2011, 02, 14));
test.deepEqual(time.timeDay.ceil(date.utc(2011, 02, 13, 10)), date.local(2011, 02, 14));
test.end();
});
tape("timeDay.ceil(date) observes end of daylight saving", function(test) {
test.deepEqual(time.timeDay.ceil(date.utc(2011, 10, 06, 07)), date.local(2011, 10, 06));
test.deepEqual(time.timeDay.ceil(date.utc(2011, 10, 06, 08)), date.local(2011, 10, 07));
test.deepEqual(time.timeDay.ceil(date.utc(2011, 10, 06, 09)), date.local(2011, 10, 07));
test.deepEqual(time.timeDay.ceil(date.utc(2011, 10, 06, 10)), date.local(2011, 10, 07));
test.end();
});
tape("timeDay.ceil(date) handles midnight for leap years", function(test) {
test.deepEqual(time.timeDay.ceil(date.utc(2012, 02, 01, 00)), date.local(2012, 02, 01));
test.deepEqual(time.timeDay.ceil(date.utc(2012, 02, 01, 00)), date.local(2012, 02, 01));
test.end();
});
tape("timeDay.offset(date) is an alias for timeDay.offset(date, 1)", function(test) {
test.deepEqual(time.timeDay.offset(date.local(2010, 11, 31, 23, 59, 59, 999)), date.local(2011, 00, 01, 23, 59, 59, 999));
test.end();
});
tape("timeDay.offset(date, step) does not modify the passed-in date", function(test) {
var d = date.local(2010, 11, 31, 23, 59, 59, 999);
time.timeDay.offset(date, +1);
test.deepEqual(d, date.local(2010, 11, 31, 23, 59, 59, 999));
test.end();
});
tape("timeDay.offset(date, step) does not round the passed-in date", function(test) {
test.deepEqual(time.timeDay.offset(date.local(2010, 11, 31, 23, 59, 59, 999), +1), date.local(2011, 00, 01, 23, 59, 59, 999));
test.deepEqual(time.timeDay.offset(date.local(2010, 11, 31, 23, 59, 59, 456), -2), date.local(2010, 11, 29, 23, 59, 59, 456));
test.end();
});
tape("timeDay.offset(date, step) allows step to be negative", function(test) {
test.deepEqual(time.timeDay.offset(date.local(2010, 11, 31), -1), date.local(2010, 11, 30));
test.deepEqual(time.timeDay.offset(date.local(2011, 00, 01), -2), date.local(2010, 11, 30));
test.deepEqual(time.timeDay.offset(date.local(2011, 00, 01), -1), date.local(2010, 11, 31));
test.end();
});
tape("timeDay.offset(date, step) allows step to be positive", function(test) {
test.deepEqual(time.timeDay.offset(date.local(2010, 11, 31), +1), date.local(2011, 00, 01));
test.deepEqual(time.timeDay.offset(date.local(2010, 11, 30), +2), date.local(2011, 00, 01));
test.deepEqual(time.timeDay.offset(date.local(2010, 11, 30), +1), date.local(2010, 11, 31));
test.end();
});
tape("timeDay.offset(date, step) allows step to be zero", function(test) {
test.deepEqual(time.timeDay.offset(date.local(2010, 11, 31, 23, 59, 59, 999), 0), date.local(2010, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.timeDay.offset(date.local(2010, 11, 31, 23, 59, 58, 000), 0), date.local(2010, 11, 31, 23, 59, 58, 000));
test.end();
});
tape("timeDay.range(start, stop) returns days between start (inclusive) and stop (exclusive)", function(test) {
test.deepEqual(time.timeDay.range(date.local(2011, 10, 04), date.local(2011, 10, 10)), [
date.local(2011, 10, 04),
date.local(2011, 10, 05),
date.local(2011, 10, 06),
date.local(2011, 10, 07),
date.local(2011, 10, 08),
date.local(2011, 10, 09)
]);
test.end();
});
tape("timeDay.range(start, stop) returns days", function(test) {
test.deepEqual(time.timeDay.range(date.local(2011, 10, 04, 02), date.local(2011, 10, 10, 13)), [
date.local(2011, 10, 05),
date.local(2011, 10, 06),
date.local(2011, 10, 07),
date.local(2011, 10, 08),
date.local(2011, 10, 09),
date.local(2011, 10, 10)
]);
test.end();
});
tape("timeDay.range(start, stop) coerces start and stop to dates", function(test) {
test.deepEqual(time.timeDay.range(+date.local(2011, 10, 04), +date.local(2011, 10, 07)), [
date.local(2011, 10, 04),
date.local(2011, 10, 05),
date.local(2011, 10, 06)
]);
test.end();
});
tape("timeDay.range(start, stop) returns the empty array for invalid dates", function(test) {
test.deepEqual(time.timeDay.range(new Date(NaN), Infinity), []);
test.end();
});
tape("timeDay.range(start, stop) returns the empty array if start >= stop", function(test) {
test.deepEqual(time.timeDay.range(date.local(2011, 10, 10), date.local(2011, 10, 04)), []);
test.deepEqual(time.timeDay.range(date.local(2011, 10, 10), date.local(2011, 10, 10)), []);
test.end();
});
tape("timeDay.range(start, stop, step) returns every step day", function(test) {
test.deepEqual(time.timeDay.range(date.local(2011, 10, 04, 02), date.local(2011, 10, 14, 13), 3), [
date.local(2011, 10, 05),
date.local(2011, 10, 08),
date.local(2011, 10, 11),
date.local(2011, 10, 14)
]);
test.end();
});
tape("timeDay.range(start, stop, step) returns the empty array if step is zero, negative or NaN", function(test) {
test.deepEqual(time.timeDay.range(date.local(2011, 00, 01, 00), date.local(2011, 04, 09, 00), 0), []);
test.deepEqual(time.timeDay.range(date.local(2011, 00, 01, 00), date.local(2011, 04, 09, 00), -1), []);
test.deepEqual(time.timeDay.range(date.local(2011, 00, 01, 00), date.local(2011, 04, 09, 00), 0.5), []);
test.deepEqual(time.timeDay.range(date.local(2011, 00, 01, 00), date.local(2011, 04, 09, 00), NaN), []);
test.end();
});
tape("timeDay.count(start, end) counts days after start (exclusive) and before end (inclusive)", function(test) {
test.equal(time.timeDay.count(date.local(2011, 00, 01, 00), date.local(2011, 04, 09, 00)), 128);
test.equal(time.timeDay.count(date.local(2011, 00, 01, 01), date.local(2011, 04, 09, 00)), 128);
test.equal(time.timeDay.count(date.local(2010, 11, 31, 23), date.local(2011, 04, 09, 00)), 129);
test.equal(time.timeDay.count(date.local(2011, 00, 01, 00), date.local(2011, 04, 08, 23)), 127);
test.equal(time.timeDay.count(date.local(2011, 00, 01, 00), date.local(2011, 04, 09, 01)), 128);
test.end();
});
tape("timeDay.count(start, end) observes daylight saving", function(test) {
test.equal(time.timeDay.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 01)), 71);
test.equal(time.timeDay.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 03)), 71);
test.equal(time.timeDay.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 04)), 71);
test.equal(time.timeDay.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 00)), 309);
test.equal(time.timeDay.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 01)), 309);
test.equal(time.timeDay.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 02)), 309);
test.end();
});
tape("timeDay.count(start, stop) does not exhibit floating-point rounding error", function(test) {
var date = new Date(2011, 4, 9);
test.equal(time.timeDay.count(time.timeYear(date), date), 128);
test.end();
});
tape("timeDay.count(start, end) returns 364 or 365 for a full year", function(test) {
test.equal(time.timeDay.count(date.local(1999, 00, 01), date.local(1999, 11, 31)), 364);
test.equal(time.timeDay.count(date.local(2000, 00, 01), date.local(2000, 11, 31)), 365); // leap year
test.equal(time.timeDay.count(date.local(2001, 00, 01), date.local(2001, 11, 31)), 364);
test.equal(time.timeDay.count(date.local(2002, 00, 01), date.local(2002, 11, 31)), 364);
test.equal(time.timeDay.count(date.local(2003, 00, 01), date.local(2003, 11, 31)), 364);
test.equal(time.timeDay.count(date.local(2004, 00, 01), date.local(2004, 11, 31)), 365); // leap year
test.equal(time.timeDay.count(date.local(2005, 00, 01), date.local(2005, 11, 31)), 364);
test.equal(time.timeDay.count(date.local(2006, 00, 01), date.local(2006, 11, 31)), 364);
test.equal(time.timeDay.count(date.local(2007, 00, 01), date.local(2007, 11, 31)), 364);
test.equal(time.timeDay.count(date.local(2008, 00, 01), date.local(2008, 11, 31)), 365); // leap year
test.equal(time.timeDay.count(date.local(2009, 00, 01), date.local(2009, 11, 31)), 364);
test.equal(time.timeDay.count(date.local(2010, 00, 01), date.local(2010, 11, 31)), 364);
test.equal(time.timeDay.count(date.local(2011, 00, 01), date.local(2011, 11, 31)), 364);
test.end();
});
tape("timeDay.every(step) returns every stepth day, starting with the first day of the month", function(test) {
test.deepEqual(time.timeDay.every(3).range(date.local(2008, 11, 30, 0, 12), date.local(2009, 0, 5, 23, 48)), [date.local(2008, 11, 31), date.local(2009, 0, 1), date.local(2009, 0, 4)]);
test.deepEqual(time.timeDay.every(5).range(date.local(2008, 11, 30, 0, 12), date.local(2009, 0, 6, 23, 48)), [date.local(2008, 11, 31), date.local(2009, 0, 1), date.local(2009, 0, 6)]);
test.deepEqual(time.timeDay.every(7).range(date.local(2008, 11, 30, 0, 12), date.local(2009, 0, 8, 23, 48)), [date.local(2009, 0, 1), date.local(2009, 0, 8)]);
test.end();
});
d3-time-1.0.11/test/friday-test.js 0000664 0000000 0000000 00000005310 13426151457 0016613 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("timeFridays in an alias for timeFriday.range", function(test) {
test.equal(time.timeFridays, time.timeFriday.range);
test.end();
});
tape("timeFriday.floor(date) returns Fridays", function(test) {
test.deepEqual(time.timeFriday.floor(date.local(2011, 00, 05, 23, 59, 59)), date.local(2010, 11, 31));
test.deepEqual(time.timeFriday.floor(date.local(2011, 00, 06, 00, 00, 00)), date.local(2010, 11, 31));
test.deepEqual(time.timeFriday.floor(date.local(2011, 00, 06, 00, 00, 01)), date.local(2010, 11, 31));
test.deepEqual(time.timeFriday.floor(date.local(2011, 00, 06, 23, 59, 59)), date.local(2010, 11, 31));
test.deepEqual(time.timeFriday.floor(date.local(2011, 00, 07, 00, 00, 00)), date.local(2011, 00, 07));
test.deepEqual(time.timeFriday.floor(date.local(2011, 00, 07, 00, 00, 01)), date.local(2011, 00, 07));
test.end();
});
tape("timeFriday.count(start, end) counts Fridays after start (exclusive) and before end (inclusive)", function(test) {
// January 2012
// Su Mo Tu We Th Fr Sa
// 1 2 3 4 5 6 7
// 8 9 10 11 12 13 14
// 15 16 17 18 19 20 21
// 22 23 24 25 26 27 28
// 29 30 31
test.equal(time.timeFriday.count(date.local(2012, 00, 01), date.local(2012, 00, 05)), 0);
test.equal(time.timeFriday.count(date.local(2012, 00, 01), date.local(2012, 00, 06)), 1);
test.equal(time.timeFriday.count(date.local(2012, 00, 01), date.local(2012, 00, 07)), 1);
test.equal(time.timeFriday.count(date.local(2012, 00, 01), date.local(2012, 00, 13)), 2);
// January 2010
// Su Mo Tu We Th Fr Sa
// 1 2
// 3 4 5 6 7 8 9
// 10 11 12 13 14 15 16
// 17 18 19 20 21 22 23
// 24 25 26 27 28 29 30
// 31
test.equal(time.timeFriday.count(date.local(2010, 00, 01), date.local(2010, 00, 07)), 0);
test.equal(time.timeFriday.count(date.local(2010, 00, 01), date.local(2010, 00, 08)), 1);
test.equal(time.timeFriday.count(date.local(2010, 00, 01), date.local(2010, 00, 09)), 1);
test.end();
});
tape("timeFriday.count(start, end) observes daylight saving", function(test) {
test.equal(time.timeFriday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 01)), 10);
test.equal(time.timeFriday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 03)), 10);
test.equal(time.timeFriday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 04)), 10);
test.equal(time.timeFriday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 00)), 44);
test.equal(time.timeFriday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 01)), 44);
test.equal(time.timeFriday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 02)), 44);
test.end();
});
d3-time-1.0.11/test/hour-test.js 0000664 0000000 0000000 00000020023 13426151457 0016310 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("timeHour.floor(date) returns hours", function(test) {
test.deepEqual(time.timeHour.floor(date.local(2010, 11, 31, 23, 59)), date.local(2010, 11, 31, 23));
test.deepEqual(time.timeHour.floor(date.local(2011, 00, 01, 00, 00)), date.local(2011, 00, 01, 00));
test.deepEqual(time.timeHour.floor(date.local(2011, 00, 01, 00, 01)), date.local(2011, 00, 01, 00));
test.end();
});
tape("timeHour.floor(date) observes start of daylight savings time", function(test) {
test.deepEqual(time.timeHour.floor(date.utc(2011, 02, 13, 08, 59)), date.utc(2011, 02, 13, 08));
test.deepEqual(time.timeHour.floor(date.utc(2011, 02, 13, 09, 00)), date.utc(2011, 02, 13, 09));
test.deepEqual(time.timeHour.floor(date.utc(2011, 02, 13, 09, 01)), date.utc(2011, 02, 13, 09));
test.deepEqual(time.timeHour.floor(date.utc(2011, 02, 13, 09, 59)), date.utc(2011, 02, 13, 09));
test.deepEqual(time.timeHour.floor(date.utc(2011, 02, 13, 10, 00)), date.utc(2011, 02, 13, 10));
test.deepEqual(time.timeHour.floor(date.utc(2011, 02, 13, 10, 01)), date.utc(2011, 02, 13, 10));
test.end();
});
tape("timeHour.floor(date) observes end of daylight savings time", function(test) {
test.deepEqual(time.timeHour.floor(date.utc(2011, 10, 06, 07, 59)), date.utc(2011, 10, 06, 07));
test.deepEqual(time.timeHour.floor(date.utc(2011, 10, 06, 08, 00)), date.utc(2011, 10, 06, 08));
test.deepEqual(time.timeHour.floor(date.utc(2011, 10, 06, 08, 01)), date.utc(2011, 10, 06, 08));
test.deepEqual(time.timeHour.floor(date.utc(2011, 10, 06, 08, 59)), date.utc(2011, 10, 06, 08));
test.deepEqual(time.timeHour.floor(date.utc(2011, 10, 06, 09, 00)), date.utc(2011, 10, 06, 09));
test.deepEqual(time.timeHour.floor(date.utc(2011, 10, 06, 09, 01)), date.utc(2011, 10, 06, 09));
test.end();
});
tape("timeHour.ceil(date) returns hours", function(test) {
test.deepEqual(time.timeHour.ceil(date.local(2010, 11, 31, 23, 59)), date.local(2011, 00, 01, 00));
test.deepEqual(time.timeHour.ceil(date.local(2011, 00, 01, 00, 00)), date.local(2011, 00, 01, 00));
test.deepEqual(time.timeHour.ceil(date.local(2011, 00, 01, 00, 01)), date.local(2011, 00, 01, 01));
test.end();
});
tape("timeHour.ceil(date) observes start of daylight savings time", function(test) {
test.deepEqual(time.timeHour.ceil(date.utc(2011, 02, 13, 08, 59)), date.utc(2011, 02, 13, 09));
test.deepEqual(time.timeHour.ceil(date.utc(2011, 02, 13, 09, 00)), date.utc(2011, 02, 13, 09));
test.deepEqual(time.timeHour.ceil(date.utc(2011, 02, 13, 09, 01)), date.utc(2011, 02, 13, 10));
test.deepEqual(time.timeHour.ceil(date.utc(2011, 02, 13, 09, 59)), date.utc(2011, 02, 13, 10));
test.deepEqual(time.timeHour.ceil(date.utc(2011, 02, 13, 10, 00)), date.utc(2011, 02, 13, 10));
test.deepEqual(time.timeHour.ceil(date.utc(2011, 02, 13, 10, 01)), date.utc(2011, 02, 13, 11));
test.end();
});
tape("timeHour.ceil(date) observes end of daylight savings time", function(test) {
test.deepEqual(time.timeHour.ceil(date.utc(2011, 10, 06, 07, 59)), date.utc(2011, 10, 06, 08));
test.deepEqual(time.timeHour.ceil(date.utc(2011, 10, 06, 08, 00)), date.utc(2011, 10, 06, 08));
test.deepEqual(time.timeHour.ceil(date.utc(2011, 10, 06, 08, 01)), date.utc(2011, 10, 06, 09));
test.deepEqual(time.timeHour.ceil(date.utc(2011, 10, 06, 08, 59)), date.utc(2011, 10, 06, 09));
test.deepEqual(time.timeHour.ceil(date.utc(2011, 10, 06, 09, 00)), date.utc(2011, 10, 06, 09));
test.deepEqual(time.timeHour.ceil(date.utc(2011, 10, 06, 09, 01)), date.utc(2011, 10, 06, 10));
test.end();
});
tape("timeHour.offset(date) does not modify the passed-in date", function(test) {
var d = date.local(2010, 11, 31, 23, 59, 59, 999);
time.timeHour.offset(d, +1);
test.deepEqual(d, date.local(2010, 11, 31, 23, 59, 59, 999));
test.end();
});
tape("timeHour.offset(date) does not round the passed-in-date", function(test) {
test.deepEqual(time.timeHour.offset(date.local(2010, 11, 31, 23, 59, 59, 999), +1), date.local(2011, 00, 01, 00, 59, 59, 999));
test.deepEqual(time.timeHour.offset(date.local(2010, 11, 31, 23, 59, 59, 456), -2), date.local(2010, 11, 31, 21, 59, 59, 456));
test.end();
});
tape("timeHour.offset(date) allows negative offsets", function(test) {
test.deepEqual(time.timeHour.offset(date.local(2010, 11, 31, 12), -1), date.local(2010, 11, 31, 11));
test.deepEqual(time.timeHour.offset(date.local(2011, 00, 01, 01), -2), date.local(2010, 11, 31, 23));
test.deepEqual(time.timeHour.offset(date.local(2011, 00, 01, 00), -1), date.local(2010, 11, 31, 23));
test.end();
});
tape("timeHour.offset(date) allows positive offsets", function(test) {
test.deepEqual(time.timeHour.offset(date.local(2010, 11, 31, 11), +1), date.local(2010, 11, 31, 12));
test.deepEqual(time.timeHour.offset(date.local(2010, 11, 31, 23), +2), date.local(2011, 00, 01, 01));
test.deepEqual(time.timeHour.offset(date.local(2010, 11, 31, 23), +1), date.local(2011, 00, 01, 00));
test.end();
});
tape("timeHour.offset(date) allows zero offset", function(test) {
test.deepEqual(time.timeHour.offset(date.local(2010, 11, 31, 23, 59, 59, 999), 0), date.local(2010, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.timeHour.offset(date.local(2010, 11, 31, 23, 59, 58, 000), 0), date.local(2010, 11, 31, 23, 59, 58, 000));
test.end();
});
tape("timeHour.range(start, stop) returns hours", function(test) {
test.deepEqual(time.timeHour.range(date.local(2010, 11, 31, 12, 30), date.local(2010, 11, 31, 15, 30)), [
date.local(2010, 11, 31, 13),
date.local(2010, 11, 31, 14),
date.local(2010, 11, 31, 15)
]);
test.end();
});
tape("timeHour.range(start, stop) has an inclusive lower bound", function(test) {
test.deepEqual(time.timeHour.range(date.local(2010, 11, 31, 23), date.local(2011, 0, 1, 2))[0], date.local(2010, 11, 31, 23));
test.end();
});
tape("timeHour.range(start, stop) has an exclusive upper bound", function(test) {
test.deepEqual(time.timeHour.range(date.local(2010, 11, 31, 23), date.local(2011, 0, 1, 2))[2], date.local(2011, 0, 1, 1));
test.end();
});
tape("timeHour.range(start, stop) can skip hours", function(test) {
test.deepEqual(time.timeHour.range(date.local(2011, 1, 1, 1), date.local(2011, 1, 1, 13), 3), [
date.local(2011, 1, 1, 1),
date.local(2011, 1, 1, 4),
date.local(2011, 1, 1, 7),
date.local(2011, 1, 1, 10)
]);
test.end();
});
tape("timeHour.range(start, stop) observes start of daylight savings time", function(test) {
test.deepEqual(time.timeHour.range(date.local(2011, 2, 13, 1), date.local(2011, 2, 13, 5)), [
date.utc(2011, 2, 13, 9),
date.utc(2011, 2, 13, 10),
date.utc(2011, 2, 13, 11)
]);
test.end();
});
tape("timeHour.range(start, stop) observes end of daylight savings time", function(test) {
test.deepEqual(time.timeHour.range(date.local(2011, 10, 6, 0), date.local(2011, 10, 6, 2)), [
date.utc(2011, 10, 6, 7),
date.utc(2011, 10, 6, 8),
date.utc(2011, 10, 6, 9)
]);
test.end();
});
tape("timeHour.every(step) returns every stepth hour, starting with the first hour of the day", function(test) {
test.deepEqual(time.timeHour.every(4).range(date.local(2008, 11, 30, 12, 47), date.local(2008, 11, 31, 13, 57)), [date.local(2008, 11, 30, 16), date.local(2008, 11, 30, 20), date.local(2008, 11, 31, 0), date.local(2008, 11, 31, 4), date.local(2008, 11, 31, 8), date.local(2008, 11, 31, 12)]);
test.deepEqual(time.timeHour.every(12).range(date.local(2008, 11, 30, 12, 47), date.local(2008, 11, 31, 13, 57)), [date.local(2008, 11, 31, 0), date.local(2008, 11, 31, 12)]);
test.end();
});
tape("timeHour.range(start, stop) returns every hour crossing the daylight savings boundary", function(test) {
test.deepEqual(time.timeHour.range(new Date(1478422800000 - 2 * 36e5), new Date(1478422800000 + 2 * 36e5)), [
new Date(1478415600000), // Sun Nov 06 2016 00:00:00 GMT-0700 (PDT)
new Date(1478419200000), // Sun Nov 06 2016 01:00:00 GMT-0700 (PDT)
new Date(1478422800000), // Sun Nov 06 2016 01:00:00 GMT-0800 (PDT)
new Date(1478426400000) // Sun Nov 06 2016 02:00:00 GMT-0800 (PDT)
]);
test.end();
});
d3-time-1.0.11/test/interval-test.js 0000664 0000000 0000000 00000011510 13426151457 0017160 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("timeInterval is an alias for timeInterval.floor", function(test) {
test.equal(time.timeYear, time.timeYear.floor);
test.end();
});
tape("timeInterval(floor, offset) returns a custom time interval", function(test) {
var i = time.timeInterval(function(date) {
date.setUTCMinutes(0, 0, 0);
}, function(date, step) {
date.setUTCHours(date.getUTCHours() + step);
});
test.deepEqual(i(date.utc(2015, 0, 1, 12, 34, 56, 789)), date.utc(2015, 0, 1, 12));
test.end();
});
tape("timeInterval(floor, offset) does not define a count method", function(test) {
var i = time.timeInterval(function(date) {
date.setUTCMinutes(0, 0, 0);
}, function(date, step) {
date.setUTCHours(date.getUTCHours() + step);
});
test.ok(!("count" in i));
test.end();
});
tape("timeInterval(floor, offset) floors the step before passing it to offset", function(test) {
var steps = [], i = time.timeInterval(function(date) {
date.setUTCMinutes(0, 0, 0);
}, function(date, step) {
steps.push(+step), date.setUTCHours(date.getUTCHours() + step);
});
test.deepEqual(i.offset(date.utc(2015, 0, 1, 12, 34, 56, 789), 1.5), date.utc(2015, 0, 1, 13, 34, 56, 789));
test.deepEqual(i.range(date.utc(2015, 0, 1, 12), date.utc(2015, 0, 1, 15), 1.5), [date.utc(2015, 0, 1, 12), date.utc(2015, 0, 1, 13), date.utc(2015, 0, 1, 14)]);
test.ok(steps.every(function(step) { return step === 1; }));
test.end();
});
tape("timeInterval(floor, offset, count) defines a count method", function(test) {
var i = time.timeInterval(function(date) {
date.setUTCMinutes(0, 0, 0);
}, function(date, step) {
date.setUTCHours(date.getUTCHours() + step);
}, function(start, end) {
return (end - start) / 36e5;
});
test.equal(i.count(date.utc(2015, 0, 1, 12, 34), date.utc(2015, 0, 1, 15, 56)), 3);
test.end();
});
tape("timeInterval(floor, offset, count) floors dates before passing them to count", function(test) {
var dates = [], i = time.timeInterval(function(date) {
date.setUTCMinutes(0, 0, 0);
}, function(date, step) {
date.setUTCHours(date.getUTCHours() + step);
}, function(start, end) {
return dates.push(new Date(+start), new Date(+end)), (end - start) / 36e5;
});
i.count(date.utc(2015, 0, 1, 12, 34), date.utc(2015, 0, 1, 15, 56));
test.deepEqual(dates, [date.utc(2015, 0, 1, 12), date.utc(2015, 0, 1, 15)]);
test.end();
});
tape("timeInterval.every(step) returns null if step is invalid", function(test) {
test.equal(time.timeDay.every(), null);
test.equal(time.timeMinute.every(null), null);
test.equal(time.timeSecond.every(undefined), null);
test.equal(time.timeDay.every(NaN), null);
test.equal(time.timeMinute.every(0), null);
test.equal(time.timeSecond.every(0.8), null);
test.equal(time.timeHour.every(-1), null);
test.end();
});
tape("timeInterval.every(step) returns interval if step is one", function(test) {
test.equal(time.timeDay.every("1"), time.timeDay);
test.equal(time.timeMinute.every(1), time.timeMinute);
test.equal(time.timeSecond.every(1.8), time.timeSecond);
test.end();
});
tape("timeInterval.every(step).range(invalid, invalid) returns the empty array", function(test) {
test.deepEqual(time.timeMinute.every(15).range(NaN, NaN), []);
test.end();
});
tape("timeInterval.every(…).offset(date, step) returns the expected value when step is positive", function(test) {
var i = time.timeMinute.every(15);
test.deepEqual(i.offset(date.local(2015, 0, 1, 12, 34), 0), date.local(2015, 0, 1, 12, 34));
test.deepEqual(i.offset(date.local(2015, 0, 1, 12, 34), 1), date.local(2015, 0, 1, 12, 45));
test.deepEqual(i.offset(date.local(2015, 0, 1, 12, 34), 2), date.local(2015, 0, 1, 13, 00));
test.deepEqual(i.offset(date.local(2015, 0, 1, 12, 34), 3), date.local(2015, 0, 1, 13, 15));
test.deepEqual(i.offset(date.local(2015, 0, 1, 12, 34), 4), date.local(2015, 0, 1, 13, 30));
test.deepEqual(i.offset(date.local(2015, 0, 1, 12, 34), 5), date.local(2015, 0, 1, 13, 45));
test.end();
});
tape("timeInterval.every(…).offset(date, step) returns the expected value when step is negative", function(test) {
var i = time.timeMinute.every(15);
test.deepEqual(i.offset(date.local(2015, 0, 1, 12, 34), -1), date.local(2015, 0, 1, 12, 30));
test.deepEqual(i.offset(date.local(2015, 0, 1, 12, 34), -2), date.local(2015, 0, 1, 12, 15));
test.deepEqual(i.offset(date.local(2015, 0, 1, 12, 34), -3), date.local(2015, 0, 1, 12, 00));
test.end();
});
tape("timeInterval.every(…).offset(date, step) returns the expected value when step is not an integer", function(test) {
var i = time.timeMinute.every(15);
test.deepEqual(i.offset(date.local(2015, 0, 1, 12, 34), 1.2), date.local(2015, 0, 1, 12, 45));
test.deepEqual(i.offset(date.local(2015, 0, 1, 12, 34), -0.8), date.local(2015, 0, 1, 12, 30));
test.end();
});
d3-time-1.0.11/test/millisecond-test.js 0000664 0000000 0000000 00000002527 13426151457 0017646 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("timeMillisecond.every(step) returns every stepth millisecond, starting with the first millisecond of the second", function(test) {
test.deepEqual(time.timeMillisecond.every(50).range(date.local(2008, 11, 30, 12, 36, 0, 947), date.local(2008, 11, 30, 12, 36, 1, 157)), [date.local(2008, 11, 30, 12, 36, 0, 950), date.local(2008, 11, 30, 12, 36, 1, 0), date.local(2008, 11, 30, 12, 36, 1, 50), date.local(2008, 11, 30, 12, 36, 1, 100), date.local(2008, 11, 30, 12, 36, 1, 150)]);
test.deepEqual(time.timeMillisecond.every(100).range(date.local(2008, 11, 30, 12, 36, 0, 947), date.local(2008, 11, 30, 12, 36, 1, 157)), [date.local(2008, 11, 30, 12, 36, 1, 0), date.local(2008, 11, 30, 12, 36, 1, 100)]);
test.deepEqual(time.timeMillisecond.every(50).range(date.utc(2008, 11, 30, 12, 36, 0, 947), date.utc(2008, 11, 30, 12, 36, 1, 157)), [date.utc(2008, 11, 30, 12, 36, 0, 950), date.utc(2008, 11, 30, 12, 36, 1, 0), date.utc(2008, 11, 30, 12, 36, 1, 50), date.utc(2008, 11, 30, 12, 36, 1, 100), date.utc(2008, 11, 30, 12, 36, 1, 150)]);
test.deepEqual(time.timeMillisecond.every(100).range(date.utc(2008, 11, 30, 12, 36, 0, 947), date.utc(2008, 11, 30, 12, 36, 1, 157)), [date.utc(2008, 11, 30, 12, 36, 1, 0), date.utc(2008, 11, 30, 12, 36, 1, 100)]);
test.end();
});
d3-time-1.0.11/test/minute-test.js 0000664 0000000 0000000 00000013410 13426151457 0016636 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("timeMinute.floor(date) returns minutes", function(test) {
test.deepEqual(time.timeMinute.floor(date.local(2010, 11, 31, 23, 59, 59)), date.local(2010, 11, 31, 23, 59));
test.deepEqual(time.timeMinute.floor(date.local(2011, 00, 01, 00, 00, 00)), date.local(2011, 00, 01, 00, 00));
test.deepEqual(time.timeMinute.floor(date.local(2011, 00, 01, 00, 00, 59)), date.local(2011, 00, 01, 00, 00));
test.deepEqual(time.timeMinute.floor(date.local(2011, 00, 01, 00, 01, 00)), date.local(2011, 00, 01, 00, 01));
test.end();
});
tape("timeMinute.ceil(date) returns minutes", function(test) {
test.deepEqual(time.timeMinute.ceil(date.local(2010, 11, 31, 23, 59, 59)), date.local(2011, 00, 01, 00, 00));
test.deepEqual(time.timeMinute.ceil(date.local(2011, 00, 01, 00, 00, 00)), date.local(2011, 00, 01, 00, 00));
test.deepEqual(time.timeMinute.ceil(date.local(2011, 00, 01, 00, 00, 59)), date.local(2011, 00, 01, 00, 01));
test.deepEqual(time.timeMinute.ceil(date.local(2011, 00, 01, 00, 01, 00)), date.local(2011, 00, 01, 00, 01));
test.end();
});
tape("timeMinute.offset(date) does not modify the passed-in date", function(test) {
var d = date.local(2010, 11, 31, 23, 59, 59, 999);
time.timeMinute.offset(d, +1);
test.deepEqual(d, date.local(2010, 11, 31, 23, 59, 59, 999));
test.end();
});
tape("timeMinute.offset(date) does not round the passed-in-date", function(test) {
test.deepEqual(time.timeMinute.offset(date.local(2010, 11, 31, 23, 59, 59, 999), +1), date.local(2011, 00, 01, 00, 00, 59, 999));
test.deepEqual(time.timeMinute.offset(date.local(2010, 11, 31, 23, 59, 59, 456), -2), date.local(2010, 11, 31, 23, 57, 59, 456));
test.end();
});
tape("timeMinute.offset(date) allows negative offsets", function(test) {
test.deepEqual(time.timeMinute.offset(date.local(2010, 11, 31, 23, 12), -1), date.local(2010, 11, 31, 23, 11));
test.deepEqual(time.timeMinute.offset(date.local(2011, 00, 01, 00, 01), -2), date.local(2010, 11, 31, 23, 59));
test.deepEqual(time.timeMinute.offset(date.local(2011, 00, 01, 00, 00), -1), date.local(2010, 11, 31, 23, 59));
test.end();
});
tape("timeMinute.offset(date) allows positive offsets", function(test) {
test.deepEqual(time.timeMinute.offset(date.local(2010, 11, 31, 23, 11), +1), date.local(2010, 11, 31, 23, 12));
test.deepEqual(time.timeMinute.offset(date.local(2010, 11, 31, 23, 59), +2), date.local(2011, 00, 01, 00, 01));
test.deepEqual(time.timeMinute.offset(date.local(2010, 11, 31, 23, 59), +1), date.local(2011, 00, 01, 00, 00));
test.end();
});
tape("timeMinute.offset(date) allows zero offset", function(test) {
test.deepEqual(time.timeMinute.offset(date.local(2010, 11, 31, 23, 59, 59, 999), 0), date.local(2010, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.timeMinute.offset(date.local(2010, 11, 31, 23, 59, 58, 000), 0), date.local(2010, 11, 31, 23, 59, 58, 000));
test.end();
});
tape("timeMinute.range(start, stop), returns minutes", function(test) {
test.deepEqual(time.timeMinute.range(date.local(2010, 11, 31, 23, 59), date.local(2011, 0, 1, 0, 2)), [
date.local(2010, 11, 31, 23, 59),
date.local(2011, 0, 1, 0, 0),
date.local(2011, 0, 1, 0, 1)
]);
test.end();
});
tape("timeMinute.range(start, stop), has an inclusive lower bound", function(test) {
test.deepEqual(time.timeMinute.range(date.local(2010, 11, 31, 23, 59), date.local(2011, 0, 1, 0, 2))[0], date.local(2010, 11, 31, 23, 59));
test.end();
});
tape("timeMinute.range(start, stop), has an exclusive upper bound", function(test) {
test.deepEqual(time.timeMinute.range(date.local(2010, 11, 31, 23, 59), date.local(2011, 0, 1, 0, 2))[2], date.local(2011, 0, 1, 0, 1));
test.end();
});
tape("timeMinute.range(start, stop), can skip minutes", function(test) {
test.deepEqual(time.timeMinute.range(date.local(2011, 1, 1, 12, 7), date.local(2011, 1, 1, 13, 7), 15), [
date.local(2011, 1, 1, 12, 7),
date.local(2011, 1, 1, 12, 22),
date.local(2011, 1, 1, 12, 37),
date.local(2011, 1, 1, 12, 52)
]);
test.end();
});
tape("timeMinute.range(start, stop), observes start of daylight savings time", function(test) {
test.deepEqual(time.timeMinute.range(date.utc(2011, 2, 13, 9, 59), date.utc(2011, 2, 13, 10, 2)), [
date.utc(2011, 2, 13, 9, 59),
date.utc(2011, 2, 13, 10, 0),
date.utc(2011, 2, 13, 10, 1)
]);
test.end();
});
tape("timeMinute.range(start, stop), observes end of daylight savings time", function(test) {
test.deepEqual(time.timeMinute.range(date.utc(2011, 10, 6, 8, 59), date.utc(2011, 10, 6, 9, 2)), [
date.utc(2011, 10, 6, 8, 59),
date.utc(2011, 10, 6, 9, 0),
date.utc(2011, 10, 6, 9, 1)
]);
test.end();
});
tape("timeMinute.every(step) returns every stepth minute, starting with the first minute of the hour", function(test) {
test.deepEqual(time.timeMinute.every(15).range(date.local(2008, 11, 30, 12, 47), date.local(2008, 11, 30, 13, 57)), [date.local(2008, 11, 30, 13, 0), date.local(2008, 11, 30, 13, 15), date.local(2008, 11, 30, 13, 30), date.local(2008, 11, 30, 13, 45)]);
test.deepEqual(time.timeMinute.every(30).range(date.local(2008, 11, 30, 12, 47), date.local(2008, 11, 30, 13, 57)), [date.local(2008, 11, 30, 13, 0), date.local(2008, 11, 30, 13, 30)]);
test.end();
});
tape("timeMinute.range(start, stop) returns every minute crossing the daylight savings boundary", function(test) {
test.deepEqual(time.timeMinute.range(new Date(1478422800000 - 2 * 6e4), new Date(1478422800000 + 2 * 6e4)), [
new Date(1478422680000), // Sun Nov 06 2016 01:58:00 GMT-0700 (PDT)
new Date(1478422740000), // Sun Nov 06 2016 01:59:00 GMT-0700 (PDT)
new Date(1478422800000), // Sun Nov 06 2016 01:00:00 GMT-0800 (PDT)
new Date(1478422860000) // Sun Nov 06 2016 01:01:00 GMT-0800 (PDT)
]);
test.end();
});
d3-time-1.0.11/test/monday-test.js 0000664 0000000 0000000 00000005750 13426151457 0016634 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("timeMondays in an alias for timeMonday.range", function(test) {
test.equal(time.timeMondays, time.timeMonday.range);
test.end();
});
tape("timeMonday.floor(date) returns Mondays", function(test) {
test.deepEqual(time.timeMonday.floor(date.local(2011, 00, 01, 23, 59, 59)), date.local(2010, 11, 27));
test.deepEqual(time.timeMonday.floor(date.local(2011, 00, 02, 00, 00, 00)), date.local(2010, 11, 27));
test.deepEqual(time.timeMonday.floor(date.local(2011, 00, 02, 00, 00, 01)), date.local(2010, 11, 27));
test.deepEqual(time.timeMonday.floor(date.local(2011, 00, 02, 23, 59, 59)), date.local(2010, 11, 27));
test.deepEqual(time.timeMonday.floor(date.local(2011, 00, 03, 00, 00, 00)), date.local(2011, 00, 03));
test.deepEqual(time.timeMonday.floor(date.local(2011, 00, 03, 00, 00, 01)), date.local(2011, 00, 03));
test.end();
});
tape("timeMonday.range(start, stop, step) returns every step Monday", function(test) {
test.deepEqual(time.timeMonday.range(date.local(2011, 11, 01), date.local(2012, 00, 15), 2), [
date.local(2011, 11, 05),
date.local(2011, 11, 19),
date.local(2012, 00, 02)
]);
test.end();
});
tape("timeMonday.count(start, end) counts Mondays after start (exclusive) and before end (inclusive)", function(test) {
// January 2014
// Su Mo Tu We Th Fr Sa
// 1 2 3 4
// 5 6 7 8 9 10 11
// 12 13 14 15 16 17 18
// 19 20 21 22 23 24 25
// 26 27 28 29 30 31
test.equal(time.timeMonday.count(date.local(2014, 00, 01), date.local(2014, 00, 05)), 0);
test.equal(time.timeMonday.count(date.local(2014, 00, 01), date.local(2014, 00, 06)), 1);
test.equal(time.timeMonday.count(date.local(2014, 00, 01), date.local(2014, 00, 07)), 1);
test.equal(time.timeMonday.count(date.local(2014, 00, 01), date.local(2014, 00, 13)), 2);
// January 2018
// Su Mo Tu We Th Fr Sa
// 1 2 3 4 5 6
// 7 8 9 10 11 12 13
// 14 15 16 17 18 19 20
// 21 22 23 24 25 26 27
// 28 29 30 31
test.equal(time.timeMonday.count(date.local(2018, 00, 01), date.local(2018, 00, 07)), 0);
test.equal(time.timeMonday.count(date.local(2018, 00, 01), date.local(2018, 00, 08)), 1);
test.equal(time.timeMonday.count(date.local(2018, 00, 01), date.local(2018, 00, 09)), 1);
test.end();
});
tape("timeMonday.count(start, end) observes daylight saving", function(test) {
test.equal(time.timeMonday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 01)), 10);
test.equal(time.timeMonday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 03)), 10);
test.equal(time.timeMonday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 04)), 10);
test.equal(time.timeMonday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 00)), 44);
test.equal(time.timeMonday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 01)), 44);
test.equal(time.timeMonday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 02)), 44);
test.end();
});
d3-time-1.0.11/test/month-test.js 0000664 0000000 0000000 00000034517 13426151457 0016475 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("timeMonths in an alias for timeMonth.range", function(test) {
test.equal(time.timeMonths, time.timeMonth.range);
test.end();
});
tape("timeMonth.floor(date) returns months", function(test) {
test.deepEqual(time.timeMonth.floor(date.local(2010, 11, 31, 23, 59, 59)), date.local(2010, 11, 01));
test.deepEqual(time.timeMonth.floor(date.local(2011, 00, 01, 00, 00, 00)), date.local(2011, 00, 01));
test.deepEqual(time.timeMonth.floor(date.local(2011, 00, 01, 00, 00, 01)), date.local(2011, 00, 01));
test.end();
});
tape("timeMonth.floor(date) observes the start of daylight savings time", function(test) {
test.deepEqual(time.timeMonth.floor(date.local(2011, 02, 13, 01)), date.local(2011, 02, 01));
test.end();
});
tape("timeMonth.floor(date) observes the end of the daylight savings time", function(test) {
test.deepEqual(time.timeMonth.floor(date.local(2011, 10, 06, 01)), date.local(2011, 10, 01));
test.end();
});
tape("timeMonth.floor(date) correctly handles years in the first century", function(test) {
test.deepEqual(time.timeMonth.floor(date.local(0011, 10, 06, 07)), date.local(0011, 10, 01));
test.end();
});
tape("timeMonth.ceil(date) returns months", function(test) {
test.deepEqual(time.timeMonth.ceil(date.local(2010, 11, 31, 23, 59, 59)), date.local(2011, 00, 01));
test.deepEqual(time.timeMonth.ceil(date.local(2011, 00, 01, 00, 00, 00)), date.local(2011, 00, 01));
test.deepEqual(time.timeMonth.ceil(date.local(2011, 00, 01, 00, 00, 01)), date.local(2011, 01, 01));
test.end();
});
tape("timeMonth.ceil(date) observes the start of daylight savings time", function(test) {
test.deepEqual(time.timeMonth.ceil(date.local(2011, 02, 13, 01)), date.local(2011, 03, 01));
test.end();
});
tape("timeMonth.ceil(date) observes the end of the daylight savings time", function(test) {
test.deepEqual(time.timeMonth.ceil(date.local(2011, 10, 06, 01)), date.local(2011, 11, 01));
test.end();
});
tape("timeMonth.offset(date) does not modify the passed-in date", function(test) {
var d = date.local(2010, 11, 31, 23, 59, 59, 999);
time.timeMonth.offset(d, +1);
test.deepEqual(d, date.local(2010, 11, 31, 23, 59, 59, 999));
test.end();
});
tape("timeMonth.offset(date) does not round the passed-in-date", function(test) {
test.deepEqual(time.timeMonth.offset(date.local(2010, 11, 31, 23, 59, 59, 999), +1), date.local(2011, 00, 31, 23, 59, 59, 999));
test.deepEqual(time.timeMonth.offset(date.local(2010, 11, 31, 23, 59, 59, 456), -2), date.local(2010, 09, 31, 23, 59, 59, 456));
test.end();
});
tape("timeMonth.offset(date) allows negative offsets", function(test) {
test.deepEqual(time.timeMonth.offset(date.local(2010, 11, 01), -1), date.local(2010, 10, 01));
test.deepEqual(time.timeMonth.offset(date.local(2011, 00, 01), -2), date.local(2010, 10, 01));
test.deepEqual(time.timeMonth.offset(date.local(2011, 00, 01), -1), date.local(2010, 11, 01));
test.end();
});
tape("timeMonth.offset(date) allows positive offsets", function(test) {
test.deepEqual(time.timeMonth.offset(date.local(2010, 10, 01), +1), date.local(2010, 11, 01));
test.deepEqual(time.timeMonth.offset(date.local(2010, 10, 01), +2), date.local(2011, 00, 01));
test.deepEqual(time.timeMonth.offset(date.local(2010, 11, 01), +1), date.local(2011, 00, 01));
test.end();
});
tape("timeMonth.offset(date) allows zero offset", function(test) {
test.deepEqual(time.timeMonth.offset(date.local(2010, 11, 31, 23, 59, 59, 999), 0), date.local(2010, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.timeMonth.offset(date.local(2010, 11, 31, 23, 59, 58, 000), 0), date.local(2010, 11, 31, 23, 59, 58, 000));
test.end();
});
tape("timeMonths in an alias for timeMonth.range", function(test) {
test.equal(time.timeMonths, time.timeMonth.range);
test.end();
});
tape("timeMonth.floor(date) returns months", function(test) {
test.deepEqual(time.timeMonth.floor(date.local(2010, 11, 31, 23)), date.local(2010, 11, 01));
test.deepEqual(time.timeMonth.floor(date.local(2011, 00, 01, 00)), date.local(2011, 00, 01));
test.deepEqual(time.timeMonth.floor(date.local(2011, 00, 01, 01)), date.local(2011, 00, 01));
test.end();
});
tape("timeMonth.floor(date) observes daylight saving", function(test) {
test.deepEqual(time.timeMonth.floor(date.utc(2011, 02, 13, 07)), date.local(2011, 02, 01));
test.deepEqual(time.timeMonth.floor(date.utc(2011, 02, 13, 08)), date.local(2011, 02, 01));
test.deepEqual(time.timeMonth.floor(date.utc(2011, 02, 13, 09)), date.local(2011, 02, 01));
test.deepEqual(time.timeMonth.floor(date.utc(2011, 02, 13, 10)), date.local(2011, 02, 01));
test.deepEqual(time.timeMonth.floor(date.utc(2011, 10, 06, 07)), date.local(2011, 10, 01));
test.deepEqual(time.timeMonth.floor(date.utc(2011, 10, 06, 08)), date.local(2011, 10, 01));
test.deepEqual(time.timeMonth.floor(date.utc(2011, 10, 06, 09)), date.local(2011, 10, 01));
test.deepEqual(time.timeMonth.floor(date.utc(2011, 10, 06, 10)), date.local(2011, 10, 01));
test.end();
});
tape("timeMonth.floor(date) handles years in the first century", function(test) {
test.deepEqual(time.timeMonth.floor(date.local(0011, 10, 06, 07)), date.local(0011, 10, 01));
test.end();
});
tape("timeMonth.round(date) returns months", function(test) {
test.deepEqual(time.timeMonth.round(date.local(2010, 11, 16, 12)), date.local(2011, 00, 01));
test.deepEqual(time.timeMonth.round(date.local(2010, 11, 16, 11)), date.local(2010, 11, 01));
test.end();
});
tape("timeMonth.round(date) observes daylight saving", function(test) {
test.deepEqual(time.timeMonth.round(date.utc(2011, 02, 13, 07)), date.local(2011, 02, 01));
test.deepEqual(time.timeMonth.round(date.utc(2011, 02, 13, 08)), date.local(2011, 02, 01));
test.deepEqual(time.timeMonth.round(date.utc(2011, 02, 13, 09)), date.local(2011, 02, 01));
test.deepEqual(time.timeMonth.round(date.utc(2011, 02, 13, 20)), date.local(2011, 02, 01));
test.deepEqual(time.timeMonth.round(date.utc(2011, 10, 06, 07)), date.local(2011, 10, 01));
test.deepEqual(time.timeMonth.round(date.utc(2011, 10, 06, 08)), date.local(2011, 10, 01));
test.deepEqual(time.timeMonth.round(date.utc(2011, 10, 06, 09)), date.local(2011, 10, 01));
test.deepEqual(time.timeMonth.round(date.utc(2011, 10, 06, 20)), date.local(2011, 10, 01));
test.end();
});
tape("timeMonth.round(date) handles midnight for leap years", function(test) {
test.deepEqual(time.timeMonth.round(date.utc(2012, 02, 01, 00)), date.local(2012, 02, 01));
test.deepEqual(time.timeMonth.round(date.utc(2012, 02, 01, 00)), date.local(2012, 02, 01));
test.end();
});
tape("timeMonth.ceil(date) returns months", function(test) {
test.deepEqual(time.timeMonth.ceil(date.local(2010, 10, 30, 23)), date.local(2010, 11, 01));
test.deepEqual(time.timeMonth.ceil(date.local(2010, 11, 01, 01)), date.local(2011, 00, 01));
test.deepEqual(time.timeMonth.ceil(date.local(2011, 1, 1)), date.local(2011, 1, 1));
test.deepEqual(time.timeMonth.ceil(date.local(2011, 2, 1)), date.local(2011, 2, 1));
test.deepEqual(time.timeMonth.ceil(date.local(2011, 3, 1)), date.local(2011, 3, 1));
test.end();
});
tape("timeMonth.ceil(date) observes daylight saving", function(test) {
test.deepEqual(time.timeMonth.ceil(date.utc(2011, 02, 13, 07)), date.local(2011, 03, 01));
test.deepEqual(time.timeMonth.ceil(date.utc(2011, 02, 13, 08)), date.local(2011, 03, 01));
test.deepEqual(time.timeMonth.ceil(date.utc(2011, 02, 13, 09)), date.local(2011, 03, 01));
test.deepEqual(time.timeMonth.ceil(date.utc(2011, 02, 13, 10)), date.local(2011, 03, 01));
test.deepEqual(time.timeMonth.ceil(date.utc(2011, 10, 06, 07)), date.local(2011, 11, 01));
test.deepEqual(time.timeMonth.ceil(date.utc(2011, 10, 06, 08)), date.local(2011, 11, 01));
test.deepEqual(time.timeMonth.ceil(date.utc(2011, 10, 06, 09)), date.local(2011, 11, 01));
test.deepEqual(time.timeMonth.ceil(date.utc(2011, 10, 06, 10)), date.local(2011, 11, 01));
test.end();
});
tape("timeMonth.ceil(date) handles midnight for leap years", function(test) {
test.deepEqual(time.timeMonth.ceil(date.utc(2012, 02, 01, 00)), date.local(2012, 02, 01));
test.deepEqual(time.timeMonth.ceil(date.utc(2012, 02, 01, 00)), date.local(2012, 02, 01));
test.end();
});
tape("timeMonth.offset(date) is an alias for timeMonth.offset(date, 1)", function(test) {
test.deepEqual(time.timeMonth.offset(date.local(2010, 11, 31, 23, 59, 59, 999)), date.local(2011, 00, 31, 23, 59, 59, 999));
test.end();
});
tape("timeMonth.offset(date, step) does not modify the passed-in date", function(test) {
var d = date.local(2010, 11, 31, 23, 59, 59, 999);
time.timeMonth.offset(date, +1);
test.deepEqual(d, date.local(2010, 11, 31, 23, 59, 59, 999));
test.end();
});
tape("timeMonth.offset(date, step) does not round the passed-in date", function(test) {
test.deepEqual(time.timeMonth.offset(date.local(2010, 11, 31, 23, 59, 59, 999), +1), date.local(2011, 00, 31, 23, 59, 59, 999));
test.deepEqual(time.timeMonth.offset(date.local(2010, 11, 31, 23, 59, 59, 456), -2), date.local(2010, 09, 31, 23, 59, 59, 456));
test.end();
});
tape("timeMonth.offset(date, step) allows step to be negative", function(test) {
test.deepEqual(time.timeMonth.offset(date.local(2010, 11, 31), -1), date.local(2010, 10, 31));
test.deepEqual(time.timeMonth.offset(date.local(2011, 00, 01), -2), date.local(2010, 10, 01));
test.deepEqual(time.timeMonth.offset(date.local(2011, 00, 01), -1), date.local(2010, 11, 01));
test.end();
});
tape("timeMonth.offset(date, step) allows step to be positive", function(test) {
test.deepEqual(time.timeMonth.offset(date.local(2010, 11, 31), +1), date.local(2011, 00, 31));
test.deepEqual(time.timeMonth.offset(date.local(2010, 11, 30), +2), date.local(2011, 01, 30));
test.deepEqual(time.timeMonth.offset(date.local(2010, 11, 30), +1), date.local(2011, 00, 30));
test.end();
});
tape("timeMonth.offset(date, step) allows step to be zero", function(test) {
test.deepEqual(time.timeMonth.offset(date.local(2010, 11, 31, 23, 59, 59, 999), 0), date.local(2010, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.timeMonth.offset(date.local(2010, 11, 31, 23, 59, 58, 000), 0), date.local(2010, 11, 31, 23, 59, 58, 000));
test.end();
});
tape("timeMonth.range(start, stop) returns months between start (inclusive) and stop (exclusive)", function(test) {
test.deepEqual(time.timeMonth.range(date.local(2011, 11, 01), date.local(2012, 05, 01)), [
date.local(2011, 11, 01),
date.local(2012, 00, 01),
date.local(2012, 01, 01),
date.local(2012, 02, 01),
date.local(2012, 03, 01),
date.local(2012, 04, 01)
]);
test.end();
});
tape("timeMonth.range(start, stop) returns months", function(test) {
test.deepEqual(time.timeMonth.range(date.local(2011, 10, 04, 02), date.local(2012, 04, 10, 13)), [
date.local(2011, 11, 01),
date.local(2012, 00, 01),
date.local(2012, 01, 01),
date.local(2012, 02, 01),
date.local(2012, 03, 01),
date.local(2012, 04, 01)
]);
test.end();
});
tape("timeMonth.range(start, stop) coerces start and stop to dates", function(test) {
test.deepEqual(time.timeMonth.range(+date.local(2011, 10, 04), +date.local(2012, 01, 07)), [
date.local(2011, 11, 01),
date.local(2012, 00, 01),
date.local(2012, 01, 01)
]);
test.end();
});
tape("timeMonth.range(start, stop) returns the empty array for invalid dates", function(test) {
test.deepEqual(time.timeMonth.range(new Date(NaN), Infinity), []);
test.end();
});
tape("timeMonth.range(start, stop) returns the empty array if start >= stop", function(test) {
test.deepEqual(time.timeMonth.range(date.local(2011, 11, 10), date.local(2011, 10, 04)), []);
test.deepEqual(time.timeMonth.range(date.local(2011, 10, 01), date.local(2011, 10, 01)), []);
test.end();
});
tape("timeMonth.range(start, stop) returns months", function(test) {
test.deepEqual(time.timeMonth.range(date.local(2010, 10, 31), date.local(2011, 2, 1)), [
date.local(2010, 11, 1),
date.local(2011, 0, 1),
date.local(2011, 1, 1)
]);
test.end();
});
tape("timeMonth.range(start, stop) has an inclusive lower bound", function(test) {
test.deepEqual(time.timeMonth.range(date.local(2010, 10, 31), date.local(2011, 2, 1))[0], date.local(2010, 11, 1));
test.end();
});
tape("timeMonth.range(start, stop) has an exclusive upper bound", function(test) {
test.deepEqual(time.timeMonth.range(date.local(2010, 10, 31), date.local(2011, 2, 1))[2], date.local(2011, 1, 1));
test.end();
});
tape("timeMonth.range(start, stop) can skip months", function(test) {
test.deepEqual(time.timeMonth.range(date.local(2011, 1, 1), date.local(2012, 1, 1), 3), [
date.local(2011, 1, 1),
date.local(2011, 4, 1),
date.local(2011, 7, 1),
date.local(2011, 10, 1)
]);
test.end();
});
tape("timeMonth.range(start, stop) observes start of daylight savings time", function(test) {
test.deepEqual(time.timeMonth.range(date.local(2011, 0, 1), date.local(2011, 4, 1)), [
date.local(2011, 0, 1),
date.local(2011, 1, 1),
date.local(2011, 2, 1),
date.local(2011, 3, 1)
]);
test.end();
});
tape("timeMonth.range(start, stop) observes end of daylight savings time", function(test) {
test.deepEqual(time.timeMonth.range(date.local(2011, 9, 1), date.local(2012, 1, 1)), [
date.local(2011, 9, 1),
date.local(2011, 10, 1),
date.local(2011, 11, 1),
date.local(2012, 0, 1)
]);
test.end();
});
tape("timeMonth.count(start, end) counts months after start (exclusive) and before end (inclusive)", function(test) {
test.equal(time.timeMonth.count(date.local(2011, 00, 01), date.local(2011, 04, 01)), 4);
test.equal(time.timeMonth.count(date.local(2011, 00, 01), date.local(2011, 03, 30)), 3);
test.equal(time.timeMonth.count(date.local(2010, 11, 31), date.local(2011, 03, 30)), 4);
test.equal(time.timeMonth.count(date.local(2010, 11, 31), date.local(2011, 04, 01)), 5);
test.equal(time.timeMonth.count(date.local(2009, 11, 31), date.local(2012, 04, 01)), 29);
test.equal(time.timeMonth.count(date.local(2012, 04, 01), date.local(2009, 11, 31)), -29);
test.end();
});
tape("timeMonth.every(step) returns every stepth month, starting with the first month of the year", function(test) {
test.deepEqual(time.timeMonth.every(3).range(date.local(2008, 11, 3), date.local(2010, 6, 5)), [date.local(2009, 0, 1), date.local(2009, 3, 1), date.local(2009, 6, 1), date.local(2009, 9, 1), date.local(2010, 0, 1), date.local(2010, 3, 1), date.local(2010, 6, 1)]);
test.end();
});
d3-time-1.0.11/test/multiYear-test.js 0000664 0000000 0000000 00000004202 13426151457 0017307 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("timeYear.every(n).floor(date) returns integer multiples of n years", function(test) {
test.deepEqual(time.timeYear.every(10).floor(date.local(2009, 11, 31, 23, 59, 59)), date.local(2000, 00, 01));
test.deepEqual(time.timeYear.every(10).floor(date.local(2010, 00, 01, 00, 00, 00)), date.local(2010, 00, 01));
test.deepEqual(time.timeYear.every(10).floor(date.local(2010, 00, 01, 00, 00, 01)), date.local(2010, 00, 01));
test.end();
});
tape("timeYear.every(n).ceil(date) returns integer multiples of n years", function(test) {
test.deepEqual(time.timeYear.every(100).ceil(date.local(1999, 11, 31, 23, 59, 59)), date.local(2000, 00, 01));
test.deepEqual(time.timeYear.every(100).ceil(date.local(2000, 00, 01, 00, 00, 00)), date.local(2000, 00, 01));
test.deepEqual(time.timeYear.every(100).ceil(date.local(2000, 00, 01, 00, 00, 01)), date.local(2100, 00, 01));
test.end();
});
tape("timeYear.every(n).offset(date, count) does not modify the passed-in date", function(test) {
var d = date.local(2010, 11, 31, 23, 59, 59, 999);
time.timeYear.every(5).offset(d, +1);
test.deepEqual(d, date.local(2010, 11, 31, 23, 59, 59, 999));
test.end();
});
tape("timeYear.every(n).offset(date, count) does not round the passed-in-date", function(test) {
test.deepEqual(time.timeYear.every(5).offset(date.local(2010, 11, 31, 23, 59, 59, 999), +1), date.local(2015, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.timeYear.every(5).offset(date.local(2010, 11, 31, 23, 59, 59, 456), -2), date.local(2000, 11, 31, 23, 59, 59, 456));
test.end();
});
tape("timeYear.every(n) does not define interval.count or interval.every", function(test) {
var decade = time.timeYear.every(10);
test.equal(decade.count, undefined);
test.equal(decade.every, undefined);
test.end();
});
tape("timeYear.every(n).range(start, stop) returns multiples of n years", function(test) {
test.deepEqual(time.timeYear.every(10).range(date.local(2010, 0, 1), date.local(2031, 0, 1)), [
date.local(2010, 0, 1),
date.local(2020, 0, 1),
date.local(2030, 0, 1)
]);
test.end();
});
d3-time-1.0.11/test/saturday-test.js 0000664 0000000 0000000 00000005403 13426151457 0017174 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("timeSaturdays in an alias for timeSaturday.range", function(test) {
test.equal(time.timeSaturdays, time.timeSaturday.range);
test.end();
});
tape("timeSaturday.floor(date) returns Saturdays", function(test) {
test.deepEqual(time.timeSaturday.floor(date.local(2011, 00, 06, 23, 59, 59)), date.local(2011, 00, 01));
test.deepEqual(time.timeSaturday.floor(date.local(2011, 00, 07, 00, 00, 00)), date.local(2011, 00, 01));
test.deepEqual(time.timeSaturday.floor(date.local(2011, 00, 07, 00, 00, 01)), date.local(2011, 00, 01));
test.deepEqual(time.timeSaturday.floor(date.local(2011, 00, 07, 23, 59, 59)), date.local(2011, 00, 01));
test.deepEqual(time.timeSaturday.floor(date.local(2011, 00, 08, 00, 00, 00)), date.local(2011, 00, 08));
test.deepEqual(time.timeSaturday.floor(date.local(2011, 00, 08, 00, 00, 01)), date.local(2011, 00, 08));
test.end();
});
tape("timeSaturday.count(start, end) counts Saturdays after start (exclusive) and before end (inclusive)", function(test) {
// January 2012
// Su Mo Tu We Th Fr Sa
// 1 2 3 4 5 6 7
// 8 9 10 11 12 13 14
// 15 16 17 18 19 20 21
// 22 23 24 25 26 27 28
// 29 30 31
test.equal(time.timeSaturday.count(date.local(2012, 00, 01), date.local(2012, 00, 06)), 0);
test.equal(time.timeSaturday.count(date.local(2012, 00, 01), date.local(2012, 00, 07)), 1);
test.equal(time.timeSaturday.count(date.local(2012, 00, 01), date.local(2012, 00, 08)), 1);
test.equal(time.timeSaturday.count(date.local(2012, 00, 01), date.local(2012, 00, 14)), 2);
// January 2011
// Su Mo Tu We Th Fr Sa
// 1
// 2 3 4 5 6 7 8
// 9 10 11 12 13 14 15
// 16 17 18 19 20 21 22
// 23 24 25 26 27 28 29
// 30 31
test.equal(time.timeSaturday.count(date.local(2011, 00, 01), date.local(2011, 00, 07)), 0);
test.equal(time.timeSaturday.count(date.local(2011, 00, 01), date.local(2011, 00, 08)), 1);
test.equal(time.timeSaturday.count(date.local(2011, 00, 01), date.local(2011, 00, 09)), 1);
test.end();
});
tape("timeSaturday.count(start, end) observes daylight saving", function(test) {
test.equal(time.timeSaturday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 01)), 10);
test.equal(time.timeSaturday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 03)), 10);
test.equal(time.timeSaturday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 04)), 10);
test.equal(time.timeSaturday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 00)), 44);
test.equal(time.timeSaturday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 01)), 44);
test.equal(time.timeSaturday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 02)), 44);
test.end();
});
d3-time-1.0.11/test/second-test.js 0000664 0000000 0000000 00000014360 13426151457 0016615 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("timeSecond.floor(date) returns seconds", function(test) {
test.deepEqual(time.timeSecond.floor(date.local(2010, 11, 31, 23, 59, 59, 999)), date.local(2010, 11, 31, 23, 59, 59));
test.deepEqual(time.timeSecond.floor(date.local(2011, 00, 01, 00, 00, 00, 000)), date.local(2011, 00, 01, 00, 00, 00));
test.deepEqual(time.timeSecond.floor(date.local(2011, 00, 01, 00, 00, 00, 001)), date.local(2011, 00, 01, 00, 00, 00));
test.end();
});
tape("timeSecond.round(date) returns seconds", function(test) {
test.deepEqual(time.timeSecond.round(date.local(2010, 11, 31, 23, 59, 59, 999)), date.local(2011, 00, 01, 00, 00, 00));
test.deepEqual(time.timeSecond.round(date.local(2011, 00, 01, 00, 00, 00, 499)), date.local(2011, 00, 01, 00, 00, 00));
test.deepEqual(time.timeSecond.round(date.local(2011, 00, 01, 00, 00, 00, 500)), date.local(2011, 00, 01, 00, 00, 01));
test.end();
});
tape("timeSecond.ceil(date) returns seconds", function(test) {
test.deepEqual(time.timeSecond.ceil(date.local(2010, 11, 31, 23, 59, 59, 999)), date.local(2011, 00, 01, 00, 00, 00));
test.deepEqual(time.timeSecond.ceil(date.local(2011, 00, 01, 00, 00, 00, 000)), date.local(2011, 00, 01, 00, 00, 00));
test.deepEqual(time.timeSecond.ceil(date.local(2011, 00, 01, 00, 00, 00, 001)), date.local(2011, 00, 01, 00, 00, 01));
test.end();
});
tape("timeSecond.offset(date, step) does not modify the passed-in date", function(test) {
var d = date.local(2010, 11, 31, 23, 59, 59, 999);
time.timeSecond.offset(d, +1);
test.deepEqual(d, date.local(2010, 11, 31, 23, 59, 59, 999));
test.end();
});
tape("timeSecond.offset(date, step) does not round the passed-in-date", function(test) {
test.deepEqual(time.timeSecond.offset(date.local(2010, 11, 31, 23, 59, 59, 999), +1), date.local(2011, 00, 01, 00, 00, 00, 999));
test.deepEqual(time.timeSecond.offset(date.local(2010, 11, 31, 23, 59, 59, 456), -2), date.local(2010, 11, 31, 23, 59, 57, 456));
test.end();
});
tape("timeSecond.offset(date, step) allows negative offsets", function(test) {
test.deepEqual(time.timeSecond.offset(date.local(2010, 11, 31, 23, 59, 59), -1), date.local(2010, 11, 31, 23, 59, 58));
test.deepEqual(time.timeSecond.offset(date.local(2011, 00, 01, 00, 00, 00), -2), date.local(2010, 11, 31, 23, 59, 58));
test.deepEqual(time.timeSecond.offset(date.local(2011, 00, 01, 00, 00, 00), -1), date.local(2010, 11, 31, 23, 59, 59));
test.end();
});
tape("timeSecond.offset(date, step) allows positive offsets", function(test) {
test.deepEqual(time.timeSecond.offset(date.local(2010, 11, 31, 23, 59, 58), +1), date.local(2010, 11, 31, 23, 59, 59));
test.deepEqual(time.timeSecond.offset(date.local(2010, 11, 31, 23, 59, 58), +2), date.local(2011, 00, 01, 00, 00, 00));
test.deepEqual(time.timeSecond.offset(date.local(2010, 11, 31, 23, 59, 59), +1), date.local(2011, 00, 01, 00, 00, 00));
test.end();
});
tape("timeSecond.offset(date, step) allows zero offset", function(test) {
test.deepEqual(time.timeSecond.offset(date.local(2010, 11, 31, 23, 59, 59, 999), 0), date.local(2010, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.timeSecond.offset(date.local(2010, 11, 31, 23, 59, 58, 000), 0), date.local(2010, 11, 31, 23, 59, 58, 000));
test.end();
});
tape("timeSecond.range(start, stop) returns seconds", function(test) {
test.deepEqual(time.timeSecond.range(date.local(2010, 11, 31, 23, 59, 59), date.local(2011, 0, 1, 0, 0, 2)), [
date.local(2010, 11, 31, 23, 59, 59),
date.local(2011, 0, 1, 0, 0, 0),
date.local(2011, 0, 1, 0, 0, 1)
]);
test.end();
});
tape("timeSecond.range(start, stop) has an inclusive lower bound", function(test) {
test.deepEqual(time.timeSecond.range(date.local(2010, 11, 31, 23, 59, 59), date.local(2011, 0, 1, 0, 0, 2))[0], date.local(2010, 11, 31, 23, 59, 59));
test.end();
});
tape("timeSecond.range(start, stop) has an exclusive upper bound", function(test) {
test.deepEqual(time.timeSecond.range(date.local(2010, 11, 31, 23, 59, 59), date.local(2011, 0, 1, 0, 0, 2))[2], date.local(2011, 0, 1, 0, 0, 1));
test.end();
});
tape("timeSecond.range(start, stop, step) can skip seconds", function(test) {
test.deepEqual(time.timeSecond.range(date.local(2011, 1, 1, 12, 0, 7), date.local(2011, 1, 1, 12, 1, 7), 15), [
date.local(2011, 1, 1, 12, 0, 7),
date.local(2011, 1, 1, 12, 0, 22),
date.local(2011, 1, 1, 12, 0, 37),
date.local(2011, 1, 1, 12, 0, 52)
]);
test.end();
});
tape("timeSecond.range(start, stop) observes start of daylight savings time", function(test) {
test.deepEqual(time.timeSecond.range(date.utc(2011, 2, 13, 9, 59, 59), date.utc(2011, 2, 13, 10, 0, 2)), [
date.utc(2011, 2, 13, 9, 59, 59),
date.utc(2011, 2, 13, 10, 0, 0),
date.utc(2011, 2, 13, 10, 0, 1)
]);
test.end();
});
tape("timeSecond.range(start, stop) observes end of daylight savings time", function(test) {
test.deepEqual(time.timeSecond.range(date.utc(2011, 10, 6, 8, 59, 59), date.utc(2011, 10, 6, 9, 0, 2)), [
date.utc(2011, 10, 6, 8, 59, 59),
date.utc(2011, 10, 6, 9, 0, 0),
date.utc(2011, 10, 6, 9, 0, 1)
]);
test.end();
});
tape("timeSecond.every(step) returns every stepth second, starting with the first second of the minute", function(test) {
test.deepEqual(time.timeSecond.every(15).range(date.local(2008, 11, 30, 12, 36, 47), date.local(2008, 11, 30, 12, 37, 57)), [date.local(2008, 11, 30, 12, 37, 0), date.local(2008, 11, 30, 12, 37, 15), date.local(2008, 11, 30, 12, 37, 30), date.local(2008, 11, 30, 12, 37, 45)]);
test.deepEqual(time.timeSecond.every(30).range(date.local(2008, 11, 30, 12, 36, 47), date.local(2008, 11, 30, 12, 37, 57)), [date.local(2008, 11, 30, 12, 37, 0), date.local(2008, 11, 30, 12, 37, 30)]);
test.end();
});
tape("timeSecond.range(start, stop) returns every second crossing the daylight savings boundary", function(test) {
test.deepEqual(time.timeSecond.range(new Date(1478422800000 - 2 * 1e3), new Date(1478422800000 + 2 * 1e3)), [
new Date(1478422798000), // Sun Nov 06 2016 01:59:58 GMT-0700 (PDT)
new Date(1478422799000), // Sun Nov 06 2016 01:59:59 GMT-0700 (PDT)
new Date(1478422800000), // Sun Nov 06 2016 01:00:00 GMT-0800 (PDT)
new Date(1478422801000) // Sun Nov 06 2016 01:00:01 GMT-0800 (PDT)
]);
test.end();
});
d3-time-1.0.11/test/sunday-test.js 0000664 0000000 0000000 00000020037 13426151457 0016643 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("timeSundays in an alias for timeSunday.range", function(test) {
test.equal(time.timeSundays, time.timeSunday.range);
test.end();
});
tape("timeSunday.floor(date) returns Sundays", function(test) {
test.deepEqual(time.timeSunday.floor(date.local(2010, 11, 31, 23, 59, 59)), date.local(2010, 11, 26));
test.deepEqual(time.timeSunday.floor(date.local(2011, 00, 01, 00, 00, 00)), date.local(2010, 11, 26));
test.deepEqual(time.timeSunday.floor(date.local(2011, 00, 01, 00, 00, 01)), date.local(2010, 11, 26));
test.deepEqual(time.timeSunday.floor(date.local(2011, 00, 01, 23, 59, 59)), date.local(2010, 11, 26));
test.deepEqual(time.timeSunday.floor(date.local(2011, 00, 02, 00, 00, 00)), date.local(2011, 00, 02));
test.deepEqual(time.timeSunday.floor(date.local(2011, 00, 02, 00, 00, 01)), date.local(2011, 00, 02));
test.end();
});
tape("timeSunday.floor(date) observes daylight saving", function(test) {
test.deepEqual(time.timeSunday.floor(date.local(2011, 02, 13, 01)), date.local(2011, 02, 13));
test.deepEqual(time.timeSunday.floor(date.local(2011, 10, 06, 01)), date.local(2011, 10, 06));
test.end();
});
tape("timeSunday.floor(date) handles years in the first century", function(test) {
test.deepEqual(time.timeSunday.floor(date.local(0011, 10, 06, 07)), date.local(0011, 10, 01));
test.end();
});
tape("timeSunday.ceil(date) returns Sundays", function(test) {
test.deepEqual(time.timeSunday.ceil(date.local(2010, 11, 31, 23, 59, 59)), date.local(2011, 00, 02));
test.deepEqual(time.timeSunday.ceil(date.local(2011, 00, 01, 00, 00, 00)), date.local(2011, 00, 02));
test.deepEqual(time.timeSunday.ceil(date.local(2011, 00, 01, 00, 00, 01)), date.local(2011, 00, 02));
test.deepEqual(time.timeSunday.ceil(date.local(2011, 00, 01, 23, 59, 59)), date.local(2011, 00, 02));
test.deepEqual(time.timeSunday.ceil(date.local(2011, 00, 02, 00, 00, 00)), date.local(2011, 00, 02));
test.deepEqual(time.timeSunday.ceil(date.local(2011, 00, 02, 00, 00, 01)), date.local(2011, 00, 09));
test.end();
});
tape("timeSunday.ceil(date) observes daylight saving", function(test) {
test.deepEqual(time.timeSunday.ceil(date.local(2011, 02, 13, 01)), date.local(2011, 02, 20));
test.deepEqual(time.timeSunday.ceil(date.local(2011, 10, 06, 01)), date.local(2011, 10, 13));
test.end();
});
tape("timeSunday.offset(date) is an alias for timeSunday.offset(date, 1)", function(test) {
test.deepEqual(time.timeSunday.offset(date.local(2010, 11, 31, 23, 59, 59, 999)), date.local(2011, 00, 07, 23, 59, 59, 999));
test.end();
});
tape("timeSunday.offset(date, step) does not modify the passed-in date", function(test) {
var d = date.local(2010, 11, 31, 23, 59, 59, 999);
time.timeSunday.offset(d, +1);
test.deepEqual(d, date.local(2010, 11, 31, 23, 59, 59, 999));
test.end();
});
tape("timeSunday.offset(date, step) does not round the passed-in date", function(test) {
test.deepEqual(time.timeSunday.offset(date.local(2010, 11, 31, 23, 59, 59, 999), +1), date.local(2011, 00, 07, 23, 59, 59, 999));
test.deepEqual(time.timeSunday.offset(date.local(2010, 11, 31, 23, 59, 59, 456), -2), date.local(2010, 11, 17, 23, 59, 59, 456));
test.end();
});
tape("timeSunday.offset(date, step) allows step to be negative", function(test) {
test.deepEqual(time.timeSunday.offset(date.local(2010, 11, 01), -1), date.local(2010, 10, 24));
test.deepEqual(time.timeSunday.offset(date.local(2011, 00, 01), -2), date.local(2010, 11, 18));
test.deepEqual(time.timeSunday.offset(date.local(2011, 00, 01), -1), date.local(2010, 11, 25));
test.end();
});
tape("timeSunday.offset(date, step) allows step to be positive", function(test) {
test.deepEqual(time.timeSunday.offset(date.local(2010, 10, 24), +1), date.local(2010, 11, 01));
test.deepEqual(time.timeSunday.offset(date.local(2010, 11, 18), +2), date.local(2011, 00, 01));
test.deepEqual(time.timeSunday.offset(date.local(2010, 11, 25), +1), date.local(2011, 00, 01));
test.end();
});
tape("timeSunday.offset(date, step) allows step to be zero", function(test) {
test.deepEqual(time.timeSunday.offset(date.local(2010, 11, 31, 23, 59, 59, 999), 0), date.local(2010, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.timeSunday.offset(date.local(2010, 11, 31, 23, 59, 58, 000), 0), date.local(2010, 11, 31, 23, 59, 58, 000));
test.end();
});
tape("timeSunday.range(start, stop) returns Sundays between start (inclusive) and stop (exclusive)", function(test) {
test.deepEqual(time.timeSunday.range(date.local(2011, 11, 01), date.local(2012, 00, 15)), [
date.local(2011, 11, 04),
date.local(2011, 11, 11),
date.local(2011, 11, 18),
date.local(2011, 11, 25),
date.local(2012, 00, 01),
date.local(2012, 00, 08)
]);
test.end();
});
tape("timeSunday.range(start, stop) returns Sundays", function(test) {
test.deepEqual(time.timeSunday.range(date.local(2011, 11, 01, 12, 23), date.local(2012, 00, 14, 12, 23)), [
date.local(2011, 11, 04),
date.local(2011, 11, 11),
date.local(2011, 11, 18),
date.local(2011, 11, 25),
date.local(2012, 00, 01),
date.local(2012, 00, 08)
]);
test.end();
});
tape("timeSunday.range(start, stop) coerces start and stop to dates", function(test) {
test.deepEqual(time.timeSunday.range(+date.local(2011, 11, 01), +date.local(2012, 00, 15)), [
date.local(2011, 11, 04),
date.local(2011, 11, 11),
date.local(2011, 11, 18),
date.local(2011, 11, 25),
date.local(2012, 00, 01),
date.local(2012, 00, 08)
]);
test.end();
});
tape("timeSunday.range(start, stop) returns the empty array for invalid dates", function(test) {
test.deepEqual(time.timeSunday.range(new Date(NaN), Infinity), []);
test.end();
});
tape("timeSunday.range(start, stop) returns the empty array if start >= stop", function(test) {
test.deepEqual(time.timeSunday.range(date.local(2011, 11, 10), date.local(2011, 10, 04)), []);
test.deepEqual(time.timeSunday.range(date.local(2011, 10, 01), date.local(2011, 10, 01)), []);
test.end();
});
tape("timeSunday.range(start, stop, step) returns every step Sunday", function(test) {
test.deepEqual(time.timeSunday.range(date.local(2011, 11, 01), date.local(2012, 00, 15), 2), [
date.local(2011, 11, 04),
date.local(2011, 11, 18),
date.local(2012, 00, 01)
]);
test.end();
});
tape("timeSunday.count(start, end) counts Sundays after start (exclusive) and before end (inclusive)", function(test) {
// January 2014
// Su Mo Tu We Th Fr Sa
// 1 2 3 4
// 5 6 7 8 9 10 11
// 12 13 14 15 16 17 18
// 19 20 21 22 23 24 25
// 26 27 28 29 30 31
test.equal(time.timeSunday.count(date.local(2014, 00, 01), date.local(2014, 00, 04)), 0);
test.equal(time.timeSunday.count(date.local(2014, 00, 01), date.local(2014, 00, 05)), 1);
test.equal(time.timeSunday.count(date.local(2014, 00, 01), date.local(2014, 00, 06)), 1);
test.equal(time.timeSunday.count(date.local(2014, 00, 01), date.local(2014, 00, 12)), 2);
// January 2012
// Su Mo Tu We Th Fr Sa
// 1 2 3 4 5 6 7
// 8 9 10 11 12 13 14
// 15 16 17 18 19 20 21
// 22 23 24 25 26 27 28
// 29 30 31
test.equal(time.timeSunday.count(date.local(2012, 00, 01), date.local(2012, 00, 07)), 0);
test.equal(time.timeSunday.count(date.local(2012, 00, 01), date.local(2012, 00, 08)), 1);
test.equal(time.timeSunday.count(date.local(2012, 00, 01), date.local(2012, 00, 09)), 1);
test.end();
});
tape("timeSunday.count(start, end) observes daylight saving", function(test) {
test.equal(time.timeSunday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 01)), 11);
test.equal(time.timeSunday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 03)), 11);
test.equal(time.timeSunday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 04)), 11);
test.equal(time.timeSunday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 00)), 45);
test.equal(time.timeSunday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 01)), 45);
test.equal(time.timeSunday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 02)), 45);
test.end();
});
d3-time-1.0.11/test/test-time-zones 0000775 0000000 0000000 00000020275 13426151457 0017026 0 ustar 00root root 0000000 0000000 #!/bin/bash
function test()
{
if [[ $1 -eq 0 ]]
then
echo -e "\x1B[1;32m✓ $2\x1B[0m"
else
echo -e "\x1B[1;31m✗ $2\x1B[0m"
fi
}
# [ "$(TZ=UTC+03:15 node -e 'd3 = require("./"); console.log(d3.timeHour.floor(new Date(1456279843199)))')" = "Tue Feb 23 2016 22:00:00 GMT-0315 (UTC)" ]; test $? "timeHour.floor with -:15 UTC offset"
# [ "$(TZ=UTC+03:15 node -e 'd3 = require("./"); console.log(d3.timeHour.ceil(new Date(1456279843199)))')" = "Tue Feb 23 2016 23:00:00 GMT-0315 (UTC)" ]; test $? "timeHour.ceil with -:15 UTC offset"
# [ "$(TZ=UTC+03:15 node -e 'd3 = require("./"); console.log(d3.timeHour.range(new Date(2011, 10, 7, 0), new Date(2011, 10, 7, 3)).join(","))')" = "Mon Nov 07 2011 00:00:00 GMT-0315 (UTC),Mon Nov 07 2011 01:00:00 GMT-0315 (UTC),Mon Nov 07 2011 02:00:00 GMT-0315 (UTC)" ]; test $? "timeHour.range with -:15 UTC offset"
# [ "$(TZ=UTC-03:15 node -e 'd3 = require("./"); console.log(d3.timeHour.floor(new Date(1456279843199)))')" = "Wed Feb 24 2016 05:00:00 GMT+0315 (UTC)" ]; test $? "timeHour.floor with +:15 UTC offset"
# [ "$(TZ=UTC-03:15 node -e 'd3 = require("./"); console.log(d3.timeHour.ceil(new Date(1456279843199)))')" = "Wed Feb 24 2016 06:00:00 GMT+0315 (UTC)" ]; test $? "timeHour.ceil with +:15 UTC offset"
# [ "$(TZ=UTC-03:15 node -e 'd3 = require("./"); console.log(d3.timeHour.range(new Date(2011, 10, 7, 0), new Date(2011, 10, 7, 3)).join(","))')" = "Mon Nov 07 2011 00:00:00 GMT+0315 (UTC),Mon Nov 07 2011 01:00:00 GMT+0315 (UTC),Mon Nov 07 2011 02:00:00 GMT+0315 (UTC)" ]; test $? "timeHour.range with +:30 UTC offset"
[ "$(TZ=Asia/Kolkata node -e 'd3 = require("./"); console.log(+d3.timeHour.floor(new Date(1456279843199)))')" = "1456277400000" ]; test $? "timeHour.floor with +:30 UTC offset"
[ "$(TZ=Asia/Kolkata node -e 'd3 = require("./"); console.log(+d3.timeHour.ceil(new Date(1456279843199)))')" = "1456281000000" ]; test $? "timeHour.ceil with +:30 UTC offset"
[ "$(TZ=Asia/Kolkata node -e 'd3 = require("./"); console.log(d3.timeHour.range(new Date(2011, 10, 7, 0), new Date(2011, 10, 7, 3)).map(Number).join(","))')" = "1320604200000,1320607800000,1320611400000" ]; test $? "timeHour.range with +:30 UTC offset"
[ "$(TZ=Asia/Kathmandu node -e 'd3 = require("./"); console.log(+d3.timeHour.floor(new Date(1456279843199)))')" = "1456276500000" ]; test $? "timeHour.floor with +:45 UTC offset"
[ "$(TZ=Asia/Kathmandu node -e 'd3 = require("./"); console.log(+d3.timeHour.ceil(new Date(1456279843199)))')" = "1456280100000" ]; test $? "timeHour.ceil with +:45 UTC offset"
[ "$(TZ=Asia/Kathmandu node -e 'd3 = require("./"); console.log(d3.timeHour.range(new Date(2011, 10, 7, 0), new Date(2011, 10, 7, 3)).map(Number).join(","))')" = "1320603300000,1320606900000,1320610500000" ]; test $? "timeHour.range with +:45 UTC offset"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.floor(new Date(Date.UTC(2016, 1, 21, 1))))')" = "1455933600000" ]; test $? "timeDay.floor when daylight saving ends at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.floor(new Date(Date.UTC(2016, 1, 21, 2))))')" = "1455933600000" ]; test $? "timeDay.floor when daylight saving ends at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.floor(new Date(Date.UTC(2016, 1, 21, 3))))')" = "1456023600000" ]; test $? "timeDay.floor when daylight saving ends at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.floor(new Date(Date.UTC(2016, 1, 21, 4))))')" = "1456023600000" ]; test $? "timeDay.floor when daylight saving ends at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.ceil(new Date(Date.UTC(2016, 1, 21, 1))))')" = "1456023600000" ]; test $? "timeDay.ceil when daylight saving ends at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.ceil(new Date(Date.UTC(2016, 1, 21, 2))))')" = "1456023600000" ]; test $? "timeDay.ceil when daylight saving ends at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.ceil(new Date(Date.UTC(2016, 1, 21, 3))))')" = "1456023600000" ]; test $? "timeDay.ceil when daylight saving ends at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.ceil(new Date(Date.UTC(2016, 1, 21, 4))))')" = "1456110000000" ]; test $? "timeDay.ceil when daylight saving ends at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.round(new Date(Date.UTC(2016, 1, 20, 14))))')" = "1455933600000" ]; test $? "timeDay.round when daylight saving ends at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.round(new Date(Date.UTC(2016, 1, 20, 15))))')" = "1456023600000" ]; test $? "timeDay.round when daylight saving ends at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.round(new Date(Date.UTC(2016, 1, 21, 14))))')" = "1456023600000" ]; test $? "timeDay.round when daylight saving ends at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.round(new Date(Date.UTC(2016, 1, 21, 15))))')" = "1456110000000" ]; test $? "timeDay.round when daylight saving ends at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(d3.timeDay.range(new Date(2016, 1, 19), new Date(2016, 1, 23)).map(Number).join(","))')" = "1455847200000,1455933600000,1456023600000,1456110000000" ]; test $? "timeDay.range when daylight saving ends at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.floor(new Date(Date.UTC(2016, 9, 16, 1))))')" = "1476500400000" ]; test $? "timeDay.floor when daylight saving begins at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.floor(new Date(Date.UTC(2016, 9, 16, 2))))')" = "1476500400000" ]; test $? "timeDay.floor when daylight saving begins at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.floor(new Date(Date.UTC(2016, 9, 16, 3))))')" = "1476586800000" ]; test $? "timeDay.floor when daylight saving begins at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.floor(new Date(Date.UTC(2016, 9, 16, 4))))')" = "1476586800000" ]; test $? "timeDay.floor when daylight saving begins at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.ceil(new Date(Date.UTC(2016, 9, 16, 1))))')" = "1476586800000" ]; test $? "timeDay.ceil when daylight saving begins at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.ceil(new Date(Date.UTC(2016, 9, 16, 2))))')" = "1476586800000" ]; test $? "timeDay.ceil when daylight saving begins at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.ceil(new Date(Date.UTC(2016, 9, 16, 3))))')" = "1476586800000" ]; test $? "timeDay.ceil when daylight saving begins at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.ceil(new Date(Date.UTC(2016, 9, 16, 4))))')" = "1476669600000" ]; test $? "timeDay.ceil when daylight saving begins at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.round(new Date(Date.UTC(2016, 9, 15, 14))))')" = "1476500400000" ]; test $? "timeDay.round when daylight saving begins at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.round(new Date(Date.UTC(2016, 9, 15, 15))))')" = "1476586800000" ]; test $? "timeDay.round when daylight saving begins at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.round(new Date(Date.UTC(2016, 9, 16, 14))))')" = "1476586800000" ]; test $? "timeDay.round when daylight saving begins at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(+d3.timeDay.round(new Date(Date.UTC(2016, 9, 16, 15))))')" = "1476669600000" ]; test $? "timeDay.round when daylight saving begins at midnight"
[ "$(TZ=America/Sao_Paulo node -e 'd3 = require("./"); console.log(d3.timeDay.range(new Date(2016, 9, 14), new Date(2016, 9, 18)).map(Number).join(","))')" = "1476414000000,1476500400000,1476586800000,1476669600000" ]; test $? "timeDay.range when daylight saving begins at midnight"
d3-time-1.0.11/test/thursday-test.js 0000664 0000000 0000000 00000005370 13426151457 0017206 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("timeThursdays in an alias for timeThursday.range", function(test) {
test.equal(time.timeThursdays, time.timeThursday.range);
test.end();
});
tape("timeThursday.floor(date) returns Thursdays", function(test) {
test.deepEqual(time.timeThursday.floor(date.local(2011, 00, 04, 23, 59, 59)), date.local(2010, 11, 30));
test.deepEqual(time.timeThursday.floor(date.local(2011, 00, 05, 00, 00, 00)), date.local(2010, 11, 30));
test.deepEqual(time.timeThursday.floor(date.local(2011, 00, 05, 00, 00, 01)), date.local(2010, 11, 30));
test.deepEqual(time.timeThursday.floor(date.local(2011, 00, 05, 23, 59, 59)), date.local(2010, 11, 30));
test.deepEqual(time.timeThursday.floor(date.local(2011, 00, 06, 00, 00, 00)), date.local(2011, 00, 06));
test.deepEqual(time.timeThursday.floor(date.local(2011, 00, 06, 00, 00, 01)), date.local(2011, 00, 06));
test.end();
});
tape("timeThursday.count(start, end) counts Thursdays after start (exclusive) and before end (inclusive)", function(test) {
// January 2012
// Su Mo Tu We Th Fr Sa
// 1 2 3 4 5 6 7
// 8 9 10 11 12 13 14
// 15 16 17 18 19 20 21
// 22 23 24 25 26 27 28
// 29 30 31
test.equal(time.timeThursday.count(date.local(2012, 00, 01), date.local(2012, 00, 04)), 0);
test.equal(time.timeThursday.count(date.local(2012, 00, 01), date.local(2012, 00, 05)), 1);
test.equal(time.timeThursday.count(date.local(2012, 00, 01), date.local(2012, 00, 06)), 1);
test.equal(time.timeThursday.count(date.local(2012, 00, 01), date.local(2012, 00, 12)), 2);
// January 2015
// Su Mo Tu We Th Fr Sa
// 1 2 3
// 4 5 6 7 8 9 10
// 11 12 13 14 15 16 17
// 18 19 20 21 22 23 24
// 25 26 27 28 29 30 31
test.equal(time.timeThursday.count(date.local(2015, 00, 01), date.local(2015, 00, 07)), 0);
test.equal(time.timeThursday.count(date.local(2015, 00, 01), date.local(2015, 00, 08)), 1);
test.equal(time.timeThursday.count(date.local(2015, 00, 01), date.local(2015, 00, 09)), 1);
test.end();
});
tape("timeThursday.count(start, end) observes daylight saving", function(test) {
test.equal(time.timeThursday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 01)), 10);
test.equal(time.timeThursday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 03)), 10);
test.equal(time.timeThursday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 04)), 10);
test.equal(time.timeThursday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 00)), 44);
test.equal(time.timeThursday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 01)), 44);
test.equal(time.timeThursday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 02)), 44);
test.end();
});
d3-time-1.0.11/test/tuesday-test.js 0000664 0000000 0000000 00000005335 13426151457 0017022 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("timeTuesdays in an alias for timeTuesday.range", function(test) {
test.equal(time.timeTuesdays, time.timeTuesday.range);
test.end();
});
tape("timeTuesday.floor(date) returns Tuesdays", function(test) {
test.deepEqual(time.timeTuesday.floor(date.local(2011, 00, 02, 23, 59, 59)), date.local(2010, 11, 28));
test.deepEqual(time.timeTuesday.floor(date.local(2011, 00, 03, 00, 00, 00)), date.local(2010, 11, 28));
test.deepEqual(time.timeTuesday.floor(date.local(2011, 00, 03, 00, 00, 01)), date.local(2010, 11, 28));
test.deepEqual(time.timeTuesday.floor(date.local(2011, 00, 03, 23, 59, 59)), date.local(2010, 11, 28));
test.deepEqual(time.timeTuesday.floor(date.local(2011, 00, 04, 00, 00, 00)), date.local(2011, 00, 04));
test.deepEqual(time.timeTuesday.floor(date.local(2011, 00, 04, 00, 00, 01)), date.local(2011, 00, 04));
test.end();
});
tape("timeTuesday.count(start, end) counts Tuesdays after start (exclusive) and before end (inclusive)", function(test) {
// January 2014
// Su Mo Tu We Th Fr Sa
// 1 2 3 4
// 5 6 7 8 9 10 11
// 12 13 14 15 16 17 18
// 19 20 21 22 23 24 25
// 26 27 28 29 30 31
test.equal(time.timeTuesday.count(date.local(2014, 00, 01), date.local(2014, 00, 06)), 0);
test.equal(time.timeTuesday.count(date.local(2014, 00, 01), date.local(2014, 00, 07)), 1);
test.equal(time.timeTuesday.count(date.local(2014, 00, 01), date.local(2014, 00, 08)), 1);
test.equal(time.timeTuesday.count(date.local(2014, 00, 01), date.local(2014, 00, 14)), 2);
// January 2013
// Su Mo Tu We Th Fr Sa
// 1 2 3 4 5
// 6 7 8 9 10 11 12
// 13 14 15 16 17 18 19
// 20 21 22 23 24 25 26
// 27 28 29 30 31
test.equal(time.timeTuesday.count(date.local(2013, 00, 01), date.local(2013, 00, 07)), 0);
test.equal(time.timeTuesday.count(date.local(2013, 00, 01), date.local(2013, 00, 08)), 1);
test.equal(time.timeTuesday.count(date.local(2013, 00, 01), date.local(2013, 00, 09)), 1);
test.end();
});
tape("timeTuesday.count(start, end) observes daylight saving", function(test) {
test.equal(time.timeTuesday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 01)), 10);
test.equal(time.timeTuesday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 03)), 10);
test.equal(time.timeTuesday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 04)), 10);
test.equal(time.timeTuesday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 00)), 44);
test.equal(time.timeTuesday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 01)), 44);
test.equal(time.timeTuesday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 02)), 44);
test.end();
});
d3-time-1.0.11/test/utcDay-test.js 0000664 0000000 0000000 00000017156 13426151457 0016601 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("utcDays in an alias for utcDay.range", function(test) {
test.equal(time.utcDays, time.utcDay.range);
test.end();
});
tape("utcDay.floor(date) returns days", function(test) {
test.deepEqual(time.utcDay.floor(date.utc(2010, 11, 31, 23)), date.utc(2010, 11, 31));
test.deepEqual(time.utcDay.floor(date.utc(2011, 00, 01, 00)), date.utc(2011, 00, 01));
test.deepEqual(time.utcDay.floor(date.utc(2011, 00, 01, 01)), date.utc(2011, 00, 01));
test.end();
});
tape("utcDay.floor(date) does not observe daylight saving", function(test) {
test.deepEqual(time.utcDay.floor(date.utc(2011, 02, 13, 07)), date.utc(2011, 02, 13));
test.deepEqual(time.utcDay.floor(date.utc(2011, 02, 13, 08)), date.utc(2011, 02, 13));
test.deepEqual(time.utcDay.floor(date.utc(2011, 02, 13, 09)), date.utc(2011, 02, 13));
test.deepEqual(time.utcDay.floor(date.utc(2011, 02, 13, 10)), date.utc(2011, 02, 13));
test.deepEqual(time.utcDay.floor(date.utc(2011, 10, 06, 05)), date.utc(2011, 10, 06));
test.deepEqual(time.utcDay.floor(date.utc(2011, 10, 06, 06)), date.utc(2011, 10, 06));
test.deepEqual(time.utcDay.floor(date.utc(2011, 10, 06, 07)), date.utc(2011, 10, 06));
test.deepEqual(time.utcDay.floor(date.utc(2011, 10, 06, 08)), date.utc(2011, 10, 06));
test.end();
});
tape("utcDay.round(date) returns days", function(test) {
test.deepEqual(time.utcDay.round(date.utc(2010, 11, 30, 13)), date.utc(2010, 11, 31));
test.deepEqual(time.utcDay.round(date.utc(2010, 11, 30, 11)), date.utc(2010, 11, 30));
test.end();
});
tape("utcDay.ceil(date) returns days", function(test) {
test.deepEqual(time.utcDay.ceil(date.utc(2010, 11, 30, 23)), date.utc(2010, 11, 31));
test.deepEqual(time.utcDay.ceil(date.utc(2010, 11, 31, 00)), date.utc(2010, 11, 31));
test.deepEqual(time.utcDay.ceil(date.utc(2010, 11, 31, 01)), date.utc(2011, 00, 01));
test.end();
});
tape("utcDay.ceil(date) does not observe daylight saving", function(test) {
test.deepEqual(time.utcDay.ceil(date.utc(2011, 02, 13, 07)), date.utc(2011, 02, 14));
test.deepEqual(time.utcDay.ceil(date.utc(2011, 02, 13, 08)), date.utc(2011, 02, 14));
test.deepEqual(time.utcDay.ceil(date.utc(2011, 02, 13, 09)), date.utc(2011, 02, 14));
test.deepEqual(time.utcDay.ceil(date.utc(2011, 02, 13, 10)), date.utc(2011, 02, 14));
test.deepEqual(time.utcDay.ceil(date.utc(2011, 10, 06, 05)), date.utc(2011, 10, 07));
test.deepEqual(time.utcDay.ceil(date.utc(2011, 10, 06, 06)), date.utc(2011, 10, 07));
test.deepEqual(time.utcDay.ceil(date.utc(2011, 10, 06, 07)), date.utc(2011, 10, 07));
test.deepEqual(time.utcDay.ceil(date.utc(2011, 10, 06, 08)), date.utc(2011, 10, 07));
test.end();
});
tape("utcDay.offset(date) is an alias for utcDay.offset(date, 1)", function(test) {
test.deepEqual(time.utcDay.offset(date.utc(2010, 11, 31, 23, 59, 59, 999)), date.utc(2011, 00, 01, 23, 59, 59, 999));
test.end();
});
tape("utcDay.offset(date, step) does not modify the passed-in date", function(test) {
var d = date.utc(2010, 11, 31, 23, 59, 59, 999);
time.utcDay.offset(d, +1);
test.deepEqual(d, date.utc(2010, 11, 31, 23, 59, 59, 999));
test.end();
});
tape("utcDay.offset(date, step) does not round the passed-in date", function(test) {
test.deepEqual(time.utcDay.offset(date.utc(2010, 11, 31, 23, 59, 59, 999), +1), date.utc(2011, 00, 01, 23, 59, 59, 999));
test.deepEqual(time.utcDay.offset(date.utc(2010, 11, 31, 23, 59, 59, 456), -2), date.utc(2010, 11, 29, 23, 59, 59, 456));
test.end();
});
tape("utcDay.offset(date, step) allows step to be negative", function(test) {
test.deepEqual(time.utcDay.offset(date.utc(2010, 11, 31), -1), date.utc(2010, 11, 30));
test.deepEqual(time.utcDay.offset(date.utc(2011, 00, 01), -2), date.utc(2010, 11, 30));
test.deepEqual(time.utcDay.offset(date.utc(2011, 00, 01), -1), date.utc(2010, 11, 31));
test.end();
});
tape("utcDay.offset(date, step) allows step to be positive", function(test) {
test.deepEqual(time.utcDay.offset(date.utc(2010, 11, 31), +1), date.utc(2011, 00, 01));
test.deepEqual(time.utcDay.offset(date.utc(2010, 11, 30), +2), date.utc(2011, 00, 01));
test.deepEqual(time.utcDay.offset(date.utc(2010, 11, 30), +1), date.utc(2010, 11, 31));
test.end();
});
tape("utcDay.offset(date, step) allows step to be zero", function(test) {
test.deepEqual(time.utcDay.offset(date.utc(2010, 11, 31, 23, 59, 59, 999), 0), date.utc(2010, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.utcDay.offset(date.utc(2010, 11, 31, 23, 59, 58, 000), 0), date.utc(2010, 11, 31, 23, 59, 58, 000));
test.end();
});
tape("utcDay.count(start, end) counts days after start (exclusive) and before end (inclusive)", function(test) {
test.equal(time.utcDay.count(date.utc(2011, 00, 01, 00), date.utc(2011, 04, 09, 00)), 128);
test.equal(time.utcDay.count(date.utc(2011, 00, 01, 01), date.utc(2011, 04, 09, 00)), 128);
test.equal(time.utcDay.count(date.utc(2010, 11, 31, 23), date.utc(2011, 04, 09, 00)), 129);
test.equal(time.utcDay.count(date.utc(2011, 00, 01, 00), date.utc(2011, 04, 08, 23)), 127);
test.equal(time.utcDay.count(date.utc(2011, 00, 01, 00), date.utc(2011, 04, 09, 01)), 128);
test.end();
});
tape("utcDay.count(start, end) does not observe daylight saving", function(test) {
test.equal(time.utcDay.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 01)), 71);
test.equal(time.utcDay.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 03)), 71);
test.equal(time.utcDay.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 04)), 71);
test.equal(time.utcDay.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 00)), 309);
test.equal(time.utcDay.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 01)), 309);
test.equal(time.utcDay.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 02)), 309);
test.end();
});
tape("utcDay.count(start, end) returns 364 or 365 for a full year", function(test) {
test.equal(time.utcDay.count(date.utc(1999, 00, 01), date.utc(1999, 11, 31)), 364);
test.equal(time.utcDay.count(date.utc(2000, 00, 01), date.utc(2000, 11, 31)), 365); // leap year
test.equal(time.utcDay.count(date.utc(2001, 00, 01), date.utc(2001, 11, 31)), 364);
test.equal(time.utcDay.count(date.utc(2002, 00, 01), date.utc(2002, 11, 31)), 364);
test.equal(time.utcDay.count(date.utc(2003, 00, 01), date.utc(2003, 11, 31)), 364);
test.equal(time.utcDay.count(date.utc(2004, 00, 01), date.utc(2004, 11, 31)), 365); // leap year
test.equal(time.utcDay.count(date.utc(2005, 00, 01), date.utc(2005, 11, 31)), 364);
test.equal(time.utcDay.count(date.utc(2006, 00, 01), date.utc(2006, 11, 31)), 364);
test.equal(time.utcDay.count(date.utc(2007, 00, 01), date.utc(2007, 11, 31)), 364);
test.equal(time.utcDay.count(date.utc(2008, 00, 01), date.utc(2008, 11, 31)), 365); // leap year
test.equal(time.utcDay.count(date.utc(2009, 00, 01), date.utc(2009, 11, 31)), 364);
test.equal(time.utcDay.count(date.utc(2010, 00, 01), date.utc(2010, 11, 31)), 364);
test.equal(time.utcDay.count(date.utc(2011, 00, 01), date.utc(2011, 11, 31)), 364);
test.end();
});
tape("utcDay.every(step) returns every stepth day, starting with the first day of the month", function(test) {
test.deepEqual(time.utcDay.every(3).range(date.utc(2008, 11, 30, 0, 12), date.utc(2009, 0, 5, 23, 48)), [date.utc(2008, 11, 31), date.utc(2009, 0, 1), date.utc(2009, 0, 4)]);
test.deepEqual(time.utcDay.every(5).range(date.utc(2008, 11, 30, 0, 12), date.utc(2009, 0, 6, 23, 48)), [date.utc(2008, 11, 31), date.utc(2009, 0, 1), date.utc(2009, 0, 6)]);
test.deepEqual(time.utcDay.every(7).range(date.utc(2008, 11, 30, 0, 12), date.utc(2009, 0, 8, 23, 48)), [date.utc(2009, 0, 1), date.utc(2009, 0, 8)]);
test.end();
});
d3-time-1.0.11/test/utcFriday-test.js 0000664 0000000 0000000 00000005152 13426151457 0017273 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("utcFridays in an alias for utcFriday.range", function(test) {
test.equal(time.utcFridays, time.utcFriday.range);
test.end();
});
tape("utcFriday.floor(date) returns Fridays", function(test) {
test.deepEqual(time.utcFriday.floor(date.utc(2011, 00, 05, 23, 59, 59)), date.utc(2010, 11, 31));
test.deepEqual(time.utcFriday.floor(date.utc(2011, 00, 06, 00, 00, 00)), date.utc(2010, 11, 31));
test.deepEqual(time.utcFriday.floor(date.utc(2011, 00, 06, 00, 00, 01)), date.utc(2010, 11, 31));
test.deepEqual(time.utcFriday.floor(date.utc(2011, 00, 06, 23, 59, 59)), date.utc(2010, 11, 31));
test.deepEqual(time.utcFriday.floor(date.utc(2011, 00, 07, 00, 00, 00)), date.utc(2011, 00, 07));
test.deepEqual(time.utcFriday.floor(date.utc(2011, 00, 07, 00, 00, 01)), date.utc(2011, 00, 07));
test.end();
});
tape("utcFriday.count(start, end) counts Fridays after start (exclusive) and before end (inclusive)", function(test) {
// January 2012
// Su Mo Tu We Th Fr Sa
// 1 2 3 4 5 6 7
// 8 9 10 11 12 13 14
// 15 16 17 18 19 20 21
// 22 23 24 25 26 27 28
// 29 30 31
test.equal(time.utcFriday.count(date.utc(2012, 00, 01), date.utc(2012, 00, 05)), 0);
test.equal(time.utcFriday.count(date.utc(2012, 00, 01), date.utc(2012, 00, 06)), 1);
test.equal(time.utcFriday.count(date.utc(2012, 00, 01), date.utc(2012, 00, 07)), 1);
test.equal(time.utcFriday.count(date.utc(2012, 00, 01), date.utc(2012, 00, 13)), 2);
// January 2010
// Su Mo Tu We Th Fr Sa
// 1 2
// 3 4 5 6 7 8 9
// 10 11 12 13 14 15 16
// 17 18 19 20 21 22 23
// 24 25 26 27 28 29 30
// 31
test.equal(time.utcFriday.count(date.utc(2010, 00, 01), date.utc(2010, 00, 07)), 0);
test.equal(time.utcFriday.count(date.utc(2010, 00, 01), date.utc(2010, 00, 08)), 1);
test.equal(time.utcFriday.count(date.utc(2010, 00, 01), date.utc(2010, 00, 09)), 1);
test.end();
});
tape("utcFriday.count(start, end) does not observe daylight saving", function(test) {
test.equal(time.utcFriday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 01)), 10);
test.equal(time.utcFriday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 03)), 10);
test.equal(time.utcFriday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 04)), 10);
test.equal(time.utcFriday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 00)), 44);
test.equal(time.utcFriday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 01)), 44);
test.equal(time.utcFriday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 02)), 44);
test.end();
});
d3-time-1.0.11/test/utcHour-test.js 0000664 0000000 0000000 00000016511 13426151457 0016773 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("utcHour.floor(date) returns hours", function(test) {
test.deepEqual(time.utcHour.floor(date.utc(2010, 11, 31, 23, 59)), date.utc(2010, 11, 31, 23));
test.deepEqual(time.utcHour.floor(date.utc(2011, 00, 01, 00, 00)), date.utc(2011, 00, 01, 00));
test.deepEqual(time.utcHour.floor(date.utc(2011, 00, 01, 00, 01)), date.utc(2011, 00, 01, 00));
test.end();
});
tape("utcHour.floor(date) observes start of daylight savings time", function(test) {
test.deepEqual(time.utcHour.floor(date.utc(2011, 02, 13, 08, 59)), date.utc(2011, 02, 13, 08));
test.deepEqual(time.utcHour.floor(date.utc(2011, 02, 13, 09, 00)), date.utc(2011, 02, 13, 09));
test.deepEqual(time.utcHour.floor(date.utc(2011, 02, 13, 09, 01)), date.utc(2011, 02, 13, 09));
test.deepEqual(time.utcHour.floor(date.utc(2011, 02, 13, 09, 59)), date.utc(2011, 02, 13, 09));
test.deepEqual(time.utcHour.floor(date.utc(2011, 02, 13, 10, 00)), date.utc(2011, 02, 13, 10));
test.deepEqual(time.utcHour.floor(date.utc(2011, 02, 13, 10, 01)), date.utc(2011, 02, 13, 10));
test.end();
});
tape("utcHour.floor(date) observes end of daylight savings time", function(test) {
test.deepEqual(time.utcHour.floor(date.utc(2011, 10, 06, 07, 59)), date.utc(2011, 10, 06, 07));
test.deepEqual(time.utcHour.floor(date.utc(2011, 10, 06, 08, 00)), date.utc(2011, 10, 06, 08));
test.deepEqual(time.utcHour.floor(date.utc(2011, 10, 06, 08, 01)), date.utc(2011, 10, 06, 08));
test.deepEqual(time.utcHour.floor(date.utc(2011, 10, 06, 08, 59)), date.utc(2011, 10, 06, 08));
test.deepEqual(time.utcHour.floor(date.utc(2011, 10, 06, 09, 00)), date.utc(2011, 10, 06, 09));
test.deepEqual(time.utcHour.floor(date.utc(2011, 10, 06, 09, 01)), date.utc(2011, 10, 06, 09));
test.end();
});
tape("utcHour.ceil(date) returns hours", function(test) {
test.deepEqual(time.utcHour.ceil(date.utc(2010, 11, 31, 23, 59)), date.utc(2011, 00, 01, 00));
test.deepEqual(time.utcHour.ceil(date.utc(2011, 00, 01, 00, 00)), date.utc(2011, 00, 01, 00));
test.deepEqual(time.utcHour.ceil(date.utc(2011, 00, 01, 00, 01)), date.utc(2011, 00, 01, 01));
test.end();
});
tape("utcHour.ceil(date) observes start of daylight savings time", function(test) {
test.deepEqual(time.utcHour.ceil(date.utc(2011, 02, 13, 08, 59)), date.utc(2011, 02, 13, 09));
test.deepEqual(time.utcHour.ceil(date.utc(2011, 02, 13, 09, 00)), date.utc(2011, 02, 13, 09));
test.deepEqual(time.utcHour.ceil(date.utc(2011, 02, 13, 09, 01)), date.utc(2011, 02, 13, 10));
test.deepEqual(time.utcHour.ceil(date.utc(2011, 02, 13, 09, 59)), date.utc(2011, 02, 13, 10));
test.deepEqual(time.utcHour.ceil(date.utc(2011, 02, 13, 10, 00)), date.utc(2011, 02, 13, 10));
test.deepEqual(time.utcHour.ceil(date.utc(2011, 02, 13, 10, 01)), date.utc(2011, 02, 13, 11));
test.end();
});
tape("utcHour.ceil(date) observes end of daylight savings time", function(test) {
test.deepEqual(time.utcHour.ceil(date.utc(2011, 10, 06, 07, 59)), date.utc(2011, 10, 06, 08));
test.deepEqual(time.utcHour.ceil(date.utc(2011, 10, 06, 08, 00)), date.utc(2011, 10, 06, 08));
test.deepEqual(time.utcHour.ceil(date.utc(2011, 10, 06, 08, 01)), date.utc(2011, 10, 06, 09));
test.deepEqual(time.utcHour.ceil(date.utc(2011, 10, 06, 08, 59)), date.utc(2011, 10, 06, 09));
test.deepEqual(time.utcHour.ceil(date.utc(2011, 10, 06, 09, 00)), date.utc(2011, 10, 06, 09));
test.deepEqual(time.utcHour.ceil(date.utc(2011, 10, 06, 09, 01)), date.utc(2011, 10, 06, 10));
test.end();
});
tape("utcHour.offset(date) does not modify the passed-in date", function(test) {
var d = date.utc(2010, 11, 31, 23, 59, 59, 999);
time.utcHour.offset(d, +1);
test.deepEqual(d, date.utc(2010, 11, 31, 23, 59, 59, 999));
test.end();
});
tape("utcHour.offset(date) does not round the passed-in-date", function(test) {
test.deepEqual(time.utcHour.offset(date.utc(2010, 11, 31, 23, 59, 59, 999), +1), date.utc(2011, 00, 01, 00, 59, 59, 999));
test.deepEqual(time.utcHour.offset(date.utc(2010, 11, 31, 23, 59, 59, 456), -2), date.utc(2010, 11, 31, 21, 59, 59, 456));
test.end();
});
tape("utcHour.offset(date) allows negative offsets", function(test) {
test.deepEqual(time.utcHour.offset(date.utc(2010, 11, 31, 12), -1), date.utc(2010, 11, 31, 11));
test.deepEqual(time.utcHour.offset(date.utc(2011, 00, 01, 01), -2), date.utc(2010, 11, 31, 23));
test.deepEqual(time.utcHour.offset(date.utc(2011, 00, 01, 00), -1), date.utc(2010, 11, 31, 23));
test.end();
});
tape("utcHour.offset(date) allows positive offsets", function(test) {
test.deepEqual(time.utcHour.offset(date.utc(2010, 11, 31, 11), +1), date.utc(2010, 11, 31, 12));
test.deepEqual(time.utcHour.offset(date.utc(2010, 11, 31, 23), +2), date.utc(2011, 00, 01, 01));
test.deepEqual(time.utcHour.offset(date.utc(2010, 11, 31, 23), +1), date.utc(2011, 00, 01, 00));
test.end();
});
tape("utcHour.offset(date) allows zero offset", function(test) {
test.deepEqual(time.utcHour.offset(date.utc(2010, 11, 31, 23, 59, 59, 999), 0), date.utc(2010, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.utcHour.offset(date.utc(2010, 11, 31, 23, 59, 58, 000), 0), date.utc(2010, 11, 31, 23, 59, 58, 000));
test.end();
});
tape("utcHour.range(start, stop) returns hours", function(test) {
test.deepEqual(time.utcHour.range(date.utc(2010, 11, 31, 12, 30), date.utc(2010, 11, 31, 15, 30)), [
date.utc(2010, 11, 31, 13),
date.utc(2010, 11, 31, 14),
date.utc(2010, 11, 31, 15)
]);
test.end();
});
tape("utcHour.range(start, stop) has an inclusive lower bound", function(test) {
test.deepEqual(time.utcHour.range(date.utc(2010, 11, 31, 23), date.utc(2011, 0, 1, 2))[0], date.utc(2010, 11, 31, 23));
test.end();
});
tape("utcHour.range(start, stop) has an exclusive upper bound", function(test) {
test.deepEqual(time.utcHour.range(date.utc(2010, 11, 31, 23), date.utc(2011, 0, 1, 2))[2], date.utc(2011, 0, 1, 1));
test.end();
});
tape("utcHour.range(start, stop) can skip hours", function(test) {
test.deepEqual(time.utcHour.range(date.utc(2011, 1, 1, 1), date.utc(2011, 1, 1, 13), 3), [
date.utc(2011, 1, 1, 1),
date.utc(2011, 1, 1, 4),
date.utc(2011, 1, 1, 7),
date.utc(2011, 1, 1, 10)
]);
test.end();
});
tape("utcHour.range(start, stop) does not observe the start of daylight savings time", function(test) {
test.deepEqual(time.utcHour.range(date.utc(2011, 2, 13, 1), date.utc(2011, 2, 13, 5)), [
date.utc(2011, 2, 13, 1),
date.utc(2011, 2, 13, 2),
date.utc(2011, 2, 13, 3),
date.utc(2011, 2, 13, 4)
]);
test.end();
});
tape("utcHour.range(start, stop) does not observe the end of daylight savings time", function(test) {
test.deepEqual(time.utcHour.range(date.utc(2011, 10, 6, 0), date.utc(2011, 10, 6, 2)), [
date.utc(2011, 10, 6, 0),
date.utc(2011, 10, 6, 1)
]);
test.end();
});
tape("utcHour.every(step) returns every stepth hour, starting with the first hour of the day", function(test) {
test.deepEqual(time.utcHour.every(4).range(date.utc(2008, 11, 30, 12, 47), date.utc(2008, 11, 31, 13, 57)), [date.utc(2008, 11, 30, 16), date.utc(2008, 11, 30, 20), date.utc(2008, 11, 31, 0), date.utc(2008, 11, 31, 4), date.utc(2008, 11, 31, 8), date.utc(2008, 11, 31, 12)]);
test.deepEqual(time.utcHour.every(12).range(date.utc(2008, 11, 30, 12, 47), date.utc(2008, 11, 31, 13, 57)), [date.utc(2008, 11, 31, 0), date.utc(2008, 11, 31, 12)]);
test.end();
});
d3-time-1.0.11/test/utcMillisecond-test.js 0000664 0000000 0000000 00000000313 13426151457 0020311 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../");
tape("utcMillisecond is an alias for timeMillisecond", function(test) {
test.equal(time.utcMillisecond, time.timeMillisecond);
test.end();
});
d3-time-1.0.11/test/utcMinute-test.js 0000664 0000000 0000000 00000012101 13426151457 0017306 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("utcMinute.floor(date) returns minutes", function(test) {
test.deepEqual(time.utcMinute.floor(date.utc(2010, 11, 31, 23, 59, 59)), date.utc(2010, 11, 31, 23, 59));
test.deepEqual(time.utcMinute.floor(date.utc(2011, 00, 01, 00, 00, 00)), date.utc(2011, 00, 01, 00, 00));
test.deepEqual(time.utcMinute.floor(date.utc(2011, 00, 01, 00, 00, 59)), date.utc(2011, 00, 01, 00, 00));
test.deepEqual(time.utcMinute.floor(date.utc(2011, 00, 01, 00, 01, 00)), date.utc(2011, 00, 01, 00, 01));
test.end();
});
tape("utcMinute.ceil(date) returns minutes", function(test) {
test.deepEqual(time.utcMinute.ceil(date.utc(2010, 11, 31, 23, 59, 59)), date.utc(2011, 00, 01, 00, 00));
test.deepEqual(time.utcMinute.ceil(date.utc(2011, 00, 01, 00, 00, 00)), date.utc(2011, 00, 01, 00, 00));
test.deepEqual(time.utcMinute.ceil(date.utc(2011, 00, 01, 00, 00, 59)), date.utc(2011, 00, 01, 00, 01));
test.deepEqual(time.utcMinute.ceil(date.utc(2011, 00, 01, 00, 01, 00)), date.utc(2011, 00, 01, 00, 01));
test.end();
});
tape("utcMinute.offset(date) does not modify the passed-in date", function(test) {
var d = date.utc(2010, 11, 31, 23, 59, 59, 999);
time.utcMinute.offset(d, +1);
test.deepEqual(d, date.utc(2010, 11, 31, 23, 59, 59, 999));
test.end();
});
tape("utcMinute.offset(date) does not round the passed-in-date", function(test) {
test.deepEqual(time.utcMinute.offset(date.utc(2010, 11, 31, 23, 59, 59, 999), +1), date.utc(2011, 00, 01, 00, 00, 59, 999));
test.deepEqual(time.utcMinute.offset(date.utc(2010, 11, 31, 23, 59, 59, 456), -2), date.utc(2010, 11, 31, 23, 57, 59, 456));
test.end();
});
tape("utcMinute.offset(date) allows negative offsets", function(test) {
test.deepEqual(time.utcMinute.offset(date.utc(2010, 11, 31, 23, 12), -1), date.utc(2010, 11, 31, 23, 11));
test.deepEqual(time.utcMinute.offset(date.utc(2011, 00, 01, 00, 01), -2), date.utc(2010, 11, 31, 23, 59));
test.deepEqual(time.utcMinute.offset(date.utc(2011, 00, 01, 00, 00), -1), date.utc(2010, 11, 31, 23, 59));
test.end();
});
tape("utcMinute.offset(date) allows positive offsets", function(test) {
test.deepEqual(time.utcMinute.offset(date.utc(2010, 11, 31, 23, 11), +1), date.utc(2010, 11, 31, 23, 12));
test.deepEqual(time.utcMinute.offset(date.utc(2010, 11, 31, 23, 59), +2), date.utc(2011, 00, 01, 00, 01));
test.deepEqual(time.utcMinute.offset(date.utc(2010, 11, 31, 23, 59), +1), date.utc(2011, 00, 01, 00, 00));
test.end();
});
tape("utcMinute.offset(date) allows zero offset", function(test) {
test.deepEqual(time.utcMinute.offset(date.utc(2010, 11, 31, 23, 59, 59, 999), 0), date.utc(2010, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.utcMinute.offset(date.utc(2010, 11, 31, 23, 59, 58, 000), 0), date.utc(2010, 11, 31, 23, 59, 58, 000));
test.end();
});
tape("utcMinute.range(start, stop), returns minutes", function(test) {
test.deepEqual(time.utcMinute.range(date.utc(2010, 11, 31, 23, 59), date.utc(2011, 0, 1, 0, 2)), [
date.utc(2010, 11, 31, 23, 59),
date.utc(2011, 0, 1, 0, 0),
date.utc(2011, 0, 1, 0, 1)
]);
test.end();
});
tape("utcMinute.range(start, stop), has an inclusive lower bound", function(test) {
test.deepEqual(time.utcMinute.range(date.utc(2010, 11, 31, 23, 59), date.utc(2011, 0, 1, 0, 2))[0], date.utc(2010, 11, 31, 23, 59));
test.end();
});
tape("utcMinute.range(start, stop), has an exclusive upper bound", function(test) {
test.deepEqual(time.utcMinute.range(date.utc(2010, 11, 31, 23, 59), date.utc(2011, 0, 1, 0, 2))[2], date.utc(2011, 0, 1, 0, 1));
test.end();
});
tape("utcMinute.range(start, stop), can skip minutes", function(test) {
test.deepEqual(time.utcMinute.range(date.utc(2011, 1, 1, 12, 7), date.utc(2011, 1, 1, 13, 7), 15), [
date.utc(2011, 1, 1, 12, 7),
date.utc(2011, 1, 1, 12, 22),
date.utc(2011, 1, 1, 12, 37),
date.utc(2011, 1, 1, 12, 52)
]);
test.end();
});
tape("utcMinute.range(start, stop), observes start of daylight savings time", function(test) {
test.deepEqual(time.utcMinute.range(date.utc(2011, 2, 13, 9, 59), date.utc(2011, 2, 13, 10, 2)), [
date.utc(2011, 2, 13, 9, 59),
date.utc(2011, 2, 13, 10, 0),
date.utc(2011, 2, 13, 10, 1)
]);
test.end();
});
tape("utcMinute.range(start, stop), observes end of daylight savings time", function(test) {
test.deepEqual(time.utcMinute.range(date.utc(2011, 10, 6, 8, 59), date.utc(2011, 10, 6, 9, 2)), [
date.utc(2011, 10, 6, 8, 59),
date.utc(2011, 10, 6, 9, 0),
date.utc(2011, 10, 6, 9, 1)
]);
test.end();
});
tape("utcMinute.every(step) returns every stepth minute, starting with the first minute of the hour", function(test) {
test.deepEqual(time.utcMinute.every(15).range(date.utc(2008, 11, 30, 12, 47), date.utc(2008, 11, 30, 13, 57)), [date.utc(2008, 11, 30, 13, 0), date.utc(2008, 11, 30, 13, 15), date.utc(2008, 11, 30, 13, 30), date.utc(2008, 11, 30, 13, 45)]);
test.deepEqual(time.utcMinute.every(30).range(date.utc(2008, 11, 30, 12, 47), date.utc(2008, 11, 30, 13, 57)), [date.utc(2008, 11, 30, 13, 0), date.utc(2008, 11, 30, 13, 30)]);
test.end();
});
d3-time-1.0.11/test/utcMonday-test.js 0000664 0000000 0000000 00000005576 13426151457 0017316 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("utcMondays in an alias for utcMonday.range", function(test) {
test.equal(time.utcMondays, time.utcMonday.range);
test.end();
});
tape("utcMonday.floor(date) returns Mondays", function(test) {
test.deepEqual(time.utcMonday.floor(date.utc(2011, 00, 01, 23, 59, 59)), date.utc(2010, 11, 27));
test.deepEqual(time.utcMonday.floor(date.utc(2011, 00, 02, 00, 00, 00)), date.utc(2010, 11, 27));
test.deepEqual(time.utcMonday.floor(date.utc(2011, 00, 02, 00, 00, 01)), date.utc(2010, 11, 27));
test.deepEqual(time.utcMonday.floor(date.utc(2011, 00, 02, 23, 59, 59)), date.utc(2010, 11, 27));
test.deepEqual(time.utcMonday.floor(date.utc(2011, 00, 03, 00, 00, 00)), date.utc(2011, 00, 03));
test.deepEqual(time.utcMonday.floor(date.utc(2011, 00, 03, 00, 00, 01)), date.utc(2011, 00, 03));
test.end();
});
tape("utcMonday.range(start, stop, step) returns every step Monday", function(test) {
test.deepEqual(time.utcMonday.range(date.utc(2011, 11, 01), date.utc(2012, 00, 15), 2), [
date.utc(2011, 11, 05),
date.utc(2011, 11, 19),
date.utc(2012, 00, 02)
]);
test.end();
});
tape("utcMonday.count(start, end) counts Mondays after start (exclusive) and before end (inclusive)", function(test) {
// January 2014
// Su Mo Tu We Th Fr Sa
// 1 2 3 4
// 5 6 7 8 9 10 11
// 12 13 14 15 16 17 18
// 19 20 21 22 23 24 25
// 26 27 28 29 30 31
test.equal(time.utcMonday.count(date.utc(2014, 00, 01), date.utc(2014, 00, 05)), 0);
test.equal(time.utcMonday.count(date.utc(2014, 00, 01), date.utc(2014, 00, 06)), 1);
test.equal(time.utcMonday.count(date.utc(2014, 00, 01), date.utc(2014, 00, 07)), 1);
test.equal(time.utcMonday.count(date.utc(2014, 00, 01), date.utc(2014, 00, 13)), 2);
// January 2018
// Su Mo Tu We Th Fr Sa
// 1 2 3 4 5 6
// 7 8 9 10 11 12 13
// 14 15 16 17 18 19 20
// 21 22 23 24 25 26 27
// 28 29 30 31
test.equal(time.utcMonday.count(date.utc(2018, 00, 01), date.utc(2018, 00, 07)), 0);
test.equal(time.utcMonday.count(date.utc(2018, 00, 01), date.utc(2018, 00, 08)), 1);
test.equal(time.utcMonday.count(date.utc(2018, 00, 01), date.utc(2018, 00, 09)), 1);
test.end();
});
tape("utcMonday.count(start, end) does not observe daylight saving", function(test) {
test.equal(time.utcMonday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 01)), 10);
test.equal(time.utcMonday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 03)), 10);
test.equal(time.utcMonday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 04)), 10);
test.equal(time.utcMonday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 00)), 44);
test.equal(time.utcMonday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 01)), 44);
test.equal(time.utcMonday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 02)), 44);
test.end();
});
d3-time-1.0.11/test/utcMonth-test.js 0000664 0000000 0000000 00000024153 13426151457 0017144 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("utcMonths in an alias for utcMonth.range", function(test) {
test.equal(time.utcMonths, time.utcMonth.range);
test.end();
});
tape("utcMonth.floor(date) returns months", function(test) {
test.deepEqual(time.utcMonth.floor(date.utc(2010, 11, 31, 23)), date.utc(2010, 11, 01));
test.deepEqual(time.utcMonth.floor(date.utc(2011, 00, 01, 00)), date.utc(2011, 00, 01));
test.deepEqual(time.utcMonth.floor(date.utc(2011, 00, 01, 01)), date.utc(2011, 00, 01));
test.end();
});
tape("utcMonth.floor(date) observes daylight saving", function(test) {
test.deepEqual(time.utcMonth.floor(date.utc(2011, 02, 13, 07)), date.utc(2011, 02, 01));
test.deepEqual(time.utcMonth.floor(date.utc(2011, 02, 13, 08)), date.utc(2011, 02, 01));
test.deepEqual(time.utcMonth.floor(date.utc(2011, 02, 13, 09)), date.utc(2011, 02, 01));
test.deepEqual(time.utcMonth.floor(date.utc(2011, 02, 13, 10)), date.utc(2011, 02, 01));
test.deepEqual(time.utcMonth.floor(date.utc(2011, 10, 06, 07)), date.utc(2011, 10, 01));
test.deepEqual(time.utcMonth.floor(date.utc(2011, 10, 06, 08)), date.utc(2011, 10, 01));
test.deepEqual(time.utcMonth.floor(date.utc(2011, 10, 06, 09)), date.utc(2011, 10, 01));
test.deepEqual(time.utcMonth.floor(date.utc(2011, 10, 06, 10)), date.utc(2011, 10, 01));
test.end();
});
tape("utcMonth.floor(date) handles years in the first century", function(test) {
test.deepEqual(time.utcMonth.floor(date.utc(0011, 10, 06, 07)), date.utc(0011, 10, 01));
test.end();
});
tape("utcMonth.round(date) returns months", function(test) {
test.deepEqual(time.utcMonth.round(date.utc(2010, 11, 16, 12)), date.utc(2011, 00, 01));
test.deepEqual(time.utcMonth.round(date.utc(2010, 11, 16, 11)), date.utc(2010, 11, 01));
test.end();
});
tape("utcMonth.round(date) observes daylight saving", function(test) {
test.deepEqual(time.utcMonth.round(date.utc(2011, 02, 13, 07)), date.utc(2011, 02, 01));
test.deepEqual(time.utcMonth.round(date.utc(2011, 02, 13, 08)), date.utc(2011, 02, 01));
test.deepEqual(time.utcMonth.round(date.utc(2011, 02, 13, 09)), date.utc(2011, 02, 01));
test.deepEqual(time.utcMonth.round(date.utc(2011, 02, 13, 20)), date.utc(2011, 02, 01));
test.deepEqual(time.utcMonth.round(date.utc(2011, 10, 06, 07)), date.utc(2011, 10, 01));
test.deepEqual(time.utcMonth.round(date.utc(2011, 10, 06, 08)), date.utc(2011, 10, 01));
test.deepEqual(time.utcMonth.round(date.utc(2011, 10, 06, 09)), date.utc(2011, 10, 01));
test.deepEqual(time.utcMonth.round(date.utc(2011, 10, 06, 20)), date.utc(2011, 10, 01));
test.end();
});
tape("utcMonth.round(date) handles midnight for leap years", function(test) {
test.deepEqual(time.utcMonth.round(date.utc(2012, 02, 01, 00)), date.utc(2012, 02, 01));
test.deepEqual(time.utcMonth.round(date.utc(2012, 02, 01, 00)), date.utc(2012, 02, 01));
test.end();
});
tape("utcMonth.ceil(date) returns months", function(test) {
test.deepEqual(time.utcMonth.ceil(date.utc(2010, 10, 30, 23)), date.utc(2010, 11, 01));
test.deepEqual(time.utcMonth.ceil(date.utc(2010, 11, 01, 01)), date.utc(2011, 00, 01));
test.end();
});
tape("utcMonth.ceil(date) observes daylight saving", function(test) {
test.deepEqual(time.utcMonth.ceil(date.utc(2011, 02, 13, 07)), date.utc(2011, 03, 01));
test.deepEqual(time.utcMonth.ceil(date.utc(2011, 02, 13, 08)), date.utc(2011, 03, 01));
test.deepEqual(time.utcMonth.ceil(date.utc(2011, 02, 13, 09)), date.utc(2011, 03, 01));
test.deepEqual(time.utcMonth.ceil(date.utc(2011, 02, 13, 10)), date.utc(2011, 03, 01));
test.deepEqual(time.utcMonth.ceil(date.utc(2011, 10, 06, 07)), date.utc(2011, 11, 01));
test.deepEqual(time.utcMonth.ceil(date.utc(2011, 10, 06, 08)), date.utc(2011, 11, 01));
test.deepEqual(time.utcMonth.ceil(date.utc(2011, 10, 06, 09)), date.utc(2011, 11, 01));
test.deepEqual(time.utcMonth.ceil(date.utc(2011, 10, 06, 10)), date.utc(2011, 11, 01));
test.end();
});
tape("utcMonth.ceil(date) handles midnight for leap years", function(test) {
test.deepEqual(time.utcMonth.ceil(date.utc(2012, 02, 01, 00)), date.utc(2012, 02, 01));
test.deepEqual(time.utcMonth.ceil(date.utc(2012, 02, 01, 00)), date.utc(2012, 02, 01));
test.end();
});
tape("utcMonth.offset(date) is an alias for utcMonth.offset(date, 1)", function(test) {
test.deepEqual(time.utcMonth.offset(date.utc(2010, 11, 31, 23, 59, 59, 999)), date.utc(2011, 00, 31, 23, 59, 59, 999));
test.end();
});
tape("utcMonth.offset(date, step) does not modify the passed-in date", function(test) {
var d = date.utc(2010, 11, 31, 23, 59, 59, 999);
time.utcMonth.offset(date, +1);
test.deepEqual(d, date.utc(2010, 11, 31, 23, 59, 59, 999));
test.end();
});
tape("utcMonth.offset(date, step) does not round the passed-in date", function(test) {
test.deepEqual(time.utcMonth.offset(date.utc(2010, 11, 31, 23, 59, 59, 999), +1), date.utc(2011, 00, 31, 23, 59, 59, 999));
test.deepEqual(time.utcMonth.offset(date.utc(2010, 11, 31, 23, 59, 59, 456), -2), date.utc(2010, 09, 31, 23, 59, 59, 456));
test.end();
});
tape("utcMonth.offset(date, step) allows step to be negative", function(test) {
test.deepEqual(time.utcMonth.offset(date.utc(2010, 11, 31), -1), date.utc(2010, 10, 31));
test.deepEqual(time.utcMonth.offset(date.utc(2011, 00, 01), -2), date.utc(2010, 10, 01));
test.deepEqual(time.utcMonth.offset(date.utc(2011, 00, 01), -1), date.utc(2010, 11, 01));
test.end();
});
tape("utcMonth.offset(date, step) allows step to be positive", function(test) {
test.deepEqual(time.utcMonth.offset(date.utc(2010, 11, 31), +1), date.utc(2011, 00, 31));
test.deepEqual(time.utcMonth.offset(date.utc(2010, 11, 30), +2), date.utc(2011, 01, 30));
test.deepEqual(time.utcMonth.offset(date.utc(2010, 11, 30), +1), date.utc(2011, 00, 30));
test.end();
});
tape("utcMonth.offset(date, step) allows step to be zero", function(test) {
test.deepEqual(time.utcMonth.offset(date.utc(2010, 11, 31, 23, 59, 59, 999), 0), date.utc(2010, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.utcMonth.offset(date.utc(2010, 11, 31, 23, 59, 58, 000), 0), date.utc(2010, 11, 31, 23, 59, 58, 000));
test.end();
});
tape("utcMonth.range(start, stop) returns months between start (inclusive) and stop (exclusive)", function(test) {
test.deepEqual(time.utcMonth.range(date.utc(2011, 11, 01), date.utc(2012, 05, 01)), [
date.utc(2011, 11, 01),
date.utc(2012, 00, 01),
date.utc(2012, 01, 01),
date.utc(2012, 02, 01),
date.utc(2012, 03, 01),
date.utc(2012, 04, 01)
]);
test.end();
});
tape("utcMonth.range(start, stop) returns months", function(test) {
test.deepEqual(time.utcMonth.range(date.utc(2011, 10, 04, 02), date.utc(2012, 04, 10, 13)), [
date.utc(2011, 11, 01),
date.utc(2012, 00, 01),
date.utc(2012, 01, 01),
date.utc(2012, 02, 01),
date.utc(2012, 03, 01),
date.utc(2012, 04, 01)
]);
test.end();
});
tape("utcMonth.range(start, stop) coerces start and stop to dates", function(test) {
test.deepEqual(time.utcMonth.range(+date.utc(2011, 10, 04), +date.utc(2012, 01, 07)), [
date.utc(2011, 11, 01),
date.utc(2012, 00, 01),
date.utc(2012, 01, 01)
]);
test.end();
});
tape("utcMonth.range(start, stop) returns the empty array for invalid dates", function(test) {
test.deepEqual(time.utcMonth.range(new Date(NaN), Infinity), []);
test.end();
});
tape("utcMonth.range(start, stop) returns the empty array if start >= stop", function(test) {
test.deepEqual(time.utcMonth.range(date.utc(2011, 11, 10), date.utc(2011, 10, 04)), []);
test.deepEqual(time.utcMonth.range(date.utc(2011, 10, 01), date.utc(2011, 10, 01)), []);
test.end();
});
tape("utcMonth.range(start, stop) returns months", function(test) {
test.deepEqual(time.utcMonth.range(date.utc(2010, 10, 31), date.utc(2011, 2, 1)), [
date.utc(2010, 11, 1),
date.utc(2011, 0, 1),
date.utc(2011, 1, 1)
]);
test.end();
});
tape("utcMonth.range(start, stop) has an inclusive lower bound", function(test) {
test.deepEqual(time.utcMonth.range(date.utc(2010, 10, 31), date.utc(2011, 2, 1))[0], date.utc(2010, 11, 1));
test.end();
});
tape("utcMonth.range(start, stop) has an exclusive upper bound", function(test) {
test.deepEqual(time.utcMonth.range(date.utc(2010, 10, 31), date.utc(2011, 2, 1))[2], date.utc(2011, 1, 1));
test.end();
});
tape("utcMonth.range(start, stop) can skip months", function(test) {
test.deepEqual(time.utcMonth.range(date.utc(2011, 1, 1), date.utc(2012, 1, 1), 3), [
date.utc(2011, 1, 1),
date.utc(2011, 4, 1),
date.utc(2011, 7, 1),
date.utc(2011, 10, 1)
]);
test.end();
});
tape("utcMonth.range(start, stop) observes start of daylight savings time", function(test) {
test.deepEqual(time.utcMonth.range(date.utc(2011, 0, 1), date.utc(2011, 4, 1)), [
date.utc(2011, 0, 1),
date.utc(2011, 1, 1),
date.utc(2011, 2, 1),
date.utc(2011, 3, 1)
]);
test.end();
});
tape("utcMonth.range(start, stop) observes end of daylight savings time", function(test) {
test.deepEqual(time.utcMonth.range(date.utc(2011, 9, 1), date.utc(2012, 1, 1)), [
date.utc(2011, 9, 1),
date.utc(2011, 10, 1),
date.utc(2011, 11, 1),
date.utc(2012, 0, 1)
]);
test.end();
});
tape("utcMonth.count(start, end) counts months after start (exclusive) and before end (inclusive)", function(test) {
test.equal(time.utcMonth.count(date.utc(2011, 00, 01), date.utc(2011, 04, 01)), 4);
test.equal(time.utcMonth.count(date.utc(2011, 00, 01), date.utc(2011, 03, 30)), 3);
test.equal(time.utcMonth.count(date.utc(2010, 11, 31), date.utc(2011, 03, 30)), 4);
test.equal(time.utcMonth.count(date.utc(2010, 11, 31), date.utc(2011, 04, 01)), 5);
test.equal(time.utcMonth.count(date.utc(2009, 11, 31), date.utc(2012, 04, 01)), 29);
test.equal(time.utcMonth.count(date.utc(2012, 04, 01), date.utc(2009, 11, 31)), -29);
test.end();
});
tape("utcMonth.every(step) returns every stepth month, starting with the first month of the year", function(test) {
test.deepEqual(time.utcMonth.every(3).range(date.utc(2008, 11, 3), date.utc(2010, 6, 5)), [date.utc(2009, 0, 1), date.utc(2009, 3, 1), date.utc(2009, 6, 1), date.utc(2009, 9, 1), date.utc(2010, 0, 1), date.utc(2010, 3, 1), date.utc(2010, 6, 1)]);
test.end();
});
d3-time-1.0.11/test/utcMultiYear-test.js 0000664 0000000 0000000 00000004103 13426151457 0017763 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("utcYear.every(n).floor(date) returns integer multiples of n years", function(test) {
test.deepEqual(time.utcYear.every(10).floor(date.utc(2009, 11, 31, 23, 59, 59)), date.utc(2000, 00, 01));
test.deepEqual(time.utcYear.every(10).floor(date.utc(2010, 00, 01, 00, 00, 00)), date.utc(2010, 00, 01));
test.deepEqual(time.utcYear.every(10).floor(date.utc(2010, 00, 01, 00, 00, 01)), date.utc(2010, 00, 01));
test.end();
});
tape("utcYear.every(n).ceil(date) returns integer multiples of n years", function(test) {
test.deepEqual(time.utcYear.every(100).ceil(date.utc(1999, 11, 31, 23, 59, 59)), date.utc(2000, 00, 01));
test.deepEqual(time.utcYear.every(100).ceil(date.utc(2000, 00, 01, 00, 00, 00)), date.utc(2000, 00, 01));
test.deepEqual(time.utcYear.every(100).ceil(date.utc(2000, 00, 01, 00, 00, 01)), date.utc(2100, 00, 01));
test.end();
});
tape("utcYear.every(n).offset(date, count) does not modify the passed-in date", function(test) {
var d = date.utc(2010, 11, 31, 23, 59, 59, 999);
time.utcYear.every(5).offset(d, +1);
test.deepEqual(d, date.utc(2010, 11, 31, 23, 59, 59, 999));
test.end();
});
tape("utcYear.every(n).offset(date, count) does not round the passed-in-date", function(test) {
test.deepEqual(time.utcYear.every(5).offset(date.utc(2010, 11, 31, 23, 59, 59, 999), +1), date.utc(2015, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.utcYear.every(5).offset(date.utc(2010, 11, 31, 23, 59, 59, 456), -2), date.utc(2000, 11, 31, 23, 59, 59, 456));
test.end();
});
tape("utcYear.every(n) does not define interval.count or interval.every", function(test) {
var decade = time.utcYear.every(10);
test.equal(decade.count, undefined);
test.equal(decade.every, undefined);
test.end();
});
tape("utcYear.every(n).range(start, stop) returns multiples of n years", function(test) {
test.deepEqual(time.utcYear.every(10).range(date.utc(2010, 0, 1), date.utc(2031, 0, 1)), [
date.utc(2010, 0, 1),
date.utc(2020, 0, 1),
date.utc(2030, 0, 1)
]);
test.end();
});
d3-time-1.0.11/test/utcSaturday-test.js 0000664 0000000 0000000 00000005245 13426151457 0017654 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("utcSaturdays in an alias for utcSaturday.range", function(test) {
test.equal(time.utcSaturdays, time.utcSaturday.range);
test.end();
});
tape("utcSaturday.floor(date) returns Saturdays", function(test) {
test.deepEqual(time.utcSaturday.floor(date.utc(2011, 00, 06, 23, 59, 59)), date.utc(2011, 00, 01));
test.deepEqual(time.utcSaturday.floor(date.utc(2011, 00, 07, 00, 00, 00)), date.utc(2011, 00, 01));
test.deepEqual(time.utcSaturday.floor(date.utc(2011, 00, 07, 00, 00, 01)), date.utc(2011, 00, 01));
test.deepEqual(time.utcSaturday.floor(date.utc(2011, 00, 07, 23, 59, 59)), date.utc(2011, 00, 01));
test.deepEqual(time.utcSaturday.floor(date.utc(2011, 00, 08, 00, 00, 00)), date.utc(2011, 00, 08));
test.deepEqual(time.utcSaturday.floor(date.utc(2011, 00, 08, 00, 00, 01)), date.utc(2011, 00, 08));
test.end();
});
tape("utcSaturday.count(start, end) counts Saturdays after start (exclusive) and before end (inclusive)", function(test) {
// January 2012
// Su Mo Tu We Th Fr Sa
// 1 2 3 4 5 6 7
// 8 9 10 11 12 13 14
// 15 16 17 18 19 20 21
// 22 23 24 25 26 27 28
// 29 30 31
test.equal(time.utcSaturday.count(date.utc(2012, 00, 01), date.utc(2012, 00, 06)), 0);
test.equal(time.utcSaturday.count(date.utc(2012, 00, 01), date.utc(2012, 00, 07)), 1);
test.equal(time.utcSaturday.count(date.utc(2012, 00, 01), date.utc(2012, 00, 08)), 1);
test.equal(time.utcSaturday.count(date.utc(2012, 00, 01), date.utc(2012, 00, 14)), 2);
// January 2011
// Su Mo Tu We Th Fr Sa
// 1
// 2 3 4 5 6 7 8
// 9 10 11 12 13 14 15
// 16 17 18 19 20 21 22
// 23 24 25 26 27 28 29
// 30 31
test.equal(time.utcSaturday.count(date.utc(2011, 00, 01), date.utc(2011, 00, 07)), 0);
test.equal(time.utcSaturday.count(date.utc(2011, 00, 01), date.utc(2011, 00, 08)), 1);
test.equal(time.utcSaturday.count(date.utc(2011, 00, 01), date.utc(2011, 00, 09)), 1);
test.end();
});
tape("utcSaturday.count(start, end) does not observe daylight saving", function(test) {
test.equal(time.utcSaturday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 01)), 10);
test.equal(time.utcSaturday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 03)), 10);
test.equal(time.utcSaturday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 04)), 10);
test.equal(time.utcSaturday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 00)), 44);
test.equal(time.utcSaturday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 01)), 44);
test.equal(time.utcSaturday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 02)), 44);
test.end();
});
d3-time-1.0.11/test/utcSecond-test.js 0000664 0000000 0000000 00000013043 13426151457 0017266 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("utcSecond.floor(date) returns seconds", function(test) {
test.deepEqual(time.utcSecond.floor(date.utc(2010, 11, 31, 23, 59, 59, 999)), date.utc(2010, 11, 31, 23, 59, 59));
test.deepEqual(time.utcSecond.floor(date.utc(2011, 00, 01, 00, 00, 00, 000)), date.utc(2011, 00, 01, 00, 00, 00));
test.deepEqual(time.utcSecond.floor(date.utc(2011, 00, 01, 00, 00, 00, 001)), date.utc(2011, 00, 01, 00, 00, 00));
test.end();
});
tape("utcSecond.round(date) returns seconds", function(test) {
test.deepEqual(time.utcSecond.round(date.utc(2010, 11, 31, 23, 59, 59, 999)), date.utc(2011, 00, 01, 00, 00, 00));
test.deepEqual(time.utcSecond.round(date.utc(2011, 00, 01, 00, 00, 00, 499)), date.utc(2011, 00, 01, 00, 00, 00));
test.deepEqual(time.utcSecond.round(date.utc(2011, 00, 01, 00, 00, 00, 500)), date.utc(2011, 00, 01, 00, 00, 01));
test.end();
});
tape("utcSecond.ceil(date) returns seconds", function(test) {
test.deepEqual(time.utcSecond.ceil(date.utc(2010, 11, 31, 23, 59, 59, 999)), date.utc(2011, 00, 01, 00, 00, 00));
test.deepEqual(time.utcSecond.ceil(date.utc(2011, 00, 01, 00, 00, 00, 000)), date.utc(2011, 00, 01, 00, 00, 00));
test.deepEqual(time.utcSecond.ceil(date.utc(2011, 00, 01, 00, 00, 00, 001)), date.utc(2011, 00, 01, 00, 00, 01));
test.end();
});
tape("utcSecond.offset(date, step) does not modify the passed-in date", function(test) {
var d = date.utc(2010, 11, 31, 23, 59, 59, 999);
time.utcSecond.offset(d, +1);
test.deepEqual(d, date.utc(2010, 11, 31, 23, 59, 59, 999));
test.end();
});
tape("utcSecond.offset(date, step) does not round the passed-in-date", function(test) {
test.deepEqual(time.utcSecond.offset(date.utc(2010, 11, 31, 23, 59, 59, 999), +1), date.utc(2011, 00, 01, 00, 00, 00, 999));
test.deepEqual(time.utcSecond.offset(date.utc(2010, 11, 31, 23, 59, 59, 456), -2), date.utc(2010, 11, 31, 23, 59, 57, 456));
test.end();
});
tape("utcSecond.offset(date, step) allows negative offsets", function(test) {
test.deepEqual(time.utcSecond.offset(date.utc(2010, 11, 31, 23, 59, 59), -1), date.utc(2010, 11, 31, 23, 59, 58));
test.deepEqual(time.utcSecond.offset(date.utc(2011, 00, 01, 00, 00, 00), -2), date.utc(2010, 11, 31, 23, 59, 58));
test.deepEqual(time.utcSecond.offset(date.utc(2011, 00, 01, 00, 00, 00), -1), date.utc(2010, 11, 31, 23, 59, 59));
test.end();
});
tape("utcSecond.offset(date, step) allows positive offsets", function(test) {
test.deepEqual(time.utcSecond.offset(date.utc(2010, 11, 31, 23, 59, 58), +1), date.utc(2010, 11, 31, 23, 59, 59));
test.deepEqual(time.utcSecond.offset(date.utc(2010, 11, 31, 23, 59, 58), +2), date.utc(2011, 00, 01, 00, 00, 00));
test.deepEqual(time.utcSecond.offset(date.utc(2010, 11, 31, 23, 59, 59), +1), date.utc(2011, 00, 01, 00, 00, 00));
test.end();
});
tape("utcSecond.offset(date, step) allows zero offset", function(test) {
test.deepEqual(time.utcSecond.offset(date.utc(2010, 11, 31, 23, 59, 59, 999), 0), date.utc(2010, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.utcSecond.offset(date.utc(2010, 11, 31, 23, 59, 58, 000), 0), date.utc(2010, 11, 31, 23, 59, 58, 000));
test.end();
});
tape("utcSecond.range(start, stop) returns seconds", function(test) {
test.deepEqual(time.utcSecond.range(date.utc(2010, 11, 31, 23, 59, 59), date.utc(2011, 0, 1, 0, 0, 2)), [
date.utc(2010, 11, 31, 23, 59, 59),
date.utc(2011, 0, 1, 0, 0, 0),
date.utc(2011, 0, 1, 0, 0, 1)
]);
test.end();
});
tape("utcSecond.range(start, stop) has an inclusive lower bound", function(test) {
test.deepEqual(time.utcSecond.range(date.utc(2010, 11, 31, 23, 59, 59), date.utc(2011, 0, 1, 0, 0, 2))[0], date.utc(2010, 11, 31, 23, 59, 59));
test.end();
});
tape("utcSecond.range(start, stop) has an exclusive upper bound", function(test) {
test.deepEqual(time.utcSecond.range(date.utc(2010, 11, 31, 23, 59, 59), date.utc(2011, 0, 1, 0, 0, 2))[2], date.utc(2011, 0, 1, 0, 0, 1));
test.end();
});
tape("utcSecond.range(start, stop, step) can skip seconds", function(test) {
test.deepEqual(time.utcSecond.range(date.utc(2011, 1, 1, 12, 0, 7), date.utc(2011, 1, 1, 12, 1, 7), 15), [
date.utc(2011, 1, 1, 12, 0, 7),
date.utc(2011, 1, 1, 12, 0, 22),
date.utc(2011, 1, 1, 12, 0, 37),
date.utc(2011, 1, 1, 12, 0, 52)
]);
test.end();
});
tape("utcSecond.range(start, stop) observes start of daylight savings time", function(test) {
test.deepEqual(time.utcSecond.range(date.utc(2011, 2, 13, 9, 59, 59), date.utc(2011, 2, 13, 10, 0, 2)), [
date.utc(2011, 2, 13, 9, 59, 59),
date.utc(2011, 2, 13, 10, 0, 0),
date.utc(2011, 2, 13, 10, 0, 1)
]);
test.end();
});
tape("utcSecond.range(start, stop) observes end of daylight savings time", function(test) {
test.deepEqual(time.utcSecond.range(date.utc(2011, 10, 6, 8, 59, 59), date.utc(2011, 10, 6, 9, 0, 2)), [
date.utc(2011, 10, 6, 8, 59, 59),
date.utc(2011, 10, 6, 9, 0, 0),
date.utc(2011, 10, 6, 9, 0, 1)
]);
test.end();
});
tape("utcSecond.every(step) returns every stepth second, starting with the first second of the minute", function(test) {
test.deepEqual(time.utcSecond.every(15).range(date.utc(2008, 11, 30, 12, 36, 47), date.utc(2008, 11, 30, 12, 37, 57)), [date.utc(2008, 11, 30, 12, 37, 0), date.utc(2008, 11, 30, 12, 37, 15), date.utc(2008, 11, 30, 12, 37, 30), date.utc(2008, 11, 30, 12, 37, 45)]);
test.deepEqual(time.utcSecond.every(30).range(date.utc(2008, 11, 30, 12, 36, 47), date.utc(2008, 11, 30, 12, 37, 57)), [date.utc(2008, 11, 30, 12, 37, 0), date.utc(2008, 11, 30, 12, 37, 30)]);
test.end();
});
d3-time-1.0.11/test/utcSunday-test.js 0000664 0000000 0000000 00000017364 13426151457 0017330 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("utcSundays in an alias for utcSunday.range", function(test) {
test.equal(time.utcSundays, time.utcSunday.range);
test.end();
});
tape("utcSunday.floor(date) returns Sundays", function(test) {
test.deepEqual(time.utcSunday.floor(date.utc(2010, 11, 31, 23, 59, 59)), date.utc(2010, 11, 26));
test.deepEqual(time.utcSunday.floor(date.utc(2011, 00, 01, 00, 00, 00)), date.utc(2010, 11, 26));
test.deepEqual(time.utcSunday.floor(date.utc(2011, 00, 01, 00, 00, 01)), date.utc(2010, 11, 26));
test.deepEqual(time.utcSunday.floor(date.utc(2011, 00, 01, 23, 59, 59)), date.utc(2010, 11, 26));
test.deepEqual(time.utcSunday.floor(date.utc(2011, 00, 02, 00, 00, 00)), date.utc(2011, 00, 02));
test.deepEqual(time.utcSunday.floor(date.utc(2011, 00, 02, 00, 00, 01)), date.utc(2011, 00, 02));
test.end();
});
tape("utcSunday.floor(date) observes daylight saving", function(test) {
test.deepEqual(time.utcSunday.floor(date.utc(2011, 02, 13, 01)), date.utc(2011, 02, 13));
test.deepEqual(time.utcSunday.floor(date.utc(2011, 10, 06, 01)), date.utc(2011, 10, 06));
test.end();
});
tape("utcSunday.floor(date) handles years in the first century", function(test) {
test.deepEqual(time.utcSunday.floor(date.utc(0011, 10, 06, 07)), date.utc(0011, 10, 01));
test.end();
});
tape("utcSunday.ceil(date) returns Sundays", function(test) {
test.deepEqual(time.utcSunday.ceil(date.utc(2010, 11, 31, 23, 59, 59)), date.utc(2011, 00, 02));
test.deepEqual(time.utcSunday.ceil(date.utc(2011, 00, 01, 00, 00, 00)), date.utc(2011, 00, 02));
test.deepEqual(time.utcSunday.ceil(date.utc(2011, 00, 01, 00, 00, 01)), date.utc(2011, 00, 02));
test.deepEqual(time.utcSunday.ceil(date.utc(2011, 00, 01, 23, 59, 59)), date.utc(2011, 00, 02));
test.deepEqual(time.utcSunday.ceil(date.utc(2011, 00, 02, 00, 00, 00)), date.utc(2011, 00, 02));
test.deepEqual(time.utcSunday.ceil(date.utc(2011, 00, 02, 00, 00, 01)), date.utc(2011, 00, 09));
test.end();
});
tape("utcSunday.ceil(date) observes daylight saving", function(test) {
test.deepEqual(time.utcSunday.ceil(date.utc(2011, 02, 13, 01)), date.utc(2011, 02, 20));
test.deepEqual(time.utcSunday.ceil(date.utc(2011, 10, 06, 01)), date.utc(2011, 10, 13));
test.end();
});
tape("utcSunday.offset(date) is an alias for utcSunday.offset(date, 1)", function(test) {
test.deepEqual(time.utcSunday.offset(date.utc(2010, 11, 31, 23, 59, 59, 999)), date.utc(2011, 00, 07, 23, 59, 59, 999));
test.end();
});
tape("utcSunday.offset(date, step) does not modify the passed-in date", function(test) {
var d = date.utc(2010, 11, 31, 23, 59, 59, 999);
time.utcSunday.offset(d, +1);
test.deepEqual(d, date.utc(2010, 11, 31, 23, 59, 59, 999));
test.end();
});
tape("utcSunday.offset(date, step) does not round the passed-in date", function(test) {
test.deepEqual(time.utcSunday.offset(date.utc(2010, 11, 31, 23, 59, 59, 999), +1), date.utc(2011, 00, 07, 23, 59, 59, 999));
test.deepEqual(time.utcSunday.offset(date.utc(2010, 11, 31, 23, 59, 59, 456), -2), date.utc(2010, 11, 17, 23, 59, 59, 456));
test.end();
});
tape("utcSunday.offset(date, step) allows step to be negative", function(test) {
test.deepEqual(time.utcSunday.offset(date.utc(2010, 11, 01), -1), date.utc(2010, 10, 24));
test.deepEqual(time.utcSunday.offset(date.utc(2011, 00, 01), -2), date.utc(2010, 11, 18));
test.deepEqual(time.utcSunday.offset(date.utc(2011, 00, 01), -1), date.utc(2010, 11, 25));
test.end();
});
tape("utcSunday.offset(date, step) allows step to be positive", function(test) {
test.deepEqual(time.utcSunday.offset(date.utc(2010, 10, 24), +1), date.utc(2010, 11, 01));
test.deepEqual(time.utcSunday.offset(date.utc(2010, 11, 18), +2), date.utc(2011, 00, 01));
test.deepEqual(time.utcSunday.offset(date.utc(2010, 11, 25), +1), date.utc(2011, 00, 01));
test.end();
});
tape("utcSunday.offset(date, step) allows step to be zero", function(test) {
test.deepEqual(time.utcSunday.offset(date.utc(2010, 11, 31, 23, 59, 59, 999), 0), date.utc(2010, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.utcSunday.offset(date.utc(2010, 11, 31, 23, 59, 58, 000), 0), date.utc(2010, 11, 31, 23, 59, 58, 000));
test.end();
});
tape("utcSunday.range(start, stop) returns Sundays between start (inclusive) and stop (exclusive)", function(test) {
test.deepEqual(time.utcSunday.range(date.utc(2011, 11, 01), date.utc(2012, 00, 15)), [
date.utc(2011, 11, 04),
date.utc(2011, 11, 11),
date.utc(2011, 11, 18),
date.utc(2011, 11, 25),
date.utc(2012, 00, 01),
date.utc(2012, 00, 08)
]);
test.end();
});
tape("utcSunday.range(start, stop) returns Sundays", function(test) {
test.deepEqual(time.utcSunday.range(date.utc(2011, 11, 01, 12, 23), date.utc(2012, 00, 14, 12, 23)), [
date.utc(2011, 11, 04),
date.utc(2011, 11, 11),
date.utc(2011, 11, 18),
date.utc(2011, 11, 25),
date.utc(2012, 00, 01),
date.utc(2012, 00, 08)
]);
test.end();
});
tape("utcSunday.range(start, stop) coerces start and stop to dates", function(test) {
test.deepEqual(time.utcSunday.range(+date.utc(2011, 11, 01), +date.utc(2012, 00, 15)), [
date.utc(2011, 11, 04),
date.utc(2011, 11, 11),
date.utc(2011, 11, 18),
date.utc(2011, 11, 25),
date.utc(2012, 00, 01),
date.utc(2012, 00, 08)
]);
test.end();
});
tape("utcSunday.range(start, stop) returns the empty array for invalid dates", function(test) {
test.deepEqual(time.utcSunday.range(new Date(NaN), Infinity), []);
test.end();
});
tape("utcSunday.range(start, stop) returns the empty array if start >= stop", function(test) {
test.deepEqual(time.utcSunday.range(date.utc(2011, 11, 10), date.utc(2011, 10, 04)), []);
test.deepEqual(time.utcSunday.range(date.utc(2011, 10, 01), date.utc(2011, 10, 01)), []);
test.end();
});
tape("utcSunday.range(start, stop, step) returns every step Sunday", function(test) {
test.deepEqual(time.utcSunday.range(date.utc(2011, 11, 01), date.utc(2012, 00, 15), 2), [
date.utc(2011, 11, 04),
date.utc(2011, 11, 18),
date.utc(2012, 00, 01)
]);
test.end();
});
tape("utcSunday.count(start, end) counts Sundays after start (exclusive) and before end (inclusive)", function(test) {
// January 2014
// Su Mo Tu We Th Fr Sa
// 1 2 3 4
// 5 6 7 8 9 10 11
// 12 13 14 15 16 17 18
// 19 20 21 22 23 24 25
// 26 27 28 29 30 31
test.equal(time.utcSunday.count(date.utc(2014, 00, 01), date.utc(2014, 00, 04)), 0);
test.equal(time.utcSunday.count(date.utc(2014, 00, 01), date.utc(2014, 00, 05)), 1);
test.equal(time.utcSunday.count(date.utc(2014, 00, 01), date.utc(2014, 00, 06)), 1);
test.equal(time.utcSunday.count(date.utc(2014, 00, 01), date.utc(2014, 00, 12)), 2);
// January 2012
// Su Mo Tu We Th Fr Sa
// 1 2 3 4 5 6 7
// 8 9 10 11 12 13 14
// 15 16 17 18 19 20 21
// 22 23 24 25 26 27 28
// 29 30 31
test.equal(time.utcSunday.count(date.utc(2012, 00, 01), date.utc(2012, 00, 07)), 0);
test.equal(time.utcSunday.count(date.utc(2012, 00, 01), date.utc(2012, 00, 08)), 1);
test.equal(time.utcSunday.count(date.utc(2012, 00, 01), date.utc(2012, 00, 09)), 1);
test.end();
});
tape("utcSunday.count(start, end) does not observe daylight saving", function(test) {
test.equal(time.utcSunday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 01)), 11);
test.equal(time.utcSunday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 03)), 11);
test.equal(time.utcSunday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 04)), 11);
test.equal(time.utcSunday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 00)), 45);
test.equal(time.utcSunday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 01)), 45);
test.equal(time.utcSunday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 02)), 45);
test.end();
});
d3-time-1.0.11/test/utcThursday-test.js 0000664 0000000 0000000 00000005232 13426151457 0017657 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("utcThursdays in an alias for utcThursday.range", function(test) {
test.equal(time.utcThursdays, time.utcThursday.range);
test.end();
});
tape("utcThursday.floor(date) returns Thursdays", function(test) {
test.deepEqual(time.utcThursday.floor(date.utc(2011, 00, 04, 23, 59, 59)), date.utc(2010, 11, 30));
test.deepEqual(time.utcThursday.floor(date.utc(2011, 00, 05, 00, 00, 00)), date.utc(2010, 11, 30));
test.deepEqual(time.utcThursday.floor(date.utc(2011, 00, 05, 00, 00, 01)), date.utc(2010, 11, 30));
test.deepEqual(time.utcThursday.floor(date.utc(2011, 00, 05, 23, 59, 59)), date.utc(2010, 11, 30));
test.deepEqual(time.utcThursday.floor(date.utc(2011, 00, 06, 00, 00, 00)), date.utc(2011, 00, 06));
test.deepEqual(time.utcThursday.floor(date.utc(2011, 00, 06, 00, 00, 01)), date.utc(2011, 00, 06));
test.end();
});
tape("utcThursday.count(start, end) counts Thursdays after start (exclusive) and before end (inclusive)", function(test) {
// January 2012
// Su Mo Tu We Th Fr Sa
// 1 2 3 4 5 6 7
// 8 9 10 11 12 13 14
// 15 16 17 18 19 20 21
// 22 23 24 25 26 27 28
// 29 30 31
test.equal(time.utcThursday.count(date.utc(2012, 00, 01), date.utc(2012, 00, 04)), 0);
test.equal(time.utcThursday.count(date.utc(2012, 00, 01), date.utc(2012, 00, 05)), 1);
test.equal(time.utcThursday.count(date.utc(2012, 00, 01), date.utc(2012, 00, 06)), 1);
test.equal(time.utcThursday.count(date.utc(2012, 00, 01), date.utc(2012, 00, 12)), 2);
// January 2015
// Su Mo Tu We Th Fr Sa
// 1 2 3
// 4 5 6 7 8 9 10
// 11 12 13 14 15 16 17
// 18 19 20 21 22 23 24
// 25 26 27 28 29 30 31
test.equal(time.utcThursday.count(date.utc(2015, 00, 01), date.utc(2015, 00, 07)), 0);
test.equal(time.utcThursday.count(date.utc(2015, 00, 01), date.utc(2015, 00, 08)), 1);
test.equal(time.utcThursday.count(date.utc(2015, 00, 01), date.utc(2015, 00, 09)), 1);
test.end();
});
tape("utcThursday.count(start, end) does not observe daylight saving", function(test) {
test.equal(time.utcThursday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 01)), 10);
test.equal(time.utcThursday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 03)), 10);
test.equal(time.utcThursday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 04)), 10);
test.equal(time.utcThursday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 00)), 44);
test.equal(time.utcThursday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 01)), 44);
test.equal(time.utcThursday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 02)), 44);
test.end();
});
d3-time-1.0.11/test/utcTuesday-test.js 0000664 0000000 0000000 00000005177 13426151457 0017502 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("utcTuesdays in an alias for utcTuesday.range", function(test) {
test.equal(time.utcTuesdays, time.utcTuesday.range);
test.end();
});
tape("utcTuesday.floor(date) returns Tuesdays", function(test) {
test.deepEqual(time.utcTuesday.floor(date.utc(2011, 00, 02, 23, 59, 59)), date.utc(2010, 11, 28));
test.deepEqual(time.utcTuesday.floor(date.utc(2011, 00, 03, 00, 00, 00)), date.utc(2010, 11, 28));
test.deepEqual(time.utcTuesday.floor(date.utc(2011, 00, 03, 00, 00, 01)), date.utc(2010, 11, 28));
test.deepEqual(time.utcTuesday.floor(date.utc(2011, 00, 03, 23, 59, 59)), date.utc(2010, 11, 28));
test.deepEqual(time.utcTuesday.floor(date.utc(2011, 00, 04, 00, 00, 00)), date.utc(2011, 00, 04));
test.deepEqual(time.utcTuesday.floor(date.utc(2011, 00, 04, 00, 00, 01)), date.utc(2011, 00, 04));
test.end();
});
tape("utcTuesday.count(start, end) counts Tuesdays after start (exclusive) and before end (inclusive)", function(test) {
// January 2014
// Su Mo Tu We Th Fr Sa
// 1 2 3 4
// 5 6 7 8 9 10 11
// 12 13 14 15 16 17 18
// 19 20 21 22 23 24 25
// 26 27 28 29 30 31
test.equal(time.utcTuesday.count(date.utc(2014, 00, 01), date.utc(2014, 00, 06)), 0);
test.equal(time.utcTuesday.count(date.utc(2014, 00, 01), date.utc(2014, 00, 07)), 1);
test.equal(time.utcTuesday.count(date.utc(2014, 00, 01), date.utc(2014, 00, 08)), 1);
test.equal(time.utcTuesday.count(date.utc(2014, 00, 01), date.utc(2014, 00, 14)), 2);
// January 2013
// Su Mo Tu We Th Fr Sa
// 1 2 3 4 5
// 6 7 8 9 10 11 12
// 13 14 15 16 17 18 19
// 20 21 22 23 24 25 26
// 27 28 29 30 31
test.equal(time.utcTuesday.count(date.utc(2013, 00, 01), date.utc(2013, 00, 07)), 0);
test.equal(time.utcTuesday.count(date.utc(2013, 00, 01), date.utc(2013, 00, 08)), 1);
test.equal(time.utcTuesday.count(date.utc(2013, 00, 01), date.utc(2013, 00, 09)), 1);
test.end();
});
tape("utcTuesday.count(start, end) does not observe daylight saving", function(test) {
test.equal(time.utcTuesday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 01)), 10);
test.equal(time.utcTuesday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 03)), 10);
test.equal(time.utcTuesday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 04)), 10);
test.equal(time.utcTuesday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 00)), 44);
test.equal(time.utcTuesday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 01)), 44);
test.equal(time.utcTuesday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 02)), 44);
test.end();
});
d3-time-1.0.11/test/utcWednesday-test.js 0000664 0000000 0000000 00000005263 13426151457 0020003 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("utcWednesdays in an alias for utcWednesday.range", function(test) {
test.equal(time.utcWednesdays, time.utcWednesday.range);
test.end();
});
tape("utcWednesday.floor(date) returns Wednesdays", function(test) {
test.deepEqual(time.utcWednesday.floor(date.utc(2011, 00, 03, 23, 59, 59)), date.utc(2010, 11, 29));
test.deepEqual(time.utcWednesday.floor(date.utc(2011, 00, 04, 00, 00, 00)), date.utc(2010, 11, 29));
test.deepEqual(time.utcWednesday.floor(date.utc(2011, 00, 04, 00, 00, 01)), date.utc(2010, 11, 29));
test.deepEqual(time.utcWednesday.floor(date.utc(2011, 00, 04, 23, 59, 59)), date.utc(2010, 11, 29));
test.deepEqual(time.utcWednesday.floor(date.utc(2011, 00, 05, 00, 00, 00)), date.utc(2011, 00, 05));
test.deepEqual(time.utcWednesday.floor(date.utc(2011, 00, 05, 00, 00, 01)), date.utc(2011, 00, 05));
test.end();
});
tape("utcWednesday.count(start, end) counts Wednesdays after start (exclusive) and before end (inclusive)", function(test) {
// January 2012
// Su Mo Tu We Th Fr Sa
// 1 2 3 4 5 6 7
// 8 9 10 11 12 13 14
// 15 16 17 18 19 20 21
// 22 23 24 25 26 27 28
// 29 30 31
test.equal(time.utcWednesday.count(date.utc(2012, 00, 01), date.utc(2012, 00, 03)), 0);
test.equal(time.utcWednesday.count(date.utc(2012, 00, 01), date.utc(2012, 00, 04)), 1);
test.equal(time.utcWednesday.count(date.utc(2012, 00, 01), date.utc(2012, 00, 05)), 1);
test.equal(time.utcWednesday.count(date.utc(2012, 00, 01), date.utc(2012, 00, 11)), 2);
// January 2014
// Su Mo Tu We Th Fr Sa
// 1 2 3 4
// 5 6 7 8 9 10 11
// 12 13 14 15 16 17 18
// 19 20 21 22 23 24 25
// 26 27 28 29 30 31
test.equal(time.utcWednesday.count(date.utc(2014, 00, 01), date.utc(2014, 00, 07)), 0);
test.equal(time.utcWednesday.count(date.utc(2014, 00, 01), date.utc(2014, 00, 08)), 1);
test.equal(time.utcWednesday.count(date.utc(2014, 00, 01), date.utc(2014, 00, 09)), 1);
test.end();
});
tape("utcWednesday.count(start, end) does not observe daylight saving", function(test) {
test.equal(time.utcWednesday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 01)), 10);
test.equal(time.utcWednesday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 03)), 10);
test.equal(time.utcWednesday.count(date.utc(2011, 00, 01), date.utc(2011, 02, 13, 04)), 10);
test.equal(time.utcWednesday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 00)), 44);
test.equal(time.utcWednesday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 01)), 44);
test.equal(time.utcWednesday.count(date.utc(2011, 00, 01), date.utc(2011, 10, 06, 02)), 44);
test.end();
});
d3-time-1.0.11/test/utcWeek-test.js 0000664 0000000 0000000 00000014024 13426151457 0016746 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("utcWeek.floor(date) returns sundays", function(test) {
test.deepEqual(time.utcWeek.floor(date.utc(2010, 11, 31, 23, 59, 59)), date.utc(2010, 11, 26));
test.deepEqual(time.utcWeek.floor(date.utc(2011, 00, 01, 00, 00, 00)), date.utc(2010, 11, 26));
test.deepEqual(time.utcWeek.floor(date.utc(2011, 00, 01, 00, 00, 01)), date.utc(2010, 11, 26));
test.deepEqual(time.utcWeek.floor(date.utc(2011, 00, 01, 23, 59, 59)), date.utc(2010, 11, 26));
test.deepEqual(time.utcWeek.floor(date.utc(2011, 00, 02, 00, 00, 00)), date.utc(2011, 00, 02));
test.deepEqual(time.utcWeek.floor(date.utc(2011, 00, 02, 00, 00, 01)), date.utc(2011, 00, 02));
test.end();
});
tape("utcWeek.floor(date) observes the start of daylight savings time", function(test) {
test.deepEqual(time.utcWeek.floor(date.utc(2011, 02, 13, 01)), date.utc(2011, 02, 13));
test.end();
});
tape("utcWeek.floor(date) observes the end of the daylight savings time", function(test) {
test.deepEqual(time.utcWeek.floor(date.utc(2011, 10, 06, 01)), date.utc(2011, 10, 06));
test.end();
});
tape("utcWeek.floor(date) correctly handles years in the first century", function(test) {
test.deepEqual(time.utcWeek.floor(date.utc(0011, 10, 06, 07)), date.utc(0011, 10, 01));
test.end();
});
tape("utcWeek.ceil(date) returns sundays", function(test) {
test.deepEqual(time.utcWeek.ceil(date.utc(2010, 11, 31, 23, 59, 59)), date.utc(2011, 00, 02));
test.deepEqual(time.utcWeek.ceil(date.utc(2011, 00, 01, 00, 00, 00)), date.utc(2011, 00, 02));
test.deepEqual(time.utcWeek.ceil(date.utc(2011, 00, 01, 00, 00, 01)), date.utc(2011, 00, 02));
test.deepEqual(time.utcWeek.ceil(date.utc(2011, 00, 01, 23, 59, 59)), date.utc(2011, 00, 02));
test.deepEqual(time.utcWeek.ceil(date.utc(2011, 00, 02, 00, 00, 00)), date.utc(2011, 00, 02));
test.deepEqual(time.utcWeek.ceil(date.utc(2011, 00, 02, 00, 00, 01)), date.utc(2011, 00, 09));
test.end();
});
tape("utcWeek.ceil(date) does not observe the start of daylight savings time", function(test) {
test.deepEqual(time.utcWeek.ceil(date.utc(2011, 02, 13, 01)), date.utc(2011, 02, 20));
test.end();
});
tape("utcWeek.ceil(date) does not observe the end of the daylight savings time", function(test) {
test.deepEqual(time.utcWeek.ceil(date.utc(2011, 10, 06, 01)), date.utc(2011, 10, 13));
test.end();
});
tape("utcWeek.offset(date, step) does not modify the passed-in date", function(test) {
var d = date.utc(2010, 11, 31, 23, 59, 59, 999);
time.utcWeek.offset(d, +1);
test.deepEqual(d, date.utc(2010, 11, 31, 23, 59, 59, 999));
test.end();
});
tape("utcWeek.offset(date, step) does not round the passed-in-date", function(test) {
test.deepEqual(time.utcWeek.offset(date.utc(2010, 11, 31, 23, 59, 59, 999), +1), date.utc(2011, 00, 07, 23, 59, 59, 999));
test.deepEqual(time.utcWeek.offset(date.utc(2010, 11, 31, 23, 59, 59, 456), -2), date.utc(2010, 11, 17, 23, 59, 59, 456));
test.end();
});
tape("utcWeek.offset(date, step) allows negative offsets", function(test) {
test.deepEqual(time.utcWeek.offset(date.utc(2010, 11, 01), -1), date.utc(2010, 10, 24));
test.deepEqual(time.utcWeek.offset(date.utc(2011, 00, 01), -2), date.utc(2010, 11, 18));
test.deepEqual(time.utcWeek.offset(date.utc(2011, 00, 01), -1), date.utc(2010, 11, 25));
test.end();
});
tape("utcWeek.offset(date, step) allows positive offsets", function(test) {
test.deepEqual(time.utcWeek.offset(date.utc(2010, 10, 24), +1), date.utc(2010, 11, 01));
test.deepEqual(time.utcWeek.offset(date.utc(2010, 11, 18), +2), date.utc(2011, 00, 01));
test.deepEqual(time.utcWeek.offset(date.utc(2010, 11, 25), +1), date.utc(2011, 00, 01));
test.end();
});
tape("utcWeek.offset(date, step) allows zero offset", function(test) {
test.deepEqual(time.utcWeek.offset(date.utc(2010, 11, 31, 23, 59, 59, 999), 0), date.utc(2010, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.utcWeek.offset(date.utc(2010, 11, 31, 23, 59, 58, 000), 0), date.utc(2010, 11, 31, 23, 59, 58, 000));
test.end();
});
tape("utcWeek.range(start, stop) returns sundays", function(test) {
test.deepEqual(time.utcWeek.range(date.utc(2010, 11, 21), date.utc(2011, 0, 12)), [
date.utc(2010, 11, 26),
date.utc(2011, 0, 2),
date.utc(2011, 0, 9)
]);
test.end();
});
tape("utcWeek.range(start, stop) has an inclusive lower bound", function(test) {
test.deepEqual(time.utcWeek.range(date.utc(2010, 11, 21), date.utc(2011, 0, 12))[0], date.utc(2010, 11, 26));
test.end();
});
tape("utcWeek.range(start, stop) has an exclusive upper bound", function(test) {
test.deepEqual(time.utcWeek.range(date.utc(2010, 11, 21), date.utc(2011, 0, 12))[2], date.utc(2011, 0, 9));
test.end();
});
tape("utcWeek.range(start, stop) can skip weeks", function(test) {
test.deepEqual(time.utcWeek.range(date.utc(2011, 0, 1), date.utc(2011, 3, 1), 4), [
date.utc(2011, 0, 2),
date.utc(2011, 0, 30),
date.utc(2011, 1, 27),
date.utc(2011, 2, 27)
]);
test.end();
});
tape("utcWeek.range(start, stop) does not observe start of daylight savings time", function(test) {
test.deepEqual(time.utcWeek.range(date.utc(2011, 2, 1), date.utc(2011, 2, 28)), [
date.utc(2011, 2, 6),
date.utc(2011, 2, 13),
date.utc(2011, 2, 20),
date.utc(2011, 2, 27)
]);
test.end();
});
tape("utcWeek.range(start, stop) does not observe end of daylight savings time", function(test) {
test.deepEqual(time.utcWeek.range(date.utc(2011, 10, 1), date.utc(2011, 10, 30)), [
date.utc(2011, 10, 6),
date.utc(2011, 10, 13),
date.utc(2011, 10, 20),
date.utc(2011, 10, 27)
]);
test.end();
});
tape("utcWeek is an alias for utcSunday", function(test) {
test.equal(time.utcWeek, time.utcSunday);
test.end();
});
tape("utcWeek.every(step) returns every stepth Sunday, starting with the first Sunday of the month", function(test) {
test.deepEqual(time.utcWeek.every(2).range(date.utc(2008, 11, 3), date.utc(2009, 1, 5)), [date.utc(2008, 11, 7), date.utc(2008, 11, 21), date.utc(2009, 0, 4), date.utc(2009, 0, 18), date.utc(2009, 1, 1)]);
test.end();
});
d3-time-1.0.11/test/utcYear-test.js 0000664 0000000 0000000 00000010112 13426151457 0016745 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("utcYear.floor(date) returns years", function(test) {
test.deepEqual(time.utcYear.floor(date.utc(2010, 11, 31, 23, 59, 59)), date.utc(2010, 00, 01));
test.deepEqual(time.utcYear.floor(date.utc(2011, 00, 01, 00, 00, 00)), date.utc(2011, 00, 01));
test.deepEqual(time.utcYear.floor(date.utc(2011, 00, 01, 00, 00, 01)), date.utc(2011, 00, 01));
test.end();
});
tape("utcYear.floor(date) does not modify the specified date", function(test) {
var d = date.utc(2010, 11, 31, 23, 59, 59);
test.deepEqual(time.utcYear.floor(d), date.utc(2010, 00, 01));
test.deepEqual(d, date.utc(2010, 11, 31, 23, 59, 59));
test.end();
});
tape("utcYear.floor(date) correctly handles years in the first century", function(test) {
test.deepEqual(time.utcYear.floor(date.utc(0011, 10, 06, 07)), date.utc(0011, 00, 01));
test.end();
});
tape("utcYear.ceil(date) returns years", function(test) {
test.deepEqual(time.utcYear.ceil(date.utc(2010, 11, 31, 23, 59, 59)), date.utc(2011, 00, 01));
test.deepEqual(time.utcYear.ceil(date.utc(2011, 00, 01, 00, 00, 00)), date.utc(2011, 00, 01));
test.deepEqual(time.utcYear.ceil(date.utc(2011, 00, 01, 00, 00, 01)), date.utc(2012, 00, 01));
test.end();
});
tape("utcYear.offset(date, count) does not modify the passed-in date", function(test) {
var d = date.utc(2010, 11, 31, 23, 59, 59, 999);
time.utcYear.offset(d, +1);
test.deepEqual(d, date.utc(2010, 11, 31, 23, 59, 59, 999));
test.end();
});
tape("utcYear.offset(date, count) does not round the passed-in-date", function(test) {
test.deepEqual(time.utcYear.offset(date.utc(2010, 11, 31, 23, 59, 59, 999), +1), date.utc(2011, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.utcYear.offset(date.utc(2010, 11, 31, 23, 59, 59, 456), -2), date.utc(2008, 11, 31, 23, 59, 59, 456));
test.end();
});
tape("utcYear.offset(date, count) allows negative offsets", function(test) {
test.deepEqual(time.utcYear.offset(date.utc(2010, 11, 01), -1), date.utc(2009, 11, 01));
test.deepEqual(time.utcYear.offset(date.utc(2011, 00, 01), -2), date.utc(2009, 00, 01));
test.deepEqual(time.utcYear.offset(date.utc(2011, 00, 01), -1), date.utc(2010, 00, 01));
test.end();
});
tape("utcYear.offset(date, count) allows positive offsets", function(test) {
test.deepEqual(time.utcYear.offset(date.utc(2009, 11, 01), +1), date.utc(2010, 11, 01));
test.deepEqual(time.utcYear.offset(date.utc(2009, 00, 01), +2), date.utc(2011, 00, 01));
test.deepEqual(time.utcYear.offset(date.utc(2010, 00, 01), +1), date.utc(2011, 00, 01));
test.end();
});
tape("utcYear.offset(date, count) allows zero offset", function(test) {
test.deepEqual(time.utcYear.offset(date.utc(2010, 11, 31, 23, 59, 59, 999), 0), date.utc(2010, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.utcYear.offset(date.utc(2010, 11, 31, 23, 59, 58, 000), 0), date.utc(2010, 11, 31, 23, 59, 58, 000));
test.end();
});
tape("utcYear.every(step) returns every stepth year, starting with year zero", function(test) {
test.deepEqual(time.utcYear.every(5).range(date.utc(2008), date.utc(2023)), [date.utc(2010), date.utc(2015), date.utc(2020)]);
test.end();
});
tape("utcYear.range(start, stop) returns years", function(test) {
test.deepEqual(time.utcYear.range(date.utc(2010, 0, 1), date.utc(2013, 0, 1)), [
date.utc(2010, 0, 1),
date.utc(2011, 0, 1),
date.utc(2012, 0, 1)
]);
test.end();
});
tape("utcYear.range(start, stop) has an inclusive lower bound", function(test) {
test.deepEqual(time.utcYear.range(date.utc(2010, 0, 1), date.utc(2013, 0, 1))[0], date.utc(2010, 0, 1));
test.end();
});
tape("utcYear.range(start, stop) has an exclusive upper bound", function(test) {
test.deepEqual(time.utcYear.range(date.utc(2010, 0, 1), date.utc(2013, 0, 1))[2], date.utc(2012, 0, 1));
test.end();
});
tape("utcYear.range(start, stop, step) can skip years", function(test) {
test.deepEqual(time.utcYear.range(date.utc(2009, 0, 1), date.utc(2029, 0, 1), 5), [
date.utc(2009, 0, 1),
date.utc(2014, 0, 1),
date.utc(2019, 0, 1),
date.utc(2024, 0, 1)
]);
test.end();
});
d3-time-1.0.11/test/wednesday-test.js 0000664 0000000 0000000 00000005421 13426151457 0017323 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("timeWednesdays in an alias for timeWednesday.range", function(test) {
test.equal(time.timeWednesdays, time.timeWednesday.range);
test.end();
});
tape("timeWednesday.floor(date) returns Wednesdays", function(test) {
test.deepEqual(time.timeWednesday.floor(date.local(2011, 00, 03, 23, 59, 59)), date.local(2010, 11, 29));
test.deepEqual(time.timeWednesday.floor(date.local(2011, 00, 04, 00, 00, 00)), date.local(2010, 11, 29));
test.deepEqual(time.timeWednesday.floor(date.local(2011, 00, 04, 00, 00, 01)), date.local(2010, 11, 29));
test.deepEqual(time.timeWednesday.floor(date.local(2011, 00, 04, 23, 59, 59)), date.local(2010, 11, 29));
test.deepEqual(time.timeWednesday.floor(date.local(2011, 00, 05, 00, 00, 00)), date.local(2011, 00, 05));
test.deepEqual(time.timeWednesday.floor(date.local(2011, 00, 05, 00, 00, 01)), date.local(2011, 00, 05));
test.end();
});
tape("timeWednesday.count(start, end) counts Wednesdays after start (exclusive) and before end (inclusive)", function(test) {
// January 2012
// Su Mo Tu We Th Fr Sa
// 1 2 3 4 5 6 7
// 8 9 10 11 12 13 14
// 15 16 17 18 19 20 21
// 22 23 24 25 26 27 28
// 29 30 31
test.equal(time.timeWednesday.count(date.local(2012, 00, 01), date.local(2012, 00, 03)), 0);
test.equal(time.timeWednesday.count(date.local(2012, 00, 01), date.local(2012, 00, 04)), 1);
test.equal(time.timeWednesday.count(date.local(2012, 00, 01), date.local(2012, 00, 05)), 1);
test.equal(time.timeWednesday.count(date.local(2012, 00, 01), date.local(2012, 00, 11)), 2);
// January 2014
// Su Mo Tu We Th Fr Sa
// 1 2 3 4
// 5 6 7 8 9 10 11
// 12 13 14 15 16 17 18
// 19 20 21 22 23 24 25
// 26 27 28 29 30 31
test.equal(time.timeWednesday.count(date.local(2014, 00, 01), date.local(2014, 00, 07)), 0);
test.equal(time.timeWednesday.count(date.local(2014, 00, 01), date.local(2014, 00, 08)), 1);
test.equal(time.timeWednesday.count(date.local(2014, 00, 01), date.local(2014, 00, 09)), 1);
test.end();
});
tape("timeWednesday.count(start, end) observes daylight saving", function(test) {
test.equal(time.timeWednesday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 01)), 10);
test.equal(time.timeWednesday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 03)), 10);
test.equal(time.timeWednesday.count(date.local(2011, 00, 01), date.local(2011, 02, 13, 04)), 10);
test.equal(time.timeWednesday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 00)), 44);
test.equal(time.timeWednesday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 01)), 44);
test.equal(time.timeWednesday.count(date.local(2011, 00, 01), date.local(2011, 10, 06, 02)), 44);
test.end();
});
d3-time-1.0.11/test/week-test.js 0000664 0000000 0000000 00000014346 13426151457 0016301 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("timeWeek.floor(date) returns sundays", function(test) {
test.deepEqual(time.timeWeek.floor(date.local(2010, 11, 31, 23, 59, 59)), date.local(2010, 11, 26));
test.deepEqual(time.timeWeek.floor(date.local(2011, 00, 01, 00, 00, 00)), date.local(2010, 11, 26));
test.deepEqual(time.timeWeek.floor(date.local(2011, 00, 01, 00, 00, 01)), date.local(2010, 11, 26));
test.deepEqual(time.timeWeek.floor(date.local(2011, 00, 01, 23, 59, 59)), date.local(2010, 11, 26));
test.deepEqual(time.timeWeek.floor(date.local(2011, 00, 02, 00, 00, 00)), date.local(2011, 00, 02));
test.deepEqual(time.timeWeek.floor(date.local(2011, 00, 02, 00, 00, 01)), date.local(2011, 00, 02));
test.end();
});
tape("timeWeek.floor(date) observes the start of daylight savings time", function(test) {
test.deepEqual(time.timeWeek.floor(date.local(2011, 02, 13, 01)), date.local(2011, 02, 13));
test.end();
});
tape("timeWeek.floor(date) observes the end of the daylight savings time", function(test) {
test.deepEqual(time.timeWeek.floor(date.local(2011, 10, 06, 01)), date.local(2011, 10, 06));
test.end();
});
tape("timeWeek.floor(date) correctly handles years in the first century", function(test) {
test.deepEqual(time.timeWeek.floor(date.local(0011, 10, 06, 07)), date.local(0011, 10, 01));
test.end();
});
tape("timeWeek.ceil(date) returns sundays", function(test) {
test.deepEqual(time.timeWeek.ceil(date.local(2010, 11, 31, 23, 59, 59)), date.local(2011, 00, 02));
test.deepEqual(time.timeWeek.ceil(date.local(2011, 00, 01, 00, 00, 00)), date.local(2011, 00, 02));
test.deepEqual(time.timeWeek.ceil(date.local(2011, 00, 01, 00, 00, 01)), date.local(2011, 00, 02));
test.deepEqual(time.timeWeek.ceil(date.local(2011, 00, 01, 23, 59, 59)), date.local(2011, 00, 02));
test.deepEqual(time.timeWeek.ceil(date.local(2011, 00, 02, 00, 00, 00)), date.local(2011, 00, 02));
test.deepEqual(time.timeWeek.ceil(date.local(2011, 00, 02, 00, 00, 01)), date.local(2011, 00, 09));
test.end();
});
tape("timeWeek.ceil(date) observes the start of daylight savings time", function(test) {
test.deepEqual(time.timeWeek.ceil(date.local(2011, 02, 13, 01)), date.local(2011, 02, 20));
test.end();
});
tape("timeWeek.ceil(date) observes the end of the daylight savings time", function(test) {
test.deepEqual(time.timeWeek.ceil(date.local(2011, 10, 06, 01)), date.local(2011, 10, 13));
test.end();
});
tape("timeWeek.offset(date, step) does not modify the passed-in date", function(test) {
var d = date.local(2010, 11, 31, 23, 59, 59, 999);
time.timeWeek.offset(d, +1);
test.deepEqual(d, date.local(2010, 11, 31, 23, 59, 59, 999));
test.end();
});
tape("timeWeek.offset(date, step) does not round the passed-in-date", function(test) {
test.deepEqual(time.timeWeek.offset(date.local(2010, 11, 31, 23, 59, 59, 999), +1), date.local(2011, 00, 07, 23, 59, 59, 999));
test.deepEqual(time.timeWeek.offset(date.local(2010, 11, 31, 23, 59, 59, 456), -2), date.local(2010, 11, 17, 23, 59, 59, 456));
test.end();
});
tape("timeWeek.offset(date, step) allows negative offsets", function(test) {
test.deepEqual(time.timeWeek.offset(date.local(2010, 11, 01), -1), date.local(2010, 10, 24));
test.deepEqual(time.timeWeek.offset(date.local(2011, 00, 01), -2), date.local(2010, 11, 18));
test.deepEqual(time.timeWeek.offset(date.local(2011, 00, 01), -1), date.local(2010, 11, 25));
test.end();
});
tape("timeWeek.offset(date, step) allows positive offsets", function(test) {
test.deepEqual(time.timeWeek.offset(date.local(2010, 10, 24), +1), date.local(2010, 11, 01));
test.deepEqual(time.timeWeek.offset(date.local(2010, 11, 18), +2), date.local(2011, 00, 01));
test.deepEqual(time.timeWeek.offset(date.local(2010, 11, 25), +1), date.local(2011, 00, 01));
test.end();
});
tape("timeWeek.offset(date, step) allows zero offset", function(test) {
test.deepEqual(time.timeWeek.offset(date.local(2010, 11, 31, 23, 59, 59, 999), 0), date.local(2010, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.timeWeek.offset(date.local(2010, 11, 31, 23, 59, 58, 000), 0), date.local(2010, 11, 31, 23, 59, 58, 000));
test.end();
});
tape("timeWeek.range(start, stop) returns sundays", function(test) {
test.deepEqual(time.timeWeek.range(date.local(2010, 11, 21), date.local(2011, 0, 12)), [
date.local(2010, 11, 26),
date.local(2011, 0, 2),
date.local(2011, 0, 9)
]);
test.end();
});
tape("timeWeek.range(start, stop) has an inclusive lower bound", function(test) {
test.deepEqual(time.timeWeek.range(date.local(2010, 11, 21), date.local(2011, 0, 12))[0], date.local(2010, 11, 26));
test.end();
});
tape("timeWeek.range(start, stop) has an exclusive upper bound", function(test) {
test.deepEqual(time.timeWeek.range(date.local(2010, 11, 21), date.local(2011, 0, 12))[2], date.local(2011, 0, 9));
test.end();
});
tape("timeWeek.range(start, stop) can skip weeks", function(test) {
test.deepEqual(time.timeWeek.range(date.local(2011, 0, 1), date.local(2011, 3, 1), 4), [
date.local(2011, 0, 2),
date.local(2011, 0, 30),
date.local(2011, 1, 27),
date.local(2011, 2, 27)
]);
test.end();
});
tape("timeWeek.range(start, stop) observes start of daylight savings time", function(test) {
test.deepEqual(time.timeWeek.range(date.local(2011, 2, 1), date.local(2011, 2, 28)), [
date.local(2011, 2, 6),
date.local(2011, 2, 13),
date.local(2011, 2, 20),
date.local(2011, 2, 27)
]);
test.end();
});
tape("timeWeek.range(start, stop) observes end of daylight savings time", function(test) {
test.deepEqual(time.timeWeek.range(date.local(2011, 10, 1), date.local(2011, 10, 30)), [
date.local(2011, 10, 6),
date.local(2011, 10, 13),
date.local(2011, 10, 20),
date.local(2011, 10, 27)
]);
test.end();
});
tape("timeWeek is an alias for timeSunday", function(test) {
test.equal(time.timeWeek, time.timeSunday);
test.end();
});
tape("timeWeek.every(step) returns every stepth Sunday, starting with the first Sunday of the month", function(test) {
test.deepEqual(time.timeWeek.every(2).range(date.local(2008, 11, 3), date.local(2009, 1, 5)), [date.local(2008, 11, 7), date.local(2008, 11, 21), date.local(2009, 0, 4), date.local(2009, 0, 18), date.local(2009, 1, 1)]);
test.end();
});
d3-time-1.0.11/test/year-test.js 0000664 0000000 0000000 00000010352 13426151457 0016277 0 ustar 00root root 0000000 0000000 var tape = require("tape"),
time = require("../"),
date = require("./date");
tape("timeYear.floor(date) returns years", function(test) {
test.deepEqual(time.timeYear.floor(date.local(2010, 11, 31, 23, 59, 59)), date.local(2010, 00, 01));
test.deepEqual(time.timeYear.floor(date.local(2011, 00, 01, 00, 00, 00)), date.local(2011, 00, 01));
test.deepEqual(time.timeYear.floor(date.local(2011, 00, 01, 00, 00, 01)), date.local(2011, 00, 01));
test.end();
});
tape("timeYear.floor(date) does not modify the specified date", function(test) {
var d = date.local(2010, 11, 31, 23, 59, 59);
test.deepEqual(time.timeYear.floor(d), date.local(2010, 00, 01));
test.deepEqual(d, date.local(2010, 11, 31, 23, 59, 59));
test.end();
});
tape("timeYear.floor(date) correctly handles years in the first century", function(test) {
test.deepEqual(time.timeYear.floor(date.local(0011, 10, 06, 07)), date.local(0011, 00, 01));
test.end();
});
tape("timeYear.ceil(date) returns years", function(test) {
test.deepEqual(time.timeYear.ceil(date.local(2010, 11, 31, 23, 59, 59)), date.local(2011, 00, 01));
test.deepEqual(time.timeYear.ceil(date.local(2011, 00, 01, 00, 00, 00)), date.local(2011, 00, 01));
test.deepEqual(time.timeYear.ceil(date.local(2011, 00, 01, 00, 00, 01)), date.local(2012, 00, 01));
test.end();
});
tape("timeYear.offset(date, count) does not modify the passed-in date", function(test) {
var d = date.local(2010, 11, 31, 23, 59, 59, 999);
time.timeYear.offset(d, +1);
test.deepEqual(d, date.local(2010, 11, 31, 23, 59, 59, 999));
test.end();
});
tape("timeYear.offset(date, count) does not round the passed-in-date", function(test) {
test.deepEqual(time.timeYear.offset(date.local(2010, 11, 31, 23, 59, 59, 999), +1), date.local(2011, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.timeYear.offset(date.local(2010, 11, 31, 23, 59, 59, 456), -2), date.local(2008, 11, 31, 23, 59, 59, 456));
test.end();
});
tape("timeYear.offset(date, count) allows negative offsets", function(test) {
test.deepEqual(time.timeYear.offset(date.local(2010, 11, 01), -1), date.local(2009, 11, 01));
test.deepEqual(time.timeYear.offset(date.local(2011, 00, 01), -2), date.local(2009, 00, 01));
test.deepEqual(time.timeYear.offset(date.local(2011, 00, 01), -1), date.local(2010, 00, 01));
test.end();
});
tape("timeYear.offset(date, count) allows positive offsets", function(test) {
test.deepEqual(time.timeYear.offset(date.local(2009, 11, 01), +1), date.local(2010, 11, 01));
test.deepEqual(time.timeYear.offset(date.local(2009, 00, 01), +2), date.local(2011, 00, 01));
test.deepEqual(time.timeYear.offset(date.local(2010, 00, 01), +1), date.local(2011, 00, 01));
test.end();
});
tape("timeYear.offset(date, count) allows zero offset", function(test) {
test.deepEqual(time.timeYear.offset(date.local(2010, 11, 31, 23, 59, 59, 999), 0), date.local(2010, 11, 31, 23, 59, 59, 999));
test.deepEqual(time.timeYear.offset(date.local(2010, 11, 31, 23, 59, 58, 000), 0), date.local(2010, 11, 31, 23, 59, 58, 000));
test.end();
});
tape("timeYear.every(step) returns every stepth year, starting with year zero", function(test) {
test.deepEqual(time.timeYear.every(5).range(date.local(2008), date.local(2023)), [date.local(2010), date.local(2015), date.local(2020)]);
test.end();
});
tape("timeYear.range(start, stop) returns years", function(test) {
test.deepEqual(time.timeYear.range(date.local(2010, 0, 1), date.local(2013, 0, 1)), [
date.local(2010, 0, 1),
date.local(2011, 0, 1),
date.local(2012, 0, 1)
]);
test.end();
});
tape("timeYear.range(start, stop) has an inclusive lower bound", function(test) {
test.deepEqual(time.timeYear.range(date.local(2010, 0, 1), date.local(2013, 0, 1))[0], date.local(2010, 0, 1));
test.end();
});
tape("timeYear.range(start, stop) has an exclusive upper bound", function(test) {
test.deepEqual(time.timeYear.range(date.local(2010, 0, 1), date.local(2013, 0, 1))[2], date.local(2012, 0, 1));
test.end();
});
tape("timeYear.range(start, stop, step) can skip years", function(test) {
test.deepEqual(time.timeYear.range(date.local(2009, 0, 1), date.local(2029, 0, 1), 5), [
date.local(2009, 0, 1),
date.local(2014, 0, 1),
date.local(2019, 0, 1),
date.local(2024, 0, 1)
]);
test.end();
});
d3-time-1.0.11/yarn.lock 0000664 0000000 0000000 00000076514 13426151457 0014704 0 ustar 00root root 0000000 0000000 # THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
# yarn lockfile v1
"@babel/code-frame@^7.0.0-beta.47":
version "7.0.0-rc.3"
resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.0.0-rc.3.tgz#d77a587401f818a3168700f596e41cd6905947b2"
dependencies:
"@babel/highlight" "7.0.0-rc.3"
"@babel/highlight@7.0.0-rc.3":
version "7.0.0-rc.3"
resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.0.0-rc.3.tgz#c2ee83f8e5c0c387279a8c48e06fef2e32027004"
dependencies:
chalk "^2.0.0"
esutils "^2.0.2"
js-tokens "^4.0.0"
"@types/estree@0.0.39":
version "0.0.39"
resolved "https://registry.yarnpkg.com/@types/estree/-/estree-0.0.39.tgz#e177e699ee1b8c22d23174caaa7422644389509f"
"@types/node@*":
version "10.9.1"
resolved "https://registry.yarnpkg.com/@types/node/-/node-10.9.1.tgz#06f002136fbcf51e730995149050bb3c45ee54e6"
acorn-jsx@^4.1.1:
version "4.1.1"
resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-4.1.1.tgz#e8e41e48ea2fe0c896740610ab6a4ffd8add225e"
dependencies:
acorn "^5.0.3"
acorn@^5.0.3, acorn@^5.6.0:
version "5.7.2"
resolved "https://registry.yarnpkg.com/acorn/-/acorn-5.7.2.tgz#91fa871883485d06708800318404e72bfb26dcc5"
ajv-keywords@^3.0.0:
version "3.2.0"
resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-3.2.0.tgz#e86b819c602cf8821ad637413698f1dec021847a"
ajv@^6.0.1, ajv@^6.5.0:
version "6.5.3"
resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.5.3.tgz#71a569d189ecf4f4f321224fecb166f071dd90f9"
dependencies:
fast-deep-equal "^2.0.1"
fast-json-stable-stringify "^2.0.0"
json-schema-traverse "^0.4.1"
uri-js "^4.2.2"
ansi-escapes@^3.0.0:
version "3.1.0"
resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-3.1.0.tgz#f73207bb81207d75fd6c83f125af26eea378ca30"
ansi-regex@^2.0.0:
version "2.1.1"
resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-2.1.1.tgz#c3b33ab5ee360d86e0e628f0468ae7ef27d654df"
ansi-regex@^3.0.0:
version "3.0.0"
resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-3.0.0.tgz#ed0317c322064f79466c02966bddb605ab37d998"
ansi-styles@^2.2.1:
version "2.2.1"
resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-2.2.1.tgz#b432dd3358b634cf75e1e4664368240533c1ddbe"
ansi-styles@^3.2.1:
version "3.2.1"
resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d"
dependencies:
color-convert "^1.9.0"
argparse@^1.0.7:
version "1.0.10"
resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911"
dependencies:
sprintf-js "~1.0.2"
array-union@^1.0.1:
version "1.0.2"
resolved "https://registry.yarnpkg.com/array-union/-/array-union-1.0.2.tgz#9a34410e4f4e3da23dea375be5be70f24778ec39"
dependencies:
array-uniq "^1.0.1"
array-uniq@^1.0.1:
version "1.0.3"
resolved "https://registry.yarnpkg.com/array-uniq/-/array-uniq-1.0.3.tgz#af6ac877a25cc7f74e058894753858dfdb24fdb6"
arrify@^1.0.0:
version "1.0.1"
resolved "https://registry.yarnpkg.com/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d"
babel-code-frame@^6.26.0:
version "6.26.0"
resolved "https://registry.yarnpkg.com/babel-code-frame/-/babel-code-frame-6.26.0.tgz#63fd43f7dc1e3bb7ce35947db8fe369a3f58c74b"
dependencies:
chalk "^1.1.3"
esutils "^2.0.2"
js-tokens "^3.0.2"
balanced-match@^1.0.0:
version "1.0.0"
resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.0.tgz#89b4d199ab2bee49de164ea02b89ce462d71b767"
brace-expansion@^1.1.7:
version "1.1.11"
resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd"
dependencies:
balanced-match "^1.0.0"
concat-map "0.0.1"
buffer-from@^1.0.0:
version "1.1.1"
resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.1.tgz#32713bc028f75c02fdb710d7c7bcec1f2c6070ef"
caller-path@^0.1.0:
version "0.1.0"
resolved "https://registry.yarnpkg.com/caller-path/-/caller-path-0.1.0.tgz#94085ef63581ecd3daa92444a8fe94e82577751f"
dependencies:
callsites "^0.2.0"
callsites@^0.2.0:
version "0.2.0"
resolved "https://registry.yarnpkg.com/callsites/-/callsites-0.2.0.tgz#afab96262910a7f33c19a5775825c69f34e350ca"
chalk@^1.1.3:
version "1.1.3"
resolved "https://registry.yarnpkg.com/chalk/-/chalk-1.1.3.tgz#a8115c55e4a702fe4d150abd3872822a7e09fc98"
dependencies:
ansi-styles "^2.2.1"
escape-string-regexp "^1.0.2"
has-ansi "^2.0.0"
strip-ansi "^3.0.0"
supports-color "^2.0.0"
chalk@^2.0.0, chalk@^2.1.0:
version "2.4.1"
resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.1.tgz#18c49ab16a037b6eb0152cc83e3471338215b66e"
dependencies:
ansi-styles "^3.2.1"
escape-string-regexp "^1.0.5"
supports-color "^5.3.0"
chardet@^0.4.0:
version "0.4.2"
resolved "https://registry.yarnpkg.com/chardet/-/chardet-0.4.2.tgz#b5473b33dc97c424e5d98dc87d55d4d8a29c8bf2"
circular-json@^0.3.1:
version "0.3.3"
resolved "https://registry.yarnpkg.com/circular-json/-/circular-json-0.3.3.tgz#815c99ea84f6809529d2f45791bdf82711352d66"
cli-cursor@^2.1.0:
version "2.1.0"
resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-2.1.0.tgz#b35dac376479facc3e94747d41d0d0f5238ffcb5"
dependencies:
restore-cursor "^2.0.0"
cli-width@^2.0.0:
version "2.2.0"
resolved "https://registry.yarnpkg.com/cli-width/-/cli-width-2.2.0.tgz#ff19ede8a9a5e579324147b0c11f0fbcbabed639"
color-convert@^1.9.0:
version "1.9.2"
resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-1.9.2.tgz#49881b8fba67df12a96bdf3f56c0aab9e7913147"
dependencies:
color-name "1.1.1"
color-name@1.1.1:
version "1.1.1"
resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.1.tgz#4b1415304cf50028ea81643643bd82ea05803689"
commander@~2.16.0:
version "2.16.0"
resolved "https://registry.yarnpkg.com/commander/-/commander-2.16.0.tgz#f16390593996ceb4f3eeb020b31d78528f7f8a50"
concat-map@0.0.1:
version "0.0.1"
resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
cross-spawn@^6.0.5:
version "6.0.5"
resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-6.0.5.tgz#4a5ec7c64dfae22c3a14124dbacdee846d80cbc4"
dependencies:
nice-try "^1.0.4"
path-key "^2.0.1"
semver "^5.5.0"
shebang-command "^1.2.0"
which "^1.2.9"
debug@^3.1.0:
version "3.1.0"
resolved "https://registry.yarnpkg.com/debug/-/debug-3.1.0.tgz#5bb5a0672628b64149566ba16819e61518c67261"
dependencies:
ms "2.0.0"
deep-equal@~1.0.1:
version "1.0.1"
resolved "https://registry.yarnpkg.com/deep-equal/-/deep-equal-1.0.1.tgz#f5d260292b660e084eff4cdbc9f08ad3247448b5"
deep-is@~0.1.3:
version "0.1.3"
resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.3.tgz#b369d6fb5dbc13eecf524f91b070feedc357cf34"
define-properties@^1.1.2:
version "1.1.3"
resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.1.3.tgz#cf88da6cbee26fe6db7094f61d870cbd84cee9f1"
dependencies:
object-keys "^1.0.12"
defined@~1.0.0:
version "1.0.0"
resolved "https://registry.yarnpkg.com/defined/-/defined-1.0.0.tgz#c98d9bcef75674188e110969151199e39b1fa693"
del@^2.0.2:
version "2.2.2"
resolved "https://registry.yarnpkg.com/del/-/del-2.2.2.tgz#c12c981d067846c84bcaf862cff930d907ffd1a8"
dependencies:
globby "^5.0.0"
is-path-cwd "^1.0.0"
is-path-in-cwd "^1.0.0"
object-assign "^4.0.1"
pify "^2.0.0"
pinkie-promise "^2.0.0"
rimraf "^2.2.8"
doctrine@^2.1.0:
version "2.1.0"
resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-2.1.0.tgz#5cd01fc101621b42c4cd7f5d1a66243716d3f39d"
dependencies:
esutils "^2.0.2"
es-abstract@^1.5.0:
version "1.12.0"
resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.12.0.tgz#9dbbdd27c6856f0001421ca18782d786bf8a6165"
dependencies:
es-to-primitive "^1.1.1"
function-bind "^1.1.1"
has "^1.0.1"
is-callable "^1.1.3"
is-regex "^1.0.4"
es-to-primitive@^1.1.1:
version "1.1.1"
resolved "https://registry.yarnpkg.com/es-to-primitive/-/es-to-primitive-1.1.1.tgz#45355248a88979034b6792e19bb81f2b7975dd0d"
dependencies:
is-callable "^1.1.1"
is-date-object "^1.0.1"
is-symbol "^1.0.1"
escape-string-regexp@^1.0.2, escape-string-regexp@^1.0.5:
version "1.0.5"
resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"
eslint-scope@^4.0.0:
version "4.0.0"
resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-4.0.0.tgz#50bf3071e9338bcdc43331794a0cb533f0136172"
dependencies:
esrecurse "^4.1.0"
estraverse "^4.1.1"
eslint-utils@^1.3.1:
version "1.3.1"
resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-1.3.1.tgz#9a851ba89ee7c460346f97cf8939c7298827e512"
eslint-visitor-keys@^1.0.0:
version "1.0.0"
resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-1.0.0.tgz#3f3180fb2e291017716acb4c9d6d5b5c34a6a81d"
eslint@5:
version "5.4.0"
resolved "https://registry.yarnpkg.com/eslint/-/eslint-5.4.0.tgz#d068ec03006bb9e06b429dc85f7e46c1b69fac62"
dependencies:
ajv "^6.5.0"
babel-code-frame "^6.26.0"
chalk "^2.1.0"
cross-spawn "^6.0.5"
debug "^3.1.0"
doctrine "^2.1.0"
eslint-scope "^4.0.0"
eslint-utils "^1.3.1"
eslint-visitor-keys "^1.0.0"
espree "^4.0.0"
esquery "^1.0.1"
esutils "^2.0.2"
file-entry-cache "^2.0.0"
functional-red-black-tree "^1.0.1"
glob "^7.1.2"
globals "^11.7.0"
ignore "^4.0.2"
imurmurhash "^0.1.4"
inquirer "^5.2.0"
is-resolvable "^1.1.0"
js-yaml "^3.11.0"
json-stable-stringify-without-jsonify "^1.0.1"
levn "^0.3.0"
lodash "^4.17.5"
minimatch "^3.0.4"
mkdirp "^0.5.1"
natural-compare "^1.4.0"
optionator "^0.8.2"
path-is-inside "^1.0.2"
pluralize "^7.0.0"
progress "^2.0.0"
regexpp "^2.0.0"
require-uncached "^1.0.3"
semver "^5.5.0"
strip-ansi "^4.0.0"
strip-json-comments "^2.0.1"
table "^4.0.3"
text-table "^0.2.0"
espree@^4.0.0:
version "4.0.0"
resolved "https://registry.yarnpkg.com/espree/-/espree-4.0.0.tgz#253998f20a0f82db5d866385799d912a83a36634"
dependencies:
acorn "^5.6.0"
acorn-jsx "^4.1.1"
esprima@^4.0.0:
version "4.0.1"
resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71"
esquery@^1.0.1:
version "1.0.1"
resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.0.1.tgz#406c51658b1f5991a5f9b62b1dc25b00e3e5c708"
dependencies:
estraverse "^4.0.0"
esrecurse@^4.1.0:
version "4.2.1"
resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.2.1.tgz#007a3b9fdbc2b3bb87e4879ea19c92fdbd3942cf"
dependencies:
estraverse "^4.1.0"
estraverse@^4.0.0, estraverse@^4.1.0, estraverse@^4.1.1:
version "4.2.0"
resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.2.0.tgz#0dee3fed31fcd469618ce7342099fc1afa0bdb13"
esutils@^2.0.2:
version "2.0.2"
resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.2.tgz#0abf4f1caa5bcb1f7a9d8acc6dea4faaa04bac9b"
external-editor@^2.1.0:
version "2.2.0"
resolved "https://registry.yarnpkg.com/external-editor/-/external-editor-2.2.0.tgz#045511cfd8d133f3846673d1047c154e214ad3d5"
dependencies:
chardet "^0.4.0"
iconv-lite "^0.4.17"
tmp "^0.0.33"
fast-deep-equal@^2.0.1:
version "2.0.1"
resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-2.0.1.tgz#7b05218ddf9667bf7f370bf7fdb2cb15fdd0aa49"
fast-json-stable-stringify@^2.0.0:
version "2.0.0"
resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz#d5142c0caee6b1189f87d3a76111064f86c8bbf2"
fast-levenshtein@~2.0.4:
version "2.0.6"
resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917"
figures@^2.0.0:
version "2.0.0"
resolved "https://registry.yarnpkg.com/figures/-/figures-2.0.0.tgz#3ab1a2d2a62c8bfb431a0c94cb797a2fce27c962"
dependencies:
escape-string-regexp "^1.0.5"
file-entry-cache@^2.0.0:
version "2.0.0"
resolved "https://registry.yarnpkg.com/file-entry-cache/-/file-entry-cache-2.0.0.tgz#c392990c3e684783d838b8c84a45d8a048458361"
dependencies:
flat-cache "^1.2.1"
object-assign "^4.0.1"
flat-cache@^1.2.1:
version "1.3.0"
resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-1.3.0.tgz#d3030b32b38154f4e3b7e9c709f490f7ef97c481"
dependencies:
circular-json "^0.3.1"
del "^2.0.2"
graceful-fs "^4.1.2"
write "^0.2.1"
for-each@~0.3.3:
version "0.3.3"
resolved "https://registry.yarnpkg.com/for-each/-/for-each-0.3.3.tgz#69b447e88a0a5d32c3e7084f3f1710034b21376e"
dependencies:
is-callable "^1.1.3"
fs.realpath@^1.0.0:
version "1.0.0"
resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
function-bind@^1.0.2, function-bind@^1.1.1, function-bind@~1.1.1:
version "1.1.1"
resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"
functional-red-black-tree@^1.0.1:
version "1.0.1"
resolved "https://registry.yarnpkg.com/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz#1b0ab3bd553b2a0d6399d29c0e3ea0b252078327"
glob@^7.0.3, glob@^7.0.5, glob@^7.1.2, glob@~7.1.2:
version "7.1.2"
resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.2.tgz#c19c9df9a028702d678612384a6552404c636d15"
dependencies:
fs.realpath "^1.0.0"
inflight "^1.0.4"
inherits "2"
minimatch "^3.0.4"
once "^1.3.0"
path-is-absolute "^1.0.0"
globals@^11.7.0:
version "11.7.0"
resolved "https://registry.yarnpkg.com/globals/-/globals-11.7.0.tgz#a583faa43055b1aca771914bf68258e2fc125673"
globby@^5.0.0:
version "5.0.0"
resolved "https://registry.yarnpkg.com/globby/-/globby-5.0.0.tgz#ebd84667ca0dbb330b99bcfc68eac2bc54370e0d"
dependencies:
array-union "^1.0.1"
arrify "^1.0.0"
glob "^7.0.3"
object-assign "^4.0.1"
pify "^2.0.0"
pinkie-promise "^2.0.0"
graceful-fs@^4.1.2:
version "4.1.11"
resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.1.11.tgz#0e8bdfe4d1ddb8854d64e04ea7c00e2a026e5658"
has-ansi@^2.0.0:
version "2.0.0"
resolved "https://registry.yarnpkg.com/has-ansi/-/has-ansi-2.0.0.tgz#34f5049ce1ecdf2b0649af3ef24e45ed35416d91"
dependencies:
ansi-regex "^2.0.0"
has-flag@^3.0.0:
version "3.0.0"
resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
has@^1.0.1, has@~1.0.3:
version "1.0.3"
resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796"
dependencies:
function-bind "^1.1.1"
iconv-lite@^0.4.17:
version "0.4.24"
resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b"
dependencies:
safer-buffer ">= 2.1.2 < 3"
ignore@^4.0.2:
version "4.0.6"
resolved "https://registry.yarnpkg.com/ignore/-/ignore-4.0.6.tgz#750e3db5862087b4737ebac8207ffd1ef27b25fc"
imurmurhash@^0.1.4:
version "0.1.4"
resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea"
inflight@^1.0.4:
version "1.0.6"
resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
dependencies:
once "^1.3.0"
wrappy "1"
inherits@2, inherits@~2.0.3:
version "2.0.3"
resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.3.tgz#633c2c83e3da42a502f52466022480f4208261de"
inquirer@^5.2.0:
version "5.2.0"
resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-5.2.0.tgz#db350c2b73daca77ff1243962e9f22f099685726"
dependencies:
ansi-escapes "^3.0.0"
chalk "^2.0.0"
cli-cursor "^2.1.0"
cli-width "^2.0.0"
external-editor "^2.1.0"
figures "^2.0.0"
lodash "^4.3.0"
mute-stream "0.0.7"
run-async "^2.2.0"
rxjs "^5.5.2"
string-width "^2.1.0"
strip-ansi "^4.0.0"
through "^2.3.6"
is-callable@^1.1.1, is-callable@^1.1.3:
version "1.1.4"
resolved "https://registry.yarnpkg.com/is-callable/-/is-callable-1.1.4.tgz#1e1adf219e1eeb684d691f9d6a05ff0d30a24d75"
is-date-object@^1.0.1:
version "1.0.1"
resolved "https://registry.yarnpkg.com/is-date-object/-/is-date-object-1.0.1.tgz#9aa20eb6aeebbff77fbd33e74ca01b33581d3a16"
is-fullwidth-code-point@^2.0.0:
version "2.0.0"
resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz#a3b30a5c4f199183167aaab93beefae3ddfb654f"
is-path-cwd@^1.0.0:
version "1.0.0"
resolved "https://registry.yarnpkg.com/is-path-cwd/-/is-path-cwd-1.0.0.tgz#d225ec23132e89edd38fda767472e62e65f1106d"
is-path-in-cwd@^1.0.0:
version "1.0.1"
resolved "https://registry.yarnpkg.com/is-path-in-cwd/-/is-path-in-cwd-1.0.1.tgz#5ac48b345ef675339bd6c7a48a912110b241cf52"
dependencies:
is-path-inside "^1.0.0"
is-path-inside@^1.0.0:
version "1.0.1"
resolved "https://registry.yarnpkg.com/is-path-inside/-/is-path-inside-1.0.1.tgz#8ef5b7de50437a3fdca6b4e865ef7aa55cb48036"
dependencies:
path-is-inside "^1.0.1"
is-promise@^2.1.0:
version "2.1.0"
resolved "https://registry.yarnpkg.com/is-promise/-/is-promise-2.1.0.tgz#79a2a9ece7f096e80f36d2b2f3bc16c1ff4bf3fa"
is-regex@^1.0.4:
version "1.0.4"
resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.0.4.tgz#5517489b547091b0930e095654ced25ee97e9491"
dependencies:
has "^1.0.1"
is-resolvable@^1.1.0:
version "1.1.0"
resolved "https://registry.yarnpkg.com/is-resolvable/-/is-resolvable-1.1.0.tgz#fb18f87ce1feb925169c9a407c19318a3206ed88"
is-symbol@^1.0.1:
version "1.0.1"
resolved "https://registry.yarnpkg.com/is-symbol/-/is-symbol-1.0.1.tgz#3cc59f00025194b6ab2e38dbae6689256b660572"
isexe@^2.0.0:
version "2.0.0"
resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10"
js-tokens@^3.0.2:
version "3.0.2"
resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-3.0.2.tgz#9866df395102130e38f7f996bceb65443209c25b"
js-tokens@^4.0.0:
version "4.0.0"
resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499"
js-yaml@^3.11.0:
version "3.12.0"
resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.12.0.tgz#eaed656ec8344f10f527c6bfa1b6e2244de167d1"
dependencies:
argparse "^1.0.7"
esprima "^4.0.0"
json-schema-traverse@^0.4.1:
version "0.4.1"
resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660"
json-stable-stringify-without-jsonify@^1.0.1:
version "1.0.1"
resolved "https://registry.yarnpkg.com/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz#9db7b59496ad3f3cfef30a75142d2d930ad72651"
levn@^0.3.0, levn@~0.3.0:
version "0.3.0"
resolved "https://registry.yarnpkg.com/levn/-/levn-0.3.0.tgz#3b09924edf9f083c0490fdd4c0bc4421e04764ee"
dependencies:
prelude-ls "~1.1.2"
type-check "~0.3.2"
lodash@^4.17.4, lodash@^4.17.5, lodash@^4.3.0:
version "4.17.10"
resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.10.tgz#1b7793cf7259ea38fb3661d4d38b3260af8ae4e7"
mimic-fn@^1.0.0:
version "1.2.0"
resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-1.2.0.tgz#820c86a39334640e99516928bd03fca88057d022"
minimatch@^3.0.4:
version "3.0.4"
resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.4.tgz#5166e286457f03306064be5497e8dbb0c3d32083"
dependencies:
brace-expansion "^1.1.7"
minimist@0.0.8:
version "0.0.8"
resolved "https://registry.yarnpkg.com/minimist/-/minimist-0.0.8.tgz#857fcabfc3397d2625b8228262e86aa7a011b05d"
minimist@~1.2.0:
version "1.2.0"
resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.0.tgz#a35008b20f41383eec1fb914f4cd5df79a264284"
mkdirp@^0.5.1:
version "0.5.1"
resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.1.tgz#30057438eac6cf7f8c4767f38648d6697d75c903"
dependencies:
minimist "0.0.8"
ms@2.0.0:
version "2.0.0"
resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8"
mute-stream@0.0.7:
version "0.0.7"
resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-0.0.7.tgz#3075ce93bc21b8fab43e1bc4da7e8115ed1e7bab"
natural-compare@^1.4.0:
version "1.4.0"
resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7"
nice-try@^1.0.4:
version "1.0.4"
resolved "https://registry.yarnpkg.com/nice-try/-/nice-try-1.0.4.tgz#d93962f6c52f2c1558c0fbda6d512819f1efe1c4"
object-assign@^4.0.1:
version "4.1.1"
resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
object-inspect@~1.6.0:
version "1.6.0"
resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.6.0.tgz#c70b6cbf72f274aab4c34c0c82f5167bf82cf15b"
object-keys@^1.0.12:
version "1.0.12"
resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.0.12.tgz#09c53855377575310cca62f55bb334abff7b3ed2"
once@^1.3.0:
version "1.4.0"
resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
dependencies:
wrappy "1"
onetime@^2.0.0:
version "2.0.1"
resolved "https://registry.yarnpkg.com/onetime/-/onetime-2.0.1.tgz#067428230fd67443b2794b22bba528b6867962d4"
dependencies:
mimic-fn "^1.0.0"
optionator@^0.8.2:
version "0.8.2"
resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.8.2.tgz#364c5e409d3f4d6301d6c0b4c05bba50180aeb64"
dependencies:
deep-is "~0.1.3"
fast-levenshtein "~2.0.4"
levn "~0.3.0"
prelude-ls "~1.1.2"
type-check "~0.3.2"
wordwrap "~1.0.0"
os-tmpdir@~1.0.2:
version "1.0.2"
resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274"
path-is-absolute@^1.0.0:
version "1.0.1"
resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
path-is-inside@^1.0.1, path-is-inside@^1.0.2:
version "1.0.2"
resolved "https://registry.yarnpkg.com/path-is-inside/-/path-is-inside-1.0.2.tgz#365417dede44430d1c11af61027facf074bdfc53"
path-key@^2.0.1:
version "2.0.1"
resolved "https://registry.yarnpkg.com/path-key/-/path-key-2.0.1.tgz#411cadb574c5a140d3a4b1910d40d80cc9f40b40"
path-parse@^1.0.5:
version "1.0.6"
resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.6.tgz#d62dbb5679405d72c4737ec58600e9ddcf06d24c"
pify@^2.0.0:
version "2.3.0"
resolved "https://registry.yarnpkg.com/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c"
pinkie-promise@^2.0.0:
version "2.0.1"
resolved "https://registry.yarnpkg.com/pinkie-promise/-/pinkie-promise-2.0.1.tgz#2135d6dfa7a358c069ac9b178776288228450ffa"
dependencies:
pinkie "^2.0.0"
pinkie@^2.0.0:
version "2.0.4"
resolved "https://registry.yarnpkg.com/pinkie/-/pinkie-2.0.4.tgz#72556b80cfa0d48a974e80e77248e80ed4f7f870"
pluralize@^7.0.0:
version "7.0.0"
resolved "https://registry.yarnpkg.com/pluralize/-/pluralize-7.0.0.tgz#298b89df8b93b0221dbf421ad2b1b1ea23fc6777"
prelude-ls@~1.1.2:
version "1.1.2"
resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.1.2.tgz#21932a549f5e52ffd9a827f570e04be62a97da54"
progress@^2.0.0:
version "2.0.0"
resolved "https://registry.yarnpkg.com/progress/-/progress-2.0.0.tgz#8a1be366bf8fc23db2bd23f10c6fe920b4389d1f"
punycode@^2.1.0:
version "2.1.1"
resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.1.1.tgz#b58b010ac40c22c5657616c8d2c2c02c7bf479ec"
regexpp@^2.0.0:
version "2.0.0"
resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-2.0.0.tgz#b2a7534a85ca1b033bcf5ce9ff8e56d4e0755365"
require-uncached@^1.0.3:
version "1.0.3"
resolved "https://registry.yarnpkg.com/require-uncached/-/require-uncached-1.0.3.tgz#4e0d56d6c9662fd31e43011c4b95aa49955421d3"
dependencies:
caller-path "^0.1.0"
resolve-from "^1.0.0"
resolve-from@^1.0.0:
version "1.0.1"
resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-1.0.1.tgz#26cbfe935d1aeeeabb29bc3fe5aeb01e93d44226"
resolve@~1.7.1:
version "1.7.1"
resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.7.1.tgz#aadd656374fd298aee895bc026b8297418677fd3"
dependencies:
path-parse "^1.0.5"
restore-cursor@^2.0.0:
version "2.0.0"
resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-2.0.0.tgz#9f7ee287f82fd326d4fd162923d62129eee0dfaf"
dependencies:
onetime "^2.0.0"
signal-exit "^3.0.2"
resumer@~0.0.0:
version "0.0.0"
resolved "https://registry.yarnpkg.com/resumer/-/resumer-0.0.0.tgz#f1e8f461e4064ba39e82af3cdc2a8c893d076759"
dependencies:
through "~2.3.4"
rimraf@^2.2.8:
version "2.6.2"
resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.6.2.tgz#2ed8150d24a16ea8651e6d6ef0f47c4158ce7a36"
dependencies:
glob "^7.0.5"
rollup-plugin-terser@1:
version "1.0.1"
resolved "https://registry.yarnpkg.com/rollup-plugin-terser/-/rollup-plugin-terser-1.0.1.tgz#ba5f497cbc9aa38ba19d3ee2167c04ea3ed279af"
dependencies:
"@babel/code-frame" "^7.0.0-beta.47"
terser "^3.7.5"
rollup@0.64:
version "0.64.1"
resolved "https://registry.yarnpkg.com/rollup/-/rollup-0.64.1.tgz#9188ee368e5fcd43ffbc00ec414e72eeb5de87ba"
dependencies:
"@types/estree" "0.0.39"
"@types/node" "*"
run-async@^2.2.0:
version "2.3.0"
resolved "https://registry.yarnpkg.com/run-async/-/run-async-2.3.0.tgz#0371ab4ae0bdd720d4166d7dfda64ff7a445a6c0"
dependencies:
is-promise "^2.1.0"
rxjs@^5.5.2:
version "5.5.11"
resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-5.5.11.tgz#f733027ca43e3bec6b994473be4ab98ad43ced87"
dependencies:
symbol-observable "1.0.1"
"safer-buffer@>= 2.1.2 < 3":
version "2.1.2"
resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a"
semver@^5.5.0:
version "5.5.1"
resolved "https://registry.yarnpkg.com/semver/-/semver-5.5.1.tgz#7dfdd8814bdb7cabc7be0fb1d734cfb66c940477"
shebang-command@^1.2.0:
version "1.2.0"
resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-1.2.0.tgz#44aac65b695b03398968c39f363fee5deafdf1ea"
dependencies:
shebang-regex "^1.0.0"
shebang-regex@^1.0.0:
version "1.0.0"
resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-1.0.0.tgz#da42f49740c0b42db2ca9728571cb190c98efea3"
signal-exit@^3.0.2:
version "3.0.2"
resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.2.tgz#b5fdc08f1287ea1178628e415e25132b73646c6d"
slice-ansi@1.0.0:
version "1.0.0"
resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-1.0.0.tgz#044f1a49d8842ff307aad6b505ed178bd950134d"
dependencies:
is-fullwidth-code-point "^2.0.0"
source-map-support@~0.5.6:
version "0.5.9"
resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.9.tgz#41bc953b2534267ea2d605bccfa7bfa3111ced5f"
dependencies:
buffer-from "^1.0.0"
source-map "^0.6.0"
source-map@^0.6.0, source-map@~0.6.1:
version "0.6.1"
resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
sprintf-js@~1.0.2:
version "1.0.3"
resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c"
string-width@^2.1.0, string-width@^2.1.1:
version "2.1.1"
resolved "https://registry.yarnpkg.com/string-width/-/string-width-2.1.1.tgz#ab93f27a8dc13d28cac815c462143a6d9012ae9e"
dependencies:
is-fullwidth-code-point "^2.0.0"
strip-ansi "^4.0.0"
string.prototype.trim@~1.1.2:
version "1.1.2"
resolved "https://registry.yarnpkg.com/string.prototype.trim/-/string.prototype.trim-1.1.2.tgz#d04de2c89e137f4d7d206f086b5ed2fae6be8cea"
dependencies:
define-properties "^1.1.2"
es-abstract "^1.5.0"
function-bind "^1.0.2"
strip-ansi@^3.0.0:
version "3.0.1"
resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-3.0.1.tgz#6a385fb8853d952d5ff05d0e8aaf94278dc63dcf"
dependencies:
ansi-regex "^2.0.0"
strip-ansi@^4.0.0:
version "4.0.0"
resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-4.0.0.tgz#a8479022eb1ac368a871389b635262c505ee368f"
dependencies:
ansi-regex "^3.0.0"
strip-json-comments@^2.0.1:
version "2.0.1"
resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz#3c531942e908c2697c0ec344858c286c7ca0a60a"
supports-color@^2.0.0:
version "2.0.0"
resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-2.0.0.tgz#535d045ce6b6363fa40117084629995e9df324c7"
supports-color@^5.3.0:
version "5.5.0"
resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f"
dependencies:
has-flag "^3.0.0"
symbol-observable@1.0.1:
version "1.0.1"
resolved "https://registry.yarnpkg.com/symbol-observable/-/symbol-observable-1.0.1.tgz#8340fc4702c3122df5d22288f88283f513d3fdd4"
table@^4.0.3:
version "4.0.3"
resolved "https://registry.yarnpkg.com/table/-/table-4.0.3.tgz#00b5e2b602f1794b9acaf9ca908a76386a7813bc"
dependencies:
ajv "^6.0.1"
ajv-keywords "^3.0.0"
chalk "^2.1.0"
lodash "^4.17.4"
slice-ansi "1.0.0"
string-width "^2.1.1"
tape@4:
version "4.9.1"
resolved "https://registry.yarnpkg.com/tape/-/tape-4.9.1.tgz#1173d7337e040c76fbf42ec86fcabedc9b3805c9"
dependencies:
deep-equal "~1.0.1"
defined "~1.0.0"
for-each "~0.3.3"
function-bind "~1.1.1"
glob "~7.1.2"
has "~1.0.3"
inherits "~2.0.3"
minimist "~1.2.0"
object-inspect "~1.6.0"
resolve "~1.7.1"
resumer "~0.0.0"
string.prototype.trim "~1.1.2"
through "~2.3.8"
terser@^3.7.5:
version "3.8.1"
resolved "https://registry.yarnpkg.com/terser/-/terser-3.8.1.tgz#cb70070ac9e0a71add169dfb63c0a64fca2738ac"
dependencies:
commander "~2.16.0"
source-map "~0.6.1"
source-map-support "~0.5.6"
text-table@^0.2.0:
version "0.2.0"
resolved "https://registry.yarnpkg.com/text-table/-/text-table-0.2.0.tgz#7f5ee823ae805207c00af2df4a84ec3fcfa570b4"
through@^2.3.6, through@~2.3.4, through@~2.3.8:
version "2.3.8"
resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5"
tmp@^0.0.33:
version "0.0.33"
resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.0.33.tgz#6d34335889768d21b2bcda0aa277ced3b1bfadf9"
dependencies:
os-tmpdir "~1.0.2"
type-check@~0.3.2:
version "0.3.2"
resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.3.2.tgz#5884cab512cf1d355e3fb784f30804b2b520db72"
dependencies:
prelude-ls "~1.1.2"
uri-js@^4.2.2:
version "4.2.2"
resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.2.2.tgz#94c540e1ff772956e2299507c010aea6c8838eb0"
dependencies:
punycode "^2.1.0"
which@^1.2.9:
version "1.3.1"
resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"
dependencies:
isexe "^2.0.0"
wordwrap@~1.0.0:
version "1.0.0"
resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-1.0.0.tgz#27584810891456a4171c8d0226441ade90cbcaeb"
wrappy@1:
version "1.0.2"
resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
write@^0.2.1:
version "0.2.1"
resolved "https://registry.yarnpkg.com/write/-/write-0.2.1.tgz#5fc03828e264cea3fe91455476f7a3c566cb0757"
dependencies:
mkdirp "^0.5.1"