feat: add nlg

Author: Léo Guillaume

src/index.ts

@@ -25,7 +25,7 @@ import { Language } from './language'
 import { NlpUtil, NlpManager, NlpExcelReader } from './nlp'
 import { XTableUtils, XTable, XDoc } from './xtables'
 import { removeEmojis, Evaluator, SpellCheck, Handlebars } from './util'
-
+import { ActionManager, NlgManager } from './nlg'
 export {
     Language,
     NlpUtil,
@@ -38,8 +38,8 @@ export {
     Evaluator,
     SpellCheck,
     Handlebars,
-    // ActionManager,
-    // NlgManager,
+    ActionManager,
+    NlgManager,
     // NeuralNetwork,
     // SentimentAnalyzer,
     // SentimentManager,

src/nlg/index.ts

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) AXA Group Operations Spain S.A.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+import { ActionManager } from '@nlpjs/nlg'
+import NlgManager from './nlg-manager'
+
+export {
+  NlgManager,
+  ActionManager,
+};

src/nlg/nlg-manager.ts

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) AXA Group Operations Spain S.A.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+import NlgManagerBase from '@nlpjs/nlg';
+import { Evaluator } from '@nlpjs/evaluator';
+
+class NlgManager extends NlgManagerBase {
+  constructor(settings: any = {}, container?: any) {
+    super(settings, container);
+    this.container.register('Evaluator', Evaluator, true);
+  }
+
+  addAnswer(locale: string, intent: string, answer: any, opts?: any): void {
+    return this.add(locale, intent, answer, opts);
+  }
+
+  async findAnswer(locale: string, intent: string, context: any, settings?: any): Promise<{ response: any } | undefined> {
+    const answer = await this.find(locale, intent, context, settings);
+    if (!answer.answer) {
+      return undefined;
+    }
+    return {
+      response: answer.answer,
+    };
+  }
+
+  removeAnswer(locale: string, intent: string, answer: any, opts?: any): void {
+    return this.remove(locale, intent, answer, opts);
+  }
+
+  isValid(condition: string | undefined, context: any): boolean {
+    const evaluator = this.container.get('Evaluator');
+    if (evaluator) {
+      return (
+          !condition ||
+          condition === '' ||
+          evaluator.evaluate(condition, context) === true
+      );
+    }
+    return true;
+  }
+
+  findAllAnswers(locale?: string, intent?: string, context?: any): {answer: string, opts: string}[] | any {
+    if (typeof locale === 'string') {
+      const found = super.findAllAnswers(locale, intent, context);
+      const filtered = super.filterAnswers(found);
+      return filtered.answers.map((x: {answer: string, opts: string}) => ({
+        response: x.answer,
+        opts: x.opts,
+      }));
+    }
+    return super.findAllAnswers(locale);
+  }
+}
+
+export default NlgManager;
+

src/types/@nlpjs/core.d.ts

@@ -57,11 +57,25 @@ declare module '@nlpjs/core' {
 
     export function ArrToObj<T extends Obj>(arr: T[], keyField: keyof T): { [key: string]: T };
 
-    export function Clonable(Base: new () => any): new () => any;
+    export class Clonable<T = any> {
+        constructor(settings?: any, container?: any);
+        readonly container: any;
+        readonly settings: T;
+        applySettings(target: any, source: any): void;
+        getPipeline(name: string): any[];
+        clone(): Clonable<T>;
+    }
 
     export class Container {
         constructor(options?: ContainerOptions);
 
+        register<T>(
+            id: string,
+            obj: T,
+            singleton?: boolean,
+            force?: boolean
+        ): void;
+
         addStemmer(lang: Language, stemmer: StemmerFunction): void;
 
         addTokenizer(lang: Language, tokenizer: TokenizerFunction): void;

src/types/@nlpjs/nlg.d.ts

@@ -0,0 +1,98 @@
+declare module '@nlpjs/nlg' {
+    import { Clonable, Container } from '@nlpjs/core';
+
+    interface Answer {
+        response: string;
+        opts?: Record<string, any>;
+    }
+
+    interface FindAnswerOptions {
+        skipIfSameInput?: boolean;
+        ignoreCase?: boolean;
+        ignoreStopWords?: boolean;
+    }
+
+    interface NlgManagerSettings {
+        settingsPerLocale?: Record<string, NlgManagerSettings>;
+        useNearestLocale?: boolean;
+    }
+
+    interface NlgManagerAnswer {
+        answer: string;
+        score: number;
+        opts?: Record<string, any>;
+        context?: Record<string, any>;
+    }
+
+    class NlgManager {
+        constructor(settings?: NlgManagerSettings, container?: Container);
+
+        add(locale: string, intent: string, answer: string, opts?: Record<string, any>): void;
+        addAnswer(locale: string, intent: string, answer: string, opts?: Record<string, any>): void;
+        filterAnswers(srcInput: {answer: string, opts: string}[]): {answers: {answer: string, opts: string}[]};
+        find(locale: string, intent: string, context?: Record<string, any>, options?: FindAnswerOptions): Promise<NlgManagerAnswer>;
+
+        findAnswer(locale: string, intent: string, context?: Record<string, any>, options?: FindAnswerOptions): Promise<Answer | undefined>;
+
+        findAllAnswers(locale?: string, intent?: string, context?: Record<string, any>): Array<{answer: string, opts: string}>;
+
+        remove(locale: string, intent: string, answer: string, opts?: Record<string, any>): void;
+        removeAnswer(locale: string, intent: string, answer: string, opts?: Record<string, any>): void;
+
+        isValid(condition: string, context?: Record<string, any>): boolean;
+
+        container: Container;
+    }
+
+    interface ActionManagerSettings {
+        container?: Container;
+        tag?: string;
+    }
+
+    interface ActionBundle {
+        action: string;
+        parameters: any[];
+    }
+
+    interface ProcessedAnswer {
+        answer?: string | object;
+        actions?: ActionBundle[];
+    }
+
+    type ActionFunction = (input: ProcessedAnswer, ...parameters: any[]) => Promise<ProcessedAnswer>;
+
+    class ActionManager extends Clonable {
+        constructor(settings?: ActionManagerSettings, container?: Container);
+
+        actions: Record<string, ActionBundle[]>;
+        actionsMap: Record<string, ActionFunction>;
+
+        registerDefault(): void;
+
+        posAction(intent: string, action: string, parameters: any[]): number;
+
+        findActions(intent: string): { action: string; parameters: any[]; fn: ActionFunction }[];
+
+        processActions(intent: string, input: string | object): Promise<ProcessedAnswer>;
+
+        addAction(intent: string, action: string, parameters: any[], fn?: ActionFunction): void;
+
+        removeAction(intent: string, action: string, parameters: any[]): void;
+
+        removeActions(intent: string): void;
+
+        registerActionInMap(action: string, fn: ActionFunction): void;
+
+        removeActionFromMap(action: string): void;
+
+        run(srcInput: { intent: string; }, settings?: any): Promise<ProcessedAnswer>;
+
+        toJSON(): { settings: ActionManagerSettings; actions: Record<string, ActionBundle[]> };
+
+        fromJSON(json: { settings: ActionManagerSettings; actions: Record<string, ActionBundle[]> }): void;
+    }
+
+    export { ActionManagerSettings, ActionManager };
+
+    export default NlgManager;
+}