effect 2.4.17 → 2.4.19

package/dist/esm/internal/fiberRuntime.js

@@ -1094,31 +1094,23 @@ export class FiberRuntime {
 /** @internal */
 export const currentMinimumLogLevel = /*#__PURE__*/globalValue("effect/FiberRef/currentMinimumLogLevel", () => core.fiberRefUnsafeMake(LogLevel.fromLiteral("Info")));
 /** @internal */
-export const getConsole = refs => {
-  const defaultServicesValue = FiberRefs.getOrDefault(refs, defaultServices.currentServices);
-  const cnsl = Context.get(defaultServicesValue, consoleTag);
-  return cnsl.unsafe;
-};
+export const loggerWithConsoleLog = self => internalLogger.makeLogger(opts => {
+  const services = FiberRefs.getOrDefault(opts.context, defaultServices.currentServices);
+  Context.get(services, consoleTag).unsafe.log(self.log(opts));
+});
 /** @internal */
-export const defaultLogger = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Logger/defaultLogger"), () => internalLogger.makeLogger(options => {
-  const formatted = internalLogger.stringLogger.log(options);
-  getConsole(options.context).log(formatted);
-}));
+export const loggerWithConsoleError = self => internalLogger.makeLogger(opts => {
+  const services = FiberRefs.getOrDefault(opts.context, defaultServices.currentServices);
+  Context.get(services, consoleTag).unsafe.error(self.log(opts));
+});
 /** @internal */
-export const jsonLogger = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Logger/jsonLogger"), () => internalLogger.makeLogger(options => {
-  const formatted = internalLogger.jsonLogger.log(options);
-  getConsole(options.context).log(formatted);
-}));
+export const defaultLogger = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Logger/defaultLogger"), () => loggerWithConsoleLog(internalLogger.stringLogger));
 /** @internal */
-export const logFmtLogger = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Logger/logFmtLogger"), () => internalLogger.makeLogger(options => {
-  const formatted = internalLogger.logfmtLogger.log(options);
-  getConsole(options.context).log(formatted);
-}));
+export const jsonLogger = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Logger/jsonLogger"), () => loggerWithConsoleLog(internalLogger.jsonLogger));
 /** @internal */
-export const structuredLogger = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Logger/structuredLogger"), () => internalLogger.makeLogger(options => {
-  const formatted = internalLogger.structuredLogger.log(options);
-  getConsole(options.context).log(formatted);
-}));
+export const logFmtLogger = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Logger/logFmtLogger"), () => loggerWithConsoleLog(internalLogger.logfmtLogger));
+/** @internal */
+export const structuredLogger = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Logger/structuredLogger"), () => loggerWithConsoleLog(internalLogger.structuredLogger));
 /** @internal */
 export const tracerLogger = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Logger/tracerLogger"), () => internalLogger.makeLogger(({
   annotations,
@@ -1611,7 +1603,7 @@ export const finalizersMask = strategy => self => core.contextWithEffect(context
 /* @internal */
 export const scopeWith = f => core.flatMap(scopeTag, f);
 /* @internal */
-export const scopedEffect = effect => core.flatMap(scopeMake(), scope => scopeUse(scope)(effect));
+export const scopedEffect = effect => core.flatMap(scopeMake(), scope => scopeUse(effect, scope));
 /* @internal */
 export const sequentialFinalizers = self => core.contextWithEffect(context => Option.match(Context.getOption(context, scopeTag), {
   onNone: () => self,
@@ -1684,50 +1676,80 @@ export const withRuntimeFlagsScoped = update => {
     return pipe(core.updateRuntimeFlags(update), core.zipRight(addFinalizer(() => core.updateRuntimeFlags(revertRuntimeFlags))), core.asUnit);
   }), core.uninterruptible);
 };
-// circular with ReleaseMap
-/* @internal */
-export const releaseMapReleaseAll = (strategy, exit) => self => core.suspend(() => {
-  switch (self.state._tag) {
-    case "Exited":
-      {
-        return core.unit;
-      }
-    case "Running":
-      {
-        const finalizersMap = self.state.finalizers;
-        const update = self.state.update;
-        const finalizers = Array.from(finalizersMap.keys()).sort((a, b) => b - a).map(key => finalizersMap.get(key));
-        self.state = {
-          _tag: "Exited",
-          nextKey: self.state.nextKey,
-          exit,
-          update
-        };
-        return executionStrategy.isSequential(strategy) ? pipe(finalizers, core.forEachSequential(fin => core.exit(update(fin)(exit))), core.flatMap(results => pipe(core.exitCollectAll(results), Option.map(core.exitAsUnit), Option.getOrElse(() => core.exitUnit)))) : executionStrategy.isParallel(strategy) ? pipe(forEachParUnbounded(finalizers, fin => core.exit(update(fin)(exit)), false), core.flatMap(results => pipe(core.exitCollectAll(results, {
-          parallel: true
-        }), Option.map(core.exitAsUnit), Option.getOrElse(() => core.exitUnit)))) : pipe(forEachParN(finalizers, strategy.parallelism, fin => core.exit(update(fin)(exit)), false), core.flatMap(results => pipe(core.exitCollectAll(results, {
-          parallel: true
-        }), Option.map(core.exitAsUnit), Option.getOrElse(() => core.exitUnit))));
-      }
-  }
-});
 // circular with Scope
 /** @internal */
 export const scopeTag = /*#__PURE__*/Context.GenericTag("effect/Scope");
 /* @internal */
 export const scope = scopeTag;
-/* @internal */
-export const scopeMake = (strategy = executionStrategy.sequential) => core.map(core.releaseMapMake, rm => ({
+const scopeUnsafeAddFinalizer = (scope, fin) => {
+  if (scope.state._tag === "Open") {
+    scope.state.finalizers.add(fin);
+  }
+};
+const ScopeImplProto = {
   [core.ScopeTypeId]: core.ScopeTypeId,
   [core.CloseableScopeTypeId]: core.CloseableScopeTypeId,
-  strategy,
   pipe() {
     return pipeArguments(this, arguments);
   },
-  fork: strategy => core.uninterruptible(pipe(scopeMake(strategy), core.flatMap(scope => pipe(core.releaseMapAdd(rm, exit => core.scopeClose(scope, exit)), core.tap(fin => core.scopeAddFinalizerExit(scope, fin)), core.as(scope))))),
-  close: exit => core.asUnit(releaseMapReleaseAll(strategy, exit)(rm)),
-  addFinalizer: fin => core.asUnit(core.releaseMapAdd(fin)(rm))
-}));
+  fork(strategy) {
+    return core.sync(() => {
+      const newScope = scopeUnsafeMake(strategy);
+      if (this.state._tag === "Closed") {
+        newScope.state = this.state;
+        return newScope;
+      }
+      const fin = exit => newScope.close(exit);
+      this.state.finalizers.add(fin);
+      scopeUnsafeAddFinalizer(newScope, _ => core.sync(() => {
+        if (this.state._tag === "Open") {
+          this.state.finalizers.delete(fin);
+        }
+      }));
+      return newScope;
+    });
+  },
+  close(exit) {
+    return core.suspend(() => {
+      if (this.state._tag === "Closed") {
+        return core.unit;
+      }
+      const finalizers = Array.from(this.state.finalizers.values()).reverse();
+      this.state = {
+        _tag: "Closed",
+        exit
+      };
+      if (finalizers.length === 0) {
+        return core.unit;
+      }
+      return executionStrategy.isSequential(this.strategy) ? pipe(core.forEachSequential(finalizers, fin => core.exit(fin(exit))), core.flatMap(results => pipe(core.exitCollectAll(results), Option.map(core.exitAsUnit), Option.getOrElse(() => core.exitUnit)))) : executionStrategy.isParallel(this.strategy) ? pipe(forEachParUnbounded(finalizers, fin => core.exit(fin(exit)), false), core.flatMap(results => pipe(core.exitCollectAll(results, {
+        parallel: true
+      }), Option.map(core.exitAsUnit), Option.getOrElse(() => core.exitUnit)))) : pipe(forEachParN(finalizers, this.strategy.parallelism, fin => core.exit(fin(exit)), false), core.flatMap(results => pipe(core.exitCollectAll(results, {
+        parallel: true
+      }), Option.map(core.exitAsUnit), Option.getOrElse(() => core.exitUnit))));
+    });
+  },
+  addFinalizer(fin) {
+    return core.suspend(() => {
+      if (this.state._tag === "Closed") {
+        return fin(this.state.exit);
+      }
+      this.state.finalizers.add(fin);
+      return core.unit;
+    });
+  }
+};
+const scopeUnsafeMake = (strategy = executionStrategy.sequential) => {
+  const scope = Object.create(ScopeImplProto);
+  scope.strategy = strategy;
+  scope.state = {
+    _tag: "Open",
+    finalizers: new Set()
+  };
+  return scope;
+};
+/* @internal */
+export const scopeMake = (strategy = executionStrategy.sequential) => core.sync(() => scopeUnsafeMake(strategy));
 /* @internal */
 export const scopeExtend = /*#__PURE__*/dual(2, (effect, scope) => core.mapInputContext(effect,
 // @ts-expect-error
@@ -1913,7 +1935,18 @@ export const interruptWhenPossible = /*#__PURE__*/dual(2, (self, all) => core.fi
 })));
 // circular Tracer
 /** @internal */
-export const makeSpanScoped = (name, options) => acquireRelease(internalEffect.makeSpan(name, options), (span, exit) => span.status._tag === "Ended" ? core.unit : core.flatMap(internalEffect.currentTimeNanosTracing, endTime => core.sync(() => span.end(endTime, exit))));
+export const makeSpanScoped = (name, options) => core.uninterruptible(core.withFiberRuntime(fiber => {
+  const scope = Context.unsafeGet(fiber.getFiberRef(core.currentContext), scopeTag);
+  const span = internalEffect.unsafeMakeSpan(fiber, name, options);
+  const timingEnabled = fiber.getFiberRef(core.currentTracerTimingEnabled);
+  const clock_ = Context.get(fiber.getFiberRef(defaultServices.currentServices), clock.clockTag);
+  return core.as(core.scopeAddFinalizerExit(scope, exit => core.sync(() => {
+    if (span.status._tag === "Ended") {
+      return;
+    }
+    span.end(timingEnabled ? clock_.unsafeCurrentTimeNanos() : BigInt(0), exit);
+  })), span);
+}));
 /* @internal */
 export const withTracerScoped = value => fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(tracer.tracerTag, value));
 /** @internal */