effect-app 0.152.0

package/_src/Pure.ts

@@ -0,0 +1,525 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as Either from "effect/Either"
+import type { ServiceTagged } from "./service.js"
+
+const S1 = Symbol()
+const S2 = Symbol()
+const W = Symbol()
+
+/**
+ * @tsplus type PureEnv
+ */
+export interface PureState<S, S2 = S> {
+  readonly [S1]: (_: S) => void
+  readonly [S2]: () => S2
+
+  state: S2
+}
+
+/**
+ * @tsplus type PureEnv
+ */
+export interface PureLog<W> {
+  readonly [W]: () => W
+  log: Chunk<W>
+}
+
+/**
+ * @tsplus type PureEnv
+ */
+export interface PureEnv<W, S, S2 = S> extends PureState<S, S2>, PureLog<W> {}
+
+export interface PureEnvTest extends PureState<any>, PureLog<any> {}
+
+class PureEnvBase<W, S, S2 = S> implements PureEnv<W, S, S2> {
+  readonly [W]!: () => W
+  readonly [S1]!: (_: S) => void
+  readonly [S2]!: () => S2
+  readonly state: S2
+  readonly log: Chunk<W>
+
+  constructor(s: S2) {
+    this.state = s
+    this.log = Chunk.empty<W>()
+  }
+}
+
+export function makePureEnv<W, S, S2 = S>(s: S2): PureEnv<W, S, S2> {
+  return new PureEnvBase<W, S, S2>(s)
+}
+
+/**
+ * @tsplus unify PureEnv
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function unifyPureEnv<X extends PureEnv<any, any, any>>(
+  self: X
+): PureEnv<
+  [X] extends [{ [W]: () => infer W }] ? W : never,
+  [X] extends [{ [S1]: (_: infer S) => void }] ? S : never,
+  [X] extends [{ [S2]: () => infer S2 }] ? S2 : never
+> {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  return self
+}
+
+/**
+ * @tsplus type Pure
+ */
+export type Pure<W, S, S2, R, E, A> = Effect<A, E, PureEnvEnv<W, S, S2> | R>
+
+// type dsl<W, S, S2> = ProgramDSL<W, S, S2>
+
+/**
+ * @tsplus static Pure.Ops GMUA_
+ */
+export function GMUA_<W, S, S2, GR, GE, GA, MR, ME, MA, UR, UE, UA>(
+  get: Pure<W, S, S2, GR, GE, GA>,
+  modify: (i: GA) => Pure<W, S, S2, MR, ME, readonly [GA, MA]>,
+  update: (i: GA) => Pure<W, S, S2, UR, UE, UA>
+): Pure<W, S, S2, GR | MR | UR, GE | ME | UE, MA> {
+  return get.flatMap(modify).flatMap(([s, a]) => update(s).map(() => a))
+}
+
+/**
+ * @tsplus static Pure.Ops GMUA
+ */
+export function GMUA<W, S, S2, GA, MR, ME, MA>(modify: (i: GA) => Pure<W, S, S2, MR, ME, readonly [GA, MA]>) {
+  return <GR, GE, UR, UE, UA>(
+    get: Pure<W, S, S2, GR, GE, GA>,
+    update: (i: GA) => Pure<W, S, S2, UR, UE, UA>
+  ) => GMUA_(get, modify, update)
+}
+
+/**
+ * @tsplus static Pure.Ops GMU_
+ */
+
+export function GMU_<W, S, S2, GR, GE, GA, MR, ME, UR, UE, UA>(
+  get: Pure<W, S, S2, GR, GE, GA>,
+  modify: (i: GA) => Pure<W, S, S2, MR, ME, GA>,
+  update: (i: GA) => Pure<W, S, S2, UR, UE, UA>
+): Pure<W, S, S2, GR | MR | UR, GE | ME | UE, UA> {
+  return get.flatMap(modify).flatMap(update)
+}
+
+/**
+ * @tsplus static Pure.Ops GMU
+ */
+export function GMU<W, S, S2, GA, MR, ME>(modify: (i: GA) => Pure<W, S, S2, MR, ME, GA>) {
+  return <GR, GE, UR, UE, UA>(
+    get: Pure<W, S, S2, GR, GE, GA>,
+    update: (i: GA) => Pure<W, S, S2, UR, UE, UA>
+  ) => GMU_(get, modify, update)
+}
+
+const tagg = GenericTag<{ env: PureEnv<never, unknown, never> }>("@services/tagg")
+function castTag<W, S, S2>() {
+  return tagg as any as Tag<PureEnvEnv<W, S, S2>, PureEnvEnv<W, S, S2>>
+}
+
+export const PureEnvEnv = Symbol()
+export interface PureEnvEnv<W, S, S2> extends ServiceTagged<typeof PureEnvEnv> {
+  env: PureEnv<W, S, S2>
+}
+
+/**
+ * @tsplus static Pure.Ops get
+ */
+export function get<S>(): Pure<never, S, S, never, never, S> {
+  return castTag<never, S, S>().map((_) => _.env.state)
+}
+
+/**
+ * @tsplus static Pure.Ops set
+ */
+export function set<S>(s: S): Pure<never, S, S, never, never, void> {
+  return castTag<never, S, S>().map((_) => _.env.state = s)
+}
+
+export type PureLogT<W> = Pure<W, unknown, never, never, never, void>
+
+/**
+ * @tsplus static Pure.Ops log
+ */
+export function log<W>(w: W): PureLogT<W> {
+  return castTag<W, unknown, never>().map((_) => _.env.log = _.env.log.append(w))
+}
+
+/**
+ * @tsplus static Pure.Ops logMany
+ */
+export function logMany<W>(w: Iterable<W>): PureLogT<W> {
+  return castTag<W, unknown, never>().map((_) => _.env.log = _.env.log.appendAll(w.toChunk))
+}
+
+/**
+ * @tsplus static Pure.Ops runAll
+ * @tsplus fluent effect/io/Effect runAll
+ */
+export function runAll<R, E, A, W3, S1, S3, S4 extends S1>(
+  self: Effect<A, E, FixEnv<R, W3, S1, S3>>,
+  s: S4
+): Effect<readonly [Chunk<W3>, Either.Either<E, readonly [S3, A]>], never, Exclude<R, { env: PureEnv<W3, S1, S3> }>> {
+  const a = self
+    .flatMap((x) =>
+      castTag<W3, S1, S3>()
+        .flatMap(
+          ({ env: _ }) => Effect.sync(() => ({ log: _.log, state: _.state })) //            Ref.get(_.log).flatMap(log => Ref.get(_.state).map(state => ({ log, state })))
+        )
+        .map(
+          (
+            { log, state }
+          ) => tuple(log, Either.right(tuple(state, x)) as Either.Either<E, readonly [S3, A]>)
+        )
+    )
+    .catchAll(
+      (err) => tagg.map((env) => tuple(env.env.log, Either.left(err) as Either.Either<E, readonly [S3, A]>))
+    )
+  return a
+    .provide(tagg.makeLayer({ env: makePureEnv<W3, S3, S4>(s) as any }) as any)
+}
+
+/**
+ * @tsplus static Pure.Ops runResult
+ * @tsplus fluent effect/io/Effect runResult
+ */
+export function runResult<R, E, A, W3, S1, S3, S4 extends S1>(
+  self: Effect<A, E, FixEnv<R, W3, S1, S3>>,
+  s: S4
+) {
+  return runAll(self, s).map(([log, r]) => tuple(log, r.map(([s]) => s)))
+}
+
+/**
+ * @tsplus static Pure.Ops runTerm
+ * @tsplus fluent effect/io/Effect runTerm
+ */
+export function runTerm<R, E, A, W3, S1, S3, S4 extends S1>(
+  self: Effect<A, E, FixEnv<R, W3, S1, S3>>,
+  s: S4
+) {
+  return runAll(self, s)
+    .flatMap(([evts, r]) =>
+      r
+        .map(([s3, a]) => tuple(s3, evts.toArray, a))
+    )
+}
+
+/**
+ * @tsplus static Pure.Ops runTermDiscard
+ * @tsplus fluent effect/io/Effect runTermDiscard
+ */
+export function runTermDiscard<R, E, A, W3, S1, S3, S4 extends S1>(
+  self: Effect<A, E, FixEnv<R, W3, S1, S3>>,
+  s: S4
+) {
+  return self.runTerm(s).map(([s3, w3]) => tuple(s3, w3))
+}
+
+/**
+ * @tsplus static Pure.Ops runA
+ * @tsplus fluent effect/io/Effect runA
+ */
+export function runA<R, E, A, W3, S1, S3, S4 extends S1>(
+  self: Effect<A, E, FixEnv<R, W3, S1, S3>>,
+  s: S4
+) {
+  return runAll(self, s).map(([log, r]) => tuple(log, r.map(([, a]) => a)))
+}
+
+/**
+ * @tsplus static Pure.Ops modifyWith
+ */
+export function modify<S2, A, S3>(mod: (s: S2) => readonly [S3, A]): Effect<A, never, { env: PureEnv<never, S2, S3> }> {
+  return castTag<never, S3, S2>().map(
+    (_) =>
+      Effect.sync(() => mod(_.env.state)).map(([s, a]) => {
+        _.env.state = s as any
+        return a
+      })
+  ) as any
+}
+
+/**
+ * @tsplus static Pure.Ops modifyWithEffect
+ */
+export function modifyM<W, R, E, A, S2, S3>(
+  mod: (s: S2) => Effect<readonly [S3, A], E, FixEnv<R, W, S2, S3>>
+): Effect<A, E, FixEnv<R, W, S2, S3>> {
+  // return serviceWithEffect(_ => Ref.modifyM_(_.state, mod))
+  return castTag<W, S3, S2>().flatMap(
+    (_) => mod(_.env.state).map(([s, a]) => Effect.sync(() => _.env.state = s as any).map(() => a))
+  ) as any
+}
+
+/**
+ * @tsplus static Pure.Ops updateWith
+ */
+export function update<S2, S3>(upd: (s: S2) => S3) {
+  return modify((_: S2) => {
+    const r = upd(_)
+    return tuple(r, r)
+  })
+}
+
+export type FixEnv<R, W, S, S2> =
+  | Exclude<R, PureEnvEnv<any, any, any>>
+  | PureEnvEnv<W, S, S2>
+
+/**
+ * @tsplus static Pure.Ops updateWithEffect
+ */
+export function updateM<W, R, E, S2, S3>(
+  upd: (s: S2, log: (evt: W) => PureLogT<W>) => Effect<S3, E, FixEnv<R, W, S2, S3>>
+): Effect<S3, E, FixEnv<R, W, S2, S3>> {
+  return modifyM((_: S2) => upd(_, Pure.log).map((_) => tuple(_, _)))
+}
+
+// export function getMA<W, S, A>(self: (s: S) => A): Pure<W, S, never, never, A> {
+//   return Effect.accessM((_: PureState<S>) => Ref.get(_.state).map(self))
+// }
+
+// /**
+//  * @tsplus static Pure.Ops getM
+//  */
+// export function getM<W, S, R, E, A>(self: (s: S) => Pure<W, S, R, E, A>): Pure<W, S, R, E, A> {
+//   return Effect.accessM((_: PureState<S>) => Ref.get(_.state).flatMap(self))
+// }
+
+// export function getTM__<W, S, R, E, A>(self: (s: S) => Pure<W, S, R, E, A>) {
+//   return (tag: Tag<PureEnv<W, S>>) => Effect.accessServiceM(tag)(_ => Ref.get(_.state).flatMap(self))
+// }
+
+// export function getTM_<W, S, R, E, A>(tag: Tag<PureEnv<W, S>>, self: (s: S) => Pure<W, S, R, E, A>) {
+//   return Effect.accessServiceM(tag)(_ => Ref.get(_.state).flatMap(self))
+// }
+
+// export function getTM<W, S, R, E, A>(tag: Tag<PureEnv<W, S>>) {
+//   const access = Effect.accessServiceM(tag)
+//   return (self: (s: S) => Pure<W, S, R, E, A>) => access(_ => Ref.get(_.state).flatMap(self))
+// }
+
+/**
+ * @tsplus type Pure.Ops
+ */
+export interface PureOps {
+  // $: PureAspects
+}
+
+// /**
+//  * @tsplus type Pure.Ops
+//  */
+
+// export interface PureAspects {}
+export const Pure: PureOps = {
+  // $: {}
+}
+
+// /**
+//  * @tsplus static Pure.Ops makeDSL
+//  */
+// export function makeProgramDSL<W, S, S2 = S>(): ProgramDSL<W, S, S2> {
+//   return makeDSL_<W,S, S2>()
+// }
+
+// function makeDSL_<W, S, S2 = S>() {
+//   const tag = tagg as unknown as Tag<PureEnvEnv<W, S, S2>>
+//   const get = Effect.serviceWithEffect(tag, _ => _.env.state.get)
+//   function getM<R, E, A>(self: (s: S2) => Effect<R, E, A>) { return get.flatMap(self) }
+//   function get_<A>(self: (s: S2) => A) { return get.map(self)}
+//   function set(s: S2) {
+//     return Effect.serviceWithEffect(tag, _ => _.env.state.set(s))
+//   }
+//   function log<W2>(w: W2): Effect<{
+//     env: PureEnv<W | W2, never, never>;
+// }, never, void> {
+//     return Effect.serviceWithEffect(tag, _ => _.env.log.update(l => l.append(w as any))) as any
+//   }
+
+//   const baseDSL = {
+//     get,
+//     log,
+//     set
+//   }
+
+//   function modify<A, S3>(mod: (s: S2) => readonly [S3, A]): Effect<{
+//     env: PureEnv<W, S, S3>;
+// }, never, A> {
+//     return Effect.serviceWithEffect(tag, _ =>
+//       _.env.state.get.map(_ => mod(_)).flatMap(([s, a]) => _.env.state.set(s as any ).map(() => a))
+//     ) as any
+//   }
+
+//   function modifyM<R, E, A, S3>(mod: (s: S2) => Effect<R, E, readonly [S3, A]>): Effect<{
+//     env: PureEnv<W, S, S3>;
+// } | R, E, A> {
+//     // return serviceWithEffect(_ => Ref.modifyM_(_.state, mod))
+//     return Effect.serviceWithEffect(tag, _ =>
+//       _.env.state.get.flatMap(_ => mod(_ as unknown as S2)).flatMap(([s, a]) => _.env.state.set(s as any).map(() => a))
+//     ) as any
+//   }
+
+//   function update<S3>(upd: (s: S2) => S3) {
+//     return modify(_ => tuple(upd(_), void 0 as void))
+//   }
+
+//   function updateM<R, E, S3>(upd: (s: S2) => Effect<R, E, S3>) {
+//     return modifyM(_ => upd(_).map(_ => tuple(_, void 0 as void)))
+//   }
+
+//   const accessLog = Effect.serviceWithEffect(tag, _ => _.env.log.get)
+
+//   function runAll<R, E, A, W3, S1, S3, S4 extends S1>(
+//     self: Effect<FixEnv<R, W3, S1, S3>, E, A>,
+//     s: S4
+//   ): Effect<Exclude<R, { env: PureEnv<W3, S1, S3>}>, never, readonly [Chunk<W3>, Either.Either<E, readonly [S3, A]>]> {
+//     return self.flatMap(x =>
+//       Effect.serviceWithEffect(tag, ({ env: _ }) =>
+//         Effect.all({ log: _.log.get, state: _.state.get })
+//         //            Ref.get(_.log).flatMap(log => Ref.get(_.state).map(state => ({ log, state })))
+//       ).map(
+//         (
+//           { log, state }
+//         ) => tuple(log, Either.right(tuple(state, x)) as Either.Either<E, readonly [S3, A]>)
+//       )
+//     ).catchAll(
+//       err =>
+//         accessLog.map(log =>
+//           tuple(log, Either.left(err) as Either.Either<E, readonly [S3, A]>)
+//         )
+//     ).provideService(tag, { env: makePureEnv<W3, S3, S4>(s) as any }) as any
+//   }
+
+//   function runResult<R, E, A, W3, S1, S3, S4 extends S1>(
+//     self: Effect<FixEnv<R, W3, S1, S3>, E, A>,
+//     s: S4
+//   ) {
+//     return runAll(self, s).map(([log, r]) => tuple(log, r.map(([s]) => s)))
+//   }
+
+//   function runA<R, E, A, W3, S1, S3, S4 extends S1>(
+//     self: Effect<FixEnv<R, W3, S1, S3>, E, A>,
+//     s: S4
+//   ) {
+//     return runAll(self, s).map(([log, r]) => tuple(log, r.map(([, a]) => a)))
+//   }
+
+//   return {
+//     ...baseDSL,
+
+//     getM,
+//     get_,
+//     accessLog,
+//     runAll,
+//     runA,
+//     runResult,
+
+//     modify,
+//     modifyM,
+//     update,
+//     updateM
+//   }
+// }
+
+// type dsl_<W,S, S2 = S> = ReturnType<typeof makeDSL_<W, S, S2>>
+
+// /**
+//  * @tsplus type Pure/DSL
+//  */
+// export interface ProgramDSL<W, S, S2 = S> extends dsl_<W, S, S2> { }
+
+// /**
+//  * @tsplus fluent Pure/DSL modifyWithEffect
+//  */
+// export function dslmodifyM<W, S, R, E, A>(dsl: ProgramDSL<W, S>, mod: (s: S, dsl: ProgramDSL<W, S>) => Effect<R, E, readonly [S, A]>) {
+//     return dsl.modifyM(_ => mod(_, dsl))
+// }
+
+// /**
+//  * @tsplus fluent Pure/DSL modifyWith
+//  */
+// export function dslmodify<W, S, A>(dsl: ProgramDSL<W, S>, mod: (s: S, dsl: ProgramDSL<W, S>) => readonly [S, A]) {
+//     return dsl.modify(_ => mod(_, dsl))
+// }
+
+// /**
+//  * @tsplus fluent Pure/DSL updateWithEffect
+//  */
+// export function dslupdateM<W, S, R, E, S2, S3>(dsl: ProgramDSL<W, S, S2>, upd: (s: S2, dsl: ProgramDSL<W, S, S2>) => Effect<R, E, S3>) {
+//     return dsl.updateM(_ => upd(_, dsl))
+// }
+
+// /**
+//  * @tsplus fluent Pure/DSL updateWith
+//  */
+// export function dslupdate<W, S>(dsl: ProgramDSL<W, S>, upd: (s: S, dsl: ProgramDSL<W, S>) => S) {
+//     return dsl.update(_ => upd(_, dsl))
+// }
+
+// export interface ZPure<out W, in S1, out S2, in R, out E, out A> {}
+
+// export class ZPureImpl<out W, in S1, out S2, in R, out E, out A> implements ZPure<W, S1, S2, R, E, A> {
+//   zipRight<W1, S3, R1, E1, B>(
+//     f: ZPure<W1, S2, S3, R1, E1, B>
+//   ): ZPure<W1 | W, S1, S3, R1 | R, E | E1, B> {
+//     throw new Error("not implemented")
+//   }
+
+//   flatMap<W1, S3, R1, E1, B>(
+//     f: (a: A) => ZPure<W1, S2, S3, R1, E1, B>
+//   ): ZPure<W1 | W, S1, S3, R1 | R, E | E1, B> {
+//     throw new Error("not implemented")
+
+//   }
+// }
+
+// declare type Eff1 = Effect<PureEnv2<string, PrintingPickItem, PickItem>, never, void>
+
+// function flatMap<R, R2, E, E2, A, A2, W, S, S2>(self: Effect<R| PureEnv2<W, S, S2>, E, A>, (s: S) => Effect<R2 | PureEnv2>) {
+// }
+
+// export interface PureEnv2<W, S, S2> extends PureState2<S, S2>, PureLog<W> {}
+
+// const S1 = Symbol()
+// const S2 = Symbol()
+// const W = Symbol()
+// export interface PureState2<S, S2> {
+//   readonly [S1]: () => S
+//   readonly [S2]: () => S2
+
+//   readonly state: Ref<S>
+// }
+
+// const abc = Do($ => {
+//   const s = $(Pure.get<{ a: 1 }>())
+//   console.log(s)
+//   // const a = $(Pure.log("hello"))
+//   $(Pure.log("hallo" as const))
+//   $(Pure.log("hello" as const))
+//   $(Pure.log<"hallo" | "hello" | 5>(5))
+// })
+
+// declare const a: Effect<
+//   | {
+//     env: PureEnv<never, never, {
+//       a: 1
+//     }>
+//   }
+//   | { env: PureEnv<string, never, never> }
+//   | { env: PureEnv<number, never, never> },
+//   never,
+//   never
+// >
+// type R = _R<typeof a>
+// type Env<T> = T extends { env: infer rr } ? rr : never
+
+// type RRRR = Env<R>
+
+// const abcc = unifyPureEnv(
+//   undefined as any as RRRR
+// )
+// const test = Pure.runAll(
+//   abc,
+//   { a: 1 }
+// )

package/_src/Request.ts

@@ -0,0 +1,106 @@
+// @ts-expect-error wtf
+import { HttpClientError } from "@effect/platform/Http/ClientError"
+import type { ClientResponse } from "@effect/platform/Http/ClientResponse"
+import type { Headers } from "@effect/platform/Http/Headers"
+
+// there are issues with global imports with "as", so we re export here
+export { Client as HttpClient } from "@effect/platform/Http/Client"
+export { Cache as EffectCache } from "effect/Cache"
+export { Request as EffectRequest } from "effect/Request"
+
+export interface ResponseWithBody<A> extends Pick<ClientResponse, "headers" | "status" | "remoteAddress"> {
+  readonly body: A
+}
+
+// TODO: consider rebuilding the text/json helpers to use a cached effect
+// https://discord.com/channels/795981131316985866/1098177242598756412/1168565257569046712
+
+/**
+ * @tsplus getter effect/platform/Http/ClientResponse responseWithJsonBody
+ */
+export const responseWithJsonBody = (
+  response: ClientResponse
+) =>
+  response.json.map((body): ResponseWithBody<unknown> => ({
+    body,
+    headers: response.headers,
+    status: response.status,
+    remoteAddress: response.remoteAddress
+  }))
+
+/**
+ * @tsplus fluent effect/platform/Http/Client schemaJsonBody
+ */
+export const schemaJsonBody = <R, To, From, A, B>(
+  client: HttpClient<A, B, ClientResponse>,
+  schema: Schema<To, From, R>
+) => {
+  return client.mapEffect((_) => _.json.flatMap(schema.decodeUnknown))
+}
+
+/**
+ * @tsplus fluent effect/platform/Http/Client schemaJsonBodyUnsafe
+ */
+export const schemaJsonBodyUnsafe = <To, From, A, B>(
+  client: HttpClient<A, B, ClientResponse>,
+  schema: Schema<To, From>
+) => {
+  return client.mapEffect((_) => _.json.map(schema.decodeUnknownSync))
+}
+
+/**
+ * @tsplus fluent effect/platform/Http/Client schemaJson
+ */
+export const schemaJson = <
+  R,
+  From extends {
+    readonly status?: number
+    readonly headers?: Headers
+    readonly body?: unknown
+  },
+  To,
+  A,
+  B
+>(
+  client: HttpClient<A, B, ClientResponse>,
+  schema: Schema<To, From, R>
+) => {
+  return client.mapEffect((_) => _.responseWithJsonBody.flatMap(schema.decodeUnknown))
+}
+
+/**
+ * @tsplus fluent effect/platform/Http/Client schemaJsonUnsafe
+ */
+export const schemaJsonUnsafe = <
+  R,
+  From extends {
+    readonly status?: number
+    readonly headers?: Headers
+    readonly body?: unknown
+  },
+  To,
+  A,
+  B
+>(
+  client: HttpClient<A, B, ClientResponse>,
+  schema: Schema<To, From, R>
+) => {
+  return client.mapEffect((_) => _.responseWithJsonBody.flatMap(schema.decodeUnknown))
+}
+
+/** @tsplus getter effect/platform/Http/Client demandJson */
+export const demandJson = <R, E>(client: HttpClient<R, E, ClientResponse>) =>
+  client
+    .mapRequest((_) => _.acceptJson)
+    .transform((r, request) =>
+      r.tap((response) =>
+        response.headers.get("Content-Type").value?.startsWith("application/json")
+          ? Effect.unit
+          : Effect.fail(HttpClientError.ResponseError({
+            request,
+            response,
+            reason: "Decode",
+            error: "not json response: " + response.headers.get("Content-Type").value
+          }))
+      )
+    )

package/_src/Widen.type.ts

@@ -0,0 +1,28 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { BuiltInObject } from "@effect-app/core/utils"
+
+type AllKeys<T> = T extends any ? keyof T : never
+
+type OptionalKeys<T> = T extends any // eslint-disable-next-line @typescript-eslint/ban-types
+  ? { [K in keyof T]-?: {} extends Pick<T, K> ? K : never }[keyof T]
+  : never
+
+type Idx<T, K extends PropertyKey, D = never> = T extends any ? K extends keyof T ? T[K]
+  : D
+  : never
+
+type PartialKeys<T, K extends keyof T> =
+  & Omit<T, K>
+  & Partial<Pick<T, K>> extends infer O ? { [P in keyof O]: O[P] }
+  : never
+
+export type Primitive = boolean | string | number | bigint | symbol | undefined | null
+export type Widen<T> = [T] extends [BuiltInObject] | [Primitive] ? T
+  : [T] extends [Array<unknown>] ? { [K in keyof T]: Widen<T[K]> }
+  : [T] extends [ReadonlyArray<unknown>] ? { [K in keyof T]: Widen<T[K]> }
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  : [T] extends [object] ? PartialKeys<
+      { [K in AllKeys<T>]: Widen<Idx<T, K>> },
+      Exclude<AllKeys<T>, keyof T> | OptionalKeys<T>
+    >
+  : T