quetch 0.11.2 → 0.13.0

package/doc/interfaces/CustomFetch.md

@@ -32,4 +32,4 @@
 
 #### Defined in
 
-[lib/types/CustomFetch.ts:5](https://github.com/nevoland/quetch/blob/6055b33/lib/types/CustomFetch.ts#L5)
+[lib/types/CustomFetch.ts:5](https://github.com/nevoland/quetch/blob/fbf3307/lib/types/CustomFetch.ts#L5)

package/lib/middlewares/fetchExternal.ts

@@ -16,7 +16,7 @@ export function fetchExternal(
     console.error("Could not find a global `fetch` function");
   }
   return async (request, _) => {
-    let response;
+    let response: Response | undefined;
     try {
       response = await fetch(request);
     } catch (error) {

package/lib/tools/filterItem.test.ts

@@ -17,7 +17,7 @@ test("tests filter lists", () => {
       },
       { a: "foo", b: "bar" },
     ),
-  ).toBeTruthy();
+  ).toBe(true);
   expect(
     filterItem(
       {
@@ -29,7 +29,7 @@ test("tests filter lists", () => {
       },
       { a: "foo", b: "bar" },
     ),
-  ).toBeFalsy();
+  ).toBe(false);
   expect(
     filterItem(
       {
@@ -38,7 +38,7 @@ test("tests filter lists", () => {
       },
       { a: "foo", b: "bar" },
     ),
-  ).toBeTruthy();
+  ).toBe(true);
   expect(
     filterItem(
       {
@@ -46,7 +46,7 @@ test("tests filter lists", () => {
       },
       { a: "foo", b: "bar" },
     ),
-  ).toBeTruthy();
+  ).toBe(true);
   expect(
     filterItem(
       {
@@ -54,7 +54,7 @@ test("tests filter lists", () => {
       },
       { a: "foo", b: "bar" },
     ),
-  ).toBeFalsy();
+  ).toBe(false);
   expect(
     filterItem(
       {
@@ -66,7 +66,7 @@ test("tests filter lists", () => {
       },
       { a: "foo", b: "bar" },
     ),
-  ).toBeTruthy();
+  ).toBe(true);
   expect(
     filterItem(
       {
@@ -78,7 +78,7 @@ test("tests filter lists", () => {
       },
       { a: "foo", b: "bar" },
     ),
-  ).toBeTruthy();
+  ).toBe(true);
   expect(
     filterItem(
       {
@@ -90,40 +90,84 @@ test("tests filter lists", () => {
       },
       { a: "foo", b: "bar" },
     ),
-  ).toBeTruthy();
+  ).toBe(true);
 });
 
 test("tests filter on string values", () => {
   expect(
     filterItem({ field: "a", operator: "equal", value: "foo" }, { a: "foo" }),
-  ).toBeTruthy();
+  ).toBe(true);
+  expect(
+    filterItem(
+      {
+        field: "a",
+        operator: "equal",
+        options: { sensitivity: "base" },
+        value: "FOO",
+      },
+      { a: "foo" },
+    ),
+  ).toBe(true);
   expect(
     filterItem({ field: "a", operator: "equal", value: "bar" }, { a: "foo" }),
-  ).toBeFalsy();
+  ).toBe(false);
+  expect(
+    filterItem(
+      {
+        field: "a",
+        operator: "equal",
+        options: { sensitivity: "accent" },
+        value: "föo",
+      },
+      { a: "foo" },
+    ),
+  ).toBe(false);
   expect(
     filterItem(
       { field: "a", operator: "notEqual", value: "bar" },
       { a: "foo" },
     ),
-  ).toBeTruthy();
+  ).toBe(true);
   expect(
     filterItem(
       { field: "a", operator: "include", value: "bar" },
       { a: "foobar" },
     ),
-  ).toBeTruthy();
+  ).toBe(true);
+  expect(
+    filterItem(
+      {
+        field: "a",
+        operator: "include",
+        options: { sensitivity: "base" },
+        value: "BAR",
+      },
+      { a: "foobar" },
+    ),
+  ).toBe(true);
   expect(
     filterItem(
       { field: "a", operator: "intersect", value: ["foo", "bar", "foobar"] },
       { a: "foobar" },
     ),
-  ).toBeTruthy();
+  ).toBe(true);
+  expect(
+    filterItem(
+      {
+        field: "a",
+        operator: "intersect",
+        options: { sensitivity: "base" },
+        value: ["FOO", "BAR", "FOOBAR"],
+      },
+      { a: "foobar" },
+    ),
+  ).toBe(true);
   expect(
     filterItem(
       { field: "a", operator: "intersect", value: ["foo", "bar"] },
       { a: "foobar" },
     ),
-  ).toBeFalsy();
+  ).toBe(false);
   expect(
     filterItem(
       {
@@ -134,7 +178,7 @@ test("tests filter on string values", () => {
       },
       { a: "foobar" },
     ),
-  ).toBeTruthy();
+  ).toBe(true);
   expect(
     filterItem(
       {
@@ -145,70 +189,70 @@ test("tests filter on string values", () => {
       },
       { a: "foobar" },
     ),
-  ).toBeFalsy();
+  ).toBe(false);
 });
 
 test("tests filter on number values", () => {
   expect(
     filterItem({ field: "a", operator: "equal", value: 1 }, { a: 1 }),
-  ).toBeTruthy();
+  ).toBe(true);
   expect(
     filterItem({ field: "a", operator: "notEqual", value: 2 }, { a: 1 }),
-  ).toBeTruthy();
+  ).toBe(true);
   expect(
     filterItem({ field: "a", operator: "greaterThan", value: 0 }, { a: 1 }),
-  ).toBeTruthy();
+  ).toBe(true);
   expect(
     filterItem(
       { field: "a", operator: "greaterThanOrEqual", value: 1 },
       { a: 1 },
     ),
-  ).toBeTruthy();
+  ).toBe(true);
   expect(
     filterItem({ field: "a", operator: "lowerThan", value: 2 }, { a: 1 }),
-  ).toBeTruthy();
+  ).toBe(true);
   expect(
     filterItem(
       { field: "a", operator: "lowerThanOrEqual", value: 1 },
       { a: 1 },
     ),
-  ).toBeTruthy();
+  ).toBe(true);
 });
 
 test("tests filter on array values", () => {
   expect(
     filterItem({ field: "a", operator: "equal", value: [2, 1] }, { a: [1, 2] }),
-  ).toBeTruthy();
+  ).toBe(true);
   expect(
     filterItem({ field: "a", operator: "equal", value: [2] }, { a: [1, 2] }),
-  ).toBeFalsy();
+  ).toBe(false);
   expect(
     filterItem({ field: "a", operator: "include", value: [1] }, { a: [1, 2] }),
-  ).toBeTruthy();
+  ).toBe(true);
   expect(
     filterItem(
       { field: "a", operator: "include", value: [2, 3] },
       { a: [1, 2] },
     ),
-  ).toBeFalsy();
+  ).toBe(false);
   expect(
     filterItem(
       { field: "a", operator: "intersect", value: [2, 3] },
       { a: [1, 2] },
     ),
-  ).toBeTruthy();
+  ).toBe(true);
   expect(
     filterItem(
       { field: "a", operator: "intersect", value: [3, 4] },
       { a: [1, 2] },
     ),
-  ).toBeFalsy();
+  ).toBe(false);
 });
 
 test("tests filter with children predicates", () => {
-  expect(
-    filterItem({ operator: "children", value: "a" }, { id: "a/b" }),
-  ).toBeTruthy();
+  expect(filterItem({ operator: "children", value: "a" }, { id: "a/b" })).toBe(
+    true,
+  );
   expect(
     filterItem(
       { operator: "children", value: ".a" },
@@ -218,7 +262,7 @@ test("tests filter with children predicates", () => {
         pathFieldSeparator: ".",
       },
     ),
-  ).toBeTruthy();
+  ).toBe(true);
   const filterChildren: FilterChildren<any> = {
     operator: "children",
     value: "a",
@@ -237,11 +281,11 @@ test("tests filter with children predicates", () => {
         },
       },
     ),
-  ).toBeTruthy();
+  ).toBe(true);
   expect(filterChildren[SymbolCache]).toBeDefined();
-  expect(
-    filterItem({ operator: "children", value: "b" }, { id: "a/b" }),
-  ).toBeFalsy();
+  expect(filterItem({ operator: "children", value: "b" }, { id: "a/b" })).toBe(
+    false,
+  );
   expect(
     filterItem(
       { operator: "children", value: "ba" },
@@ -251,5 +295,5 @@ test("tests filter with children predicates", () => {
         pathFieldSeparator: ".",
       },
     ),
-  ).toBeFalsy();
+  ).toBe(false);
 });

package/lib/tools/filterItem.ts

@@ -54,10 +54,44 @@ export function filterItem<T extends object>(
         }
         return filter.value.every((value) => item.includes(value));
       }
-      return value[filter.field] === filter.value;
+      const item = value[filter.field];
+      if (item === filter.value) {
+        return true;
+      }
+      if (
+        ("options" in filter && filter.options) ||
+        ("locale" in filter && filter.locale)
+      ) {
+        return (
+          item !== undefined &&
+          filter.value.localeCompare(
+            item as string,
+            filter.locale,
+            filter.options,
+          ) === 0
+        );
+      }
+      return false;
+    }
+    case "notEqual": {
+      const item = value[filter.field];
+      if (item === filter.value) {
+        return false;
+      }
+      if (
+        ("options" in filter && filter.options) ||
+        ("locale" in filter && filter.locale)
+      ) {
+        return (
+          filter.value.localeCompare(
+            value[filter.field] as string,
+            filter.locale,
+            filter.options,
+          ) !== 0
+        );
+      }
+      return true;
     }
-    case "notEqual":
-      return value[filter.field] !== filter.value;
     case "children": {
       if (filter[SymbolCache] === undefined) {
         switch (true) {
@@ -83,58 +117,179 @@ export function filterItem<T extends object>(
     case "custom": {
       return filter.value(value);
     }
-    case "startWith":
-      return (
-        (value[filter.field] as string | undefined)?.startsWith(filter.value) ??
-        false
-      );
-    case "endWith":
-      return (
-        (value[filter.field] as string | undefined)?.endsWith(filter.value) ??
-        false
-      );
+    case "startWith": {
+      const item = value[filter.field] as string | undefined;
+      if (item === undefined || item.length < filter.value.length) {
+        return false;
+      }
+      if (filter.options !== undefined || filter.locale !== undefined) {
+        return (
+          filter.value.localeCompare(
+            item.slice(0, filter.value.length),
+            filter.locale,
+            filter.options,
+          ) !== 0
+        );
+      }
+      return item.startsWith(filter.value) ?? false;
+    }
+    case "endWith": {
+      const item = value[filter.field] as string | undefined;
+      if (item === undefined || item.length < filter.value.length) {
+        return false;
+      }
+      if (filter.options !== undefined || filter.locale !== undefined) {
+        return (
+          filter.value.localeCompare(
+            item.slice(-filter.value.length),
+            filter.locale,
+            filter.options,
+          ) !== 0
+        );
+      }
+      return item.endsWith(filter.value) ?? false;
+    }
     case "include": {
-      const item = value[filter.field];
-      if (item === undefined) {
+      const item = value[filter.field] as string | any[];
+      if (item == null) {
         return false;
       }
       if (isArray(filter.value)) {
-        if (!isArray(item)) {
+        // FIXME: Get unique values
+        if (!isArray(item) || item.length < filter.value.length) {
           return false;
         }
         return filter.value.every((value) => item.includes(value));
       }
-      return (item as string).includes?.(filter.value) ?? false;
+      if (isArray(item) || item.length < filter.value.length) {
+        return false;
+      }
+      if (
+        ("options" in filter && filter.options) ||
+        ("locale" in filter && filter.locale)
+      ) {
+        const { length } = filter.value;
+        const end = item.length - length + 1;
+        for (let i = 0; i < end; i++) {
+          if (
+            filter.value.localeCompare(
+              item.slice(i, i + length),
+              filter.locale,
+              filter.options,
+            ) === 0
+          ) {
+            return true;
+          }
+        }
+        return false;
+      }
+      return item.includes?.(filter.value) ?? false;
+    }
+    case "greaterThan": {
+      const item = value[filter.field];
+      if (
+        ("options" in filter && filter.options) ||
+        ("locale" in filter && filter.locale)
+      ) {
+        return (
+          filter.value.localeCompare(
+            item as string,
+            filter.locale,
+            filter.options,
+          ) < 0
+        );
+      }
+      return item > filter.value;
+    }
+    case "greaterThanOrEqual": {
+      const item = value[filter.field];
+      if (
+        ("options" in filter && filter.options) ||
+        ("locale" in filter && filter.locale)
+      ) {
+        return (
+          filter.value.localeCompare(
+            item as string,
+            filter.locale,
+            filter.options,
+          ) <= 0
+        );
+      }
+      return item >= filter.value;
+    }
+    case "lowerThan": {
+      const item = value[filter.field];
+      if (
+        ("options" in filter && filter.options) ||
+        ("locale" in filter && filter.locale)
+      ) {
+        return (
+          filter.value.localeCompare(
+            item as string,
+            filter.locale,
+            filter.options,
+          ) > 0
+        );
+      }
+      return item < filter.value;
+    }
+    case "lowerThanOrEqual": {
+      const item = value[filter.field];
+      if (
+        ("options" in filter && filter.options) ||
+        ("locale" in filter && filter.locale)
+      ) {
+        return (
+          filter.value.localeCompare(
+            item as string,
+            filter.locale,
+            filter.options,
+          ) >= 0
+        );
+      }
+      return item <= filter.value;
     }
-    case "greaterThan":
-      return value[filter.field] > filter.value;
-    case "greaterThanOrEqual":
-      return value[filter.field] >= filter.value;
-    case "lowerThan":
-      return value[filter.field] < filter.value;
-    case "lowerThanOrEqual":
-      return value[filter.field] <= filter.value;
     case "match": {
       const item = value[filter.field] as string | undefined;
       if (item === undefined) {
         return false;
       }
       if (filter[SymbolCache] === undefined) {
-        const { options = {} } = filter;
         filter[SymbolCache] = new RegExp(
           filter.value,
-          `${options.ignoreCase ? "i" : ""}${options.dotAll ? "s" : ""}`,
+          `${filter.options?.ignoreCase ? "i" : ""}${
+            filter.options?.dotAll ? "s" : ""
+          }`,
         );
       }
       return filter[SymbolCache].test(item);
     }
     case "intersect": {
       const item = value[filter.field];
-      if (item === undefined) {
+      if (item == null) {
         return false;
       }
       if (isArray(item)) {
-        return filter.value.some((value) => item?.includes(value));
+        return (
+          isArray(filter.value) &&
+          filter.value.some((value) => item.includes(value))
+        );
+      }
+      if (
+        ("options" in filter && filter.options) ||
+        ("locale" in filter && filter.locale)
+      ) {
+        return (
+          item !== undefined &&
+          filter.value.some(
+            (value) =>
+              value.localeCompare(
+                item as string,
+                filter.locale,
+                filter.options,
+              ) === 0,
+          )
+        );
       }
       return filter.value.includes(item as string);
     }

package/lib/types/FilterString.ts

@@ -1,4 +1,5 @@
 import type { FilterKeys } from "./FilterKeys";
+import type { Locale } from "./Locale";
 
 /**
  * Checks if a given string field matches a given string value according to a given operator.
@@ -16,4 +17,6 @@ export type FilterString<T extends object> = {
     | "lowerThanOrEqual";
   field: FilterKeys<T, string>;
   value: string;
+  options?: Intl.CollatorOptions;
+  locale?: Locale;
 };

package/lib/types/FilterStringIntersect.ts

@@ -1,4 +1,5 @@
 import type { FilterKeys } from "./FilterKeys";
+import type { Locale } from "./Locale";
 
 /**
  * Checks if a given string field has any of the provided values.
@@ -7,4 +8,6 @@ export type FilterStringIntersect<T extends object> = {
   operator: "intersect";
   field: FilterKeys<T, string>;
   value: string[];
+  options?: Intl.CollatorOptions;
+  locale?: Locale;
 };

package/lib/types/FilterStringMatch.ts

@@ -17,11 +17,11 @@ export type FilterStringMatch<T extends object> = {
    */
   options?: {
     /**
-     * When matching, casing differences are ignored.
+     * Ignore casing differences if `true`.
      */
     ignoreCase?: boolean;
     /**
-     * Allows . to match newlines.
+     * Allow `.` to match newlines.
      */
     dotAll?: boolean;
   };

package/lib/types/Locale.ts

@@ -0,0 +1 @@
+export type Locale = string | string[];

package/lib/types/QuerySettings.ts

@@ -27,4 +27,8 @@ export type QuerySettings<T extends object> = {
    * Abort signal to abort the query.
    */
   signal?: AbortSignal;
+  /**
+   * Abort controller to abort the query.
+   */
+  abortController?: AbortController;
 };

package/lib/types.ts

@@ -30,6 +30,7 @@ export type { Immutable } from "./types/Immutable";
 export type { InjectCustomFields } from "./types/InjectCustomFields";
 export type { Item } from "./types/Item";
 export type { Key } from "./types/Key";
+export type { Locale } from "./types/Locale";
 export type { Mutable } from "./types/Mutable";
 export type { NextHandler } from "./types/NextHandler";
 export type { Order } from "./types/Order";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quetch",
-  "version": "0.11.2",
+  "version": "0.13.0",
   "type": "module",
   "main": "./dist/main.js",
   "exports": {