nl2time 0.1.1 → 0.3.0

package/dist/parse/en.d.ts

@@ -15,4 +15,13 @@ export interface RuleMatch {
 }
 export type Rule = (tokens: Token[], i: number, ctx: TimeContext) => RuleMatch | undefined;
 /** Rules in priority order (first match at a position wins ties by length then order). */
+/**
+ * Built-in English rules with stable public names (docs/extending.md).
+ * Order matters: the scanner prefers longer matches, then higher confidence,
+ * then earlier list position — so names are also the disable/override handle.
+ */
+export declare const EN_RULE_ENTRIES: readonly {
+    name: string;
+    rule: Rule;
+}[];
 export declare const EN_RULES: readonly Rule[];

package/dist/parse/en.js

@@ -2404,6 +2404,25 @@ const ruleClockTime = (tokens, i, ctx) => {
                 role: 'time',
             };
         }
+        // Day-shifting period phrases: "10 last night", "8 yesterday morning",
+        // "5 tomorrow afternoon" (#10). Emit the bare hour with meridiem
+        // 'unknown' and stop — the following day-part matches separately and the
+        // refiner merges them, with the period supplying the meridiem and the
+        // deictic supplying the day shift. Same noun-guard as "this <period>":
+        // "the count was 4 last night" keeps the period's range reading.
+        const relNext = word(tokens[i + hn.consumed]);
+        const isDayShifter = relNext !== undefined &&
+            (REL_SYNONYMS[relNext] !== undefined ||
+                relNext === 'yesterday' || relNext === 'tomorrow' || relNext === 'today');
+        const relPeriodWord = isDayShifter ? word(tokens[i + hn.consumed + 1]) : undefined;
+        if (allowThis && relPeriodWord !== undefined && PERIOD_WORDS[relPeriodWord]) {
+            return {
+                expr: { op: 'literal', time: { hour: hn.value, meridiem: 'unknown' } },
+                consumed: hn.consumed,
+                confidence: 0.95,
+                role: 'time',
+            };
+        }
         if (['at', 'from', 'around', 'about'].includes(word(tokens[i - 1]) ?? '')) {
             return {
                 expr: { op: 'literal', time: { hour: hn.value, meridiem: 'unknown' } },
@@ -2696,34 +2715,40 @@ const ruleAllUnit = (tokens, i) => {
     return { expr: { op: 'amount', amount: amountFor(unit, 1) }, consumed: 2, confidence: 0.9, role: 'duration' };
 };
 /** Rules in priority order (first match at a position wins ties by length then order). */
-export const EN_RULES = [
-    ruleRange,
-    ruleWeekOf,
-    ruleNthWeekdayOf,
-    ruleDayOfScope,
-    ruleWeekendOf,
-    ruleHoliday,
-    ruleEarlyLate,
-    ruleEndOf,
-    ruleDeicticDay,
-    ruleWithin,
-    ruleNAfterDate,
-    ruleUnitAfterNext,
-    rulePastN,
-    ruleNextN,
-    ruleTheNPastNext,
-    ruleTheUnit,
-    ruleLastThisNext,
-    ruleAgoIn,
-    ruleDuration,
-    ruleFractionDuration,
-    ruleAllUnit,
-    ruleDecadeCentury,
-    ruleBareYear,
-    ruleCalendarDate,
-    ruleClockTime,
-    ruleWeekdayDay,
-    ruleWeekdayAlone,
-    rulePeriodAlone,
-    ruleNow,
+/**
+ * Built-in English rules with stable public names (docs/extending.md).
+ * Order matters: the scanner prefers longer matches, then higher confidence,
+ * then earlier list position — so names are also the disable/override handle.
+ */
+export const EN_RULE_ENTRIES = [
+    { name: 'range', rule: ruleRange },
+    { name: 'week-of', rule: ruleWeekOf },
+    { name: 'nth-weekday-of', rule: ruleNthWeekdayOf },
+    { name: 'day-of-scope', rule: ruleDayOfScope },
+    { name: 'weekend-of', rule: ruleWeekendOf },
+    { name: 'holiday', rule: ruleHoliday },
+    { name: 'early-late', rule: ruleEarlyLate },
+    { name: 'end-of', rule: ruleEndOf },
+    { name: 'deictic-day', rule: ruleDeicticDay },
+    { name: 'within', rule: ruleWithin },
+    { name: 'n-after-date', rule: ruleNAfterDate },
+    { name: 'unit-after-next', rule: ruleUnitAfterNext },
+    { name: 'past-n', rule: rulePastN },
+    { name: 'next-n', rule: ruleNextN },
+    { name: 'the-n-past-next', rule: ruleTheNPastNext },
+    { name: 'the-unit', rule: ruleTheUnit },
+    { name: 'last-this-next', rule: ruleLastThisNext },
+    { name: 'ago-in', rule: ruleAgoIn },
+    { name: 'duration', rule: ruleDuration },
+    { name: 'fraction-duration', rule: ruleFractionDuration },
+    { name: 'all-unit', rule: ruleAllUnit },
+    { name: 'decade-century', rule: ruleDecadeCentury },
+    { name: 'bare-year', rule: ruleBareYear },
+    { name: 'calendar-date', rule: ruleCalendarDate },
+    { name: 'clock-time', rule: ruleClockTime },
+    { name: 'weekday-day', rule: ruleWeekdayDay },
+    { name: 'weekday-alone', rule: ruleWeekdayAlone },
+    { name: 'period-alone', rule: rulePeriodAlone },
+    { name: 'now', rule: ruleNow },
 ];
+export const EN_RULES = EN_RULE_ENTRIES.map((e) => e.rule);

package/dist/parse/es.d.ts

@@ -0,0 +1,9 @@
+import type { Rule } from './en.js';
+import { type LatinLexicon } from './latin.js';
+export declare const ES_LEXICON: LatinLexicon;
+export declare const ES_RULE_ENTRIES: {
+    name: string;
+    rule: Rule;
+}[];
+/** Connector words allowed between merged date & time parts. */
+export declare const ES_CONNECTORS: string[];