@nocobase/plugin-backups 2.0.56

package/dist/node_modules/cron-parser/test/field_compactor.js

@@ -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();
+});

package/dist/node_modules/cron-parser/test/field_stringify.js

@@ -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();
+});

package/dist/node_modules/cron-parser/test/fields.js

@@ -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();
+});
+

package/dist/node_modules/cron-parser/test/increment_on_first_iteration.js

@@ -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');
+  }
+});

package/dist/node_modules/cron-parser/test/index-ts3.test-d.ts

@@ -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) => {}))

package/dist/node_modules/cron-parser/test/index.test-d.ts

@@ -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) => {}))

package/dist/node_modules/cron-parser/test/leap_year.js

@@ -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');
+  }
+});