effect 3.10.14 → 3.10.16

package/dist/esm/internal/version.js

@@ -1,4 +1,4 @@
-let moduleVersion = "3.10.14";
+let moduleVersion = "3.10.16";
 export const getCurrentVersion = () => moduleVersion;
 export const setCurrentVersion = version => {
   moduleVersion = version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "3.10.14",
+  "version": "3.10.16",
   "description": "The missing standard library for TypeScript, for writing production-grade software.",
   "license": "MIT",
   "repository": {

package/src/DateTime.ts

@@ -480,15 +480,21 @@ export const unsafeMake = <A extends DateTime.Input>(input: A): DateTime.Preserv
  *
  * DateTime.unsafeMakeZoned(new Date(), { timeZone: "Europe/London" })
  */
-export const unsafeMakeZoned = (input: DateTime.Input, options: {
-  readonly timeZone: number | string | TimeZone
+export const unsafeMakeZoned = (input: DateTime.Input, options?: {
+  readonly timeZone?: number | string | TimeZone | undefined
   readonly adjustForTimeZone?: boolean | undefined
 }): Zoned => {
+  if (options?.timeZone === undefined && isDateTime(input) && isZoned(input)) {
+    return input
+  }
   const self = unsafeMake(input)
   let zone: TimeZone
-  if (isTimeZone(options.timeZone)) {
+  if (options?.timeZone === undefined) {
+    const offset = new Date(self.epochMillis).getTimezoneOffset() * -60 * 1000
+    zone = zoneMakeOffset(offset)
+  } else if (isTimeZone(options?.timeZone)) {
     zone = options.timeZone
-  } else if (typeof options.timeZone === "number") {
+  } else if (typeof options?.timeZone === "number") {
     zone = zoneMakeOffset(options.timeZone)
   } else {
     const parsedZone = zoneFromString(options.timeZone)
@@ -497,7 +503,7 @@ export const unsafeMakeZoned = (input: DateTime.Input, options: {
     }
     zone = parsedZone.value
   }
-  if (options.adjustForTimeZone !== true) {
+  if (options?.adjustForTimeZone !== true) {
     return makeZonedProto(self.epochMillis, zone, self.partsUtc)
   }
   return makeZonedFromAdjusted(self.epochMillis, zone)
@@ -519,12 +525,11 @@ export const unsafeMakeZoned = (input: DateTime.Input, options: {
  */
 export const makeZoned: (
   input: DateTime.Input,
-  options: {
-    readonly timeZone: number | string | TimeZone
+  options?: {
+    readonly timeZone?: number | string | TimeZone | undefined
     readonly adjustForTimeZone?: boolean | undefined
   }
-) => Option.Option<Zoned> = Option
-  .liftThrowable(unsafeMakeZoned)
+) => Option.Option<Zoned> = Option.liftThrowable(unsafeMakeZoned)
 
 /**
  * Create a `DateTime` from one of the following:

package/src/JSONSchema.ts

@@ -600,7 +600,26 @@ const go = (
       // the 'to' side of the AST. This approach prevents the generation of useless schemas
       // derived from the 'from' side (type: string), ensuring the output matches the intended
       // complex schema type.
-      const next = isParseJsonTransformation(ast.from) ? ast.to : ast.from
+      if (isParseJsonTransformation(ast.from)) {
+        return go(ast.to, $defs, true, path)
+      }
+      let next = ast.from
+      if (AST.isTypeLiteralTransformation(ast.transformation)) {
+        // Annotations from the transformation are applied unless there are user-defined annotations on the form side,
+        // ensuring that the user's intended annotations are included in the generated schema.
+        const identifier = AST.getIdentifierAnnotation(ast)
+        if (Option.isSome(identifier) && Option.isNone(AST.getIdentifierAnnotation(next))) {
+          next = AST.annotations(next, { [AST.IdentifierAnnotationId]: identifier.value })
+        }
+        const title = AST.getTitleAnnotation(ast)
+        if (Option.isSome(title) && Option.isNone(AST.getTitleAnnotation(next))) {
+          next = AST.annotations(next, { [AST.TitleAnnotationId]: title.value })
+        }
+        const description = AST.getDescriptionAnnotation(ast)
+        if (Option.isSome(description) && Option.isNone(AST.getDescriptionAnnotation(next))) {
+          next = AST.annotations(next, { [AST.DescriptionAnnotationId]: description.value })
+        }
+      }
       return go(next, $defs, true, path)
     }
   }

package/src/ParseResult.ts

@@ -854,7 +854,7 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
           const result = flatMap(
             orElse(from(i, options), (ef) => {
               const issue = new Refinement(ast, i, "From", ef)
-              if (allErrors && AST.hasStableFilter(ast)) {
+              if (allErrors && AST.hasStableFilter(ast) && isComposite(ef)) {
                 return Option.match(
                   ast.filter(i, options, ast),
                   {

package/src/Schema.ts

@@ -2677,8 +2677,8 @@ const getDefaultTypeLiteralAST = <
         })
       }
       return new AST.Transformation(
-        new AST.TypeLiteral(from, issFrom, { [AST.TitleAnnotationId]: "Struct (Encoded side)" }),
-        new AST.TypeLiteral(to, issTo, { [AST.TitleAnnotationId]: "Struct (Type side)" }),
+        new AST.TypeLiteral(from, issFrom, { [AST.AutoTitleAnnotationId]: "Struct (Encoded side)" }),
+        new AST.TypeLiteral(to, issTo, { [AST.AutoTitleAnnotationId]: "Struct (Type side)" }),
         new AST.TypeLiteralTransformation(transformations)
       )
     }
@@ -8228,7 +8228,7 @@ export interface Class<Self, Fields extends Struct.Fields, I, R, C, Inherited, P
   new(
     props: RequiredKeys<C> extends never ? void | Simplify<C> : Simplify<C>,
     options?: MakeOptions
-  ): Struct.Type<Fields> & Omit<Inherited, keyof Fields> & Proto
+  ): Struct.Type<Fields> & Inherited & Proto
 
   /** @since 3.10.0 */
   readonly ast: AST.Transformation
@@ -8588,15 +8588,6 @@ const extendFields = (a: Struct.Fields, b: Struct.Fields): Struct.Fields => {
   return out
 }
 
-// does not overwrite existing title annotation
-const orElseTitleAnnotation = <A, I, R>(schema: Schema<A, I, R>, title: string): Schema<A, I, R> => {
-  const annotation = AST.getTitleAnnotation(schema.ast)
-  if (option_.isNone(annotation)) {
-    return schema.annotations({ title })
-  }
-  return schema
-}
-
 type MakeOptions = boolean | {
   readonly disableValidation?: boolean
 }
@@ -8616,9 +8607,9 @@ const makeClass = ({ Base, annotations, disableToString, fields, identifier, kin
   disableToString?: boolean | undefined
 }): any => {
   const classSymbol = Symbol.for(`effect/Schema/${kind}/${identifier}`)
-  const validateSchema = orElseTitleAnnotation(schema, `${identifier} (Constructor)`)
-  const encodedSide: Schema.Any = orElseTitleAnnotation(schema, `${identifier} (Encoded side)`)
-  const typeSide = orElseTitleAnnotation(typeSchema(schema), `${identifier} (Type side)`)
+  const validateSchema = schema.annotations({ [AST.AutoTitleAnnotationId]: `${identifier} (Constructor)` })
+  const encodedSide: Schema.Any = schema.annotations({ [AST.AutoTitleAnnotationId]: `${identifier} (Encoded side)` })
+  const typeSide = typeSchema(schema).annotations({ [AST.AutoTitleAnnotationId]: `${identifier} (Type side)` })
   const fallbackInstanceOf = (u: unknown) => Predicate.hasProperty(u, classSymbol) && ParseResult.is(typeSide)(u)
   const klass = class extends Base {
     constructor(

package/src/SchemaAST.ts

@@ -126,6 +126,9 @@ export type TitleAnnotation = string
  */
 export const TitleAnnotationId: unique symbol = Symbol.for("effect/annotation/Title")
 
+/** @internal */
+export const AutoTitleAnnotationId: unique symbol = Symbol.for("effect/annotation/AutoTitle")
+
 /**
  * @category annotations
  * @since 3.10.0
@@ -354,6 +357,9 @@ export const getMissingMessageAnnotation = getAnnotation<MissingMessageAnnotatio
  */
 export const getTitleAnnotation = getAnnotation<TitleAnnotation>(TitleAnnotationId)
 
+/** @internal */
+export const getAutoTitleAnnotation = getAnnotation<TitleAnnotation>(AutoTitleAnnotationId)
+
 /**
  * @category annotations
  * @since 3.10.0
@@ -2822,6 +2828,7 @@ const formatKeyword = (ast: AST): string => Option.getOrElse(getExpected(ast), (
 const getExpected = (ast: Annotated): Option.Option<string> => {
   return getIdentifierAnnotation(ast).pipe(
     Option.orElse(() => getTitleAnnotation(ast)),
-    Option.orElse(() => getDescriptionAnnotation(ast))
+    Option.orElse(() => getDescriptionAnnotation(ast)),
+    Option.orElse(() => getAutoTitleAnnotation(ast))
   )
 }

package/src/Stream.ts

@@ -8224,7 +8224,7 @@ export const someOrFail: {
 } = internal.someOrFail
 
 /**
- * Splits elements based on a predicate.
+ * Splits elements based on a predicate or refinement.
  *
  * ```ts
  * import * as Stream from "./Stream"
@@ -8243,7 +8243,28 @@ export const someOrFail: {
  */
 export const split: {
   /**
-   * Splits elements based on a predicate.
+   * Splits elements based on a predicate or refinement.
+   *
+   * ```ts
+   * import * as Stream from "./Stream"
+   * import { pipe } from "./Function"
+   *
+   * pipe(
+   *   Stream.range(1, 10),
+   *   Stream.split((n) => n % 4 === 0),
+   *   Stream.runCollect
+   * )
+   * // => Chunk(Chunk(1, 2, 3), Chunk(5, 6, 7), Chunk(9))
+   * ```
+   *
+   * @since 2.0.0
+   * @category utils
+   */
+  <A, B extends A>(
+    refinement: Refinement<NoInfer<A>, B>
+  ): <E, R>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<Exclude<A, B>>, E, R>
+  /**
+   * Splits elements based on a predicate or refinement.
    *
    * ```ts
    * import * as Stream from "./Stream"
@@ -8262,7 +8283,26 @@ export const split: {
    */
   <A>(predicate: Predicate<NoInfer<A>>): <E, R>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R>
   /**
-   * Splits elements based on a predicate.
+   * Splits elements based on a predicate or refinement.
+   *
+   * ```ts
+   * import * as Stream from "./Stream"
+   * import { pipe } from "./Function"
+   *
+   * pipe(
+   *   Stream.range(1, 10),
+   *   Stream.split((n) => n % 4 === 0),
+   *   Stream.runCollect
+   * )
+   * // => Chunk(Chunk(1, 2, 3), Chunk(5, 6, 7), Chunk(9))
+   * ```
+   *
+   * @since 2.0.0
+   * @category utils
+   */
+  <A, E, R, B extends A>(self: Stream<A, E, R>, refinement: Refinement<A, B>): Stream<Chunk.Chunk<Exclude<A, B>>, E, R>
+  /**
+   * Splits elements based on a predicate or refinement.
    *
    * ```ts
    * import * as Stream from "./Stream"

package/src/internal/mailbox.ts

@@ -85,7 +85,7 @@ class MailboxImpl<A, E> extends Effectable.Class<readonly [messages: Chunk.Chunk
   private messagesChunk = Chunk.empty<A>()
   constructor(
     readonly scheduler: Scheduler,
-    readonly capacity: number,
+    private capacity: number,
     readonly strategy: "suspend" | "dropping" | "sliding"
   ) {
     super()
@@ -100,6 +100,11 @@ class MailboxImpl<A, E> extends Effectable.Class<readonly [messages: Chunk.Chunk
           case "dropping":
             return exitFalse
           case "suspend":
+            if (this.capacity <= 0 && this.state.takers.size > 0) {
+              this.messages.push(message)
+              this.releaseTaker()
+              return exitTrue
+            }
             return this.offerRemainingSingle(message)
           case "sliding":
             this.unsafeTake()
@@ -120,6 +125,10 @@ class MailboxImpl<A, E> extends Effectable.Class<readonly [messages: Chunk.Chunk
         this.unsafeTake()
         this.messages.push(message)
         return true
+      } else if (this.capacity <= 0 && this.state.takers.size > 0) {
+        this.messages.push(message)
+        this.releaseTaker()
+        return true
       }
       return false
     }
@@ -164,7 +173,9 @@ class MailboxImpl<A, E> extends Effectable.Class<readonly [messages: Chunk.Chunk
       this.scheduleReleaseTaker()
       return []
     }
-    const free = this.capacity - this.messages.length - this.messagesChunk.length
+    const free = this.capacity <= 0
+      ? this.state.takers.size
+      : this.capacity - this.messages.length - this.messagesChunk.length
     if (free === 0) {
       return Arr.fromIterable(messages)
     }
@@ -274,6 +285,11 @@ class MailboxImpl<A, E> extends Effectable.Class<readonly [messages: Chunk.Chunk
       message = this.messages[0]
       this.messagesChunk = Chunk.drop(Chunk.unsafeFromArray(this.messages), 1)
       this.messages = []
+    } else if (this.capacity <= 0 && this.state.offers.size > 0) {
+      this.capacity = 1
+      this.releaseCapacity()
+      this.capacity = 0
+      return this.messages.length > 0 ? core.exitSucceed(this.messages.pop()!) : undefined
     } else {
       return undefined
     }
@@ -422,6 +438,11 @@ class MailboxImpl<A, E> extends Effectable.Class<readonly [messages: Chunk.Chunk
       const messages = Chunk.unsafeFromArray(this.messages)
       this.messages = []
       return messages
+    } else if (this.state._tag !== "Done" && this.state.offers.size > 0) {
+      this.capacity = 1
+      this.releaseCapacity()
+      this.capacity = 0
+      return Chunk.of(this.messages.pop()!)
     }
     return empty
   }

package/src/internal/stream.ts

@@ -6189,44 +6189,59 @@ export const slidingSize = dual<
 )
 
 /** @internal */
-export const split = dual<
-  <A>(predicate: Predicate<NoInfer<A>>) => <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<Chunk.Chunk<A>, E, R>,
-  <A, E, R>(self: Stream.Stream<A, E, R>, predicate: Predicate<A>) => Stream.Stream<Chunk.Chunk<A>, E, R>
->(2, <A, E, R>(self: Stream.Stream<A, E, R>, predicate: Predicate<A>): Stream.Stream<Chunk.Chunk<A>, E, R> => {
-  const split = (
-    leftovers: Chunk.Chunk<A>,
-    input: Chunk.Chunk<A>
-  ): Channel.Channel<Chunk.Chunk<Chunk.Chunk<A>>, Chunk.Chunk<A>, E, E, unknown, unknown, R> => {
-    const [chunk, remaining] = pipe(leftovers, Chunk.appendAll(input), Chunk.splitWhere(predicate))
-    if (Chunk.isEmpty(chunk) || Chunk.isEmpty(remaining)) {
-      return loop(pipe(chunk, Chunk.appendAll(pipe(remaining, Chunk.drop(1)))))
+export const split: {
+  <A, B extends A>(
+    refinement: Refinement<NoInfer<A>, B>
+  ): <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<Chunk.Chunk<Exclude<A, B>>, E, R>
+  <A>(
+    predicate: Predicate<NoInfer<A>>
+  ): <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<Chunk.Chunk<A>, E, R>
+  <A, E, R, B extends A>(
+    self: Stream.Stream<A, E, R>,
+    refinement: Refinement<A, B>
+  ): Stream.Stream<Chunk.Chunk<Exclude<A, B>>, E, R>
+  <A, E, R>(self: Stream.Stream<A, E, R>, predicate: Predicate<A>): Stream.Stream<Chunk.Chunk<A>, E, R>
+} = dual(
+  2,
+  <A, E, R>(
+    self: Stream.Stream<A, E, R>,
+    predicate: Predicate<A>
+  ): Stream.Stream<Chunk.Chunk<A>, E, R> => {
+    const split = (
+      leftovers: Chunk.Chunk<A>,
+      input: Chunk.Chunk<A>
+    ): Channel.Channel<Chunk.Chunk<Chunk.Chunk<A>>, Chunk.Chunk<A>, E, E, unknown, unknown, R> => {
+      const [chunk, remaining] = pipe(leftovers, Chunk.appendAll(input), Chunk.splitWhere(predicate))
+      if (Chunk.isEmpty(chunk) || Chunk.isEmpty(remaining)) {
+        return loop(pipe(chunk, Chunk.appendAll(pipe(remaining, Chunk.drop(1)))))
+      }
+      return pipe(
+        core.write(Chunk.of(chunk)),
+        core.flatMap(() => split(Chunk.empty(), pipe(remaining, Chunk.drop(1))))
+      )
     }
-    return pipe(
-      core.write(Chunk.of(chunk)),
-      core.flatMap(() => split(Chunk.empty(), pipe(remaining, Chunk.drop(1))))
-    )
-  }
-  const loop = (
-    leftovers: Chunk.Chunk<A>
-  ): Channel.Channel<Chunk.Chunk<Chunk.Chunk<A>>, Chunk.Chunk<A>, E, E, unknown, unknown, R> =>
-    core.readWith({
-      onInput: (input: Chunk.Chunk<A>) => split(leftovers, input),
-      onFailure: core.fail,
-      onDone: () => {
-        if (Chunk.isEmpty(leftovers)) {
-          return core.void
-        }
-        if (Option.isNone(pipe(leftovers, Chunk.findFirst(predicate)))) {
-          return channel.zipRight(core.write(Chunk.of(leftovers)), core.void)
+    const loop = (
+      leftovers: Chunk.Chunk<A>
+    ): Channel.Channel<Chunk.Chunk<Chunk.Chunk<A>>, Chunk.Chunk<A>, E, E, unknown, unknown, R> =>
+      core.readWith({
+        onInput: (input: Chunk.Chunk<A>) => split(leftovers, input),
+        onFailure: core.fail,
+        onDone: () => {
+          if (Chunk.isEmpty(leftovers)) {
+            return core.void
+          }
+          if (Option.isNone(pipe(leftovers, Chunk.findFirst(predicate)))) {
+            return channel.zipRight(core.write(Chunk.of(leftovers)), core.void)
+          }
+          return channel.zipRight(
+            split(Chunk.empty(), leftovers),
+            core.void
+          )
         }
-        return channel.zipRight(
-          split(Chunk.empty(), leftovers),
-          core.void
-        )
-      }
-    })
-  return new StreamImpl(pipe(toChannel(self), core.pipeTo(loop(Chunk.empty()))))
-})
+      })
+    return new StreamImpl(pipe(toChannel(self), core.pipeTo(loop(Chunk.empty()))))
+  }
+)
 
 /** @internal */
 export const splitOnChunk = dual<

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.10.14"
+let moduleVersion = "3.10.16"
 
 export const getCurrentVersion = () => moduleVersion