cronli5 0.1.5 → 0.1.7

package/src/lang/fi/index.ts

@@ -11,7 +11,9 @@
 
 import {clockDigits, numeral} from '../../core/format.js';
 import {maxClockTimes, weekdayNumbers} from '../../core/specs.js';
-import {arithmeticStep, toFieldNumber} from '../../core/util.js';
+import {
+  arithmeticStep, orderWeekdaysForDisplay, toFieldNumber
+} from '../../core/util.js';
 import {resolveDialect} from './dialects.js';
 import type {
   ClockTime, HourTimesPlan, IR, Language, NormalizedOptions, PlanNode,
@@ -353,9 +355,13 @@ function composeHourCadence(
   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 renderComposeSeconds(
@@ -400,7 +406,15 @@ function renderComposeSeconds(
     return secondsLeadClause(ir, opts) + ' joka toisena minuuttina';
   }
 
-  return secondsLeadClause(ir, opts) + ', ' + render(ir, 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
+  // clockSecond), so it still leads its own clause here.
+  const restOwnsLead = plan.rest.kind === 'compactClockTimes' &&
+    ir.analyses.clockSecond;
+  const lead = restOwnsLead ? '' : secondsLeadClause(ir, opts) + ', ';
+
+  return lead + render(ir, plan.rest, opts);
 }
 
 // A wildcard second over an unoffset minute */2 with a wildcard hour: the two
@@ -627,6 +641,16 @@ function renderMinuteFrequency(
   const seg = stepSegment(ir.analyses.segments.minute!);
 
   if (plan.hours.kind === 'during') {
+    // A bounded or uneven hour stride reads as its endpoint-pinning cadence
+    // after the minute step ("15 minuutin välein, viiden tunnin välein klo
+    // 0–20").
+    const cadence = unevenHourCadence(ir, opts);
+
+    if (cadence !== null) {
+      return stepCycle60(seg, units.minute, opts) + ', ' + cadence +
+        trailingQualifier(ir, opts);
+    }
+
     // When the step renders as anchored ("kohdalla"), the per-hour windows
     // are redundant — use bare clock hours instead, then reorder to
     // hours-first: "klo <hours> aina minuuttien <spec> kohdalla".
@@ -687,9 +711,20 @@ function renderMinutesAcrossHours(
   plan: Extract<PlanNode, {kind: 'minutesAcrossHours'}>,
   opts: NormalizedOptions
 ): string {
+  // A bounded or uneven hour stride reads as its endpoint-pinning cadence after
+  // the minute clause ("joka minuutti, viiden tunnin välein klo 0–20"), not a
+  // wall of hour windows.
+  const cadence = unevenHourCadence(ir, opts);
+
   if (plan.form === 'wildcard') {
-    return 'joka minuutti ' + hourWindowsFromTimes(ir, plan.times, opts) +
-      trailingQualifier(ir, opts);
+    return cadence ?
+      'joka minuutti, ' + cadence + trailingQualifier(ir, opts) :
+      'joka minuutti ' + hourWindowsFromTimes(ir, plan.times, opts) +
+        trailingQualifier(ir, opts);
+  }
+
+  if (cadence !== null) {
+    return bareMinutes(ir, opts) + ', ' + cadence + trailingQualifier(ir, opts);
   }
 
   // Range+isolated hours: minute-first, bare minutes, sekä klo.
@@ -714,25 +749,25 @@ function renderMinuteSpanAcrossHourStep(
 ): string {
   // An hour-step plan's first hour segment is always a step segment.
   const segment = stepSegment(ir.analyses.segments.hour!);
+  // A bounded or uneven hour stride reads as its endpoint-pinning cadence; an
+  // offset-clean stride keeps its confinement / per-step phrasing.
+  const cadence = unevenHourCadence(ir, opts);
 
   // A wildcard span always sets the step off with a comma ("joka
   // minuutti, joka toinen tunti"); a restricted span joins a plain step
   // directly ("minuuteilla 0–30 joka toinen tunti").
-  // A wildcard minute (a cadence) is reached only for a clean step and is
-  // confined to every Nth hour; a restricted span is a per-hour window whose
-  // recurrence joins as a plain step.
+  // A wildcard minute (a cadence) is reached only for a clean step (a bounded
+  // or uneven step routes through minutesAcrossHours instead) and is confined
+  // to every Nth hour; a restricted span is a per-hour window + plain step.
   if (plan.form === 'wildcard') {
     return 'joka minuutti ' + everyNthHour(segment, opts) +
       trailingQualifier(ir, opts);
   }
 
-  // A bounded range-step (e.g. 9-17/2) whose fires enumerate as a klo-digit
-  // list renders hours-first. A clean or offset unbounded step (e.g. 1/6,
-  // */2) keeps minute-first with its step phrase.
-  if (segment.startToken.indexOf('-') !== -1) {
-    const hoursStr = kloList(segment.fires, opts);
-
-    return hoursFirstMinutes(hoursStr, ir, opts) + trailingQualifier(ir, opts);
+  // A bounded or uneven stride reads as its bounded cadence after the bare
+  // minutes ("minuuteilla 0–30, kahden tunnin välein klo 9–17").
+  if (cadence !== null) {
+    return bareMinutes(ir, opts) + ', ' + cadence + trailingQualifier(ir, opts);
   }
 
   return bareMinutes(ir, opts) + hourStepTail(segment, opts) +
@@ -840,6 +875,15 @@ function renderHourStep(
   plan: Extract<PlanNode, {kind: 'hourStep'}>,
   opts: NormalizedOptions
 ): string {
+  // A bounded or uneven hour step reads as its endpoint-pinning cadence
+  // ("kahden tunnin välein klo 9–17"); an offset-clean step keeps its bare or
+  // "alkaen" cadence.
+  const cadence = unevenHourCadence(ir, opts);
+
+  if (cadence !== null) {
+    return cadence + trailingQualifier(ir, opts);
+  }
+
   return stepHours(stepSegment(ir.analyses.segments.hour!), opts) +
     trailingQualifier(ir, opts);
 }
@@ -867,10 +911,13 @@ function renderClockTimes(
   plan: Extract<PlanNode, {kind: 'clockTimes'}>,
   opts: NormalizedOptions
 ): string {
-  // An hour step (or arithmetic-progression hour list) under a single pinned
-  // minute reads as a cadence rather than a cross-product of clock times.
+  // An hour step or range (or arithmetic-progression hour list) under a single
+  // pinned minute reads as a cadence or window rather than a cross-product of
+  // clock times.
   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;
@@ -904,7 +951,8 @@ function renderCompactClockTimes(
   // minute reads as a cadence, not a wall of clock times. (Returns null for an
   // irregular list or a range, which keep folding below.)
   if (plan.fold) {
-    const cadence = hourCadence(ir, plan.minute, opts);
+    const cadence = hourCadence(ir, plan.minute, opts) ??
+      hourRangeCadence(ir, plan.minute, opts);
 
     if (cadence !== null) {
       return cadence;
@@ -938,11 +986,16 @@ function renderCompactClockTimes(
       hourSegmentTimes(ir, plan.minute, ir.analyses.clockSecond, opts);
   }
 
-  // A minute list over purely enumerated hours (step fires, all singles) —
-  // hours-first, drop "joka tunti".
-  const hoursStr = hourSegmentTimes(ir, 0, null, opts);
-  const phrase = hoursFirstMinutes(hoursStr, ir, opts) +
-    trailingQualifier(ir, opts);
+  // A bounded or uneven hour stride reads as its endpoint-pinning cadence after
+  // the bare minute clause ("minuuteilla 0, 25 ja 50, viiden tunnin välein klo
+  // 0–20"), not a wall of clock-time columns.
+  const cadence = unevenHourCadence(ir, opts);
+  const phrase = cadence ?
+    bareMinutes(ir, opts) + ', ' + cadence + trailingQualifier(ir, opts) :
+    // A minute list over purely enumerated hours (step fires, all singles) —
+    // hours-first, drop "joka tunti".
+    hoursFirstMinutes(hourSegmentTimes(ir, 0, null, opts), ir, opts) +
+      trailingQualifier(ir, opts);
 
   return ir.analyses.clockSecond ?
     secondsLeadClause(ir, opts) + ', ' + phrase :
@@ -1128,12 +1181,56 @@ function hourStrideCadence(
     kloRange({hour: start, minute: 0}, {hour: last, minute: 0}, opts);
 }
 
+// An hour list's arithmetic progression, or null when its values are not a step
+// the renderer should speak as a cadence. The core rewrites a uneven hour step
+// (whose interval does not tile 24, e.g. `*/5` → 0,5,10,15,20) to its literal
+// fire list, indistinguishable in the IR from a hand-written list; the renderer
+// recovers the cadence from the values. A progression starting at zero is a
+// `*/n` step however short (0,7,14,21 is `*/7`); a non-zero progression is only
+// a step when it is too long to be a deliberate clock-time list (9,17 is two
+// named times, not a cadence). Interval one is a plain range, never a step.
+function hourListStride(
+  values: number[]
+): {start: number; interval: number; last: number} | null {
+  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]};
+}
+
+// Whether an hour stride wraps the day cleanly from within its first interval
+// (a `*/n` from the top, or a `m/n` offset with m < n that divides 24): such a
+// stride has no distinct endpoint and keeps its bare or "alkaen" cadence. Every
+// other stride — a uneven interval, or one starting at or past its interval (a
+// bounded `a-b/n`) — is a bounded set the cadence pins both endpoints of.
+function offsetCleanStride(
+  stride: {start: number; interval: number}
+): boolean {
+  return stride.start < stride.interval && 24 % stride.interval === 0;
+}
+
 // The hour field's stride, or null when the hour is not a cadence: a step
 // segment yields its {start, interval, last} directly; an all-single hour list
-// yields one only when its values form a long-enough arithmetic progression
-// (so an irregular list like 9,17 keeps enumerating). The IR is unchanged —
-// the renderer recognizes the stride and speaks it as a cadence instead of the
-// clock-time cross-product.
+// yields one only when its values form a step progression (so an irregular list
+// like 9,17 keeps enumerating). The IR is unchanged — the renderer recognizes
+// the stride and speaks it as a cadence, not the clock-time cross-product.
 function hourStride(
   ir: IR
 ): {start: number; interval: number; last: number} | null {
@@ -1146,6 +1243,13 @@ function hourStride(
 
   if (segments.length === 1 && segments[0].kind === 'step') {
     const segment = segments[0];
+
+    // A bounded step that fires only once (e.g. `9-10/5` -> just 9) is a single
+    // value, not a stride: it has no interval to speak and no endpoint to pin.
+    if (segment.fires.length < 2) {
+      return null;
+    }
+
     const start = segment.startToken === '*' ?
       0 :
       +segment.startToken.split('-')[0];
@@ -1155,9 +1259,25 @@ function hourStride(
   }
 
   const values = singleValues(segments);
-  const step = values && arithmeticStep(values);
 
-  return step || null;
+  return values && hourListStride(values);
+}
+
+// The bounded cadence for an hour stride that pins both clock-time endpoints,
+// or null when the hour is not such a stride. The core rewrites a uneven step
+// to its fire list, so a minute window/list/step crossed with it lands in the
+// enumerating list paths; there the bounded hour reads better as its cadence
+// ("…, viiden tunnin välein klo 0–20") than as a wall of clock times. An
+// offset-clean stride keeps its existing confinement form, so only the
+// endpoint-bearing case routes here.
+function unevenHourCadence(ir: IR, opts: NormalizedOptions): string | null {
+  const stride = hourStride(ir);
+
+  if (!stride || offsetCleanStride(stride)) {
+    return null;
+  }
+
+  return hourStrideCadence(stride, opts);
 }
 
 // The second's status against a pinned minute: a wildcard or sub-minute step
@@ -1214,7 +1334,13 @@ function hourCadence(ir: IR, minute: number,
 
   const fires = (stride.last - stride.start) / stride.interval + 1;
 
-  if (ir.pattern.second === '0' && fires <= maxClockTimes) {
+  // A short stride that spells out as few clock times stays an enumeration only
+  // when it wraps cleanly (an offset-clean stride with no endpoint): the bare
+  // or "alkaen" form is no shorter than the list. A bounded or uneven stride
+  // has no clean wrap, so its endpoint-pinning cadence ("viiden tunnin välein
+  // klo 0–20") reads better however short.
+  if (ir.pattern.second === '0' && fires <= maxClockTimes &&
+      offsetCleanStride(stride)) {
     return null;
   }
 
@@ -1232,6 +1358,13 @@ function hourCadence(ir: IR, minute: number,
       everyNthHour(segment, opts) + trailingQualifier(ir, opts);
   }
 
+  // A plain top-of-the-hour fire (minute 0 with no meaningful second) has no
+  // lead clause to fold in, so the bounded cadence stands on its own ("viiden
+  // tunnin välein klo 0–20").
+  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);
 }
@@ -1249,6 +1382,55 @@ function cleanHourStride(segment: StepSegment): boolean {
   return 24 % segment.interval === 0 && start < segment.interval;
 }
 
+// Whether the hour field is a range — or a list whose segments include a
+// range — and so forms a window rather than a cross-product of clock times.
+// A pure single-value list (9,17) has no range to span and still enumerates;
+// a step is handled by hourStride/hourCadence.
+function hasHourWindow(ir: IR): boolean {
+  const segments = ir.analyses.segments.hour;
+
+  return !!segments && segments.some(function range(segment: Segment) {
+    return segment.kind === 'range';
+  });
+}
+
+// The hour-range window as a cadence tail at the top of each hour: a lone
+// range is the bare "klo 9–17"; a range plus a non-contiguous hour joins it
+// with "sekä klo" ("klo 9–20 sekä klo 22"), the same idiom the bare folded
+// window uses. The minute has folded into the lead, so the window closes on
+// the top of its final hour.
+function hourRangeWindowTail(ir: IR, opts: NormalizedOptions): string {
+  return ir.analyses.segments.hour!.length === 1 ?
+    hourSegmentTimes(ir, 0, null, opts) :
+    hourSegmentTimesWithSeka(ir, 0, null, opts);
+}
+
+// Render an hour range (or a list whose segments include a range) under
+// minute 0 and a meaningful second as the hour-range window — the lead clause,
+// then "klo 9–17" — instead of cross-multiplying the hours into a wall of
+// clock times. The hour-RANGE analog of hourCadence. Returns null when the
+// hour has no range, when the minute is non-zero (a real clock minute the
+// existing window form already speaks), or when a plain :00 set carries no
+// clause. Renderer-only; the IR is unchanged.
+function hourRangeCadence(ir: IR, minute: number,
+  opts: NormalizedOptions): string | null {
+  if (minute !== 0 || !hasHourWindow(ir) || ir.pattern.second === '0') {
+    return null;
+  }
+
+  const tail = hourRangeWindowTail(ir, opts);
+
+  // A wildcard or sub-minute step second is the whole minute-0 window
+  // ("minuutin ajan", carried by hourCadenceLead), then the window — kept
+  // distinct from the bare "joka tunti klo 9–17" so the confinement is never
+  // heard as it (the hour-range analog of "minuutin ajan joka toisen tunnin
+  // aikana"). A meaningful second leads at its mark, then the window.
+  const joiner = subMinuteSecond(ir) ? ' ' : ', ';
+
+  return hourCadenceLead(ir, minute, opts) + joiner + tail +
+    trailingQualifier(ir, opts);
+}
+
 // --- Hour-time phrasing. ---
 
 // On-the-hour fires as one klo phrase: "klo 0, 10 ja 20".
@@ -1276,23 +1458,32 @@ function kloFromTimes(
   return hourSegmentTimes(ir, 0, null, opts);
 }
 
-// Each fire hour as its own one-hour dash window under a single klo:
-// "klo 9.00–9.59 ja 17.00–17.59". Finnish prefers this to the English
-// "during the 9 a.m. and 5 p.m. hours" shape.
+// The hours accompanying a named-once minute clause under an hour list or
+// step. On-the-hour hours (a fires set, or a segment set with no real range)
+// are listed once — "klo 0, 5, 10, 15 ja 20" — so the minute is never repeated
+// as a per-hour span. A real hour RANGE segment is a genuine span and keeps its
+// per-segment window ("klo 8.00–18.59 ja 22.00–22.59"), mirroring the other
+// languages, which list discrete hours but keep range windows.
 function hourWindowsFromTimes(
   ir: IR,
   times: HourTimesPlan,
   opts: NormalizedOptions
 ): string {
   if (times.kind === 'fires') {
-    return 'klo ' + joinList(times.fires.map(function window(hour: number) {
-      return hourWindowDigits(hour, opts);
-    }));
+    return kloList(times.fires, opts);
+  }
+
+  const segments = ir.analyses.segments.hour!;
+
+  if (!segments.some(function ranged(segment: Segment) {
+    return segment.kind === 'range';
+  })) {
+    return kloList(hourSegmentFires(segments), opts);
   }
 
   const pieces: string[] = [];
 
-  ir.analyses.segments.hour!.forEach(function window(segment: Segment) {
+  segments.forEach(function window(segment: Segment) {
     if (segment.kind === 'range') {
       pieces.push(rangeDigits({hour: +segment.bounds[0], minute: 0},
         {hour: +segment.bounds[1], minute: 59}, opts));
@@ -1310,6 +1501,23 @@ function hourWindowsFromTimes(
   return 'klo ' + joinList(pieces);
 }
 
+// The on-the-hour fires of a range-free hour segment set, in order: a step
+// segment contributes its enumerated fires, a single its one value.
+function hourSegmentFires(segments: Segment[]): number[] {
+  const hours: number[] = [];
+
+  segments.forEach(function each(segment: Segment) {
+    if (segment.kind === 'step') {
+      hours.push(...segment.fires);
+    }
+    else if (segment.kind === 'single') {
+      hours.push(+segment.value);
+    }
+  });
+
+  return hours;
+}
+
 // "9.00–9.59": one hour as a dash window, in digits.
 function hourWindowDigits(hour: number, opts: NormalizedOptions): string {
   return rangeDigits({hour, minute: 0}, {hour, minute: 59}, opts);
@@ -1497,7 +1705,9 @@ function weekdayQualifier(ir: IR): string {
     return quartz;
   }
 
-  const segments = flattenSteps(ir.analyses.segments.weekday!);
+  // Weekday lists display Monday-first (Sunday last); a lone range keeps its
+  // form. The IR stays canonical (Sunday=0). The helper flattens steps.
+  const segments = orderWeekdaysForDisplay(ir.analyses.segments.weekday!);
 
   return joinList(segments.map(function piece(segment: FlatSegment) {
     if (segment.kind === 'range') {