cronli5 0.8.2 → 0.8.5

package/src/lang/pt/index.ts

@@ -348,6 +348,14 @@ function renderSecondsWithinMinute(
       trailingQualifier(schedule, opts);
   }
 
+  // A second LIST or RANGE under a single minute confines that minute in the
+  // genitive ("nos segundos 5 e 10 do minuto 30 de cada hora"), never the comma
+  // juxtaposition; a STEP second is a cadence and keeps its own lead.
+  if (secondsConfinesMinute(schedule)) {
+    return secondsBareLead(schedule) + ' ' +
+      confinedMinutePhrase(schedule) + trailingQualifier(schedule, opts);
+  }
+
   return secondsLeadClause(schedule, opts) + ', no minuto ' + minuteField +
     ' de cada hora' + trailingQualifier(schedule, opts);
 }
@@ -413,6 +421,161 @@ function isPinnedMinuteSeconds(
       schedule.shapes.second === 'step');
 }
 
+// The minute field's step stride for the confinement frame, or null when the
+// minute is not a stepped cadence. A `step`-shaped field reads its segment; a
+// `list`-shaped field the core enumerated from a uneven step (`2/7` → 2,9,…,58)
+// recovers the progression from its values.
+function minuteStride(
+  schedule: Schedule
+): {start: number; interval: number; last: number} | null {
+  if (schedule.shapes.minute === 'step') {
+    const segment = stepSegment(schedule, 'minute');
+    const start = segment.startToken === '*' ? 0 : +segment.startToken;
+
+    return {interval: segment.interval, last:
+      segment.fires[segment.fires.length - 1], start};
+  }
+
+  const values = singleValues(segmentsOf(schedule, 'minute'));
+
+  return values && arithmeticStep(values);
+}
+
+// A stepped minute under a wildcard/stepped second and wildcard hour: bind the
+// second clause leads, a COMMA, then the minute's own STANDALONE cardinal
+// cadence ("a cada segundo, a cada seis minutos a partir do minuto 4 de cada
+// hora"; "nos segundos 5, 10 e 15, a cada seis minutos …"). The ordinal "no
+// sexto minuto" read as a single minute (the 10th), not the every-sixth series;
+// the standalone cardinal "a cada seis minutos" reads it correctly and handles
+// every stride (offset, bounded, uneven) for free. The lead is the cadence
+// clause for a wildcard/stepped second, the bare clock-point clause otherwise.
+function steppedMinuteConfinement(
+  schedule: Schedule,
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
+  lead: string,
+  opts: Opts
+): string {
+  return lead + ', ' + render(schedule, plan.rest, opts) +
+    trailingQualifier(schedule, opts);
+}
+
+// Whether a stepped minute fills a wildcard hour under a wildcard/stepped
+// second — the shape the confinement frame above handles.
+function isSteppedMinuteSeconds(
+  schedule: Schedule,
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>
+): boolean {
+  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;
+}
+
+// The leading seconds words for a clock-point second, WITHOUT the trailing "de
+// cada minuto" anchor: a confined second attaches to the CONFINED minute ("do
+// sexto minuto…"), so the generic minute anchor would be redundant.
+function secondsBareLead(schedule: Schedule): string {
+  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')));
+}
+
+// The CONFINED-minute genitive phrase a clock-point second attaches to ("dos
+// minutos 0, 15 e 30 de cada hora", "do minuto 30 de cada hora", "de cada
+// minuto do 0 ao 30 de cada hora"). A stepped minute is handled by the
+// standalone-cadence confinement before this point; a list, range, or single
+// names the minute(s) — so the bare seconds lead never stacks a redundant "de
+// cada minuto".
+function confinedMinutePhrase(schedule: Schedule): string {
+  if (schedule.shapes.minute === 'range') {
+    // `minuteRangeLead` is "a cada minuto do 0 ao 30"; the genitive "de"
+    // absorbs its leading "a" ("de cada minuto …", not "de a cada minuto").
+    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';
+}
+
+// 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 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');
+}
+
+// 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 anchored to the confined minute. 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, opts: Opts
+): string | null {
+  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)) {
+    // A clock-point second over a STEPPED minute reuses the standalone cardinal
+    // cadence the same way; only a list/range/single minute keeps the genitive.
+    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: Schedule,
   plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
@@ -456,6 +619,17 @@ function renderComposeSeconds(
     return dayFrame + ', ' + window + ', ' + cadence;
   }
 
+  // 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 ("a cada segundo no sexto
+  // minuto …"); a CLOCK-POINT second uses the genitive form anchored to the
+  // confined minute ("nos segundos 5, 10 e 15 do sexto minuto …").
+  const confined = minuteConfinementRender(plan, schedule, opts);
+
+  if (confined !== null) {
+    return confined;
+  }
+
   // A wildcard second under a minute */2 with a wildcard hour juxtaposes two
   // cadences that read as contradictory ("a cada segundo, a cada dois
   // minutos"). Bind them with the genitive "de" ("a cada segundo de cada dois

package/src/lang/zh/index.ts

@@ -833,8 +833,12 @@ function secondClause(schedule: Schedule): string {
 
   const first = segs[0];
 
-  if (segs.length === 1 && first.kind === 'step' && first.startToken === '*') {
-    return cadence(first.interval, UNITS.second);
+  // A STEP-shaped second reads as its stride cadence ("每6秒"), whether written
+  // "*/6" or the offset-clean "0/6" — both fire 0,6,…,54 — never the enumerated
+  // "第0、6、…、54秒". stepClause routes a clean/offset-clean stride through the
+  // bare cadence and only lists a bounded `a-b/n` or a short offset.
+  if (segs.length === 1 && first.kind === 'step') {
+    return stepClause(first, '秒', '秒', '每分钟');
   }
 
   // An offset/uneven step the core enumerated to this list reads as a stride
@@ -909,10 +913,14 @@ function composeSecondsOnHour(
     return '每天' + restText + secTail;
   }
 
-  // A stated minute (e.g. minute 0 under a sub-minute second) takes the same
-  // "，" connector the listed-minute path uses.
+  // A stated single minute (minute 0 under an open hour) confines the second
+  // beneath it with "的" when the second is a cadence ("每小时0分的每一秒"), the
+  // same fusion the other pinned-minute paths use; the bare comma ("每小时0分，
+  // 每秒") reads as two independent cadences. A single/list/range second is a
+  // clock-point, not a cadence, so it keeps the "，" connector.
   if (rest.kind === 'singleMinute') {
-    return restText + '，' + sec;
+    return secondIsCadence(schedule) ?
+      restText + confinedSecondTail(sec) : restText + '，' + sec;
   }
 
   return restText + secTail;
@@ -1040,6 +1048,13 @@ function composeSecondsCadence(schedule: Schedule): string {
       }
     }
 
+    // A CLOCK-POINT second (a single/list/range, not a stride cadence) under a
+    // clean minute step fuses beneath the minute with "的" ("每6分钟的第30秒"),
+    // never the comma that reads as two independent schedules.
+    if (!secondIsCadence(schedule) && !secondIsStride(schedule)) {
+      return minuteClause(schedule) + '的' + sec;
+    }
+
     return sec + '，' + minuteClause(schedule);
   }
 
@@ -1069,7 +1084,14 @@ function composeSecondsListed(schedule: Schedule): string {
   }
 
   if (schedule.shapes.hour === 'wildcard') {
-    return minutes + '，' + sec;
+    // The minute(s) are stated and the hour is open, so the second — whether a
+    // cadence ("每秒"/"每N秒") or a clock-point ("第5、10、15秒") — fuses beneath
+    // the minute(s) with "的" ("每小时30分的每一秒", "每小时0、15、30分的第5、10、15
+    // 秒"). The bare comma ("…，第5、10、15秒") reads as two independent schedules.
+    // A second STRIDE the core enumerated to a list ("3/2" → "每2秒，至59秒") is a
+    // bounded cadence with its own trailing "，至N秒"; it keeps the comma.
+    return secondIsStride(schedule) ?
+      minutes + '，' + sec : minutes + confinedSecondTail(sec);
   }
 
   const hourCad = unevenHourCadence(schedule);
@@ -1084,6 +1106,68 @@ function composeSecondsListed(schedule: Schedule): string {
   return hourFrame(schedule) + minutes + '，' + sec;
 }
 
+// Whether the minute field is a stepped cadence (a clean `*/n`, an offset
+// `m/n`, or a uneven step the core enumerated to an arithmetic fire list). The
+// shape the seconds-wildcard confinement below fuses with "的".
+function isMinuteStride(schedule: Schedule): boolean {
+  if (schedule.shapes.minute === 'step') {
+    return true;
+  }
+
+  const values = singleValues(segmentsOf(schedule, 'minute'));
+
+  return values !== null && arithmeticStep(values) !== null;
+}
+
+// Whether the second is a CADENCE (wildcard "每秒" or a clean step "每N秒") rather
+// than a clock-point (a single/list/range). A cadence second under a stated
+// minute fuses beneath it with "的"; a clock-point keeps the "，" connector.
+function secondIsCadence(schedule: Schedule): boolean {
+  return schedule.pattern.second === '*' || schedule.shapes.second === 'step';
+}
+
+// Whether a second LIST is really a stride the core enumerated from a step
+// ("3/2" → 3,5,…,59), spoken as a bounded cadence ("每2秒，至59秒") with its own
+// trailing comma — not a clock-point list ("第5、10、15秒"). Such a stride keeps
+// its comma form rather than fusing beneath the minute with "的".
+function secondIsStride(schedule: Schedule): boolean {
+  if (schedule.shapes.second !== 'list') {
+    return false;
+  }
+
+  const values = singleValues(segmentsOf(schedule, 'second'));
+
+  return values !== null && arithmeticStep(values) !== null;
+}
+
+// The "的"-fused second tail for a clause that already states its minute(s):
+// "的每一秒" for a wildcard second, else "的" + the second's own cadence clause.
+// The fusion binds the second beneath the minute rather than leaving a bare
+// trailing "每秒" that reads as a second, independent cadence.
+function confinedSecondTail(sec: string): string {
+  return sec === '每秒' ? '的每一秒' : '的' + sec;
+}
+
+// Whether a compose-seconds plan is a stepped minute under a cadence second and
+// wildcard hour — the shape the "的"-fused confinement below handles, kept
+// distinct from the */2 even-minutes idiom and the composed-clock paths.
+function isSteppedMinuteSeconds(
+  schedule: Schedule, composedClock: boolean
+): boolean {
+  return !composedClock && schedule.shapes.hour === 'wildcard' &&
+    secondIsCadence(schedule) && schedule.pattern.minute !== '*/2' &&
+    isMinuteStride(schedule);
+}
+
+// A stepped minute under a cadence second and wildcard hour: fuse the minute
+// cadence and the second cadence with "的" ("每小时从4分起每6分钟的每一秒"), never
+// the comma juxtaposition ("…每6分钟，每秒") that reads as two independent
+// cadences. The minute clause carries the offset/bound ("从4分起" / "，至58分").
+function minuteStrideConfinement(schedule: Schedule): string {
+  return minuteHourClause(schedule) +
+    confinedSecondTail(secondClause(schedule));
+}
+
 // Seconds composed with the minute/hour structure, dispatched on the minute.
 // A single minute over a composed clock-time rest (the core already joined the
 // lone hour and minute into "N点M分") keeps that composition, attaching the
@@ -1096,6 +1180,13 @@ function renderComposeSeconds(
   const composedClock =
     rest.kind === 'clockTimes' || rest.kind === 'compactClockTimes';
 
+  // A stepped minute under a cadence second and wildcard hour confines the
+  // second beneath the minute cadence with "的", never the comma that reads as
+  // two independent cadences. The */2 step keeps its own "每偶数分钟" idiom.
+  if (isSteppedMinuteSeconds(schedule, composedClock)) {
+    return minuteStrideConfinement(schedule);
+  }
+
   if (schedule.pattern.minute === '0' ||
     composedClock && schedule.shapes.minute === 'single') {
     return composeSecondsOnHour(schedule, plan, opts);