@duplojs/utils 1.4.39 → 1.4.40

package/dist/either/index.cjs

@@ -48,7 +48,9 @@ exports.whenHasInformation = whenHasInformation.whenHasInformation;
 exports.createEitherKind = kind.createEitherKind;
 exports.eitherInformationKind = kind.eitherInformationKind;
 exports.callbackError = safeCallback.callbackError;
+exports.callbackSuccess = safeCallback.callbackSuccess;
 exports.eitherCallbackErrorKind = safeCallback.eitherCallbackErrorKind;
+exports.eitherCallbackSuccessKind = safeCallback.eitherCallbackSuccessKind;
 exports.safeCallback = safeCallback.safeCallback;
 exports.bool = create.bool;
 exports.boolFalsy = falsy.boolFalsy;

package/dist/either/index.mjs

@@ -1,7 +1,7 @@
 export { hasInformation } from './hasInformation.mjs';
 export { whenHasInformation } from './whenHasInformation.mjs';
 export { createEitherKind, eitherInformationKind } from './kind.mjs';
-export { callbackError, eitherCallbackErrorKind, safeCallback } from './safeCallback.mjs';
+export { callbackError, callbackSuccess, eitherCallbackErrorKind, eitherCallbackSuccessKind, safeCallback } from './safeCallback.mjs';
 export { bool } from './bool/create.mjs';
 export { boolFalsy, eitherBoolFalsyKind, isBoolFalsy, whenIsBoolFalsy } from './bool/falsy.mjs';
 export { boolTruthy, eitherBoolTruthyKind, isBoolTruthy, whenIsBoolTruthy } from './bool/truthy.mjs';

package/dist/either/safeCallback.cjs

@@ -2,17 +2,28 @@
 
 var kind = require('./kind.cjs');
 var create = require('./left/create.cjs');
+var create$1 = require('./right/create.cjs');
+var is = require('./right/is.cjs');
+var is$1 = require('./left/is.cjs');
 
 const eitherCallbackErrorKind = kind.createEitherKind("callback-error");
-/**
- * {@include either/safeCallback/index.md}
- */
+const eitherCallbackSuccessKind = kind.createEitherKind("callback-success");
 function callbackError(value) {
     return eitherCallbackErrorKind.setTo(create.left("callback", value));
 }
+function callbackSuccess(value) {
+    return eitherCallbackSuccessKind.setTo(create$1.right("callback", value));
+}
+/**
+ * {@include either/safeCallback/index.md}
+ */
 function safeCallback(theFunction) {
     try {
-        return theFunction();
+        const result = theFunction();
+        if (is.isRight(result) || is$1.isLeft(result)) {
+            return result;
+        }
+        return callbackSuccess(result);
     }
     catch (error) {
         return callbackError(error);
@@ -20,5 +31,7 @@ function safeCallback(theFunction) {
 }
 
 exports.callbackError = callbackError;
+exports.callbackSuccess = callbackSuccess;
 exports.eitherCallbackErrorKind = eitherCallbackErrorKind;
+exports.eitherCallbackSuccessKind = eitherCallbackSuccessKind;
 exports.safeCallback = safeCallback;

package/dist/either/safeCallback.d.ts

@@ -1,11 +1,21 @@
-import { type Kind } from "../common";
+import type { Kind, EscapeVoid } from "../common";
 import { type EitherLeft } from "./left";
+import { type EitherRight } from "./right";
 export declare const eitherCallbackErrorKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsEither/callback-error", unknown>>;
+export declare const eitherCallbackSuccessKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsEither/callback-success", unknown>>;
 type _EitherCallbackError = (EitherLeft<"callback", unknown> & Kind<typeof eitherCallbackErrorKind.definition>);
+type _EitherCallbackSuccess<GenericValue extends unknown> = (EitherRight<"callback", GenericValue> & Kind<typeof eitherCallbackSuccessKind.definition>);
 export interface EitherCallbackError extends _EitherCallbackError {
 }
+export interface EitherCallbackSuccess<GenericValue extends unknown> extends _EitherCallbackSuccess<GenericValue> {
+}
+export declare function callbackError(value: unknown): EitherCallbackError;
+export declare function callbackSuccess<GenericValue extends unknown>(value: GenericValue): EitherCallbackSuccess<GenericValue>;
+type Either = EitherRight | EitherLeft;
+type ComputeSafeCallbackResult<GenericOutput extends unknown> = GenericOutput extends Either ? GenericOutput : GenericOutput extends EscapeVoid ? EitherCallbackSuccess<undefined> : EitherCallbackSuccess<GenericOutput>;
 /**
  * Runs a callback in a safe block. If the callback throws, the function returns a "callback" typed EitherLeft instead of propagating the exception.
+ * If the callback returns an Either, it is returned as-is; otherwise the value is wrapped in an EitherRight.
  * 
  * Signature: `safeCallback(theFunction)` → returns a value
  * 
@@ -13,16 +23,24 @@ export interface EitherCallbackError extends _EitherCallbackError {
  * 
  * ```ts
  * const success = E.safeCallback(() => 42);
+ * // E.EitherCallbackError | E.EitherCallbackSuccess<number>
  * 
  * const failure = E.safeCallback(() => {
  * 	throw new Error("boom");
  * });
  * 
  * const isFailure = E.isLeft(failure);
+ * 
+ * const eitherResult = E.safeCallback(
+ * 	() => E.left("example", "already"),
+ * );
+ * 
+ * const isEitherLeft = E.isLeft(eitherResult);
  * ```
  * 
  * @remarks
  * - Catches exceptions thrown by the callback and wraps them in an `EitherLeft<"callback">`
+ * - Keeps an `EitherLeft` or `EitherRight` returned by the callback untouched
  * - Useful for working in an unsafe environment (3rd party libraries, user code, etc.)
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/safeCallback
@@ -30,6 +48,5 @@ export interface EitherCallbackError extends _EitherCallbackError {
  * @namespace E
  * 
  */
-export declare function callbackError(value: unknown): EitherCallbackError;
-export declare function safeCallback<GenericOutput extends unknown>(theFunction: () => GenericOutput): GenericOutput | EitherCallbackError;
+export declare function safeCallback<GenericOutput extends unknown>(theFunction: () => GenericOutput): ComputeSafeCallbackResult<GenericOutput> | EitherCallbackError;
 export {};

package/dist/either/safeCallback.mjs

@@ -1,20 +1,31 @@
 import { createEitherKind } from './kind.mjs';
 import { left } from './left/create.mjs';
+import { right } from './right/create.mjs';
+import { isRight } from './right/is.mjs';
+import { isLeft } from './left/is.mjs';
 
 const eitherCallbackErrorKind = createEitherKind("callback-error");
-/**
- * {@include either/safeCallback/index.md}
- */
+const eitherCallbackSuccessKind = createEitherKind("callback-success");
 function callbackError(value) {
     return eitherCallbackErrorKind.setTo(left("callback", value));
 }
+function callbackSuccess(value) {
+    return eitherCallbackSuccessKind.setTo(right("callback", value));
+}
+/**
+ * {@include either/safeCallback/index.md}
+ */
 function safeCallback(theFunction) {
     try {
-        return theFunction();
+        const result = theFunction();
+        if (isRight(result) || isLeft(result)) {
+            return result;
+        }
+        return callbackSuccess(result);
     }
     catch (error) {
         return callbackError(error);
     }
 }
 
-export { callbackError, eitherCallbackErrorKind, safeCallback };
+export { callbackError, callbackSuccess, eitherCallbackErrorKind, eitherCallbackSuccessKind, safeCallback };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.4.39",
+  "version": "1.4.40",
   "author": {
     "name": "mathcovax",
     "url": "https://github.com/mathcovax"