@kermank/nldp/dist/parser/parser-engine.js

A modular date/time parser for converting natural language into dates and times

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createParserState = createParserState;
exports.registerRule = registerRule;
exports.parse = parse;
const debug_trace_1 = require("../utils/debug-trace");
const Logger_1 = require("../utils/Logger");
const resolution_engine_1 = require("../resolver/resolution-engine");
const preference_resolver_1 = require("../resolver/preference-resolver");
function createParserState(preferences) {
    return {
        rules: [],
        tokenizerOptions: {},
        defaultPreferences: preferences,
    };
}
function registerRule(state, rule) {
    return {
        ...state,
        rules: [...state.rules, rule]
    };
}
function parse(state, input, preferences) {
    const mergedPrefs = {
        ...state.defaultPreferences,
        ...preferences
    };
    if (mergedPrefs.debug) {
        debug_trace_1.debugTrace.startTrace(input);
    }
    // Collect all components from all rules
    const components = [];
    for (const rule of state.rules) {
        // Try each pattern in the rule
        for (const pattern of rule.patterns) {
            const matches = pattern.regex.exec(input);
            if (matches) {
                if (mergedPrefs.debug) {
                    debug_trace_1.debugTrace.addRuleMatch({
                        ruleName: rule.name,
                        input: matches[0],
                        matched: true
                    });
                }
                try {
                    const result = pattern.parse(matches, mergedPrefs);
                    if (isParseComponent(result)) {
                        Logger_1.Logger.debug('Rule match component:', {
                            ruleName: rule.name,
                            componentType: result.type,
                            span: result.span,
                            confidence: result.confidence,
                            value: isDateTimeRange(result.value)
                                ? {
                                    start: result.value.start.toISO(),
                                    end: result.value.end.toISO()
                                }
                                : result.value.toISO()
                        });
                        components.push(result);
                    }
                }
                catch (err) {
                    Logger_1.Logger.error(`Error in rule ${rule.name}:`, { error: err });
                    continue;
                }
            }
            else if (mergedPrefs.debug) {
                debug_trace_1.debugTrace.addRuleMatch({
                    ruleName: rule.name,
                    input: input,
                    matched: false
                });
            }
        }
    }
    // No components found
    if (components.length === 0) {
        if (mergedPrefs.debug) {
            debug_trace_1.debugTrace.endTrace();
        }
        return null;
    }
    // Resolve components into a result
    const result = (0, resolution_engine_1.resolveComponents)(components, input);
    if (!result) {
        if (mergedPrefs.debug) {
            debug_trace_1.debugTrace.endTrace();
        }
        return null;
    }
    // Apply preferences to the result
    const finalResult = (0, preference_resolver_1.resolvePreferences)(result, mergedPrefs);
    // Add debug trace if in debug mode
    if (mergedPrefs.debug) {
        const trace = debug_trace_1.debugTrace.getTrace();
        if (trace) {
            finalResult.debugTrace = trace;
        }
        debug_trace_1.debugTrace.endTrace();
    }
    return finalResult;
}
// Type guards
function isParseComponent(value) {
    return (value &&
        typeof value === 'object' &&
        'type' in value &&
        'span' in value &&
        'value' in value &&
        'confidence' in value);
}
function isDateTimeRange(value) {
    return typeof value === 'object' && 'start' in value && 'end' in value;
}
//# sourceMappingURL=parser-engine.js.map