effect 4.0.0-beta.43 → 4.0.0-beta.44

package/src/SchemaAST.ts

@@ -2803,21 +2803,10 @@ export function mutableKey<A extends AST>(ast: A): A {
 /** @internal */
 export function withConstructorDefault<A extends AST>(
   ast: A,
-  /**
-   * The `input` parameters is `None` if the value is not present and
-   * `Some(undefined)` if the value is present but undefined
-   */
-  defaultValue: (input: Option.Option<undefined>) => Option.Option<unknown> | Effect.Effect<Option.Option<unknown>>
+  defaultValue: Effect.Effect<unknown>
 ): A {
   const transformation = new Transformation.Transformation(
-    new Getter.Getter((o) => {
-      if (Option.isNone(Option.filter(o, Predicate.isNotUndefined))) {
-        const oe = defaultValue(o as Option.Option<undefined>)
-        return Effect.isEffect(oe) ? oe : Effect.succeed(oe)
-      } else {
-        return Effect.succeed(o)
-      }
-    }),
+    Getter.withDefault(defaultValue),
     Getter.passthrough()
   )
   const encoding: Encoding = [new Link(unknown, transformation)]
@@ -3208,7 +3197,9 @@ export function isStringBigInt(annotations?: Schema.Annotations.Filter) {
 }
 
 /** @internal */
-export const bigIntString = appendChecks(string, [isStringBigInt()])
+export const bigIntString = appendChecks(string, [isStringBigInt({
+  expected: "a string representing a bigint"
+})])
 
 const bigIntToString = new Link(
   bigIntString,

package/src/SchemaGetter.ts

@@ -38,6 +38,7 @@
  * - Parse/stringify JSON → {@link parseJson}, {@link stringifyJson}
  * - Encode/decode Base64 → {@link encodeBase64}, {@link decodeBase64}, {@link decodeBase64String}
  * - Encode/decode Hex → {@link encodeHex}, {@link decodeHex}, {@link decodeHexString}
+ * - Encode/decode URI components → {@link encodeUriComponent}, {@link decodeUriComponent}
  * - Parse DateTime → {@link dateTimeUtcFromInput}
  * - Decode/encode FormData → {@link decodeFormData}, {@link encodeFormData}
  * - Decode/encode URLSearchParams → {@link decodeURLSearchParams}, {@link encodeURLSearchParams}
@@ -670,16 +671,16 @@ export function omit<T>(): Getter<never, T> {
  * - A field may be `undefined` in the encoded input and should have a fallback.
  *
  * Behavior:
- * - If the input is `Some(undefined)` or `None`, produces `Some(defaultValue())`.
+ * - If the input is `Some(undefined)` or `None`, produces `Some(T)`.
  * - If the input is `Some(value)` where value is not `undefined`, passes it through.
- * - `defaultValue` is called lazily each time a default is needed.
+ * - `defaultValue` is an `Effect` that will be executed each time a default is needed.
  *
  * **Example** (Default value for optional field)
  *
  * ```ts
- * import { SchemaGetter } from "effect"
+ * import { Effect, SchemaGetter } from "effect"
  *
- * const withZero = SchemaGetter.withDefault(() => 0)
+ * const withZero = SchemaGetter.withDefault(Effect.succeed(0))
  * // Getter<number, number | undefined>
  * ```
  *
@@ -690,13 +691,11 @@ export function omit<T>(): Getter<never, T> {
  * @category Constructors
  * @since 4.0.0
  */
-export function withDefault<T>(defaultValue: () => T): Getter<T, T | undefined> {
-  return transformOptional((o) =>
-    o.pipe(
-      Option.filter(Predicate.isNotUndefined),
-      Option.orElseSome(defaultValue)
-    )
-  )
+export function withDefault<T>(defaultValue: Effect.Effect<T>): Getter<T, T | undefined> {
+  return new Getter((o) => {
+    const filtered = Option.filter(o, Predicate.isNotUndefined)
+    return Option.isSome(filtered) ? Effect.succeed(filtered) : Effect.map(defaultValue, Option.some)
+  })
 }
 
 /**
@@ -1456,6 +1455,65 @@ export function decodeHexString<E extends string>(): Getter<string, E> {
   )
 }
 
+/**
+ * Encodes a string using `encodeURIComponent`.
+ *
+ * Behavior:
+ * - Pure, never fails.
+ *
+ * **Example** (Encode a URI component)
+ *
+ * ```ts
+ * import { SchemaGetter } from "effect"
+ *
+ * const encode = SchemaGetter.encodeUriComponent<string>()
+ * ```
+ *
+ * See also:
+ * - {@link decodeUriComponent} - inverse operation
+ *
+ * @category URI
+ * @since 4.0.0
+ */
+export function encodeUriComponent<E extends string>(): Getter<string, E> {
+  return transform(encodeURIComponent)
+}
+
+/**
+ * Decodes a URI component encoded string using `decodeURIComponent`.
+ *
+ * Behavior:
+ * - Fails with `Issue.InvalidValue` if the input contains malformed percent-encoding sequences.
+ *
+ * **Example** (Decode a URI component)
+ *
+ * ```ts
+ * import { SchemaGetter } from "effect"
+ *
+ * const decode = SchemaGetter.decodeUriComponent<string>()
+ * // Getter<string, string>
+ * ```
+ *
+ * See also:
+ * - {@link encodeUriComponent} - inverse operation
+ *
+ * @category URI
+ * @since 4.0.0
+ */
+export function decodeUriComponent<E extends string>(): Getter<string, E> {
+  return transformOrFail((input) => {
+    try {
+      return Effect.succeed(globalThis.decodeURIComponent(input))
+    } catch (e) {
+      return Effect.fail(
+        new Issue.InvalidValue(Option.some(input), {
+          message: e instanceof URIError ? e.message : "Invalid URI component"
+        })
+      )
+    }
+  })
+}
+
 /**
  * Parses a `DateTime.Input` value (string, number, or Date) into a `DateTime.Utc`.
  *

package/src/SchemaTransformation.ts

@@ -35,10 +35,13 @@
  * - Trim/case strings → {@link trim}, {@link toLowerCase}, {@link toUpperCase}, {@link capitalize}, {@link uncapitalize}, {@link snakeToCamel}
  * - Parse key-value strings → {@link splitKeyValue}
  * - Coerce string ↔ number/bigint → {@link numberFromString}, {@link bigintFromString}
+ * - Coerce string ↔ Date → {@link dateFromString}
  * - Decode durations → {@link durationFromNanos}, {@link durationFromMillis}
  * - Wrap nullable/optional as Option → {@link optionFromNullOr}, {@link optionFromOptionalKey}, {@link optionFromOptional}
  * - Parse URLs → {@link urlFromString}
  * - Base64 ↔ Uint8Array → {@link uint8ArrayFromBase64String}
+ * - Base64 ↔ string → {@link stringFromBase64String}
+ * - URI component ↔ string → {@link stringFromUriComponent}
  * - JSON string ↔ unknown → {@link fromJsonString}
  * - FormData/URLSearchParams ↔ unknown → {@link fromFormData}, {@link fromURLSearchParams}
  * - Check if a value is a Transformation → {@link isTransformation}
@@ -86,6 +89,7 @@ import * as BigDecimal from "./BigDecimal.ts"
 import * as DateTime from "./DateTime.ts"
 import * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
+import { formatDate } from "./Formatter.ts"
 import * as Option from "./Option.ts"
 import * as Predicate from "./Predicate.ts"
 import type * as AST from "./SchemaAST.ts"
@@ -878,6 +882,39 @@ export const bigintFromString = new Transformation(
   Getter.String()
 )
 
+/**
+ * Decodes a `string` into a `Date` and encodes a `Date` back to a `string`.
+ *
+ * When to use this:
+ * - Parsing ISO 8601 date strings from APIs or user input.
+ *
+ * Behavior:
+ * - Decode: creates a `Date` from the string (like `new Date(s)`).
+ * - Encode: converts the `Date` to an ISO string (like `date.toISOString()`),
+ *   returning `"Invalid Date"` for invalid dates.
+ *
+ * **Example** (Date from string)
+ *
+ * ```ts
+ * import { Schema, SchemaTransformation } from "effect"
+ *
+ * const schema = Schema.String.pipe(
+ *   Schema.decodeTo(Schema.Date, SchemaTransformation.dateFromString)
+ * )
+ * ```
+ *
+ * See also:
+ * - {@link numberFromString}
+ * - {@link dateTimeUtcFromString}
+ *
+ * @category Coercions
+ * @since 4.0.0
+ */
+export const dateFromString: Transformation<globalThis.Date, string> = new Transformation(
+  Getter.Date(),
+  Getter.transform(formatDate)
+)
+
 /**
  * Decodes a `bigint` (nanoseconds) into a `Duration` and encodes a
  * `Duration` back to `bigint` nanoseconds.
@@ -1269,6 +1306,7 @@ export const bigDecimalFromString: Transformation<BigDecimal.BigDecimal, string>
  *
  * See also:
  * - {@link fromJsonString}
+ * - `Schema.Uint8ArrayFromBase64` - a ready-made schema wrapping this transformation.
  *
  * @since 4.0.0
  */
@@ -1277,6 +1315,134 @@ export const uint8ArrayFromBase64String: Transformation<Uint8Array<ArrayBufferLi
   Getter.encodeBase64()
 )
 
+/**
+ * Decodes a Base64-encoded `string` into a UTF-8 `string` and encodes a
+ * UTF-8 `string` back to a Base64 string.
+ *
+ * When to use this:
+ * - Handling text data transmitted as Base64 strings.
+ *
+ * Behavior:
+ * - Decode: parses the Base64 string into a UTF-8 string.
+ * - Encode: encodes the string as a Base64 string.
+ *
+ * **Example** (String from Base64)
+ *
+ * ```ts
+ * import { Schema, SchemaTransformation } from "effect"
+ *
+ * const schema = Schema.String.pipe(
+ *   Schema.decodeTo(Schema.String, SchemaTransformation.stringFromBase64String)
+ * )
+ * ```
+ *
+ * See also:
+ * - {@link uint8ArrayFromBase64String}
+ * - `Schema.StringFromBase64` - a ready-made schema wrapping this transformation.
+ *
+ * @since 4.0.0
+ */
+export const stringFromBase64String: Transformation<string, string> = new Transformation(
+  Getter.decodeBase64String(),
+  Getter.encodeBase64()
+)
+
+/**
+ * Decodes a base64 (URL) encoded `string` into a UTF-8 `string` and encodes it back.
+ *
+ * When to use this:
+ * - Handling text data transmitted as Base64 URL-safe strings.
+ *
+ * Behavior:
+ * - Decode: parses the Base64 URL string into a UTF-8 string.
+ * - Encode: encodes the string as a Base64 URL string.
+ *
+ * **Example** (String from Base64Url)
+ *
+ * ```ts
+ * import { Schema, SchemaTransformation } from "effect"
+ *
+ * const schema = Schema.String.pipe(
+ *   Schema.decodeTo(Schema.String, SchemaTransformation.stringFromBase64UrlString)
+ * )
+ * ```
+ *
+ * See also:
+ * - {@link stringFromBase64String}
+ * - `Schema.StringFromBase64Url` - a ready-made schema wrapping this transformation.
+ *
+ * @since 4.0.0
+ */
+export const stringFromBase64UrlString: Transformation<string, string> = new Transformation(
+  Getter.decodeBase64UrlString(),
+  Getter.encodeBase64Url()
+)
+
+/**
+ * Decodes a hex encoded `string` into a UTF-8 `string` and encodes it back.
+ *
+ * When to use this:
+ * - Handling text data transmitted as hexadecimal strings.
+ *
+ * Behavior:
+ * - Decode: parses the hex string into a UTF-8 string.
+ * - Encode: encodes the string as a hex string.
+ *
+ * **Example** (String from Hex)
+ *
+ * ```ts
+ * import { Schema, SchemaTransformation } from "effect"
+ *
+ * const schema = Schema.String.pipe(
+ *   Schema.decodeTo(Schema.String, SchemaTransformation.stringFromHexString)
+ * )
+ * ```
+ *
+ * See also:
+ * - {@link stringFromBase64String}
+ * - `Schema.StringFromHex` - a ready-made schema wrapping this transformation.
+ *
+ * @since 4.0.0
+ */
+export const stringFromHexString: Transformation<string, string> = new Transformation(
+  Getter.decodeHexString(),
+  Getter.encodeHex()
+)
+
+/**
+ * Decodes a URI component encoded string into a UTF-8 string and encodes a
+ * UTF-8 string into a URI component encoded string.
+ *
+ * When to use this:
+ * - Storing structured data in URL query parameters or fragments.
+ * - Composing with `Schema.parseJson` to round-trip JSON through a URL.
+ *
+ * Behavior:
+ * - Decode: calls `decodeURIComponent`. Fails if the input contains malformed
+ *   percent-encoding sequences.
+ * - Encode: calls `encodeURIComponent`.
+ *
+ * **Example** (URI component schema)
+ *
+ * ```ts
+ * import { Schema, SchemaTransformation } from "effect"
+ *
+ * const schema = Schema.String.pipe(
+ *   Schema.decodeTo(Schema.String, SchemaTransformation.stringFromUriComponent)
+ * )
+ * ```
+ *
+ * See also:
+ * - {@link stringFromBase64String}
+ * - `Schema.StringFromUriComponent` - a ready-made schema wrapping this transformation.
+ *
+ * @since 4.0.0
+ */
+export const stringFromUriComponent: Transformation<string, string> = new Transformation(
+  Getter.decodeUriComponent(),
+  Getter.encodeUriComponent()
+)
+
 /**
  * Decodes a JSON `string` into an `unknown` value and encodes an `unknown`
  * value back to a JSON string.

package/src/Scope.ts

@@ -14,10 +14,10 @@
  * @since 2.0.0
  */
 
+import type * as Context from "./Context.ts"
 import type { Effect } from "./Effect.ts"
 import type { Exit } from "./Exit.ts"
 import * as effect from "./internal/effect.ts"
-import type * as ServiceMap from "./ServiceMap.ts"
 
 const TypeId = effect.ScopeTypeId
 const CloseableTypeId = effect.ScopeCloseableTypeId
@@ -208,7 +208,7 @@ export namespace State {
  * @since 2.0.0
  * @category tags
  */
-export const Scope: ServiceMap.Service<Scope, Scope> = effect.scopeTag
+export const Scope: Context.Service<Scope, Scope> = effect.scopeTag
 
 /**
  * Creates a new `Scope` with the specified finalizer strategy.

package/src/ScopedCache.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import * as Arr from "./Array.ts"
+import * as Context from "./Context.ts"
 import * as Deferred from "./Deferred.ts"
 import * as Duration from "./Duration.ts"
 import type * as Effect from "./Effect.ts"
@@ -16,7 +17,6 @@ import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
 import * as Scope from "./Scope.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 
 const TypeId = "~effect/ScopedCache"
 
@@ -76,13 +76,13 @@ export const makeWith = <
   never,
   ("lookup" extends ServiceMode ? never : R) | Scope.Scope
 > =>
-  effect.servicesWith((services: ServiceMap.ServiceMap<any>) => {
-    const scope = ServiceMap.get(services, Scope.Scope)
+  effect.contextWith((context: Context.Context<any>) => {
+    const scope = Context.get(context, Scope.Scope)
     const self = Object.create(Proto)
     self.lookup = (key: Key): Effect.Effect<A, E> =>
-      effect.updateServices(
+      effect.updateContext(
         options.lookup(key),
-        (input) => ServiceMap.merge(services, input)
+        (input) => Context.merge(context, input)
       )
     const map = MutableHashMap.empty<Key, Entry<A, E>>()
     self.state = { _tag: "Open", map }

package/src/Sink.ts

@@ -6,6 +6,7 @@ import * as Arr from "./Array.ts"
 import * as Cause from "./Cause.ts"
 import * as Channel from "./Channel.ts"
 import * as Clock from "./Clock.ts"
+import type * as Context from "./Context.ts"
 import * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
@@ -22,7 +23,6 @@ import * as Pull from "./Pull.ts"
 import * as Queue from "./Queue.ts"
 import * as Result from "./Result.ts"
 import * as Scope from "./Scope.ts"
-import type * as ServiceMap from "./ServiceMap.ts"
 import type { Stream } from "./Stream.ts"
 import type * as Types from "./Types.ts"
 import type * as Unify from "./Unify.ts"
@@ -1807,24 +1807,24 @@ export const timed: Sink<Duration.Duration, unknown> = map(withDuration(drain),
  * @since 4.0.0
  * @category Services
  */
-export const provideServices: {
+export const provideContext: {
   /**
    * @since 4.0.0
    * @category Services
    */
-  <Provided>(services: ServiceMap.ServiceMap<Provided>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, Exclude<R, Provided>>
+  <Provided>(context: Context.Context<Provided>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, Exclude<R, Provided>>
   /**
    * @since 4.0.0
    * @category Services
    */
-  <A, In, L, E, R, Provided>(self: Sink<A, In, L, E, R>, services: ServiceMap.ServiceMap<Provided>): Sink<A, In, L, E, Exclude<R, Provided>>
+  <A, In, L, E, R, Provided>(self: Sink<A, In, L, E, R>, context: Context.Context<Provided>): Sink<A, In, L, E, Exclude<R, Provided>>
 } = dual(2, <A, In, L, E, R, Provided>(
   self: Sink<A, In, L, E, R>,
-  services: ServiceMap.ServiceMap<Provided>
+  context: Context.Context<Provided>
 ): Sink<A, In, L, E, Exclude<R, Provided>> =>
   fromTransform((upstream, scope) =>
     self.transform(upstream, scope).pipe(
-      Effect.provideServices(services)
+      Effect.provideContext(context)
     )
   ))
 
@@ -1837,19 +1837,19 @@ export const provideService: {
    * @since 4.0.0
    * @category Services
    */
-  <I, S>(key: ServiceMap.Key<I, S>, value: Types.NoInfer<S>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, Exclude<R, I>>
+  <I, S>(key: Context.Key<I, S>, value: Types.NoInfer<S>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, Exclude<R, I>>
   /**
    * @since 4.0.0
    * @category Services
    */
   <A, In, L, E, R, I, S>(
     self: Sink<A, In, L, E, R>,
-    key: ServiceMap.Key<I, S>,
+    key: Context.Key<I, S>,
     value: Types.NoInfer<S>
   ): Sink<A, In, L, E, Exclude<R, I>>
 } = dual(3, <A, In, L, E, R, I, S>(
   self: Sink<A, In, L, E, R>,
-  key: ServiceMap.Key<I, S>,
+  key: Context.Key<I, S>,
   value: Types.NoInfer<S>
 ): Sink<A, In, L, E, Exclude<R, I>> =>
   fromTransform((upstream, scope) =>

package/src/Stdio.ts

@@ -1,10 +1,10 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "./Context.ts"
 import * as Effect from "./Effect.ts"
 import * as Layer from "./Layer.ts"
 import type { PlatformError } from "./PlatformError.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 import * as Sink from "./Sink.ts"
 import * as Stream from "./Stream.ts"
 
@@ -39,7 +39,7 @@ export interface Stdio {
  * @since 4.0.0
  * @category Services
  */
-export const Stdio: ServiceMap.Service<Stdio, Stdio> = ServiceMap.Service<Stdio>(TypeId)
+export const Stdio: Context.Service<Stdio, Stdio> = Context.Service<Stdio>(TypeId)
 
 /**
  * @since 4.0.0