effect-app 4.0.0-beta.27 → 4.0.0-beta.272

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

@@ -0,0 +1,329 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { expectTypeOf } from "@effect/vitest"
+import type { FieldValues } from "../fields.ts"
+import type { BrowserNativeObject, Equals, IsLiteral, IsNever, Primitive } from "../utils.ts"
+
+import type { ArrayKey, IsTuple, TupleKeys } from "./common.ts"
+
+/**
+ * Helper type for recursively constructing paths through a type.
+ * `Seen` carries the set of object types already entered on this branch so
+ * recursion terminates on self-referential types (see {@link Path}).
+ */
+type PathImpl<K extends string | number, V, Seen> = V extends
+  | Primitive
+  | BrowserNativeObject ? `${K}`
+  // Stop before re-entering a type already on this branch. Recursive types
+  // (notably `Json`, the encoded form of `Schema.Defect()`:
+  // `JsonObject = { [x: string]: Json }`) would otherwise descend forever and
+  // blow past TS's instantiation limit => TS2589. The key itself stays a valid
+  // leaf path; only the unbounded descent is cut.
+  : [V] extends [Seen] ? `${K}`
+  : `${K}` | `${K}.${Path<V, Seen | V>}`
+
+/**
+ * Type which eagerly collects all paths through a type
+ * @typeParam T    - type which should be introspected
+ * @typeParam Seen - object types already entered on this recursion branch;
+ *                   used to terminate on self-referential types
+ * @example
+ * ```
+ * Path<{foo: {bar: string}}> = 'foo' | 'foo.bar'
+ * ```
+ */
+export type Path<T, Seen = never> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
+      [K in TupleKeys<T>]-?: PathImpl<K & string, T[K], Seen> | "length"
+    }[TupleKeys<T>]
+  : PathImpl<ArrayKey, V, Seen | T> | "length"
+  : {
+    [K in keyof T]-?: PathImpl<K & string, T[K], Seen | T>
+  }[keyof T]
+
+/**
+ * See {@link Path}
+ */
+export type FieldPath<TFieldValues extends FieldValues> = Path<TFieldValues>
+
+{
+  // Regression: self-referential types must terminate instead of blowing past
+  // TS's instantiation limit (TS2589). `JsonLike` mirrors effect's `Json` — the
+  // encoded form of `Schema.Defect()` — whose `{ [x: string]: Json }` index
+  // signature previously made `Path` recurse forever. These aliases failing to
+  // compile (rather than resolving to a string union) signals the regression.
+  type JsonLike =
+    | string
+    | number
+    | boolean
+    | null
+    | ReadonlyArray<JsonLike>
+    | { readonly [x: string]: JsonLike }
+  type _RawDefect = Path<{ id: string; raw: JsonLike }>
+  type _NestedDefect = Path<{ a: { b: { error: { raw: JsonLike } } } }>
+  type _ArrayOfDefect = Path<{ items: ReadonlyArray<{ raw: JsonLike }> }>
+  // finite paths are still produced
+  expectTypeOf<"id">().toExtend<_RawDefect>()
+  expectTypeOf<"raw">().toExtend<_RawDefect>()
+  expectTypeOf<"a.b.error.raw">().toExtend<_NestedDefect>()
+  expectTypeOf<`items.${number}.raw`>().toExtend<_ArrayOfDefect>()
+}
+
+/**
+ * Type to evaluate the type which the given path points to.
+ * @typeParam T - deeply nested type which is indexed by the path
+ * @typeParam P - path into the deeply nested type
+ * @example
+ * ```
+ * PathValue<{foo: {bar: string}}, 'foo.bar'> = string
+ * PathValue<[number, string], '1'> = string
+ * ```
+ */
+/* 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
+/* dprint-ignore-end */
+
+/**
+ * See {@link PathValue}
+ */
+export type FieldPathValue<
+  TFieldValues extends FieldValues,
+  TFieldPath extends FieldPath<TFieldValues>
+> = PathValue<TFieldValues, TFieldPath>
+
+/* 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,
+  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 EraseNeverContainingUnionElements<T> = T extends any ? {
+  [K in keyof T]: IsNever<T[K]> extends true ? true : false
+} extends infer $NC ? true extends $NC[keyof $NC] ? never : T
+: never : never
+
+export type RefineFieldPathValue<
+  TFieldValues extends FieldValues,
+  TFieldPath extends FieldPath<TFieldValues>,
+  X extends string | number | boolean | null | bigint,
+  Exclde extends boolean = false
+> = EraseNeverContainingUnionElements<RefinePathValue<TFieldValues, TFieldPath, X, Exclde>>
+
+{
+  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 } }>()
+
+  type test10 = RefineFieldPathValue<
+    | { nested: { a: string; _tag: "a" } | { b: number; _tag: "b" }; _tag: "ab" }
+    | { nested: { b: number; _tag: "b" } | { c: boolean; _tag: "c" }; _tag: "bc" },
+    "nested._tag",
+    "a"
+  >
+
+  expectTypeOf<test10>().toEqualTypeOf<{
+    nested: {
+      a: string
+      _tag: "a"
+    }
+    _tag: "ab"
+  }>()
+}
+
+{
+  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.
+ * @typeParam TFieldValues - field values which are indexed by the paths
+ * @typeParam TPath        - paths into the deeply nested field values
+ * @example
+ * ```
+ * FieldPathValues<{foo: {bar: string}}, ['foo', 'foo.bar']>
+ *   = [{bar: string}, string]
+ * ```
+ */
+export type FieldPathValues<
+  TFieldValues extends FieldValues,
+  TPath extends FieldPath<TFieldValues>[] | readonly FieldPath<TFieldValues>[]
+> =
+  & {}
+  & {
+    [K in keyof TPath]: FieldPathValue<
+      TFieldValues,
+      TPath[K] & FieldPath<TFieldValues>
+    >
+  }
+
+/**
+ * Type which eagerly collects all paths through a fieldType that matches a give type
+ * @typeParam TFieldValues - field values which are indexed by the paths
+ * @typeParam TValue       - the value you want to match into each type
+ * @example
+ * ```typescript
+ * FieldPathByValue<{foo: {bar: number}, baz: number, bar: string}, number>
+ *   = 'foo.bar' | 'baz'
+ * ```
+ */
+export type FieldPathByValue<TFieldValues extends FieldValues, TValue> = {
+  [Key in FieldPath<TFieldValues>]: FieldPathValue<
+    TFieldValues,
+    Key
+  > extends TValue ? Key
+    : never
+}[FieldPath<TFieldValues>]

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

@@ -0,0 +1,4 @@
+/** Re-export public API */
+
+export type { PathString } from "./common.ts"
+export type { FieldPath, FieldPathByValue, FieldPathValue, FieldPathValues, Path, PathValue } from "./eager.ts"

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

@@ -0,0 +1,128 @@
+declare const $NestedValue: unique symbol
+
+/**
+ * @deprecated to be removed in the next major version
+ */
+export type NestedValue<TValue extends object = object> = {
+  [$NestedValue]: never
+} & TValue
+
+/**
+ * @deprecated to be removed in the next major version
+ */
+export type UnpackNestedValue<T> = T extends NestedValue<infer U> ? U
+  : T extends Date | FileList | File | Blob ? T
+  : T extends object ? { [K in keyof T]: UnpackNestedValue<T[K]> }
+  : T
+
+/*
+Projects that React Hook Form installed don't include the DOM library need these interfaces to compile.
+React Native applications is no DOM available. The JavaScript runtime is ES6/ES2015 only.
+These definitions allow such projects to compile with only --lib ES6.
+
+Warning: all of these interfaces are empty.
+If you want type definitions for various properties, you need to add `--lib DOM` (via command line or tsconfig.json).
+*/
+
+export type Noop = () => void
+
+interface File extends Blob {
+  readonly lastModified: number
+  readonly name: string
+}
+
+interface FileList {
+  readonly length: number
+  item(index: number): File | null
+  [index: number]: File
+}
+
+export type Primitive =
+  | null
+  | undefined
+  | string
+  | number
+  | boolean
+  | symbol
+  | bigint
+
+export type BrowserNativeObject = Date | FileList | File
+
+export type EmptyObject = { [K in string | number]: never }
+
+export type NonUndefined<T> = T extends undefined ? never : T
+
+export type LiteralUnion<T extends U, U extends Primitive> =
+  | T
+  | (U & { _?: never })
+
+export type DeepPartial<T> = T extends BrowserNativeObject | NestedValue ? T
+  : { [K in keyof T]?: DeepPartial<T[K]> }
+
+export type DeepPartialSkipArrayKey<T> = T extends
+  | BrowserNativeObject
+  | NestedValue ? T
+  : T extends ReadonlyArray<any> ? { [K in keyof T]: DeepPartialSkipArrayKey<T[K]> }
+  : { [K in keyof T]?: DeepPartialSkipArrayKey<T[K]> }
+
+/**
+ * Checks whether the type is any
+ * See {@link https://stackoverflow.com/a/49928360/3406963}
+ * @typeParam T - type which may be any
+ * ```
+ * IsAny<any> = true
+ * IsAny<string> = false
+ * ```
+ */
+export type IsAny<T> = 0 extends 1 & T ? true : false
+
+/**
+ * Checks whether the type is never
+ * @typeParam T - type which may be never
+ * ```
+ * IsAny<never> = true
+ * IsAny<string> = false
+ * ```
+ */
+export type IsNever<T> = [T] extends [never] ? true : false
+
+export type DeepMap<T, TValue> = IsAny<T> extends true ? any
+  : T extends BrowserNativeObject | NestedValue ? TValue
+  : T extends object ? { [K in keyof T]: DeepMap<NonUndefined<T[K]>, TValue> }
+  : TValue
+
+export type IsFlatObject<T extends object> = Extract<
+  Exclude<T[keyof T], NestedValue | Date | FileList>,
+  any[] | object
+> extends never ? true
+  : false
+
+export type Merge<A, B> = {
+  [K in keyof A | keyof B]?: K extends keyof A & keyof B ? [A[K], B[K]] extends [object, object] ? Merge<A[K], B[K]>
+    : A[K] | B[K]
+    : K extends keyof A ? A[K]
+    : K extends keyof B ? B[K]
+    : never
+}
+
+export type Resolve<T> =
+  & {
+    [K in keyof T]: Resolve<T[K]>
+  }
+  & {}
+
+export type ResolveFirstLevel<T> =
+  & {
+    [K in keyof T]: T[K]
+  }
+  & {}
+
+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

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

@@ -0,0 +1,46 @@
+import type { Message } from "./errors.ts"
+import type { FieldValues, InternalFieldName } from "./fields.ts"
+import type { FieldPath, FieldPathValue } from "./path/index.ts"
+
+export type ValidationValue = boolean | number | string | RegExp
+
+export type ValidationRule<
+  TValidationValue extends ValidationValue = ValidationValue
+> = TValidationValue | ValidationValueMessage<TValidationValue>
+
+export type ValidationValueMessage<
+  TValidationValue extends ValidationValue = ValidationValue
+> = {
+  value: TValidationValue
+  message: Message
+}
+
+export type ValidateResult = Message | Message[] | boolean | undefined
+
+export type Validate<TFieldValue> = (
+  value: TFieldValue
+) => ValidateResult | Promise<ValidateResult>
+
+export type RegisterOptions<
+  TFieldValues extends FieldValues = FieldValues,
+  TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>
+> = Partial<{
+  required: Message | ValidationRule<boolean>
+  min: ValidationRule<number | string>
+  max: ValidationRule<number | string>
+  maxLength: ValidationRule<number>
+  minLength: ValidationRule<number>
+  pattern: ValidationRule<RegExp>
+  validate:
+    | Validate<FieldPathValue<TFieldValues, TFieldName>>
+    | Record<string, Validate<FieldPathValue<TFieldValues, TFieldName>>>
+  valueAsNumber: boolean
+  valueAsDate: boolean
+  value: FieldPathValue<TFieldValues, TFieldName>
+  setValueAs: (value: any) => any
+  shouldUnregister?: boolean
+  onChange?: (event: any) => void
+  onBlur?: (event: any) => void
+  disabled: boolean
+  deps: InternalFieldName | InternalFieldName[]
+}>

package/src/Model/filter/types.ts

@@ -0,0 +1,6 @@
+// codegen:start {preset: barrel, include: ./types/*.ts}
+export * from "./types/errors.ts"
+export * from "./types/fields.ts"
+export * from "./types/utils.ts"
+export * from "./types/validator.ts"
+// codegen:end