effect-app 4.0.0-beta.99 → 4.0.1

package/src/utils.ts

@@ -1,20 +1,24 @@
 /* eslint-disable @typescript-eslint/no-unsafe-function-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-redundant-type-constituents */
-import { Cause, Effect, Exit, Fiber, Option, Record } from "effect"
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as Fiber from "effect/Fiber"
 import { dual } from "effect/Function"
-import { isFunction, isObject } from "effect/Predicate"
+import * as Option from "effect/Option"
+import { isFunction } from "effect/Predicate"
+import * as Record from "effect/Record"
 import * as Result from "effect/Result"
-import type { GetFieldType, NumericDictionary, PropertyPath } from "lodash"
-import { identity, pipe } from "./Function.js"
-import type { DeepMutable, Equals, Mutable } from "./Types.js"
+import { identity, pipe } from "./Function.ts"
+import type { DeepMutable, Equals, Mutable } from "./Types.ts"
 
 // codegen:start {preset: barrel, include: ./utils/*.ts, nodir: false }
-export * from "./utils/effectify.js"
-export * from "./utils/extend.js"
-export * from "./utils/gen.js"
-export * from "./utils/logger.js"
-export * from "./utils/logLevel.js"
+export * from "./utils/effectify.ts"
+export * from "./utils/extend.ts"
+export * from "./utils/gen.ts"
+export * from "./utils/logger.ts"
+export * from "./utils/logLevel.ts"
 // codegen:end
 
 export * from "effect/Utils"
@@ -24,121 +28,6 @@ export interface Clone {
   [cloneTrait](this: this, that: any): this
 }
 
-function get<TObject extends object, TKey extends keyof TObject>(object: TObject, path: TKey | [TKey]): TObject[TKey]
-function get<TObject extends object, TKey extends keyof TObject>(
-  object: TObject | null | undefined,
-  path: TKey | [TKey]
-): TObject[TKey] | undefined
-function get<TObject extends object, TKey extends keyof TObject, TDefault>(
-  object: TObject | null | undefined,
-  path: TKey | [TKey],
-  defaultValue: TDefault
-): Exclude<TObject[TKey], undefined> | TDefault
-function get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(
-  object: TObject,
-  path: [TKey1, TKey2]
-): TObject[TKey1][TKey2]
-function get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(
-  object: TObject | null | undefined,
-  path: [TKey1, TKey2]
-): TObject[TKey1][TKey2] | undefined
-function get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TDefault>(
-  object: TObject | null | undefined,
-  path: [TKey1, TKey2],
-  defaultValue: TDefault
-): Exclude<TObject[TKey1][TKey2], undefined> | TDefault
-function get<
-  TObject extends object,
-  TKey1 extends keyof TObject,
-  TKey2 extends keyof TObject[TKey1],
-  TKey3 extends keyof TObject[TKey1][TKey2]
->(object: TObject, path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3]
-function get<
-  TObject extends object,
-  TKey1 extends keyof TObject,
-  TKey2 extends keyof TObject[TKey1],
-  TKey3 extends keyof TObject[TKey1][TKey2]
->(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3] | undefined
-function get<
-  TObject extends object,
-  TKey1 extends keyof TObject,
-  TKey2 extends keyof TObject[TKey1],
-  TKey3 extends keyof TObject[TKey1][TKey2],
-  TDefault
->(
-  object: TObject | null | undefined,
-  path: [TKey1, TKey2, TKey3],
-  defaultValue: TDefault
-): Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault
-function get<
-  TObject extends object,
-  TKey1 extends keyof TObject,
-  TKey2 extends keyof TObject[TKey1],
-  TKey3 extends keyof TObject[TKey1][TKey2],
-  TKey4 extends keyof TObject[TKey1][TKey2][TKey3]
->(object: TObject, path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4]
-function get<
-  TObject extends object,
-  TKey1 extends keyof TObject,
-  TKey2 extends keyof TObject[TKey1],
-  TKey3 extends keyof TObject[TKey1][TKey2],
-  TKey4 extends keyof TObject[TKey1][TKey2][TKey3]
->(
-  object: TObject | null | undefined,
-  path: [TKey1, TKey2, TKey3, TKey4]
-): TObject[TKey1][TKey2][TKey3][TKey4] | undefined
-function get<
-  TObject extends object,
-  TKey1 extends keyof TObject,
-  TKey2 extends keyof TObject[TKey1],
-  TKey3 extends keyof TObject[TKey1][TKey2],
-  TKey4 extends keyof TObject[TKey1][TKey2][TKey3],
-  TDefault
->(
-  object: TObject | null | undefined,
-  path: [TKey1, TKey2, TKey3, TKey4],
-  defaultValue: TDefault
-): Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault
-function get<T>(object: NumericDictionary<T>, path: number): T
-function get<T>(object: NumericDictionary<T> | null | undefined, path: number): T | undefined
-function get<T, TDefault>(
-  object: NumericDictionary<T> | null | undefined,
-  path: number,
-  defaultValue: TDefault
-): T | TDefault
-function get<TDefault>(object: null | undefined, path: PropertyPath, defaultValue: TDefault): TDefault
-function get(object: null | undefined, path: PropertyPath): undefined
-function get<TObject, TPath extends string>(
-  data: TObject,
-  path: TPath
-): string extends TPath ? any : GetFieldType<TObject, TPath>
-function get<TObject, TPath extends string, TDefault = GetFieldType<TObject, TPath>>(
-  data: TObject,
-  path: TPath,
-  defaultValue: TDefault
-): Exclude<GetFieldType<TObject, TPath>, null | undefined> | TDefault
-function get(object: any, path: PropertyPath, defaultValue?: any): any
-function get(obj: any, path: any, defaultValue = undefined) {
-  // https://github.com/you-dont-need/You-Dont-Need-Lodash-Underscore?tab=readme-ov-file#_get
-  const travel = (regexp: any) =>
-    String
-      .prototype
-      .split
-      .call(path, regexp)
-      .filter(Boolean)
-      .reduce((res, key) => (res !== null && res !== undefined ? res[key] : res), obj)
-  const result = travel(/[,[\]]+?/) || travel(/[,[\].]+?/)
-  return result === undefined || result === obj ? defaultValue : result
-}
-
-// codegen:start {preset: barrel, include: ./utils/*.ts }
-export * from "./utils/effectify.js"
-export * from "./utils/extend.js"
-export * from "./utils/gen.js"
-export * from "./utils/logger.js"
-export * from "./utils/logLevel.js"
-// codegen:end
-
 export const unsafeRight = <E, A>(ei: Result.Result<A, E>) => {
   if (Result.isFailure(ei)) {
     console.error(ei.failure)
@@ -158,11 +47,6 @@ export function toString(v: unknown) {
   return `${v}`
 }
 
-export const typedKeysOf = <T extends {}>(obj: T) => Object.keys(obj) as (keyof T)[]
-// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-export const typedValuesOf = <T extends {}>(obj: T) => Object.values(obj) as ValueOf<T>[]
-type ValueOf<T> = T[keyof T]
-
 export type Constructor<T = any> = { new(...args: any[]): T }
 export type ThenArg<T> = T extends Promise<infer U> ? U
   : T extends (...args: any[]) => Promise<infer V> ? V
@@ -244,14 +128,6 @@ export function dropUndefined<A>(
 type GetTag<T> = T extends { _tag: infer K } ? K : never
 export const isOfType = <T extends { _tag: string }>(tag: GetTag<T>) => (e: { _tag: string }): e is T => e._tag === tag
 
-export function capitalize<T extends string>(string: T): Capitalize<T> {
-  return (string.charAt(0).toUpperCase() + string.slice(1)) as Capitalize<T>
-}
-
-export function uncapitalize<T extends string>(string: T): Uncapitalize<T> {
-  return (string.charAt(0).toLowerCase() + string.slice(1)) as Uncapitalize<T>
-}
-
 export function pretty(o: unknown): string {
   return JSON.stringify(o, undefined, 2) ?? "undefined"
 }
@@ -269,7 +145,7 @@ export type EnforceNonEmptyRecord<R> = keyof R extends never ? never : R
 export function intersect<AS extends unknown[] & { 0: unknown }>(
   ...as: AS
 ): UnionToIntersection<{ [k in keyof AS]: AS[k] }[number]> {
-  return as.reduce((a: any, b: any) => ({ ...a, ...b })) as any
+  return as.reduce((a: any, b: any) => Object.assign(a, b), {}) as any
 }
 
 export type IsEqualTo<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
@@ -280,8 +156,7 @@ export type IsEqualTo<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
 export const unifyIndex = Symbol()
 export type unifyIndex = typeof unifyIndex
 
-// @ts-expect-error abc
-export interface UnifiableIndexed<X> {}
+export interface UnifiableIndexed<_X> {}
 export type UnifiableIndexedURI = keyof UnifiableIndexed<any>
 
 export interface Unifiable<X> {
@@ -313,9 +188,7 @@ function decorateNew(
   if (out.descriptor) {
     out.descriptor = Object.assign({}, out.descriptor)
   }
-  const actualDesc: PropertyDescriptor = <any> (
-    out.descriptor || /* istanbul ignore next */ out
-  )
+  const actualDesc: PropertyDescriptor = out.descriptor || /* istanbul ignore next */ out
 
   const originalMethod = validateAndExtractMethodFromDescriptor(actualDesc)
   const isStatic = inp.placement === "static"
@@ -342,7 +215,7 @@ function decorateNew(
 function decorateLegacy(
   target: any,
   key: PropertyKey,
-  descriptor: PropertyDescriptor,
+  descriptor: PropertyDescriptor | undefined,
   setProto: boolean,
   makeNonConfigurable: boolean,
   // tslint:enable:bool-param-default
@@ -350,11 +223,12 @@ function decorateLegacy(
 ): PropertyDescriptor {
   /* istanbul ignore if */
   if (!descriptor) {
-    descriptor = <any> Object.getOwnPropertyDescriptor(target, key)
+    descriptor = Object.getOwnPropertyDescriptor(target, key)
     if (!descriptor) {
-      const e = new Error("@LazyGetter is unable to determine the property descriptor")
-      ;(<any> e).$target = target
-      ;(<any> e).$key = key
+      const e = Object.assign(new Error("@LazyGetter is unable to determine the property descriptor"), {
+        $key: key,
+        $target: target
+      })
       throw e
     }
   }
@@ -409,7 +283,7 @@ function defaultFilter(): boolean {
 
 function validateAndExtractMethodFromDescriptor(desc: PropertyDescriptor): Function {
   // eslint-disable-next-line @typescript-eslint/unbound-method
-  const originalMethod = <Function> desc.get
+  const originalMethod = desc.get
 
   if (!originalMethod) {
     throw new Error("@LazyGetter can only decorate getters!")
@@ -432,7 +306,7 @@ function getterCommon( // tslint:disable-line:parameters-max-number
   makeNonConfigurable: boolean,
   resultSelector: ResultSelectorFn
 ): any {
-  const value = originalMethod.apply(thisArg, <any> args)
+  const value = originalMethod.apply(thisArg, args)
 
   if (resultSelector(value)) {
     const newDescriptor: PropertyDescriptor = {
@@ -467,23 +341,23 @@ export function LazyGetter(
 ): MethodDecorator & ResettableDescriptor {
   let desc: PropertyDescriptor
   let prop: PropertyKey
-  let args: IArguments = <any> null
+  let args: [targetOrDesc: any, key: PropertyKey | undefined, descriptor: PropertyDescriptor | undefined] | undefined
   let isLegacy: boolean
 
   function decorator(
     targetOrDesc: any,
-    key: PropertyKey,
-    descriptor: PropertyDescriptor
+    key: PropertyKey | undefined,
+    descriptor: PropertyDescriptor | undefined
   ): DecoratorReturn {
-    // eslint-disable-next-line prefer-rest-params
-    args = arguments
+    args = [targetOrDesc, key, descriptor]
     if (key === undefined) {
       if (typeof desc === "undefined") {
+        const newDescriptor = targetOrDesc as NewDescriptor
         isLegacy = false
-        prop = (<NewDescriptor> targetOrDesc).key
+        prop = newDescriptor.key
         desc = Object.assign(
           {},
-          (<NewDescriptor> targetOrDesc).descriptor
+          newDescriptor.descriptor
             /* istanbul ignore next */ || targetOrDesc
         )
       }
@@ -525,11 +399,14 @@ export function LazyGetter(
           "Unable to restore descriptor. Did you remember to apply your decorator to a method?"
         )
       }
+      if (!args) {
+        throw new Error("Unable to restore descriptor before applying the decorator.")
+      }
       // Restore descriptor to its original state
       Object.defineProperty(on, prop, desc)
-      // eslint-disable-next-line prefer-spread
-      const ret: any = decorator.apply(null, <any> args)
-      Object.defineProperty(on, prop, isLegacy ? ret : ret.descriptor || ret)
+      const ret = decorator.apply(null, args)
+      const restoredDescriptor = isLegacy ? ret : "descriptor" in ret && ret.descriptor ? ret.descriptor : ret
+      Object.defineProperty(on, prop, restoredDescriptor)
     }
 
   return decorator
@@ -675,16 +552,12 @@ export function exhaustiveMatch_<T extends string>(t: T) {
   return <Out extends Record<T, (t: T) => any>>(handlers: Out): ReturnType<Out[keyof Out]> => handlers[t](t)
 }
 
-export function assertUnreachable(x: never): never {
-  throw new Error("Unknown case " + x)
-}
-
 export type OptPromise<T extends () => any> = (
   ...args: Parameters<T>
 ) => Promise<ReturnType<T>> | ReturnType<T>
 
 export function access<T extends string, T2>(t: Record<T, T2>) {
-  return (key: T) => t[key] as T2
+  return (key: T) => t[key]
 }
 
 export function todayAtUTCNoon() {
@@ -736,25 +609,64 @@ export const copy = dual<
   }
 >(2, <A>(self: A, f: Partial<A> | ((a: A) => Partial<A>)) => clone(self, { ...self, ...(isFunction(f) ? f(self) : f) }))
 
-type CopyOriginU<U, Ctor extends new(...args: any[]) => any> =
+export type CopyOriginU<U, Ctor extends new(...args: any[]) => any> =
   & {
     [K in keyof U & keyof InstanceType<Ctor>]?: U[K]
   }
   & {}
 
-type CopyOriginRet<A, U> =
+export type CopyOriginRet<A, U> =
   & {
     [K in keyof A | keyof U]: K extends keyof U ? U[K] : A[K & keyof A]
   }
   & {}
 
-type CopyOriginSelf<A, U> = Equals<{}, U> extends true
+export type CopyOriginSelf<A, U> = Equals<{}, U> extends true
   ? Equals<keyof {}, keyof U> extends true ? `updates argument is empty or contains only extra properties`
   : A
   : A
 
+export interface StructuralCopyOrigin<Self extends object> {
+  <A extends Self, U extends Partial<Self>>(
+    f: (a: A) =>
+      & {
+        [K in keyof U & keyof Self]?: U[K]
+      }
+      & {}
+  ): (self: CopyOriginSelf<A, U>) => CopyOriginRet<A, U>
+  <A extends Self, U extends Partial<Self>>(
+    updates:
+      & {
+        [K in keyof U & keyof Self]?: U[K]
+      }
+      & {}
+  ): (self: CopyOriginSelf<A, U>) => CopyOriginRet<A, U>
+  <A extends Self, U extends Partial<Self>>(
+    self: CopyOriginSelf<A, U>,
+    f: (a: A) =>
+      & {
+        [K in keyof U & keyof Self]?: U[K]
+      }
+      & {}
+  ): CopyOriginRet<A, U>
+  <A extends Self, U extends Partial<Self>>(
+    self: CopyOriginSelf<A, U>,
+    updates:
+      & {
+        [K in keyof U & keyof Self]?: U[K]
+      }
+      & {}
+  ): CopyOriginRet<A, U>
+}
+
 // just one input param: the convention is that the ctor takes an object
-// containing the properties of the class (I can't put object there as type because of contravariance)
+// containing the properties of the value (I can't put object there as type because of contravariance)
+/**
+ * By design this does not return `Self` directly.
+ *
+ * The return type is computed from `Self` and the update payload so callers can
+ * expose an explicit structural return type that remains assignable to `Self`.
+ */
 export const copyOrigin = <Ctor extends new(_: any) => any>(ctor: Ctor) =>
   dual<
     {
@@ -883,8 +795,6 @@ export function setMoveElDropUndefined<T>(el: T, newIndex: number) {
     pipe([...arrInput], arMoveElDropUndefined(el, newIndex), Option.map((ar) => new Set(ar)))
 }
 
-export { get }
-
 type RemoveNonArray<T> = T extends readonly any[] ? T : never
 export function isNativeTuple<A>(a: A): a is RemoveNonArray<A> {
   return Array.isArray(a)
@@ -956,7 +866,7 @@ const genConstructor = (function*() {}).constructor
 /**
  * @example
  * ```ts
- * import { Utils } from "effect"
+ * import * as Utils from "effect/Utils"
  *
  * function* generatorFn() {
  *   yield 1
@@ -970,5 +880,5 @@ const genConstructor = (function*() {}).constructor
  * @category predicates
  * @since 3.11.0
  */
-export const isGeneratorFunction = (u: unknown): u is (...args: Array<any>) => Generator<any, any, any> =>
-  isObject(u) && u.constructor === genConstructor
+export const isGeneratorFunction = (u: unknown): u is (...args: Array<any>) => Generator<any> =>
+  isFunction(u) && u.constructor === genConstructor

package/src/validation.ts

@@ -1,4 +1,4 @@
-import type { Predicate } from "./Function.js"
+import type { Predicate } from "./Function.ts"
 
 export const all_ = <T>(v: T, ...a: Predicate<T>[]) => !a.some((x) => !x(v))
 export const all = <T>(...a: Predicate<T>[]) => (v: T) => all_(v, ...a)
@@ -15,4 +15,4 @@ export const min = (min: number) => {
   return (v: { length: number }) => f(v.length)
 }
 
-export * from "./validation/validators.js"
+export * from "./validation/validators.ts"

package/src/withToast.ts

@@ -0,0 +1,133 @@
+import * as Cause from "effect/Cause"
+import * as Fiber from "effect/Fiber"
+import * as Context from "./Context.ts"
+import * as Effect from "./Effect.ts"
+import * as Layer from "./Layer.ts"
+import type * as Option from "./Option.ts"
+import * as S from "./Schema.ts"
+import { CurrentToastId, Toast, type ToastId } from "./toast.ts"
+import { wrapEffect } from "./utils.ts"
+
+export interface ToastOptions<A, E, Args extends ReadonlyArray<unknown>, WaiR, SucR, ErrR> {
+  stableToastId?: undefined | string | ((...args: Args) => string | undefined)
+  timeout?: number
+  showSpanInfo?: false
+  groupId?: string
+  onWaiting:
+    | string
+    | ((...args: Args) => string | null)
+    | null
+    | ((
+      ...args: Args
+    ) => Effect.Effect<string | null, never, WaiR>)
+  onSuccess:
+    | string
+    | ((a: A, ...args: Args) => string | null)
+    | null
+    | ((
+      a: A,
+      ...args: Args
+    ) => Effect.Effect<string | null, never, SucR>)
+  onFailure:
+    | string
+    | ((
+      error: Option.Option<E>,
+      ...args: Args
+    ) => string | { level: "warn" | "error"; message: string })
+    | ((
+      error: Option.Option<E>,
+      ...args: Args
+    ) => Effect.Effect<string | { level: "warn" | "error"; message: string }, never, ErrR>)
+}
+
+// @effect-diagnostics-next-line missingEffectServiceDependency:off
+export class WithToast extends Context.Service<WithToast>()("WithToast", {
+  make: Effect.gen(function*() {
+    const toast = yield* Toast
+    return <A, E, Args extends readonly unknown[], R, WaiR = never, SucR = never, ErrR = never>(
+      options: ToastOptions<A, E, Args, WaiR, SucR, ErrR>
+    ) =>
+      Effect.fnUntraced(function*(self: Effect.Effect<A, E, R>, ...args: Args) {
+        const baseTimeout = options.timeout ?? 3_000
+
+        const stableToastId = typeof options.stableToastId === "function"
+          ? options.stableToastId(...args)
+          : options.stableToastId
+
+        const requestId: string = yield* Effect.currentSpan.pipe(
+          Effect.map((span) => span.traceId),
+          Effect.orElseSucceed(() => S.StringId.make())
+        )
+        const groupId = options.groupId
+        const meta = { ...(groupId !== undefined ? { groupId } : {}), requestId }
+
+        const t = yield* wrapEffect(options.onWaiting)(...args)
+        const toastId: ToastId | undefined = t === null
+          ? stableToastId
+          : stableToastId ?? `wait-${Math.random().toString(36).slice(2)}`
+
+        const waitingFiber = t === null ? undefined : yield* Effect.forkChild(
+          Effect.sleep("1 seconds").pipe(
+            Effect.andThen(toast.info(t, { id: toastId!, timeout: Infinity, ...meta }))
+          )
+        )
+        const interruptWaiting = waitingFiber ? Fiber.interrupt(waitingFiber) : Effect.void
+
+        return yield* self.pipe(
+          Effect.tap(Effect.fnUntraced(function*(a) {
+            yield* interruptWaiting
+            const t = yield* wrapEffect(options.onSuccess)(a, ...args)
+            if (t === null) {
+              return
+            }
+            yield* toast.success(
+              t,
+              toastId !== undefined
+                ? { id: toastId, timeout: baseTimeout, ...meta }
+                : { timeout: baseTimeout, ...meta }
+            )
+          })),
+          Effect.tapCause(Effect.fnUntraced(function*(cause) {
+            yield* interruptWaiting
+            yield* Effect.logDebug(
+              "WithToast - caught error cause: " + Cause.squash(cause),
+              Cause.hasInterruptsOnly(cause),
+              cause
+            )
+
+            if (Cause.hasInterruptsOnly(cause)) {
+              if (toastId) yield* toast.dismiss(toastId)
+              return
+            }
+
+            const spanInfo = options.showSpanInfo !== false
+              ? yield* Effect.currentSpan.pipe(
+                Effect.map((span) => `\nTrace: ${span.traceId}\nSpan: ${span.spanId}`),
+                Effect.orElseSucceed(() => "")
+              )
+              : ""
+
+            const t = yield* wrapEffect(options.onFailure)(Cause.findErrorOption(cause), ...args)
+            const opts = { timeout: baseTimeout * 2, ...meta }
+
+            if (typeof t === "object") {
+              const message = t.message + spanInfo
+              return t.level === "warn"
+                ? yield* toast.warning(message, toastId !== undefined ? { ...opts, id: toastId } : opts)
+                : yield* toast.error(message, toastId !== undefined ? { ...opts, id: toastId } : opts)
+            }
+            yield* toast.error(t + spanInfo, toastId !== undefined ? { ...opts, id: toastId } : opts)
+          }, Effect.uninterruptible)),
+          toastId !== undefined ? Effect.provideService(CurrentToastId, CurrentToastId.of({ toastId })) : (_) => _
+        )
+      })
+  })
+}) {
+  static readonly DefaultWithoutDependencies = Layer.effect(this, this.make)
+  static readonly Default = this.DefaultWithoutDependencies
+
+  static readonly handle = <A, E, Args extends Array<unknown>, R, WaiR = never, SucR = never, ErrR = never>(
+    options: ToastOptions<A, E, Args, WaiR, SucR, ErrR>
+  ): (self: Effect.Effect<A, E, R>, ...args: Args) => Effect.Effect<A, E, R | WaiR | SucR | ErrR | WithToast> =>
+  (self, ...args) => this.use((_) => _<A, E, Args, R, WaiR, SucR, ErrR>(options)(self, ...args))
+}

package/test/dateTimeLocal.test.ts

@@ -0,0 +1,55 @@
+import { makeZonedLocal, pipeZonedLocal } from "effect-app/DateTime"
+import * as DateTime from "effect/DateTime"
+import { describe, expect, test } from "vitest"
+
+describe("local Date helpers", () => {
+  const start = new Date("2024-03-09T17:00:00.000Z")
+
+  test("makeZonedLocal keeps the instant and uses the process zone", () => {
+    const zoned = makeZonedLocal(start)
+    expect(zoned.epochMilliseconds).toBe(start.getTime())
+    expect(DateTime.zoneToString(zoned.zone)).toBe(DateTime.zoneToString(DateTime.zoneMakeLocal()))
+  })
+
+  test("pipeZonedLocal adds a local calendar day and returns the instant", () => {
+    const expected = new Date(start.getTime())
+    expected.setDate(expected.getDate() + 1)
+    expect(pipeZonedLocal(start, DateTime.add({ days: 1 })).getTime()).toBe(expected.getTime())
+  })
+
+  test("pipeZonedLocal runs every step before toDateUtc", () => {
+    const expected = new Date(start.getTime())
+    expected.setDate(expected.getDate() + 1)
+    expected.setMonth(expected.getMonth() + 1)
+    const result = pipeZonedLocal(start, DateTime.add({ days: 1 }), DateTime.add({ months: 1 }))
+    expect(result.getTime()).toBe(expected.getTime())
+  })
+
+  test("pipeZonedLocal accepts as many functions as pipe", () => {
+    const keep = <A extends DateTime.DateTime>(self: A) => self
+    const expected = new Date(start.getTime())
+    expected.setDate(expected.getDate() + 1)
+    const result = pipeZonedLocal(
+      start,
+      keep,
+      keep,
+      keep,
+      keep,
+      keep,
+      keep,
+      keep,
+      keep,
+      keep,
+      keep,
+      keep,
+      keep,
+      keep,
+      keep,
+      keep,
+      keep,
+      keep,
+      DateTime.add({ days: 1 })
+    )
+    expect(result.getTime()).toBe(expected.getTime())
+  })
+})

package/test/dist/dateTimeLocal.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dateTimeLocal.test.d.ts","sourceRoot":"","sources":["../dateTimeLocal.test.ts"],"names":[],"mappings":""}

package/test/dist/nativeEffectMigration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nativeEffectMigration.test.d.ts","sourceRoot":"","sources":["../nativeEffectMigration.test.ts"],"names":[],"mappings":""}

package/test/dist/rpc.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAErF,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAE7C,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKL,qBAAa,KAAM,SAAQ,UAQzB;CAAG"}
+{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACrF,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAE7C,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAI0B,KAAK;;;;AAKpC,qBAAa,KAAM,SAAQ,UAQzB;CAAG"}

package/test/dist/rpcMiddlewareContext.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpcMiddlewareContext.test.d.ts","sourceRoot":"","sources":["../rpcMiddlewareContext.test.ts"],"names":[],"mappings":""}