@rfprodz/client-util-eliza 1.0.0

package/esm2020/lib/services/eliza/eliza.service.mjs

@@ -0,0 +1,441 @@
+/**
+ * elizabot.js v.1.1 - ELIZA JS library (N.Landsteiner 2005)
+ * Eliza is a mock Rogerian psychotherapist.
+ * Original program by Joseph Weizenbaum in MAD-SLIP for "Project MAC" at MIT.
+ * cf: Weizenbaum, Joseph "ELIZA - A Computer Program For the Study of Natural Language Communication Between Man and Machine"
+ * in: Communications of the ACM; Volume 9 , Issue 1 (January 1966): p 36-45.
+ * JavaScript implementation by Norbert Landsteiner 2005; <http://www.masserk.at>
+ *
+ * `ElizaBot' is also a general chatbot engine that can be supplied with any rule set.
+ * (for required data structures cf. "elizadata.js" and/or see the documentation.)
+ * data is parsed and transformed for internal use at the creation time of the first instance of the `ElizaBot' constructor.
+ *
+ * JavaScript source: https://github.com/natelewis/eliza-as-promised
+ */
+import { Inject, Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { ELIZA_DATA } from '../../config/data.config';
+import { elizaInitialConfig } from '../../config/eliza.config';
+import { elizaFinalDefault } from '../../config/finals.config';
+import { elizaInitialDefault } from '../../config/initials.config';
+import * as i0 from "@angular/core";
+export class AppElizaService {
+    constructor(elizaData) {
+        this.elizaData = elizaData;
+        /**
+         * Eliza configuration.
+         */
+        this.configSubject = new BehaviorSubject({ ...elizaInitialConfig });
+        /**
+         * Publicly readable Eliza configuration.
+         */
+        this.config$ = this.configSubject.asObservable();
+        this.mem = [];
+        this.lastChoice = [];
+        this.postExp = new RegExp('');
+        this.preExp = new RegExp('');
+        this.pres = {};
+        this.posts = {};
+        /**
+         * Conversation messages.
+         */
+        this.messagesSubject = new BehaviorSubject([]);
+        /**
+         * Publicly readable conversation messages.
+         */
+        this.messages$ = this.messagesSubject.asObservable();
+        this.setup(elizaData);
+    }
+    /**
+     * Adds next chat message.
+     * @param message chat message
+     */
+    nextMessage(message) {
+        this.messagesSubject.next([...this.messagesSubject.value, message]);
+    }
+    /**
+     * Modifies Eliza configuration.
+     * @param config Eliza config
+     */
+    nextConfig(config) {
+        this.configSubject.next({ ...this.configSubject.value, ...config });
+    }
+    /**
+     * Sets up Eliza.
+     * @param data Eliza data
+     * @param reinitialize indicates that Eliza should be initialized again, even if it's data has already been initialized
+     */
+    setup(data, reinitialize = false) {
+        if (typeof this.data === 'undefined' && !reinitialize) {
+            this.init(data);
+        }
+        this.reset();
+    }
+    /**
+     * Resets Eliza.
+     */
+    reset() {
+        const data = this.data;
+        if (typeof data === 'undefined') {
+            throw new Error('Initialize Eliza first.');
+        }
+        this.mem = [];
+        this.lastChoice = [];
+        for (let k = 0; k < data.keywords.length; k += 1) {
+            this.lastChoice[k] = [];
+            const rules = data.keywords[k].rules;
+            for (let i = 0; i < rules.length; i += 1) {
+                this.lastChoice[k][i] = -1;
+            }
+        }
+        this.messagesSubject.next([{ bot: true, text: this.getInitial(data) }]);
+    }
+    // eslint-disable-next-line max-lines-per-function, complexity -- TODO refactor
+    init(data) {
+        this.data = { ...data };
+        // Parse data and convert it from canonical form to internal use.
+        // Produce a list of synonyms.
+        const synPatterns = {};
+        for (const item in this.data.synonyms) {
+            if (item) {
+                synPatterns[item] = `(${item}|${this.data.synonyms[item].join('|')})`;
+            }
+        }
+        // Check keywords.
+        if (data.keywords.length === 0) {
+            throw Error('Eliza does not have any configured keywords.');
+        }
+        // First, convert rules to regexps.
+        // Expand synonyms and insert asterisk expressions for backtracking.
+        const sre = /@(\S+)/;
+        const are = /(\S)\s*\*\s*(\S)/;
+        const are1 = /^\s*\*\s*(\S)/;
+        const are2 = /(\S)\s*\*\s*$/;
+        const are3 = /^\s*\*\s*$/;
+        const wsre = /\s+/g;
+        for (let i = 0; i < this.data.keywords.length; i += 1) {
+            const rules = this.data.keywords[i].rules;
+            for (let j = 0; j < rules.length; j += 1) {
+                const rule = rules[j];
+                // Check mem flag and store it as decomp's element 2.
+                if (rule.pattern.charAt(0) === '$') {
+                    let ofs = 1;
+                    while (rule.pattern.charAt[ofs] === ' ') {
+                        ofs += 1;
+                    }
+                    rule.pattern = rule.pattern.substring(ofs);
+                    rule.memory = true;
+                }
+                else {
+                    rule.memory = false;
+                }
+                let match = rule.pattern.match(sre);
+                while (match !== null) {
+                    const sp = synPatterns[match[1]] ? synPatterns[match[1]] : match[1];
+                    rule.pattern = rule.pattern.substring(0, match.index ?? 0) + sp + rule.pattern.substring((match.index ?? 0) + match[0].length);
+                    match = rule.pattern.match(sre);
+                }
+                // Expand asterisk expressions.
+                if (are3.test(rule.pattern)) {
+                    rule.pattern = '\\s*(.*)\\s*';
+                }
+                else {
+                    match = rule.pattern.match(are);
+                    if (match !== null) {
+                        let leftPart = '';
+                        let rightPart = rule.pattern;
+                        while (match !== null) {
+                            leftPart += rightPart.substring(0, (match.index ?? 0) + 1);
+                            if (match[1] !== ')') {
+                                leftPart += '\\b';
+                            }
+                            leftPart += '\\s*(.*)\\s*';
+                            if (match[2] !== '(' && match[2] !== '\\') {
+                                leftPart += '\\b';
+                            }
+                            leftPart += match[2];
+                            rightPart = rightPart.substring((match.index ?? 0) + match[0].length);
+                            match = rightPart.match(are);
+                        }
+                        rule.pattern = leftPart + rightPart;
+                    }
+                    match = rule.pattern.match(are1);
+                    if (match !== null) {
+                        let leftPart = '\\s*(.*)\\s*';
+                        if (match[1] !== ')' && match[1] !== '\\') {
+                            leftPart += '\\b';
+                        }
+                        rule.pattern = leftPart + rule.pattern.substring((match.index ?? 0) - 1 + match[0].length);
+                    }
+                    match = rule.pattern.match(are2);
+                    if (match !== null) {
+                        let leftPart = rule.pattern.substring(0, (match.index ?? 0) + 1);
+                        if (match[1] !== '(') {
+                            leftPart += '\\b';
+                        }
+                        rule.pattern = leftPart + '\\s*(.*)\\s*';
+                    }
+                }
+                // Expand whitespaces.
+                rule.pattern = rule.pattern.replace(wsre, '\\s+');
+                wsre.lastIndex = 0;
+            }
+        }
+        // Sort keywords by rank (highest first).
+        this.data.keywords.sort(this.sortKeywords);
+        // Compose regexps and refs for pres and posts.
+        this.composeRegExpsAndPresAndPosts(this.data);
+    }
+    /**
+     * Composes regexps and refs for pres and posts.
+     * @param data Eliza data
+     */
+    composeRegExpsAndPresAndPosts(data) {
+        this.pres = {};
+        this.posts = {};
+        if (data.pres.length === 0) {
+            throw Error('Eliza does not have any configured pre expressions.');
+        }
+        else {
+            const a = [];
+            for (let i = 0; i < data.pres.length; i += 2) {
+                a.push(data.pres[i]);
+                this.pres[data.pres[i]] = data.pres[i + 1];
+            }
+            this.preExp = new RegExp('\\b(' + a.join('|') + ')\\b');
+        }
+        if (data.posts.length === 0) {
+            throw Error('Eliza does not have any configured post expressions.');
+        }
+        else {
+            const a = [];
+            for (let i = 0; i < data.posts.length; i += 2) {
+                a.push(data.posts[i]);
+                this.posts[data.posts[i]] = data.posts[i + 1];
+            }
+            this.postExp = new RegExp('\\b(' + a.join('|') + ')\\b');
+        }
+    }
+    // eslint-disable-next-line max-lines-per-function, complexity -- TODO refactor
+    execRule(data, k, sentence) {
+        const config = this.configSubject.value;
+        const rules = data.keywords[k].rules;
+        const paramRegExp = /\(([0-9]+)\)/;
+        for (let i = 0; i < rules.length; i += 1) {
+            const match = sentence.match(rules[i].pattern);
+            if (match !== null) {
+                const options = rules[i].options;
+                const memory = rules[i].memory;
+                let optionIndex = config.noRandom ? 0 : Math.floor(Math.random() * options.length);
+                if ((config.noRandom && this.lastChoice[k][i] > optionIndex) || this.lastChoice[k][i] === optionIndex) {
+                    this.lastChoice[k][i] += 1;
+                    optionIndex = this.lastChoice[k][i];
+                    if (optionIndex >= options.length) {
+                        optionIndex = 0;
+                        this.lastChoice[k][i] = -1;
+                    }
+                }
+                else {
+                    this.lastChoice[k][i] = optionIndex;
+                }
+                let reply = options[optionIndex];
+                if (config.debug) {
+                    const debugLog = `match:\nkey: ${data.keywords[k].key}\nrank: ${data.keywords[k].rank}\ndecomp: ${rules[i].pattern}\nreasmb: ${reply}\nmemory: ${memory}`;
+                    // eslint-disable-next-line no-console -- debug output
+                    console.warn('debugLog', debugLog);
+                }
+                if (reply.search('^goto ') === 0) {
+                    const key = reply.substring(5);
+                    const ki = this.getRuleIndexByKey(data, key);
+                    if (ki >= 0) {
+                        return this.execRule(data, ki, sentence);
+                    }
+                }
+                // Substitute positional params.
+                let paramRegExpMatch = reply.match(paramRegExp);
+                if (paramRegExpMatch) {
+                    let leftPart = '';
+                    let rightPart = reply;
+                    while (paramRegExpMatch !== null) {
+                        let param = match[parseInt(paramRegExpMatch[1], 10)];
+                        // Postprocess param.
+                        let postExpMatch = param.match(this.postExp);
+                        if (postExpMatch !== null) {
+                            let leftPart2 = '';
+                            let rightPart2 = param;
+                            while (postExpMatch !== null) {
+                                leftPart2 += rightPart2.substring(0, postExpMatch.index ?? 0) + this.posts[postExpMatch[1]];
+                                rightPart2 = rightPart2.substring((postExpMatch.index ?? 0) + postExpMatch[0].length);
+                                postExpMatch = rightPart2.match(this.postExp);
+                            }
+                            param = leftPart2 + rightPart2;
+                        }
+                        leftPart += rightPart.substring(0, paramRegExpMatch.index) + param;
+                        rightPart = rightPart.substring((paramRegExpMatch.index ?? 0) + paramRegExpMatch[0].length);
+                        paramRegExpMatch = rightPart.match(paramRegExp);
+                    }
+                    reply = leftPart + rightPart;
+                }
+                const transformedReply = this.postTransform(data, reply);
+                if (memory) {
+                    this.memSave(transformedReply);
+                }
+                else {
+                    return transformedReply;
+                }
+            }
+        }
+        return '';
+    }
+    // eslint-disable-next-line complexity -- TODO refactor
+    transformUserQuery(data, input) {
+        let reply = '';
+        // Unify text string and split text in part sentences and loop through them.
+        const parts = this.splitUserQueryIntoParts(input);
+        for (let i = 0; i < parts.length; i += 1) {
+            let part = parts[i];
+            if (part !== '') {
+                // Check for quit expressions.
+                for (let q = 0; q < data.quits.length; q += 1) {
+                    if (data.quits[q] === part) {
+                        return { reply: this.getFinal(data), final: true };
+                    }
+                }
+                let match = part.match(this.preExp);
+                if (match !== null) {
+                    let leftPart = '';
+                    let rightPart = part;
+                    while (match !== null) {
+                        leftPart += rightPart.substring(0, match.index ?? 0) + this.pres[match[1]];
+                        rightPart = rightPart.substring((match.index ?? 0) + match[0].length);
+                        match = rightPart.match(this.preExp);
+                    }
+                    part = leftPart + rightPart;
+                }
+                // Loop trough keywords.
+                for (let k = 0; k < data.keywords.length; k += 1) {
+                    if (part.search(new RegExp('\\b' + data.keywords[k].key + '\\b', 'i')) >= 0) {
+                        reply = this.execRule(data, k, part);
+                    }
+                    if (reply !== '') {
+                        return { reply, final: false };
+                    }
+                }
+            }
+        }
+        // Nothing matched, try mem.
+        reply = this.memGet();
+        // If nothing in mem, try xnone.
+        if (reply === '') {
+            const k = this.getRuleIndexByKey(data, 'xnone');
+            reply = k >= 0 ? this.execRule(data, k, ' ') : reply;
+        }
+        return { reply: reply !== '' ? reply : 'I am at a loss for words.', final: false };
+    }
+    /**
+     * Unify text string, split text into partial sentences to be able to loop through them.
+     * @param input user query
+     * @returns split user query
+     */
+    splitUserQueryIntoParts(input) {
+        const parts = input
+            .toLowerCase()
+            .replace(/@#\$%\^&\*\(\)_\+=~`\{\[\}\]\|:;<>\/\\\t/g, ' ')
+            .replace(/\s+-+\s+/g, '.')
+            .replace(/\s*[,.?!;]+\s*/g, '.')
+            .replace(/\s*\bbut\b\s*/g, '.')
+            .replace(/\s{2,}/g, ' ')
+            .split('.');
+        return parts;
+    }
+    sortKeywords(a, b) {
+        if (a.rank > b.rank) {
+            return -1;
+        }
+        else if (a.rank < b.rank) {
+            return 1;
+        }
+        else if (a.index > b.index) {
+            return 1;
+        }
+        else if (a.index < b.index) {
+            return -1;
+        }
+        return 0;
+    }
+    postTransform(data, input) {
+        // final cleanings
+        let result = input.replace(/\s{2,}/g, ' ').replace(/\s+\./g, '.');
+        if (data.postTransforms.length > 0) {
+            for (let i = 0; i < data.postTransforms.length; i += 1) {
+                const postTransform = data.postTransforms[i];
+                result = result.replace(postTransform.searchValue, postTransform.replaceValue);
+                data.postTransforms[i].searchValue.lastIndex = 0;
+            }
+        }
+        if (this.configSubject.value.capitalizeFirstLetter) {
+            const match = result.match(/^([a-z])/);
+            if (match) {
+                result = match[0].toUpperCase() + result.substring(1);
+            }
+        }
+        return result;
+    }
+    getRuleIndexByKey(data, key) {
+        for (let k = 0; k < data.keywords.length; k += 1) {
+            if (data.keywords[k].key === key) {
+                return k;
+            }
+        }
+        return -1;
+    }
+    memSave(input) {
+        this.mem.push(input);
+        if (this.mem.length > this.configSubject.value.memSize) {
+            this.mem.shift();
+        }
+    }
+    memGet() {
+        if (this.mem.length > 0) {
+            if (this.configSubject.value.noRandom) {
+                return this.mem.shift() ?? '';
+            }
+            const n = Math.floor(Math.random() * this.mem.length);
+            const reply = this.mem[n];
+            for (let i = n + 1; i < this.mem.length; i += 1) {
+                this.mem[i - 1] = this.mem[i];
+            }
+            this.mem.length -= 1;
+            return reply;
+        }
+        return '';
+    }
+    getFinal(data) {
+        return data.finals.length === 0 ? elizaFinalDefault : data.finals[Math.floor(Math.random() * data.finals.length)];
+    }
+    getInitial(data) {
+        return data.initials.length === 0 ? elizaInitialDefault : data.initials[Math.floor(Math.random() * data.initials.length)];
+    }
+    getResponse(statement) {
+        const data = this.data;
+        if (typeof data === 'undefined') {
+            throw new Error('Initialize Eliza first.');
+        }
+        return new Promise(resolve => {
+            const elizaReply = this.transformUserQuery(data, statement);
+            resolve(elizaReply);
+        });
+    }
+}
+/** @nocollapse */ AppElizaService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: AppElizaService, deps: [{ token: ELIZA_DATA }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ AppElizaService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: AppElizaService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: AppElizaService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [ELIZA_DATA]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eliza.service.js","sourceRoot":"","sources":["../../../../../../../libs/client-util-eliza/src/lib/services/eliza/eliza.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * elizabot.js v.1.1 - ELIZA JS library (N.Landsteiner 2005)\n * Eliza is a mock Rogerian psychotherapist.\n * Original program by Joseph Weizenbaum in MAD-SLIP for \"Project MAC\" at MIT.\n * cf: Weizenbaum, Joseph \"ELIZA - A Computer Program For the Study of Natural Language Communication Between Man and Machine\"\n * in: Communications of the ACM; Volume 9 , Issue 1 (January 1966): p 36-45.\n * JavaScript implementation by Norbert Landsteiner 2005; <http://www.masserk.at>\n *\n * `ElizaBot' is also a general chatbot engine that can be supplied with any rule set.\n * (for required data structures cf. \"elizadata.js\" and/or see the documentation.)\n * data is parsed and transformed for internal use at the creation time of the first instance of the `ElizaBot' constructor.\n *\n * JavaScript source: https://github.com/natelewis/eliza-as-promised\n */\n\nimport { Inject, Injectable } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\n\nimport { ELIZA_DATA } from '../../config/data.config';\nimport { elizaInitialConfig } from '../../config/eliza.config';\nimport { elizaFinalDefault } from '../../config/finals.config';\nimport { elizaInitialDefault } from '../../config/initials.config';\nimport { IChatMessage } from '../../interfaces/chat.interface';\nimport { IElizaConfig, IElizaData, IElizaKeyword, IElizaResponse } from '../../interfaces/eliza.interface';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class AppElizaService {\n  /**\n   * Eliza configuration.\n   */\n  private readonly configSubject = new BehaviorSubject<IElizaConfig>({ ...elizaInitialConfig });\n\n  /**\n   * Publicly readable Eliza configuration.\n   */\n  public readonly config$ = this.configSubject.asObservable();\n\n  private data?: IElizaData;\n\n  private mem: string[] = [];\n\n  private lastChoice: number[][] = [];\n\n  private postExp = new RegExp('');\n\n  private preExp = new RegExp('');\n\n  private pres: Record<string, string> = {};\n\n  private posts: Record<string, string> = {};\n\n  /**\n   * Conversation messages.\n   */\n  private readonly messagesSubject = new BehaviorSubject<IChatMessage[]>([]);\n\n  /**\n   * Publicly readable conversation messages.\n   */\n  public readonly messages$ = this.messagesSubject.asObservable();\n\n  constructor(@Inject(ELIZA_DATA) public readonly elizaData: IElizaData) {\n    this.setup(elizaData);\n  }\n\n  /**\n   * Adds next chat message.\n   * @param message chat message\n   */\n  public nextMessage(message: IChatMessage): void {\n    this.messagesSubject.next([...this.messagesSubject.value, message]);\n  }\n\n  /**\n   * Modifies Eliza configuration.\n   * @param config Eliza config\n   */\n  public nextConfig(config: Partial<IElizaConfig>): void {\n    this.configSubject.next({ ...this.configSubject.value, ...config });\n  }\n\n  /**\n   * Sets up Eliza.\n   * @param data Eliza data\n   * @param reinitialize indicates that Eliza should be initialized again, even if it's data has already been initialized\n   */\n  public setup(data: IElizaData, reinitialize = false): void {\n    if (typeof this.data === 'undefined' && !reinitialize) {\n      this.init(data);\n    }\n    this.reset();\n  }\n\n  /**\n   * Resets Eliza.\n   */\n  public reset(): void {\n    const data = this.data;\n    if (typeof data === 'undefined') {\n      throw new Error('Initialize Eliza first.');\n    }\n    this.mem = [];\n    this.lastChoice = [];\n    for (let k = 0; k < data.keywords.length; k += 1) {\n      this.lastChoice[k] = [];\n      const rules = data.keywords[k].rules;\n      for (let i = 0; i < rules.length; i += 1) {\n        this.lastChoice[k][i] = -1;\n      }\n    }\n    this.messagesSubject.next([{ bot: true, text: this.getInitial(data) }]);\n  }\n\n  // eslint-disable-next-line max-lines-per-function, complexity -- TODO refactor\n  private init(data: IElizaData): void {\n    this.data = { ...data };\n    // Parse data and convert it from canonical form to internal use.\n    // Produce a list of synonyms.\n    const synPatterns: Record<string, string> = {};\n    for (const item in this.data.synonyms) {\n      if (item) {\n        synPatterns[item] = `(${item}|${this.data.synonyms[item].join('|')})`;\n      }\n    }\n    // Check keywords.\n    if (data.keywords.length === 0) {\n      throw Error('Eliza does not have any configured keywords.');\n    }\n    // First, convert rules to regexps.\n    // Expand synonyms and insert asterisk expressions for backtracking.\n    const sre = /@(\\S+)/;\n    const are = /(\\S)\\s*\\*\\s*(\\S)/;\n    const are1 = /^\\s*\\*\\s*(\\S)/;\n    const are2 = /(\\S)\\s*\\*\\s*$/;\n    const are3 = /^\\s*\\*\\s*$/;\n    const wsre = /\\s+/g;\n    for (let i = 0; i < this.data.keywords.length; i += 1) {\n      const rules = this.data.keywords[i].rules;\n      for (let j = 0; j < rules.length; j += 1) {\n        const rule = rules[j];\n        // Check mem flag and store it as decomp's element 2.\n        if (rule.pattern.charAt(0) === '$') {\n          let ofs = 1;\n          while (rule.pattern.charAt[ofs] === ' ') {\n            ofs += 1;\n          }\n          rule.pattern = rule.pattern.substring(ofs);\n          rule.memory = true;\n        } else {\n          rule.memory = false;\n        }\n        let match = rule.pattern.match(sre);\n        while (match !== null) {\n          const sp = synPatterns[match[1]] ? synPatterns[match[1]] : match[1];\n          rule.pattern = rule.pattern.substring(0, match.index ?? 0) + sp + rule.pattern.substring((match.index ?? 0) + match[0].length);\n          match = rule.pattern.match(sre);\n        }\n        // Expand asterisk expressions.\n        if (are3.test(rule.pattern)) {\n          rule.pattern = '\\\\s*(.*)\\\\s*';\n        } else {\n          match = rule.pattern.match(are);\n          if (match !== null) {\n            let leftPart = '';\n            let rightPart = rule.pattern;\n            while (match !== null) {\n              leftPart += rightPart.substring(0, (match.index ?? 0) + 1);\n              if (match[1] !== ')') {\n                leftPart += '\\\\b';\n              }\n              leftPart += '\\\\s*(.*)\\\\s*';\n              if (match[2] !== '(' && match[2] !== '\\\\') {\n                leftPart += '\\\\b';\n              }\n              leftPart += match[2];\n              rightPart = rightPart.substring((match.index ?? 0) + match[0].length);\n              match = rightPart.match(are);\n            }\n            rule.pattern = leftPart + rightPart;\n          }\n          match = rule.pattern.match(are1);\n          if (match !== null) {\n            let leftPart = '\\\\s*(.*)\\\\s*';\n            if (match[1] !== ')' && match[1] !== '\\\\') {\n              leftPart += '\\\\b';\n            }\n            rule.pattern = leftPart + rule.pattern.substring((match.index ?? 0) - 1 + match[0].length);\n          }\n          match = rule.pattern.match(are2);\n          if (match !== null) {\n            let leftPart = rule.pattern.substring(0, (match.index ?? 0) + 1);\n            if (match[1] !== '(') {\n              leftPart += '\\\\b';\n            }\n            rule.pattern = leftPart + '\\\\s*(.*)\\\\s*';\n          }\n        }\n        // Expand whitespaces.\n        rule.pattern = rule.pattern.replace(wsre, '\\\\s+');\n        wsre.lastIndex = 0;\n      }\n    }\n    // Sort keywords by rank (highest first).\n    this.data.keywords.sort(this.sortKeywords);\n    // Compose regexps and refs for pres and posts.\n    this.composeRegExpsAndPresAndPosts(this.data);\n  }\n\n  /**\n   * Composes regexps and refs for pres and posts.\n   * @param data Eliza data\n   */\n  private composeRegExpsAndPresAndPosts(data: IElizaData): void {\n    this.pres = {};\n    this.posts = {};\n    if (data.pres.length === 0) {\n      throw Error('Eliza does not have any configured pre expressions.');\n    } else {\n      const a = [];\n      for (let i = 0; i < data.pres.length; i += 2) {\n        a.push(data.pres[i]);\n        this.pres[data.pres[i]] = data.pres[i + 1];\n      }\n      this.preExp = new RegExp('\\\\b(' + a.join('|') + ')\\\\b');\n    }\n    if (data.posts.length === 0) {\n      throw Error('Eliza does not have any configured post expressions.');\n    } else {\n      const a = [];\n      for (let i = 0; i < data.posts.length; i += 2) {\n        a.push(data.posts[i]);\n        this.posts[data.posts[i]] = data.posts[i + 1];\n      }\n      this.postExp = new RegExp('\\\\b(' + a.join('|') + ')\\\\b');\n    }\n  }\n\n  // eslint-disable-next-line max-lines-per-function, complexity -- TODO refactor\n  private execRule(data: IElizaData, k: number, sentence: string): string {\n    const config = this.configSubject.value;\n    const rules = data.keywords[k].rules;\n    const paramRegExp = /\\(([0-9]+)\\)/;\n    for (let i = 0; i < rules.length; i += 1) {\n      const match = sentence.match(rules[i].pattern);\n      if (match !== null) {\n        const options = rules[i].options;\n        const memory = rules[i].memory;\n        let optionIndex = config.noRandom ? 0 : Math.floor(Math.random() * options.length);\n        if ((config.noRandom && this.lastChoice[k][i] > optionIndex) || this.lastChoice[k][i] === optionIndex) {\n          this.lastChoice[k][i] += 1;\n          optionIndex = this.lastChoice[k][i];\n          if (optionIndex >= options.length) {\n            optionIndex = 0;\n            this.lastChoice[k][i] = -1;\n          }\n        } else {\n          this.lastChoice[k][i] = optionIndex;\n        }\n        let reply = options[optionIndex];\n        if (config.debug) {\n          const debugLog = `match:\\nkey: ${data.keywords[k].key}\\nrank: ${data.keywords[k].rank}\\ndecomp: ${rules[i].pattern}\\nreasmb: ${reply}\\nmemory: ${memory}`;\n          // eslint-disable-next-line no-console -- debug output\n          console.warn('debugLog', debugLog);\n        }\n        if (reply.search('^goto ') === 0) {\n          const key = reply.substring(5);\n          const ki = this.getRuleIndexByKey(data, key);\n          if (ki >= 0) {\n            return this.execRule(data, ki, sentence);\n          }\n        }\n        // Substitute positional params.\n        let paramRegExpMatch = reply.match(paramRegExp);\n        if (paramRegExpMatch) {\n          let leftPart = '';\n          let rightPart = reply;\n          while (paramRegExpMatch !== null) {\n            let param = match[parseInt(paramRegExpMatch[1], 10)];\n            // Postprocess param.\n            let postExpMatch = param.match(this.postExp);\n            if (postExpMatch !== null) {\n              let leftPart2 = '';\n              let rightPart2 = param;\n              while (postExpMatch !== null) {\n                leftPart2 += rightPart2.substring(0, postExpMatch.index ?? 0) + this.posts[postExpMatch[1]];\n                rightPart2 = rightPart2.substring((postExpMatch.index ?? 0) + postExpMatch[0].length);\n                postExpMatch = rightPart2.match(this.postExp);\n              }\n              param = leftPart2 + rightPart2;\n            }\n            leftPart += rightPart.substring(0, paramRegExpMatch.index) + param;\n            rightPart = rightPart.substring((paramRegExpMatch.index ?? 0) + paramRegExpMatch[0].length);\n            paramRegExpMatch = rightPart.match(paramRegExp);\n          }\n          reply = leftPart + rightPart;\n        }\n        const transformedReply = this.postTransform(data, reply);\n        if (memory) {\n          this.memSave(transformedReply);\n        } else {\n          return transformedReply;\n        }\n      }\n    }\n    return '';\n  }\n\n  // eslint-disable-next-line complexity -- TODO refactor\n  private transformUserQuery(data: IElizaData, input: string): IElizaResponse {\n    let reply = '';\n    // Unify text string and split text in part sentences and loop through them.\n    const parts = this.splitUserQueryIntoParts(input);\n    for (let i = 0; i < parts.length; i += 1) {\n      let part = parts[i];\n      if (part !== '') {\n        // Check for quit expressions.\n        for (let q = 0; q < data.quits.length; q += 1) {\n          if (data.quits[q] === part) {\n            return { reply: this.getFinal(data), final: true };\n          }\n        }\n        let match = part.match(this.preExp);\n        if (match !== null) {\n          let leftPart = '';\n          let rightPart = part;\n          while (match !== null) {\n            leftPart += rightPart.substring(0, match.index ?? 0) + this.pres[match[1]];\n            rightPart = rightPart.substring((match.index ?? 0) + match[0].length);\n            match = rightPart.match(this.preExp);\n          }\n          part = leftPart + rightPart;\n        }\n        // Loop trough keywords.\n        for (let k = 0; k < data.keywords.length; k += 1) {\n          if (part.search(new RegExp('\\\\b' + data.keywords[k].key + '\\\\b', 'i')) >= 0) {\n            reply = this.execRule(data, k, part);\n          }\n          if (reply !== '') {\n            return { reply, final: false };\n          }\n        }\n      }\n    }\n    // Nothing matched, try mem.\n    reply = this.memGet();\n    // If nothing in mem, try xnone.\n    if (reply === '') {\n      const k = this.getRuleIndexByKey(data, 'xnone');\n      reply = k >= 0 ? this.execRule(data, k, ' ') : reply;\n    }\n    return { reply: reply !== '' ? reply : 'I am at a loss for words.', final: false };\n  }\n\n  /**\n   * Unify text string, split text into partial sentences to be able to loop through them.\n   * @param input user query\n   * @returns split user query\n   */\n  private splitUserQueryIntoParts(input: string): string[] {\n    const parts = input\n      .toLowerCase()\n      .replace(/@#\\$%\\^&\\*\\(\\)_\\+=~`\\{\\[\\}\\]\\|:;<>\\/\\\\\\t/g, ' ')\n      .replace(/\\s+-+\\s+/g, '.')\n      .replace(/\\s*[,.?!;]+\\s*/g, '.')\n      .replace(/\\s*\\bbut\\b\\s*/g, '.')\n      .replace(/\\s{2,}/g, ' ')\n      .split('.');\n    return parts;\n  }\n\n  private sortKeywords(a: IElizaKeyword, b: IElizaKeyword) {\n    if (a.rank > b.rank) {\n      return -1;\n    } else if (a.rank < b.rank) {\n      return 1;\n    } else if (a.index > b.index) {\n      return 1;\n    } else if (a.index < b.index) {\n      return -1;\n    }\n    return 0;\n  }\n\n  private postTransform(data: IElizaData, input: string): string {\n    // final cleanings\n    let result = input.replace(/\\s{2,}/g, ' ').replace(/\\s+\\./g, '.');\n    if (data.postTransforms.length > 0) {\n      for (let i = 0; i < data.postTransforms.length; i += 1) {\n        const postTransform = data.postTransforms[i];\n        result = result.replace(postTransform.searchValue, postTransform.replaceValue);\n        data.postTransforms[i].searchValue.lastIndex = 0;\n      }\n    }\n    if (this.configSubject.value.capitalizeFirstLetter) {\n      const match = result.match(/^([a-z])/);\n      if (match) {\n        result = match[0].toUpperCase() + result.substring(1);\n      }\n    }\n    return result;\n  }\n\n  private getRuleIndexByKey(data: IElizaData, key: string): number {\n    for (let k = 0; k < data.keywords.length; k += 1) {\n      if (data.keywords[k].key === key) {\n        return k;\n      }\n    }\n    return -1;\n  }\n\n  private memSave(input: string): void {\n    this.mem.push(input);\n    if (this.mem.length > this.configSubject.value.memSize) {\n      this.mem.shift();\n    }\n  }\n\n  private memGet(): string {\n    if (this.mem.length > 0) {\n      if (this.configSubject.value.noRandom) {\n        return this.mem.shift() ?? '';\n      }\n      const n = Math.floor(Math.random() * this.mem.length);\n      const reply = this.mem[n];\n      for (let i = n + 1; i < this.mem.length; i += 1) {\n        this.mem[i - 1] = this.mem[i];\n      }\n      this.mem.length -= 1;\n      return reply;\n    }\n    return '';\n  }\n\n  private getFinal(data: IElizaData): string {\n    return data.finals.length === 0 ? elizaFinalDefault : data.finals[Math.floor(Math.random() * data.finals.length)];\n  }\n\n  private getInitial(data: IElizaData): string {\n    return data.initials.length === 0 ? elizaInitialDefault : data.initials[Math.floor(Math.random() * data.initials.length)];\n  }\n\n  public getResponse(statement: string): Promise<IElizaResponse> {\n    const data = this.data;\n    if (typeof data === 'undefined') {\n      throw new Error('Initialize Eliza first.');\n    }\n    return new Promise<IElizaResponse>(resolve => {\n      const elizaReply = this.transformUserQuery(data, statement);\n      resolve(elizaReply);\n    });\n  }\n}\n"]}

package/esm2020/lib/services/index.mjs

@@ -0,0 +1,2 @@
+export * from './eliza/eliza.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NsaWVudC11dGlsLWVsaXphL3NyYy9saWIvc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZWxpemEvZWxpemEuc2VydmljZSc7XG4iXX0=

package/esm2020/rfprodz-client-util-eliza.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmZwcm9kei1jbGllbnQtdXRpbC1lbGl6YS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYnMvY2xpZW50LXV0aWwtZWxpemEvc3JjL3JmcHJvZHotY2xpZW50LXV0aWwtZWxpemEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=