@dataloop-ai/components 0.19.217 → 0.19.219

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dataloop-ai/components",
-  "version": "0.19.217",
+  "version": "0.19.219",
   "exports": {
     ".": "./index.ts",
     "./models": "./models.ts",

package/src/components/compound/DlSearches/DlSmartSearch/components/DlSmartSearchInput.vue

@@ -29,6 +29,7 @@
                         :style="textareaStyles"
                         :placeholder="inputPlaceholder"
                         :contenteditable="!disabled"
+                        :spellcheck="false"
                         @keypress="onKeyPress"
                         @keyup.esc="onKeyPress"
                         @input="onInput"
@@ -468,28 +469,25 @@ export default defineComponent({
         const forceStringsType = (data: string | Data): string | Data => {
             const convertNode = (node: Data) => {
                 for (const key in node) {
-                    const value = node[key]
-                    if (Array.isArray(value)) {
-                        for (let i = 0; i < value.length; i++) {
-                            value[i] = '' + value[i]
+                    if (key !== '$exists') {
+                        const value = node[key]
+                        if (Array.isArray(value)) {
+                            for (let i = 0; i < value.length; i++) {
+                                value[i] = '' + value[i]
+                            }
+                        } else {
+                            node[key] = '' + value
                         }
-                    } else {
-                        node[key] = '' + value
                     }
                 }
             }
             if (typeof data !== 'string' && schema.value) {
                 for (const key in data) {
                     const type = schema.value[key]
-                    if (Array.isArray(type)) {
-                        if (type.includes('string')) {
-                            if (typeof data[key] === 'object') {
-                                convertNode(data[key])
-                            } else {
-                                data[key] = '' + data[key]
-                            }
-                        }
-                    } else if (type === 'string') {
+                    if (
+                        (Array.isArray(type) && type.includes('string')) ||
+                        type === 'string'
+                    ) {
                         if (typeof data[key] === 'object') {
                             convertNode(data[key])
                         } else {

package/src/components/compound/DlSelect/DlSelect.vue

@@ -425,6 +425,13 @@ export default defineComponent({
         selectChildren: {
             type: Boolean,
             default: true
+        },
+        /**
+         * the label to show when items are selected
+         */
+        selectedResourceLabel: {
+            type: String,
+            default: 'Selected Items'
         }
     },
     emits: [
@@ -616,7 +623,7 @@ export default defineComponent({
                 return getLabelOfSelectedOption(valueToSearch, this.options)
             }
             return this.modelValueLength > 0
-                ? `${this.modelValueLength} Selected Items`
+                ? `${this.modelValueLength} ${this.selectedResourceLabel}`
                 : this.computedPlaceholder
         },
         computedAllItemsLabel(): string {

package/src/hooks/use-suggestions.ts

@@ -38,7 +38,9 @@ export const operators: Operators = {
     $lt: '<', // number, date, datetime, time
     $lte: '<=', // number, date, datetime, time
     $in: 'IN', // all types
-    $nin: 'NOT-IN' // all types
+    $nin: 'NOT-IN', // all types
+    $exists: 'EXISTS', // all types
+    $doesnt_exist_dummy: 'DOESNT-EXIST' // all types
 }
 
 type OperatorToDataTypeMap = {
@@ -53,7 +55,9 @@ const operatorToDataTypeMap: OperatorToDataTypeMap = {
     $lt: ['number', 'date', 'datetime', 'time'],
     $lte: ['number', 'date', 'datetime', 'time'],
     $in: [],
-    $nin: []
+    $nin: [],
+    $exists: [],
+    $doesnt_exist_dummy: []
 }
 
 const knownDataTypes = [
@@ -86,6 +90,8 @@ export const datePattern = new RegExp(
 export const datePatternNoBrackets =
     /(\d{2}\/\d{2}\/\d{4}\s?|\s?dd\/mm\/yyyy\s?)/
 
+const existsValuePlaceholder = 'existsValuePlaceholder'
+
 const mergeWords = (words: string[]) => {
     const result: string[] = []
     let merging = false
@@ -93,8 +99,18 @@ const mergeWords = (words: string[]) => {
 
     for (let i = 0; i < words.length; ++i) {
         const currentItem = words[i]
-
-        if (currentItem === 'IN' || currentItem === 'NOT-IN') {
+        if (
+            currentItem === operators.$exists ||
+            currentItem === operators.$doesnt_exist_dummy
+        ) {
+            merging = false
+            result.push(currentItem)
+            result.push(existsValuePlaceholder)
+            continue
+        } else if (
+            currentItem === operators.$in ||
+            currentItem === operators.$nin
+        ) {
             merging = true
             result.push(currentItem)
             mergeIndex = result.length
@@ -317,7 +333,12 @@ export const useSuggestions = (
                 localSuggestions = []
             }
 
-            if (!value || !isNextCharSpace(input, value)) {
+            const lastTerm =
+                operator === operators.$exists ||
+                operator === operators.$doesnt_exist_dummy
+                    ? operator
+                    : value
+            if (!lastTerm || !isNextCharSpace(input, lastTerm)) {
                 continue
             }
 

package/src/utils/parse-smart-query.ts

@@ -35,7 +35,18 @@ const GeneratePureValue = (value: any) => {
     return value
 }
 
-const Operators: string[] = ['>=', '<=', '!=', '=', '>', '<', 'IN', 'NOT-IN']
+const Operators: string[] = [
+    '>=',
+    '<=',
+    '!=',
+    '=',
+    '>',
+    '<',
+    'IN',
+    'NOT-IN',
+    'EXISTS',
+    'DOESNT-EXIST'
+]
 
 /**
  * Method to convert a DlSmartSearch query string to Mongo based JSON query
@@ -103,51 +114,59 @@ export const parseSmartQuery = (
 
             switch (true) {
                 case term.includes('>='):
-                    [key, value] = term.split('>=').map((x) => x.trim())
+                    ;[key, value] = term.split('>=').map((x) => x.trim())
                     pureValue = GeneratePureValue(value)
                     if (pureValue !== null) {
                         andQuery.push({ [key]: { $gte: pureValue } })
                     }
                     break
                 case term.includes('<='):
-                    [key, value] = term.split('<=').map((x) => x.trim())
+                    ;[key, value] = term.split('<=').map((x) => x.trim())
                     pureValue = GeneratePureValue(value)
                     if (pureValue !== null) {
                         andQuery.push({ [key]: { $lte: pureValue } })
                     }
                     break
                 case term.includes('>'):
-                    [key, value] = term.split('>').map((x) => x.trim())
+                    ;[key, value] = term.split('>').map((x) => x.trim())
                     pureValue = GeneratePureValue(value)
                     if (pureValue !== null) {
                         andQuery.push({ [key]: { $gt: pureValue } })
                     }
                     break
                 case term.includes('<'):
-                    [key, value] = term.split('<').map((x) => x.trim())
+                    ;[key, value] = term.split('<').map((x) => x.trim())
                     pureValue = GeneratePureValue(value)
                     if (pureValue !== null) {
                         andQuery.push({ [key]: { $lt: pureValue } })
                     }
                     break
                 case term.includes('!='):
-                    [key, value] = term.split('!=').map((x) => x.trim())
+                    ;[key, value] = term.split('!=').map((x) => x.trim())
                     pureValue = GeneratePureValue(value)
                     if (pureValue !== null) {
                         andQuery.push({ [key]: { $ne: pureValue } })
                     }
                     break
                 case term.includes('='):
-                    [key, value] = term.split('=').map((x) => x.trim())
+                    ;[key, value] = term.split('=').map((x) => x.trim())
                     pureValue = GeneratePureValue(value)
                     if (pureValue !== null) {
                         andQuery.push({ [key]: pureValue })
                     }
                     break
+                case term.includes('EXISTS'):
+                    key = term.split('EXISTS')[0].trim()
+                    andQuery.push({ [key]: { $exists: true } })
+                    break
+                case term.includes('DOESNT-EXIST'):
+                    key = term.split('DOESNT-EXIST')[0].trim()
+                    andQuery.push({ [key]: { $exists: false } })
+                    break
                 case term.includes('IN'):
-                    [key, value] = term.split('IN').map((x) => x.trim())
+                    ;[key, value] = term.split('IN').map((x) => x.trim())
                     if (key.includes('NOT-')) {
-                        [key, value] = term
+                        ;[key, value] = term
                             .split('NOT-IN')
                             .map((x) => x.trim())
                         queryValue = term
@@ -269,6 +288,11 @@ export const stringifySmartQuery = (query: { [key: string]: any }): string => {
                         case '$lte':
                             result += `${key} <= ${operatorValue}`
                             break
+                        case '$exists':
+                            result += `${key} ${
+                                operatorValue ? 'EXISTS' : 'DOESNT-EXIST'
+                            }`
+                            break
                         case '$in':
                             if (!Array.isArray(operatorValue)) {
                                 operatorValue = [operatorValue] as