cronli5 0.1.2 → 0.1.4

package/src/lang/es/index.ts

@@ -9,6 +9,8 @@
 // lists render as per-hour windows).
 
 import {clockDigits, numeral} from '../../core/format.js';
+import {weekdayNumbers} from '../../core/specs.js';
+import {toFieldNumber} from '../../core/util.js';
 import type {Cronli5Options} from '../../types.js';
 import type {
   Field, HourTimesPlan, IR, Language, NormalizedOptions, PlanNode,
@@ -109,16 +111,6 @@ const weekdayNames = [
   'sábado'
 ];
 
-// Cron token vocabulary (JAN..DEC, SUN..SAT) is part of cron syntax; map
-// it to Spanish names.
-const monthTokens: {[token: string]: number} = {
-  JAN: 1, FEB: 2, MAR: 3, APR: 4, MAY: 5, JUN: 6,
-  JUL: 7, AUG: 8, SEP: 9, OCT: 10, NOV: 11, DEC: 12
-};
-const weekdayTokens: {[token: string]: number} = {
-  SUN: 0, MON: 1, TUE: 2, WED: 3, THU: 4, FRI: 5, SAT: 6
-};
-
 // Ordinals for Quartz `#` weekday occurrences (1-5).
 const nthWeekdayNames =
   [null, 'primer', 'segundo', 'tercer', 'cuarto', 'quinto'];
@@ -219,6 +211,13 @@ function renderComposeSeconds(
   plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
   opts: Opts
 ): string {
+  // A wildcard or stepped second with the minute pinned to a single value
+  // across one or more specific hours: the seconds confine to the clock time.
+  if (plan.rest.kind === 'clockTimes' &&
+      (ir.shapes.second === 'wildcard' || ir.shapes.second === 'step')) {
+    return pinnedMinuteSeconds(ir, plan.rest, opts);
+  }
+
   // Seconds list + fixed clock time: nest the seconds into the clock time(s)
   // with genitive "de las HH:MM" instead of "de cada minuto"; the minute is
   // fixed so "de cada minuto" is misleading. Single seconds already fold into
@@ -256,6 +255,33 @@ function renderComposeSeconds(
   return secondsLeadClause(ir, opts) + ', ' + render(ir, plan.rest, opts);
 }
 
+// A wildcard or stepped second under a single pinned minute and specific
+// hour(s). The clock-time rest folds the minute into the hour, and on the
+// 12-hour clock a pinned minute-0 drops the :00 entirely ("a las 9 de la
+// mañana") — and even "a las 9" reads aloud as the whole hour, hiding the
+// one-minute confinement (60 fires in :00, not 3,600 across the hour). Minute
+// 0 is the one-minute window at the top of each named hour: a duration frame
+// ("durante un minuto a las 9") states the confinement outright, with the hour
+// as a bare hour so it cannot be heard as the whole hour. A non-zero pinned
+// minute is an unambiguous clock time, so the genitive "de las 09:05" form
+// reads it as the minute, never the hour.
+function pinnedMinuteSeconds(
+  ir: IR,
+  rest: Extract<PlanNode, {kind: 'clockTimes'}>,
+  opts: Opts
+): string {
+  const dayTrail = leadingQualifier(ir, opts).trimEnd();
+  const trail = dayTrail ? ', ' + dayTrail : '';
+
+  if (+rest.times[0].minute === 0) {
+    return secondsLeadClause(ir, opts) + ' durante un minuto ' +
+      durationHourList(rest.times, opts) + trail;
+  }
+
+  return secondsLeadClause(ir, opts) + ' de ' +
+    explicitClockList(rest.times, opts) + trail;
+}
+
 // The leading clause describing a second field relative to the minute.
 function secondsLeadClause(ir: IR, opts: Opts): string {
   const secondField = ir.pattern.second;
@@ -453,12 +479,21 @@ function renderMinuteFrequency(
   return phrase + trailingQualifier(ir, opts);
 }
 
-// "cada minuto de las 9:00 a las 9:29 de la mañana".
+// "cada minuto de las 9:00 a las 9:29 de la mañana". A wildcard minute is the
+// whole hour, so it reads as that hour itself ("cada minuto de la hora de las
+// 09:00") rather than a synthesized "de las HH:00 a las HH:59" range the
+// source never stated; a plain range is a real window and keeps "de … a …".
 function renderMinuteSpanInHour(
   ir: IR,
   plan: Extract<PlanNode, {kind: 'minuteSpanInHour'}>,
   opts: Opts
 ): string {
+  if (ir.pattern.minute === '*') {
+    return 'cada minuto de la hora ' +
+      fromTime(timePhrase(plan.hour, 0, null, opts)) +
+      trailingQualifier(ir, opts);
+  }
+
   return 'cada minuto ' +
     timeRange({hour: plan.hour, minute: plan.span[0]},
       {hour: plan.hour, minute: plan.span[1]}, opts) +
@@ -689,6 +724,82 @@ function renderClockTimes(
   return leadingQualifier(ir, opts) + groupClockTimes(phrases);
 }
 
+// The genitive clock-time list for a minute-0 compose-seconds confinement:
+// each time with its minute forced visible ("las 09:00"), grouped as usual,
+// then reframed from "a …" to the genitive "de …" the caller prepends. So a
+// pinned minute-0 reads "de las 09:00", never the bare hour.
+function explicitClockList(
+  times: {hour: number; minute: number; second?: number | null}[],
+  opts: Opts
+): string {
+  const phrases = times.map(function clock(time) {
+    return atTime(explicitTimePhrase(time.hour, time.minute, opts));
+  });
+  const grouped = groupClockTimes(phrases);
+
+  // Strip the leading "a " so the caller's "de " produces the genitive form.
+  return grouped.startsWith('a ') ? grouped.slice(2) : grouped;
+}
+
+// The bare-hour list for a minute-0 duration confinement, keeping the "a …"
+// frame the caller embeds after "durante un minuto": "a las 9",
+// "a medianoche", "a las 9, 10, 11 y 12". The hour reads as a bare hour
+// (no minutes), since the "durante un minuto" frame already carries the
+// one-minute window — never "las 09:00", which would read as the whole hour.
+function durationHourList(
+  times: {hour: number; minute: number; second?: number | null}[],
+  opts: Opts
+): string {
+  const phrases = times.map(function clock(time) {
+    return atTime(bareHourPhrase(time.hour, opts));
+  });
+
+  return groupClockTimes(phrases);
+}
+
+// A bare hour with its article, no minutes: "las 9" / "la 1" / "mediodía" /
+// "medianoche" on the 24-hour clock, or the 12-hour day-period form
+// ("las 9 de la mañana"). Used by the minute-0 duration frame, where the
+// minute is already stated and the clock minute would only mislead.
+function bareHourPhrase(hour: number, opts: Opts): string {
+  if (opts.ampm) {
+    return timePhrase(hour, 0, null, opts);
+  }
+
+  if (+hour === 0) {
+    return 'medianoche';
+  }
+
+  if (+hour === 12) {
+    return 'mediodía';
+  }
+
+  return (+hour === 1 ? 'la ' : 'las ') + hour;
+}
+
+// A clock time with its minute forced visible and the noon/midnight words
+// suppressed: "las 09:00", "las 9:00 de la mañana", "las 12:00 de la tarde".
+// So a pinned minute-0 confinement always shows its ":00".
+function explicitTimePhrase(hour: number, minute: number, opts: Opts): string {
+  if (!opts.ampm) {
+    const article = +hour === 1 ? 'la ' : 'las ';
+    const suffix = opts.style.hSuffix ? ' h' : '';
+
+    return article +
+      clockDigits({hour, minute, second: 0},
+        {pad: true, sep: opts.style.sep}) + suffix;
+  }
+
+  const display = hour % 12 || 12;
+  const time = (display === 1 ? 'la ' : 'las ') +
+    clockDigits({hour: display, minute, second: 0}, {sep: opts.style.sep});
+  const period = opts.style.meridiem === 'english' ?
+    meridiemMark(hour) :
+    dayPeriod(hour, opts);
+
+  return time + ' ' + period;
+}
+
 // Group a chronological run of "a la(s) …" clock phrases. The 12-hour clock
 // carries day periods ("de la <period>"), which group chronologically by
 // period; the 24-hour clock has none, so it falls through to article-grouping.
@@ -1689,16 +1800,13 @@ function numero(n: number, opts: Opts): string | number {
   return numeral(n, numeros, opts);
 }
 
-// A weekday name from a number or a cron token.
+// A weekday name from a canonical number, or from a Quartz stem (`5L`,
+// `MON#2`), which the core does not number-canonicalize: resolve any name
+// via the core's index and fold the Sunday alias 7 to 0.
 function weekdayName(token: NameToken): string {
-  if (token === '7' || token === 7) {
-    return weekdayNames[0];
-  }
+  const number = toFieldNumber('' + token, weekdayNumbers);
 
-  // `token` may be a numeric (string or number) field index or a cron name;
-  // the numeric path indexes the name array, the name path the token map.
-  return weekdayNames[token as number] ||
-    weekdayNames[weekdayTokens[token as string]];
+  return weekdayNames[number === 7 ? 0 : number];
 }
 
 // The plural weekday form: días ending in -s are invariant ("los lunes");
@@ -1709,12 +1817,10 @@ function pluralWeekday(token: NameToken): string {
   return name.endsWith('s') ? name : name + 's';
 }
 
-// A month name from a number or a cron token.
+// A month name from a canonical month number. The name array has a leading
+// null hole for the 1-based index.
 function monthName(token: NameToken): string {
-  // As with weekdays: a numeric index hits the name array, a cron name the
-  // token map. The name array has a leading null hole for the 1-based index.
-  return (monthNames[token as number] ||
-    monthNames[monthTokens[token as string]]) as string;
+  return monthNames[+token] as string;
 }
 
 // Whether a canonical field value is an open step (`*/n` or `a/n`).
@@ -1730,7 +1836,10 @@ const es: Language<SpanishStyle> = {
   fallback: 'un patrón cron irreconocible',
   options: normalizeOptions,
   reboot: 'al arrancar el sistema',
-  sentence: (description) => 'Se ejecuta ' + description + '.'
+  // A description ending in a period already carries it, so closing the
+  // sentence must not double it.
+  sentence: (description) =>
+    'Se ejecuta ' + description + (description.endsWith('.') ? '' : '.')
 };
 
 export default es;

package/src/lang/fi/index.ts

@@ -10,6 +10,8 @@
 // case-pair construction wherever digits appear.
 
 import {clockDigits, numeral} from '../../core/format.js';
+import {weekdayNumbers} from '../../core/specs.js';
+import {toFieldNumber} from '../../core/util.js';
 import {resolveDialect} from './dialects.js';
 import type {
   ClockTime, HourTimesPlan, IR, Language, NormalizedOptions, PlanNode,
@@ -159,16 +161,6 @@ const monthStems: (string | null)[] = [
   'joulu'
 ];
 
-// Cron token vocabulary (JAN..DEC, SUN..SAT) is part of cron syntax; map
-// it to field numbers.
-const monthTokens: {[token: string]: number} = {
-  JAN: 1, FEB: 2, MAR: 3, APR: 4, MAY: 5, JUN: 6,
-  JUL: 7, AUG: 8, SEP: 9, OCT: 10, NOV: 11, DEC: 12
-};
-const weekdayTokens: {[token: string]: number} = {
-  SUN: 0, MON: 1, TUE: 2, WED: 3, THU: 4, FRI: 5, SAT: 6
-};
-
 // Unit form tables for the anchored-minute/second constructions.
 // `mark` is the frequency for the "N minuutin kohdalla" ("at the
 // N-minute mark") form; `anchor` is the possessive for the elative
@@ -349,9 +341,42 @@ function renderComposeSeconds(
       hourClause + trailingQualifier(ir, opts);
   }
 
+  // A sub-minute second with the minute pinned to 0 and a specific hour: the
+  // clock-time rest would read "klo 9", dropping the pinned :00 and so the
+  // one-minute confinement (60 fires in :00, not 3,600 across the hour). Bind
+  // the seconds to the explicit clock minute with the "minuutin HH.00 aikana"
+  // frame (an "of"/during form, never a range) and trail the day qualifier
+  // ("joka sekunti minuutin 9.00 aikana, joka päivä").
+  if (plan.rest.kind === 'clockTimes' &&
+      plan.rest.times.every((time) => +time.minute === 0)) {
+    return composeMinuteZero(ir, plan.rest, opts);
+  }
+
   return secondsLeadClause(ir, opts) + ', ' + render(ir, plan.rest, opts);
 }
 
+// The minute-0 confinement: bind the seconds to the explicit clock minute(s)
+// in the "minuutin/minuuttien HH.00 aikana" frame (an "of"/during form, never
+// a range — a range would round-trip back to the whole hour) and trail the day
+// qualifier ("joka sekunti minuutin 9.00 aikana, joka päivä").
+function composeMinuteZero(
+  ir: IR,
+  rest: Extract<PlanNode, {kind: 'clockTimes'}>,
+  opts: NormalizedOptions
+): string {
+  const clocks = rest.times.map(function clock(time): string {
+    return clockDigits({hour: time.hour, minute: time.minute},
+      {sep: opts.style.sep});
+  });
+  const frame = clocks.length === 1 ?
+    'minuutin ' + clocks[0] :
+    'minuuttien ' + joinList(clocks);
+  const dayTrail = leadingQualifier(ir, opts).trimEnd();
+
+  return secondsLeadClause(ir, opts) + ' ' + frame + ' aikana' +
+    (dayTrail ? ', ' + dayTrail : '');
+}
+
 // The leading clause describing a second field relative to the minute.
 function secondsLeadClause(ir: IR, opts: NormalizedOptions): string {
   const secondField = ir.pattern.second;
@@ -542,12 +567,20 @@ function renderMinuteFrequency(
   return phrase + trailingQualifier(ir, opts);
 }
 
-// "joka minuutti klo 9.00–9.59".
+// "joka minuutti klo 9.00–9.59". A wildcard minute is the whole hour, so it
+// reads as that hour itself ("joka minuutti kello 9 aikana") rather than a
+// synthesized "klo 9.00–9.59" range the source never stated; a plain range is
+// a real window and keeps the dash form.
 function renderMinuteSpanInHour(
   ir: IR,
   plan: Extract<PlanNode, {kind: 'minuteSpanInHour'}>,
   opts: NormalizedOptions
 ): string {
+  if (ir.pattern.minute === '*') {
+    return 'joka minuutti kello ' + plan.hour + ' aikana' +
+      trailingQualifier(ir, opts);
+  }
+
   return 'joka minuutti ' +
     kloRange({hour: plan.hour, minute: plan.span[0]},
       {hour: plan.hour, minute: plan.span[1]}, opts) +
@@ -1339,18 +1372,16 @@ function quartzWeekdayPhrase(weekdayField: string): string | undefined {
   }
 }
 
-// Resolve a weekday token or number to its table index.
+// Resolve a weekday to its table index. Weekday-field segments are already
+// canonical numbers; a Quartz stem (`5L`, `MON#2`) is not, so resolve any
+// name via the core's index (with the Sunday alias 7 folding to 0).
 function weekdayNumber(token: string | number): number {
-  if (token in weekdayTokens) {
-    return weekdayTokens[token];
-  }
-
-  return +token % 7;
+  return toFieldNumber('' + token, weekdayNumbers) % 7;
 }
 
-// Resolve a month token or number to its table index.
+// Resolve a canonical month number to its table index.
 function monthNumber(token: string | number): number {
-  return monthTokens[token] || +token;
+  return +token;
 }
 
 // --- Years. ---
@@ -1492,7 +1523,10 @@ const fi: Language = {
   fallback: 'tunnistamaton cron-lauseke',
   options: normalizeOptions,
   reboot: 'järjestelmän käynnistyessä',
-  sentence: (description) => 'Suoritetaan ' + description + '.'
+  // A description ending in a period already carries it, so closing the
+  // sentence must not double it.
+  sentence: (description) =>
+    'Suoritetaan ' + description + (description.endsWith('.') ? '' : '.')
 };
 
 export default fi;

package/src/lang/zh/index.ts

@@ -226,7 +226,13 @@ function renderMinuteFrequency(ir: IR, plan: PlanNode): string {
   const {hours} = plan as Extract<PlanNode, {kind: 'minuteFrequency'}>;
 
   if (hours.kind === 'step') {
-    return cadence(stepSegment(ir, 'hour').interval, UNITS.hour) + base;
+    const hourStep = stepSegment(ir, 'hour');
+
+    // "每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 (hours.kind === 'single' ||
@@ -247,10 +253,16 @@ function renderMinuteFrequency(ir: IR, plan: PlanNode): string {
   return base;
 }
 
-// A minute span within a single hour: "在9点至9点58分之间，每分钟".
+// A minute span within a single hour. A wildcard minute reads as that hour
+// itself — "凌晨0点的每一分钟" — not a synthesized "在H点至H点59分之间" range the
+// source never stated; a partial minute span keeps the named range.
 function renderMinuteSpanInHour(ir: IR, plan: PlanNode): string {
   const span = plan as Extract<PlanNode, {kind: 'minuteSpanInHour'}>;
 
+  if (ir.pattern.minute === '*') {
+    return hourWord(span.hour) + '的每一分钟';
+  }
+
   return '在' + hourWord(span.hour) + '至' + span.hour + '点' +
     span.span[1] + '分之间，每分钟';
 }
@@ -271,15 +283,31 @@ function renderMinutesAcrossHours(ir: IR, plan: PlanNode): string {
 // A minute clause across a stepped hour field. A wildcard minute reads "每2小时
 // 内，每分钟"; a ranged minute names it: "每2小时，每小时0至30分，每分钟".
 function renderMinuteSpanAcrossHourStep(ir: IR, plan: PlanNode): string {
-  const cad = cadence(stepSegment(ir, 'hour').interval, UNITS.hour);
+  const hourStep = stepSegment(ir, 'hour');
   const {form} = plan as Extract<PlanNode, {kind: 'minuteSpanAcrossHourStep'}>;
+  const minuteTail = form === 'wildcard' ?
+    '每分钟' :
+    '每小时' + valueList(fieldSegments(ir, 'minute'), '分') + '，每分钟';
 
-  if (form === 'wildcard') {
-    return cad + '内，每分钟';
+  // An offset stride (2/6 fires at 2,8,14,20) enumerates its hours like a
+  // discrete list; "每N小时" is faithful only from midnight.
+  if (hourStep.startToken !== '*') {
+    return form === 'wildcard' ?
+      '在' + hourList(ir) + '，' + minuteTail :
+      hourList(ir) + '，' + minuteTail;
   }
 
-  return cad + '，每小时' + valueList(fieldSegments(ir, 'minute'), '分') +
-    '，每分钟';
+  // A step-2 hour from midnight IS exactly the even hours; name them so, rather
+  // than the vague "每2小时内" that reads as an interval. Other strides keep it.
+  if (hourStep.interval === 2 && form === 'wildcard') {
+    return '在偶数小时，' + minuteTail;
+  }
+
+  const cad = cadence(hourStep.interval, UNITS.hour);
+
+  return form === 'wildcard' ?
+    cad + '内，' + minuteTail :
+    cad + '，' + minuteTail;
 }
 
 // Discrete clock times: "9点", "9点和17点".
@@ -422,11 +450,30 @@ function isHourCadence(ir: IR): boolean {
 function composeSecondsOnHour(ir: IR, plan: PlanNode, opts: Opts): string {
   const sec = secondClause(ir);
   const {rest} = plan as Extract<PlanNode, {kind: 'composeSeconds'}>;
-  const restText = render(ir, rest, opts);
 
+  // The minute is pinned to 0 under a specific hour: a bare clock word ("9点")
+  // would hide the :00 and leave the second dangling ("…9点每秒"), reading as
+  // the whole hour. Fuse the seconds with the explicit clock minute ("9点0分
+  // 的每一秒"), so the one-minute confinement (60 fires in :00, not 3,600
+  // across the hour) stays visible. The daily frame leads with 每天; a weekday
+  // or date qualifier is added by describe().
   if ((rest.kind === 'clockTimes' || rest.kind === 'compactClockTimes') &&
-    isDaily(ir)) {
-    return '每天' + restText + sec;
+    ir.pattern.minute === '0') {
+    const clocks = hourFires(ir).map(function clock(hour): string {
+      return hourWord(hour) + '0分';
+    });
+    const tail = sec === '每秒' ? '的每一秒' : '的' + sec;
+    const core = joinAnd(clocks) + tail;
+
+    return isDaily(ir) ? '每天' + core : core;
+  }
+
+  const restText = render(ir, rest, opts);
+
+  if (rest.kind === 'clockTimes' || rest.kind === 'compactClockTimes') {
+    if (isDaily(ir)) {
+      return '每天' + restText + sec;
+    }
   }
 
   // A stated minute (e.g. minute 0 under a sub-minute second) takes the same
@@ -466,6 +513,14 @@ function composeSecondsListed(ir: IR): string {
   const sec = secondClause(ir);
   const minutes = '每小时' + valueList(fieldSegments(ir, 'minute'), '分');
 
+  // A single restricted hour with an every-second cadence fuses the clock time
+  // with its minutes — "凌晨0点5、20、35、50分的每一秒" — rather than the "每小时"
+  // that falsely implies every hour. A non-wildcard second keeps the list form.
+  if (ir.shapes.hour === 'single' && sec === '每秒') {
+    return hourWord(hourFires(ir)[0]) +
+      valueList(fieldSegments(ir, 'minute'), '分') + '的每一秒';
+  }
+
   if (ir.shapes.hour === 'wildcard') {
     return minutes + '，' + sec;
   }
@@ -479,12 +534,28 @@ function composeSecondsListed(ir: IR): string {
 }
 
 // Seconds composed with the minute/hour structure, dispatched on the minute.
+// A single minute over a composed clock-time rest (the core already joined the
+// lone hour and minute into "N点M分") keeps that composition, attaching the
+// second to it rather than splitting the minute back out into the "每小时N分"
+// list path; a minute list stays on that list path so each fire is named.
 function renderComposeSeconds(ir: IR, plan: PlanNode, opts: Opts): string {
-  if (ir.pattern.minute === '0') {
+  const {rest} = plan as Extract<PlanNode, {kind: 'composeSeconds'}>;
+  const composedClock =
+    rest.kind === 'clockTimes' || rest.kind === 'compactClockTimes';
+
+  if (ir.pattern.minute === '0' ||
+    composedClock && ir.shapes.minute === 'single') {
     return composeSecondsOnHour(ir, plan, opts);
   }
 
-  if (ir.pattern.minute === '*' || ir.shapes.minute === 'step') {
+  // "每N分钟" is faithful only for a wildcard or top-of-hour step; an offset
+  // step (5/15 fires at :05,:20,…) takes the enumerated list path so its start
+  // is named, never dropped.
+  const minuteCadence = ir.pattern.minute === '*' ||
+    ir.shapes.minute === 'step' &&
+      stepSegment(ir, 'minute').startToken === '*';
+
+  if (minuteCadence) {
     return composeSecondsCadence(ir);
   }