cronli5 0.1.2 → 0.1.5

package/dist/cronli5.cjs

@@ -95,6 +95,21 @@ function isNonNegativeInteger(value) {
   const digits = /^\d+$/;
   return digits.test(value);
 }
+function arithmeticStep(values) {
+  if (values.length < 5) {
+    return null;
+  }
+  const interval = values[1] - values[0];
+  if (interval < 2) {
+    return null;
+  }
+  for (let i = 2; i < values.length; i += 1) {
+    if (values[i] - values[i - 1] !== interval) {
+      return null;
+    }
+  }
+  return { start: values[0], interval, last: values[values.length - 1] };
+}
 function toFieldNumber(token, numberMap) {
   return isNonNegativeInteger(token) ? +token : numberMap[token.toUpperCase()];
 }
@@ -226,14 +241,20 @@ function normalizeField(value, field, spec) {
   }
   const cycle = timeFieldCycle[field];
   const segments = stringValue.split(",").map(function canonical(segment) {
-    return enumerateNonUniformStep(
-      collapseDegenerateRange(
-        collapseOnceStep(collapseUnitStep(segment, spec), spec),
-        spec
+    return canonicalizeTokens(collapseFullSpanRange(
+      enumerateNonUniformStep(
+        collapseFullSpanStep(
+          collapseDegenerateRange(
+            collapseOnceStep(collapseUnitStep(segment, spec), spec),
+            spec
+          ),
+          spec
+        ),
+        spec,
+        cycle
       ),
-      spec,
-      cycle
-    );
+      spec
+    ), spec);
   }).join(",").split(",");
   if (segments.indexOf("*") !== -1) {
     return "*";
@@ -242,6 +263,23 @@ function normalizeField(value, field, spec) {
     return firstFire(a, spec) - firstFire(b, spec);
   }).join(",");
 }
+function canonicalizeTokens(segment, spec) {
+  if (!spec.numbers) {
+    return segment;
+  }
+  const parts = segment.split("/");
+  const start = parts[0].split("-").map(function fold(token) {
+    return canonicalizeToken(token, spec);
+  }).join("-");
+  return parts.length === 2 ? start + "/" + parts[1] : start;
+}
+function canonicalizeToken(token, spec) {
+  if (token === "*") {
+    return token;
+  }
+  const number = toFieldNumber(token, spec.numbers);
+  return "" + (number > spec.top ? spec.min : number);
+}
 function collapseUnitStep(segment, spec) {
   const parts = segment.split("/");
   if (!spec.cyclic || parts.length !== 2 || +parts[1] !== 1) {
@@ -284,6 +322,35 @@ function enumerateNonUniformStep(segment, spec, cycle) {
   }
   return fires.join(",");
 }
+function collapseFullSpanStep(segment, spec) {
+  const parts = segment.split("/");
+  if (parts.length !== 2 || !includes(parts[0], "-")) {
+    return segment;
+  }
+  return collapseFullSpanRange(parts[0], spec) === "*" ? "*/" + parts[1] : segment;
+}
+function collapseFullSpanRange(segment, spec) {
+  if (typeof spec.top !== "number" || includes(segment, "/") || !includes(segment, "-")) {
+    return segment;
+  }
+  const bounds = segment.split("-");
+  const low = toFieldNumber(bounds[0], spec.numbers);
+  const high = toFieldNumber(bounds[1], spec.numbers);
+  if (low > high) {
+    return segment;
+  }
+  const top = spec.top;
+  const fired = {};
+  for (let value = low; value <= high; value += 1) {
+    fired[value > top ? spec.min : value] = true;
+  }
+  for (let value = spec.min; value <= top; value += 1) {
+    if (!fired[value]) {
+      return segment;
+    }
+  }
+  return "*";
+}
 function collapseDegenerateRange(segment, spec) {
   const start = segment.split("/")[0];
   if (!includes(start, "-")) {
@@ -573,7 +640,7 @@ function planStandaloneSeconds(pattern, shapes) {
   }
   return { kind: "standaloneSeconds" };
 }
-function planMinutes(pattern, shapes, analyses, subMinuteSecond = false) {
+function planMinutes(pattern, shapes, analyses, subMinuteSecond2 = false) {
   if (shapes.minute === "step") {
     return {
       hours: planFrequencyHours(pattern, shapes, analyses),
@@ -596,7 +663,7 @@ function planMinutes(pattern, shapes, analyses, subMinuteSecond = false) {
     return underStep;
   }
   if (pattern.hour === "*") {
-    return planMinutesUnderOpenHour(pattern, shapes, subMinuteSecond);
+    return planMinutesUnderOpenHour(pattern, shapes, subMinuteSecond2);
   }
 }
 function cleanHourStride(hourField) {
@@ -618,6 +685,9 @@ function planMinuteUnderHourStep(pattern, shapes) {
   if (shapes.minute === "range") {
     return { form: "range", kind: "minuteSpanAcrossHourStep" };
   }
+  if (shapes.minute === "list" && cleanHourStride(pattern.hour)) {
+    return { form: "list", kind: "minuteSpanAcrossHourStep" };
+  }
   return null;
 }
 function planFrequencyHours(pattern, shapes, analyses) {
@@ -666,7 +736,7 @@ function planMinutesAcrossHours(pattern, shapes) {
   }
   return null;
 }
-function planMinutesUnderOpenHour(pattern, shapes, subMinuteSecond) {
+function planMinutesUnderOpenHour(pattern, shapes, subMinuteSecond2) {
   if (shapes.minute === "range") {
     return { kind: "rangeOfMinutes" };
   }
@@ -676,16 +746,16 @@ function planMinutesUnderOpenHour(pattern, shapes, subMinuteSecond) {
   if (pattern.minute === "*") {
     return { kind: "everyMinute" };
   }
-  if (pattern.minute !== "0" || subMinuteSecond) {
+  if (pattern.minute !== "0" || subMinuteSecond2) {
     return { kind: "singleMinute" };
   }
 }
-function planHours(pattern, shapes, analyses, subMinuteSecond = false) {
-  const absorbsMinuteZero = subMinuteSecond && pattern.minute === "0";
+function planHours(pattern, shapes, analyses, subMinuteSecond2 = false) {
+  const absorbsMinuteZero = subMinuteSecond2 && pattern.minute === "0";
   if (shapes.hour === "range" && !absorbsMinuteZero) {
     return planHourRange(pattern, shapes, analyses);
   }
-  if (shapes.hour === "step" && pattern.minute === "0" && !subMinuteSecond) {
+  if (shapes.hour === "step" && pattern.minute === "0" && !subMinuteSecond2) {
     return { kind: "hourStep" };
   }
   if (pattern.hour === "*" && !absorbsMinuteZero) {
@@ -852,20 +922,6 @@ var weekdayNames = [
   ["Friday", "Fri"],
   ["Saturday", "Sat"]
 ];
-var monthAbbreviations = {
-  JAN: monthNames[1],
-  FEB: monthNames[2],
-  MAR: monthNames[3],
-  APR: monthNames[4],
-  MAY: monthNames[5],
-  JUN: monthNames[6],
-  JUL: monthNames[7],
-  AUG: monthNames[8],
-  SEP: monthNames[9],
-  OCT: monthNames[10],
-  NOV: monthNames[11],
-  DEC: monthNames[12]
-};
 var weekdayAbbreviations = {
   SUN: weekdayNames[0],
   MON: weekdayNames[1],
@@ -914,10 +970,50 @@ function renderSecondsWithinMinute(ir, plan, opts) {
   }
   return secondsLeadClause(ir, opts) + ", " + minuteWord + " " + minuteUnit + " past the hour, every hour" + trailingQualifier(ir, opts);
 }
+function composeHourCadence(ir, plan, opts) {
+  const clockRest = plan.rest.kind === "clockTimes" || plan.rest.kind === "compactClockTimes";
+  return clockRest && ir.shapes.minute === "single" ? hourCadence(ir, +ir.pattern.minute, opts) : null;
+}
 function renderComposeSeconds(ir, plan, opts) {
+  const cadence = composeHourCadence(ir, plan, opts);
+  if (cadence !== null) {
+    return cadence;
+  }
+  if (plan.rest.kind === "clockTimes" && (ir.shapes.second === "wildcard" || ir.shapes.second === "step")) {
+    const minute = plan.rest.times[0].minute;
+    if (+minute === 0) {
+      return secondsLeadClause(ir, opts) + " for one minute at " + durationHours(ir, plan.rest, opts);
+    }
+    return secondsLeadClause(ir, opts) + " of " + clockTimesOf(ir, plan.rest, opts);
+  }
+  if (ir.shapes.second === "wildcard" && plan.rest.kind === "minuteFrequency" && plan.rest.hours.kind === "none" && ir.pattern.minute === "*/2") {
+    return "every second of every other minute" + trailingQualifier(ir, opts);
+  }
   return secondsLeadClause(ir, opts) + ", " + render(ir, plan.rest, opts);
 }
+function durationHours(ir, plan, opts) {
+  const hours = plan.times.map(function clock(time) {
+    return getTime({ hour: time.hour, minute: 0 }, opts);
+  });
+  const trail = dayQualifier(ir, leadingWords, opts);
+  return joinList(hours, opts) + (trail && ", " + trail);
+}
+function clockTimesOf(ir, plan, opts) {
+  const times = plan.times.map(function clock(time) {
+    return getTime({
+      hour: time.hour,
+      minute: time.minute,
+      second: time.second,
+      explicit: true
+    }, opts);
+  });
+  const trail = dayQualifier(ir, leadingWords, opts);
+  return joinList(times, opts) + (trail && ", " + trail);
+}
 function secondsLeadClause(ir, opts) {
+  return secondsClause(ir, "minute", opts);
+}
+function secondsClause(ir, anchor, opts) {
   const secondField = ir.pattern.second;
   const shape = ir.shapes.second;
   if (secondField === "*") {
@@ -927,22 +1023,27 @@ function secondsLeadClause(ir, opts) {
     return stepCycle60(
       ir.analyses.segments.second[0],
       "second",
-      "minute",
+      anchor,
       opts
     );
   }
   if (shape === "range") {
     const bounds = secondField.split("-");
     const num = seriesNumber(bounds, opts);
-    return "every second from " + num(bounds[0]) + through(opts) + num(bounds[1]) + " past the minute";
+    return "every second from " + num(bounds[0]) + through(opts) + num(bounds[1]) + " past the " + anchor;
   }
   if (shape === "single") {
-    return "at " + getNumber(secondField, opts) + " " + pluralize(secondField, "second") + " past the minute";
+    return "at " + getNumber(secondField, opts) + " " + pluralize(secondField, "second") + " past the " + anchor;
   }
-  return listPastThe(
+  return strideFromSegments(
+    ir.analyses.segments.second,
+    "second",
+    anchor,
+    opts
+  ) ?? listPastThe(
     segmentWords(ir.analyses.segments.second, opts),
     "second",
-    "minute",
+    anchor,
     opts
   );
 }
@@ -957,12 +1058,11 @@ function renderRangeOfMinutes(ir, plan, opts) {
   return minuteRangeLead(ir.pattern.minute, opts) + trailingQualifier(ir, opts);
 }
 function renderMultipleMinutes(ir, plan, opts) {
-  return listPastThe(
-    segmentWords(ir.analyses.segments.minute, opts),
-    "minute",
-    "hour",
+  const stride = strideFromSegments(ir.analyses.segments.minute, "minute", "hour", opts);
+  return (stride ?? listPastThe(segmentWords(
+    ir.analyses.segments.minute,
     opts
-  ) + trailingQualifier(ir, opts);
+  ), "minute", "hour", opts)) + trailingQualifier(ir, opts);
 }
 function renderMinuteFrequency(ir, plan, opts) {
   let phrase = stepCycle60(
@@ -981,6 +1081,9 @@ function renderMinuteFrequency(ir, plan, opts) {
   return phrase + trailingQualifier(ir, opts);
 }
 function renderMinuteSpanInHour(ir, plan, opts) {
+  if (ir.pattern.minute === "*") {
+    return "every minute of the " + getTime({ hour: plan.hour, minute: 0 }, opts) + " hour" + trailingQualifier(ir, opts);
+  }
   return "every minute from " + getTime({ hour: plan.hour, minute: plan.span[0] }, opts) + through(opts) + getTime({ hour: plan.hour, minute: plan.span[1] }, opts) + trailingQualifier(ir, opts);
 }
 function renderMinutesAcrossHours(ir, plan, opts) {
@@ -989,8 +1092,9 @@ function renderMinutesAcrossHours(ir, plan, opts) {
   }
   const times = hourTimesFromPlan(ir, plan.times, true, opts);
   const lead = plan.form === "range" ? minuteRangeLead(ir.pattern.minute, opts) : (
-    // The 'list' form is a minute list, which has segments.
-    listPastThe(
+    // The 'list' form is a minute list, which has segments; an offset/uneven
+    // step enumerated to that list reads as a stride.
+    strideFromSegments(ir.analyses.segments.minute, "minute", "hour", opts) ?? listPastThe(
       segmentWords(ir.analyses.segments.minute, opts),
       "minute",
       "hour",
@@ -1017,7 +1121,13 @@ function renderMinuteSpanAcrossHourStep(ir, plan, opts) {
   if (plan.form === "wildcard") {
     return "every minute " + everyNthHour(segment, opts) + trailingQualifier(ir, opts);
   }
-  return minuteRangeLead(ir.pattern.minute, opts) + ", " + stepHours(segment, opts) + trailingQualifier(ir, opts);
+  const lead = plan.form === "list" ? strideFromSegments(ir.analyses.segments.minute, "minute", "hour", opts) ?? listPastThe(
+    segmentWords(ir.analyses.segments.minute, opts),
+    "minute",
+    "hour",
+    opts
+  ) : minuteRangeLead(ir.pattern.minute, opts);
+  return lead + ", " + stepHours(segment, opts) + trailingQualifier(ir, opts);
 }
 function minuteRangeLead(minuteField, opts) {
   const bounds = minuteField.split("-");
@@ -1041,7 +1151,12 @@ function rangeMinuteLead(ir, opts) {
   if (ir.pattern.minute === "0") {
     return "every hour";
   }
-  return listPastThe(
+  return strideFromSegments(
+    ir.analyses.segments.minute,
+    "minute",
+    "hour",
+    opts
+  ) ?? listPastThe(
     segmentWords(ir.analyses.segments.minute, opts),
     "minute",
     "hour",
@@ -1058,6 +1173,12 @@ function hourWindow(window, opts) {
   return "from " + getTime({ hour: window.from, minute: 0 }, opts) + through(opts) + getTime({ hour: window.to, minute: window.last }, opts);
 }
 function renderClockTimes(ir, plan, opts) {
+  if (ir.shapes.minute === "single") {
+    const cadence = hourCadence(ir, +ir.pattern.minute, opts);
+    if (cadence !== null) {
+      return cadence;
+    }
+  }
   const plain = mixedTwelve(plan.times);
   const times = plan.times.map(function clock(time) {
     return getTime({
@@ -1071,6 +1192,10 @@ function renderClockTimes(ir, plan, opts) {
 }
 function renderCompactClockTimes(ir, plan, opts) {
   if (plan.fold) {
+    const cadence = hourCadence(ir, +plan.minute, opts);
+    if (cadence !== null) {
+      return cadence;
+    }
     const hasRange = ir.analyses.segments.hour.some(function range(segment) {
       return segment.kind === "range";
     });
@@ -1081,13 +1206,14 @@ function renderCompactClockTimes(ir, plan, opts) {
     return interpretDayQualifier(ir, opts) + "at " + hourSegmentTimes(ir, fold, true, opts);
   }
   const phrase = (
-    // The non-fold branch is a minute list, which has segments.
-    listPastThe(
+    // The non-fold branch is a minute list, which has segments. An
+    // offset/uneven step enumerated to that list reads as a stride.
+    (strideFromSegments(ir.analyses.segments.minute, "minute", "hour", opts) ?? listPastThe(
       segmentWords(ir.analyses.segments.minute, opts),
       "minute",
       "hour",
       opts
-    ) + ", at " + hourSegmentTimes(ir, { minute: 0, second: null }, true, opts) + trailingQualifier(ir, opts)
+    )) + ", at " + hourSegmentTimes(ir, { minute: 0, second: null }, true, opts) + trailingQualifier(ir, opts)
   );
   return ir.analyses.clockSecond ? secondsLeadClause(ir, opts) + ", " + phrase : phrase;
 }
@@ -1135,24 +1261,50 @@ var renderers = {
   singleMinute: renderSingleMinute,
   standaloneSeconds: renderStandaloneSeconds
 };
+function renderStride(stride, opts) {
+  const { interval, start, last, cycle, unit, anchor } = stride;
+  const cadence = "every " + getNumber(interval, opts) + " " + unit + "s";
+  const tiles = cycle % interval === 0;
+  if (start === 0 && tiles) {
+    return cadence;
+  }
+  if (start < interval && tiles) {
+    return cadence + " from " + getNumber(start, opts) + " " + pluralize(start, unit) + " past the " + anchor;
+  }
+  const num = seriesNumber([start, last], opts);
+  return cadence + " from " + num(start) + through(opts) + num(last) + " " + pluralize(last, unit) + " past the " + anchor;
+}
+function singleValues(segments) {
+  const values = [];
+  for (const segment of segments) {
+    if (segment.kind !== "single") {
+      return null;
+    }
+    values.push(+segment.value);
+  }
+  return values;
+}
+function strideFromSegments(segments, unit, anchor, opts) {
+  const values = singleValues(segments);
+  const step = values && arithmeticStep(values);
+  return step ? renderStride({ ...step, cycle: 60, unit, anchor }, opts) : null;
+}
 function stepCycle60(segment, unit, anchor, opts) {
   if (segment.startToken.indexOf("-") !== -1) {
     return listPastThe(numberWords(segment.fires, opts), unit, anchor, opts);
   }
   const start = segment.startToken === "*" ? 0 : +segment.startToken;
-  const interval = segment.interval;
-  if (start !== 0) {
-    if (segment.fires.length <= 3) {
-      return listPastThe(
-        numberWords(segment.fires, opts),
-        unit,
-        anchor,
-        opts
-      );
-    }
-    return "every " + getNumber(interval, opts) + " " + unit + "s from " + getNumber(start, opts) + " " + pluralize(start, unit) + " past the " + anchor;
+  if (start !== 0 && segment.fires.length <= 3) {
+    return listPastThe(numberWords(segment.fires, opts), unit, anchor, opts);
   }
-  return "every " + getNumber(interval, opts) + " " + unit + "s";
+  return renderStride({
+    interval: segment.interval,
+    start,
+    last: segment.fires[segment.fires.length - 1],
+    cycle: 60,
+    unit,
+    anchor
+  }, opts);
 }
 function stepHours(segment, opts) {
   if (segment.startToken.indexOf("-") !== -1) {
@@ -1168,6 +1320,68 @@ function stepHours(segment, opts) {
   }
   return "every " + getNumber(interval, opts) + " hours from " + getTime({ hour: start, minute: 0 }, opts);
 }
+function hourStrideCadence(stride, opts) {
+  const { start, interval, last } = stride;
+  const cadence = "every " + getNumber(interval, opts) + " hours";
+  const tiles = 24 % interval === 0;
+  if (start === 0 && tiles) {
+    return cadence;
+  }
+  if (start < interval && tiles) {
+    return cadence + " from " + getTime({ hour: start, minute: 0 }, opts);
+  }
+  return cadence + " from " + getTime({ hour: start, minute: 0 }, opts) + through(opts) + getTime({ hour: last, minute: 0 }, opts);
+}
+function hourStride(ir) {
+  const segments = ir.analyses.segments.hour;
+  if (segments.length === 1 && segments[0].kind === "step") {
+    const segment = segments[0];
+    const start = segment.startToken === "*" ? 0 : +segment.startToken.split("-")[0];
+    return { interval: segment.interval, last: segment.fires[segment.fires.length - 1], start };
+  }
+  const values = singleValues(segments);
+  const step = values && arithmeticStep(values);
+  return step || null;
+}
+function subMinuteSecond(ir) {
+  return ir.pattern.second === "*" || ir.shapes.second === "step";
+}
+function hourCadenceLead(ir, minute, opts) {
+  if (minute === 0) {
+    if (subMinuteSecond(ir)) {
+      return secondsClause(ir, "minute", opts) + " for one minute";
+    }
+    return secondsClause(ir, "hour", opts);
+  }
+  const minutePhrase = getNumber(minute, opts) + " " + pluralize(minute, "minute") + " past the hour";
+  if (ir.pattern.second === "0") {
+    return minutePhrase;
+  }
+  return secondsClause(ir, "minute", opts) + ", " + minutePhrase;
+}
+function hourCadence(ir, minute, opts) {
+  const stride = hourStride(ir);
+  if (!stride) {
+    return null;
+  }
+  const fires = (stride.last - stride.start) / stride.interval + 1;
+  if (ir.pattern.second === "0" && fires <= maxClockTimes) {
+    return null;
+  }
+  const confinement = minute === 0 && subMinuteSecond(ir) && cleanStrideSegment(ir);
+  if (confinement) {
+    return secondsClause(ir, "minute", opts) + " for one minute " + everyNthHour(confinement, opts) + trailingQualifier(ir, opts);
+  }
+  return hourCadenceLead(ir, minute, opts) + ", " + hourStrideCadence(stride, opts) + trailingQualifier(ir, opts);
+}
+function cleanStrideSegment(ir) {
+  const segments = ir.analyses.segments.hour;
+  const segment = segments.length === 1 && segments[0];
+  if (!segment || segment.kind !== "step" || segment.startToken.indexOf("-") !== -1 || !(segment.interval in stepOrdinals)) {
+    return null;
+  }
+  return segment;
+}
 function seriesNumber(values, opts) {
   const anyBig = values.some(function big(v) {
     return +v > 10;
@@ -1479,7 +1693,7 @@ function stepYears(yearField, opts) {
   return phrase;
 }
 function getTime(time, opts) {
-  const { hour, minute, plain } = time;
+  const { hour, minute, plain, explicit } = time;
   const second = typeof time.second === "number" && time.second > 0 ? time.second : 0;
   if (!opts.ampm) {
     return clockDigits({
@@ -1488,12 +1702,12 @@ function getTime(time, opts) {
       second
     }, { pad: true, sep: opts.style.sep });
   }
-  return twelveHourTime({ hour, minute, second, plain }, opts);
+  return twelveHourTime({ hour, minute, second, plain, explicit }, opts);
 }
 function twelveHourTime(time, opts) {
-  const { hour, minute, second, plain } = time;
+  const { hour, minute, second, plain, explicit } = time;
   const style = opts.style;
-  if (!plain && +minute === 0 && !second) {
+  if (!plain && !explicit && +minute === 0 && !second) {
     if (+hour === 0) {
       return style.midnight;
     }
@@ -1503,7 +1717,7 @@ function twelveHourTime(time, opts) {
   }
   const digits = clockDigits(
     { hour: hour % 12 || 12, minute, second },
-    { lean: true, sep: style.sep }
+    { lean: !explicit, sep: style.sep }
   );
   return digits + (style.closeUp ? "" : " ") + (hour < 12 ? style.am : style.pm);
 }
@@ -1526,7 +1740,7 @@ function getOrdinal(n) {
   return n + suffix;
 }
 function getMonth(m, opts) {
-  const month = monthNames[m] || monthAbbreviations[m];
+  const month = monthNames[+m];
   return month && month[opts.short ? 1 : 0];
 }
 function getWeekday(d, opts) {
@@ -1539,7 +1753,9 @@ var en = {
   fallback: "an unrecognizable cron pattern",
   options: normalizeOptions,
   reboot: "at system startup",
-  sentence: (description) => "Runs " + description + "."
+  // A description ending in an abbreviation already carries its period
+  // ("…9 a.m."), so closing the sentence must not double it.
+  sentence: (description) => "Runs " + description + (description.endsWith(".") ? "" : ".")
 };
 var en_default = en;