quetch 0.33.0 → 0.33.2

package/lib/tools/comparatorFieldValues.ts

@@ -19,6 +19,7 @@ export function comparatorFieldValues<T>({
   pathField = "path" as FieldFiltered<T, string>,
   pathFieldSeparator = "/",
   pathFieldSeparatorEscape = "\\",
+  collator,
 }: NormalizedPathFieldSettings<T> = EMPTY_OBJECT): QuerySettings<T>["compareFieldValues"] {
   const fieldSeparatorRegexp = new RegExp(
     !pathFieldSeparatorEscape
@@ -45,9 +46,30 @@ export function comparatorFieldValues<T>({
       fieldSeparatorRegexp,
       "\x00",
     );
-    if (normalizedA > normalizedB) {
+    if (collator) {
+      const comparison = collator.compare(normalizedA, normalizedB);
+      return descending
+        ? comparison > 0
+          ? -1
+          : comparison < 0
+            ? 1
+            : 0
+        : comparison > 0
+          ? 1
+          : comparison < 0
+            ? -1
+            : 0;
+    }
+    const comparison = normalizedA.localeCompare(normalizedB, undefined, {
+      numeric: true,
+    });
+    const comparisonNormalized = comparison > 0 ? 1 : comparison < 0 ? -1 : 0;
+    if (comparisonNormalized > 0) {
       return descending ? -1 : 1;
     }
-    return descending ? 1 : -1;
+    if (comparisonNormalized < 0) {
+      return descending ? 1 : -1;
+    }
+    return 0;
   };
 }

package/lib/types/CombineUnion.ts

@@ -7,7 +7,7 @@ export type CombineUnion<U> = [unknown] extends [U]
     ? any
     : [U] extends [Function | readonly Function[]]
       ? undefined
-      : [U] extends [Primitive]
+      : [U] extends [Primitive | undefined]
         ? U
         : [U] extends readonly [Array<any>]
           ? U

package/lib/types/Context.ts

@@ -10,10 +10,14 @@ import type { Primitive } from "./Primitive.js";
  *
  * It can be a partial object of the type `T` or a primitive value wrapped in an object with the `SELF` key.
  */
-export type Context<T> = [0] extends [1 & T]
+export type Context<T> = [unknown] extends [T]
   ? any
-  : T extends Primitive
-    ? { [SELF]: T }
-    : {
-        [K in keyof T]?: T[K];
-      };
+  : [0] extends [1 & T]
+    ? any
+    : T extends Primitive
+      ? { [SELF]: T }
+      : T extends undefined
+        ? never
+        : {
+            [K in keyof T]?: T[K];
+          };

package/lib/types/FieldFiltered.ts

@@ -2,6 +2,9 @@ import type { CombineUnion } from "./CombineUnion";
 import type { KeyFiltered } from "./KeyFiltered";
 import type { PathFiltered } from "./PathFiltered";
 
+/**
+ * Returns union of keys and paths whose mapped value extend the provided `P` type.
+ */
 export type FieldFiltered<T, P> = KeyOrPathFiltered<CombineUnion<T>, P>;
 
 type KeyOrPathFiltered<T, P> = KeyFiltered<T, P> | PathFiltered<T, P>;

package/lib/types/FieldKey.ts

@@ -3,8 +3,11 @@ import type { SELF } from "../constants/SELF.ts";
 import type { Key } from "./Key.ts";
 import type { Primitive } from "./Primitive";
 
+/**
+ * Returns the type of keys that can be used to select fields from a value of type `T`.
+ */
 export type FieldKey<T> = [unknown] extends [T]
   ? Key
-  : T extends Primitive
+  : T extends Primitive | undefined
     ? typeof SELF
     : keyof T;

package/lib/types/NormalizedPathFieldSettings.ts

@@ -22,4 +22,8 @@ export type NormalizedPathFieldSettings<T> = {
    * @default "/"
    */
   pathFieldSeparator?: string;
+  /**
+   * Collator used for string comparison.
+   */
+  collator?: Intl.Collator;
 };

package/lib/types/Path.ts

@@ -3,13 +3,16 @@ import type { DepthLimit } from "./DepthLimit";
 import type { Key } from "./Key";
 import type { Primitive } from "./Primitive";
 
+/**
+ * Returns the type of paths that can be used to select fields from a value of type `T`, with an optional depth limit `D`.
+ */
 export type Path<T, D = DepthLimit> = [unknown] extends [T]
   ? readonly (Key | never)[]
   : [0] extends [1 & T]
     ? readonly (Key | never)[]
     : D extends -1
       ? never
-      : T extends Primitive
+      : T extends Primitive | undefined
         ? readonly never[]
         : T extends Array<infer P>
           ? readonly [number] | readonly [number, ...Path<P, Decrement<D>>]

package/lib/types/PathFiltered.ts

@@ -2,6 +2,9 @@ import type { Decrement } from "./Decrement";
 import type { DepthLimit } from "./DepthLimit";
 import type { Key } from "./Key";
 
+/**
+ * Returns the type of paths that can be used to select fields from a value of type `T` whose mapped value extend the provided `P` type, with an optional depth limit `D`.
+ */
 export type PathFiltered<T, P, D = DepthLimit> = [unknown] extends [T]
   ? readonly (Key | never)[]
   : [0] extends [1 & T]

package/lib/types/Primitive.ts

@@ -1 +1,4 @@
+/**
+ * Defined primitive types.
+ */
 export type Primitive = string | number | boolean | bigint | symbol;

package/lib/types/Result.ts

@@ -8,37 +8,39 @@ import type { QueryRead } from "./QueryRead";
 import type { QueryReadMultiple } from "./QueryReadMultiple";
 
 /**
- * Picks fields `F` from object `T`.
+ * Picks fields `F` from value `T`.
  */
 type PickFields<T, F extends readonly Field<T>[]> = [unknown] extends [T]
   ? T
   : T extends Primitive
     ? T
-    : [F] extends [readonly [infer J, ...infer R]]
-      ? Merge<
-          | // J is a single key
-          ([J] extends [keyof T]
-              ? PickField<T, J, T[J]>
-              : // J is a path
-                [J] extends [readonly [infer K, ...infer S]]
-                ? [K] extends [keyof T]
-                  ? PickField<
-                      T,
-                      K,
-                      PickFields<
-                        T[K],
-                        S extends readonly Field<T[K]>[] ? S : never
+    : T extends undefined
+      ? never
+      : [F] extends [readonly [infer J, ...infer R]]
+        ? Merge<
+            | // J is a single key
+            ([J] extends [keyof T]
+                ? PickField<T, J, T[J]>
+                : // J is a path
+                  [J] extends [readonly [infer K, ...infer S]]
+                  ? [K] extends [keyof T]
+                    ? PickField<
+                        T,
+                        K,
+                        PickFields<
+                          T[K],
+                          S extends readonly Field<T[K]>[] ? S : never
+                        >
                       >
-                    >
-                  : never
-                : never)
-          | (R extends readonly never[]
-              ? never
-              : R extends readonly Field<T>[]
-                ? PickFields<T, R>
-                : never)
-        >
-      : never;
+                    : never
+                  : never)
+            | (R extends readonly never[]
+                ? never
+                : R extends readonly Field<T>[]
+                  ? PickFields<T, R>
+                  : never)
+          >
+        : never;
 
 type Merge<T> = Prettify<IntersectUnion<T>>;
 

package/package.json

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