eliza-core/mention-router.js

A rendition of ELIZA program engine by Weizenbaum sharable for all javascript environments

"use strict";
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
    result["default"] = mod;
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
var EString = __importStar(require("./estring"));
var exceptions_1 = require("./exceptions");
var utils_1 = require("./utils");
var NAMING_CHARACTERS = ('ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    + 'abcdefghijklmnopqrstuvwxyz'
    + '0123456789-_').split('');
function validateMentionNaming(name) {
    return name.split('').find(function (c) { return NAMING_CHARACTERS.indexOf(c) < 0; }) === undefined;
}
function segmentScope(pattern) {
    var patternProfile = [];
    var restToSegment = pattern;
    while (true) {
        var segmentedPat = EString.match(restToSegment, '*@*[*]*');
        if (!segmentedPat) {
            patternProfile.push({ pattern: restToSegment });
            break;
        }
        if (validateMentionNaming(segmentedPat[1])) {
            patternProfile.push({ pattern: segmentedPat[0] });
            patternProfile.push({ pattern: segmentedPat[2], mentions: [segmentedPat[1]] });
            restToSegment = segmentedPat[3];
            continue;
        }
        var searchMentionNamePosition = segmentedPat[1].lastIndexOf('@');
        if (searchMentionNamePosition > -1) {
            patternProfile.push({
                pattern: segmentedPat[0] + '@'
                    + segmentedPat[1].substring(0, searchMentionNamePosition),
            });
            patternProfile.push({
                pattern: segmentedPat[2],
                mentions: [segmentedPat[1].substring(searchMentionNamePosition + 1)],
            });
            restToSegment = segmentedPat[3];
            continue;
        }
        patternProfile.push({ pattern: restToSegment });
    }
    return patternProfile;
}
function cartesianAllScopes(synonyms, patternProfile) {
    return patternProfile.reduce(function (agg, current) {
        if (agg.length < 1) {
            return [[current]];
        }
        if (current.mentions) {
            var possibleWords_1 = [];
            current.mentions.forEach(function (mentionTag) {
                var mentionRoute = synonyms.find(function (synonym) { return synonym.tag === mentionTag; });
                if (mentionRoute) {
                    possibleWords_1 = possibleWords_1.concat(mentionRoute.words.map(function (word) {
                        return ({ pattern: word, mentionTag: mentionTag, innerPattern: current.pattern });
                    }));
                }
                else {
                    throw new exceptions_1.NoMentionDefException(mentionTag);
                }
            });
            return utils_1.cartesian(agg, possibleWords_1).map(function (comb) { return comb[0].concat([comb[1]]); });
        }
        else {
            return utils_1.cartesian(agg, [current]).map(function (comb) { return comb[0].concat([comb[1]]); });
        }
    }, []);
}
function matchDecomposition(synonyms, str, pat) {
    var patternProfile = segmentScope(pat);
    if (patternProfile.length < 3) {
        var simpleMatch = EString.match(str, pat);
        return simpleMatch ? {
            slottedTokens: simpleMatch.map(function (t) { return ({
                token: t, scopes: {},
            }); }), scopes: {},
        } : null;
    }
    var cartesianAllSyn = cartesianAllScopes(synonyms, patternProfile);
    var matchedParts = [];
    var matchedPattern = cartesianAllSyn.find(function (patternParts) {
        var matchAttempt = EString.match(str, patternParts.map(function (p) { return p.pattern; }).join(''));
        if (matchAttempt) {
            matchedParts = matchAttempt;
        }
        return !!matchAttempt;
    });
    if (!matchedPattern) {
        return null;
    }
    var ensuredParts = matchedParts;
    var hyperDecomposeRes = {
        slottedTokens: [],
        scopes: {},
    };
    matchedPattern.forEach(function (p) {
        var expectedParts = EString.count(p.pattern, '*');
        if (p.mentionTag && p.innerPattern) {
            var mentionTag_1 = p.mentionTag;
            var innerDecomposition = matchDecomposition(synonyms, p.pattern, p.innerPattern);
            if (!innerDecomposition) {
                throw new Error("Fatal Error: Decomposing in scope failed: [" + p.pattern + "] --> [" + p.innerPattern + "]");
            }
            innerDecomposition.slottedTokens
                .forEach(function (part) {
                part.scopes[mentionTag_1] = {
                    text: p.pattern, mentionTag: p.mentionTag,
                };
                hyperDecomposeRes.slottedTokens.push(part);
            });
            hyperDecomposeRes.scopes[mentionTag_1] = {
                text: p.pattern, mentionTag: p.mentionTag,
            };
            return;
        }
        for (var index = 0; index < expectedParts; index++) {
            var part = ensuredParts.shift();
            if (part === undefined || part === null) {
                throw new Error('Fatal Error: Extracted Terms not matching wildcards!');
            }
            hyperDecomposeRes.slottedTokens.push({ token: part, scopes: {} });
        }
    });
    return hyperDecomposeRes;
}
exports.matchDecomposition = matchDecomposition;