@duplojs/utils 1.4.44 → 1.4.46

package/dist/either/right/success.d.ts

@@ -1,11 +1,19 @@
 import { type Kind } from "../../common/kind";
-import { type EitherRight } from "./create";
+import { type Right } from "./create";
+export declare const successKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/success", unknown>>;
+/**
+ * @deprecated use successKind
+ */
 export declare const eitherSuccessKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/success", unknown>>;
-type _EitherSuccess<GenericValue extends unknown = unknown> = (EitherRight<"success", GenericValue> & Kind<typeof eitherSuccessKind.definition>);
-export interface EitherSuccess<GenericValue extends unknown = unknown> extends _EitherSuccess<GenericValue> {
+type _Success<GenericValue extends unknown = unknown> = (Right<"success", GenericValue> & Kind<typeof successKind.definition>);
+export interface Success<GenericValue extends unknown = unknown> extends _Success<GenericValue> {
 }
 /**
- * Readable shortcut to create an EitherRight with the literal info "success". Ideal for functions that return only one type of success.
+ * @deprecated use Success
+ */
+export type EitherSuccess<GenericValue extends unknown = unknown> = Success<GenericValue>;
+/**
+ * Readable shortcut to create an Right with the literal info "success". Ideal for functions that return only one type of success.
  * 
  * Signature: `success(value)` → returns a value
  * 
@@ -24,7 +32,7 @@ export interface EitherSuccess<GenericValue extends unknown = unknown> extends _
  * 	),
  * );
  * 
- * // type: E.EitherError<string> | E.EitherSuccess<string>
+ * // type: E.Error<string> | E.Success<string>
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/success
@@ -32,5 +40,5 @@ export interface EitherSuccess<GenericValue extends unknown = unknown> extends _
  * @namespace E
  * 
  */
-export declare function success<const GenericValue extends unknown>(value: GenericValue): EitherSuccess<GenericValue>;
+export declare function success<const GenericValue extends unknown>(value: GenericValue): Success<GenericValue>;
 export {};

package/dist/either/right/success.mjs

@@ -1,12 +1,16 @@
 import { createEitherKind } from '../kind.mjs';
 import { right } from './create.mjs';
 
-const eitherSuccessKind = createEitherKind("success");
+const successKind = createEitherKind("success");
+/**
+ * @deprecated use successKind
+ */
+const eitherSuccessKind = successKind;
 /**
  * {@include either/success/index.md}
  */
 function success(value) {
-    return eitherSuccessKind.setTo(right("success", value));
+    return successKind.setTo(right("success", value));
 }
 
-export { eitherSuccessKind, success };
+export { eitherSuccessKind, success, successKind };

package/dist/either/right/when.d.ts

@@ -1,7 +1,7 @@
 import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
-import { type EitherRight } from "./create";
+import { type Right } from "./create";
 /**
- * Applies a function only when the input is an EitherRight. Otherwise, the original value is returned as-is.
+ * Applies a function only when the input is an Right. Otherwise, the original value is returned as-is.
  * 
  * **Supported call styles:**
  * - Classic: `whenIsRight(input, theFunction)` → returns a value
@@ -26,5 +26,5 @@ import { type EitherRight } from "./create";
  * @namespace E
  * 
  */
-export declare function whenIsRight<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<BreakGenericLink<GenericInput>, EitherRight>>) => GenericOutput): (input: GenericInput) => Exclude<BreakGenericLink<GenericInput>, EitherRight> | GenericOutput;
-export declare function whenIsRight<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<BreakGenericLink<GenericInput>, EitherRight>>) => GenericOutput): Exclude<GenericInput, EitherRight> | GenericOutput;
+export declare function whenIsRight<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<BreakGenericLink<GenericInput>, Right>>) => GenericOutput): (input: GenericInput) => Exclude<BreakGenericLink<GenericInput>, Right> | GenericOutput;
+export declare function whenIsRight<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<BreakGenericLink<GenericInput>, Right>>) => GenericOutput): Exclude<GenericInput, Right> | GenericOutput;

package/dist/either/safeCallback.cjs

@@ -6,13 +6,21 @@ 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");
-const eitherCallbackSuccessKind = kind.createEitherKind("callback-success");
+const callbackErrorKind = kind.createEitherKind("callback-error");
+/**
+ * @deprecated use callbackErrorKind
+ */
+const eitherCallbackErrorKind = callbackErrorKind;
+const callbackSuccessKind = kind.createEitherKind("callback-success");
+/**
+ * @deprecated use callbackSuccessKind
+ */
+const eitherCallbackSuccessKind = callbackSuccessKind;
 function callbackError(value) {
-    return eitherCallbackErrorKind.setTo(create.left("callback", value));
+    return callbackErrorKind.setTo(create.left("callback", value));
 }
 function callbackSuccess(value) {
-    return eitherCallbackSuccessKind.setTo(create$1.right("callback", value));
+    return callbackSuccessKind.setTo(create$1.right("callback", value));
 }
 /**
  * {@include either/safeCallback/index.md}
@@ -31,7 +39,9 @@ function safeCallback(theFunction) {
 }
 
 exports.callbackError = callbackError;
+exports.callbackErrorKind = callbackErrorKind;
 exports.callbackSuccess = callbackSuccess;
+exports.callbackSuccessKind = callbackSuccessKind;
 exports.eitherCallbackErrorKind = eitherCallbackErrorKind;
 exports.eitherCallbackSuccessKind = eitherCallbackSuccessKind;
 exports.safeCallback = safeCallback;

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/dist/string/isIn.d.ts

@@ -43,5 +43,5 @@
  * @namespace S
  * 
  */
-export declare function isIn<GenericInput extends string, GenericValue extends GenericInput>(array: readonly GenericValue[]): (input: GenericInput) => input is Extract<GenericInput, GenericValue>;
-export declare function isIn<GenericInput extends string, GenericValue extends GenericInput>(input: GenericInput, array: readonly GenericValue[]): input is Extract<GenericInput, GenericValue>;
+export declare function isIn<GenericValue extends string>(array: readonly (GenericValue | string)[]): (input: string) => input is GenericValue;
+export declare function isIn<GenericValue extends string>(input: string, array: readonly (GenericValue | string)[]): input is GenericValue;

package/dist/string/slice.d.ts

@@ -10,7 +10,7 @@
  * ```ts
  * S.slice("DuploJS Utils", 0, 7); // "DuploJS"
  * 
- * S.slice("DuploJS Utils", -5); // "Utils"
+ * S.slice("DuploJS Utils", -5, Infinity); // "Utils"
  * 
  * pipe(
  * 	"DuploJS Utils",

package/package.json

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