@xen-orchestra/cron/dist/parse.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

function _toArray(arr) { return _arrayWithHoles(arr) || _iterableToArray(arr) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

const compareNumbers = (a, b) => a - b;

const createParser = (_ref) => {
  let _ref$fields = _toArray(_ref.fields),
      fields = _ref$fields.slice(0),
      presets = _extends({}, _ref.presets);

  const m = fields.length;

  for (let j = 0; j < m; ++j) {
    const field = fields[j];
    let aliases = field.aliases;

    if (aliases !== undefined) {
      let symbols = aliases;

      if (Array.isArray(aliases)) {
        aliases = {};

        const _field$range = _slicedToArray(field.range, 1),
              start = _field$range[0];

        symbols.forEach((alias, i) => {
          aliases[alias] = start + i;
        });
      } else {
        symbols = Object.keys(aliases);
      }

      fields[j] = _objectSpread({}, field, {
        aliases,
        aliasesRegExp: new RegExp(symbols.join('|'), 'y')
      });
    }
  }

  let field, i, n, pattern, schedule, values;

  const isDigit = c => c >= '0' && c <= '9';

  const match = c => pattern[i] === c && (++i, true);

  const consumeWhitespaces = () => {
    let c;

    while ((c = pattern[i]) === ' ' || c === '\t') {
      ++i;
    }
  };

  const parseInteger = () => {
    let c;
    const digits = [];

    while (isDigit(c = pattern[i])) {
      ++i;
      digits.push(c);
    }

    if (digits.length === 0) {
      throw new SyntaxError("".concat(field.name, ": missing integer at character ").concat(i));
    }

    return Number.parseInt(digits.join(''), 10);
  };

  const parseValue = () => {
    let value;
    const _field = field,
          aliasesRegExp = _field.aliasesRegExp;

    if (aliasesRegExp === undefined || isDigit(pattern[i])) {
      value = parseInteger();
      const _field2 = field,
            post = _field2.post;

      if (post !== undefined) {
        value = post(value);
      }
    } else {
      aliasesRegExp.lastIndex = i;
      const matches = aliasesRegExp.exec(pattern);

      if (matches === null) {
        throw new SyntaxError("".concat(field.name, ": missing alias or integer at character ").concat(i));
      }

      const _matches = _slicedToArray(matches, 1),
            alias = _matches[0];

      i += alias.length;
      value = field.aliases[alias];
    }

    const _field3 = field,
          range = _field3.range;

    if (value < range[0] || value > range[1]) {
      throw new SyntaxError("".concat(field.name, ": ").concat(value, " is not between ").concat(range[0], " and ").concat(range[1]));
    }

    return value;
  };

  const parseRange = () => {
    let end, start, step;

    if (match('*')) {
      if (!match('/')) {
        return;
      }

      ;

      var _field$range2 = _slicedToArray(field.range, 2);

      start = _field$range2[0];
      end = _field$range2[1];
      step = parseInteger();
    } else {
      start = parseValue();

      if (!match('-')) {
        values.add(start);
        return;
      }

      end = parseValue();
      step = match('/') ? parseInteger() : 1;
    }

    for (let i = start; i <= end; i += step) {
      values.add(i);
    }
  };

  const parseSequence = () => {
    do {
      parseRange();
    } while (match(','));
  };

  const parse = p => {
    {
      const schedule = presets[p];

      if (schedule !== undefined) {
        return typeof schedule === 'string' ? presets[p] = parse(schedule) : schedule;
      }
    }

    try {
      i = 0;
      n = p.length;
      pattern = p;
      schedule = {};

      for (let j = 0; j < m; ++j) {
        consumeWhitespaces();
        field = fields[j];
        values = new Set();
        parseSequence();

        if (values.size !== 0) {
          schedule[field.name] = Array.from(values).sort(compareNumbers);
        }
      }

      consumeWhitespaces();

      if (i !== n) {
        throw new SyntaxError("unexpected character at offset ".concat(i, ", expected end"));
      }

      return schedule;
    } finally {
      field = pattern = schedule = values = undefined;
    }
  };

  return parse;
};

var _default = createParser({
  fields: [{
    name: 'minute',
    range: [0, 59]
  }, {
    name: 'hour',
    range: [0, 23]
  }, {
    name: 'dayOfMonth',
    range: [1, 31]
  }, {
    aliases: 'jan feb mar apr may jun jul aug sep oct nov dec'.split(' '),
    name: 'month',
    range: [0, 11]
  }, {
    aliases: 'sun mon tue wen thu fri sat'.split(' '),
    name: 'dayOfWeek',
    post: value => value === 7 ? 0 : value,
    range: [0, 6]
  }],
  presets: {
    '@annually': '0 0 1 jan *',
    '@daily': '0 0 * * *',
    '@hourly': '0 * * * *',
    '@monthly': '0 0 1 * *',
    '@weekly': '0 0 * * sun',
    '@yearly': '0 0 1 jan *'
  }
});

exports.default = _default;
//# sourceMappingURL=parse.js.map