cronli5 0.8.3 → 0.8.6

package/src/lang/es/index.ts

@@ -215,7 +215,19 @@ function renderSecondsWithinMinute(
       trailingQualifier(schedule, opts);
   }
 
-  return secondsLeadClause(schedule, opts) + ', en el minuto ' + minuteField +
+  // A second LIST or RANGE under a single minute confines that minute with the
+  // genitive "de" ("en los segundos 5 y 10 del minuto 30 de cada hora"), never
+  // the comma juxtaposition that reads as two independent schedules. A STEP
+  // second is a cadence ("cada 15 segundos") and keeps its own lead.
+  if (secondsConfinesMinute(schedule)) {
+    return secondsBareLead(schedule) + ' ' +
+      confinedMinutePhrase(schedule, opts) + trailingQualifier(schedule, opts);
+  }
+
+  // A cadence/stepped second leads straight into the locative "en el minuto …"
+  // with NO comma ("cada 15 segundos en el minuto 30 de cada hora"); the
+  // locative binds the two specs, matching the no-comma list/single form.
+  return secondsLeadClause(schedule, opts) + ' en el minuto ' + minuteField +
     ' de cada hora' + trailingQualifier(schedule, opts);
 }
 
@@ -345,6 +357,136 @@ 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 ("de
+// cada sexto minuto…"), so the generic minute anchor would be redundant. The
+// list/range/single forms mirror `secondsClause` minus that anchor.
+function secondsBareLead(schedule: Schedule): string {
+  const secondField = schedule.pattern.second;
+  const shape = schedule.shapes.second;
+
+  if (shape === 'range') {
+    const bounds = secondField.split('-');
+
+    return 'cada segundo del ' + bounds[0] + ' al ' + bounds[1];
+  }
+
+  if (shape === 'single') {
+    return 'en el segundo ' + secondField;
+  }
+
+  return 'en los segundos ' +
+    joinList(segmentWords(segmentsOf(schedule, 'second')));
+}
+
+// The CONFINED-minute genitive phrase a clock-point second attaches to, with
+// its leading connector folded in ("de cada sexto minuto a partir del minuto 4
+// de cada hora", "de los minutos 0, 15 y 30 de cada hora", "del minuto 30 de
+// cada hora"). A stepped minute reuses the ordinal cadence form; a list, range,
+// or single names the minute(s) directly. This is the seconds clause's anchor,
+// so the generic "de cada minuto" is never stacked alongside it.
+function confinedMinutePhrase(schedule: Schedule, opts: Opts): string {
+  const stride = minuteStride(schedule);
+
+  if (stride && schedule.pattern.minute !== '*/2') {
+    const ordinal = stepOrdinals[stride.interval];
+    const head = ordinal ?
+      'cada ' + ordinal + ' minuto' :
+      'cada ' + numero(stride.interval, opts) + ' minutos';
+    const tail = chooseStride({...stride, cycle: 60}, {
+      bare: () => '',
+      offset: () => ' a partir del minuto ' + stride.start,
+      bounded: () => ' del minuto ' + stride.start + ' al ' + stride.last
+    });
+
+    return 'de ' + head + tail + ' de cada hora';
+  }
+
+  if (schedule.shapes.minute === 'range') {
+    return 'de ' + minuteRangeLead(schedule.pattern.minute) + ' de cada hora';
+  }
+
+  if (schedule.shapes.minute === 'list') {
+    return 'de los minutos ' +
+      joinList(segmentWords(segmentsOf(schedule, 'minute'))) + ' de cada hora';
+  }
+
+  // A single pinned minute: "del minuto 30 de cada hora".
+  return 'del 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 with the
+// genitive "de" rather than juxtapose it behind a comma (two independent
+// schedules). The single-second + single-minute pair folds into one coherent
+// clock point ("en el minuto 5 y el segundo 30 de cada hora") and is excluded.
+// 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 minuteStepConfinement(schedule, minuteStride(schedule)!, opts);
+  }
+
+  const minuteRest = plan.rest.kind === 'minuteFrequency' ||
+    plan.rest.kind === 'multipleMinutes' ||
+    plan.rest.kind === 'rangeOfMinutes';
+
+  if (minuteRest && secondsConfinesMinute(schedule)) {
+    return secondsBareLead(schedule) + ' ' +
+      confinedMinutePhrase(schedule, opts) + trailingQualifier(schedule, opts);
+  }
+
+  return null;
+}
+
+function secondsConfinesMinute(schedule: Schedule): boolean {
+  const {second, minute, hour} = schedule.shapes;
+
+  // A second LIST the core enumerated from a step (`*/15` → 0,15,30,45; `3/2` →
+  // 3,5,…) is really a stride CADENCE, spoken "cada N segundos" and confined by
+  // the cadence path, not a clock-point clause; exclude it here.
+  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 seconds lead plus its connector for a generic compose-seconds fallback:
+// empty when the rest already owns the second (a compact clock time folding a
+// meaningful single second); a bare space when the rest is a locative "en …"
+// minute LIST/SINGLE under a wildcard hour (the locative binds the two specs,
+// so no comma); otherwise the comma that sets the seconds clause apart.
+function composeConnector(
+  schedule: Schedule,
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
+  opts: Opts
+): string {
+  if (plan.rest.kind === 'compactClockTimes' && schedule.analyses.clockSecond) {
+    return '';
+  }
+
+  const locative = (plan.rest.kind === 'multipleMinutes' ||
+    plan.rest.kind === 'singleMinute') && schedule.shapes.hour === 'wildcard';
+
+  return secondsLeadClause(schedule, opts) + (locative ? ' ' : ', ');
+}
+
 function renderComposeSeconds(
   schedule: Schedule,
   plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
@@ -388,12 +530,15 @@ function renderComposeSeconds(
     return dayFrame + ', ' + window + ', ' + cadence;
   }
 
-  // A stepped minute under a wildcard second + wildcard hour confines the
-  // second cadence to the ordinal minute cadence ("cada segundo en cada sexto
-  // minuto a partir del 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 ("cada segundo en cada sexto
+  // minuto …"); a CLOCK-POINT second uses the genitive form anchored to the
+  // confined minute ("en los segundos 5, 10 y 15 de cada 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
@@ -408,11 +553,12 @@ function renderComposeSeconds(
 
   // 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
-  // clockSecond), so it still leads its own clause here.
-  const restOwnsLead = plan.rest.kind === 'compactClockTimes' &&
-    schedule.analyses.clockSecond;
-  const lead = restOwnsLead ? '' : secondsLeadClause(schedule, opts) + ', ';
+  // double it (empty connector). A cadence/stepped second under a minute
+  // LIST or SINGLE and a wildcard hour leads straight into the locative "en …"
+  // minute phrase with NO comma ("cada segundo en los minutos 0, 15 y 30 de
+  // cada hora") — the locative binds the two specs, matching the no-comma
+  // stepped-minute and list-tier confinements. Every other rest takes a comma.
+  const lead = composeConnector(schedule, plan, opts);
 
   return lead + render(schedule, plan.rest, opts);
 }

package/src/lang/fi/index.ts

@@ -346,6 +346,13 @@ function renderSecondsWithinMinute(
       units.second.gen + ' kohdalla' + trailingQualifier(schedule, opts);
   }
 
+  // A second LIST or RANGE under a single minute folds both into one shared
+  // "kohdalla" ("joka tunti 30 minuutin ja 5 ja 10 sekunnin kohdalla"), never
+  // the comma juxtaposition; a STEP second is a cadence and keeps its clause.
+  if (secondsConfinesMinute(schedule)) {
+    return secondsConfinement(schedule, opts);
+  }
+
   return secondsLeadClause(schedule, opts) + ', ' +
     atMarks(minuteField, units.minute, true) +
     trailingQualifier(schedule, opts);
@@ -480,6 +487,68 @@ function isSteppedMinuteSeconds(
     minuteStride(schedule) !== 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 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 shared "kohdalla"
+// already ("joka tunti 30 minuutin ja 15 sekunnin kohdalla") 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 over a minute-cadence/list/range rest carries
+// a clock-point second that must confine the minute — the gate for the "的"/
+// shared-"kohdalla" fusion in `renderComposeSeconds`, kept out of that function
+// to hold its branch count down.
+function composeConfinesMinute(
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>, schedule: Schedule
+): boolean {
+  const minuteRest = plan.rest.kind === 'minuteFrequency' ||
+    plan.rest.kind === 'multipleMinutes' ||
+    plan.rest.kind === 'rangeOfMinutes';
+
+  return minuteRest && secondsConfinesMinute(schedule);
+}
+
+// Confine a restricted minute under a clock-point second. A STEPPED minute
+// keeps the essive ordinal cadence frame ("joka kuudentena minuuttina jokaisen
+// tunnin minuutista 4 alkaen") and the seconds trail as their postposition,
+// mirroring the open-minute "joka minuutti 5, 10 ja 15 sekunnin kohdalla". A
+// list, range, or single minute folds BOTH fields into one shared "kohdalla"
+// ("joka tunti 0, 15 ja 30 minuutin ja 5, 10 ja 15 sekunnin kohdalla"), the
+// same fusion the single-second case uses — never the comma juxtaposition.
+function secondsConfinement(
+  schedule: Schedule, opts: NormalizedOptions
+): string {
+  const stride = minuteStride(schedule);
+
+  if (stride && schedule.pattern.minute !== '*/2') {
+    return minuteStepConfinement(schedule, stride, opts);
+  }
+
+  const minuteDigits = joinList(segmentWords(segmentsOf(schedule, 'minute')));
+  const secondDigits = joinList(segmentWords(segmentsOf(schedule, 'second')));
+
+  return units.minute.mark + ' ' + minuteDigits + ' ' + units.minute.gen +
+    ' ja ' + secondDigits + ' ' + units.second.gen + ' kohdalla' +
+    trailingQualifier(schedule, opts);
+}
+
 function renderComposeSeconds(
   schedule: Schedule,
   plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
@@ -505,6 +574,14 @@ function renderComposeSeconds(
     return minuteStepConfinement(schedule, minuteStride(schedule)!, opts);
   }
 
+  // A clock-point second (list/range/single) under a restricted minute confines
+  // that minute, never the comma juxtaposition that reads as two schedules: a
+  // stepped minute keeps its essive frame with the seconds postposition; a
+  // list, range, or single minute folds both into one shared "kohdalla".
+  if (composeConfinesMinute(plan, schedule)) {
+    return secondsConfinement(schedule, opts);
+  }
+
   // When the rest is a minute-step cadence, the step leads and the second
   // anchor follows after a comma (the comma marks the granularity boundary
   // between the two levels, not a flat list).

package/src/lang/fr/index.ts

@@ -127,16 +127,6 @@ const weekdayNames = [
 const nthWeekdayMasculine =
   [null, 'premier', 'deuxième', 'troisième', 'quatrième', 'cinquième'];
 
-// French ordinals (gender-neutral "-ième") for a stepped-minute cadence under a
-// seconds lead ("à la sixième minute"). The interval-2 step keeps its own
-// idiom and never reaches here; a lookup miss falls back to the cardinal-with-
-// preposition form, which still confines (see `minuteStepConfinement`).
-const stepOrdinals: Record<number, string> = {
-  3: 'troisième', 4: 'quatrième', 5: 'cinquième', 6: 'sixième',
-  7: 'septième', 8: 'huitième', 9: 'neuvième', 10: 'dixième',
-  12: 'douzième', 15: 'quinzième', 20: 'vingtième', 30: 'trentième'
-};
-
 // Normalize raw user options.
 function normalizeOptions(options?: Cronli5Options): Opts {
   options = options || {};
@@ -227,6 +217,14 @@ function renderSecondsWithinMinute(
       trailingQualifier(schedule, opts);
   }
 
+  // A second LIST or RANGE under a single minute confines that minute in the
+  // genitive ("aux secondes 5 et 10 de la minute 30 de chaque heure"), 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) + ', à la minute ' + minuteField +
     ' de chaque heure' + trailingQualifier(schedule, opts);
 }
@@ -309,30 +307,22 @@ function minuteStride(
   return values && arithmeticStep(values);
 }
 
-// A stepped minute under a wildcard/stepped second and wildcard hour: bind the
-// second cadence to the minute cadence as a CONFINEMENT ("chaque seconde à la
-// sixième minute à partir de la minute 4 de chaque heure"), never the comma
-// juxtaposition that reads as two independent cadences. The cadence is ORDINAL
-// ("à la sixième minute") — the cardinal "toutes les six minutes" is what fuels
-// the misread — and the start/bound mirror the standalone minute cadence.
-function minuteStepConfinement(
+// A stepped minute under a wildcard hour: the second clause leads, a COMMA,
+// then the minute's own STANDALONE cardinal cadence ("chaque seconde, toutes
+// les six minutes à partir de la minute 4 de chaque heure"; "aux secondes 5,
+// 10 et 15, toutes les six minutes …"). The ordinal "à la sixième minute" read
+// as a single minute (the 10th), not the every-sixth series; the standalone
+// cardinal "toutes les six minutes" 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 for a list/range/single.
+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 ?
-    'à la ' + ordinal + ' minute' :
-    'à la minute toutes les ' + numero(stride.interval, opts);
-
-  const tail = chooseStride({...stride, cycle: 60}, {
-    bare: () => '',
-    offset: () => ' à partir de la minute ' + stride.start,
-    bounded: () => ' de la minute ' + stride.start + ' à ' + stride.last
-  });
-
-  return secondsLeadClause(schedule, opts) + ' ' + head + tail +
-    ' de chaque heure' + 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
@@ -350,6 +340,108 @@ function isSteppedMinuteSeconds(
     minuteStride(schedule) !== null;
 }
 
+// The leading seconds words for a clock-point second, WITHOUT the trailing "de
+// chaque minute" anchor: a confined second attaches to the CONFINED minute ("de
+// la sixième minute…"), 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 'chaque seconde de ' + bounds[0] + ' à ' + bounds[1];
+  }
+
+  if (shape === 'single') {
+    return 'à la seconde ' + secondField;
+  }
+
+  return 'aux secondes ' +
+    joinList(segmentWords(segmentsOf(schedule, 'second')));
+}
+
+// The CONFINED-minute genitive phrase a clock-point second attaches to ("des
+// minutes 0, 15 et 30 de chaque heure", "de la minute 30 de chaque heure", "de
+// chaque minute de 0 à 30 de chaque heure"). A stepped minute is handled by the
+// standalone-cadence confinement before this point; a list, range, or single
+// names the minute(s) in the genitive — so the bare seconds lead never stacks a
+// redundant "de chaque minute".
+function confinedMinutePhrase(schedule: Schedule): string {
+  if (schedule.shapes.minute === 'range') {
+    return 'de ' + minuteRangeLead(schedule.pattern.minute) +
+      ' de chaque heure';
+  }
+
+  if (schedule.shapes.minute === 'list') {
+    return 'des minutes ' +
+      joinList(segmentWords(segmentsOf(schedule, 'minute'))) +
+      ' de chaque heure';
+  }
+
+  return 'de la minute ' + schedule.pattern.minute + ' de chaque heure';
+}
+
+// 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 STEPPED minute (cadence or clock-point second) leads with
+// the second clause, a comma, then the minute's own standalone cardinal
+// cadence; a CLOCK-POINT second over a LIST/RANGE/SINGLE minute uses the
+// genitive form anchored to the confined minute. Both bind the second beneath
+// the minute instead of juxtaposing the two behind a bare comma + "de chaque
+// minute". 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'}>,
@@ -397,8 +489,15 @@ function renderComposeSeconds(
   // the second cadence to the ordinal minute cadence ("chaque seconde à la
   // sixième minute à partir de la minute 4 de chaque heure"), 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 ("chaque seconde à la
+  // sixième minute …"); a CLOCK-POINT second uses the genitive form anchored to
+  // the confined minute ("aux secondes 5, 10 et 15 de la sixième minute …").
+  const confined = minuteConfinementRender(plan, schedule, opts);
+
+  if (confined !== null) {
+    return confined;
   }
 
   // A wildcard second under a minute */2 with a wildcard hour juxtaposes two