feathers-utils 6.0.0 → 7.0.1

package/src/utils/mergeQuery/mergeArrays.ts

@@ -1,5 +1,5 @@
-import type { Path } from "../../typesInternal";
-import type { Handle, ActionOnEmptyIntersect } from "./types";
+import type { Path } from '../../typesInternal.js'
+import type { Handle, ActionOnEmptyIntersect } from './types.js'
 
 export function mergeArrays<T>(
   targetArr: T[] | undefined,
@@ -9,110 +9,110 @@ export function mergeArrays<T>(
   actionOnEmptyIntersect?: ActionOnEmptyIntersect,
 ): T[] | undefined {
   if (!sourceArr && !targetArr) {
-    return;
+    return
   }
-  if (handle === "target") {
-    return targetArr;
-  } else if (handle === "source") {
-    return sourceArr;
-  } else if (handle === "combine") {
+  if (handle === 'target') {
+    return targetArr
+  } else if (handle === 'source') {
+    return sourceArr
+  } else if (handle === 'combine') {
     if (!sourceArr || !Array.isArray(sourceArr)) {
-      return targetArr;
+      return targetArr
     }
     if (!targetArr || !Array.isArray(targetArr)) {
-      return sourceArr;
+      return sourceArr
     }
-    const arr = targetArr.concat(sourceArr);
-    return [...new Set(arr)];
-  } else if (handle === "intersect" || handle === "intersectOrFull") {
-    const targetIsNotArray = !targetArr || !Array.isArray(targetArr);
-    const sourceIsNotArray = !sourceArr || !Array.isArray(sourceArr);
+    const arr = targetArr.concat(sourceArr)
+    return [...new Set(arr)]
+  } else if (handle === 'intersect' || handle === 'intersectOrFull') {
+    const targetIsNotArray = !targetArr || !Array.isArray(targetArr)
+    const sourceIsNotArray = !sourceArr || !Array.isArray(sourceArr)
 
-    if ((targetIsNotArray || sourceIsNotArray) && handle === "intersect") {
+    if ((targetIsNotArray || sourceIsNotArray) && handle === 'intersect') {
       if (actionOnEmptyIntersect) {
         actionOnEmptyIntersect(
           targetArr as unknown,
           sourceArr,
           prependKey || [],
-        );
+        )
       }
-      return;
+      return
     }
 
     if (targetIsNotArray || sourceIsNotArray) {
-      const val = !targetIsNotArray ? targetArr : sourceArr;
-      return val;
+      const val = !targetIsNotArray ? targetArr : sourceArr
+      return val
     }
 
-    return targetArr!.filter((val) => sourceArr!.includes(val));
+    return targetArr!.filter((val) => sourceArr!.includes(val))
   }
-  return undefined;
+  return undefined
 }
 
 if (import.meta.vitest) {
-  const { it, expect } = import.meta.vitest;
+  const { it, expect } = import.meta.vitest
 
-  describe("target", function () {
-    it("returns target", function () {
-      const arr = mergeArrays([1], [2], "target");
+  describe('target', function () {
+    it('returns target', function () {
+      const arr = mergeArrays([1], [2], 'target')
 
-      expect(arr).toStrictEqual([1]);
-    });
+      expect(arr).toStrictEqual([1])
+    })
 
-    it("returns target even if undefined", function () {
-      const arr = mergeArrays(undefined, [1], "target");
+    it('returns target even if undefined', function () {
+      const arr = mergeArrays(undefined, [1], 'target')
 
-      expect(arr).toBeUndefined();
-    });
-  });
+      expect(arr).toBeUndefined()
+    })
+  })
 
-  describe("source", function () {
-    it("returns source", function () {
-      const arr = mergeArrays([1], [2], "source");
+  describe('source', function () {
+    it('returns source', function () {
+      const arr = mergeArrays([1], [2], 'source')
 
-      expect(arr).toStrictEqual([2]);
-    });
+      expect(arr).toStrictEqual([2])
+    })
 
-    it("returns source even if undefined", function () {
-      const arr = mergeArrays([1], undefined, "source");
+    it('returns source even if undefined', function () {
+      const arr = mergeArrays([1], undefined, 'source')
 
-      expect(arr).toBeUndefined();
-    });
-  });
+      expect(arr).toBeUndefined()
+    })
+  })
 
-  describe("combine", function () {
-    it("returns combined array", function () {
-      const arr = mergeArrays([1, 2], [2, 3], "combine");
+  describe('combine', function () {
+    it('returns combined array', function () {
+      const arr = mergeArrays([1, 2], [2, 3], 'combine')
 
-      expect(arr).toStrictEqual([1, 2, 3]);
-    });
+      expect(arr).toStrictEqual([1, 2, 3])
+    })
 
-    it("returns one array if combine", function () {
-      const arr1 = mergeArrays([1, 2], undefined, "combine");
+    it('returns one array if combine', function () {
+      const arr1 = mergeArrays([1, 2], undefined, 'combine')
 
-      expect(arr1).toStrictEqual([1, 2]);
+      expect(arr1).toStrictEqual([1, 2])
 
-      const arr2 = mergeArrays(undefined, [1, 2], "combine");
+      const arr2 = mergeArrays(undefined, [1, 2], 'combine')
 
-      expect(arr2).toStrictEqual([1, 2]);
-    });
-  });
+      expect(arr2).toStrictEqual([1, 2])
+    })
+  })
 
-  describe("intersect", function () {
-    it("returns intersected array", function () {
-      const arr = mergeArrays([1, 2], [2, 3], "intersect");
+  describe('intersect', function () {
+    it('returns intersected array', function () {
+      const arr = mergeArrays([1, 2], [2, 3], 'intersect')
 
-      expect(arr).toStrictEqual([2]);
-    });
+      expect(arr).toStrictEqual([2])
+    })
 
-    it("returns undefined if one is undefined", function () {
-      const arr1 = mergeArrays([1, 2], undefined, "intersect");
+    it('returns undefined if one is undefined', function () {
+      const arr1 = mergeArrays([1, 2], undefined, 'intersect')
 
-      expect(arr1).toBeUndefined();
+      expect(arr1).toBeUndefined()
 
-      const arr2 = mergeArrays(undefined, [1, 2], "intersect");
+      const arr2 = mergeArrays(undefined, [1, 2], 'intersect')
 
-      expect(arr2).toBeUndefined();
-    });
-  });
+      expect(arr2).toBeUndefined()
+    })
+  })
 }