cronli5 0.1.4 → 0.1.6

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()];
 }
@@ -625,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),
@@ -648,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) {
@@ -670,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) {
@@ -718,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" };
   }
@@ -728,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) {
@@ -952,18 +970,34 @@ 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";
+  if (!clockRest || ir.shapes.minute !== "single") {
+    return null;
+  }
+  const minute = +ir.pattern.minute;
+  return hourCadence(ir, minute, opts) ?? hourRangeCadence(ir, minute, opts);
+}
+function clockTimesConfinement(ir, rest, opts) {
+  if (+rest.times[0].minute === 0 && ir.shapes.minute === "single") {
+    return secondsLeadClause(ir, opts) + " for one minute at " + durationHours(ir, rest, opts);
+  }
+  return secondsLeadClause(ir, opts) + " of " + clockTimesOf(ir, rest, opts);
+}
 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);
+    return clockTimesConfinement(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);
+  const restOwnsLead = plan.rest.kind === "compactClockTimes" && ir.analyses.clockSecond;
+  const lead = restOwnsLead ? "" : secondsLeadClause(ir, opts) + ", ";
+  return lead + render(ir, plan.rest, opts);
 }
 function durationHours(ir, plan, opts) {
   const hours = plan.times.map(function clock(time) {
@@ -985,6 +1019,9 @@ function clockTimesOf(ir, plan, 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 === "*") {
@@ -994,22 +1031,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
   );
 }
@@ -1024,12 +1066,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(
@@ -1039,7 +1080,8 @@ function renderMinuteFrequency(ir, plan, opts) {
     opts
   );
   if (plan.hours.kind === "during") {
-    phrase += " during the " + hourTimesFromPlan(ir, plan.hours.times, false, opts) + " hours";
+    const cadence = unevenHourCadence(ir, opts);
+    phrase += cadence ? ", " + cadence : " during the " + hourTimesFromPlan(ir, plan.hours.times, false, opts) + " hours";
   } else if (plan.hours.kind === "window") {
     phrase += " " + hourWindow(plan.hours, opts);
   } else if (plan.hours.kind === "step") {
@@ -1054,19 +1096,27 @@ function renderMinuteSpanInHour(ir, plan, 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) {
+  const cadence = unevenHourCadence(ir, opts);
   if (plan.form === "wildcard") {
+    if (cadence !== null) {
+      return "every minute, " + cadence + trailingQualifier(ir, opts);
+    }
     return "every minute during the " + hourTimesFromPlan(ir, plan.times, false, opts) + " hours" + trailingQualifier(ir, 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",
       opts
     )
   );
+  if (cadence !== null) {
+    return lead + ", " + cadence + trailingQualifier(ir, opts);
+  }
+  const times = hourTimesFromPlan(ir, plan.times, true, opts);
   return lead + ", at " + times + trailingQualifier(ir, opts);
 }
 var stepOrdinals = {
@@ -1087,7 +1137,14 @@ 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);
+  const cadence = unevenHourCadence(ir, opts);
+  return lead + ", " + (cadence ?? stepHours(segment, opts)) + trailingQualifier(ir, opts);
 }
 function minuteRangeLead(minuteField, opts) {
   const bounds = minuteField.split("-");
@@ -1111,7 +1168,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",
@@ -1119,6 +1181,10 @@ function rangeMinuteLead(ir, opts) {
   );
 }
 function renderHourStep(ir, plan, opts) {
+  const cadence = unevenHourCadence(ir, opts);
+  if (cadence !== null) {
+    return cadence + trailingQualifier(ir, opts);
+  }
   return stepHours(ir.analyses.segments.hour[0], opts) + trailingQualifier(ir, opts);
 }
 function boundedWindow(plan) {
@@ -1128,6 +1194,13 @@ 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 minute = +ir.pattern.minute;
+    const cadence = hourCadence(ir, minute, opts) ?? hourRangeCadence(ir, minute, opts);
+    if (cadence !== null) {
+      return cadence;
+    }
+  }
   const plain = mixedTwelve(plan.times);
   const times = plan.times.map(function clock(time) {
     return getTime({
@@ -1141,6 +1214,10 @@ function renderClockTimes(ir, plan, opts) {
 }
 function renderCompactClockTimes(ir, plan, opts) {
   if (plan.fold) {
+    const cadence2 = hourCadence(ir, +plan.minute, opts) ?? hourRangeCadence(ir, +plan.minute, opts);
+    if (cadence2 !== null) {
+      return cadence2;
+    }
     const hasRange = ir.analyses.segments.hour.some(function range(segment) {
       return segment.kind === "range";
     });
@@ -1150,15 +1227,18 @@ function renderCompactClockTimes(ir, plan, opts) {
     const fold = { minute: plan.minute, second: ir.analyses.clockSecond };
     return interpretDayQualifier(ir, opts) + "at " + hourSegmentTimes(ir, fold, true, opts);
   }
-  const phrase = (
-    // The non-fold branch is a minute list, which has segments.
-    listPastThe(
+  const minuteLead = (
+    // 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)
+    )
   );
+  const cadence = unevenHourCadence(ir, opts);
+  const phrase = cadence ? minuteLead + ", " + cadence + trailingQualifier(ir, opts) : minuteLead + ", at " + hourSegmentTimes(ir, { minute: 0, second: null }, true, opts) + trailingQualifier(ir, opts);
   return ir.analyses.clockSecond ? secondsLeadClause(ir, opts) + ", " + phrase : phrase;
 }
 function foldedHourWindows(ir, plan, opts) {
@@ -1205,24 +1285,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) {
@@ -1238,6 +1344,141 @@ 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 offsetCleanStride(stride) {
+  return stride.start < stride.interval && 24 % stride.interval === 0;
+}
+function unevenHourCadence(ir, opts) {
+  const stride = hourStride(ir);
+  if (!stride || offsetCleanStride(stride)) {
+    return null;
+  }
+  return hourStrideCadence(stride, opts);
+}
+function hourListStride(values) {
+  if (values.length < 2) {
+    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;
+    }
+  }
+  if (values[0] !== 0 && values.length < 5) {
+    return null;
+  }
+  return { interval, last: values[values.length - 1], start: values[0] };
+}
+function hourStride(ir) {
+  const segments = ir.analyses.segments.hour;
+  if (segments.length === 1 && segments[0].kind === "step") {
+    const segment = segments[0];
+    if (segment.fires.length < 2) {
+      return null;
+    }
+    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);
+  return values && hourListStride(values);
+}
+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 && offsetCleanStride(stride)) {
+    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);
+  }
+  if (minute === 0 && ir.pattern.second === "0") {
+    return hourStrideCadence(stride, 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 hasHourWindow(ir) {
+  return ir.analyses.segments.hour.some(function range(segment) {
+    return segment.kind === "range";
+  });
+}
+function hourRangeWindowTail(ir, opts) {
+  const windows = [];
+  const singles = [];
+  ir.analyses.segments.hour.forEach(function classify(segment) {
+    if (segment.kind === "range") {
+      windows.push("from " + getTime(
+        { hour: +segment.bounds[0], minute: 0 },
+        opts
+      ) + through(opts) + getTime({ hour: +segment.bounds[1], minute: 0 }, opts));
+    } else if (segment.kind === "step") {
+      singles.push(...segment.fires);
+    } else {
+      singles.push(+segment.value);
+    }
+  });
+  let phrase = "every hour " + joinList(windows, opts);
+  if (singles.length) {
+    phrase += " and at " + joinList(singles.map(function time(hour) {
+      return getTime({ hour, minute: 0 }, opts);
+    }), opts);
+  }
+  return phrase;
+}
+function hourRangeCadence(ir, minute, opts) {
+  if (minute !== 0 || !hasHourWindow(ir)) {
+    return null;
+  }
+  if (ir.pattern.second === "0") {
+    return null;
+  }
+  if (subMinuteSecond(ir)) {
+    return secondsClause(ir, "minute", opts) + " for one minute during the " + hourSegmentTimes(ir, { minute: 0, second: null }, false, opts) + " hours" + trailingQualifier(ir, opts);
+  }
+  return hourCadenceLead(ir, minute, opts) + ", " + hourRangeWindowTail(ir, opts) + trailingQualifier(ir, opts);
+}
 function seriesNumber(values, opts) {
   const anyBig = values.some(function big(v) {
     return +v > 10;