cronli5 0.8.3 → 0.8.6

package/src/lang/pt/index.ts

@@ -144,16 +144,6 @@ const nthWeekdayMasculine =
 const nthWeekdayFeminine =
   [null, 'primeira', 'segunda', 'terceira', 'quarta', 'quinta'];
 
-// Portuguese ordinals (masculine) for a stepped-minute cadence under a seconds
-// lead ("a cada segundo no sexto minuto"). The interval-2 step keeps its own
-// idiom and never reaches here, so the colliding "segundo" is unused; a lookup
-// miss falls back to the cardinal-with-"no" form, which still confines.
-const stepOrdinals: Record<number, string> = {
-  3: 'terceiro', 4: 'quarto', 5: 'quinto', 6: 'sexto', 7: 'sétimo',
-  8: 'oitavo', 9: 'nono', 10: 'décimo', 12: 'décimo segundo',
-  15: 'décimo quinto', 20: 'vigésimo', 30: 'trigésimo'
-};
-
 // --- Contractions (the principal es->pt divergence). ---
 //
 // Portuguese fuses a preposition with the following article wherever es emitted
@@ -358,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);
 }
@@ -444,29 +442,21 @@ function minuteStride(
 }
 
 // A stepped minute under a wildcard/stepped second and wildcard hour: bind the
-// second cadence to the minute cadence as a CONFINEMENT ("a cada segundo no
-// sexto minuto a partir do minuto 4 de cada hora"), never the comma
-// juxtaposition that reads as two independent cadences. The cadence is ORDINAL
-// ("no sexto minuto") — the cardinal "a cada seis minutos" is what fuels the
-// misread — and the start/bound mirror the standalone minute cadence.
-function minuteStepConfinement(
+// 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,
-  stride: {start: number; interval: number; last: number},
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
+  lead: string,
   opts: Opts
 ): string {
-  const ordinal = stepOrdinals[stride.interval];
-  const head = ordinal ?
-    'no ' + ordinal + ' minuto' :
-    'a cada ' + numero(stride.interval, opts) + ' minutos';
-
-  const tail = chooseStride({...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);
+  return lead + ', ' + render(schedule, plan.rest, opts) +
+    trailingQualifier(schedule, opts);
 }
 
 // Whether a stepped minute fills a wildcard hour under a wildcard/stepped
@@ -484,6 +474,108 @@ function isSteppedMinuteSeconds(
     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'}>,
@@ -527,12 +619,15 @@ function renderComposeSeconds(
     return dayFrame + ', ' + window + ', ' + cadence;
   }
 
-  // A stepped minute under a wildcard/stepped second + wildcard hour confines
-  // the second cadence to the ordinal minute cadence ("a cada segundo no sexto
-  // minuto a partir do minuto 4 de cada hora"), never the comma juxtaposition
-  // that reads as two independent cadences.
-  if (isSteppedMinuteSeconds(schedule, plan)) {
-    return minuteStepConfinement(schedule, minuteStride(schedule)!, opts);
+  // 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

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
@@ -1044,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);
   }
 
@@ -1073,13 +1084,14 @@ function composeSecondsListed(schedule: Schedule): string {
   }
 
   if (schedule.shapes.hour === 'wildcard') {
-    // A wildcard or stepped second is a cadence; the bare comma ("每小时30分，
-    // 每秒") reads as two independent cadences, so fuse the second beneath the
-    // stated minute(s) with "的" ("每小时30分的每一秒"), the same confinement the
-    // minute-stride and pinned-clock paths use. A single/list/range second is a
-    // clock-point, not a cadence, so it keeps the comma.
-    return secondIsCadence(schedule) ?
-      minutes + confinedSecondTail(sec) : 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);
@@ -1114,6 +1126,20 @@ 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