cronli5 0.2.0 → 0.3.1

package/src/types.ts

@@ -46,22 +46,22 @@ export interface Cronli5Dialect {
 }
 
 /**
- * A language module is a renderer over the semantic IR plus the
+ * A language module is a renderer over the semantic Schedule plus the
  * language-owned strings and option normalization. The `describe`/`options`
- * payloads are the module's internal `IR`/options shapes (see
- * `core/ir.ts`). They are intentionally opaque at this public boundary,
+ * payloads are the module's internal `Schedule`/options shapes (see
+ * `core/schedule.ts`). They are intentionally opaque at this public boundary,
  * which a caller passes to `cronli5` via the `lang` option but never invokes
  * directly.
  */
 export interface Cronli5Language {
-  describe(ir: any, opts: any): string;
+  describe(schedule: any, opts: any): string;
   fallback: string;
   options(options?: Cronli5Options): any;
   reboot: string;
   sentence(description: string): string;
-  // Optional strategy override (see `core/ir.ts` `Language.strategy`). Opaque
+  // Optional plan override (see `core/schedule.ts` `Language.plan`). Opaque
   // at this public boundary, like `describe`/`options`.
-  strategy?(content: any, base: any): any;
+  plan?(facts: any, base: any): any;
 }
 
 /**

package/types/core/analyze.d.ts

@@ -1,4 +1,4 @@
-import type { Content, IR, Pattern, PlanNode } from './ir.js';
+import type { Pattern, PlanNode, Schedule, ScheduleFacts } from './schedule.js';
 declare function getOccurrences(start: number, interval: number, max: number): number[];
 declare function enumerateStep(field: string, min: number, max: number, numberMap?: {
     [name: string]: number;
@@ -8,6 +8,6 @@ declare function enumerateValues(field: string): number[];
 declare function minuteSpan(minuteField: string): [number, number] | null;
 declare function lastMinuteFire(minuteField: string): number;
 declare function clockSecond(secondField: string): number | undefined;
-declare function analyze(pattern: Pattern): IR;
-declare function selectStrategy(content: Content): PlanNode;
-export { analyze, clockSecond, enumerateFires, enumerateStep, enumerateValues, getOccurrences, lastMinuteFire, minuteSpan, selectStrategy };
+declare function analyze(pattern: Pattern): Schedule;
+declare function selectPlan(facts: ScheduleFacts): PlanNode;
+export { analyze, clockSecond, enumerateFires, enumerateStep, enumerateValues, getOccurrences, lastMinuteFire, minuteSpan, selectPlan };

package/types/core/cadence.d.ts

@@ -0,0 +1,33 @@
+import type { Field, Schedule, Segment } from './schedule.js';
+type StepSegment = Extract<Segment, {
+    kind: 'step';
+}>;
+declare function arithmeticStep(values: number[]): {
+    start: number;
+    interval: number;
+    last: number;
+} | null;
+declare function segmentsOf(schedule: Schedule, field: Field): Segment[];
+declare function stepSegment(schedule: Schedule, field: Field): StepSegment;
+declare function singleValues(segments: Segment[]): number[] | null;
+declare function offsetCleanStride(stride: {
+    start: number;
+    interval: number;
+}): boolean;
+interface StrideParts {
+    bare(): string;
+    offset(): string;
+    bounded(): string;
+}
+declare function renderStride(spec: {
+    start: number;
+    interval: number;
+    cycle: number;
+}, parts: StrideParts): string;
+declare function hourListStride(values: number[]): {
+    start: number;
+    interval: number;
+    last: number;
+} | null;
+export { arithmeticStep, hourListStride, offsetCleanStride, renderStride, segmentsOf, singleValues, stepSegment };
+export type { StrideParts };

package/types/core/index.d.ts

@@ -1,8 +1,10 @@
-import type { NormalizedOptions, Pattern } from './ir.js';
+import type { NormalizedOptions, Pattern } from './schedule.js';
 import type { CronPattern } from '../types.js';
 declare function prepare(cronPattern: CronPattern, opts: NormalizedOptions): Pattern;
 export { prepare };
 export * from './specs.js';
 export * from './util.js';
+export * from './weekday.js';
+export * from './cadence.js';
 export * from './shapes.js';
 export * from './analyze.js';

package/types/core/normalize.d.ts

@@ -1,5 +1,5 @@
 import type { CronLike } from './specs.js';
-import type { Pattern } from './ir.js';
+import type { Pattern } from './schedule.js';
 declare function applyQuartzAliases(cronPattern: CronLike): void;
 declare function normalizeCronPattern(cronPattern: CronLike): Pattern;
 export { applyQuartzAliases, normalizeCronPattern };

package/types/core/parse.d.ts

@@ -1,5 +1,5 @@
 import type { CronLike } from './specs.js';
-import type { NormalizedOptions } from './ir.js';
+import type { NormalizedOptions } from './schedule.js';
 import type { CronPattern } from '../types.js';
 declare function parseCronPattern(cronPattern: CronPattern, opts: NormalizedOptions): CronLike;
 export { parseCronPattern };

package/types/core/{ir.d.ts → schedule.d.ts}

@@ -43,11 +43,6 @@ export type HoursPlan = {
 } | {
     kind: 'during';
     times: HourTimesPlan;
-} | {
-    kind: 'single';
-    from: number;
-    to: number;
-    last: number;
 };
 /** Hour times: enumerated fires, or deferred to per-segment rendering. */
 export type HourTimesPlan = {
@@ -57,7 +52,7 @@ export type HourTimesPlan = {
     kind: 'segments';
 };
 /**
- * The rendering strategy the core selects for a pattern. The `kind`
+ * The rendering plan the core selects for a pattern. The `kind`
  * discriminant tells a renderer which fields are present.
  */
 export type PlanNode = {
@@ -121,25 +116,25 @@ export interface Analyses {
     segments: Record<Field, Segment[] | null>;
 }
 /**
- * The neutral content plan: the language-independent facts about a pattern,
- * carrying no phrasing decision. `analyze` produces this; `selectStrategy`
- * reads it to suggest a `plan`. The phrasing strategy is deliberately *not*
- * part of the neutral content (docs/i18n-design.md §2.2).
+ * The neutral schedule facts: the language-independent facts about a pattern,
+ * carrying no phrasing decision. `analyze` produces this; `selectPlan`
+ * reads it to suggest a `plan`. The phrasing plan is deliberately *not*
+ * part of the neutral facts (docs/i18n-design.md §2.2).
  */
-export interface Content {
+export interface ScheduleFacts {
     pattern: Pattern;
     shapes: Shapes;
     analyses: Analyses;
 }
 /**
- * The semantic intermediate representation a language renders: the neutral
- * `Content` plus the selected `plan`. A language may widen `plan` with its
- * own `Extra` strategy kinds via `Language.strategy`; by default there are
- * none, so `IR` is the neutral content with a core `PlanNode`.
+ * The semantic schedule a language renders: the neutral `ScheduleFacts`
+ * plus the selected `plan`. A language may widen `plan` with its own
+ * `Extra` plan kinds via `Language.plan`; by default there are none, so
+ * `Schedule` is the neutral facts with a core `PlanNode`.
  */
-export interface IR<Extra extends {
+export interface Schedule<Extra extends {
     kind: string;
-} = never> extends Content {
+} = never> extends ScheduleFacts {
     plan: PlanNode | Extra;
 }
 /** A resolved style table. */
@@ -172,16 +167,16 @@ export interface NormalizedOptions<Style = DialectStyle> {
 }
 /**
  * The interface every language module's default export implements. `Extra`
- * lets a language add its own strategy kinds (default: none), which its
- * `strategy` override emits and its `describe` renders.
+ * lets a language add its own plan kinds (default: none), which its
+ * `plan` override emits and its `describe` renders.
  */
 export interface Language<Style = DialectStyle, Extra extends {
     kind: string;
 } = never> {
-    describe(ir: IR<Extra>, opts: NormalizedOptions<Style>): string;
+    describe(schedule: Schedule<Extra>, opts: NormalizedOptions<Style>): string;
     fallback: string;
     options(options?: Cronli5Options): NormalizedOptions<Style>;
     reboot: string;
     sentence(description: string): string;
-    strategy?(content: Content, base: PlanNode): PlanNode | Extra;
+    plan?(facts: ScheduleFacts, base: PlanNode): PlanNode | Extra;
 }

package/types/core/shapes.d.ts

@@ -3,4 +3,5 @@ declare function isPlainRange(field: string): boolean;
 declare function isPlainStep(field: string): boolean;
 declare function isDiscreteList(field: string): boolean;
 declare function isDiscreteHours(hourField: string): boolean;
-export { isDiscreteHours, isDiscreteList, isPlainRange, isPlainStep, isSingleValue };
+declare function isOpenStep(field: string): boolean;
+export { isDiscreteHours, isDiscreteList, isOpenStep, isPlainRange, isPlainStep, isSingleValue };

package/types/core/specs.d.ts

@@ -1,4 +1,4 @@
-import type { Field } from './ir.js';
+import type { Field } from './schedule.js';
 /**
  * A parsed but not-yet-canonical cron pattern: every field present, values
  * still as the caller gave them (string or number) until normalization

package/types/core/util.d.ts

@@ -1,21 +1,7 @@
-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;
-declare function arithmeticStep(values: number[]): {
-    start: 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, orderWeekdaysForDisplay, toFieldNumber, unique };
+export { includes, isNonNegativeInteger, toFieldNumber, unique };

package/types/core/weekday.d.ts

@@ -0,0 +1,10 @@
+import type { Segment } from './schedule.js';
+type WeekdaySegment = {
+    kind: 'single';
+    value: string;
+} | {
+    kind: 'range';
+    bounds: [string, string];
+};
+declare function orderWeekdaysForDisplay(segments: Segment[]): WeekdaySegment[];
+export { orderWeekdaysForDisplay };

package/types/lang/de/index.d.ts

@@ -1,4 +1,4 @@
-import type { Language } from '../../core/ir.js';
+import type { Language } from '../../core/schedule.js';
 import { type GermanStyle } from './dialects.js';
 declare const de: Language<GermanStyle>;
 export default de;

package/types/lang/en/dialects.d.ts

@@ -1,4 +1,4 @@
 import type { Cronli5Options } from '../../types.js';
-import type { DialectStyle } from '../../core/ir.js';
+import type { DialectStyle } from '../../core/schedule.js';
 declare function resolveDialect(dialect?: Cronli5Options['dialect']): DialectStyle;
 export { resolveDialect };

package/types/lang/en/index.d.ts

@@ -1,3 +1,3 @@
-import type { Language } from '../../core/ir.js';
+import type { Language } from '../../core/schedule.js';
 declare const en: Language;
 export default en;

package/types/lang/es/index.d.ts

@@ -1,4 +1,4 @@
-import type { Language } from '../../core/ir.js';
+import type { Language } from '../../core/schedule.js';
 import { type SpanishStyle } from './dialects.js';
 declare const es: Language<SpanishStyle>;
 export default es;

package/types/lang/fi/dialects.d.ts

@@ -1,4 +1,4 @@
-import type { DialectStyle } from '../../core/ir.js';
+import type { DialectStyle } from '../../core/schedule.js';
 import type { Cronli5Options } from '../../types.js';
 declare function resolveDialect(dialect?: Cronli5Options['dialect']): DialectStyle;
 export { resolveDialect };

package/types/lang/fi/index.d.ts

@@ -1,3 +1,3 @@
-import type { Language } from '../../core/ir.js';
+import type { Language } from '../../core/schedule.js';
 declare const fi: Language;
 export default fi;

package/types/lang/zh/index.d.ts

@@ -1,4 +1,4 @@
-import type { Language } from '../../core/ir.js';
+import type { Language } from '../../core/schedule.js';
 import { type ChineseStyle } from './dialects.js';
 declare const zh: Language<ChineseStyle>;
 export default zh;

package/types/types.d.ts

@@ -30,20 +30,20 @@ export interface Cronli5Dialect {
     through?: string;
 }
 /**
- * A language module is a renderer over the semantic IR plus the
+ * A language module is a renderer over the semantic Schedule plus the
  * language-owned strings and option normalization. The `describe`/`options`
- * payloads are the module's internal `IR`/options shapes (see
- * `core/ir.ts`). They are intentionally opaque at this public boundary,
+ * payloads are the module's internal `Schedule`/options shapes (see
+ * `core/schedule.ts`). They are intentionally opaque at this public boundary,
  * which a caller passes to `cronli5` via the `lang` option but never invokes
  * directly.
  */
 export interface Cronli5Language {
-    describe(ir: any, opts: any): string;
+    describe(schedule: any, opts: any): string;
     fallback: string;
     options(options?: Cronli5Options): any;
     reboot: string;
     sentence(description: string): string;
-    strategy?(content: any, base: any): any;
+    plan?(facts: any, base: any): any;
 }
 /**
  * Option flags accepted as the second argument to `cronli5`.