effect 3.10.13 → 3.10.15

package/dist/esm/internal/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "3.10.13",
+  "version": "3.10.15",
   "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/Schema.ts

@@ -5443,7 +5443,7 @@ export const JsonNumberSchemaId: unique symbol = Symbol.for("effect/SchemaId/Jso
  * @since 3.10.0
  */
 export class JsonNumber extends Number$.pipe(
-  filter((n) => !Number.isNaN(n) && Number.isFinite(n), {
+  filter(Number.isFinite, {
     schemaId: JsonNumberSchemaId,
     identifier: "JsonNumber",
     title: "JSON-compatible number",

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/managedRuntime.ts

@@ -1,4 +1,3 @@
-import type { Mutable } from "effect/Types"
 import type * as Effect from "../Effect.js"
 import * as Effectable from "../Effectable.js"
 import type { Exit } from "../Exit.js"
@@ -9,6 +8,7 @@ import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
 import type * as Runtime from "../Runtime.js"
 import * as Scope from "../Scope.js"
+import type { Mutable } from "../Types.js"
 import * as core from "./core.js"
 import * as fiberRuntime from "./fiberRuntime.js"
 import * as internalLayer from "./layer.js"
@@ -57,19 +57,21 @@ export const make = <R, ER>(
   memoMap = memoMap ?? internalLayer.unsafeMakeMemoMap()
   const scope = internalRuntime.unsafeRunSyncEffect(fiberRuntime.scopeMake())
   let buildFiber: Fiber.RuntimeFiber<Runtime.Runtime<R>, ER> | undefined
-  const runtimeEffect = core.suspend(() => {
-    buildFiber ??= internalRuntime.unsafeForkEffect(
-      core.tap(
-        Scope.extend(
-          internalLayer.toRuntimeWithMemoMap(layer, memoMap),
-          scope
+  const runtimeEffect = core.withFiberRuntime<Runtime.Runtime<R>, ER>((fiber) => {
+    if (!buildFiber) {
+      buildFiber = internalRuntime.unsafeForkEffect(
+        core.tap(
+          Scope.extend(
+            internalLayer.toRuntimeWithMemoMap(layer, memoMap),
+            scope
+          ),
+          (rt) => {
+            self.cachedRuntime = rt
+          }
         ),
-        (rt) => {
-          self.cachedRuntime = rt
-        }
-      ),
-      { scope }
-    )
+        { scope, scheduler: fiber.currentScheduler }
+      )
+    }
     return core.flatten(buildFiber.await)
   })
   const self: ManagedRuntimeImpl<R, ER> = Object.assign(Object.create(ManagedRuntimeProto), {

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.13"
+let moduleVersion = "3.10.15"
 
 export const getCurrentVersion = () => moduleVersion