nl2time 0.1.1 → 0.3.1

package/dist/parse/index.d.ts

@@ -5,6 +5,8 @@
  */
 import type { TimeContext } from '../context.js';
 import type { TimeExpr } from '../ir/types.js';
+import { type DomainPack } from '../packs/index.js';
+import { type Rule } from './en.js';
 export interface ParseMatch {
     /** The matched source text span. */
     text: string;
@@ -17,4 +19,17 @@ export interface ParseMatch {
 export interface ParseResult {
     matches: ParseMatch[];
 }
-export declare function parse(text: string, ctx: TimeContext): ParseResult;
+export interface ParseOptions {
+    /** Declarative domain packs (docs/extending.md); their rules run first. */
+    packs?: DomainPack[];
+    /** Extra code-level rules; run after packs, before built-ins. */
+    rules?: Rule[];
+    /** Built-in rule names to disable (see EN_RULE_ENTRIES). */
+    disable?: string[];
+}
+/**
+ * Precompiled parser for hot paths — compiles packs/rule lists once per
+ * language instead of per call.
+ */
+export declare function createParser(opts?: ParseOptions): (text: string, ctx: TimeContext) => ParseResult;
+export declare function parse(text: string, ctx: TimeContext, opts?: ParseOptions): ParseResult;

package/dist/parse/index.js

@@ -1,13 +1,43 @@
-import { EN_RULES } from './en.js';
+import { compilePack } from '../packs/index.js';
+import { languageDef } from './languages.js';
 import { tokenize } from './tokenizer.js';
-const CONNECTORS = ['at', 'on', 'in', 'of', 'the', 'for', 'from', 'around', 'about', '-'];
-export function parse(text, ctx) {
+function buildRules(opts, language) {
+    const base = languageDef(language).ruleEntries;
+    if (!opts || (!opts.packs?.length && !opts.rules?.length && !opts.disable?.length)) {
+        return base.map((e) => e.rule);
+    }
+    const disabled = new Set([...(opts.disable ?? []), ...(opts.packs ?? []).flatMap((p) => p.disable ?? [])]);
+    return [
+        ...(opts.packs ?? []).map(compilePack),
+        ...(opts.rules ?? []),
+        ...base.filter((e) => !disabled.has(e.name)).map((e) => e.rule),
+    ];
+}
+/**
+ * Precompiled parser for hot paths — compiles packs/rule lists once per
+ * language instead of per call.
+ */
+export function createParser(opts = {}) {
+    const cache = new Map();
+    return (text, ctx) => {
+        let rules = cache.get(ctx.language);
+        if (!rules) {
+            rules = buildRules(opts, ctx.language);
+            cache.set(ctx.language, rules);
+        }
+        return parseWithRules(text, ctx, rules);
+    };
+}
+export function parse(text, ctx, opts) {
+    return parseWithRules(text, ctx, buildRules(opts, ctx.language));
+}
+function parseWithRules(text, ctx, rules) {
     const tokens = tokenize(text);
     const raw = [];
     let i = 0;
     while (i < tokens.length) {
         let best;
-        for (const rule of EN_RULES) {
+        for (const rule of rules) {
             const m = rule(tokens, i, ctx);
             if (!m)
                 continue;
@@ -24,9 +54,10 @@ export function parse(text, ctx) {
         }
     }
     // Merge to fixpoint: [date, duration, time] needs two passes.
-    let merged = mergeAdjacent(raw, tokens);
+    const connectors = languageDef(ctx.language).connectors;
+    let merged = mergeAdjacent(raw, tokens, connectors);
     for (let pass = 0; pass < 2; pass += 1) {
-        const again = mergeAdjacent(merged, tokens);
+        const again = mergeAdjacent(merged, tokens, connectors);
         if (again.length === merged.length)
             break;
         merged = again;
@@ -52,7 +83,7 @@ export function parse(text, ctx) {
  * separated by a connector token) into intersect(date, time) — "yesterday at
  * 9pm", "next Tuesday morning", "May 29 at noon".
  */
-function mergeAdjacent(matches, tokens) {
+function mergeAdjacent(matches, tokens, connectors) {
     const out = [];
     let k = 0;
     while (k < matches.length) {
@@ -88,7 +119,7 @@ function mergeAdjacent(matches, tokens) {
             isWeekExpr(cur.expr) &&
             next.expr.op === 'seek' &&
             next.expr.target.kind === 'weekday' &&
-            isAdjacent(cur, next, tokens)) {
+            isAdjacent(cur, next, tokens, connectors)) {
             out.push({
                 expr: { op: 'seek', base: cur.expr, dir: 'next', target: next.expr.target, n: 1 },
                 consumed: next.tokenEnd - cur.tokenStart,
@@ -100,13 +131,16 @@ function mergeAdjacent(matches, tokens) {
             k += 2;
             continue;
         }
-        if (next && canMerge(cur, next) && isAdjacent(cur, next, tokens)) {
+        if (next && canMerge(cur, next) && isAdjacent(cur, next, tokens, connectors)) {
             const [datePart, timePart] = cur.role === 'time' ? [next, cur] : [cur, next];
             let dateExpr = datePart.expr;
             let timeExpr = inferMeridiem(dateExpr, timePart.expr);
             // A day-period on the date side pushes its meridiem into an explicit
             // time range and then steps aside: "Monday morning 6-8" is Monday
-            // 06:00–08:00, not clipped to the morning boundaries.
+            // 06:00–08:00, not clipped to the morning boundaries. A cross-midnight
+            // range ("last night between 11pm and 1am") keeps the period part:
+            // its window extends past midnight, so the range can roll into the
+            // next day instead of being clipped at the day anchor's end (#19).
             if (timeExpr.op === 'between') {
                 const period = findDayPeriod(dateExpr);
                 if (period) {
@@ -115,7 +149,11 @@ function mergeAdjacent(matches, tokens) {
                         start: forceMeridiem(timeExpr.start, period),
                         end: forceMeridiem(timeExpr.end, period),
                     };
-                    dateExpr = stripDayPeriod(dateExpr) ?? dateExpr;
+                    const sm = literalMinuteOfDay(timeExpr.start);
+                    const em = literalMinuteOfDay(timeExpr.end);
+                    const wraps = sm !== undefined && em !== undefined && em <= sm;
+                    if (!wraps)
+                        dateExpr = stripDayPeriod(dateExpr) ?? dateExpr;
                 }
             }
             out.push({
@@ -180,6 +218,18 @@ function inferMeridiem(dateExpr, timeExpr) {
         time: { ...timeExpr.time, meridiem },
     };
 }
+/** Minutes-since-midnight of a literal time with a known meridiem, if any. */
+function literalMinuteOfDay(expr) {
+    if (expr.op !== 'literal' || expr.time?.hour === undefined)
+        return undefined;
+    const h = expr.time.hour % 12;
+    const min = expr.time.minute ?? 0;
+    if (expr.time.meridiem === 'am')
+        return h * 60 + min;
+    if (expr.time.meridiem === 'pm')
+        return (h + 12) * 60 + min;
+    return undefined;
+}
 function forceMeridiem(expr, period) {
     if (expr.op !== 'literal' || !expr.time || (expr.time.meridiem && expr.time.meridiem !== 'unknown')) {
         return expr;
@@ -220,11 +270,11 @@ const REDUNDANT_BETWEEN = new Set([
     'mon', 'tue', 'tues', 'wed', 'weds', 'thu', 'thur', 'thurs', 'fri', 'sat', 'sun',
     'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday',
 ]);
-function isAdjacent(a, b, tokens) {
+function isAdjacent(a, b, tokens, connectors) {
     const between = tokens.slice(a.tokenEnd, b.tokenStart);
     if (between.length > 2)
         return false;
     // A parenthesized weekday between date and time ("May/22 (Tue) 11:30") is
     // redundant with the date and doesn't block the merge.
-    return between.every((t) => t.type === 'word' && (CONNECTORS.includes(t.value) || REDUNDANT_BETWEEN.has(t.value)));
+    return between.every((t) => t.type === 'word' && (connectors.includes(t.value) || REDUNDANT_BETWEEN.has(t.value)));
 }

package/dist/parse/ja.d.ts

@@ -0,0 +1,7 @@
+import type { Rule } from './en.js';
+export declare const JA_RULE_ENTRIES: readonly {
+    name: string;
+    rule: Rule;
+}[];
+/** Particles transparent between merged date & time parts ("明日の朝8時"). */
+export declare const JA_CONNECTORS: string[];