wingbot 3.27.0-alpha.2 → 3.27.1

package/package.json

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

package/src/wingbot/CustomEntityDetectionModel.js

@@ -58,6 +58,14 @@ const { replaceDiacritics } = require('../utils');
 
 /** @typedef {import('../Request')} Request */
 
+function optionalWrap (l, r, content) {
+    const consistent = !l === !r;
+    if (consistent) {
+        return `(${content})`;
+    }
+    return `${l || ''}(${content})${r || ''}`;
+}
+
 class CustomEntityDetectionModel {
 
     /**
@@ -165,8 +173,9 @@ class CustomEntityDetectionModel {
         ]);
 
         const cleanSubWordResults = subWordResults
-            .filter((regular) => regularResults
-                .some((e) => e.start < regular.end && e.end > regular.start));
+            .filter((regular) => !regularResults
+                .some((e) => e.start < regular.end && e.end > regular.start
+                    && e.end >= regular.end && e.start <= regular.start));
 
         subWord.push(...cleanSubWordResults);
 
@@ -352,11 +361,11 @@ class CustomEntityDetectionModel {
      * @param {string} text
      * @param {string} [singleEntity]
      * @param {string[]} [expected]
-     * @param {DetectedEntity[]} [entities] - previously detected entities to include
+     * @param {DetectedEntity[]} [prevEnts] - previously detected entities to include
      * @param {DetectedEntity[]} [subWord] - previously detected entities within words
      * @returns {Promise<DetectedEntity[]>}
      */
-    async resolveEntities (text, singleEntity = null, expected = [], entities = [], subWord = []) {
+    async resolveEntities (text, singleEntity = null, expected = [], prevEnts = [], subWord = []) {
         // mark unknown dependencies as resolved
         const resolved = new Set(
             this.getDependentEntities(false)
@@ -364,6 +373,15 @@ class CustomEntityDetectionModel {
         );
 
         let missing = Array.from(this._entityDetectors.keys());
+        const entities = prevEnts.map((e) => {
+            if (typeof e.text === 'string') {
+                return e;
+            }
+            return {
+                ...e,
+                text: text.substring(e.start, e.end)
+            };
+        });
 
         while (missing.length !== 0) {
             let detect = [];
@@ -498,16 +516,16 @@ class CustomEntityDetectionModel {
                 return null;
             }
 
-            let replaced = source.replace(/@[A-Z0-9-]+/g, (value) => {
+            let replaced = source.replace(/(\()?@([A-Z0-9-]+)(\))?/g, (value, l, ent, r) => {
                 const matchingEntities = entities
-                    .filter((e) => `@${e.entity.toUpperCase()}` === value)
+                    .filter((e) => e.entity.toUpperCase() === ent)
                     .map((e) => this._escapeRegex(e.text, options.replaceDiacritics));
 
                 if (matchingEntities.length === 0) {
-                    return value;
+                    return optionalWrap(l, r, `@${ent}`);
                 }
                 matchingEntities.sort((a, z) => z.length - a.length);
-                return `(${matchingEntities.join('|')})`;
+                return optionalWrap(l, r, matchingEntities.join('|'));
             });
 
             if (options.matchWholeWords && !searchWithinWords) {
@@ -539,19 +557,15 @@ class CustomEntityDetectionModel {
 
             if (typeof extractValue === 'function') {
                 value = extractValue(match, useEntities);
-            } else if (typeof extractValue === 'string' || dependencies.length === 1) {
+            } else if (typeof extractValue === 'string' || dependencies.length > 0) {
                 const entityName = typeof extractValue === 'string'
                     ? extractValue
                     : dependencies[0];
 
                 const entity = this._entityByDependency(useEntities, entityName);
                 value = entity ? entity.value : null;
-            } else if (entities.length === 0) {
-                [value] = match;
             } else {
-                value = useEntities.reduce((o, e) => Object.assign(o, {
-                    [e.entity]: e.value
-                }), {});
+                [value] = match;
             }
 
             return {