Function addTerm

packages/agent-core/src/tools/cron/cron-expr.ts:130–188

(out: Set<number>, term: string, min: number, max: number, name: string)

}

function addTerm(out: Set<number>, term: string, min: number, max: number, name: string): void {
  let rangePart = term;
  let step = 1;
  const slash = term.indexOf('/');
  if (slash !== -1) {
    rangePart = term.slice(0, slash);
    const stepStr = term.slice(slash + 1);
    if (stepStr === '') {
      throw new Error(`cron ${name} step is empty in "${term}"`);
    }
    const parsedStep = parseCronInt(stepStr, name, 'step');
    if (parsedStep <= 0) {
      throw new Error(`cron ${name} step must be a positive integer (got "${stepStr}")`);
    }
    step = parsedStep;
    if (rangePart === '') {
      throw new Error(`cron ${name} step needs a range or "*" before "/" in "${term}"`);
    }
  }

  let lo: number;
  let hi: number;
  if (rangePart === '*') {
    lo = min;
    hi = max;
  } else {
    const dash = rangePart.indexOf('-');
    if (dash === -1) {
      const single = parseCronInt(rangePart, name, 'value');
      if (single < min || single > max) {
        throw new Error(`cron ${name} value ${single} out of range ${min}..${max}`);
      }
      // A bare single value with a step (`5/10`) is unusual; treat as
      // "from value through max stepping by N", which is what most cron
      // dialects do.
      if (slash !== -1) {
        lo = single;
        hi = max;
      } else {
        out.add(single);
        return;
      }
    } else {
      const loStr = rangePart.slice(0, dash);
      const hiStr = rangePart.slice(dash + 1);
      lo = parseCronInt(loStr, name, 'range lower bound');
      hi = parseCronInt(hiStr, name, 'range upper bound');
      if (lo < min || hi > max || lo > hi) {
        throw new Error(
          `cron ${name} range ${lo}-${hi} out of bounds (must be ${min}..${max}, ascending)`,
        );
      }
    }
  }

  for (let v = lo; v <= hi; v += step) {
    out.add(v);
  }