cronli5 0.1.5 → 0.1.6

package/dist/cronli5.js

@@ -946,7 +946,17 @@ function renderSecondsWithinMinute(ir, plan, 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;
+  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);
@@ -954,16 +964,14 @@ function renderComposeSeconds(ir, plan, opts) {
     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) {
@@ -1046,7 +1054,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") {
@@ -1061,10 +1070,13 @@ 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; an offset/uneven
     // step enumerated to that list reads as a stride.
@@ -1075,6 +1087,10 @@ function renderMinutesAcrossHours(ir, plan, opts) {
       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 = {
@@ -1101,7 +1117,8 @@ function renderMinuteSpanAcrossHourStep(ir, plan, opts) {
     "hour",
     opts
   ) : minuteRangeLead(ir.pattern.minute, opts);
-  return lead + ", " + stepHours(segment, opts) + trailingQualifier(ir, opts);
+  const cadence = unevenHourCadence(ir, opts);
+  return lead + ", " + (cadence ?? stepHours(segment, opts)) + trailingQualifier(ir, opts);
 }
 function minuteRangeLead(minuteField, opts) {
   const bounds = minuteField.split("-");
@@ -1138,6 +1155,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) {
@@ -1148,7 +1169,8 @@ function hourWindow(window, opts) {
 }
 function renderClockTimes(ir, plan, opts) {
   if (ir.shapes.minute === "single") {
-    const cadence = hourCadence(ir, +ir.pattern.minute, opts);
+    const minute = +ir.pattern.minute;
+    const cadence = hourCadence(ir, minute, opts) ?? hourRangeCadence(ir, minute, opts);
     if (cadence !== null) {
       return cadence;
     }
@@ -1166,9 +1188,9 @@ 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 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";
@@ -1179,16 +1201,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 = (
+  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(
+    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) {
@@ -1306,16 +1330,46 @@ function hourStrideCadence(stride, 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);
-  const step = values && arithmeticStep(values);
-  return step || null;
+  return values && hourListStride(values);
 }
 function subMinuteSecond(ir) {
   return ir.pattern.second === "*" || ir.shapes.second === "step";
@@ -1339,13 +1393,16 @@ function hourCadence(ir, minute, opts) {
     return null;
   }
   const fires = (stride.last - stride.start) / stride.interval + 1;
-  if (ir.pattern.second === "0" && fires <= maxClockTimes) {
+  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) {
@@ -1356,6 +1413,46 @@ function cleanStrideSegment(ir) {
   }
   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;

package/dist/lang/de.cjs

@@ -458,9 +458,17 @@ function renderMinuteSpanInHour(ir, plan, opts) {
   const sep = opts.style.sep;
   return "jede Minute von " + spanTime(plan.hour, plan.span[0], sep) + " bis " + spanTime(plan.hour, plan.span[1], sep) + " Uhr";
 }
+function isEveryOtherMinuteSeconds(ir, plan) {
+  if (plan.rest.kind !== "minuteFrequency" || ir.shapes.second !== "wildcard" || ir.shapes.hour !== "wildcard") {
+    return false;
+  }
+  const minuteStep = stepSegment(ir.analyses.segments.minute);
+  return minuteStep.startToken === "*" && minuteStep.interval === 2;
+}
 function renderComposeSeconds(ir, plan, opts) {
   if ((plan.rest.kind === "clockTimes" || plan.rest.kind === "compactClockTimes") && ir.shapes.minute === "single") {
-    const cadence = hourCadence(ir, +ir.pattern.minute);
+    const minute = +ir.pattern.minute;
+    const cadence = hourCadence(ir, minute) ?? hourRangeCadence(ir, minute);
     if (cadence !== null) {
       return cadence;
     }
@@ -468,13 +476,12 @@ function renderComposeSeconds(ir, plan, opts) {
   if (composeMinuteZero(ir, plan)) {
     return secondsLead(ir) + " " + clockMinuteGenitive(plan.rest.times, opts.style.sep);
   }
-  if (plan.rest.kind === "minuteFrequency" && ir.shapes.second === "wildcard" && ir.shapes.hour === "wildcard") {
-    const minuteStep = stepSegment(ir.analyses.segments.minute);
-    if (minuteStep.startToken === "*" && minuteStep.interval === 2) {
-      return secondsLead(ir) + " jeder zweiten Minute";
-    }
+  if (isEveryOtherMinuteSeconds(ir, plan)) {
+    return secondsLead(ir) + " jeder zweiten Minute";
   }
-  return secondsLead(ir) + ", " + render(ir, plan.rest, opts);
+  const restOwnsLead = plan.rest.kind === "compactClockTimes" && ir.analyses.clockSecond;
+  const lead = restOwnsLead ? "" : secondsLead(ir) + ", ";
+  return lead + render(ir, plan.rest, opts);
 }
 function composeMinuteZero(ir, plan) {
   return plan.rest.kind === "clockTimes" && plan.rest.times.every((time) => +time.minute === 0);
@@ -487,31 +494,37 @@ function clockMinuteGenitive(times, sep) {
 }
 function renderMinutesAcrossHours(ir, plan, opts) {
   const sep = opts.style.sep;
+  const cadence = unevenHourCadence(ir);
   if (plan.form === "wildcard") {
-    return "jede Minute " + duringHours(ir, plan.times, sep);
+    return cadence ? "jede Minute, " + cadence : "jede Minute " + duringHours(ir, plan.times, sep);
+  }
+  const minuteLead = strideFromSegments(fieldSegments(ir, "minute"), UNITS.minute, "") ?? countedPhrase(ir, "minute", "Minute", "Minuten");
+  if (cadence !== null) {
+    return minuteLead + ", " + cadence;
   }
   const hours = plan.times.kind === "fires" ? atHours(plan.times.fires) : joinList(hourSegmentParts(ir, 0, 0, sep));
-  return (strideFromSegments(fieldSegments(ir, "minute"), UNITS.minute, "") ?? countedPhrase(ir, "minute", "Minute", "Minuten")) + ", " + hours;
+  return minuteLead + ", " + hours;
 }
 function renderMinuteSpanAcrossHourStep(ir, plan) {
+  const cadence = unevenHourCadence(ir);
   if (plan.form === "wildcard") {
     return "jede Minute " + everyNthHour(stepSegment(ir.analyses.segments.hour));
   }
   const segment = stepSegment(ir.analyses.segments.hour);
-  const hours = confinedHourStride(segment) ? everyNthHour(segment) : atHours(segment.fires);
+  const hours = cadence ?? (confinedHourStride(segment) ? everyNthHour(segment) : atHours(segment.fires));
   return (strideFromSegments(fieldSegments(ir, "minute"), UNITS.minute, "") ?? countedPhrase(ir, "minute", "Minute", "Minuten")) + ", " + hours;
 }
 function renderCompactClockTimes(ir, plan, opts) {
   const sep = opts.style.sep;
   if (plan.fold) {
-    const cadence = hourCadence(ir, plan.minute);
+    const cadence = hourCadence(ir, plan.minute) ?? hourRangeCadence(ir, plan.minute);
     if (cadence !== null) {
       return cadence;
     }
     const hourly = fieldSegments(ir, "hour").some((segment) => segment.kind === "range");
     return (hourly ? "st\xFCndlich " : "t\xE4glich ") + joinList(hourSegmentParts(ir, plan.minute, ir.analyses.clockSecond, sep));
   }
-  const hours = fieldSegments(ir, "hour").some((segment) => segment.kind === "range") ? joinList(hourSegmentParts(ir, 0, 0, sep)) : atHours(hourFires(ir));
+  const hours = unevenHourCadence(ir) ?? (fieldSegments(ir, "hour").some((segment) => segment.kind === "range") ? joinList(hourSegmentParts(ir, 0, 0, sep)) : atHours(hourFires(ir)));
   const lead = ir.analyses.clockSecond ? countedPhrase(ir, "second", "Sekunde", "Sekunden") + ", " : "";
   return lead + (strideFromSegments(fieldSegments(ir, "minute"), UNITS.minute, "") ?? countedPhrase(ir, "minute", "Minute", "Minuten")) + ", " + hours;
 }
@@ -530,7 +543,8 @@ function renderMinuteFrequency(ir, plan, opts) {
     return clean ? base + " " + window : base + ", " + window;
   }
   if (plan.hours.kind === "during") {
-    return base + " " + duringHours(ir, plan.hours.times, sep);
+    const cadence = unevenHourCadence(ir);
+    return cadence ? base + ", " + cadence : base + " " + duringHours(ir, plan.hours.times, sep);
   }
   if (plan.hours.kind === "step") {
     return base + " " + everyNthHour(stepSegment(ir.analyses.segments.hour));
@@ -538,6 +552,10 @@ function renderMinuteFrequency(ir, plan, opts) {
   return base;
 }
 function hourStepPhrase(ir) {
+  const cadence = unevenHourCadence(ir);
+  if (cadence !== null) {
+    return cadence;
+  }
   const segment = stepSegment(ir.analyses.segments.hour);
   return cleanStep(segment, 24) ? everyN(segment.interval, UNITS.hour) : atHours(segment.fires);
 }
@@ -553,6 +571,27 @@ function hourStrideCadence(stride) {
   }
   return cadence + " von " + start + " bis " + last + " Uhr";
 }
+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 offsetCleanStride(stride) {
+  return stride.start < stride.interval && 24 % stride.interval === 0;
+}
 function hourStride(ir) {
   const segments = fieldSegments(ir, "hour");
   if (!segments) {
@@ -560,12 +599,21 @@ function hourStride(ir) {
   }
   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);
-  const step = values && arithmeticStep(values);
-  return step || null;
+  return values && hourListStride(values);
+}
+function unevenHourCadence(ir) {
+  const stride = hourStride(ir);
+  if (!stride || offsetCleanStride(stride)) {
+    return null;
+  }
+  return hourStrideCadence(stride);
 }
 function subMinuteSecond(ir) {
   return ir.pattern.second === "*" || ir.shapes.second === "step";
@@ -589,7 +637,7 @@ function hourCadence(ir, minute) {
     return null;
   }
   const fires = (stride.last - stride.start) / stride.interval + 1;
-  if (ir.pattern.second === "0" && fires <= maxClockTimes) {
+  if (ir.pattern.second === "0" && fires <= maxClockTimes && offsetCleanStride(stride)) {
     return null;
   }
   const segment = fieldSegments(ir, "hour")[0];
@@ -597,10 +645,32 @@ function hourCadence(ir, minute) {
   if (confined) {
     return secondsClause(ir, "jeder Minute") + " f\xFCr eine Minute " + everyNthHour(segment);
   }
+  if (minute === 0 && ir.pattern.second === "0") {
+    return hourStrideCadence(stride);
+  }
   return hourCadenceLead(ir, minute) + ", " + hourStrideCadence(stride);
 }
 function hourCadenceApplies(ir) {
-  return ir.shapes.minute === "single" && hourCadence(ir, +ir.pattern.minute) !== null;
+  if (ir.shapes.minute !== "single") {
+    return false;
+  }
+  const minute = +ir.pattern.minute;
+  return hourCadence(ir, minute) !== null || hourRangeCadence(ir, minute) !== null;
+}
+function hasHourWindow(ir) {
+  const segments = fieldSegments(ir, "hour");
+  return !!segments && segments.some(function range(segment) {
+    return segment.kind === "range";
+  });
+}
+function hourRangeCadence(ir, minute) {
+  if (minute !== 0 || !hasHourWindow(ir) || ir.pattern.second === "0") {
+    return null;
+  }
+  return hourCadenceLead(ir, minute) + ", " + hourRangeWindowTail(ir);
+}
+function hourRangeWindowTail(ir) {
+  return joinList(hourSegmentParts(ir, 0, 0, ":"));
 }
 function renderHourRange(ir, plan, opts) {
   const window = hourWindow(
@@ -615,11 +685,16 @@ function renderHourRange(ir, plan, opts) {
   if (plan.minuteForm === "lead" && ir.pattern.minute === "0") {
     return "st\xFCndlich " + window;
   }
-  return countedPhrase(ir, "minute", "Minute", "Minuten") + " jeder Stunde, " + window;
+  return (strideFromSegments(
+    fieldSegments(ir, "minute"),
+    UNITS.minute,
+    "jeder Stunde"
+  ) ?? countedPhrase(ir, "minute", "Minute", "Minuten") + " jeder Stunde") + ", " + window;
 }
 function renderClockTimes(ir, plan, opts) {
   if (ir.shapes.minute === "single") {
-    const cadence = hourCadence(ir, +ir.pattern.minute);
+    const minute = +ir.pattern.minute;
+    const cadence = hourCadence(ir, minute) ?? hourRangeCadence(ir, minute);
     if (cadence !== null) {
       return cadence;
     }