nl2time 0.1.0 → 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

@@ -125,12 +125,17 @@ function yearAt(tokens, i) {
         ? t.value
         : undefined;
 }
-/** "in the morning" / "at night" / "tonight" lookahead. Returns period + consumed. */
-function readPeriodSuffix(tokens, i) {
+/** "in the morning" / "at night" / "this morning" / "tonight" lookahead.
+ * Returns period + consumed. "this <period>" binds a preceding bare hour
+ * exactly like "in the <period>" ("8 this morning" → 8am): the period
+ * supplies the meridiem, and the reference day is the anchor either way.
+ * Deliberately NOT "last night": that also shifts the day, which a
+ * meridiem-only suffix can't express (#9). */
+function readPeriodSuffix(tokens, i, allowThis = true) {
     let at = i;
     if (word(tokens[at]) === 'in' || word(tokens[at]) === 'at')
         at += 1;
-    if (word(tokens[at]) === 'the')
+    if (word(tokens[at]) === 'the' || (allowThis && word(tokens[at]) === 'this'))
         at += 1;
     const w = word(tokens[at]);
     if (w === 'tonight')
@@ -143,6 +148,12 @@ function readPeriodSuffix(tokens, i) {
 function meridiemFor(period) {
     return period === 'morning' ? 'am' : 'pm';
 }
+/** Words that license a following bare number as a clock time
+ * ("at 8 this morning", "by 5 this afternoon"). */
+const TIME_PREPOSITIONS = new Set([
+    'at', 'around', 'about', 'by', 'from', 'until', 'till', 'to',
+    'before', 'after', 'since',
+]);
 // --- rules -----------------------------------------------------------------
 /** today / yesterday / tomorrow / tonight / day before yesterday / day after tomorrow */
 const ruleDeicticDay = (tokens, i) => {
@@ -2353,7 +2364,17 @@ const ruleClockTime = (tokens, i, ctx) => {
         if (after === "o'clock" || after === 'oclock') {
             return withPeriodSuffix({ hour: hn.value, meridiem: 'unknown' }, hn.consumed + 1);
         }
-        const ps = readPeriodSuffix(tokens, i + hn.consumed + mc);
+        // A BARE number before "this <period>" is only a clock time when the
+        // number isn't already bound by a preceding noun — "8 this morning"
+        // is 8am, but in "building 4 this afternoon" the 4 is a building
+        // number and the period keeps its range reading (Recognizers
+        // rt-dtm-0523). Utterance start or a time-preposition before the
+        // number licenses the binding; an arbitrary preceding word does not.
+        // The in/at forms ("4 in the afternoon") are explicit enough to bind
+        // regardless, as before.
+        const prevWord = word(tokens[i - 1]);
+        const allowThis = i === 0 || prevWord === undefined || TIME_PREPOSITIONS.has(prevWord);
+        const ps = readPeriodSuffix(tokens, i + hn.consumed + mc, allowThis);
         if (ps) {
             const time = { hour: hn.value, meridiem: meridiemFor(ps.period) };
             if (minute !== undefined)
@@ -2383,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' } },
@@ -2675,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[];