@duplojs/utils 1.4.43 → 1.4.45

package/dist/either/safeCallback.d.ts

@@ -1,21 +1,37 @@
 import type { Kind, EscapeVoid } from "../common";
-import { type EitherLeft } from "./left";
-import { type EitherRight } from "./right";
+import { type Left } from "./left";
+import { type Right } from "./right";
+export declare const callbackErrorKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsEither/callback-error", unknown>>;
+/**
+ * @deprecated use callbackErrorKind
+ */
 export declare const eitherCallbackErrorKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsEither/callback-error", unknown>>;
+export declare const callbackSuccessKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsEither/callback-success", unknown>>;
+/**
+ * @deprecated use callbackSuccessKind
+ */
 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 {
+type _CallbackError = (Left<"callback", unknown> & Kind<typeof callbackErrorKind.definition>);
+type _CallbackSuccess<GenericValue extends unknown> = (Right<"callback", GenericValue> & Kind<typeof callbackSuccessKind.definition>);
+export interface CallbackError extends _CallbackError {
 }
-export interface EitherCallbackSuccess<GenericValue extends unknown> extends _EitherCallbackSuccess<GenericValue> {
+export interface CallbackSuccess<GenericValue extends unknown> extends _CallbackSuccess<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.
+ * @deprecated use CallbackError
+ */
+export type EitherCallbackError = CallbackError;
+/**
+ * @deprecated use CallbackSuccess
+ */
+export type EitherCallbackSuccess<GenericValue extends unknown> = CallbackSuccess<GenericValue>;
+export declare function callbackError(value: unknown): CallbackError;
+export declare function callbackSuccess<GenericValue extends unknown>(value: GenericValue): CallbackSuccess<GenericValue>;
+type Either = Right | Left;
+type ComputeSafeCallbackResult<GenericOutput extends unknown> = GenericOutput extends Either ? GenericOutput : GenericOutput extends EscapeVoid ? CallbackSuccess<undefined> : CallbackSuccess<GenericOutput>;
+/**
+ * Runs a callback in a safe block. If the callback throws, the function returns a "callback" typed Left instead of propagating the exception.
+ * If the callback returns an Either, it is returned as-is; otherwise the value is wrapped in an Right.
  * 
  * Signature: `safeCallback(theFunction)` → returns a value
  * 
@@ -23,7 +39,7 @@ type ComputeSafeCallbackResult<GenericOutput extends unknown> = GenericOutput ex
  * 
  * ```ts
  * const success = E.safeCallback(() => 42);
- * // E.EitherCallbackError | E.EitherCallbackSuccess<number>
+ * // E.CallbackError | E.CallbackSuccess<number>
  * 
  * const failure = E.safeCallback(() => {
  * 	throw new Error("boom");
@@ -35,12 +51,12 @@ type ComputeSafeCallbackResult<GenericOutput extends unknown> = GenericOutput ex
  * 	() => E.left("example", "already"),
  * );
  * 
- * const isEitherLeft = E.isLeft(eitherResult);
+ * const isLeft = 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
+ * - Catches exceptions thrown by the callback and wraps them in an `Left<"callback">`
+ * - Keeps an `Left` or `Right` 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
@@ -48,5 +64,5 @@ type ComputeSafeCallbackResult<GenericOutput extends unknown> = GenericOutput ex
  * @namespace E
  * 
  */
-export declare function safeCallback<GenericOutput extends unknown>(theFunction: () => GenericOutput): ComputeSafeCallbackResult<GenericOutput> | EitherCallbackError;
+export declare function safeCallback<GenericOutput extends unknown>(theFunction: () => GenericOutput): ComputeSafeCallbackResult<GenericOutput> | CallbackError;
 export {};

package/dist/either/safeCallback.mjs

@@ -4,13 +4,21 @@ import { right } from './right/create.mjs';
 import { isRight } from './right/is.mjs';
 import { isLeft } from './left/is.mjs';
 
-const eitherCallbackErrorKind = createEitherKind("callback-error");
-const eitherCallbackSuccessKind = createEitherKind("callback-success");
+const callbackErrorKind = createEitherKind("callback-error");
+/**
+ * @deprecated use callbackErrorKind
+ */
+const eitherCallbackErrorKind = callbackErrorKind;
+const callbackSuccessKind = createEitherKind("callback-success");
+/**
+ * @deprecated use callbackSuccessKind
+ */
+const eitherCallbackSuccessKind = callbackSuccessKind;
 function callbackError(value) {
-    return eitherCallbackErrorKind.setTo(left("callback", value));
+    return callbackErrorKind.setTo(left("callback", value));
 }
 function callbackSuccess(value) {
-    return eitherCallbackSuccessKind.setTo(right("callback", value));
+    return callbackSuccessKind.setTo(right("callback", value));
 }
 /**
  * {@include either/safeCallback/index.md}
@@ -28,4 +36,4 @@ function safeCallback(theFunction) {
     }
 }
 
-export { callbackError, callbackSuccess, eitherCallbackErrorKind, eitherCallbackSuccessKind, safeCallback };
+export { callbackError, callbackErrorKind, callbackSuccess, callbackSuccessKind, eitherCallbackErrorKind, eitherCallbackSuccessKind, safeCallback };

package/dist/either/whenHasInformation.cjs

@@ -15,7 +15,7 @@ function whenHasInformation(...args) {
         ? information
         : [information];
     if ((is.isLeft(input)
-        || is$1.isRight(input)) && formattedInformation.includes(kind.eitherInformationKind.getValue(input))) {
+        || is$1.isRight(input)) && formattedInformation.includes(kind.informationKind.getValue(input))) {
         return theFunction(unwrap.unwrap(input));
     }
     return input;

package/dist/either/whenHasInformation.d.ts

@@ -1,8 +1,8 @@
 import { type Kind, type WrappedValue, type AnyValue, type Unwrap, type BreakGenericLink } from "../common";
-import { type EitherRight } from "./right";
-import { type EitherLeft } from "./left";
-import { eitherInformationKind } from "./kind";
-type Either = EitherRight | EitherLeft;
+import { type Right } from "./right";
+import { type Left } from "./left";
+import { informationKind } from "./kind";
+type Either = Right | Left;
 /**
  * Functional pattern matching based on the literal information of an Either. The function is executed only when the information (or one of the informations) matches.
  * 
@@ -31,7 +31,7 @@ type Either = EitherRight | EitherLeft;
  * 	}),
  * );
  * 
- * // type: 1 | 2 | E.EitherLeft<"left-3", 3>
+ * // type: 1 | 2 | E.Left<"left-3", 3>
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/whenHasInformation
@@ -39,6 +39,6 @@ type Either = EitherRight | EitherLeft;
  * @namespace E
  * 
  */
-export declare function whenHasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof eitherInformationKind.getValue<GenericInput>> : never), const GenericOutput extends AnyValue>(information: GenericInformation | GenericInformation[], theFunction: (value: Unwrap<Extract<BreakGenericLink<GenericInput>, Kind<typeof eitherInformationKind.definition, GenericInformation> & WrappedValue>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<BreakGenericLink<GenericInput>, Kind<typeof eitherInformationKind.definition, GenericInformation>>;
-export declare function whenHasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof eitherInformationKind.getValue<GenericInput>> : never), const GenericOutput extends AnyValue>(input: GenericInput, information: GenericInformation | GenericInformation[], theFunction: (value: Unwrap<Extract<BreakGenericLink<GenericInput>, Kind<typeof eitherInformationKind.definition, GenericInformation> & WrappedValue>>) => GenericOutput): GenericOutput | Exclude<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation>>;
+export declare function whenHasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof informationKind.getValue<GenericInput>> : never), const GenericOutput extends AnyValue>(information: GenericInformation | GenericInformation[], theFunction: (value: Unwrap<Extract<BreakGenericLink<GenericInput>, Kind<typeof informationKind.definition, GenericInformation> & WrappedValue>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<BreakGenericLink<GenericInput>, Kind<typeof informationKind.definition, GenericInformation>>;
+export declare function whenHasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof informationKind.getValue<GenericInput>> : never), const GenericOutput extends AnyValue>(input: GenericInput, information: GenericInformation | GenericInformation[], theFunction: (value: Unwrap<Extract<BreakGenericLink<GenericInput>, Kind<typeof informationKind.definition, GenericInformation> & WrappedValue>>) => GenericOutput): GenericOutput | Exclude<GenericInput, Kind<typeof informationKind.definition, GenericInformation>>;
 export {};

package/dist/either/whenHasInformation.mjs

@@ -1,4 +1,4 @@
-import { eitherInformationKind } from './kind.mjs';
+import { informationKind } from './kind.mjs';
 import { isLeft } from './left/is.mjs';
 import { isRight } from './right/is.mjs';
 import { unwrap } from '../common/unwrap.mjs';
@@ -13,7 +13,7 @@ function whenHasInformation(...args) {
         ? information
         : [information];
     if ((isLeft(input)
-        || isRight(input)) && formattedInformation.includes(eitherInformationKind.getValue(input))) {
+        || isRight(input)) && formattedInformation.includes(informationKind.getValue(input))) {
         return theFunction(unwrap(input));
     }
     return input;

package/package.json

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