effect 4.0.0-beta.10 → 4.0.0-beta.12

package/dist/internal/effect.js

@@ -201,7 +201,8 @@ export const causePrettyErrors = self => {
   Error.stackTraceLimit = prevStackLimit;
   return errors;
 };
-const causePrettyError = (original, annotations) => {
+/** @internal */
+export const causePrettyError = (original, annotations) => {
   const kind = typeof original;
   let error;
   if (original && kind === "object") {
@@ -322,17 +323,31 @@ const fiberIdStore = {
 /** @internal */
 export const getCurrentFiber = () => globalThis[currentFiberTypeId];
 const keepAlive = /*#__PURE__*/(() => {
+  let isAvailable;
+  const start = () => {
+    if (isAvailable === true) return setInterval(constVoid, 2_147_483_647);else if (isAvailable === false) return undefined;
+    try {
+      const running = setInterval(constVoid, 2_147_483_647);
+      isAvailable = true;
+      return running;
+    } catch {
+      isAvailable = false;
+      return undefined;
+    }
+  };
   let count = 0;
   let running = undefined;
   return {
     increment() {
       count++;
-      running ??= globalThis.setInterval(constVoid, 2_147_483_647);
+      if (running === undefined) {
+        running = start();
+      }
     },
     decrement() {
       count--;
       if (count === 0 && running !== undefined) {
-        globalThis.clearInterval(running);
+        clearInterval(running);
         running = undefined;
       }
     }
@@ -598,8 +613,10 @@ export const fiberJoinAll = self => callback(resume => {
 /** @internal */
 export const fiberInterrupt = self => withFiber(fiber => fiberInterruptAs(self, fiber.id));
 /** @internal */
-export const fiberInterruptAs = /*#__PURE__*/dual(2, (self, fiberId) => withFiber(parent => {
-  self.interruptUnsafe(fiberId, fiberStackAnnotations(parent));
+export const fiberInterruptAs = /*#__PURE__*/dual(args => hasProperty(args[0], FiberTypeId), (self, fiberId, annotations) => withFiber(parent => {
+  let ann = fiberStackAnnotations(parent);
+  ann = ann && annotations ? ServiceMap.merge(ann, annotations) : ann ?? annotations;
+  self.interruptUnsafe(fiberId, ann);
   return asVoid(fiberAwait(self));
 }));
 /** @internal */
@@ -1117,33 +1134,17 @@ export const updateServices = /*#__PURE__*/dual(2, (self, f) => withFiber(fiber
   const nextServices = f(prev);
   if (prev === nextServices) return self;
   fiber.setServices(nextServices);
-  const newServices = new Map();
-  for (const [key, value] of fiber.services.mapUnsafe) {
-    if (!prev.mapUnsafe.has(key) || value !== prev.mapUnsafe.get(key)) {
-      newServices.set(key, value);
-    }
-  }
   return onExitPrimitive(self, () => {
-    const map = new Map(fiber.services.mapUnsafe);
-    for (const [key, value] of newServices) {
-      if (value !== map.get(key)) continue;
-      if (prev.mapUnsafe.has(key)) {
-        map.set(key, prev.mapUnsafe.get(key));
-      } else {
-        map.delete(key);
-      }
-    }
-    fiber.setServices(ServiceMap.makeUnsafe(map));
+    fiber.setServices(prev);
     return undefined;
   });
 }));
 /** @internal */
-export const updateService = /*#__PURE__*/dual(3, (self, service, f) => withFiber(fiber => {
-  const prev = ServiceMap.getUnsafe(fiber.services, service);
+export const updateService = /*#__PURE__*/dual(3, (self, service, f) => updateServices(self, s => {
+  const prev = ServiceMap.getUnsafe(s, service);
   const next = f(prev);
-  if (prev === next) return self;
-  fiber.setServices(ServiceMap.add(fiber.services, service, next));
-  return onExit(self, () => sync(() => fiber.setServices(ServiceMap.add(fiber.services, service, prev))));
+  if (prev === next) return s;
+  return ServiceMap.add(s, service, next);
 }));
 /** @internal */
 export const services = () => getServiceMap;
@@ -1162,11 +1163,10 @@ export const provideService = function () {
   }
   return dual(3, (self, service, impl) => provideServiceImpl(self, service, impl)).apply(this, arguments);
 };
-const provideServiceImpl = (self, service, implementation) => withFiber(fiber => {
-  const prev = ServiceMap.getOption(fiber.services, service);
-  if (prev._tag === "Some" && prev.value === implementation) return self;
-  fiber.setServices(ServiceMap.add(fiber.services, service, implementation));
-  return onExit(self, () => sync(() => fiber.setServices(ServiceMap.addOrOmit(fiber.services, service, prev))));
+const provideServiceImpl = (self, service, implementation) => updateServices(self, s => {
+  const prev = s.mapUnsafe.get(service.key);
+  if (prev === implementation) return s;
+  return ServiceMap.add(s, service, implementation);
 });
 /** @internal */
 export const provideServiceEffect = /*#__PURE__*/dual(3, (self, service, acquire) => flatMap(acquire, implementation => provideService(self, service, implementation)));
@@ -1569,11 +1569,11 @@ export const scope = /*#__PURE__*/scopeTag.asEffect();
 export const provideScope = /*#__PURE__*/provideService(scopeTag);
 /** @internal */
 export const scoped = self => withFiber(fiber => {
-  const prev = ServiceMap.getOption(fiber.services, scopeTag);
+  const prev = fiber.services;
   const scope = scopeMakeUnsafe();
   fiber.setServices(ServiceMap.add(fiber.services, scopeTag, scope));
   return onExitPrimitive(self, exit => {
-    fiber.setServices(ServiceMap.addOrOmit(fiber.services, scopeTag, prev));
+    fiber.setServices(prev);
     return scopeCloseUnsafe(scope, exit);
   });
 });
@@ -1735,6 +1735,15 @@ export const all = (arg, options) => {
 /** @internal */
 export const partition = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, f, options) => map(forEach(elements, (a, i) => result(f(a, i)), options), results => Arr.partitionMap(results, identity)));
 /** @internal */
+export const validate = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, f, options) => flatMap(partition(elements, f, {
+  concurrency: options?.concurrency
+}), ([excluded, satisfying]) => {
+  if (Arr.isArrayNonEmpty(excluded)) {
+    return fail(excluded);
+  }
+  return options?.discard ? void_ : succeed(satisfying);
+}));
+/** @internal */
 export const whileLoop = /*#__PURE__*/makePrimitive({
   op: "While",
   [contA](value, fiber) {
@@ -2539,6 +2548,38 @@ export const LogToStderr = /*#__PURE__*/ServiceMap.Reference("effect/Logger/LogT
   defaultValue: constFalse
 });
 /** @internal */
+export const annotateLogsScoped = function () {
+  const entries = typeof arguments[0] === "string" ? [[arguments[0], arguments[1]]] : Object.entries(arguments[0]);
+  return uninterruptible(withFiber(fiber => {
+    const prev = fiber.getRef(CurrentLogAnnotations);
+    const next = {
+      ...prev
+    };
+    for (let i = 0; i < entries.length; i++) {
+      const [key, value] = entries[i];
+      next[key] = value;
+    }
+    fiber.setServices(ServiceMap.add(fiber.services, CurrentLogAnnotations, next));
+    return scopeAddFinalizerExit(ServiceMap.getUnsafe(fiber.services, scopeTag), _ => {
+      const current = fiber.getRef(CurrentLogAnnotations);
+      const next = {
+        ...current
+      };
+      for (let i = 0; i < entries.length; i++) {
+        const [key, value] = entries[i];
+        if (current[key] !== value) continue;
+        if (key in prev) {
+          next[key] = prev[key];
+        } else {
+          delete next[key];
+        }
+      }
+      fiber.setServices(ServiceMap.add(fiber.services, CurrentLogAnnotations, next));
+      return void_;
+    });
+  }));
+};
+/** @internal */
 export const LoggerTypeId = "~effect/Logger";
 const LoggerProto = {
   [LoggerTypeId]: {
@@ -2845,4 +2886,28 @@ export function interruptChildrenPatch() {
 const undefined_ = /*#__PURE__*/succeed(undefined);
 /** @internal */
 export { undefined_ as undefined };
+// ----------------------------------------------------------------------------
+// ErrorReporter
+// ----------------------------------------------------------------------------
+/** @internal */
+export const CurrentErrorReporters = /*#__PURE__*/ServiceMap.Reference("effect/ErrorReporter/CurrentErrorReporters", {
+  defaultValue: () => new Set()
+});
+/** @internal */
+export const withErrorReporting = /*#__PURE__*/dual(args => isEffect(args[0]), (self, options) => onError(self, cause => withFiber(fiber => {
+  reportCauseUnsafe(fiber, cause, options?.defectsOnly);
+  return void_;
+})));
+/** @internal */
+export const reportCauseUnsafe = (fiber, cause, defectsOnly) => {
+  const reporters = fiber.getRef(CurrentErrorReporters);
+  if (reporters.size === 0) return;
+  if (defectsOnly && !hasDies(cause)) return;
+  const opts = {
+    cause,
+    fiber,
+    timestamp: fiber.getRef(ClockRef).currentTimeNanosUnsafe()
+  };
+  reporters.forEach(reporter => reporter.report(opts));
+};
 //# sourceMappingURL=effect.js.map