Projektstart

backend/node_modules/cron-parser/LICENSE

@@ -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.

backend/node_modules/cron-parser/README.md

@@ -0,0 +1,175 @@
+cron-parser
+================
+
+[![Build Status](https://github.com/harrisiirak/cron-parser/actions/workflows/push.yml/badge.svg?branch=master)](https://github.com/harrisiirak/cron-parser/actions/workflows/push.yml)
+[![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 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 0 * * 1,3L
+```

backend/node_modules/cron-parser/lib/date.js

@@ -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;

backend/node_modules/cron-parser/lib/field_compactor.js

@@ -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;

backend/node_modules/cron-parser/lib/field_stringify.js

@@ -0,0 +1,58 @@
+'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 result = [];
+  for (var i = 0, l = ranges.length; i < l; ++i) {
+    var range = ranges[i];
+    if (range.count === 1) {
+      result.push(range.start);
+      continue;
+    }
+
+    var step = range.step;
+    if (range.step === 1) {
+      result.push(range.start + '-' + range.end);
+      continue;
+    }
+
+    var multiplier = range.start == 0 ? range.count - 1 : range.count;
+    if (range.step * multiplier > range.end) {
+      result = result.concat(
+         Array
+          .from({ length: range.end - range.start + 1 })
+          .map(function (_, index) {
+            var value = range.start + index;
+            if ((value - range.start) % range.step === 0) {
+              return value;
+            }
+            return null;
+          })
+          .filter(function (value) {
+            return value != null;
+          })
+      );
+    } else if (range.end === max - range.step + 1) {
+      result.push(range.start + '/' + range.step);
+    } else {
+      result.push(range.start + '-' + range.end + '/' + range.step);
+    }
+  }
+
+  return result.join(',');
+}
+
+module.exports = stringifyField;

backend/node_modules/cron-parser/lib/parser.js

@@ -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;

backend/node_modules/cron-parser/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "cron-parser",
+  "version": "4.9.0",
+  "description": "Node.js library for parsing crontab instructions",
+  "main": "lib/parser.js",
+  "types": "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": "^15.0.1",
+    "tap": "^16.3.3",
+    "tsd": "^0.26.0"
+  },
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "browser": {
+    "fs": false
+  },
+  "tap": {
+    "check-coverage": false
+  },
+  "tsd": {
+    "directory": "test",
+    "compilerOptions": {
+      "lib": [
+        "es2017",
+        "dom"
+      ]
+    }
+  },
+  "files": [
+    "lib",
+    "types",
+    "LICENSE",
+    "README.md"
+  ]
+}

backend/node_modules/cron-parser/types/common.d.ts

@@ -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>,
+}

backend/node_modules/cron-parser/types/index.d.ts

@@ -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;

backend/node_modules/cron-parser/types/ts3/index.d.ts

@@ -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;