cronli5 0.8.3 → 0.8.6

package/dist/lang/pt.js

@@ -206,20 +206,6 @@ function weekdayFeminine(number) {
 }
 var nthWeekdayMasculine = [null, "primeiro", "segundo", "terceiro", "quarto", "quinto"];
 var nthWeekdayFeminine = [null, "primeira", "segunda", "terceira", "quarta", "quinta"];
-var stepOrdinals = {
-  3: "terceiro",
-  4: "quarto",
-  5: "quinto",
-  6: "sexto",
-  7: "s\xE9timo",
-  8: "oitavo",
-  9: "nono",
-  10: "d\xE9cimo",
-  12: "d\xE9cimo segundo",
-  15: "d\xE9cimo quinto",
-  20: "vig\xE9simo",
-  30: "trig\xE9simo"
-};
 function noonMidnightArticle(phrase) {
   if (phrase === "meio-dia") {
     return "o";
@@ -325,6 +311,9 @@ function renderSecondsWithinMinute(schedule, plan, opts) {
   if (plan.singleSecond) {
     return "no minuto " + minuteField + " e no segundo " + schedule.pattern.second + " de cada hora" + trailingQualifier(schedule, opts);
   }
+  if (secondsConfinesMinute(schedule)) {
+    return secondsBareLead(schedule) + " " + confinedMinutePhrase(schedule) + trailingQualifier(schedule, opts);
+  }
   return secondsLeadClause(schedule, opts) + ", no minuto " + minuteField + " de cada hora" + trailingQualifier(schedule, opts);
 }
 function secondsListAtClock(schedule, rest, opts) {
@@ -358,19 +347,68 @@ function minuteStride(schedule) {
   const values = singleValues(segmentsOf(schedule, "minute"));
   return values && arithmeticStep(values);
 }
-function minuteStepConfinement(schedule, stride, opts) {
-  const ordinal = stepOrdinals[stride.interval];
-  const head = ordinal ? "no " + ordinal + " minuto" : "a cada " + numero(stride.interval, opts) + " minutos";
-  const tail = renderStride({ ...stride, cycle: 60 }, {
-    bare: () => "",
-    offset: () => " a partir do minuto " + stride.start,
-    bounded: () => " do minuto " + stride.start + " ao " + stride.last
-  });
-  return secondsLeadClause(schedule, opts) + " " + head + tail + " de cada hora" + trailingQualifier(schedule, opts);
+function steppedMinuteConfinement(schedule, plan, lead, opts) {
+  return lead + ", " + render(schedule, plan.rest, opts) + trailingQualifier(schedule, opts);
 }
 function isSteppedMinuteSeconds(schedule, plan) {
   return (plan.rest.kind === "minuteFrequency" || plan.rest.kind === "multipleMinutes") && (schedule.shapes.second === "wildcard" || schedule.shapes.second === "step") && schedule.shapes.hour === "wildcard" && schedule.pattern.minute !== "*/2" && minuteStride(schedule) !== null;
 }
+function secondsBareLead(schedule) {
+  const secondField = schedule.pattern.second;
+  const shape = schedule.shapes.second;
+  if (shape === "range") {
+    const bounds = secondField.split("-");
+    return "a cada segundo do " + bounds[0] + " ao " + bounds[1];
+  }
+  if (shape === "single") {
+    return "no segundo " + secondField;
+  }
+  return "nos segundos " + joinList(segmentWords(segmentsOf(schedule, "second")));
+}
+function confinedMinutePhrase(schedule) {
+  if (schedule.shapes.minute === "range") {
+    const range = minuteRangeLead(schedule.pattern.minute).replace(/^a /u, "");
+    return "de " + range + " de cada hora";
+  }
+  if (schedule.shapes.minute === "list") {
+    return "dos minutos " + joinList(segmentWords(segmentsOf(schedule, "minute"))) + " de cada hora";
+  }
+  return "do minuto " + schedule.pattern.minute + " de cada hora";
+}
+function secondsConfinesMinute(schedule) {
+  const { second, minute, hour } = schedule.shapes;
+  if (second === "list") {
+    const values = singleValues(segmentsOf(schedule, "second"));
+    if (values && arithmeticStep(values)) {
+      return false;
+    }
+  }
+  const clockPoint = second === "single" || second === "range" || second === "list";
+  return clockPoint && minute !== "wildcard" && hour === "wildcard" && !(second === "single" && minute === "single");
+}
+function minuteConfinementRender(plan, schedule, opts) {
+  if (isSteppedMinuteSeconds(schedule, plan)) {
+    return steppedMinuteConfinement(
+      schedule,
+      plan,
+      secondsLeadClause(schedule, opts),
+      opts
+    );
+  }
+  const minuteRest = plan.rest.kind === "minuteFrequency" || plan.rest.kind === "multipleMinutes" || plan.rest.kind === "rangeOfMinutes";
+  if (minuteRest && secondsConfinesMinute(schedule)) {
+    if (minuteStride(schedule) && schedule.pattern.minute !== "*/2") {
+      return steppedMinuteConfinement(
+        schedule,
+        plan,
+        secondsBareLead(schedule),
+        opts
+      );
+    }
+    return secondsBareLead(schedule) + " " + confinedMinutePhrase(schedule) + trailingQualifier(schedule, opts);
+  }
+  return null;
+}
 function renderComposeSeconds(schedule, plan, opts) {
   const hourCad = composeHourCadence(schedule, plan, opts);
   if (hourCad !== null) {
@@ -389,8 +427,9 @@ function renderComposeSeconds(schedule, plan, opts) {
     const cadence = "a cada " + numero(stepSegment(schedule, "second").interval, opts) + " segundos do minuto " + schedule.pattern.minute;
     return dayFrame + ", " + window + ", " + cadence;
   }
-  if (isSteppedMinuteSeconds(schedule, plan)) {
-    return minuteStepConfinement(schedule, minuteStride(schedule), opts);
+  const confined = minuteConfinementRender(plan, schedule, opts);
+  if (confined !== null) {
+    return confined;
   }
   if (isEveryOtherMinuteSeconds(schedule, plan)) {
     const rest = render(schedule, plan.rest, opts).replace(/^a /u, "");

package/dist/lang/zh.cjs

@@ -573,8 +573,8 @@ function secondClause(schedule) {
     return "\u6BCF\u79D2";
   }
   const first = segs[0];
-  if (segs.length === 1 && first.kind === "step" && first.startToken === "*") {
-    return cadence(first.interval, UNITS.second);
+  if (segs.length === 1 && first.kind === "step") {
+    return stepClause(first, "\u79D2", "\u79D2", "\u6BCF\u5206\u949F");
   }
   return strideFromSegments(segs, "\u79D2", "\u79D2", "\u6BCF\u5206\u949F") ?? "\u7B2C" + valueText(segs) + "\u79D2";
 }
@@ -670,6 +670,9 @@ function composeSecondsCadence(schedule) {
         return "\u6BCF\u5076\u6570\u5206\u949F\u7684\u6BCF\u4E00\u79D2";
       }
     }
+    if (!secondIsCadence(schedule) && !secondIsStride(schedule)) {
+      return minuteClause(schedule) + "\u7684" + sec;
+    }
     return sec + "\uFF0C" + minuteClause(schedule);
   }
   return hourFrame(schedule) + tail;
@@ -683,7 +686,7 @@ function composeSecondsListed(schedule) {
     return hourWord(hourFires(schedule)[0]) + minuteCad + "\u7684\u6BCF\u4E00\u79D2";
   }
   if (schedule.shapes.hour === "wildcard") {
-    return secondIsCadence(schedule) ? minutes + confinedSecondTail(sec) : minutes + "\uFF0C" + sec;
+    return secondIsStride(schedule) ? minutes + "\uFF0C" + sec : minutes + confinedSecondTail(sec);
   }
   const hourCad = unevenHourCadence(schedule);
   if (hourCad !== null) {
@@ -701,6 +704,13 @@ function isMinuteStride(schedule) {
 function secondIsCadence(schedule) {
   return schedule.pattern.second === "*" || schedule.shapes.second === "step";
 }
+function secondIsStride(schedule) {
+  if (schedule.shapes.second !== "list") {
+    return false;
+  }
+  const values = singleValues(segmentsOf(schedule, "second"));
+  return values !== null && arithmeticStep(values) !== null;
+}
 function confinedSecondTail(sec) {
   return sec === "\u6BCF\u79D2" ? "\u7684\u6BCF\u4E00\u79D2" : "\u7684" + sec;
 }

package/dist/lang/zh.js

@@ -547,8 +547,8 @@ function secondClause(schedule) {
     return "\u6BCF\u79D2";
   }
   const first = segs[0];
-  if (segs.length === 1 && first.kind === "step" && first.startToken === "*") {
-    return cadence(first.interval, UNITS.second);
+  if (segs.length === 1 && first.kind === "step") {
+    return stepClause(first, "\u79D2", "\u79D2", "\u6BCF\u5206\u949F");
   }
   return strideFromSegments(segs, "\u79D2", "\u79D2", "\u6BCF\u5206\u949F") ?? "\u7B2C" + valueText(segs) + "\u79D2";
 }
@@ -644,6 +644,9 @@ function composeSecondsCadence(schedule) {
         return "\u6BCF\u5076\u6570\u5206\u949F\u7684\u6BCF\u4E00\u79D2";
       }
     }
+    if (!secondIsCadence(schedule) && !secondIsStride(schedule)) {
+      return minuteClause(schedule) + "\u7684" + sec;
+    }
     return sec + "\uFF0C" + minuteClause(schedule);
   }
   return hourFrame(schedule) + tail;
@@ -657,7 +660,7 @@ function composeSecondsListed(schedule) {
     return hourWord(hourFires(schedule)[0]) + minuteCad + "\u7684\u6BCF\u4E00\u79D2";
   }
   if (schedule.shapes.hour === "wildcard") {
-    return secondIsCadence(schedule) ? minutes + confinedSecondTail(sec) : minutes + "\uFF0C" + sec;
+    return secondIsStride(schedule) ? minutes + "\uFF0C" + sec : minutes + confinedSecondTail(sec);
   }
   const hourCad = unevenHourCadence(schedule);
   if (hourCad !== null) {
@@ -675,6 +678,13 @@ function isMinuteStride(schedule) {
 function secondIsCadence(schedule) {
   return schedule.pattern.second === "*" || schedule.shapes.second === "step";
 }
+function secondIsStride(schedule) {
+  if (schedule.shapes.second !== "list") {
+    return false;
+  }
+  const values = singleValues(segmentsOf(schedule, "second"));
+  return values !== null && arithmeticStep(values) !== null;
+}
 function confinedSecondTail(sec) {
   return sec === "\u6BCF\u79D2" ? "\u7684\u6BCF\u4E00\u79D2" : "\u7684" + sec;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cronli5",
-  "version": "0.8.3",
+  "version": "0.8.6",
   "description": "Cron Like I'm Five: A Cron to English Utility",
   "repository": {
     "type": "git",

package/src/lang/de/index.ts

@@ -668,7 +668,17 @@ function renderSecondsWithinMinute(
       schedule.pattern.second + ' jeder Stunde';
   }
 
-  return secondsLead(schedule) + ', in Minute ' + schedule.pattern.minute +
+  // A second LIST or RANGE under a single minute confines that minute in the
+  // genitive ("in den Sekunden 5 und 10 der Minute 30 jeder Stunde"), never the
+  // comma juxtaposition; a STEP second is a cadence and keeps its own lead.
+  if (secondsConfinesMinute(schedule)) {
+    return secondsLead(schedule) + ' ' + confinedMinutePhrase(schedule);
+  }
+
+  // A cadence/stepped second leads straight into the locative "in Minute …"
+  // with NO comma ("alle 15 Sekunden in Minute 30 jeder Stunde"); the locative
+  // binds the two specs, matching the no-comma list/single confinement.
+  return secondsLead(schedule) + ' in Minute ' + schedule.pattern.minute +
     ' jeder Stunde';
 }
 
@@ -786,6 +796,96 @@ function isSteppedMinuteSeconds(
     minuteStride(schedule) !== null;
 }
 
+// The CONFINED-minute phrase in the genitive that a clock-point second attaches
+// to ("jeder sechsten Minute ab Minute 4 jeder Stunde", "der Minuten 0, 15 und
+// 30 jeder Stunde", "der Minute 30 jeder Stunde"). A stepped minute reuses the
+// ordinal cadence; a list, range, or single names the minute(s) in the genitive
+// — so the seconds clause's bare lead never stacks a redundant "jeder Minute".
+function confinedMinutePhrase(schedule: Schedule): string {
+  const stride = minuteStride(schedule);
+
+  if (stride && schedule.pattern.minute !== '*/2') {
+    const ordinal = minuteStepOrdinals[stride.interval];
+    const head = ordinal ?
+      'jeder ' + ordinal + ' Minute' :
+      'alle ' + stride.interval + ' Minuten';
+    const tail = chooseStride({...stride, cycle: 60}, {
+      bare: () => '',
+      offset: () => ' ab Minute ' + stride.start,
+      bounded: () => ' von Minute ' + stride.start + ' bis ' + stride.last
+    });
+
+    return head + tail + ' jeder Stunde';
+  }
+
+  const genitive = schedule.shapes.minute === 'single' ?
+    'der Minute ' + schedule.pattern.minute :
+    'der Minuten ' + joinList(fieldValues(schedule, 'minute'));
+
+  return genitive + ' jeder Stunde';
+}
+
+// The minute-confinement rendering for a compose-seconds plan, or null when the
+// plan is not one. A CADENCE second over a stepped minute uses the ordinal
+// cadence form; a CLOCK-POINT second (list/range/single) over any restricted
+// minute uses the genitive form. Both bind the second beneath the minute
+// instead of juxtaposing the two behind a comma. Folded into one helper so
+// `renderComposeSeconds` carries a single branch.
+function minuteConfinementRender(
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>, schedule: Schedule
+): string | null {
+  if (isSteppedMinuteSeconds(schedule, plan)) {
+    return minuteStepConfinement(schedule, minuteStride(schedule)!);
+  }
+
+  const minuteRest = plan.rest.kind === 'minuteFrequency' ||
+    plan.rest.kind === 'multipleMinutes' ||
+    plan.rest.kind === 'rangeOfMinutes';
+
+  if (minuteRest && secondsConfinesMinute(schedule)) {
+    return secondsLead(schedule) + ' ' + confinedMinutePhrase(schedule);
+  }
+
+  return null;
+}
+
+// Whether a clock-point second (list, range, or single) sits under a restricted
+// minute and a wildcard hour — the shape that must CONFINE the minute in the
+// genitive rather than juxtapose it behind a comma (two independent schedules).
+// A second LIST the core enumerated from a step (`3/2`) is really a stride
+// cadence and stays out. The single-second + single-minute pair folds into one
+// coherent clock point ("in Minute 5 und Sekunde 30 jeder Stunde") and is
+// excluded.
+function secondsConfinesMinute(schedule: Schedule): boolean {
+  const {second, minute, hour} = schedule.shapes;
+
+  if (second === 'list') {
+    const values = singleValues(segmentsOf(schedule, 'second'));
+
+    if (values && arithmeticStep(values)) {
+      return false;
+    }
+  }
+
+  const clockPoint = second === 'single' || second === 'range' ||
+    second === 'list';
+
+  return clockPoint && minute !== 'wildcard' && hour === 'wildcard' &&
+    !(second === 'single' && minute === 'single');
+}
+
+// Whether a compose-seconds plan is a cadence/stepped second under a minute
+// LIST or SINGLE and a wildcard hour — the shape that leads into the locative
+// "in …" minute phrase with no comma. A restricted/cadence hour keeps the
+// comma, so it does not qualify.
+function isLocativeMinuteConfinement(
+  schedule: Schedule,
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>
+): boolean {
+  return (plan.rest.kind === 'multipleMinutes' ||
+    plan.rest.kind === 'singleMinute') && schedule.shapes.hour === 'wildcard';
+}
+
 function renderComposeSeconds(
   schedule: Schedule,
   plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
@@ -818,12 +918,15 @@ function renderComposeSeconds(
       clockMinuteGenitive(plan.rest.times, opts.style.sep);
   }
 
-  // A stepped minute under a wildcard/stepped second + wildcard hour confines
-  // the second cadence to the ordinal minute cadence ("jede Sekunde in jeder
-  // sechsten Minute ab Minute 4 jeder Stunde"), never the comma juxtaposition
-  // that reads as two independent cadences.
-  if (isSteppedMinuteSeconds(schedule, plan)) {
-    return minuteStepConfinement(schedule, minuteStride(schedule)!);
+  // A second confines the minute restriction (open hour), never the comma
+  // juxtaposition that reads as two independent cadences: a CADENCE second over
+  // a stepped minute uses the ordinal-cadence form ("jede Sekunde in jeder
+  // sechsten Minute …"); a CLOCK-POINT second uses the genitive form ("in den
+  // Sekunden 5, 10 und 15 jeder sechsten Minute …").
+  const confined = minuteConfinementRender(plan, schedule);
+
+  if (confined !== null) {
+    return confined;
   }
 
   // A wildcard second under a minute */2 with a wildcard hour binds in the
@@ -832,6 +935,15 @@ function renderComposeSeconds(
     return secondsLead(schedule) + ' jeder zweiten Minute';
   }
 
+  // A cadence/stepped second under a minute LIST or SINGLE and a wildcard hour
+  // leads straight into the locative minute phrase with NO comma ("jede Sekunde
+  // in den Minuten 0, 15 und 30 jeder Stunde"). The locative "in" already binds
+  // the two specs; the comma read as two independent specifications and is
+  // inconsistent with the no-comma stepped-minute and list-tier confinements.
+  if (isLocativeMinuteConfinement(schedule, plan)) {
+    return secondsLead(schedule) + ' ' + render(schedule, plan.rest, opts);
+  }
+
   // A compact clock-time rest folds a meaningful SINGLE second into its own
   // leading clause, so the composer must not prepend a second lead that would
   // double it. A wildcard or stepped second is not folded there (no

package/src/lang/en/index.ts

@@ -10,7 +10,7 @@ import {
 import {orderWeekdaysForDisplay} from '../../core/weekday.js';
 import {isOpenStep} from '../../core/shapes.js';
 import {maxClockTimes} from '../../core/specs.js';
-import {clockDigits, numeral, pad} from '../../core/format.js';
+import {clockDigits, numeral} from '../../core/format.js';
 import type {Cronli5Options} from '../../types.js';
 import type {
   HourTimesPlan, Schedule, Language, NormalizedOptions, PlanNode, Segment
@@ -1102,15 +1102,69 @@ function isCadenceField(token: string): boolean {
     token.startsWith('*/') && token.indexOf('-') === -1;
 }
 
+// Whether the second field leads the confinement frame as a clean cadence. A
+// wildcard ("every second") and a clean `*/n` step both lead via
+// `isCadenceField`; an OPEN OFFSET step (`m/n`) is the SAME cadence, only named
+// from its offset ("every six seconds from five seconds past the minute"), so
+// it leads the SAME confinement rather than juxtaposing the minute restriction
+// behind a comma — whether the offset is clean from the top (`0/n`) or not
+// (`5/n`). A bounded step (`a-b/n`, a windowed set) is not an open cadence and
+// keeps its existing form.
+function secondLeadsCadence(schedule: Schedule): boolean {
+  if (isCadenceField(schedule.pattern.second)) {
+    return true;
+  }
+
+  if (schedule.shapes.second !== 'step') {
+    return false;
+  }
+
+  // Reached only under a stepped second the `isCadenceField` guard did not
+  // already admit, so its `*/n` clean-cadence forms are gone and the remaining
+  // open form is the offset step `m/n` (`0/n` or non-zero). A bounded step
+  // `a-b/n` is a windowed set, not a cadence, and stays out.
+  return isOpenStep(schedule.pattern.second);
+}
+
+// Whether the second leads the confinement frame as a CLOCK-POINT clause (a
+// list, range, or single second), as opposed to a cadence. A clock-point second
+// under a minute restriction confines that restriction exactly as the cadence
+// does ("at 5, 10, and 15 seconds past the minute during every sixth minute …")
+// rather than juxtaposing it behind a comma, which reads as two independent
+// schedules. The single-second + single-minute pair is excluded: it folds into
+// one coherent clock point ("30 minutes and 15 seconds past the hour"), not a
+// juxtaposition, so it keeps that fold. The confinement only applies where the
+// minute is the restriction and the hour is open; `confinementEligible` gates
+// the rest (a restricted hour folds into a clock time, left to that renderer).
+function secondLeadsClockPoint(schedule: Schedule): boolean {
+  // Only a MEANINGFUL second leads a clause: the two seconds-bearing plans the
+  // core chooses for a real second. A 5-field pattern (or an explicit `0`
+  // second) carries no seconds clause — its plan is the minute's own — so it is
+  // not confined here, which would otherwise prepend "at zero seconds …".
+  if (schedule.plan.kind !== 'composeSeconds' &&
+      schedule.plan.kind !== 'secondsWithinMinute') {
+    return false;
+  }
+
+  const {second, minute, hour} = schedule.shapes;
+  const clockPoint = second === 'single' || second === 'range' ||
+    second === 'list';
+  const minuteRestricted = minute !== 'wildcard';
+
+  return clockPoint && minuteRestricted && hour === 'wildcard' &&
+    !(second === 'single' && minute === 'single');
+}
+
 // The leading cadence and whether the second is the leading field, or null when
 // the pattern has no cadence lead (the finest restricted field is a clock-point
-// single/range/list). The seconds lead when restricted as a cadence; otherwise
-// the minute leads when the second is a plain :00 and the minute is a cadence.
+// single/range/list). The seconds lead when restricted as a cadence, or as a
+// clock-point clause that confines a minute restriction; otherwise the minute
+// leads when the second is a plain :00 and the minute is a cadence.
 function leadingCadence(schedule: Schedule, opts: NormalizedOptions):
   {text: string; secondLead: boolean} | null {
   const {second, minute} = schedule.pattern;
 
-  if (isCadenceField(second)) {
+  if (secondLeadsCadence(schedule) || secondLeadsClockPoint(schedule)) {
     return {secondLead: true, text: secondsClause(schedule, 'minute', opts)};
   }
 
@@ -1156,23 +1210,23 @@ function minuteConfinement(schedule: Schedule,
   }
 
   // A minute single/range/list under the seconds lead. The minute reads as a
-  // ":NN" clock-minute confinement, never "N minutes past the hour" (that is
+  // plain integer confinement, never "N minutes past the hour" (that is
   // the minute-lead clock-point form).
   const segments = segmentsOf(schedule, 'minute');
 
   if (schedule.shapes.minute === 'single') {
-    return ' during minute :' + pad(minute);
+    return ' during minute ' + Number(minute);
   }
 
   if (schedule.shapes.minute === 'range') {
     const bounds = minute.split('-');
 
-    return ' during minutes :' + pad(bounds[0]) + through(opts) + ':' +
-      pad(bounds[1]);
+    return ' during minutes ' + Number(bounds[0]) + through(opts) +
+      Number(bounds[1]);
   }
 
-  const values = segmentWords(segments, opts).map(function colon(word) {
-    return ':' + pad(word);
+  const values = segmentWords(segments, opts).map(function plain(word) {
+    return String(Number(word));
   });
 
   return ' during minutes ' + joinList(values, opts);