cronli5 0.1.5 → 0.1.6

package/src/lang/zh/index.ts

@@ -314,9 +314,30 @@ function renderMinutePast(ir: IR): string {
   return minuteHourClause(ir);
 }
 
-// The hour list as clock words: "9点、11点和13点".
+// One hour segment as clock words by its form: a range is a span ("9点至20点"),
+// a single is one clock word ("22点"), a step keeps its fires enumerated as
+// clock words ("9点、11点、13点"). A range stated as a list element should read
+// as the span the source wrote, not the hours it expands to — the same choice
+// en/es/de/fi make ("from 9 a.m. through 8 p.m. and at 10 p.m.").
+function hourSegmentWords(segment: Segment): string[] {
+  if (segment.kind === 'range') {
+    return [hourWord(+segment.bounds[0]) + '至' + hourWord(+segment.bounds[1])];
+  }
+
+  if (segment.kind === 'step') {
+    return segment.fires.map(hourWord);
+  }
+
+  return [hourWord(+segment.value)];
+}
+
+// The hour field as clock words, by segment form: "9点、11点和13点" for a list
+// of singles, "9点至20点和22点" for a range plus a single. Each segment renders
+// as the operator the source wrote (range → span), not its expanded fires.
 function hourList(ir: IR): string {
-  return joinAnd(hourFires(ir).map(hourWord));
+  const words = fieldSegments(ir, 'hour').flatMap(hourSegmentWords);
+
+  return joinAnd(words);
 }
 
 // A frame that confines a cadence to active hours: a range gives "在F点至T点之
@@ -340,14 +361,17 @@ function renderMinuteFrequency(ir: IR, plan: PlanNode): string {
   const base = stepClause(minuteStep, UNITS.minute, '分', '每小时');
   const {hours} = plan as Extract<PlanNode, {kind: 'minuteFrequency'}>;
 
-  if (hours.kind === 'step') {
-    const hourStep = stepSegment(ir, 'hour');
+  // An hour stride (a clean step, or an offset/non-tiling progression the core
+  // kept a step shape or enumerated to a list) leads the minute cadence:
+  // "每2小时每5分钟", "从2点起每6小时每15分钟". A clean cadence concatenates as
+  // before; a bounded cadence ends on "至K点", so a comma keeps that endpoint
+  // from gluing onto the minute clause ("从9点起每2小时，至17点，每2分钟").
+  if (hours.kind === 'step' || hours.kind === 'during') {
+    const hourCad = hourCadencePhrase(ir);
 
-    // "每N小时" is only faithful from midnight; an offset step (2/6 fires at
-    // 2,8,14,20) enumerates its hours instead.
-    return hourStep.startToken === '*' ?
-      cadence(hourStep.interval, UNITS.hour) + base :
-      '在' + hourList(ir) + '，' + base;
+    if (hourCad !== null) {
+      return hourCad + (hourCad.indexOf('至') === -1 ? '' : '，') + base;
+    }
   }
 
   if (hours.kind === 'single' ||
@@ -383,15 +407,20 @@ function renderMinuteSpanInHour(ir: IR, plan: PlanNode): string {
 }
 
 // A minute clause across discrete hours. A wildcard minute reads "在9点、11点…，
-// 每分钟"; a ranged/listed minute names it: "9点和17点，每小时0至30分，每分钟".
+// 每分钟"; a ranged/listed minute names it: "9点和17点，每小时0至30分，每分钟". An
+// hour progression reads as its cadence ("从9点起每2小时，至17点，每分钟") rather
+// than the enumerated hours, the same idiom the minute field uses.
 function renderMinutesAcrossHours(ir: IR, plan: PlanNode): string {
   const {form} = plan as Extract<PlanNode, {kind: 'minutesAcrossHours'}>;
+  const hourCad = hourCadencePhrase(ir);
 
   if (form === 'wildcard') {
-    return '在' + hourList(ir) + '，每分钟';
+    return hourCad === null ?
+      '在' + hourList(ir) + '，每分钟' :
+      hourCad + '，每分钟';
   }
 
-  return hourList(ir) + '，' + minuteHourClause(ir) + '，每分钟';
+  return (hourCad ?? hourList(ir)) + '，' + minuteHourClause(ir) + '，每分钟';
 }
 
 // A minute clause across a stepped hour field. A wildcard minute reads "每2小时
@@ -400,22 +429,22 @@ function renderMinuteSpanAcrossHourStep(ir: IR, plan: PlanNode): string {
   const hourStep = stepSegment(ir, 'hour');
   const {form} = plan as Extract<PlanNode, {kind: 'minuteSpanAcrossHourStep'}>;
 
-  // A minute list enumerates its hours, with no "from M" idiom to lean on:
-  // "每小时5分和30分，在1点、3点…".
+  // A minute list reads as the hour cadence plus the minute list ("每2小时，
+  // 每小时0、25、50分"; offset "从1点起每2小时，每小时5分和30分"), the same compaction
+  // the wildcard/range minute already uses, rather than the enumerated hours.
   if (form === 'list') {
-    return renderMinutePast(ir) + '，在' + hourList(ir);
+    return hourCadencePhrase(ir) + '，' + renderMinutePast(ir);
   }
 
   const minuteTail = form === 'wildcard' ?
     '每分钟' :
     minuteHourClause(ir) + '，每分钟';
 
-  // An offset stride (2/6 fires at 2,8,14,20) enumerates its hours like a
-  // discrete list; "每N小时" is faithful only from midnight.
+  // An offset or non-tiling stride (2/6 fires at 2,8,14,20) reads as its
+  // cadence ("从2点起每6小时"). A wildcard minute hangs off it with a comma; a
+  // named minute follows the cadence and its own comma.
   if (hourStep.startToken !== '*') {
-    return form === 'wildcard' ?
-      '在' + hourList(ir) + '，' + minuteTail :
-      hourList(ir) + '，' + minuteTail;
+    return hourCadencePhrase(ir) + '，' + minuteTail;
   }
 
   // A step-2 hour from midnight IS exactly the even hours; name them so, rather
@@ -435,12 +464,10 @@ function renderMinuteSpanAcrossHourStep(ir: IR, plan: PlanNode): string {
 function renderClockTimes(ir: IR, plan: PlanNode, opts: Opts): 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.
-  if (ir.shapes.minute === 'single') {
-    const cad = hourCadence(ir);
+  const cad = hourCadenceText(ir);
 
-    if (cad !== null) {
-      return cad;
-    }
+  if (cad !== null) {
+    return cad;
   }
 
   const {times} = plan as Extract<PlanNode, {kind: 'clockTimes'}>;
@@ -454,20 +481,34 @@ function renderCompactClockTimes(ir: IR, plan: PlanNode): string {
   // An hour step (or arithmetic-progression hour list) under the single pinned
   // minute reads as a cadence, not a wall of clock times. (Returns null for an
   // irregular list or a range, which keep enumerating below.)
-  if (ir.shapes.minute === 'single') {
-    const cad = hourCadence(ir);
+  const cad = hourCadenceText(ir);
 
-    if (cad !== null) {
-      return cad;
-    }
+  if (cad !== null) {
+    return cad;
   }
 
-  const {minute} = plan as Extract<PlanNode, {kind: 'compactClockTimes'}>;
+  const compact = plan as Extract<PlanNode, {kind: 'compactClockTimes'}>;
   const secs = fieldSegments(ir, 'second');
   const tail = secs.length && ir.pattern.second !== '0' ?
     '，第' + valueText(secs) + '秒' : '';
 
-  if (minute > 0) {
+  // A multi-valued minute (`fold` false) names its whole set, never just its
+  // first fire — a list starting at 0 ("*/25" -> :00,:25,:50) must keep the
+  // minute clause, not drop it because the leading fire is 0. The hour reads as
+  // its bounded cadence when its fires form a progression ("从0点起每5小时，至20
+  // 点"), composed after the minute set, the same idiom the stepped-hour path
+  // uses; an irregular hour list keeps enumerating with the "在…" frame.
+  if (!compact.fold) {
+    const hourCad = hourCadencePhrase(ir);
+
+    return hourCad === null ?
+      minuteHourClause(ir) + '，在' + hourList(ir) + tail :
+      hourCad + '，' + minuteHourClause(ir) + tail;
+  }
+
+  // A single pinned minute past 0 leads with its clause; a pinned 0 folds into
+  // the hour times (the :00 is implicit).
+  if (compact.minute > 0) {
     return minuteHourClause(ir) + '，在' + hourList(ir) + tail;
   }
 
@@ -497,67 +538,71 @@ function renderHourRange(ir: IR, plan: PlanNode): string {
     range.last + '分之间，每分钟';
 }
 
-// A stepped hour field: "每2小时", or its two fires as clock words when the
-// stride fires only twice. An uneven stride (one that does not divide 24) is
-// rewritten to its fire list upstream and never reaches here.
+// A stepped hour field as its cadence: "每2小时" (clean), "从1点起每2小时"
+// (offset), "从9点起每2小时，至17点" (bounded). A stride that fires only twice
+// reads instead as its two clock words ("凌晨0点和正午", "8点和20点"), shorter and
+// clearer than a cadence for a pair.
 function renderHourStep(ir: IR): string {
   const segment = stepSegment(ir, 'hour');
 
-  if (segment.startToken !== '*') {
-    return hourList(ir);
-  }
-
-  // A step that fires only twice reads as two clock times ("凌晨0点和正午").
   if (segment.fires.length <= 2) {
     return joinAnd(segment.fires.map(hourWord));
   }
 
-  return cadence(segment.interval, UNITS.hour);
+  return hourCadencePhrase(ir) as string;
 }
 
 // --- Hour-step cadence (the 24-cycle analog of renderStride). ---
 
-// The hour field's stride, or null when the hour is not a cadence: a clean
-// step segment from midnight yields its {interval, last}; an all-single hour
-// list yields one only when its values form a long-enough arithmetic
-// progression from midnight (so an irregular list like 9,17 keeps
-// enumerating). Chinese has no "每N小时从X起" offset-hour idiom, so an offset or
-// bounded stride (start > 0, or an interval not dividing 24) returns null and
-// the caller enumerates its clock words, as before. The IR is unchanged.
-function hourStride(ir: IR): {interval: number; last: number} | null {
+// The hour field's stride, or null when the hour is not a cadence: a step
+// segment yields its {interval, start, last}; an all-single hour list yields
+// one only when its values form a long-enough arithmetic progression (so an
+// irregular list, or a too-short one like 9,17, keeps enumerating). An offset
+// (start > 0) or non-tiling (interval ∤ 24) stride is still a cadence — Chinese
+// names its start and endpoint ("从M点起每N小时，至K点"), the same idiom the
+// minute field already uses — so it is no longer rejected. The IR is unchanged.
+function hourStride(
+  ir: IR
+): {interval: number; start: number; last: number} | null {
   const segments = fieldSegments(ir, 'hour');
 
   if (segments.length === 1 && segments[0].kind === 'step') {
-    const segment = segments[0];
-    const start = segment.startToken === '*' ? 0 : +segment.startToken;
-
-    if (start !== 0 || 24 % segment.interval !== 0) {
-      return null;
-    }
+    const {fires, interval} = segments[0];
 
-    return {interval: segment.interval,
-      last: segment.fires[segment.fires.length - 1]};
+    return {interval, start: fires[0], last: fires[fires.length - 1]};
   }
 
   const values = singleValues(segments);
-  const step = values && arithmeticStep(values);
 
-  if (!step || step.start !== 0 || 24 % step.interval !== 0) {
-    return null;
-  }
+  return values && arithmeticStep(values);
+}
+
+// The hour field's cadence phrase ("每2小时", "从1点起每2小时", "从0点起每5小时，
+// 至20点"), or null when the hour is not a single arithmetic progression (an
+// irregular list, a range, or a too-short list keeps enumerating). The 24-cycle
+// analog of strideFromSegments — it routes the stride through the one phrasing
+// renderStride speaks, so a clean, offset, or non-tiling hour stride all read
+// as the cadence the equivalent minute step does.
+function hourCadencePhrase(ir: IR): string | null {
+  const stride = hourStride(ir);
 
-  return {interval: step.interval, last: step.last};
+  return stride && renderStride({
+    ...stride, cycle: 24, unit: UNITS.hour, mark: '点', anchor: ''
+  });
 }
 
 // Render an hour step (or arithmetic-progression hour list) under a single
-// pinned minute and a second as a cadence — "每N小时" plus the minute/second —
-// instead of cross-multiplying the hours into a wall of clock times. Returns
-// null when the hour is not a clean stride from midnight, or when the
-// cross-product is short enough that enumeration is no longer than the cadence:
-// a meaningful second makes every clock time carry a second, so any stride is
-// worth compacting; otherwise the stride must exceed the clock-time cap, the
-// same point at which the core itself stops enumerating. Renderer-only; the IR
-// is unchanged.
+// pinned minute and a second as a cadence — the hour cadence plus the
+// minute/second — instead of cross-multiplying the hours into a wall of clock
+// times. Returns null when the hour is not a stride, when the cross-product is
+// short enough that enumeration is no longer than the cadence (a meaningful
+// second makes every clock time carry a second, so any stride is worth
+// compacting; otherwise the stride must exceed the clock-time cap, the same
+// point at which the core itself stops enumerating), or when the cadence is
+// bounded ("…，至K点"): a trailing minute fused onto its endpoint ("至20点0分")
+// would read as a clock time, so a bounded stride keeps enumerating its fused
+// clock times here, naming the cadence only where no minute follows it (the
+// bare hour field). Renderer-only; the IR is unchanged.
 function hourCadence(ir: IR): string | null {
   const stride = hourStride(ir);
 
@@ -565,25 +610,33 @@ function hourCadence(ir: IR): string | null {
     return null;
   }
 
-  const fires = stride.last / stride.interval + 1;
+  const fires = (stride.last - stride.start) / stride.interval + 1;
 
   if (ir.pattern.second === '0' && fires <= maxClockTimes) {
     return null;
   }
 
-  const prefix = cadence(stride.interval, UNITS.hour);
+  const prefix = hourCadencePhrase(ir) as string;
+
+  // A bounded cadence cannot carry a fused minute unambiguously; enumerate.
+  if (prefix.indexOf('至') !== -1) {
+    return null;
+  }
+
   const minute = +ir.pattern.minute;
   const subMinute = ir.pattern.second === '*' || ir.shapes.second === 'step';
 
-  // A wildcard or sub-minute step second confined to minute 0 of a clean
+  // A wildcard or sub-minute step second confined to minute 0 of the even-hour
   // stride is a confinement, not a juxtaposed cadence. Reuse the even-hours
   // idiom ("在偶数小时0分的每一秒") so the form does NOT contain the bare "每2小时"
   // and can never be misread as the absorbing hour cadence (the same reason en
   // says "for one minute during every other hour", not "every two hours"). The
-  // idiom exists only for the even-hour stride; another clean stride keeps
-  // enumerating (return null) rather than coin a misleading "每N小时…" form.
+  // idiom exists only for the even-hour stride (interval 2 from midnight);
+  // another stride keeps enumerating (return null) rather than coin a
+  // misleading "…小时…" form.
   if (minute === 0 && subMinute) {
-    return stride.interval === 2 ? '在偶数小时0分' + secondTail(ir) : null;
+    return stride.interval === 2 && stride.start === 0 ?
+      '在偶数小时0分' + secondTail(ir) : null;
   }
 
   // A pinned minute 0 folds into the cadence with the explicit "0分" so the
@@ -599,6 +652,24 @@ function hourCadence(ir: IR): string | null {
     prefix + minute + '分' + secondTail(ir);
 }
 
+// The cadence a clock-point core (clockTimes/compactClockTimes/composeSeconds)
+// renders an hour stride to, or null. A bare hour stride (minute 0 on the plain
+// :00 second) is the cadence phrase itself — "每2小时", "从0点起每5小时，至20点" —
+// so a short non-tiling stride like */5, which hourCadence keeps enumerating
+// (no minute to fold, nothing to disambiguate), still reads as the cadence. A
+// pinned minute or meaningful second folds into the cadence via hourCadence.
+function hourCadenceText(ir: IR): string | null {
+  if (ir.shapes.minute !== 'single') {
+    return null;
+  }
+
+  if (+ir.pattern.minute === 0 && ir.pattern.second === '0') {
+    return hourCadencePhrase(ir);
+  }
+
+  return hourCadence(ir);
+}
+
 // The fused second tail for an hour cadence: "的每一秒" for a wildcard second,
 // else "的" + the second's own clause ("的第30秒", "的每15秒").
 function secondTail(ir: IR): string {
@@ -676,11 +747,13 @@ function minuteClause(ir: IR): string {
   return valueList(fieldSegments(ir, 'minute'), '分');
 }
 
-// Whether the hour field is a true "every N hours" cadence (vs discrete fires
-// like 9-17/2, whose start token is a number).
-function isHourCadence(ir: IR): boolean {
-  return ir.shapes.hour === 'step' &&
-    stepSegment(ir, 'hour').startToken === '*';
+// A single second folds into each clock time a clockTimes rest renders
+// ("9点5分30秒"), so it is already spoken; appending the second clause again
+// would double it. A wildcard/list/range second does not fold, so it still
+// leads its own clause after the clock times.
+function clockRestCarriesSecond(rest: PlanNode): boolean {
+  return rest.kind === 'clockTimes' &&
+    rest.times.some((time) => Boolean(time.second));
 }
 
 // minute = 0 ("on the hour"): render the rest schedule and attach the second.
@@ -710,11 +783,10 @@ function composeSecondsOnHour(ir: IR, plan: PlanNode, opts: Opts): string {
   }
 
   const restText = render(ir, rest, opts);
+  const secTail = clockRestCarriesSecond(rest) ? '' : sec;
 
-  if (rest.kind === 'clockTimes' || rest.kind === 'compactClockTimes') {
-    if (isDaily(ir)) {
-      return '每天' + restText + sec;
-    }
+  if (composedClock && isDaily(ir)) {
+    return '每天' + restText + secTail;
   }
 
   // A stated minute (e.g. minute 0 under a sub-minute second) takes the same
@@ -723,7 +795,7 @@ function composeSecondsOnHour(ir: IR, plan: PlanNode, opts: Opts): string {
     return restText + '，' + sec;
   }
 
-  return restText + sec;
+  return restText + secTail;
 }
 
 // A minute pinned to 0 under specific clock hours (not a compacted cadence): a
@@ -733,6 +805,15 @@ function composeSecondsOnHour(ir: IR, plan: PlanNode, opts: Opts): string {
 // :00, not 3,600 across the hour) stays visible. The daily frame leads with
 // 每天; a weekday or date qualifier is added by describe().
 function composeMinuteZeroClocks(ir: IR, sec: string): string {
+  // An hour RANGE (or a list whose segments include a range) reads as the span
+  // the source wrote ("9点至17点"), not the wall of clock words it expands to —
+  // the hour-RANGE analog of the hour-step cadence. A pure single-value list
+  // (9,17) has no range to span and keeps enumerating below.
+  if (hasHourWindow(ir)) {
+    return isDaily(ir) ? '每天' + hourRangeWindow(ir, sec) :
+      hourRangeWindow(ir, sec);
+  }
+
   const clocks = hourFires(ir).map(function clock(hour): string {
     // Noon's word (正午) already pins 12:00, so the "0分" is redundant for it;
     // midnight (凌晨0点) and other hours still need it to pin the minute.
@@ -747,13 +828,45 @@ function composeMinuteZeroClocks(ir: IR, sec: string): string {
   return isDaily(ir) ? '每天' + core : core;
 }
 
+// Whether the hour field is a range — or a list whose segments include a
+// range — and so forms a window ("9点至17点") rather than a wall of clock
+// words. A pure single-value list (9,17) has no range to span; a step is
+// handled by hourStride/hourCadence.
+function hasHourWindow(ir: IR): boolean {
+  return fieldSegments(ir, 'hour').some(function range(segment) {
+    return segment.kind === 'range';
+  });
+}
+
+// The hour-range window under a pinned minute 0 and a meaningful or wildcard
+// second: the hour span list ("9点至17点", "9点至20点和22点") plus the second.
+// A wildcard or sub-minute step second pins the explicit "0分" so the
+// one-minute confinement stays visible ("9点至17点0分的每一秒"), distinct from
+// the bare hourly window ("在9点至17点之间，每小时"); a single/list/range second
+// reads as a clock-point span with the second appended ("9点至17点，第30秒"),
+// matching the folded compact form for the same shape.
+function hourRangeWindow(ir: IR, sec: string): string {
+  const span = hourList(ir);
+
+  if (ir.pattern.second === '*' || ir.shapes.second === 'step') {
+    return span + '0分' + (sec === '每秒' ? '的每一秒' : '的' + sec);
+  }
+
+  return span + '，' + sec;
+}
+
 // Wildcard or stepped minute: hang the "每分钟/每N分钟每秒" tail off the hour.
 function composeSecondsCadence(ir: IR): string {
   const sec = secondClause(ir);
   const tail = minuteClause(ir) + sec;
 
-  if (isHourCadence(ir)) {
-    return cadence(stepSegment(ir, 'hour').interval, UNITS.hour) + '的' + tail;
+  const hourCad = hourCadencePhrase(ir);
+
+  if (hourCad !== null) {
+    // The cadence absorbs the tail with "的" ("每2小时的每分钟每秒",
+    // "从1点起每2小时的每分钟每秒"); a bounded cadence ends on "至K点", so its tail
+    // takes a comma to keep that endpoint from reading as a fused clock time.
+    return hourCad + (hourCad.indexOf('至') === -1 ? '的' : '，') + tail;
   }
 
   if (ir.shapes.hour === 'single') {
@@ -805,9 +918,10 @@ function composeSecondsListed(ir: IR): string {
     return minutes + '，' + sec;
   }
 
-  if (isHourCadence(ir)) {
-    return cadence(stepSegment(ir, 'hour').interval, UNITS.hour) + '，' +
-      minutes + '，' + sec;
+  const hourCad = hourCadencePhrase(ir);
+
+  if (hourCad !== null) {
+    return hourCad + '，' + minutes + '，' + sec;
   }
 
   return hourFrame(ir) + minutes + '，' + sec;
@@ -1141,10 +1255,11 @@ function composeWindow(ir: IR, core: string): string {
   return qualifier(ir) + core;
 }
 
-// Whether an hour cadence applies — a single pinned minute over a clean hour
-// stride — so the clock-point plans take the cadence frame, not the daily one.
+// Whether an hour cadence applies — a single pinned minute over an hour stride
+// (clean, offset, or non-tiling) — so the clock-point plans take the cadence
+// frame, not the daily one.
 function hourCadenceApplies(ir: IR): boolean {
-  return ir.shapes.minute === 'single' && hourCadence(ir) !== null;
+  return hourCadenceText(ir) !== null;
 }
 
 function describe(ir: IR, opts: Opts): string {