wingbot 3.26.0 → 3.27.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.26.0",
+  "version": "3.27.0-alpha.1",
   "description": "Enterprise Messaging Bot Conversation Engine",
   "main": "index.js",
   "scripts": {

package/src/AiMatching.js

@@ -403,13 +403,25 @@ class AiMatching {
                     score: regexpScore - handicap
                 };
             }
+
+            let useState;
+            if (stateless || intents.length === 0) {
+                useState = Object.entries(req.state)
+                    .reduce((o, [k, v]) => {
+                        if (k.startsWith('@')) {
+                            return o;
+                        }
+                        return Object.assign(o, { [k]: v });
+                    }, {});
+            } else {
+                useState = req.state;
+            }
+
             const { score, handicap, matched } = this
                 ._entityMatching(
                     entities,
                     reqEntities,
-                    stateless || intents.length === 0
-                        ? {}
-                        : req.state
+                    useState
                 );
 
             const allOptional = entities.every((e) => e.optional);

package/src/Processor.js

@@ -179,7 +179,7 @@ class Processor extends EventEmitter {
         }
     }
 
-    _createPostBack (postbackAcumulator, req, res) {
+    _createPostBack (postbackAcumulator, req, res, features) {
         const postBack = (action, inputData = {}, dontWaitTillEndOfLoop = false) => {
             let data = inputData;
             if (typeof data === 'function') {
@@ -214,11 +214,12 @@ class Processor extends EventEmitter {
                 postbackAcumulator.push(data
                     .then((result) => ({
                         action,
-                        data: Object.assign(result || {}, { _localpostback: true })
+                        data: Object.assign(result || {}, { _localpostback: true }),
+                        features
                     })));
             } else {
                 Object.assign(data, { _localpostback: true });
-                postbackAcumulator.push({ action, data });
+                postbackAcumulator.push({ action, data, features });
             }
 
             return Promise.resolve();
@@ -512,16 +513,17 @@ class Processor extends EventEmitter {
                 }
             );
 
+            const features = [
+                ...(this.options.features || []),
+                ...req.features
+            ];
             const options = {
                 ...this.options,
-                features: [
-                    ...(this.options.features || []),
-                    ...req.features
-                ]
+                features
             };
 
             res = new Responder(senderId, messageSender, token, options, responderData);
-            const postBack = this._createPostBack(postbackAcumulator, req, res);
+            const postBack = this._createPostBack(postbackAcumulator, req, res, features);
 
             let continueDispatching = true;
 
@@ -729,13 +731,14 @@ class Processor extends EventEmitter {
     _processPostbacks (postbackAcumulator, senderId, pageId, messageSender, responderData) {
         return postbackAcumulator.reduce((promise, postback) => promise
             .then(() => postback)
-            .then(({ action, data = {} }) => {
+            .then(({ action, data = {}, features }) => {
                 let request;
                 if (typeof action === 'object') {
                     request = action;
                 } else {
                     request = Request.postBack(senderId, action, data);
                 }
+                Object.assign(request, { features });
                 return this._processMessage(request, pageId, messageSender, responderData);
             }), Promise.resolve({}));
     }

package/src/wingbot/CustomEntityDetectionModel.js

@@ -19,6 +19,7 @@ const { replaceDiacritics } = require('../utils');
  * @callback EntityDetector
  * @param {string} text - part of text
  * @param {DetectedEntity[]} entities - dependent entities
+ * @param {boolean} [searchWithinWords] - optional ability to search within words
  * @returns {DetectedEntity[]|DetectedEntity|Promise<DetectedEntity>|Promise<DetectedEntity[]>}
  */
 
@@ -154,19 +155,52 @@ class CustomEntityDetectionModel {
      * @param {string} entity
      * @param {string} text
      * @param {DetectedEntity[]} entities
+     * @param {DetectedEntity[]} subWord
      * @returns {Promise<DetectedEntity[]>}
      */
-    async _detectEntities (entity, text, entities) {
+    async _detectAllEntities (entity, text, entities, subWord) {
+        const [regularResults, subWordResults] = await Promise.all([
+            this._detectEntities(entity, text, entities, subWord, false),
+            this._detectEntities(entity, text, entities, subWord, true)
+        ]);
+
+        const cleanSubWordResults = subWordResults
+            .filter((regular) => regularResults
+                .some((e) => e.start < regular.end && e.end > regular.start));
+
+        subWord.push(...cleanSubWordResults);
+
+        return regularResults;
+    }
+
+    /**
+     *
+     * @param {string} entity
+     * @param {string} text
+     * @param {DetectedEntity[]} entities
+     * @param {DetectedEntity[]} subWord
+     * @param {boolean} detectSubWords
+     * @returns {Promise<DetectedEntity[]>}
+     */
+    async _detectEntities (entity, text, entities, subWord, detectSubWords) {
         const { entityDetector, dependencies } = this._entityDetectors.get(entity);
 
+        if (detectSubWords && entityDetector.length < 3) {
+            return [];
+        }
+
         const collected = [];
         let o = 0;
         let t = text;
         try {
             for (let i = 0; i < text.length; i++) {
-
-                const dependentEntities = entities.filter((e) => dependencies.includes(`@${e.entity.toUpperCase()}`));
-                const res = await Promise.resolve(entityDetector(t, dependentEntities));
+                const dependentEntities = [
+                    ...subWord.filter((e) => dependencies.includes(`@${e.entity.toUpperCase()}`)),
+                    ...entities.filter((e) => dependencies.includes(`@${e.entity.toUpperCase()}`))
+                ];
+                const res = await Promise.resolve(
+                    entityDetector(t, dependentEntities, detectSubWords)
+                );
 
                 const resWasArray = Array.isArray(res);
                 const resArray = resWasArray ? res : [res];
@@ -194,8 +228,14 @@ class CustomEntityDetectionModel {
         }
     }
 
-    _escapeRegex (string) {
-        return string.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+    _escapeRegex (string, shouldReplaceDiacritics) {
+        const ret = string.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+
+        if (!shouldReplaceDiacritics) {
+            return ret;
+        }
+
+        return replaceDiacritics(ret);
     }
 
     /**
@@ -279,16 +319,50 @@ class CustomEntityDetectionModel {
         return res;
     }
 
+    /**
+     *
+     * @param {boolean} [known]
+     * @returns {string[]} -
+     */
+    getDependentEntities (known = null) {
+        const entities = new Set();
+        const knownEntities = new Map(
+            Array.from(this._entityDetectors.keys())
+                .map((key) => [key.toLowerCase(), key])
+        );
+
+        for (const { dependencies } of this._entityDetectors.values()) {
+            for (const entity of dependencies) {
+                const lowerCase = entity.replace(/^@/, '').toLowerCase();
+                const isKnown = knownEntities.has(lowerCase);
+
+                if (isKnown && known !== false) {
+                    entities.add(knownEntities.get(lowerCase));
+                } else if (!isKnown && known !== true) {
+                    entities.add(lowerCase);
+                }
+            }
+        }
+
+        return Array.from(entities.values());
+    }
+
     /**
      *
      * @param {string} text
      * @param {string} [singleEntity]
-     * @param {string[]} expectedEntities
+     * @param {string[]} [expected]
      * @param {DetectedEntity[]} [entities] - previously detected entities to include
+     * @param {DetectedEntity[]} [subWord] - previously detected entities within words
      * @returns {Promise<DetectedEntity[]>}
      */
-    async resolveEntities (text, singleEntity = null, expectedEntities = [], entities = []) {
-        const resolved = new Set();
+    async resolveEntities (text, singleEntity = null, expected = [], entities = [], subWord = []) {
+        // mark unknown dependencies as resolved
+        const resolved = new Set(
+            this.getDependentEntities(false)
+                .map((entity) => resolved.add(`@${entity.toUpperCase()}`))
+        );
+
         let missing = Array.from(this._entityDetectors.keys());
 
         while (missing.length !== 0) {
@@ -315,7 +389,7 @@ class CustomEntityDetectionModel {
             }
 
             const results = await Promise.all(
-                detect.map((entity) => this._detectEntities(entity, text, entities))
+                detect.map((entity) => this._detectAllEntities(entity, text, entities, subWord))
             );
 
             detect.forEach((entity) => resolved.add(`@${entity.toUpperCase()}`));
@@ -323,7 +397,7 @@ class CustomEntityDetectionModel {
             results.forEach((res) => entities.push(...res));
         }
 
-        const clean = this.nonOverlapping(entities, expectedEntities);
+        const clean = this.nonOverlapping(entities, expected);
 
         if (!singleEntity) {
             return clean;
@@ -415,8 +489,9 @@ class CustomEntityDetectionModel {
         /**
          * @param {string} text
          * @param {DetectedEntity[]} entities
+         * @param {boolean} searchWithinWords
          */
-        return (text, entities) => {
+        return (text, entities, searchWithinWords) => {
             if (typeof extractValue === 'string'
                 && !this._entityByDependency(entities, extractValue)) {
 
@@ -426,15 +501,16 @@ class CustomEntityDetectionModel {
             let replaced = source.replace(/@[A-Z0-9-]+/g, (value) => {
                 const matchingEntities = entities
                     .filter((e) => `@${e.entity.toUpperCase()}` === value)
-                    .map((e) => this._escapeRegex(e.text));
+                    .map((e) => this._escapeRegex(e.text, options.replaceDiacritics));
 
                 if (matchingEntities.length === 0) {
                     return value;
                 }
+                matchingEntities.sort((a, z) => z.length - a.length);
                 return `(${matchingEntities.join('|')})`;
             });
 
-            if (options.matchWholeWords) {
+            if (options.matchWholeWords && !searchWithinWords) {
                 replaced = `(?<=(^|[^a-z0-9\u00C0-\u017F]))${replaced}(?=([^a-z0-9\u00C0-\u017F]|$))`;
             }
 
@@ -446,6 +522,8 @@ class CustomEntityDetectionModel {
             }
             const match = matchText.match(r);
 
+            // console.log({ matchText, replaced, match: match && match[0], searchWithinWords });
+
             if (!match) {
                 return null;
             }