feat(expr): Make intersects() return the intersection when non-empty

Author: effigies

src/schema/expressionLanguage.test.ts

@@ -16,16 +16,26 @@ Deno.test('test expression functions', async (t) => {
   })
   await t.step('intersects function', () => {
     const intersects = expressionFunctions.intersects
-    assert(intersects([1, 2, 3], [2, 3, 4]) === true)
-    assert(intersects([1, 2, 3], [4, 5, 6]) === false)
-    assert(intersects(['abc', 'def'], ['def']) === true)
-    assert(intersects(['abc', 'def'], ['ghi']) === false)
+    const truthy = (a: any): boolean => !!a
+    const falsey = (a: any): boolean => !a
+    const equal = expressionFunctions.allequal
+    assert(truthy(intersects([1, 2, 3], [2, 3, 4])))
+    assert(falsey(intersects([1, 2, 3], [4, 5, 6])))
+    assert(truthy(intersects(['abc', 'def'], ['def'])))
+    assert(falsey(intersects(['abc', 'def'], ['ghi'])))
+    // Just checking values, I'm not concerned about types here
+    // @ts-expect-error
+    assert(equal(intersects([1, 2, 3], [2, 3, 4]), [2, 3]))
+    // @ts-expect-error
+    assert(equal(intersects(['abc', 'def'], ['def']), ['def']))
 
     // Promote scalars to arrays
     // @ts-ignore
-    assert(intersects('abc', ['abc', 'def']) === true)
+    assert(truthy(intersects('abc', ['abc', 'def'])))
     // @ts-ignore
-    assert(intersects('abc', ['a', 'b', 'c']) === false)
+    assert(falsey(intersects('abc', ['a', 'b', 'c'])))
+    // @ts-expect-error
+    assert(equal(intersects('abc', ['abc', 'def']), ['abc']))
   })
   await t.step('match function', () => {
     const match = expressionFunctions.match

src/schema/expressionLanguage.ts

@@ -40,14 +40,30 @@ export const expressionFunctions = {
     const index = list.indexOf(item)
     return index != -1 ? index : null
   },
-  intersects: <T>(a: T[], b: T[]): boolean => {
+  intersects: <T>(a: T[], b: T[]): T[] | null => {
+    // Tolerate single values
     if (!Array.isArray(a)) {
       a = [a]
     }
     if (!Array.isArray(b)) {
       b = [b]
     }
-    return a.some((x) => b.includes(x))
+    // Construct a set from the smaller list
+    if (a.length < b.length) {
+      const tmp = a
+      a = b
+      b = tmp
+    }
+    if (b.length === 0) {
+      return null
+    }
+
+    const bSet = new Set(b)
+    const intersection = a.filter((x) => bSet.has(x))
+    if (intersection.length === 0) {
+      return null
+    }
+    return intersection
   },
   match: (target: string, regex: string): boolean => {
     const re = RegExp(regex)