quetch 0.19.5 → 0.21.0

package/lib/tools/testFilter.ts

@@ -1,3 +1,5 @@
+import { EMPTY_OBJECT } from "unchangeable";
+
 import { CACHE } from "../constants/CACHE.js";
 import type { QuerySettings } from "../types/QuerySettings.js";
 import type { FieldFiltered, Filter, FilterString } from "../types.js";
@@ -103,7 +105,9 @@ export function testFilter<T>(
       }
       return true;
     }
-    case "children": {
+    case "children":
+    case "notChildren": {
+      const not = filter.operator[0] === "n";
       if (filter[CACHE] === undefined) {
         switch (true) {
           case settings?.transformFilterChildren !== undefined:
@@ -111,72 +115,83 @@ export function testFilter<T>(
             break;
           default: {
             const {
-              pathFieldKey = "id" as FieldFiltered<T, string>,
-              pathFieldSeparator = "/",
-            } = settings || {};
+              pathField = "id" as FieldFiltered<T, string>,
+              pathFieldSeparator,
+            } = settings || (EMPTY_OBJECT as QuerySettings<T>);
             filter[CACHE] = filterChildren(
               filter.value as string,
-              pathFieldKey,
+              pathField,
               filter.deep,
               pathFieldSeparator,
             );
           }
         }
       }
-      return testFilter(filter[CACHE], value);
+      return negate(testFilter(filter[CACHE], value), not);
     }
     case "custom": {
       return filter.value(value);
     }
-    case "startWith": {
+    case "startWith":
+    case "notStartWith": {
+      const not = filter.operator[0] === "n";
       const rightValue = valueFromFilter(value, filter);
       const leftValue = get<T, any>(value, filter.field) as string | undefined;
       if (leftValue === undefined || leftValue.length < rightValue.length) {
-        return false;
+        return negate(false, not);
       }
       if (filter.options !== undefined || filter.locale !== undefined) {
-        return (
+        return negate(
           rightValue.localeCompare(
             leftValue.slice(0, rightValue.length),
             filter.locale,
             filter.options,
-          ) === 0
+          ) === 0,
+          not,
         );
       }
-      return leftValue.startsWith(rightValue) ?? false;
+      return negate(leftValue.startsWith(rightValue) ?? false, not);
     }
-    case "endWith": {
+    case "endWith":
+    case "notEndWith": {
+      const not = filter.operator[0] === "n";
       const rightValue = valueFromFilter(value, filter);
       const leftValue = get<T, any>(value, filter.field) as string | undefined;
       if (leftValue === undefined || leftValue.length < rightValue.length) {
-        return false;
+        return negate(false, not);
       }
       if (filter.options !== undefined || filter.locale !== undefined) {
-        return (
+        return negate(
           rightValue.localeCompare(
             leftValue.slice(-rightValue.length),
             filter.locale,
             filter.options,
-          ) === 0
+          ) === 0,
+          not,
         );
       }
-      return leftValue.endsWith(rightValue) ?? false;
+      return negate(leftValue.endsWith(rightValue) ?? false, not);
     }
-    case "include": {
+    case "include":
+    case "notInclude": {
+      const not = filter.operator[0] === "n";
       const rightValue = valueFromFilter(value, filter);
       const leftValue = get<T, any>(value, filter.field) as string | any[];
       if (leftValue == null) {
-        return false;
+        return negate(false, not);
       }
       if (isArray(rightValue)) {
         // FIXME: Get unique values
         if (!isArray(leftValue) || leftValue.length < rightValue.length) {
-          return false;
+          return negate(false, not);
         }
-        return rightValue.every((value) => leftValue.includes(value));
+        return negate(
+          rightValue.every((value) => leftValue.includes(value)),
+          not,
+        );
       }
       if (isArray(leftValue) || leftValue.length < rightValue.length) {
-        return false;
+        return negate(false, not);
       }
       if (
         (filter as FilterString<T>).options ||
@@ -192,12 +207,12 @@ export function testFilter<T>(
               (filter as FilterString<T>).options,
             ) === 0
           ) {
-            return true;
+            return negate(true, not);
           }
         }
-        return false;
+        return negate(false, not);
       }
-      return leftValue.includes?.(rightValue) ?? false;
+      return negate(leftValue.includes?.(rightValue) ?? false, not);
     }
     case "greaterThan": {
       const rightValue = valueFromFilter(value, filter);
@@ -267,11 +282,13 @@ export function testFilter<T>(
       }
       return leftValue <= rightValue;
     }
-    case "match": {
+    case "match":
+    case "notMatch": {
+      const not = filter.operator[0] === "n";
       const rightValue = valueFromFilter(value, filter);
       const leftValue = get<T, any>(value, filter.field) as string | undefined;
       if (leftValue === undefined) {
-        return false;
+        return negate(false, not);
       }
       if (filter[CACHE] === undefined) {
         filter[CACHE] = new RegExp(
@@ -281,39 +298,47 @@ export function testFilter<T>(
           }`,
         );
       }
-      return filter[CACHE].test(leftValue);
+      return negate(filter[CACHE].test(leftValue), not);
     }
-    case "intersect": {
+    case "intersect":
+    case "notIntersect": {
+      const not = filter.operator[0] === "n";
       const rightValue = valueFromFilter(value, filter);
       const leftValue = get<T, any>(value, filter.field);
       if (leftValue == null) {
-        return false;
+        return negate(false, not);
       }
       if (isArray(leftValue)) {
-        return (
+        return negate(
           isArray(rightValue) &&
-          rightValue.some((value) => leftValue.includes(value))
+            rightValue.some((value) => leftValue.includes(value)),
+          not,
         );
       }
       if (
         (filter as FilterString<T>).options ||
         (filter as FilterString<T>).locale
       ) {
-        return (
+        return negate(
           leftValue !== undefined &&
-          (rightValue as string[]).some(
-            (value) =>
-              value.localeCompare(
-                leftValue as string,
-                (filter as FilterString<T>).locale,
-                (filter as FilterString<T>).options,
-              ) === 0,
-          )
+            (rightValue as string[]).some(
+              (value) =>
+                value.localeCompare(
+                  leftValue as string,
+                  (filter as FilterString<T>).locale,
+                  (filter as FilterString<T>).options,
+                ) === 0,
+            ),
+          not,
         );
       }
-      return rightValue.includes(leftValue as string);
+      return negate(rightValue.includes(leftValue as string), not);
     }
     default:
       throw new Error(`Unknown filter operator '${(filter as any).operator}'`);
   }
 }
+
+function negate(value: boolean, condition: boolean) {
+  return condition ? !value : value;
+}

package/lib/tools.ts

@@ -12,5 +12,6 @@ export { isFilterGroup } from "./tools/isFilterGroup.js";
 export { normalizeOrder } from "./tools/normalizeOrder.js";
 export { queryItemList } from "./tools/queryItemList.js";
 export { reverseOrder } from "./tools/reverseOrder.js";
+export { sameField } from "./tools/sameField.js";
 export { sortItemList } from "./tools/sortItemList.js";
 export { testFilter } from "./tools/testFilter.js";

package/lib/types/Field.ts

@@ -1,9 +1,7 @@
-import type { SELF } from "../constants/SELF.js";
-
 import type { CombineUnion } from "./CombineUnion";
+import type { FieldKey } from "./FieldKey.js";
 import type { Path } from "./Path";
-import type { Primitive } from "./Primitive";
 
 export type Field<T> = KeyOrPath<CombineUnion<T>>;
 
-type KeyOrPath<T> = (T extends Primitive ? typeof SELF : keyof T) | Path<T>;
+type KeyOrPath<T> = FieldKey<T> | Path<T>;

package/lib/types/FieldKey.ts

@@ -0,0 +1,5 @@
+import type { SELF } from "../constants/SELF.ts";
+
+import type { Primitive } from "./Primitive";
+
+export type FieldKey<T> = T extends Primitive ? typeof SELF : keyof T;

package/lib/types/FieldMap.ts

@@ -0,0 +1,6 @@
+import type { Field } from "./Field";
+
+/**
+ * Maps the fields of the provided value `T` to a specific value `V`.
+ */
+export type FieldMap<T, V> = readonly [Field<T>, V][];

package/lib/types/FilterArray.ts

@@ -9,6 +9,12 @@ import type { Value } from "./Value";
  * - `intersect` requires at least one item of the value to be present in the array.
  */
 export type FilterArray<T, P = any> = {
-  operator: "equal" | "include" | "intersect";
+  operator:
+    | "equal"
+    | "include"
+    | "intersect"
+    | "notEqual"
+    | "notInclude"
+    | "notIntersect";
   field: FieldFiltered<T, P[]>;
 } & Value<T, P[]>;

package/lib/types/FilterChildren.ts

@@ -8,7 +8,7 @@ import type { Filter } from "./Filter";
  * If `deep` is `true`, also captures all the descendants.
  */
 export type FilterChildren<T> = {
-  operator: "children";
+  operator: "children" | "notChildren";
   value?: Context<T> | string;
   deep?: boolean;
   [CACHE]?: Filter<T>;

package/lib/types/FilterField.ts

@@ -4,7 +4,7 @@ import type { Field } from "./Field";
  * Checks if a given field exists.
  */
 export type FilterField<T> = {
-  operator: "exist";
+  operator: "exist" | "notExist";
   /**
    * The field name or path for which to check its existence.
    */

package/lib/types/FilterNumber.ts

@@ -11,6 +11,10 @@ export type FilterNumber<T> = {
     | "greaterThan"
     | "greaterThanOrEqual"
     | "lowerThan"
-    | "lowerThanOrEqual";
+    | "lowerThanOrEqual"
+    | "between"
+    | "notBetween"
+    | "betweenOrEqual"
+    | "notBetweenOrEqual";
   field: FieldFiltered<T, number>;
 } & Value<T, number>;

package/lib/types/FilterString.ts

@@ -11,12 +11,18 @@ export type FilterString<T> = {
     // FIXME: Redundant with `"not"` operator
     | "notEqual"
     | "startWith"
+    | "notStartWith"
     | "endWith"
+    | "notEndWith"
     | "include"
     | "greaterThan"
     | "greaterThanOrEqual"
     | "lowerThan"
-    | "lowerThanOrEqual";
+    | "lowerThanOrEqual"
+    | "between"
+    | "notBetween"
+    | "betweenOrEqual"
+    | "notBetweenOrEqual";
   field: FieldFiltered<T, string>;
   options?: Intl.CollatorOptions;
   locale?: Locale;

package/lib/types/FilterStringIntersect.ts

@@ -6,7 +6,7 @@ import type { Value } from "./Value";
  * Checks if a given string field has any of the provided values.
  */
 export type FilterStringIntersect<T> = {
-  operator: "intersect";
+  operator: "intersect" | "notIntersect";
   field: FieldFiltered<T, string>;
   options?: Intl.CollatorOptions;
   locale?: Locale;

package/lib/types/FilterStringMatch.ts

@@ -7,7 +7,7 @@ import type { Value } from "./Value";
  * Checks if a given string field matches a given regular expression, the value being a raw regular expression string.
  */
 export type FilterStringMatch<T> = {
-  operator: "match";
+  operator: "match" | "notMatch";
   field: FieldFiltered<T, string>;
   /**
    * Regular expression options.

package/lib/types/QuerySettings.ts

@@ -6,15 +6,20 @@ import type { FilterChildren } from "./FilterChildren";
  * Settings to use when doing a query.
  */
 export type QuerySettings<T> = {
-  // TODO: Move `path*` and `transform*` to fetch middleware?
   /**
-   * String used to separate the path nodes of an item.
+   * Path to the field that contains the path value of an item, used for displaying items in a tree.
    */
-  pathFieldSeparator?: string;
+  pathField?: FieldFiltered<T, string>;
   /**
-   * Field key to that contains the path value of an item.
+   * String used to escape the separator.
+   *
+   * @default "\\"
    */
-  pathFieldKey?: FieldFiltered<T, string>;
+  pathFieldSeparatorEscape?: string;
+  /**
+   * Maps path fields to a string used to separate the path nodes of a field value.
+   */
+  pathFieldSeparator?: string;
   /**
    * Returns a filter that captures the items expressed by the provided `FilterChildren`. The return filter cannot use filters of type `FilterChildren`.
    *

package/lib/types/ValueMap.ts

@@ -0,0 +1,14 @@
+import type { Primitive } from "./Primitive";
+
+/**
+ * Maps the properties of the provided value `T` to a specific value `V`.
+ */
+export type ValueMap<T, V> = T extends Primitive
+  ? V
+  : T extends Array<infer P>
+    ? Record<number, ValueMap<P, V>>
+    : T extends object
+      ? {
+          [K in keyof T]?: ValueMap<T[K], V>;
+        }
+      : never;

package/lib/types.ts

@@ -12,6 +12,8 @@ export type { FieldFunction } from "./types/FieldFunction";
 export type { FieldFunctionCustom } from "./types/FieldFunctionCustom";
 export type { FieldFunctionFormatDate } from "./types/FieldFunctionFormatDate";
 export type { FieldFunctionReturn } from "./types/FieldFunctionReturn";
+export type { FieldKey } from "./types/FieldKey";
+export type { FieldMap } from "./types/FieldMap";
 export type { Filter } from "./types/Filter";
 export type { FilterArray } from "./types/FilterArray";
 export type { FilterBoolean } from "./types/FilterBoolean";
@@ -60,3 +62,4 @@ export type { QueryUpdateMultiple } from "./types/QueryUpdateMultiple";
 export type { Result } from "./types/Result";
 export type { Store } from "./types/Store";
 export type { Value } from "./types/Value";
+export type { ValueMap } from "./types/ValueMap";

package/package.json

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