@effect-app/infra 2.16.6 → 2.16.7

package/src/Model/filter/types/path/eager.ts

@@ -1,5 +1,7 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { expectTypeOf } from "@effect/vitest"
 import type { FieldValues } from "../fields.js"
-import type { BrowserNativeObject, Primitive } from "../utils.js"
+import type { BrowserNativeObject, Equals, IsLiteral, IsNever, Primitive } from "../utils.js"
 
 import type { ArrayKey, IsTuple, TupleKeys } from "./common.js"
 
@@ -33,39 +35,6 @@ export type Path<T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true
  */
 export type FieldPath<TFieldValues extends FieldValues> = Path<TFieldValues>
 
-/**
- * Helper type for recursively constructing paths through a type.
- * See {@link ArrayPath}
- */
-type ArrayPathImpl<K extends string | number, V> = V extends
-  | Primitive
-  | BrowserNativeObject ? never
-  : V extends ReadonlyArray<infer U> ? U extends Primitive | BrowserNativeObject ? never
-    : `${K}` | `${K}.${ArrayPath<V>}`
-  : `${K}.${ArrayPath<V>}`
-
-/**
- * Type which eagerly collects all paths through a type which point to an array
- * type.
- * @typeParam T - type which should be introspected
- * @example
- * ```
- * Path<{foo: {bar: string[], baz: number[]}}> = 'foo.bar' | 'foo.baz'
- * ```
- */
-export type ArrayPath<T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
-      [K in TupleKeys<T>]-?: ArrayPathImpl<K & string, T[K]>
-    }[TupleKeys<T>]
-  : ArrayPathImpl<ArrayKey, V>
-  : {
-    [K in keyof T]-?: ArrayPathImpl<K & string, T[K]>
-  }[keyof T]
-
-/**
- * See {@link ArrayPath}
- */
-export type FieldArrayPath<TFieldValues extends FieldValues> = ArrayPath<TFieldValues>
-
 /**
  * Type to evaluate the type which the given path points to.
  * @typeParam T - deeply nested type which is indexed by the path
@@ -76,17 +45,28 @@ export type FieldArrayPath<TFieldValues extends FieldValues> = ArrayPath<TFieldV
  * PathValue<[number, string], '1'> = string
  * ```
  */
-export type PathValue<T, P extends Path<T> | ArrayPath<T>> = T extends any
-  ? P extends `${infer K}.${infer R}` ? K extends keyof T ? R extends Path<T[K]> ? PathValue<T[K], R>
-      : never
-    : K extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? PathValue<V, R & Path<V>>
-      : never
-    : never
-  : P extends keyof T ? T[P]
-  : P extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? V
+/* dprint-ignore-start */
+export type PathValue<T, P extends Path<T>> =
+  T extends any
+    ? P extends `${infer K}.${infer R}`
+      ? K extends keyof T
+        ? R extends Path<T[K]>
+          ? PathValue<T[K], R>
+          : never
+        : K extends `${ArrayKey}`
+          ? T extends ReadonlyArray<infer V>
+            ? PathValue<V, R & Path<V>>
+            : never
+          : never
+      : P extends keyof T
+        ? T[P]
+        : P extends `${ArrayKey}`
+          ? T extends ReadonlyArray<infer V>
+            ? V
+            : never
+          : never
     : never
-  : never
-  : never
+/* dprint-ignore-end */
 
 /**
  * See {@link PathValue}
@@ -96,13 +76,165 @@ export type FieldPathValue<
   TFieldPath extends FieldPath<TFieldValues>
 > = PathValue<TFieldValues, TFieldPath>
 
-/**
- * See {@link PathValue}
- */
-export type FieldArrayPathValue<
+/* dprint-ignore-start */
+export type SetPathValue<T, P extends Path<T>, X> =
+  T extends any
+    ? P extends `${infer K}.${infer R}`
+      ? K extends keyof T
+        ? R extends Path<T[K]>
+          ? { [_ in keyof T]: _ extends K ? SetPathValue<T[K], R, X> : T[_] }
+          : never
+        : K extends `${ArrayKey}`
+          ? T extends ReadonlyArray<infer V>
+            ? { [_ in keyof T]: SetPathValue<V, R & Path<V>, X> }
+            : never
+          : never
+      : P extends keyof T
+        ? { [_ in keyof T]: _ extends P ? X : T[_] }
+        : P extends `${ArrayKey}`
+          ? T extends ReadonlyArray<any>
+            ? { [_ in keyof T]: X }
+            : never
+          : never
+    : never
+/* dprint-ignore-end */
+
+export type SetFieldPathValue<
   TFieldValues extends FieldValues,
-  TFieldArrayPath extends FieldArrayPath<TFieldValues>
-> = PathValue<TFieldValues, TFieldArrayPath>
+  TFieldPath extends FieldPath<TFieldValues>,
+  X
+> = SetPathValue<TFieldValues, TFieldPath, X>
+
+/* dprint-ignore-start */
+export type RefinePathValue<T, P extends Path<T>, X extends string | number | boolean | null | bigint, Exclde extends boolean = false> =
+  T extends any
+    // recursive cases
+    ? P extends `${infer K}.${infer R}`
+      ? K extends keyof T
+        ? R extends Path<T[K]>
+          ? { [_ in keyof T]: _ extends K ? RefinePathValue<T[K], R, X, Exclde> : T[_] }
+          : never
+        : K extends `${ArrayKey}`
+          ? T extends ReadonlyArray<infer V>
+            ? { [_ in keyof T]: RefinePathValue<V, R & Path<V>, X, Exclde> }
+            : never
+          : never
+      // base cases
+      : P extends keyof T
+        ? X extends T[P]
+          ? ({ [_ in keyof T]: _ extends P
+              ? Equals<
+                  Exclde,
+                  true,
+                  Exclude<T[_], X>,
+                  IsLiteral<T[_], X, Equals<X, null, null, NonNullable<T[_]>>>
+                >
+              : T[_]
+            }) extends infer $T
+              ? Equals<IsNever<$T[P & keyof $T]>, true, never, $T>
+              : never
+          : Equals<Exclde, true, T, never>
+        : P extends `${ArrayKey}`
+          ? T extends ReadonlyArray<infer V>
+            ? X extends V
+              ? { [_ in keyof T]: Equals<
+                  Exclde,
+                  true,
+                  Exclude<T[_], X>,
+                  IsLiteral<T[_], X, Equals<X, null, null, NonNullable<T[_]>>>
+                > }
+              : never
+            : never
+          : never
+    : never
+/* dprint-ignore-end */
+
+export type RefineFieldPathValue<
+  TFieldValues extends FieldValues,
+  TFieldPath extends FieldPath<TFieldValues>,
+  X extends string | number | boolean | null | bigint,
+  Exclde extends boolean = false
+> = RefinePathValue<TFieldValues, TFieldPath, X, Exclde>
+
+export namespace RefinePathValueTests {
+  type test1 = RefineFieldPathValue<{ a: { b: "tag1"; v1: string } | { b: "tag2"; v2: number } }, "a.b", "tag1">
+  expectTypeOf<test1>().toEqualTypeOf<{ a: { b: "tag1"; v1: string } }>()
+
+  type test2 = RefineFieldPathValue<{ b: "tag1"; v1: string } | { b: "tag2"; v2: number }, "b", "tag1">
+  expectTypeOf<test2>().toEqualTypeOf<{ b: "tag1"; v1: string }>()
+
+  type test3 = RefineFieldPathValue<{ b: "tag1" | "tag2" }, "b", "tag1">
+  expectTypeOf<test3>().toEqualTypeOf<{ b: "tag1" }>()
+
+  type test4 = RefineFieldPathValue<{ b: ("tag1" | "tag2")[] }, `b.${number}`, "tag1">
+  expectTypeOf<test4>().toEqualTypeOf<{ b: "tag1"[] }>()
+
+  type test5 = RefineFieldPathValue<{ b: "tag1"; v1: unknown } | { b: "tag2"; v2: unknown }, "b", "tag1">
+  expectTypeOf<test5>().toEqualTypeOf<{ b: "tag1"; v1: unknown }>()
+
+  type test6 = RefineFieldPathValue<
+    { a: { b: "tag1"; v1: string } | { b: "tag2"; v2: number } } | { something: "else " },
+    "a.b",
+    "tag2"
+  >
+  expectTypeOf<test6>().toEqualTypeOf<{ a: { b: "tag2"; v2: number } }>()
+
+  type test7 = RefineFieldPathValue<{ b: string | null }, "b", "tag1">
+  expectTypeOf<test7>().toEqualTypeOf<{ b: string }>()
+
+  type test8 = RefineFieldPathValue<{ b: string | null }, "b", null>
+  expectTypeOf<test8>().toEqualTypeOf<{ b: null }>()
+
+  type test1E = RefineFieldPathValue<{ a: { b: "tag1"; v1: string } | { b: "tag2"; v2: number } }, "a.b", "tag1", true>
+  expectTypeOf<test1E>().toEqualTypeOf<{ a: { b: "tag2"; v2: number } }>()
+
+  type test2E = RefineFieldPathValue<{ b: "tag1"; v1: string } | { b: "tag2"; v2: number }, "b", "tag2", true>
+  expectTypeOf<test2E>().toEqualTypeOf<{ b: "tag1"; v1: string }>()
+
+  type test3E = RefineFieldPathValue<{ b: "tag1" | "tag2" | null }, "b", null, true>
+  expectTypeOf<test3E>().toEqualTypeOf<{ b: "tag1" | "tag2" }>()
+
+  type test4E = RefineFieldPathValue<{ b: ("tag1" | "tag2")[] }, `b.${number}`, "tag1", true>
+  expectTypeOf<test4E>().toEqualTypeOf<{ b: "tag2"[] }>()
+
+  type test5E = RefineFieldPathValue<{ b: "tag1"; v1: unknown } | { b: "tag2"; v2: unknown }, "b", "tag1", true>
+  expectTypeOf<test5E>().toEqualTypeOf<{ b: "tag2"; v2: unknown }>()
+
+  type test6E = RefineFieldPathValue<
+    { a: { b: "tag1"; v1: string } | { b: "tag2"; v2: number } } | { something: "else " },
+    "a.b",
+    "tag2",
+    true
+  >
+  expectTypeOf<test6E>().toEqualTypeOf<{ a: { b: "tag1"; v1: string } }>()
+}
+
+export namespace SetFieldPathValueTests {
+  type test1 = SetFieldPathValue<{ foo: { bar: string[] } }, `foo.bar`, boolean>
+  expectTypeOf<test1>().toEqualTypeOf<{ foo: { bar: boolean } }>()
+
+  type test1a = SetFieldPathValue<{ foo: { bar: string[]; baz: 12 } }, `foo.bar`, boolean>
+  expectTypeOf<test1a>().toEqualTypeOf<{ foo: { bar: boolean; baz: 12 } }>()
+
+  type test2 = SetFieldPathValue<{ foo: { bar: string[] } }, `foo.bar.${number}`, boolean>
+  expectTypeOf<test2>().toEqualTypeOf<{ foo: { bar: boolean[] } }>()
+
+  type test2a = SetFieldPathValue<{ foo: { bar: readonly string[]; baz: 3 }; ban: 123 }, `foo.bar.${number}`, boolean>
+  expectTypeOf<test2a>().toEqualTypeOf<{ foo: { bar: readonly boolean[]; baz: 3 }; ban: 123 }>()
+
+  type test2b = SetFieldPathValue<
+    { foo: { bar: readonly { a: 1; b: 2 }[]; baz: 3 }; ban: 123 },
+    `foo.bar.${number}.b`,
+    "b"
+  >
+  expectTypeOf<test2b>().toEqualTypeOf<{ foo: { bar: readonly { a: 1; b: "b" }[]; baz: 3 }; ban: 123 }>()
+
+  type test3 = SetFieldPathValue<{ foo: ["a", "b"] }, `foo.0`, boolean>
+  expectTypeOf<test3>().toEqualTypeOf<{ foo: [boolean, "b"] }>()
+
+  type test3a = SetFieldPathValue<{ foo: [{ a: 123 }, "b"] }, `foo.0.a`, boolean>
+  expectTypeOf<test3a>().toEqualTypeOf<{ foo: [{ a: boolean }, "b"] }>()
+}
 
 /**
  * Type to evaluate the type which the given paths point to.

package/src/Model/filter/types/path/index.ts

@@ -1,14 +1,4 @@
 /** Re-export public API */
 
 export type { PathString } from "./common.js"
-export type {
-  ArrayPath,
-  FieldArrayPath,
-  FieldArrayPathValue,
-  FieldPath,
-  FieldPathByValue,
-  FieldPathValue,
-  FieldPathValues,
-  Path,
-  PathValue
-} from "./eager.js"
+export type { FieldPath, FieldPathByValue, FieldPathValue, FieldPathValues, Path, PathValue } from "./eager.js"

package/src/Model/filter/types/utils.ts

@@ -104,3 +104,25 @@ export type Merge<A, B> = {
     : K extends keyof B ? B[K]
     : never
 }
+
+export type Resolve<T> =
+  & {
+    [K in keyof T]: Resolve<T[K]>
+  }
+  & unknown
+
+export type ResolveFirstLevel<T> =
+  & {
+    [K in keyof T]: T[K]
+  }
+  & unknown
+
+export type Cast<T, U> = T extends U ? T : U
+
+export type IsLiteral<T, True, False> = string extends T ? False : number extends T ? False : True
+
+export type Extends<T, U, True, False> = T extends U ? True : False
+
+export type IsEqual<T, U> = (<_>() => _ extends T ? 1 : 2) extends (<_>() => _ extends U ? 1 : 2) ? true : false
+
+export type Equals<T, U, True, False> = IsEqual<T, U> extends true ? True : False