@effect-app/infra 4.0.0-beta.247 → 4.0.0-beta.249

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

@@ -1,297 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { expectTypeOf } from "@effect/vitest"
-import type { FieldValues } from "../fields.js"
-import type { BrowserNativeObject, Equals, IsLiteral, IsNever, Primitive } from "../utils.js"
-
-import type { ArrayKey, IsTuple, TupleKeys } from "./common.js"
-
-/**
- * Helper type for recursively constructing paths through a type.
- * See {@link Path}
- */
-type PathImpl<K extends string | number, V> = V extends
-  | Primitive
-  | BrowserNativeObject ? `${K}`
-  : `${K}` | `${K}.${Path<V>}`
-
-/**
- * Type which eagerly collects all paths through a type
- * @typeParam T - type which should be introspected
- * @example
- * ```
- * Path<{foo: {bar: string}}> = 'foo' | 'foo.bar'
- * ```
- */
-export type Path<T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
-      [K in TupleKeys<T>]-?: PathImpl<K & string, T[K]> | "length"
-    }[TupleKeys<T>]
-  : PathImpl<ArrayKey, V> | "length"
-  : {
-    [K in keyof T]-?: PathImpl<K & string, T[K]>
-  }[keyof T]
-
-/**
- * See {@link Path}
- */
-export type FieldPath<TFieldValues extends FieldValues> = Path<TFieldValues>
-
-/**
- * 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>>
-
-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 } }>()
-
-  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"
-  }>()
-}
-
-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.
- * @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

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

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

@@ -1,128 +0,0 @@
-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

@@ -1,46 +0,0 @@
-import type { Message } from "./errors.js"
-import type { FieldValues, InternalFieldName } from "./fields.js"
-import type { FieldPath, FieldPathValue } from "./path/index.js"
-
-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

@@ -1,6 +0,0 @@
-// 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