wdjones/eufy-security-client-dz
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Init

Browse Source
This commit is contained in:
William D. Jones
2025-11-11 00:04:55 -06:00
parent a76ad41fde
commit 40538eddfd
6405 changed files with 1289756 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
node_modules/cron-parser/.eslintrc.json generated vendored Normal file
View File

@ -0,0 +1,15 @@
{
"rules": {
"eol-last": ["error", "always"],
"quotes": ["error", "single"],
"semi": ["error", "always"]
},
"overrides": [
{
"files": ["test/**.js"],
"parserOptions": {
"ecmaVersion": 6
}
}
]
}

10
node_modules/cron-parser/.travis.yml generated vendored Normal file
View File

@ -0,0 +1,10 @@
language: node_js
dist: focal
node_js:
- '12'
- '14'
- '15'
- '16'
- '17'
- '18'
- '19'

21
node_modules/cron-parser/LICENSE generated vendored Normal file
View File

@ -0,0 +1,21 @@
The MIT License (MIT)
Copyright (c) 2014-2016 Harri Siirak
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

175
node_modules/cron-parser/README.md generated vendored Normal file
View File

@ -0,0 +1,175 @@
cron-parser
================
[![Build Status](https://travis-ci.com/harrisiirak/cron-parser.svg?branch=master)](https://travis-ci.com/harrisiirak/cron-parser)
[![NPM version](https://badge.fury.io/js/cron-parser.png)](http://badge.fury.io/js/cron-parser)
Node.js library for parsing and manipulating crontab instructions. It includes support for timezones and DST transitions.
__Compatibility__
Node >= 12.0.0
TypeScript >= 4.2
Setup
========
```bash
npm install cron-parser
```
Supported format
========
```
* * * * * *
┬ ┬ ┬ ┬ ┬ ┬
│ │ │ │ │ |
│ │ │ │ │ └ day of week (0 - 7, 1L - 7L) (0 or 7 is Sun)
│ │ │ │ └───── month (1 - 12)
│ │ │ └────────── day of month (1 - 31, L)
│ │ └─────────────── hour (0 - 23)
│ └──────────────────── minute (0 - 59)
└───────────────────────── second (0 - 59, optional)
```
Supports mixed use of ranges and range increments (W character not supported currently). See tests for examples.
Usage
========
Simple expression.
```javascript
var parser = require('cron-parser');
try {
var interval = parser.parseExpression('*/2 * * * *');
console.log('Date: ', interval.next().toString()); // Sat Dec 29 2012 00:42:00 GMT+0200 (EET)
console.log('Date: ', interval.next().toString()); // Sat Dec 29 2012 00:44:00 GMT+0200 (EET)
console.log('Date: ', interval.prev().toString()); // Sat Dec 29 2012 00:42:00 GMT+0200 (EET)
console.log('Date: ', interval.prev().toString()); // Sat Dec 29 2012 00:40:00 GMT+0200 (EET)
} catch (err) {
console.log('Error: ' + err.message);
}
```
Iteration with limited timespan. Also returns ES6 compatible iterator (when iterator flag is set to true).
```javascript
var parser = require('cron-parser');
var options = {
currentDate: new Date('Wed, 26 Dec 2012 12:38:53 UTC'),
endDate: new Date('Wed, 26 Dec 2012 14:40:00 UTC'),
iterator: true
};
try {
var interval = parser.parseExpression('*/22 * * * *', options);
while (true) {
try {
var obj = interval.next();
console.log('value:', obj.value.toString(), 'done:', obj.done);
} catch (e) {
break;
}
}
// value: Wed Dec 26 2012 14:44:00 GMT+0200 (EET) done: false
// value: Wed Dec 26 2012 15:00:00 GMT+0200 (EET) done: false
// value: Wed Dec 26 2012 15:22:00 GMT+0200 (EET) done: false
// value: Wed Dec 26 2012 15:44:00 GMT+0200 (EET) done: false
// value: Wed Dec 26 2012 16:00:00 GMT+0200 (EET) done: false
// value: Wed Dec 26 2012 16:22:00 GMT+0200 (EET) done: true
} catch (err) {
console.log('Error: ' + err.message);
}
```
Timezone support
```javascript
var parser = require('cron-parser');
var options = {
currentDate: '2016-03-27 00:00:01',
tz: 'Europe/Athens'
};
try {
var interval = parser.parseExpression('0 * * * *', options);
console.log('Date: ', interval.next().toString()); // Date: Sun Mar 27 2016 01:00:00 GMT+0200
console.log('Date: ', interval.next().toString()); // Date: Sun Mar 27 2016 02:00:00 GMT+0200
console.log('Date: ', interval.next().toString()); // Date: Sun Mar 27 2016 04:00:00 GMT+0300 (Notice DST transition)
} catch (err) {
console.log('Error: ' + err.message);
}
```
Manipulation
```javascript
var parser = require('cron-parser');
var interval = parser.parseExpression('0 7 * * 0-4');
var fields = JSON.parse(JSON.stringify(interval.fields)); // Fields is immutable
fields.hour = [8];
fields.minute = [29];
fields.dayOfWeek = [1,3,4,5,6,7];
var modifiedInterval = parser.fieldsToExpression(fields);
var cronString = modifiedInterval.stringify();
console.log(cronString); // "29 8 * * 1,3-7"
```
Options
========
* *currentDate* - Start date of the iteration
* *endDate* - End date of the iteration
`currentDate` and `endDate` accept `string`, `integer` and `Date` as input.
In case of using `string` as input, not every string format accepted
by the `Date` constructor will work correctly.
The supported formats are:
- [`ISO8601`](https://moment.github.io/luxon/#/parsing?id=iso-8601)
- [`HTTP and RFC2822`](https://moment.github.io/luxon/#/parsing?id=http-and-rfc2822)
- [`SQL`](https://moment.github.io/luxon/#/parsing?id=sql)
The reason being that those are the formats accepted by the
[`luxon`](https://moment.github.io/luxon/) library which is being used to handle dates.
Using `Date` as an input can be problematic specially when using the `tz` option. The issue being that, when creating a new `Date` object without
any timezone information, it will be created in the timezone of the system that is running the code. This (most of times) won't be what the user
will be expecting. Using one of the supported `string` formats will solve the issue(see timezone example).
* *iterator* - Return ES6 compatible iterator object
* *utc* - Enable UTC
* *tz* - Timezone string. It won't be used in case `utc` is enabled
Last weekday of the month
=========================
This library supports parsing the range `0L - 7L` in the `weekday` position of
the cron expression, where the `L` means "last occurrence of this weekday for
the month in progress".
For example, the following expression will run on the last monday of the month
at midnight:
```
0 0 * * * 1L
```
The library also supports combining `L` expressions with other weekday
expressions. For example, the following cron will run every Monday as well
as the last Wednesday of the month:
```
0 0 * * * 1,3L
```

21
node_modules/cron-parser/component.json generated vendored Normal file
View File

@ -0,0 +1,21 @@
{
"name": "cron-parser",
"repo": "harrisiirak/cron-parser",
"description": "Node.js library for parsing crontab instructions",
"version": "4.7.1",
"keywords": [
"cron",
"crontab",
"parser"
],
"dependencies": {},
"development": {},
"main": "lib/parser.js",
"scripts": [
"lib/parser.js",
"lib/expression.js",
"lib/date.js",
"lib/field_compactor.js",
"lib/field_stringify.js"
]
}

1
node_modules/cron-parser/index.d.ts generated vendored Normal file
View File

@ -0,0 +1 @@
export * from './types'

252
node_modules/cron-parser/lib/date.js generated vendored Normal file
View File

@ -0,0 +1,252 @@
'use strict';
var luxon = require('luxon');
CronDate.prototype.addYear = function() {
this._date = this._date.plus({ years: 1 });
};
CronDate.prototype.addMonth = function() {
this._date = this._date.plus({ months: 1 }).startOf('month');
};
CronDate.prototype.addDay = function() {
this._date = this._date.plus({ days: 1 }).startOf('day');
};
CronDate.prototype.addHour = function() {
var prev = this._date;
this._date = this._date.plus({ hours: 1 }).startOf('hour');
if (this._date <= prev) {
this._date = this._date.plus({ hours: 1 });
}
};
CronDate.prototype.addMinute = function() {
var prev = this._date;
this._date = this._date.plus({ minutes: 1 }).startOf('minute');
if (this._date < prev) {
this._date = this._date.plus({ hours: 1 });
}
};
CronDate.prototype.addSecond = function() {
var prev = this._date;
this._date = this._date.plus({ seconds: 1 }).startOf('second');
if (this._date < prev) {
this._date = this._date.plus({ hours: 1 });
}
};
CronDate.prototype.subtractYear = function() {
this._date = this._date.minus({ years: 1 });
};
CronDate.prototype.subtractMonth = function() {
this._date = this._date
.minus({ months: 1 })
.endOf('month')
.startOf('second');
};
CronDate.prototype.subtractDay = function() {
this._date = this._date
.minus({ days: 1 })
.endOf('day')
.startOf('second');
};
CronDate.prototype.subtractHour = function() {
var prev = this._date;
this._date = this._date
.minus({ hours: 1 })
.endOf('hour')
.startOf('second');
if (this._date >= prev) {
this._date = this._date.minus({ hours: 1 });
}
};
CronDate.prototype.subtractMinute = function() {
var prev = this._date;
this._date = this._date.minus({ minutes: 1 })
.endOf('minute')
.startOf('second');
if (this._date > prev) {
this._date = this._date.minus({ hours: 1 });
}
};
CronDate.prototype.subtractSecond = function() {
var prev = this._date;
this._date = this._date
.minus({ seconds: 1 })
.startOf('second');
if (this._date > prev) {
this._date = this._date.minus({ hours: 1 });
}
};
CronDate.prototype.getDate = function() {
return this._date.day;
};
CronDate.prototype.getFullYear = function() {
return this._date.year;
};
CronDate.prototype.getDay = function() {
var weekday = this._date.weekday;
return weekday == 7 ? 0 : weekday;
};
CronDate.prototype.getMonth = function() {
return this._date.month - 1;
};
CronDate.prototype.getHours = function() {
return this._date.hour;
};
CronDate.prototype.getMinutes = function() {
return this._date.minute;
};
CronDate.prototype.getSeconds = function() {
return this._date.second;
};
CronDate.prototype.getMilliseconds = function() {
return this._date.millisecond;
};
CronDate.prototype.getTime = function() {
return this._date.valueOf();
};
CronDate.prototype.getUTCDate = function() {
return this._getUTC().day;
};
CronDate.prototype.getUTCFullYear = function() {
return this._getUTC().year;
};
CronDate.prototype.getUTCDay = function() {
var weekday = this._getUTC().weekday;
return weekday == 7 ? 0 : weekday;
};
CronDate.prototype.getUTCMonth = function() {
return this._getUTC().month - 1;
};
CronDate.prototype.getUTCHours = function() {
return this._getUTC().hour;
};
CronDate.prototype.getUTCMinutes = function() {
return this._getUTC().minute;
};
CronDate.prototype.getUTCSeconds = function() {
return this._getUTC().second;
};
CronDate.prototype.toISOString = function() {
return this._date.toUTC().toISO();
};
CronDate.prototype.toJSON = function() {
return this._date.toJSON();
};
CronDate.prototype.setDate = function(d) {
this._date = this._date.set({ day: d });
};
CronDate.prototype.setFullYear = function(y) {
this._date = this._date.set({ year: y });
};
CronDate.prototype.setDay = function(d) {
this._date = this._date.set({ weekday: d });
};
CronDate.prototype.setMonth = function(m) {
this._date = this._date.set({ month: m + 1 });
};
CronDate.prototype.setHours = function(h) {
this._date = this._date.set({ hour: h });
};
CronDate.prototype.setMinutes = function(m) {
this._date = this._date.set({ minute: m });
};
CronDate.prototype.setSeconds = function(s) {
this._date = this._date.set({ second: s });
};
CronDate.prototype.setMilliseconds = function(s) {
this._date = this._date.set({ millisecond: s });
};
CronDate.prototype._getUTC = function() {
return this._date.toUTC();
};
CronDate.prototype.toString = function() {
return this.toDate().toString();
};
CronDate.prototype.toDate = function() {
return this._date.toJSDate();
};
CronDate.prototype.isLastDayOfMonth = function() {
//next day
var newDate = this._date.plus({ days: 1 }).startOf('day');
return this._date.month !== newDate.month;
};
/**
* Returns true when the current weekday is the last occurrence of this weekday
* for the present month.
*/
CronDate.prototype.isLastWeekdayOfMonth = function() {
// Check this by adding 7 days to the current date and seeing if it's
// a different month
var newDate = this._date.plus({ days: 7 }).startOf('day');
return this._date.month !== newDate.month;
};
function CronDate (timestamp, tz) {
var dateOpts = { zone: tz };
if (!timestamp) {
this._date = luxon.DateTime.local();
} else if (timestamp instanceof CronDate) {
this._date = timestamp._date;
} else if (timestamp instanceof Date) {
this._date = luxon.DateTime.fromJSDate(timestamp, dateOpts);
} else if (typeof timestamp === 'number') {
this._date = luxon.DateTime.fromMillis(timestamp, dateOpts);
} else if (typeof timestamp === 'string') {
this._date = luxon.DateTime.fromISO(timestamp, dateOpts);
this._date.isValid || (this._date = luxon.DateTime.fromRFC2822(timestamp, dateOpts));
this._date.isValid || (this._date = luxon.DateTime.fromSQL(timestamp, dateOpts));
// RFC2822-like format without the required timezone offset (used in tests)
this._date.isValid || (this._date = luxon.DateTime.fromFormat(timestamp, 'EEE, d MMM yyyy HH:mm:ss', dateOpts));
}
if (!this._date || !this._date.isValid) {
throw new Error('CronDate: unhandled timestamp: ' + JSON.stringify(timestamp));
}
if (tz && tz !== this._date.zoneName) {
this._date = this._date.setZone(tz);
}
}
module.exports = CronDate;

1002
node_modules/cron-parser/lib/expression.js generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

70
node_modules/cron-parser/lib/field_compactor.js generated vendored Normal file
View File

@ -0,0 +1,70 @@
'use strict';
function buildRange(item) {
return {
start: item,
count: 1
};
}
function completeRangeWithItem(range, item) {
range.end = item;
range.step = item - range.start;
range.count = 2;
}
function finalizeCurrentRange(results, currentRange, currentItemRange) {
if (currentRange) {
// Two elements do not form a range so split them into 2 single elements
if (currentRange.count === 2) {
results.push(buildRange(currentRange.start));
results.push(buildRange(currentRange.end));
} else {
results.push(currentRange);
}
}
if (currentItemRange) {
results.push(currentItemRange);
}
}
function compactField(arr) {
var results = [];
var currentRange = undefined;
for (var i = 0; i < arr.length; i++) {
var currentItem = arr[i];
if (typeof currentItem !== 'number') {
// String elements can't form a range
finalizeCurrentRange(results, currentRange, buildRange(currentItem));
currentRange = undefined;
} else if (!currentRange) {
// Start a new range
currentRange = buildRange(currentItem);
} else if (currentRange.count === 1) {
// Guess that the current item starts a range
completeRangeWithItem(currentRange, currentItem);
} else {
if (currentRange.step === currentItem - currentRange.end) {
// We found another item that matches the current range
currentRange.count++;
currentRange.end = currentItem;
} else if (currentRange.count === 2) { // The current range can't be continued
// Break the first item of the current range into a single element, and try to start a new range with the second item
results.push(buildRange(currentRange.start));
currentRange = buildRange(currentRange.end);
completeRangeWithItem(currentRange, currentItem);
} else {
// Persist the current range and start a new one with current item
finalizeCurrentRange(results, currentRange);
currentRange = buildRange(currentItem);
}
}
}
finalizeCurrentRange(results, currentRange);
return results;
}
module.exports = compactField;

38
node_modules/cron-parser/lib/field_stringify.js generated vendored Normal file
View File

@ -0,0 +1,38 @@
'use strict';
var compactField = require('./field_compactor');
function stringifyField(arr, min, max) {
var ranges = compactField(arr);
if (ranges.length === 1) {
var singleRange = ranges[0];
var step = singleRange.step;
if (step === 1 && singleRange.start === min && singleRange.end === max) {
return '*';
}
if (step !== 1 && singleRange.start === min && singleRange.end === max - step + 1) {
return '*/' + step;
}
}
var resultArr = [];
for (var i = 0, l = ranges.length; i < l; ++i) {
var range = ranges[i];
if (range.count === 1) {
resultArr.push(range.start);
} else {
var step = range.step;
if (step === 1) {
resultArr.push(range.start + '-' + range.end);
} else {
if (range.end === max - step + 1) {
resultArr.push(range.start + '/' + step);
} else {
resultArr.push(range.start + '-' + range.end + '/' + step);
}
}
}
}
return resultArr.join(',');
}
module.exports = stringifyField;

116
node_modules/cron-parser/lib/parser.js generated vendored Normal file
View File

@ -0,0 +1,116 @@
'use strict';
var CronExpression = require('./expression');
function CronParser() {}
/**
* Parse crontab entry
*
* @private
* @param {String} entry Crontab file entry/line
*/
CronParser._parseEntry = function _parseEntry (entry) {
var atoms = entry.split(' ');
if (atoms.length === 6) {
return {
interval: CronExpression.parse(entry)
};
} else if (atoms.length > 6) {
return {
interval: CronExpression.parse(
atoms.slice(0, 6).join(' ')
),
command: atoms.slice(6, atoms.length)
};
} else {
throw new Error('Invalid entry: ' + entry);
}
};
/**
* Wrapper for CronExpression.parser method
*
* @public
* @param {String} expression Input expression
* @param {Object} [options] Parsing options
* @return {Object}
*/
CronParser.parseExpression = function parseExpression (expression, options) {
return CronExpression.parse(expression, options);
};
/**
* Wrapper for CronExpression.fieldsToExpression method
*
* @public
* @param {Object} fields Input fields
* @param {Object} [options] Parsing options
* @return {Object}
*/
CronParser.fieldsToExpression = function fieldsToExpression (fields, options) {
return CronExpression.fieldsToExpression(fields, options);
};
/**
* Parse content string
*
* @public
* @param {String} data Crontab content
* @return {Object}
*/
CronParser.parseString = function parseString (data) {
var blocks = data.split('\n');
var response = {
variables: {},
expressions: [],
errors: {}
};
for (var i = 0, c = blocks.length; i < c; i++) {
var block = blocks[i];
var matches = null;
var entry = block.trim(); // Remove surrounding spaces
if (entry.length > 0) {
if (entry.match(/^#/)) { // Comment
continue;
} else if ((matches = entry.match(/^(.*)=(.*)$/))) { // Variable
response.variables[matches[1]] = matches[2];
} else { // Expression?
var result = null;
try {
result = CronParser._parseEntry('0 ' + entry);
response.expressions.push(result.interval);
} catch (err) {
response.errors[entry] = err;
}
}
}
}
return response;
};
/**
* Parse crontab file
*
* @public
* @param {String} filePath Path to file
* @param {Function} callback
*/
CronParser.parseFile = function parseFile (filePath, callback) {
require('fs').readFile(filePath, function(err, data) {
if (err) {
callback(err);
return;
}
return callback(null, CronParser.parseString(data.toString()));
});
};
module.exports = CronParser;

85
node_modules/cron-parser/package.json generated vendored Normal file
View File

@ -0,0 +1,85 @@
{
"name": "cron-parser",
"version": "4.7.1",
"description": "Node.js library for parsing crontab instructions",
"main": "lib/parser.js",
"types": "index.d.ts",
"typesVersions": {
"<4.1": {
"*": [
"types/ts3/*"
]
}
},
"directories": {
"test": "test"
},
"scripts": {
"test:tsd": "tsd",
"test:unit": "TZ=UTC tap ./test/*.js",
"test:cover": "TZ=UTC tap --coverage-report=html ./test/*.js",
"lint": "eslint .",
"lint:fix": "eslint --fix .",
"test": "npm run lint && npm run test:unit && npm run test:tsd"
},
"repository": {
"type": "git",
"url": "https://github.com/harrisiirak/cron-parser.git"
},
"keywords": [
"cron",
"crontab",
"parser"
],
"author": "Harri Siirak",
"contributors": [
"Nicholas Clawson",
"Daniel Prentis <daniel@salsitasoft.com>",
"Renault John Lecoultre",
"Richard Astbury <richard.astbury@gmail.com>",
"Meaglin Wasabi <Meaglin.wasabi@gmail.com>",
"Mike Kusold <hello@mikekusold.com>",
"Alex Kit <alex.kit@atmajs.com>",
"Santiago Gimeno <santiago.gimeno@gmail.com>",
"Daniel <darc.tec@gmail.com>",
"Christian Steininger <christian.steininger.cs@gmail.com>",
"Mykola Piskovyi <m.piskovyi@gmail.com>",
"Brian Vaughn <brian.david.vaughn@gmail.com>",
"Nicholas Clawson <nickclaw@gmail.com>",
"Yasuhiroki <yasuhiroki.duck@gmail.com>",
"Nicholas Clawson <nickclaw@gmail.com>",
"Brendan Warkentin <faazshift@gmail.com>",
"Charlie Fish <fishcharlie.code@gmail.com>",
"Ian Graves <ian+diskimage@iangrav.es>",
"Andy Thompson <me@andytson.com>",
"Regev Brody <regevbr@gmail.com>"
],
"license": "MIT",
"dependencies": {
"luxon": "^3.2.1"
},
"devDependencies": {
"eslint": "^8.27.0",
"sinon": "^14.0.2",
"tap": "^16.3.3",
"tsd": "^0.24.1"
},
"engines": {
"node": ">=12.0.0"
},
"browser": {
"fs": false
},
"tap": {
"check-coverage": false
},
"tsd": {
"directory": "test",
"compilerOptions": {
"lib": [
"es2017",
"dom"
]
}
}
}

17
node_modules/cron-parser/test/31_of_month.js generated vendored Normal file
View File

@ -0,0 +1,17 @@
var util = require('util');
var test = require('tap').test;
var expression = require('../lib/expression');
test('expression 31 of month', function(t) {
try {
var interval = expression.parse('0 0 31 * *');
var i;
var d;
for (i = 0; i < 20; ++i) {
d = interval.next();
}
t.end();
} catch (err) {
t.error(err, 'Interval parse error');
}
});

29
node_modules/cron-parser/test/bug.js generated vendored Normal file
View File

@ -0,0 +1,29 @@
var util = require('util');
var test = require('tap').test;
var CronExpression = require('../lib/expression');
var CronDate = require('../lib/date');
test('parse expression as UTC', function(t) {
try {
var options = {
utc: true
};
var interval = CronExpression.parse('0 0 10 * * *', options);
var date = interval.next();
t.equal(date.getUTCHours(), 10, 'Correct UTC hour value');
interval = CronExpression.parse('0 */5 * * * *', options);
var date = interval.next(), now = new Date();
now.setMinutes(now.getMinutes() + 5 - (now.getMinutes() % 5));
t.equal(date.getHours(), now.getUTCHours(), 'Correct local time for 5 minute interval');
} catch (err) {
t.error(err, 'UTC parse error');
}
t.end();
});

16
node_modules/cron-parser/test/crondate.js generated vendored Normal file
View File

@ -0,0 +1,16 @@
// empty around comma
var test = require('tap').test;
var CronDate = require('../lib/date');
test('is the last weekday of the month', function (t) {
// Last monday of septhember
var date = new CronDate(new Date(2021, 8, 27));
t.equal(date.isLastWeekdayOfMonth(), true);
// Second-to-last monday of septhember
var date = new CronDate(new Date(2021, 8, 20));
t.equal(date.isLastWeekdayOfMonth(), false);
t.end();
});

7
node_modules/cron-parser/test/crontab.example generated vendored Normal file
View File

@ -0,0 +1,7 @@
# Comment line (ignore)
ENV1="test1"
ENV2="test2"
*/10 * * * * /path/to/exe
*/10 * * * * /path/to/exe
0 09-18 * * 1-5 /path/to/exe

22
node_modules/cron-parser/test/empty_around_comma.js generated vendored Normal file
View File

@ -0,0 +1,22 @@
// empty around comma
var test = require('tap').test;
var CronExpression = require('../lib/expression');
const options = {
utc: true
};
test('both empty around comma', function (t) {
t.throws(function () {
CronExpression.parse('*/10 * * * * ,', options);
}, new Error('Invalid list value format'));
t.end();
});
test('one side empty around comma', function (t) {
t.throws(function () {
CronExpression.parse('*/10 * * * * ,2', options);
}, new Error('Invalid list value format'));
t.end();
});

1514
node_modules/cron-parser/test/expression.js generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

250
node_modules/cron-parser/test/field_compactor.js generated vendored Normal file
View File

@ -0,0 +1,250 @@
'use strict';
var test = require('tap').test;
var compactField = require('../lib/field_compactor');
test('compact field - empty array', function(t) {
try {
var result = compactField([]);
t.same(result, []);
} catch (err) {
t.error(err, 'compact field error');
}
t.end();
});
test('compact field - single element array', function(t) {
try {
var result = compactField([1]);
t.same(result, [{
start: 1,
count: 1
}]);
} catch (err) {
t.error(err, 'compact field error');
}
t.end();
});
test('compact field - 2 elements array', function(t) {
try {
var result = compactField([1, 2]);
t.same(result, [
{
start: 1,
count: 1
},
{
start: 2,
count: 1
}
]);
} catch (err) {
t.error(err, 'compact field error');
}
t.end();
});
test('compact field - 2 elements array big step', function(t) {
try {
var result = compactField([1, 5]);
t.same(result, [
{
start: 1,
count: 1
},
{
start: 5,
count: 1
}
]);
} catch (err) {
t.error(err, 'compact field error');
}
t.end();
});
test('compact field - 3 elements array 1 step', function(t) {
try {
var result = compactField([1, 2, 3]);
t.same(result, [
{
start: 1,
end: 3,
count: 3,
step: 1
}
]);
} catch (err) {
t.error(err, 'compact field error');
}
t.end();
});
test('compact field - 3 elements array 1 step, dangling extra at end', function(t) {
try {
var result = compactField([1, 2, 3, 5]);
t.same(result, [
{
start: 1,
end: 3,
count: 3,
step: 1
},
{
start: 5,
count: 1
}
]);
} catch (err) {
t.error(err, 'compact field error');
}
t.end();
});
test('compact field - 3 elements array 1 step, dangling extra at end and beginning', function(t) {
try {
var result = compactField([1, 4, 5, 6, 9]);
t.same(result, [
{
start: 1,
count: 1
},
{
start: 4,
end: 6,
count: 3,
step: 1
},
{
start: 9,
count: 1
}
]);
} catch (err) {
t.error(err, 'compact field error');
}
t.end();
});
test('compact field - 2 ranges with dangling in the middle', function(t) {
try {
var result = compactField([1, 2, 3, 6, 9, 11, 13]);
t.same(result, [
{
start: 1,
end: 3,
count: 3,
step: 1
},
{
start: 6,
count: 1
},
{
start: 9,
end: 13,
count: 3,
step: 2
}
]);
} catch (err) {
t.error(err, 'compact field error');
}
t.end();
});
test('compact field - with chars', function(t) {
try {
var result = compactField(['L', 'W']);
t.same(result, [
{
start: 'L',
count: 1
},
{
start: 'W',
count: 1
}
]);
} catch (err) {
t.error(err, 'compact field error');
}
t.end();
});
test('compact field - with chars and range', function(t) {
try {
var result = compactField([1, 'L', 'W']);
t.same(result, [
{
start: 1,
count: 1,
},
{
start: 'L',
count: 1
},
{
start: 'W',
count: 1
}
]);
} catch (err) {
t.error(err, 'compact field error');
}
t.end();
});
test('compact field - with chars and range (v2)', function(t) {
try {
var result = compactField([1, 2, 'L', 'W']);
t.same(result, [
{
start: 1,
count: 1,
},
{
start: 2,
count: 1,
},
{
start: 'L',
count: 1
},
{
start: 'W',
count: 1
}
]);
} catch (err) {
t.error(err, 'compact field error');
}
t.end();
});
test('compact field - with chars and range (v3)', function(t) {
try {
var result = compactField([1, 2, 3, 'L', 'W']);
t.same(result, [
{
start: 1,
end: 3,
count: 3,
step: 1
},
{
start: 'L',
count: 1
},
{
start: 'W',
count: 1
}
]);
} catch (err) {
t.error(err, 'compact field error');
}
t.end();
});

84
node_modules/cron-parser/test/field_stringify.js generated vendored Normal file
View File

@ -0,0 +1,84 @@
'use strict';
var test = require('tap').test;
var stringifyField = require('../lib/field_stringify');
test('stringify astrix', function (t) {
try {
var str = stringifyField([1, 2, 3, 4], 1, 4);
t.equal(str, '*');
} catch (err) {
t.error(err, 'stringify field error');
}
t.end();
});
test('stringify astrix step', function (t) {
try {
var str = stringifyField([0, 2, 4, 6], 0, 7);
t.equal(str, '*/2');
} catch (err) {
t.error(err, 'stringify field error');
}
t.end();
});
test('stringify single value', function (t) {
try {
var str = stringifyField([2], 0, 7);
t.equal(str, '2');
} catch (err) {
t.error(err, 'stringify field error');
}
t.end();
});
test('stringify multiple single values', function (t) {
try {
var str = stringifyField([2, 5, 9], 0, 7);
t.equal(str, '2,5,9');
} catch (err) {
t.error(err, 'stringify field error');
}
t.end();
});
test('stringify range', function (t) {
try {
var str = stringifyField([2, 3, 4], 0, 7);
t.equal(str, '2-4');
} catch (err) {
t.error(err, 'stringify field error');
}
t.end();
});
test('stringify range step', function (t) {
try {
var str = stringifyField([2, 4, 6], 0, 8);
t.equal(str, '2-6/2');
} catch (err) {
t.error(err, 'stringify field error');
}
t.end();
});
test('stringify semi range step', function (t) {
try {
var str = stringifyField([4, 6, 8], 0, 9);
t.equal(str, '4/2');
} catch (err) {
t.error(err, 'stringify field error');
}
t.end();
});
test('stringify multi types', function (t) {
try {
var str = stringifyField([1, 2, 4, 5, 6, 7, 8, 9, 10, 20, 25, 30, 35, 57], 0, 59);
t.equal(str, '1,2,4-10,20-35/5,57');
} catch (err) {
t.error(err, 'stringify field error');
}
t.end();
});

32
node_modules/cron-parser/test/fields.js generated vendored Normal file
View File

@ -0,0 +1,32 @@
var test = require('tap').test;
var CronExpression = require('../lib/expression');
test('Fields are exposed', function(t){
try {
var interval = CronExpression.parse('0 1 2 3 * 1-3,5');
t.ok(interval, 'Interval parsed');
CronExpression.map.forEach(function(field) {
interval.fields[field] = [];
t.throws(function() {
interval.fields[field].push(-1);
}, /Cannot add property .*?, object is not extensible/, field + ' is frozen');
delete interval.fields[field];
});
interval.fields.dummy = [];
t.same(interval.fields.dummy, undefined, 'Fields is frozen');
t.same(interval.fields.second, [0], 'Second matches');
t.same(interval.fields.minute, [1], 'Minute matches');
t.same(interval.fields.hour, [2], 'Hour matches');
t.same(interval.fields.dayOfMonth, [3], 'Day of month matches');
t.same(interval.fields.month, [1,2,3,4,5,6,7,8,9,10,11,12], 'Month matches');
t.same(interval.fields.dayOfWeek, [1,2,3,5], 'Day of week matches');
} catch (err) {
t.error(err, 'Interval parse error');
}
t.end();
});

22
node_modules/cron-parser/test/increment_on_first_iteration.js generated vendored Normal file
View File

@ -0,0 +1,22 @@
var util = require('util');
var sinon = require('sinon');
var test = require('tap').test;
var CronExpression = require('../lib/expression');
test('increment_on_first_itereation', function(t) {
try {
var clock = sinon.useFakeTimers();
var fake_now = new Date('Tue Feb 21 2017 16:45:00');
clock.tick(fake_now.getTime());
var interval = CronExpression.parse('* * * * *');
t.ok(interval, 'Interval parsed');
var next = interval.next();
t.ok(next, 'Found next scheduled interval');
// Make sure next has incremented in 1 minute
t.equal(fake_now.getTime() + 60000, next.getTime());
clock.restore();
t.end();
} catch (err) {
t.error(err, 'Interval parse error');
}
});

133
node_modules/cron-parser/test/index-ts3.test-d.ts generated vendored Normal file
View File

@ -0,0 +1,133 @@
import {expectAssignable, expectError, expectNotAssignable, expectType} from 'tsd';
import {
CronDate,
CronExpression,
CronFields, DateType,
parseExpression,
parseFile, ParserOptions,
parseString,
fieldsToExpression,
StringResult
} from '../types/ts3';
const interval = parseExpression('0 1 2 3 * 1-3,5');
const intervalIterator = parseExpression('0 1 2 3 * 1-3,5', {iterator: true});
expectType<readonly number[]>(interval.fields.second);
expectType<readonly number[]>(interval.fields.minute);
expectType<readonly number[]>(interval.fields.hour);
expectType<readonly (number | 'L')[]>(interval.fields.dayOfMonth);
expectType<readonly number[]>(interval.fields.month);
expectType<readonly number[]>(interval.fields.dayOfWeek);
expectError(interval.fields = interval.fields);
expectError(interval.fields.second = []);
expectError(interval.fields.second.push(1));
expectError(interval.fields.minute = []);
expectError(interval.fields.minute.push(1));
expectError(interval.fields.hour = []);
expectError(interval.fields.hour.push(1));
expectError(interval.fields.dayOfMonth = []);
expectError(interval.fields.dayOfMonth.push(1));
expectError(interval.fields.month = []);
expectError(interval.fields.month.push(1));
expectError(interval.fields.dayOfWeek = []);
expectError(interval.fields.dayOfWeek.push(1));
expectAssignable<typeof interval.fields.second[0]>(0);
expectAssignable<typeof interval.fields.second[0]>(59);
expectAssignable<typeof interval.fields.minute[0]>(0);
expectAssignable<typeof interval.fields.minute[0]>(59);
expectAssignable<typeof interval.fields.hour[0]>(0);
expectAssignable<typeof interval.fields.hour[0]>(23);
expectAssignable<typeof interval.fields.dayOfMonth[0]>(1);
expectAssignable<typeof interval.fields.dayOfMonth[0]>(31);
expectAssignable<typeof interval.fields.dayOfMonth[0]>('L');
expectAssignable<typeof interval.fields.month[0]>(1);
expectAssignable<typeof interval.fields.month[0]>(12);
expectAssignable<typeof interval.fields.dayOfWeek[0]>(0);
expectAssignable<typeof interval.fields.dayOfWeek[0]>(7);
const parseOptions: ParserOptions<true> = {
currentDate: 'f',
startDate: 4,
endDate: new Date(),
iterator: true,
utc: true,
tz: 'f',
nthDayOfWeek: 5,
}
expectAssignable<{
currentDate?: string | number | Date
startDate?: string | number | Date
endDate?: string | number | Date
iterator?: boolean
utc?: boolean
tz?: string
nthDayOfWeek?: number
}>(parseOptions)
expectType<CronExpression>(parseExpression('0 1 2 3 * 1-3,5'))
expectType<CronExpression<true>>(parseExpression('0 1 2 3 * 1-3,5', parseOptions))
const fields: CronFields = {
second: [1, 1],
minute: [1],
hour: [1],
dayOfMonth: [1],
month: [1],
dayOfWeek: [1],
}
expectType<CronExpression>(fieldsToExpression(fields))
expectType<CronExpression<true>>(fieldsToExpression(fields, parseOptions))
expectType<string>(fieldsToExpression(fields).stringify())
expectType<string>(fieldsToExpression(fields, parseOptions).stringify())
expectType<string>(fieldsToExpression(fields, parseOptions).stringify(true))
expectType<void>(parseFile('path', (err: any, data: StringResult) => console.log(data)))
expectType<StringResult>(parseString('path'))
const stringResult = parseString('path');
expectType<{
variables: Record<string, string>,
expressions: CronExpression[],
errors: Record<string, any>,
}>(stringResult)
expectType<CronFields>(interval.fields)
expectType<CronDate>(interval.next())
expectType<CronDate>(interval.prev())
expectType<boolean>(interval.hasNext())
expectType<boolean>(interval.hasPrev())
expectType<string>(interval.stringify())
expectType<string>(interval.stringify(true))
expectType<void>(interval.reset())
expectType<void>(interval.reset("Sdf"))
expectType<void>(interval.reset(5))
expectType<void>(interval.reset(new Date()))
expectType<CronDate[]>(interval.iterate(5))
expectType<CronDate[]>(interval.iterate(5, (item: CronDate, i: number) => {}))
expectAssignable<DateType>(new Date())
expectAssignable<DateType>(5)
expectAssignable<DateType>("SDf")
expectType<IteratorResult<CronDate, CronDate>>(intervalIterator.next())
expectType<IteratorResult<CronDate, CronDate>>(intervalIterator.prev())
expectType<IteratorResult<CronDate, CronDate>[]>(intervalIterator.iterate(5))
expectType<IteratorResult<CronDate, CronDate>[]>(intervalIterator.iterate(5, (item: IteratorResult<CronDate, CronDate>, i: number) => {}))

138
node_modules/cron-parser/test/index.test-d.ts generated vendored Normal file
View File

@ -0,0 +1,138 @@
import {expectAssignable, expectError, expectNotAssignable, expectType} from 'tsd';
import {
CronDate,
CronExpression,
CronFields, DateType,
parseExpression,
parseFile, ParserOptions,
parseString,
fieldsToExpression,
StringResult
} from '../index';
const interval = parseExpression('0 1 2 3 * 1-3,5');
const intervalIterator = parseExpression('0 1 2 3 * 1-3,5', {iterator: true});
expectError(interval.fields = interval.fields);
expectError(interval.fields.second = []);
expectError(interval.fields.second.push(1));
expectError(interval.fields.minute = []);
expectError(interval.fields.minute.push(1));
expectError(interval.fields.hour = []);
expectError(interval.fields.hour.push(1));
expectError(interval.fields.dayOfMonth = []);
expectError(interval.fields.dayOfMonth.push(1));
expectError(interval.fields.month = []);
expectError(interval.fields.month.push(1));
expectError(interval.fields.dayOfWeek = []);
expectError(interval.fields.dayOfWeek.push(1));
expectAssignable<typeof interval.fields.second[0]>(0);
expectAssignable<typeof interval.fields.second[0]>(59);
expectNotAssignable<typeof interval.fields.second[0]>(-1);
expectNotAssignable<typeof interval.fields.second[0]>(60);
expectAssignable<typeof interval.fields.minute[0]>(0);
expectAssignable<typeof interval.fields.minute[0]>(59);
expectNotAssignable<typeof interval.fields.minute[0]>(-1);
expectNotAssignable<typeof interval.fields.minute[0]>(60);
expectAssignable<typeof interval.fields.hour[0]>(0);
expectAssignable<typeof interval.fields.hour[0]>(23);
expectNotAssignable<typeof interval.fields.hour[0]>(-1);
expectNotAssignable<typeof interval.fields.hour[0]>(24);
expectAssignable<typeof interval.fields.dayOfMonth[0]>(1);
expectAssignable<typeof interval.fields.dayOfMonth[0]>(31);
expectAssignable<typeof interval.fields.dayOfMonth[0]>('L');
expectNotAssignable<typeof interval.fields.dayOfMonth[0]>(0);
expectNotAssignable<typeof interval.fields.dayOfMonth[0]>(32);
expectAssignable<typeof interval.fields.month[0]>(1);
expectAssignable<typeof interval.fields.month[0]>(12);
expectNotAssignable<typeof interval.fields.month[0]>(0);
expectNotAssignable<typeof interval.fields.month[0]>(13);
expectAssignable<typeof interval.fields.dayOfWeek[0]>(0);
expectAssignable<typeof interval.fields.dayOfWeek[0]>(7);
expectNotAssignable<typeof interval.fields.dayOfWeek[0]>(-1);
expectNotAssignable<typeof interval.fields.dayOfWeek[0]>(8);
const parseOptions: ParserOptions<true> = {
currentDate: 'f',
startDate: 4,
endDate: new Date(),
iterator: true,
utc: true,
tz: 'f',
nthDayOfWeek: 5,
}
expectAssignable<{
currentDate?: string | number | Date
startDate?: string | number | Date
endDate?: string | number | Date
iterator?: boolean
utc?: boolean
tz?: string
nthDayOfWeek?: number
}>(parseOptions)
expectType<CronExpression>(parseExpression('0 1 2 3 * 1-3,5'))
expectType<CronExpression<true>>(parseExpression('0 1 2 3 * 1-3,5', parseOptions))
const fields: CronFields = {
second: [1, 1],
minute: [1],
hour: [1],
dayOfMonth: [1],
month: [1],
dayOfWeek: [1],
}
expectType<CronExpression>(fieldsToExpression(fields))
expectType<CronExpression<true>>(fieldsToExpression(fields, parseOptions))
expectType<string>(fieldsToExpression(fields).stringify())
expectType<string>(fieldsToExpression(fields, parseOptions).stringify())
expectType<string>(fieldsToExpression(fields, parseOptions).stringify(true))
expectType<void>(parseFile('path', (err: any, data: StringResult) => console.log(data)))
expectType<StringResult>(parseString('path'))
const stringResult = parseString('path');
expectType<{
variables: Record<string, string>,
expressions: CronExpression[],
errors: Record<string, any>,
}>(stringResult)
expectType<CronFields>(interval.fields)
expectType<CronDate>(interval.next())
expectType<CronDate>(interval.prev())
expectType<boolean>(interval.hasNext())
expectType<boolean>(interval.hasPrev())
expectType<string>(interval.stringify())
expectType<string>(interval.stringify(true))
expectType<void>(interval.reset())
expectType<void>(interval.reset("Sdf"))
expectType<void>(interval.reset(5))
expectType<void>(interval.reset(new Date()))
expectType<CronDate[]>(interval.iterate(5))
expectType<CronDate[]>(interval.iterate(5, (item: CronDate, i: number) => {}))
expectAssignable<DateType>(new Date())
expectAssignable<DateType>(5)
expectAssignable<DateType>("SDf")
expectType<IteratorResult<CronDate, CronDate>>(intervalIterator.next())
expectType<IteratorResult<CronDate, CronDate>>(intervalIterator.prev())
expectType<IteratorResult<CronDate, CronDate>[]>(intervalIterator.iterate(5))
expectType<IteratorResult<CronDate, CronDate>[]>(intervalIterator.iterate(5, (item: IteratorResult<CronDate, CronDate>, i: number) => {}))

17
node_modules/cron-parser/test/leap_year.js generated vendored Normal file
View File

@ -0,0 +1,17 @@
var util = require('util');
var test = require('tap').test;
var expression = require('../lib/expression');
test('leap year', function(t) {
try {
var interval = expression.parse('0 0 29 2 *');
var i;
var d;
for (i = 0; i < 20; ++i) {
d = interval.next();
}
t.end();
} catch (err) {
t.error(err, 'Interval parse error');
}
});

46
node_modules/cron-parser/test/parser.js generated vendored Normal file
View File

@ -0,0 +1,46 @@
var test = require('tap').test;
var CronParser = require('../lib/parser');
// Globals
test('load crontab file', function(t) {
CronParser.parseFile(__dirname + '/crontab.example', function(err, result) {
t.error(err, 'File read error');
t.ok(result, 'Crontab parsed parsed');
t.equal(Object.keys(result.variables).length, 2, 'variables length matches');
t.equal(Object.keys(result.errors).length, 0, 'errors length matches');
t.equal(result.expressions.length, 3, 'expressions length matches');
// Parse expressions
var next = null;
t.equal(result.expressions[0].hasNext(), true);
next = result.expressions[0].next();
t.ok(next, 'first date');
next = result.expressions[1].next();
t.ok(next, 'second date');
next = result.expressions[2].next();
t.ok(next, 'third date');
t.end();
});
});
test('no next date', function(t) {
var options = {
currentDate: new Date(2014, 0, 1),
endDate: new Date(2014, 0, 1)
};
try {
var interval = CronParser.parseExpression('* * 2 * *', options);
t.equal(interval.hasNext(), false);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});

145
node_modules/cron-parser/test/parser_crondate_formats.js generated vendored Normal file
View File

@ -0,0 +1,145 @@
var luxon = require('luxon');
var test = require('tap').test;
var CronDate = require('../lib/date');
test('parse cron date formats with local timezone', (t) => {
// Some tests need the local offset to be compatible without invoking timezone management.
// Local offset is dependent on what the system being tested on is
var offset = new Date().getTimezoneOffset();
var offsetHours = Math.abs(Math.floor(offset/60));
var offsetMinutes = offset % 60;
var offsetSign = offset < 0 ? '-' : '+';
var expectedTime = new Date(2021, 0, 4, 10, 0, 0).toString();
test('undefined date', (t) => {
const realDate = new Date();
var d = new CronDate();
t.equal(d.toDate().toString(), realDate.toString());
t.end();
});
test('JS Date', (t) => {
var d = new CronDate(new Date(2021, 0, 4, 10, 0, 0));
t.equal(d.toDate().toString(), expectedTime);
t.end();
});
test('ISO 8601', (t) => {
var d = new CronDate('2021-01-04T10:00:00');
t.equal(d.toDate().toString(), expectedTime);
t.end();
});
test('ISO 8601 date', (t) => {
var d = new CronDate('2021-01-04');
var expectedTime = new Date(2021, 0, 4, 0, 0, 0).toString();
t.equal(d.toDate().toString(), expectedTime);
t.end();
});
test('RFC2822', (t) => {
var offsetString = offsetSign + String(offsetHours).padStart(2, 0) + String(offsetMinutes).padStart(2, 0);
var d = new CronDate('Mon, 4 Jan 2021 10:00:00 ' + offsetString);
t.equal(d.toDate().toString(), expectedTime);
t.end();
});
test('RFC2822-like without timezone offset', (t) => {
var d = new CronDate('Mon, 4 Jan 2021 10:00:00');
t.equal(d.toDate().toString(), expectedTime);
t.end();
});
test('SQL', (t) => {
var d = new CronDate('2021-01-04 10:00:00');
t.equal(d.toDate().toString(), expectedTime);
t.end();
});
test('milliseconds', (t) => {
var d = new CronDate(new Date('2021-01-04 10:00:00').valueOf());
t.equal(d.toDate().toString(), expectedTime);
t.end();
});
test('CronDate', (t) => {
var date = new CronDate('Mon, 4 Jan 2021 10:00:00');
var d = new CronDate(date);
t.equal(d.toDate().toString(), expectedTime);
t.end();
});
test('invalid', (t) => {
t.throws(() => {
var d = new CronDate('2021-01-4 10:00:00');
});
t.end();
});
t.end();
});
test('parse cron date formats with another timezone', (t) => {
test('ISO 8601 without offset', (t) => {
// implies format already in timezone
var d = new CronDate('2021-01-04T10:00:00', 'Europe/Athens');
t.equal(d.toISOString(), '2021-01-04T08:00:00.000Z');
t.end();
});
test('ISO 8601 with non-local offset', (t) => {
var d = new CronDate('2021-01-04T10:00:00+01:00', 'Europe/Athens');
t.equal(d.toISOString(), '2021-01-04T09:00:00.000Z');
t.end();
});
test('RFC2822 with non-local offset', (t) => {
var d = new CronDate('Mon, 4 Jan 2021 10:00:00 +0100', 'Europe/Athens');
t.equal(d.toISOString(), '2021-01-04T09:00:00.000Z');
t.end();
});
test('milliseconds', (t) => {
var date = luxon.DateTime.fromISO('2021-01-04T11:00:00.000+02:00').valueOf();
var d = new CronDate(date, 'Europe/Athens');
t.equal(d.toISOString(), '2021-01-04T09:00:00.000Z');
t.end();
});
test('CronDate with same timezone', (t) => {
var date = new CronDate('Mon, 4 Jan 2021 10:00:00', 'Europe/Athens');
var d = new CronDate(date);
t.equal(d.toISOString(), '2021-01-04T08:00:00.000Z');
t.end();
});
test('CronDate with different timezone', (t) => {
var date = new CronDate('Mon, 4 Jan 2021 10:00:00', 'America/New_York');
var d = new CronDate(date, 'Europe/Athens');
t.equal(d.toISOString(), '2021-01-04T15:00:00.000Z');
t.end();
});
t.end('crondate input should');
});

169
node_modules/cron-parser/test/parser_day_of_month.js generated vendored Normal file
View File

@ -0,0 +1,169 @@
var test = require('tap').test;
var CronParser = require('../lib/parser');
test('parse cron with last day in a month', function(t) {
var options = {
currentDate: new Date(2014, 0, 1),
endDate: new Date(2014, 10, 1)
};
try {
var interval = CronParser.parseExpression('0 0 L * *', options);
t.equal(interval.hasNext(), true);
for (i = 0; i < 10; ++i) {
var next = interval.next();
t.ok(next, 'has a date');
}
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('parse cron with last day in feb', function(t) {
var options = {
currentDate: new Date(2016, 0, 1),
endDate: new Date(2016, 10, 1)
};
try {
var interval = CronParser.parseExpression('0 0 6-20/2,L 2 *', options);
t.equal(interval.hasNext(), true);
var next = null;
var items = 9;
var i = 0;
while(interval.hasNext()) {
next = interval.next();
i += 1;
t.ok(next, 'has a date');
}
//leap year
t.equal(next.getDate(), 29);
t.equal(i, items);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('parse cron with last day in feb', function(t) {
var options = {
currentDate: new Date(2014, 0, 1),
endDate: new Date(2014, 10, 1)
};
try {
var interval = CronParser.parseExpression('0 0 1,3,6-10,L 2 *', options);
t.equal(interval.hasNext(), true);
var next = null;
while(interval.hasNext()) {
next = interval.next();
t.ok(next, 'has a date');
}
//common year
t.equal(next.getDate(), 28);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('parse cron with last weekday of the month', function(t) {
var options = {
currentDate: new Date(2021, 8, 1),
endDate: new Date(2021, 11, 1)
};
var testCases = [
{ expression: '0 0 0 * * 1L', expectedDate: 27 },
{ expression: '0 0 0 * * 2L', expectedDate: 28 },
{ expression: '0 0 0 * * 3L', expectedDate: 29 },
{ expression: '0 0 0 * * 4L', expectedDate: 30 },
{ expression: '0 0 0 * * 5L', expectedDate: 24 },
{ expression: '0 0 0 * * 6L', expectedDate: 25 },
{ expression: '0 0 0 * * 0L', expectedDate: 26 },
{ expression: '0 0 0 * * 7L', expectedDate: 26 }
];
testCases.forEach(function({ expression, expectedDate }) {
t.test(expression, function(t) {
try {
var interval = CronParser.parseExpression(expression, options);
t.equal(interval.hasNext(), true);
var next = interval.next();
t.equal(next.getDate(), expectedDate);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
});
t.end();
});
test('parses expression that runs on both last monday and friday of the month', function(t) {
var options = {
currentDate: new Date(2021, 8, 1),
endDate: new Date(2021, 11, 1)
};
try {
var interval = CronParser.parseExpression('0 0 0 * * 1L,5L', options);
t.equal(interval.next().getDate(), 24);
t.equal(interval.next().getDate(), 27);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('parses expression that runs on both every monday and last friday of mont', function(t) {
var options = {
currentDate: new Date(2021, 8, 1),
endDate: new Date(2021, 8, 30)
};
try {
var interval = CronParser.parseExpression('0 0 0 * * 1,5L', options);
var dates = [];
while(true) {
try {
dates.push(interval.next().getDate());
} catch (e) {
if (e.message !== 'Out of the timespan range') {
throw e;
}
break;
}
}
t.same(dates, [6, 13, 20, 24, 27]);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('fails to parse for invalid last weekday of month expression', function(t) {
t.throws(function() {
var interval = CronParser.parseExpression('0 0 0 * * L');
interval.next();
});
t.end();
});

32
node_modules/cron-parser/test/prev_date.js generated vendored Normal file
View File

@ -0,0 +1,32 @@
var test = require('tap').test;
var CronExpression = require('../lib/expression');
test('prev should match correctly (issue #98) when milliseconds are greater than 0', function(t) {
var options = {
currentDate: new Date('2017-06-13T18:21:25.002Z')
};
var interval = CronExpression.parse('*/5 * * * * *', options);
var prev = interval.prev();
t.equal(prev.getSeconds(), 25);
t.end();
});
test('prev should match correctly (issue #98) when milliseconds are equal to 0', function(t) {
var interval = CronExpression.parse('59 59 23 * * *',{
currentDate : new Date('2012-12-26 14:38:53')
});
[25, 24, 23, 22].forEach(function(date) {
var prev = interval.prev();
t.equal(prev.getFullYear(), 2012);
t.equal(prev.getMonth(), 11);
t.equal(prev.getDate(), date);
t.equal(prev.getHours(), 23);
t.equal(prev.getMinutes(), 59);
t.equal(prev.getSeconds(), 59);
});
t.end();
});

457
node_modules/cron-parser/test/stringify.js generated vendored Normal file
View File

@ -0,0 +1,457 @@
'use strict';
var test = require('tap').test;
var CronParser = require('../lib/parser');
test('stringify cron expression all stars no seconds', function (t) {
try {
var expected = '0 * * * * *';
var interval = CronParser.parseExpression('* * * * *', {});
var str = interval.stringify(true);
t.equal(str, expected);
str = CronParser.fieldsToExpression(interval.fields).stringify(true);
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('stringify cron expression all stars no seconds (discard seconds)', function (t) {
try {
var expected = '* * * * *';
var interval = CronParser.parseExpression('* * * * *', {});
var str = interval.stringify();
t.equal(str, expected);
str = CronParser.fieldsToExpression(interval.fields).stringify();
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('stringify cron expression all stars with seconds', function (t) {
try {
var expected = '* * * * * *';
var interval = CronParser.parseExpression('* * * * * *', {});
var str = interval.stringify(true);
t.equal(str, expected);
str = CronParser.fieldsToExpression(interval.fields).stringify(true);
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('stringify cron expression all stars with seconds (discard seconds)', function (t) {
try {
var expected = '* * * * *';
var interval = CronParser.parseExpression('* * * * * *', {});
var str = interval.stringify();
t.equal(str, expected);
str = CronParser.fieldsToExpression(interval.fields).stringify();
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('stringify cron expression', function (t) {
try {
var expected = '0 1,2,4-10,20-35/5,57 * * * *';
var interval = CronParser.parseExpression('1,2,4-10,20-35/5,57 * * * *', {});
var str = interval.stringify(true);
t.equal(str, expected);
str = CronParser.fieldsToExpression(interval.fields).stringify(true);
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('stringify cron expression (discard seconds)', function (t) {
try {
var expected = '1,2,4-10,20-35/5,57 * * * *';
var interval = CronParser.parseExpression('1,2,4-10,20-35/5,57 * * * *', {});
var str = interval.stringify();
t.equal(str, expected);
str = CronParser.fieldsToExpression(interval.fields).stringify();
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('stringify cron expression with star range step', function (t) {
try {
var expected = '0 */5 */2 * * *';
var interval = CronParser.parseExpression('*/5 */2 */1 * *', {});
var str = interval.stringify(true);
t.equal(str, expected);
str = CronParser.fieldsToExpression(interval.fields).stringify(true);
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('stringify cron expression with star range step (discard seconds)', function (t) {
try {
var expected = '*/5 */2 * * *';
var interval = CronParser.parseExpression('*/5 */2 */1 * *', {});
var str = interval.stringify();
t.equal(str, expected);
str = CronParser.fieldsToExpression(interval.fields).stringify();
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('stringify cron expression with semi range step', function (t) {
try {
var expected = '0 5/5 * * * *';
var interval = CronParser.parseExpression('5/5 * * * *', {});
var str = interval.stringify(true);
t.equal(str, expected);
str = CronParser.fieldsToExpression(interval.fields).stringify(true);
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('stringify cron expression with semi range step (discard seconds)', function (t) {
try {
var expected = '5/5 * * * *';
var interval = CronParser.parseExpression('5/5 * * * *', {});
var str = interval.stringify();
t.equal(str, expected);
str = CronParser.fieldsToExpression(interval.fields).stringify();
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('stringify cron expression with L', function (t) {
try {
var expected = '0 * * 1,4-10,L * *';
var interval = CronParser.parseExpression('* * 1,4-10,L * *', {});
var str = interval.stringify(true);
t.equal(str, expected);
str = CronParser.fieldsToExpression(interval.fields).stringify(true);
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('stringify cron expression with L (discard seconds)', function (t) {
try {
var expected = '* * 1,4-10,L * *';
var interval = CronParser.parseExpression('* * 1,4-10,L * *', {});
var str = interval.stringify();
t.equal(str, expected);
str = CronParser.fieldsToExpression(interval.fields).stringify();
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('stringify cron expression with weekday L', function (t) {
try {
var expected = '0 0 0 * * 1L';
var interval = CronParser.parseExpression(expected, {});
var str = interval.stringify(true);
t.equal(str, expected);
str = CronParser.fieldsToExpression(interval.fields).stringify(true);
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('stringify cron expression with multiple weekday, one of them with an L', function (t) {
try {
var expected = '0 0 0 * * 4,6L';
var interval = CronParser.parseExpression(expected, {});
var str = interval.stringify(true);
t.equal(str, expected);
str = CronParser.fieldsToExpression(interval.fields).stringify(true);
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('stringify cron expression with multiple weekday, two of them with an L', function (t) {
try {
var expected = '0 0 0 * * 1L,5L';
var interval = CronParser.parseExpression(expected, {});
var str = interval.stringify(true);
t.equal(str, expected);
str = CronParser.fieldsToExpression(interval.fields).stringify(true);
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('stringify cron expression with wildcard day of month and single month value', function (t) {
try {
var expected = '* * * 4 *';
var interval = CronParser.parseExpression(expected, {});
var str = interval.stringify();
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('stringify cron expression with wildcard day of month and month rangee', function (t) {
try {
var expected = '* * * 4-6 *';
var interval = CronParser.parseExpression(expected, {});
var str = interval.stringify();
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('stringify cron expression with day of month range and single month value', function (t) {
try {
var expected = '* * 1-25 4 *';
var interval = CronParser.parseExpression(expected, {});
var str = interval.stringify();
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('stringify from fields out of order', function (t) {
try {
var expected = '1-5 1 1 1 1 1';
var str = CronParser.fieldsToExpression({
second: [5,2,1,4,3],
minute: [1],
hour: [1],
month: [1],
dayOfMonth: [1],
dayOfWeek: [1],
}).stringify(true);
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('stringify from fields out of order (discard seconds)', function (t) {
try {
var expected = '1 1 1 1 1';
var str = CronParser.fieldsToExpression({
second: [5,2,1,4,3],
minute: [1],
hour: [1],
month: [1],
dayOfMonth: [1],
dayOfWeek: [1],
}).stringify();
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('stringify cron expression with extended day of week range (0,7)', function (t) {
try {
var expected = '* * * * *';
var interval = CronParser.parseExpression('* * * * *');
var str = CronParser.fieldsToExpression({
second: interval.fields.second,
minute: interval.fields.minute,
hour: interval.fields.hour,
month: interval.fields.month,
dayOfMonth: interval.fields.dayOfMonth,
dayOfWeek: [0, 1, 2, 3, 4, 5, 6],
}).stringify();
t.equal(str, expected);
str = CronParser.fieldsToExpression({
second: interval.fields.second,
minute: interval.fields.minute,
hour: interval.fields.hour,
month: interval.fields.month,
dayOfMonth: interval.fields.dayOfMonth,
dayOfWeek: [0, 1, 2, 3, 4, 5, 6, 7],
}).stringify();
t.equal(str, expected);
} catch (err) {
t.error(err, 'Parse read error');
}
t.end();
});
test('validation error - missing seconds', function (t) {
t.throws(function () {
CronParser.fieldsToExpression({
minute: [1],
hour: [1],
dayOfMonth: [1],
month: [1],
dayOfWeek: [1],
});
}, new Error('Validation error, Field second is missing'));
t.end();
});
test('validation error - empty seconds', function (t) {
t.throws(function () {
CronParser.fieldsToExpression({
second: [],
minute: [1],
hour: [1],
dayOfMonth: [1],
month: [1],
dayOfWeek: [1],
});
}, new Error('Validation error, Field second contains no values'));
t.end();
});
test('validation error - missing values - empty array', function (t) {
t.throws(function () {
CronParser.fieldsToExpression({
second: [1],
minute: [],
hour: [1],
dayOfMonth: [1],
month: [1],
dayOfWeek: [1],
});
}, new Error('Validation error, Field minute contains no values'));
t.end();
});
test('validation error - missing values', function (t) {
t.throws(function () {
CronParser.fieldsToExpression({
second: [1],
hour: [1],
dayOfMonth: [1],
month: [1],
dayOfWeek: [1],
});
}, new Error('Validation error, Field minute is missing'));
t.end();
});
test('validation error - range error', function (t) {
t.throws(function () {
CronParser.fieldsToExpression({
second: [-1, 1, 0],
minute: [1],
hour: [1],
dayOfMonth: [1],
month: [1],
dayOfWeek: [1],
});
}, new Error('Constraint error, got value -1 expected range 0-59'));
t.end();
});
test('validation error - bad chars error', function (t) {
t.throws(function () {
CronParser.fieldsToExpression({
second: [0, 'R'],
minute: [1],
hour: [1],
dayOfMonth: [1],
month: [1],
dayOfWeek: [1],
});
}, new Error('Constraint error, got value R expected range 0-59'));
t.end();
});
test('validation error - duplicates', function (t) {
t.throws(function () {
CronParser.fieldsToExpression({
second: [1, 1],
minute: [1],
hour: [1],
dayOfMonth: [1],
month: [1],
dayOfWeek: [1],
});
}, new Error('Validation error, Field second contains duplicate values'));
t.end();
});

422
node_modules/cron-parser/test/timezone.js generated vendored Normal file
View File

@ -0,0 +1,422 @@
var test = require('tap').test;
var CronExpression = require('../lib/expression');
test('It works on DST start', function(t) {
try {
var options = {
currentDate: '2016-03-27 02:00:01',
tz: 'Europe/Athens'
};
var interval, date;
interval = CronExpression.parse('0 * * * *', options);
t.ok(interval, 'Interval parsed');
date = interval.next();
t.equal(date.getMinutes(), 0, '0 Minutes');
t.equal(date.getHours(), 4, 'Due to DST start in Athens, 3 is skipped');
t.equal(date.getDate(), 27, 'on the 27th');
date = interval.next();
t.equal(date.getMinutes(), 0, '0 Minutes');
t.equal(date.getHours(), 5, '5 AM');
t.equal(date.getDate(), 27, 'on the 27th');
interval = CronExpression.parse('30 2 * * *', options);
t.ok(interval, 'Interval parsed');
date = interval.next();
t.equal(date.getMinutes(), 30, '30 Minutes');
t.equal(date.getHours(), 2, '2 AM');
t.equal(date.getDate(), 27, 'on the 27th');
date = interval.next();
t.equal(date.getMinutes(), 30, '30 Minutes');
t.equal(date.getHours(), 2, '2 AM');
t.equal(date.getDate(), 28, 'on the 28th');
interval = CronExpression.parse('0 3 * * *', options);
t.ok(interval, 'Interval parsed');
date = interval.next();
t.equal(date.getMinutes(), 0, '0 Minutes');
t.equal(date.getHours(), 4, 'Due to DST start in Athens, 3 is skipped');
t.equal(date.getDate(), 27, 'on the 27th');
date = interval.next();
t.equal(date.getMinutes(), 0, '0 Minutes');
t.equal(date.getHours(), 3, '3 on the 28th');
t.equal(date.getDate(), 28, 'on the 28th');
interval = CronExpression.parse('*/20 3 * * *', options);
t.ok(interval, 'Interval parsed');
date = interval.next();
t.equal(date.getMinutes(), 0, '0 Minutes');
t.equal(date.getHours(), 4, 'Due to DST start in Athens, 3 is skipped');
t.equal(date.getDate(), 27, 'on the 27th');
date = interval.next();
t.equal(date.getMinutes(), 20, '20 Minutes');
t.equal(date.getHours(), 4, 'Due to DST start in Athens, 3 is skipped');
t.equal(date.getDate(), 27, 'on the 27th');
date = interval.next();
t.equal(date.getMinutes(), 40, '20 Minutes');
t.equal(date.getHours(), 4, 'Due to DST start in Athens, 3 is skipped');
t.equal(date.getDate(), 27, 'on the 27th');
date = interval.next();
t.equal(date.getMinutes(), 0, '0 Minutes');
t.equal(date.getHours(), 3, '3 AM');
t.equal(date.getDate(), 28, 'on the 28th');
options.currentDate = '2016-03-27 00:00:01';
interval = CronExpression.parse('0 * 27 * *', options);
t.ok(interval, 'Interval parsed');
date = interval.next();
t.equal(date.getMinutes(), 0, '0 Minutes');
t.equal(date.getHours(), 1, '1 AM');
t.equal(date.getDate(), 27, 'on the 27th');
date = interval.next();
t.equal(date.getMinutes(), 0, '0 Minutes');
t.equal(date.getHours(), 2, '2 AM');
t.equal(date.getDate(), 27, 'on the 27th');
date = interval.next();
t.equal(date.getMinutes(), 0, '0 Minutes');
t.equal(date.getHours(), 4, '4 AM');
t.equal(date.getDate(), 27, 'on the 27th');
date = interval.next();
t.equal(date.getMinutes(), 0, '0 Minutes');
t.equal(date.getHours(), 5, '5 AM');
t.equal(date.getDate(), 27, 'on the 27th');
options.currentDate = '2016-03-27 00:00:01';
options.endDate = '2016-03-27 03:00:01';
interval = CronExpression.parse('0 * * * *', options);
t.ok(interval, 'Interval parsed');
date = interval.next();
t.equal(date.getMinutes(), 0, '0 Minutes');
t.equal(date.getHours(), 1, '1 AM');
t.equal(date.getDate(), 27, 'on the 27th');
date = interval.next();
t.equal(date.getMinutes(), 0, '0 Minutes');
t.equal(date.getHours(), 2, '2 AM');
t.equal(date.getDate(), 27, 'on the 27th');
date = interval.next();
t.equal(date.getMinutes(), 0, '0 Minutes');
t.equal(date.getHours(), 4, '4 AM');
t.equal(date.getDate(), 27, 'on the 27th');
// Out of the timespan range
t.throws(function() {
date = interval.next();
});
} catch (err) {
t.error(err, 'Interval parse error');
}
t.end();
});
test('It works on DST end', function(t) {
try {
var options = {
currentDate: '2016-10-30 02:00:01',
tz: 'Europe/Athens'
};
var interval, date;
interval = CronExpression.parse('0 * * * *', options);
t.ok(interval, 'Interval parsed');
date = interval.next();
t.equal(date.getHours(), 3, '3 AM');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getHours(), 3, 'Due to DST end in Athens (4-->3)');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getHours(), 4, '4 AM');
t.equal(date.getDate(), 30, '30th');
interval = CronExpression.parse('0 3 * * *', options);
t.ok(interval, 'Interval parsed');
date = interval.next();
t.equal(date.getHours(), 3, '3 AM');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getHours(), 3, '3 AM');
t.equal(date.getDate(), 31, '31st');
interval = CronExpression.parse('*/20 3 * * *', options);
t.ok(interval, 'Interval parsed');
date = interval.next();
t.equal(date.getMinutes(), 0, '0');
t.equal(date.getHours(), 3, '3 AM');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getMinutes(), 20, '20');
t.equal(date.getHours(), 3, '3 AM');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getMinutes(), 40, '40');
t.equal(date.getHours(), 3, '3 AM');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getMinutes(), 0, '0');
t.equal(date.getHours(), 3, '3 AM');
t.equal(date.getDate(), 31, '31st');
options.currentDate = '2016-10-30 00:00:01';
interval = CronExpression.parse('0 * 30 * *', options);
t.ok(interval, 'Interval parsed');
date = interval.next();
t.equal(date.getHours(), 1, '1 AM');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getHours(), 2, '2 AM');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getHours(), 3, '3 AM');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getHours(), 3, '3 AM');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getHours(), 4, '4 AM');
t.equal(date.getDate(), 30, '30th');
options.currentDate = '2016-10-30 00:00:01';
// specify the DST offset via ISO 8601 format, as 3am is repeated
options.endDate = '2016-10-30T03:00:01+03';
interval = CronExpression.parse('0 * * * *', options);
t.ok(interval, 'Interval parsed');
date = interval.next();
t.equal(date.getHours(), 1, '1 AM');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getHours(), 2, '2 AM');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getHours(), 3, '3 AM');
t.equal(date.getDate(), 30, '30th');
// Out of the timespan range
t.throws(function() {
date = interval.next();
});
options.endDate = '2016-10-30 04:00:01';
interval = CronExpression.parse('0 * * * *', options);
t.ok(interval, 'Interval parsed');
date = interval.next();
t.equal(date.getHours(), 1, '1 AM');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getHours(), 2, '2 AM');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getHours(), 3, '3 AM');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getHours(), 3, '3 AM');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getHours(), 4, '4 AM');
t.equal(date.getDate(), 30, '30th');
// Out of the timespan range
t.throws(function() {
date = interval.next();
});
options = {
currentDate : new Date('Sun Oct 29 2016 01:00:00 GMT+0200')
};
interval = CronExpression.parse('0 12 * * *', options);
t.ok(interval, 'Interval parsed');
date = interval.next();
t.equal(date.getHours(), 12, '12');
t.equal(date.getDate(), 29, '29th');
date = interval.next();
t.equal(date.getHours(), 12, '12');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getHours(), 12, '12');
t.equal(date.getDate(), 31, '31st');
options = {
currentDate : new Date('Sun Oct 29 2016 02:59:00 GMT+0200')
};
interval = CronExpression.parse('0 12 * * *', options);
t.ok(interval, 'Interval parsed');
date = interval.next();
t.equal(date.getHours(), 12, '12');
t.equal(date.getDate(), 29, '29th');
date = interval.next();
t.equal(date.getHours(), 12, '12');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getHours(), 12, '12');
t.equal(date.getDate(), 31, '31st');
options = {
currentDate : new Date('Sun Oct 29 2016 02:59:59 GMT+0200')
};
interval = CronExpression.parse('0 12 * * *', options);
t.ok(interval, 'Interval parsed');
date = interval.next();
t.equal(date.getHours(), 12, '12');
t.equal(date.getDate(), 29, '29th');
date = interval.next();
t.equal(date.getHours(), 12, '12');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getHours(), 12, '12');
t.equal(date.getDate(), 31, '31st');
options = {
currentDate : new Date('Sun Oct 30 2016 01:00:00 GMT+0200')
};
interval = CronExpression.parse('0 12 * * *', options);
t.ok(interval, 'Interval parsed');
date = interval.next();
t.equal(date.getHours(), 12, '12');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getHours(), 12, '12');
t.equal(date.getDate(), 31, '31st');
options = {
currentDate : new Date('Sun Oct 30 2016 01:59:00 GMT+0200')
};
interval = CronExpression.parse('0 12 * * *', options);
t.ok(interval, 'Interval parsed');
date = interval.next();
t.equal(date.getHours(), 12, '12');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getHours(), 12, '12');
t.equal(date.getDate(), 31, '31st');
options = {
currentDate : new Date('Sun Oct 30 2016 01:59:59 GMT+0200')
};
interval = CronExpression.parse('0 12 * * *', options);
t.ok(interval, 'Interval parsed');
date = interval.next();
t.equal(date.getHours(), 12, '12');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getHours(), 12, '12');
t.equal(date.getDate(), 31, '31st');
options = {
currentDate : new Date('Sun Oct 30 2016 02:59:00 GMT+0200')
};
interval = CronExpression.parse('0 12 * * *', options);
t.ok(interval, 'Interval parsed');
date = interval.next();
t.equal(date.getHours(), 12, '12');
t.equal(date.getDate(), 30, '30th');
date = interval.next();
t.equal(date.getHours(), 12, '12');
t.equal(date.getDate(), 31, '31st');
} catch (err) {
t.error(err, 'Interval parse error');
}
t.end();
});
test('it will work with #131 issue case', function(t) {
var options = {
tz: 'America/Sao_Paulo',
currentDate : new Date('Sun Oct 30 2018 02:59:00 GMT+0200')
};
var interval = CronExpression.parse('0 9 1 1 *', options);
var date = interval.next();
t.equal(date.getFullYear(), 2019);
t.equal(date.getDate(), 1);
t.equal(date.getMonth(), 0);
date = interval.prev();
t.equal(date.getFullYear(), 2018);
t.equal(date.getDate(), 1);
t.equal(date.getMonth(), 0);
date = interval.prev();
t.equal(date.getFullYear(), 2017);
t.equal(date.getDate(), 1);
t.equal(date.getMonth(), 0);
t.end();
});
test('it will work with #137 issue case', function(t) {
var options = {
tz: 'America/New_York',
currentDate : new Date('10/28/2018')
};
var interval = CronExpression.parse('0 12 * * 3', options);
var date = interval.next();
t.equal(date.getFullYear(), 2018);
t.equal(date.getDate(), 31);
t.equal(date.getMonth(), 9);
t.end();
});

131
node_modules/cron-parser/types/common.d.ts generated vendored Normal file
View File

@ -0,0 +1,131 @@
export type DateType = Date | number | string
export interface CronDate {
addYear(): void
addMonth(): void
addDay(): void
addHour(): void
addMinute(): void
addSecond(): void
subtractYear(): void
subtractMonth(): void
subtractDay(): void
subtractHour(): void
subtractMinute(): void
subtractSecond(): void
getDate(): number
getFullYear(): number
getDay(): number
getMonth(): number
getHours(): number
getMinutes(): number
getSeconds(): number
getMilliseconds(): number
getTime(): number
getUTCDate(): number
getUTCFullYear(): number
getUTCDay(): number
getUTCMonth(): number
getUTCHours(): number
getUTCMinutes(): number
getUTCSeconds(): number
toISOString(): string
toJSON(): string
setDate(d: number): void
setFullYear(y: number): void
setDay(d: number): void
setMonth(m: number): void
setHours(h: number): void
setMinutes(m: number): void
setSeconds(s: number): void
setMilliseconds(s: number): void
getTime(): number
toString(): string
toDate(): Date
isLastDayOfMonth(): boolean
}
export interface ParserOptions<IsIterable extends boolean = false> {
currentDate?: DateType
startDate?: DateType
endDate?: DateType
utc?: boolean
tz?: string
nthDayOfWeek?: number
iterator?: IsIterable
}
type IteratorResultOrCronDate<IsIterable extends boolean> = IsIterable extends true
? IteratorResult<CronDate, CronDate>
: CronDate;
export interface ICronExpression<CronFields, IsIterable extends boolean> {
readonly fields: CronFields;
/** Find next suitable date */
next(): IteratorResultOrCronDate<IsIterable>
/** Find previous suitable date */
prev(): IteratorResultOrCronDate<IsIterable>
/** Check if next suitable date exists */
hasNext(): boolean
/** Check if previous suitable date exists */
hasPrev(): boolean
/** Iterate over expression iterator */
iterate(steps: number, callback?: (item: IteratorResultOrCronDate<IsIterable>, i: number) => void): IteratorResultOrCronDate<IsIterable>[]
/** Reset expression iterator state */
reset(resetDate?: string | number | Date): void
stringify(includeSeconds?: boolean): string
}
export interface IStringResult<CronFields> {
variables: Record<string, string>,
expressions: ICronExpression<CronFields, false>[],
errors: Record<string, any>,
}

45
node_modules/cron-parser/types/index.d.ts generated vendored Normal file
View File

@ -0,0 +1,45 @@
import {
CronDate,
DateType,
ICronExpression,
IStringResult,
ParserOptions,
} from './common';
type BuildRangeTuple<Current extends [...number[]], Count extends number> =
Current["length"] extends Count
? Current
: BuildRangeTuple<[number, ...Current], Count>
type RangeTuple<Count extends number> = BuildRangeTuple<[], Count>
type BuildRange<Current extends number, End extends number, Accu extends [...number[]]> =
Accu["length"] extends End
? Current
: BuildRange<Current | Accu["length"], End, [number, ...Accu]>
type Range<StartInclusive extends number, EndExclusive extends number> = BuildRange<StartInclusive, EndExclusive, RangeTuple<StartInclusive>>
export type SixtyRange = Range<0, 30> | Range<30, 60>; // Typescript restriction on recursion depth
export type HourRange = Range<0, 24>;
export type DayOfTheMonthRange = Range<1, 32> | 'L';
export type MonthRange = Range<1, 13>;
export type DayOfTheWeekRange = Range<0, 8>;
export type CronFields = {
readonly second: readonly SixtyRange[];
readonly minute: readonly SixtyRange[];
readonly hour: readonly HourRange[];
readonly dayOfMonth: readonly DayOfTheMonthRange[];
readonly month: readonly MonthRange[];
readonly dayOfWeek: readonly DayOfTheWeekRange[];
}
export {ParserOptions, CronDate, DateType}
export type CronExpression<IsIterable extends boolean = false> = ICronExpression<CronFields, IsIterable>
export type StringResult = IStringResult<CronFields>
export function parseExpression<IsIterable extends boolean = false>(expression: string, options?: ParserOptions<IsIterable>): CronExpression<IsIterable>;
export function fieldsToExpression<IsIterable extends boolean = false>(fields: CronFields, options?: ParserOptions<IsIterable>): CronExpression<IsIterable>;
export function parseFile(filePath: string, callback: (err: any, data: StringResult) => any): void;
export function parseString(data: string): StringResult;

28
node_modules/cron-parser/types/ts3/index.d.ts generated vendored Normal file
View File

@ -0,0 +1,28 @@
import {
CronDate,
DateType,
ICronExpression,
IStringResult,
ParserOptions,
} from '../common';
export type CronFields = {
readonly second: readonly number[];
readonly minute: readonly number[];
readonly hour: readonly number[];
readonly dayOfMonth: readonly (number | 'L')[];
readonly month: readonly number[];
readonly dayOfWeek: readonly number[];
}
export {ParserOptions, CronDate, DateType}
export type CronExpression<IsIterable extends boolean = false> = ICronExpression<CronFields, IsIterable>
export type StringResult = IStringResult<CronFields>
export function parseExpression<IsIterable extends boolean = false>(expression: string, options?: ParserOptions<IsIterable>): CronExpression<IsIterable>;
export function fieldsToExpression<IsIterable extends boolean = false>(fields: CronFields, options?: ParserOptions<IsIterable>): CronExpression<IsIterable>;
export function parseFile(filePath: string, callback: (err: any, data: StringResult) => any): void;
export function parseString(data: string): StringResult;