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

package/src/Model/dsl.ts

@@ -1,129 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import type { NonEmptyReadonlyArray } from "effect-app/Array"
-import { toNonEmptyArray } from "effect-app/Array"
-import * as Effect from "effect-app/Effect"
-import { type FixEnv, get, logMany, type Pure, type PureEnvEnv, type PureLogT, set } from "effect-app/Pure"
-
-export interface PureDSL<S, S2, W> {
-  get: Pure<never, S, S, never, never, S>
-  set: (s: S2) => Pure<never, S2, S2, never, never, void>
-  log: (...w: W[]) => PureLogT<W>
-}
-
-export const AnyPureDSL: PureDSL<any, any, any> = {
-  get: get(),
-  set: set as any,
-  log: (...evt: any[]) => logMany(evt)
-}
-
-const anyDSL = makeDSL<any, any, any>()
-
-export type AllDSL<T, Evt> =
-  & (<R, A, E, S1 extends T, S2 extends T>(
-    pure: (dsl: PureDSL<S1[], S2[], Evt>) => Effect.Effect<A, E, R>
-  ) => Effect.Effect<A, E, FixEnv<R, Evt, S1[], S2[]>>)
-  & AllDSLExt<T, Evt>
-
-export interface AllDSLExt<T, Evt> {
-  modify: <R, E, A, S1 extends T, S2 extends T>(
-    pure: (items: readonly S1[], dsl: PureDSL<readonly S1[], readonly S2[], Evt>) => Effect.Effect<A, E, R>
-  ) => Effect.Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>
-  update: <R, E, S1 extends T, S2 extends T>(
-    pure: (items: readonly S1[], log: (...evt: Evt[]) => PureLogT<Evt>) => Effect.Effect<readonly S2[], E, R>
-  ) => Effect.Effect<readonly S2[], E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>
-  updateWith: <S1 extends T, S2 extends T>(
-    upd: (item: readonly S1[]) => readonly S2[]
-  ) => Effect.Effect<readonly S2[], never, PureEnvEnv<Evt, readonly S1[], readonly S2[]>>
-}
-
-export function makeAllDSL<T, Evt>() {
-  const dsl: AllDSL<T, Evt> = anyDSL
-  return dsl
-}
-
-export type OneDSL<T, Evt> =
-  & (<R, A, E, S1 extends T, S2 extends T>(
-    pure: (dsl: PureDSL<S1, S2, Evt>) => Effect.Effect<A, E, R>
-  ) => Effect.Effect<A, E, FixEnv<R, Evt, S1, S2>>)
-  & OneDSLExt<T, Evt>
-
-export interface OneDSLExt<T, Evt> {
-  modify: <R, E, A, S1 extends T, S2 extends T>(
-    pure: (items: S1, dsl: PureDSL<S1, S2, Evt>) => Effect.Effect<A, E, R>
-  ) => Effect.Effect<A, E, FixEnv<R, Evt, S1, S2> | PureEnvEnv<Evt, S1, S1>>
-  update: <R, E, S1 extends T, S2 extends T>(
-    pure: (items: S1, log: (...evt: Evt[]) => PureLogT<Evt>) => Effect.Effect<S2, E, R>
-  ) => Effect.Effect<S2, E, FixEnv<R, Evt, S1, S2>>
-  updateWith: <S1 extends T, S2 extends T>(
-    upd: (item: S1) => S2
-  ) => Effect.Effect<S2, never, PureEnvEnv<Evt, S1, S2>>
-}
-
-export function makeOneDSL<T, Evt>(): OneDSL<T, Evt> {
-  return anyDSL
-}
-
-export function makeDSL<S1, S2, Evt>() {
-  const dsl: PureDSL<S1, S2, Evt> = AnyPureDSL
-
-  function modify<
-    R,
-    E,
-    A
-  >(
-    pure: (
-      items: S1,
-      dsl: PureDSL<S1, S2, Evt>
-    ) => Effect.Effect<A, E, R>
-  ): Effect.Effect<A, E, FixEnv<R, Evt, S1, S2>> {
-    return dsl.get.pipe(Effect.flatMap((items) => pure(items, dsl))) as any
-  }
-
-  function update<
-    R,
-    E
-  >(
-    pure: (
-      items: S1,
-      log: (...evt: Evt[]) => PureLogT<Evt>
-    ) => Effect.Effect<S2, E, R>
-  ): Effect.Effect<S2, E, FixEnv<R, Evt, S1, S2>> {
-    return dsl.get.pipe(Effect.flatMap((items) => pure(items, dsl.log).pipe(Effect.tap(dsl.set)))) as any
-  }
-
-  function withDSL<
-    R,
-    A,
-    E
-  >(
-    pure: (dsl: PureDSL<S1, S2, Evt>) => Effect.Effect<A, E, R>
-  ): Effect.Effect<A, E, FixEnv<R, Evt, S1, S2>> {
-    return pure(AnyPureDSL) as any
-  }
-
-  function updateWith(upd: (item: S1) => S2) {
-    return update((_: S1) => Effect.sync(() => upd(_)))
-  }
-
-  return Object.assign(
-    withDSL,
-    {
-      modify,
-      update,
-      updateWith
-    }
-  )
-}
-
-export interface DSLExt<S1, S2, Evt> extends ReturnType<typeof makeDSL<S1, S2, Evt>> {}
-
-export function ifAny<T, R, E, A>(fn: (items: NonEmptyReadonlyArray<T>) => Effect.Effect<A, E, R>) {
-  return (items: Iterable<T>) => Effect.flatMapOption(Effect.sync(() => toNonEmptyArray([...items])), fn)
-}
-
-export function ifAny_<T, R, E, A>(
-  items: Iterable<T>,
-  fn: (items: NonEmptyReadonlyArray<T>) => Effect.Effect<A, E, R>
-) {
-  return Effect.flatMapOption(Effect.sync(() => toNonEmptyArray([...items])), fn)
-}

package/src/Model/filter/filterApi.ts

@@ -1,60 +0,0 @@
-import { type RelationDirection } from "../query.js"
-
-export type InOps =
-  | "in"
-  | "notIn"
-
-export type OtherOps =
-  | "endsWith"
-  | "startsWith"
-  | "notEndsWith"
-  | "notStartsWith"
-  | "contains"
-  | "notContains"
-  | "includes"
-  | "notIncludes"
-  | "includes-any"
-  | "notIncludes-any"
-  | "includes-all"
-  | "notIncludes-all"
-  | "eq"
-  | "neq"
-  | "gt"
-  | "gte"
-  | "lt"
-  | "lte"
-
-export type Ops = OtherOps | InOps
-
-export type FilterScopes = {
-  t: "or-scope"
-  result: readonly FilterResult[]
-  relation: RelationDirection
-} | {
-  t: "and-scope"
-  result: readonly FilterResult[]
-  relation: RelationDirection
-} | {
-  t: "where-scope"
-  result: readonly FilterResult[]
-  relation: RelationDirection
-}
-
-export type FilterR = {
-  op: Ops
-
-  path: string
-  value: string // ToDO: Value[]
-}
-
-export type FilterResult =
-  | {
-    t: "where"
-  } & FilterR
-  | {
-    t: "or"
-  } & FilterR
-  | {
-    t: "and"
-  } & FilterR
-  | FilterScopes

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

@@ -1,47 +0,0 @@
-import type { FieldValues, InternalFieldName } from "./fields.js"
-import type { BrowserNativeObject, IsAny, LiteralUnion, Merge } from "./utils.js"
-import type { RegisterOptions, ValidateResult } from "./validator.js"
-
-export type Message = string
-
-export type MultipleFieldErrors =
-  & {
-    [K in keyof RegisterOptions]?: ValidateResult
-  }
-  & {
-    [key: string]: ValidateResult
-  }
-
-export type FieldError = {
-  type: LiteralUnion<keyof RegisterOptions, string>
-  root?: FieldError
-  // ref?: Ref
-  types?: MultipleFieldErrors
-  message?: Message
-}
-
-export type ErrorOption = {
-  message?: Message
-  type?: LiteralUnion<keyof RegisterOptions, string>
-  types?: MultipleFieldErrors
-}
-
-export type DeepRequired<T> = T extends BrowserNativeObject | Blob ? T
-  : {
-    [K in keyof T]-?: NonNullable<DeepRequired<T[K]>>
-  }
-
-export type FieldErrorsImpl<T extends FieldValues = FieldValues> = {
-  [K in keyof T]?: T[K] extends BrowserNativeObject | Blob ? FieldError
-    : T[K] extends object ? Merge<FieldError, FieldErrorsImpl<T[K]>>
-    : FieldError
-}
-
-export type FieldErrors<T extends FieldValues = FieldValues> = Partial<
-  FieldValues extends IsAny<FieldValues> ? any
-    : FieldErrorsImpl<DeepRequired<T>>
->
-
-export type InternalFieldErrors = Partial<
-  Record<InternalFieldName, FieldError>
->

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

@@ -1,50 +0,0 @@
-import type { IsFlatObject } from "./utils.js"
-import type { RegisterOptions } from "./validator.js"
-
-export type InternalFieldName = string
-
-export type FieldName<TFieldValues extends FieldValues> = IsFlatObject<TFieldValues> extends true
-  ? Extract<keyof TFieldValues, string>
-  : string
-
-// export type CustomElement<TFieldValues extends FieldValues> = {
-//   name: FieldName<TFieldValues>
-//   type?: string
-//   value?: any
-//   disabled?: boolean
-//   checked?: boolean
-//   options?: HTMLOptionsCollection
-//   files?: FileList | null
-//   focus?: Noop
-// }
-
-export type FieldValue<TFieldValues extends FieldValues> = TFieldValues[InternalFieldName]
-
-export type FieldValues = Record<string, any>
-
-export type NativeFieldValue =
-  | string
-  | number
-  | boolean
-  | null
-  | undefined
-  | unknown[]
-
-// export type FieldElement<TFieldValues extends FieldValues = FieldValues> =
-//   | HTMLInputElement
-//   | HTMLSelectElement
-//   | HTMLTextAreaElement
-//   | CustomElement<TFieldValues>
-
-// export type Ref = FieldElement
-
-export type Field = {
-  _f: {
-    // ref: Ref
-    name: InternalFieldName
-    // refs?: HTMLInputElement[]
-    mount?: boolean
-  } & RegisterOptions
-}
-
-export type FieldRefs = Partial<Record<InternalFieldName, Field>>

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

@@ -1,404 +0,0 @@
-import type { IsAny, IsNever } from "../utils.js"
-
-/**
- * Type alias to `string` which describes a lodash-like path through an object.
- * E.g. `'foo.bar.0.baz'`
- */
-export type PathString = string
-
-/**
- * Type which can be traversed through with a {@link PathString}.
- * I.e. objects, arrays, and tuples
- */
-export type Traversable = object
-
-/**
- * Type to query whether an array type T is a tuple type.
- * @typeParam T - type which may be an array or tuple
- * @example
- * ```
- * IsTuple<[number]> = true
- * IsTuple<number[]> = false
- * ```
- */
-export type IsTuple<T extends ReadonlyArray<any>> = number extends T["length"] ? false
-  : true
-
-/**
- * Type which can be used to index an array or tuple type.
- */
-export type ArrayKey = number
-
-/**
- * Type which can be used to index an object.
- */
-export type Key = string
-
-/**
- * Type to assert that a type is a {@link Key}.
- * @typeParam T - type which may be a {@link Key}
- */
-export type AsKey<T> = Extract<T, Key>
-
-/**
- * Type to convert a type to a {@link Key}.
- * @typeParam T - type which may be converted to a {@link Key}
- */
-export type ToKey<T> = T extends ArrayKey ? `${T}` : AsKey<T>
-
-/**
- * Type which describes a path through an object
- * as a list of individual {@link Key}s.
- */
-export type PathTuple = Key[]
-
-/**
- * Type to assert that a type is a {@link PathTuple}.
- * @typeParam T - type which may be a {@link PathTuple}
- */
-export type AsPathTuple<T> = Extract<T, PathTuple>
-
-/**
- * Type to intersect a union type.
- * See https://fettblog.eu/typescript-union-to-intersection/
- * @typeParam U - union
- * @example
- * ```
- * UnionToIntersection<{ foo: string } | { bar: number }>
- *   = { foo: string; bar: number }
- * ```
- */
-export type UnionToIntersection<U> = (
-  U extends any ? (_: U) => any : never
-) extends (_: infer I) => any ? I
-  : never
-
-/**
- * Type which appends a {@link Key} to the {@link PathTuple} only if it is not
- * blank, i.e. not the empty string.
- * @typeParam PT - path
- * @typeParam K  - key
- * @example
- * ```
- * AppendNonBlankKey<['foo'], 'bar'> = ['foo', 'bar']
- * AppendNonBlankKey<['foo'], ''> = ['foo']
- * ```
- */
-type AppendNonBlankKey<PT extends PathTuple, K extends Key> = K extends "" ? PT
-  : [...PT, K]
-
-/**
- * Type to implement {@link SplitPathString} tail recursively.
- * @typeParam PS - remaining {@link PathString} which should be split into its
- *                 individual {@link Key}s
- * @typeParam PT - accumulator of the {@link Key}s which have been split from
- *                 the original {@link PathString} already
- */
-type SplitPathStringImpl<
-  PS extends PathString,
-  PT extends PathTuple
-> = PS extends `${infer K}.${infer R}` ? SplitPathStringImpl<R, AppendNonBlankKey<PT, K>>
-  : AppendNonBlankKey<PT, PS>
-
-/**
- * Type to split a {@link PathString} into a {@link PathTuple}.
- * The individual {@link Key}s may be empty strings.
- * @typeParam PS  - {@link PathString} which should be split into its
- *                  individual {@link Key}s
- * @example
- * ```
- * SplitPathString<'foo'> = ['foo']
- * SplitPathString<'foo.bar.0.baz'> = ['foo', 'bar', '0', 'baz']
- * SplitPathString<'.'> = []
- * ```
- */
-export type SplitPathString<PS extends PathString> = SplitPathStringImpl<
-  PS,
-  []
->
-
-/**
- * Type to implement {@link JoinPathTuple} tail-recursively.
- * @typeParam PT - remaining {@link Key}s which needs to be joined
- * @typeParam PS - accumulator of the already joined {@link Key}s
- */
-type JoinPathTupleImpl<
-  PT extends PathTuple,
-  PS extends PathString
-> = PT extends [infer K, ...infer R] ? JoinPathTupleImpl<AsPathTuple<R>, `${PS}.${AsKey<K>}`>
-  : PS
-
-/**
- * Type to join a {@link PathTuple} to a {@link PathString}.
- * @typeParam PT - {@link PathTuple} which should be joined.
- * @example
- * ```
- * JoinPathTuple<['foo']> = 'foo'
- * JoinPathTuple<['foo', 'bar', '0', 'baz']> = 'foo.bar.0.baz'
- * JoinPathTuple<[]> = never
- * ```
- */
-export type JoinPathTuple<PT extends PathTuple> = PT extends [
-  infer K,
-  ...infer R
-] ? JoinPathTupleImpl<AsPathTuple<R>, AsKey<K>>
-  : never
-
-/**
- * Type which converts all keys of an object to {@link Key}s.
- * @typeParam T - object type
- * @example
- * ```
- * MapKeys<{0: string}> = {'0': string}
- * ```
- */
-type MapKeys<T> = { [K in keyof T as ToKey<K>]: T[K] }
-
-/**
- * Type to access a type by a key.
- *  - Returns undefined if it can't be indexed by that key.
- *  - Returns null if the type is null.
- *  - Returns undefined if the type is not traversable.
- * @typeParam T - type which is indexed by the key
- * @typeParam K - key into the type
- * ```
- * TryAccess<{foo: string}, 'foo'> = string
- * TryAccess<{foo: string}, 'bar'> = undefined
- * TryAccess<null, 'foo'> = null
- * TryAccess<string, 'foo'> = undefined
- * ```
- */
-type TryAccess<T, K> = K extends keyof T ? T[K]
-  : T extends null ? null
-  : undefined
-
-/**
- * Type to access an array type by a key.
- * Returns undefined if the key is non-numeric.
- * @typeParam T - type which is indexed by the key
- * @typeParam K - key into the type
- * ```
- * TryAccessArray<string[], '0'> = string
- * TryAccessArray<string[], 'foo'> = undefined
- * ```
- */
-type TryAccessArray<
-  T extends ReadonlyArray<any>,
-  K extends Key
-> = K extends `${ArrayKey}` ? T[number] : TryAccess<T, K>
-
-/**
- * Type to evaluate the type which the given key points to.
- * @typeParam T - type which is indexed by the key
- * @typeParam K - key into the type
- * @example
- * ```
- * EvaluateKey<{foo: string}, 'foo'> = string
- * EvaluateKey<[number, string], '1'> = string
- * EvaluateKey<string[], '1'> = string
- * ```
- */
-export type EvaluateKey<T, K extends Key> = T extends ReadonlyArray<any> ? IsTuple<T> extends true ? TryAccess<T, K>
-  : TryAccessArray<T, K>
-  : TryAccess<MapKeys<T>, K>
-
-/**
- * Type to evaluate the type which the given path points to.
- * @typeParam T  - deeply nested type which is indexed by the path
- * @typeParam PT - path into the deeply nested type
- * @example
- * ```
- * EvaluatePath<{foo: {bar: string}}, ['foo', 'bar']> = string
- * EvaluatePath<[number, string], ['1']> = string
- * EvaluatePath<number, []> = number
- * EvaluatePath<number, ['foo']> = undefined
- * ```
- */
-export type EvaluatePath<T, PT extends PathTuple> = PT extends [
-  infer K,
-  ...infer R
-] ? EvaluatePath<EvaluateKey<T, AsKey<K>>, AsPathTuple<R>>
-  : T
-
-/**
- * Type which given a tuple type returns its own keys, i.e. only its indices.
- * @typeParam T - tuple type
- * @example
- * ```
- * TupleKeys<[number, string]> = '0' | '1'
- * ```
- */
-export type TupleKeys<T extends ReadonlyArray<any>> = Exclude<
-  keyof T,
-  keyof any[]
->
-
-/**
- * Type which extracts all numeric keys from an object.
- * @typeParam T - type
- * @example
- * ```
- * NumericObjectKeys<{0: string, '1': string, foo: string}> = '0' | '1'
- * ```
- */
-type NumericObjectKeys<T extends Traversable> = ToKey<
-  Extract<keyof T, ArrayKey | `${ArrayKey}`>
->
-
-/**
- * Type which extracts all numeric keys from an object, tuple, or array.
- * If a union is passed, it evaluates to the overlapping numeric keys.
- * @typeParam T - type
- * @example
- * ```
- * NumericKeys<{0: string, '1': string, foo: string}> = '0' | '1'
- * NumericKeys<number[]> = `${number}`
- * NumericKeys<[string, number]> = '0' | '1'
- * NumericKeys<{0: string, '1': string} | [number] | number[]> = '0'
- * ```
- */
-export type NumericKeys<T extends Traversable> = UnionToIntersection<
-  T extends ReadonlyArray<any> ? IsTuple<T> extends true ? [TupleKeys<T>]
-    : [ToKey<ArrayKey>]
-    : [NumericObjectKeys<T>]
->[never]
-
-/**
- * Type which extracts all keys from an object.
- * If a union is passed, it evaluates to the overlapping keys.
- * @typeParam T - object type
- * @example
- * ```
- * ObjectKeys<{foo: string, bar: string}, string> = 'foo' | 'bar'
- * ObjectKeys<{foo: string, bar: number}, string> = 'foo'
- * ```
- */
-export type ObjectKeys<T extends Traversable> = Exclude<
-  ToKey<keyof T>,
-  `${string}.${string}` | ""
->
-
-/**
- * Type to check whether a type's property matches the constraint type
- * and return its key. Converts the key to a {@link Key}.
- * @typeParam T - type whose property should be checked
- * @typeParam K - key of the property
- * @typeParam U - constraint type
- * @example
- * ```
- * CheckKeyConstraint<{foo: string}, 'foo', string> = 'foo'
- * CheckKeyConstraint<{foo: string}, 'foo', number> = never
- * CheckKeyConstraint<string[], number, string> = `${number}`
- * ```
- */
-export type CheckKeyConstraint<T, K extends Key, U> = K extends any ? EvaluateKey<T, K> extends U ? K
-  : never
-  : never
-
-/**
- * Type which evaluates to true when the type is an array or tuple or is a union
- * which contains an array or tuple.
- * @typeParam T - type
- * @example
- * ```
- * ContainsIndexable<{foo: string}> = false
- * ContainsIndexable<{foo: string} | number[]> = true
- * ```
- */
-export type ContainsIndexable<T> = IsNever<
-  Extract<T, ReadonlyArray<any>>
-> extends true ? false
-  : true
-
-/**
- * Type to implement {@link Keys} for non-nullable values.
- * @typeParam T - non-nullable type whose property should be checked
- */
-type KeysImpl<T> = [T] extends [Traversable] ? ContainsIndexable<T> extends true ? NumericKeys<T>
-  : ObjectKeys<T>
-  : never
-
-/**
- * Type to find all properties of a type that match the constraint type
- * and return their keys.
- * If a union is passed, it evaluates to the overlapping keys.
- * @typeParam T - type whose property should be checked
- * @typeParam U - constraint type
- * @example
- * ```
- * Keys<{foo: string, bar: string}, string> = 'foo' | 'bar'
- * Keys<{foo?: string, bar?: string}> = 'foo' | 'bar'
- * Keys<{foo: string, bar: number}, string> = 'foo'
- * Keys<[string, number], string> = '0'
- * Keys<string[], string> = `${number}`
- * Keys<{0: string, '1': string} | [number] | number[]> = '0'
- * ```
- */
-export type Keys<T, U = unknown> = IsAny<T> extends true ? Key
-  : IsNever<T> extends true ? Key
-  : IsNever<NonNullable<T>> extends true ? never
-  : CheckKeyConstraint<T, KeysImpl<NonNullable<T>>, U>
-
-/**
- * Type to check whether a {@link Key} is present in a type.
- * If a union of {@link Key}s is passed, all {@link Key}s have to be present
- * in the type.
- * @typeParam T - type which is introspected
- * @typeParam K - key
- * @example
- * ```
- * HasKey<{foo: string}, 'foo'> = true
- * HasKey<{foo: string}, 'bar'> = false
- * HasKey<{foo: string}, 'foo' | 'bar'> = false
- * ```
- */
-export type HasKey<T, K extends Key> = IsNever<Exclude<K, Keys<T>>>
-
-/**
- * Type to implement {@link ValidPathPrefix} tail recursively.
- * @typeParam T   - type which the path should be checked against
- * @typeParam PT  - path which should exist within the given type
- * @typeParam VPT - accumulates the prefix of {@link Key}s which have been
- *                  confirmed to exist already
- */
-type ValidPathPrefixImpl<
-  T,
-  PT extends PathTuple,
-  VPT extends PathTuple
-> = PT extends [infer K, ...infer R] ? HasKey<T, AsKey<K>> extends true ? ValidPathPrefixImpl<
-      EvaluateKey<T, AsKey<K>>,
-      AsPathTuple<R>,
-      AsPathTuple<[...VPT, K]>
-    >
-  : VPT
-  : VPT
-
-/**
- * Type to find the longest path prefix which is still valid,
- * i.e. exists within the given type.
- * @typeParam T  - type which the path should be checked against
- * @typeParam PT - path which should exist within the given type
- * @example
- * ```
- * ValidPathPrefix<{foo: {bar: string}}, ['foo', 'bar']> = ['foo', 'bar']
- * ValidPathPrefix<{foo: {bar: string}}, ['foo', 'ba']> = ['foo']
- * ```
- */
-export type ValidPathPrefix<T, PT extends PathTuple> = ValidPathPrefixImpl<
-  T,
-  PT,
-  []
->
-
-/**
- * Type to check whether a path through a type exists.
- * @typeParam T  - type which the path should be checked against
- * @typeParam PT - path which should exist within the given type
- * @example
- * ```
- * HasPath<{foo: {bar: string}}, ['foo', 'bar']> = true
- * HasPath<{foo: {bar: string}}, ['foo', 'ba']> = false
- * ```
- */
-export type HasPath<T, PT extends PathTuple> = ValidPathPrefix<T, PT> extends PT ? true
-  : false