cronli5 0.1.6 → 0.1.7

package/src/lang/es/index.ts

@@ -10,7 +10,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 type {Cronli5Options} from '../../types.js';
 import type {
   Field, HourTimesPlan, IR, Language, NormalizedOptions, PlanNode,
@@ -313,7 +315,7 @@ function renderComposeSeconds(
   if (plan.rest.kind === 'hourRange' && ir.shapes.second === 'step' &&
       ir.pattern.weekday !== '*') {
     const restNode = plan.rest;
-    const window = hourWindow(restNode, opts);
+    const window = hourWindow(boundedWindow(restNode), opts);
     const dayFrame = weekdayQualifier(ir) + monthScope(ir);
     const cadence = 'cada ' +
       numero(stepSegment(ir.analyses.segments.second).interval, opts) +
@@ -754,13 +756,18 @@ function renderHourStep(
     trailingQualifier(ir, opts);
 }
 
-// The hour-range plan as a window whose closing minute honors `boundMinute`:
-// a bare close (`null`) lands on the top of the final hour (minute 0),
-// matching the minute-0 baseline, with the minutes stated separately.
+// The hour-range plan as a window. The close lands on the top of the final
+// hour (minute 0) unless the minute genuinely runs to the end of that hour —
+// i.e. a wildcard minute, which fills every minute and states no separate
+// clause. A pinned/listed/ranged minute is named in its own lead clause, so
+// folding it into the close too would read as a span ("a las 17:05") that
+// contradicts the minute clause; the window stays bare ("a las 17:00").
 function boundedWindow(
   plan: Extract<PlanNode, {kind: 'hourRange'}>
 ): {from: number; to: number; last: number} {
-  return {from: plan.from, last: plan.boundMinute ?? 0, to: plan.to};
+  const last = plan.minuteForm === 'wildcard' ? plan.boundMinute ?? 0 : 0;
+
+  return {from: plan.from, last, to: plan.to};
 }
 
 // "de las 9:00 a las 17:45": a window from the top of the first hour to
@@ -839,7 +846,9 @@ function dowArm(ir: IR): string {
     return quartz;
   }
 
-  const segments = flattenSteps(fieldSegments(ir, '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(fieldSegments(ir, 'weekday'));
   const allSingles = segments.every(function single(segment) {
     return segment.kind === 'single';
   });
@@ -1258,7 +1267,7 @@ function renderCompactClockTimes(
   const phrase = cadence ?
     minutesList(ir, opts) + ', ' + cadence + trailingQualifier(ir, opts) :
     minutesList(ir, opts) + ', ' +
-      hourSegmentTimes(ir, 0, null, opts) + trailingQualifier(ir, opts);
+      hourContextTimes(ir, opts) + trailingQualifier(ir, opts);
 
   return ir.analyses.clockSecond ?
     secondsLeadClause(ir, opts) + ', ' + phrase :
@@ -1681,6 +1690,71 @@ function hourRangeCadence(ir: IR, minute: number, opts: Opts): string | null {
 
 // --- Hour-time phrasing. ---
 
+// The fixed hour(s) of a stepped/listed minute, named as the HOUR rather than a
+// "a las HH:00" clock instant the minute never fires at: noon and midnight read
+// as the hour word ("al mediodía"/"a medianoche"), any other hour as the whole
+// hour "de la hora de las HH:00" (the idiom a wildcard minute already uses).
+// Used by the compact-clock non-fold path, where the minute is a step or list
+// (a single-value minute keeps its real "a las HH:MM" clock time elsewhere).
+function hourContextTimes(ir: IR, opts: Opts): string {
+  const segments = hourSegments(ir);
+
+  // Collect the point hours (singles and step fires) — a range stays a window.
+  const points: number[] = [];
+  const hasRange = segments.some(function range(segment) {
+    return segment.kind === 'range';
+  });
+
+  segments.forEach(function collect(segment) {
+    if (segment.kind === 'step') {
+      points.push(...segment.fires);
+    }
+    else if (segment.kind === 'single') {
+      points.push(+segment.value);
+    }
+  });
+
+  // All point hours, all noon/midnight: stand alone as their own words ("a
+  // medianoche y al mediodía").
+  function isWord(hour: number): boolean {
+    return !opts.ampm && (hour === 0 || hour === 12);
+  }
+
+  if (!hasRange && points.every(isWord)) {
+    return joinList(points.map(function each(hour) {
+      return atTime(bareHourPhrase(hour, opts));
+    }));
+  }
+
+  // A point hour as the whole hour: "de la hora de las HH:00".
+  function wholeHour(hour: number): string {
+    return 'de la hora ' + fromTime(explicitTimePhrase(hour, 0, opts));
+  }
+
+  // Otherwise each whole hour reads as a window ("de las HH:00 a las HH:00" for
+  // a range, "de la hora de las HH:00" for a point), never a false "a las
+  // HH:00" clock instant the stepped minute never fires at.
+  const pieces: string[] = [];
+
+  segments.forEach(function place(segment) {
+    if (segment.kind === 'range') {
+      pieces.push(timeRange(
+        {hour: +segment.bounds[0], minute: 0},
+        {hour: +segment.bounds[1], minute: 0}, opts));
+    }
+    else if (segment.kind === 'step') {
+      segment.fires.forEach(function each(hour) {
+        pieces.push(wholeHour(hour));
+      });
+    }
+    else {
+      pieces.push(wholeHour(+segment.value));
+    }
+  });
+
+  return joinList(pieces);
+}
+
 // "a las 9:00" / "a la 1:00" / "al mediodía" for each fire hour.
 function atTimes(hours: number[], opts: Opts): string[] {
   return hours.map(function each(hour) {
@@ -2131,7 +2205,9 @@ function weekdayQualifier(ir: IR): string {
     return quartz;
   }
 
-  const segments = flattenSteps(fieldSegments(ir, '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(fieldSegments(ir, 'weekday'));
   const allSingles = segments.every(function single(segment) {
     return segment.kind === 'single';
   });

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,
@@ -1703,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') {

package/src/lang/zh/index.ts

@@ -4,7 +4,9 @@
 // big-endian dates, 每 for recurrence, 24-hour clock with 凌晨0点/正午 anchors,
 // day periods under `ampm`. The style contract is src/lang/zh/notes.md.
 
-import {arithmeticStep, toFieldNumber} from '../../core/util.js';
+import {
+  arithmeticStep, orderWeekdaysForDisplay, toFieldNumber
+} from '../../core/util.js';
 import {maxClockTimes, monthNumbers, weekdayNumbers} from '../../core/specs.js';
 import type {Cronli5Options} from '../../types.js';
 import type {
@@ -591,6 +593,30 @@ function hourCadencePhrase(ir: IR): string | null {
   });
 }
 
+// A wildcard or sub-minute step second confined to minute 0 of an hour stride
+// is a confinement, not a juxtaposed cadence. The even-hour stride (interval 2
+// from midnight) reuses 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"). An OFFSET stride names its start ("从1点起每2小时"),
+// already unambiguous — it cannot be heard as the bare cadence — so it folds
+// "0分" and the second onto that named cadence ("从1点起每2小时0分的每一秒"). A bare
+// cadence from midnight (no start named, e.g. "每3小时") keeps enumerating its
+// hours so it is never heard as the absorbing form.
+function minuteZeroConfinement(
+  ir: IR, stride: {interval: number; start: number}, prefix: string
+): string | null {
+  if (stride.interval === 2 && stride.start === 0) {
+    return '在偶数小时0分' + secondTail(ir);
+  }
+
+  if (prefix.indexOf('从') !== -1) {
+    return prefix + '0分' + secondTail(ir);
+  }
+
+  return null;
+}
+
 // Render an hour step (or arithmetic-progression hour list) under a single
 // 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
@@ -626,17 +652,8 @@ function hourCadence(ir: IR): string | 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 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 (interval 2 from midnight);
-  // another stride keeps enumerating (return null) rather than coin a
-  // misleading "…小时…" form.
   if (minute === 0 && subMinute) {
-    return stride.interval === 2 && stride.start === 0 ?
-      '在偶数小时0分' + secondTail(ir) : null;
+    return minuteZeroConfinement(ir, stride, prefix);
   }
 
   // A pinned minute 0 folds into the cadence with the explicit "0分" so the
@@ -1050,7 +1067,7 @@ function quartzDate(token: string, monthPrefix: string): string {
     return monthPrefix + '最后第' + token.slice(2) + '天';
   }
 
-  return '最接近' + token.slice(0, -1) + '日的工作日';
+  return monthPrefix + '最接近' + token.slice(0, -1) + '日的工作日';
 }
 
 // The date side of a qualifier (month folded in): "每月1日", "1月1日",
@@ -1071,7 +1088,17 @@ function datePhrase(ir: IR): string {
     return month + cadence(stepSegment(ir, 'date').interval, '天');
   }
 
-  return month ? month + dayList(ir) : '每月' + dayList(ir);
+  if (!month) {
+    return '每月' + dayList(ir);
+  }
+
+  // A multi-month scope (range/list) ends in 月 and would run straight into the
+  // day — "6月至8月1日" reads "8月1日" as August 1st. The comma keeps the month
+  // scope distinct from the day ("6月至8月，1日"). A single month stays glued
+  // ("6月1日"), which is unambiguous.
+  const monthMulti = ir.shapes.month === 'range' || ir.shapes.month === 'list';
+
+  return month + (monthMulti ? '，' : '') + dayList(ir);
 }
 
 // The date side WITHOUT its month or 每月 lead — just the day part: "1日",
@@ -1140,13 +1167,12 @@ function weekdayPhrase(
     return '每' + weekdayName(from) + '至' + weekdayName(to);
   }
 
+  // Weekday lists display Monday-first (Sunday last); the IR stays canonical
+  // (Sunday=0). The helper flattens steps into singles and orders the list.
   const days: number[] = [];
 
-  segs.forEach(function expand(seg) {
-    if (seg.kind === 'step') {
-      days.push(...seg.fires);
-    }
-    else if (seg.kind === 'single') {
+  orderWeekdaysForDisplay(segs).forEach(function expand(seg) {
+    if (seg.kind === 'single') {
       days.push(toFieldNumber(seg.value, weekdayNumbers));
     }
   });

package/types/core/util.d.ts

@@ -1,3 +1,4 @@
+import type { Segment } from './ir.js';
 declare function includes(str: string | number, sub: string): boolean;
 declare function unique<T>(items: T[]): T[];
 declare function isNonNegativeInteger(value: string): boolean;
@@ -6,7 +7,15 @@ declare function arithmeticStep(values: number[]): {
     interval: number;
     last: number;
 } | null;
+type WeekdaySegment = {
+    kind: 'single';
+    value: string;
+} | {
+    kind: 'range';
+    bounds: [string, string];
+};
+declare function orderWeekdaysForDisplay(segments: Segment[]): WeekdaySegment[];
 declare function toFieldNumber(token: string, numberMap?: {
     [name: string]: number;
 }): number;
-export { arithmeticStep, includes, isNonNegativeInteger, toFieldNumber, unique };
+export { arithmeticStep, includes, isNonNegativeInteger, orderWeekdaysForDisplay, toFieldNumber, unique };