cronli5 0.1.1 → 0.1.4

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,
@@ -62,7 +64,6 @@ interface UnitForms {
   anchor: string;
   ela: string;
   gen: string;
-  restart: string;
 }
 
 // Genitive numerals for the "N <unit>in välein" construction, spelled
@@ -160,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
@@ -179,15 +170,13 @@ const units: {minute: UnitForms; second: UnitForms} = {
     mark: 'joka tunti',
     anchor: 'jokaisen tunnin',
     ela: 'minuutista',
-    gen: 'minuutin',
-    restart: 'tasatunnista alkaen'
+    gen: 'minuutin'
   },
   second: {
     mark: 'joka minuutti',
     anchor: 'jokaisen minuutin',
     ela: 'sekunnista',
-    gen: 'sekunnin',
-    restart: 'joka minuutti'
+    gen: 'sekunnin'
   }
 };
 
@@ -352,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;
@@ -545,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) +
@@ -858,15 +888,9 @@ function stepCycle60(
       ' alkaen';
   }
 
-  if (60 % interval === 0) {
-    return cadence;
-  }
-
-  if (segment.fires.length <= 2) {
-    return atMarks(joinList(wordList(segment.fires)), unit, true);
-  }
-
-  return cadence + ' ' + unit.restart;
+  // A clean stride from the top of the cycle is the bare cadence. (An uneven
+  // stride is rewritten to its fires upstream and never reaches here.)
+  return cadence;
 }
 
 // "kahden tunnin välein", "klo 0, 10 ja 20", or "viiden tunnin välein
@@ -880,7 +904,9 @@ function stepHours(segment: StepSegment, opts: NormalizedOptions): string {
   const interval = segment.interval;
   const cadence = genitive(interval, opts) + ' tunnin välein';
 
-  if (start === 0 && 24 % interval === 0) {
+  // A clean stride from midnight is the bare cadence. (An uneven stride is
+  // rewritten to its fires upstream and never reaches here.)
+  if (start === 0) {
     return cadence;
   }
 
@@ -888,10 +914,6 @@ function stepHours(segment: StepSegment, opts: NormalizedOptions): string {
     return kloList(segment.fires, opts);
   }
 
-  if (start === 0) {
-    return cadence + ' keskiyöstä alkaen';
-  }
-
   return cadence + ' klo ' + hourElatives[start] + ' alkaen';
 }
 
@@ -1350,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. ---
@@ -1503,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

@@ -217,11 +217,22 @@ function hourFrame(ir: IR): string {
 
 // A repeating minute step, optionally confined to active hours.
 function renderMinuteFrequency(ir: IR, plan: PlanNode): string {
-  const base = cadence(stepSegment(ir, 'minute').interval, UNITS.minute);
+  const minuteStep = stepSegment(ir, 'minute');
+  // A "每N分钟" cadence is only faithful from the top of the hour; an offset
+  // step (5/6 fires at :05,:11,…) enumerates its fires instead.
+  const base = minuteStep.startToken === '*' ?
+    cadence(minuteStep.interval, UNITS.minute) :
+    renderMinutePast(ir);
   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' ||
@@ -242,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] + '分之间，每分钟';
 }
@@ -266,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;
+  }
+
+  // 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;
   }
 
-  return cad + '，每小时' + valueList(fieldSegments(ir, 'minute'), '分') +
-    '，每分钟';
+  const cad = cadence(hourStep.interval, UNITS.hour);
+
+  return form === 'wildcard' ?
+    cad + '内，' + minuteTail :
+    cad + '，' + minuteTail;
 }
 
 // Discrete clock times: "9点", "9点和17点".
@@ -323,8 +356,9 @@ function renderHourRange(ir: IR, plan: PlanNode): string {
     range.last + '分之间，每分钟';
 }
 
-// A stepped hour field: "每2小时", or "从凌晨0点起，每5小时" when the step does not
-// divide 24 (the cadence wraps), or its discrete fires as clock words.
+// 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.
 function renderHourStep(ir: IR): string {
   const segment = stepSegment(ir, 'hour');
 
@@ -332,16 +366,11 @@ function renderHourStep(ir: IR): string {
     return hourList(ir);
   }
 
-  // A step that fires only twice reads as two clock times ("凌晨0点和13点").
+  // A step that fires only twice reads as two clock times ("凌晨0点和正午").
   if (segment.fires.length <= 2) {
     return joinAnd(segment.fires.map(hourWord));
   }
 
-  if (24 % segment.interval !== 0) {
-    return '从' + hourWord(segment.fires[0]) + '起，' +
-      cadence(segment.interval, UNITS.hour);
-  }
-
   return cadence(segment.interval, UNITS.hour);
 }
 
@@ -421,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
@@ -465,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;
   }
@@ -478,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);
   }