@rotomeca/rop 0.0.2 → 1.0.0

package/{src/classes/Fail.ts → dist/esm/src/classes/Fail.d.ts}

@@ -1,92 +1,69 @@
-// type: class
-// description: Class representing a error result.
-
 import { ResultState, ITResult } from "../interfaces/ITResult";
 import { ResultMatch } from "../types/ResultMatch";
 import { ChainedCallback, SuccessMapCallback, ErrorMapCallback } from "../types/resultsCallbacks";
 import { ATresult } from "./abstracts/ATresult";
-
 /**
  * Class representing a failed result.
  * @template TSuccess - The type of the success value.
  * @template TE - The type of the error value (default is Error).
  */
-export class Fail<TSuccess, TE = Error> extends ATresult<TSuccess, TE> {
+export declare class Fail<TSuccess, TE = Error> extends ATresult<TSuccess, TE> {
+    readonly error: TE;
     /**
      * Creates an instance of Fail.
      * @param error The error value.
      */
-    constructor(public readonly error: TE) { super(); }
-
+    constructor(error: TE);
     /**
      * Returns the state of the result.
      * @returns The state indicating failure.
      */
-    state(): ResultState {
-        return ResultState.Error;
-    }
+    state(): ResultState;
     /**
      * Matches the result with the provided matcher functions.
      * @param matcher The matcher object containing functions for success and error cases.
      * @returns The result of the matched function.
      */
-    match<Result>(matcher: ResultMatch<TSuccess, TE, Result>): Result {
-        return matcher.Err(this.error);
-    }
+    match<Result>(matcher: ResultMatch<TSuccess, TE, Result>): Result;
     /**
      * Chains the result with another operation that returns a new result.
      * @param fn The function to apply if the result is successful.
      * @returns The result of the chained operation.
      */
-    andThen<NewSuccess>(_: ChainedCallback<TSuccess, NewSuccess, TE>): ITResult<NewSuccess, TE> {
-        return new Fail<NewSuccess, TE>(this.error);
-    }
+    andThen<NewSuccess>(_: ChainedCallback<TSuccess, NewSuccess, TE>): ITResult<NewSuccess, TE>;
     /**
      * Maps the success value to a new value.
      * @param fn The function to apply to the success value.
      * @returns A new Success instance containing the mapped value.
      */
-    map<NewSuccess>(_: SuccessMapCallback<TSuccess, NewSuccess>): ITResult<NewSuccess, TE> {
-        return new Fail<NewSuccess, TE>(this.error);
-    }
+    map<NewSuccess>(_: SuccessMapCallback<TSuccess, NewSuccess>): ITResult<NewSuccess, TE>;
     /**
      * Maps the error value to a new error value.
      * @param _ The function to apply to the error value.
      * @returns A new Success instance containing the original success value.
      */
-    mapError<NewError>(fn: ErrorMapCallback<TE, NewError>): ITResult<TSuccess, NewError> {
-        return new Fail<TSuccess, NewError>(fn(this.error));
-    }
-
+    mapError<NewError>(fn: ErrorMapCallback<TE, NewError>): ITResult<TSuccess, NewError>;
     /**
      * Returns the success value or throws an error if the result is an error.
      * @throws The error value if the result is an error.
      * @returns The success value.
      */
-    throwIfError(): TSuccess {
-        throw this.error;
-    }
-
+    throwIfError(): TSuccess;
     /**
      * Retrieves the success value or returns the provided default value if the result is an error.
      * @param defaultValue The value to return if the result is an error.
      * @returns The success value if the result is a success, otherwise the default value.
      */
-    unwrapOr(defaultValue: TSuccess): TSuccess {
-        return defaultValue;
-    }
-
+    unwrapOr(defaultValue: TSuccess): TSuccess;
     /**
      * Creates a new Fail instance.
      * @param error The error value.
      * @returns A new Fail instance containing the error.
-     * 
+     *
      * @template TSuccess - The type of the success value.
      * @template TE - The type of the error value (default is Error).
-     * 
+     *
      * @static
      */
-    static Create<TSuccess, TE = Error>(error: TE): Fail<TSuccess, TE> {
-        return new Fail(error);
-    }
-}
+    static Create<TSuccess, TE = Error>(error: TE): Fail<TSuccess, TE>;
+}

package/dist/esm/src/classes/Fail.js

@@ -0,0 +1,87 @@
+// type: class
+// description: Class representing a error result.
+import { ResultState } from "../interfaces/ITResult";
+import { ATresult } from "./abstracts/ATresult";
+/**
+ * Class representing a failed result.
+ * @template TSuccess - The type of the success value.
+ * @template TE - The type of the error value (default is Error).
+ */
+export class Fail extends ATresult {
+    /**
+     * Creates an instance of Fail.
+     * @param error The error value.
+     */
+    constructor(error) {
+        super();
+        this.error = error;
+    }
+    /**
+     * Returns the state of the result.
+     * @returns The state indicating failure.
+     */
+    state() {
+        return ResultState.Error;
+    }
+    /**
+     * Matches the result with the provided matcher functions.
+     * @param matcher The matcher object containing functions for success and error cases.
+     * @returns The result of the matched function.
+     */
+    match(matcher) {
+        return matcher.Err(this.error);
+    }
+    /**
+     * Chains the result with another operation that returns a new result.
+     * @param fn The function to apply if the result is successful.
+     * @returns The result of the chained operation.
+     */
+    andThen(_) {
+        return new Fail(this.error);
+    }
+    /**
+     * Maps the success value to a new value.
+     * @param fn The function to apply to the success value.
+     * @returns A new Success instance containing the mapped value.
+     */
+    map(_) {
+        return new Fail(this.error);
+    }
+    /**
+     * Maps the error value to a new error value.
+     * @param _ The function to apply to the error value.
+     * @returns A new Success instance containing the original success value.
+     */
+    mapError(fn) {
+        return new Fail(fn(this.error));
+    }
+    /**
+     * Returns the success value or throws an error if the result is an error.
+     * @throws The error value if the result is an error.
+     * @returns The success value.
+     */
+    throwIfError() {
+        throw this.error;
+    }
+    /**
+     * Retrieves the success value or returns the provided default value if the result is an error.
+     * @param defaultValue The value to return if the result is an error.
+     * @returns The success value if the result is a success, otherwise the default value.
+     */
+    unwrapOr(defaultValue) {
+        return defaultValue;
+    }
+    /**
+     * Creates a new Fail instance.
+     * @param error The error value.
+     * @returns A new Fail instance containing the error.
+     *
+     * @template TSuccess - The type of the success value.
+     * @template TE - The type of the error value (default is Error).
+     *
+     * @static
+     */
+    static Create(error) {
+        return new Fail(error);
+    }
+}

package/{src/classes/Success.ts → dist/esm/src/classes/Success.d.ts}

@@ -1,91 +1,68 @@
-// type: class
-// description: Class representing a successful result.
-
 import { ResultState, ITResult } from "../interfaces/ITResult";
 import { ResultMatch } from "../types/ResultMatch";
 import { ChainedCallback, SuccessMapCallback, ErrorMapCallback } from "../types/resultsCallbacks";
 import { ATresult } from "./abstracts/ATresult";
-
 /**
  * Class representing a successful result.
  * @template TSuccess - The type of the success value.
  * @template TE - The type of the error value (default is Error).
  */
-export class Success<TSuccess, TE = Error> extends ATresult<TSuccess, TE> {
+export declare class Success<TSuccess, TE = Error> extends ATresult<TSuccess, TE> {
+    readonly value: TSuccess;
     /**
      * Creates an instance of Success.
      * @param value The success value.
      */
-    constructor(public readonly value: TSuccess) { super(); }
-
+    constructor(value: TSuccess);
     /**
      * Returns the state of the result.
      * @returns The state indicating success.
      */
-    state(): ResultState {
-        return ResultState.Success;
-    }
+    state(): ResultState;
     /**
      * Matches the result with the provided matcher functions.
      * @param matcher The matcher object containing functions for success and error cases.
      * @returns The result of the matched function.
      */
-    match<Result>(matcher: ResultMatch<TSuccess, TE, Result>): Result {
-        return matcher.Ok(this.value);
-    }
+    match<Result>(matcher: ResultMatch<TSuccess, TE, Result>): Result;
     /**
      * Chains the result with another operation that returns a new result.
      * @param fn The function to apply if the result is successful.
      * @returns The result of the chained operation.
      */
-    andThen<NewSuccess>(fn: ChainedCallback<TSuccess, NewSuccess, TE>): ITResult<NewSuccess, TE> {
-        return fn(this.value);
-    }
+    andThen<NewSuccess>(fn: ChainedCallback<TSuccess, NewSuccess, TE>): ITResult<NewSuccess, TE>;
     /**
      * Maps the success value to a new value.
      * @param fn The function to apply to the success value.
      * @returns A new Success instance containing the mapped value.
      */
-    map<NewSuccess>(fn: SuccessMapCallback<TSuccess, NewSuccess>): ITResult<NewSuccess, TE> {
-        return new Success(fn(this.value));
-    }
+    map<NewSuccess>(fn: SuccessMapCallback<TSuccess, NewSuccess>): ITResult<NewSuccess, TE>;
     /**
      * Maps the error value to a new error value.
      * @param _ The function to apply to the error value.
      * @returns A new Success instance containing the original success value.
      */
-    mapError<NewError>(_: ErrorMapCallback<TE, NewError>): ITResult<TSuccess, NewError> {
-        return new Success<TSuccess, NewError>(this.value);
-    }
-
+    mapError<NewError>(_: ErrorMapCallback<TE, NewError>): ITResult<TSuccess, NewError>;
     /**
      * Returns the success value or throws an error if the result is an error.
      * @returns The success value.
      */
-    throwIfError(): TSuccess {
-        return this.value;
-    }
-
+    throwIfError(): TSuccess;
     /**
      * Retrieves the success value or returns the provided default value if the result is an error.
      * @param _ The value to return if the result is an error.
      * @returns The success value if the result is a success, otherwise the default value.
      */
-    unwrapOr(_: TSuccess): TSuccess {
-        return this.value;
-    }
-
+    unwrapOr(_: TSuccess): TSuccess;
     /**
      * Creates a new Success instance.
      * @param value The success value.
      * @returns A new Success instance containing the value.
-     * 
+     *
      * @template TSuccess - The type of the success value.
      * @template TE - The type of the error value (default is Error).
-     * 
+     *
      * @static
      */
-    static Create<TSuccess, TE = Error>(value: TSuccess): Success<TSuccess, TE> {
-        return new Success(value);
-    }
-}
+    static Create<TSuccess, TE = Error>(value: TSuccess): Success<TSuccess, TE>;
+}

package/dist/esm/src/classes/Success.js

@@ -0,0 +1,86 @@
+// type: class
+// description: Class representing a successful result.
+import { ResultState } from "../interfaces/ITResult";
+import { ATresult } from "./abstracts/ATresult";
+/**
+ * Class representing a successful result.
+ * @template TSuccess - The type of the success value.
+ * @template TE - The type of the error value (default is Error).
+ */
+export class Success extends ATresult {
+    /**
+     * Creates an instance of Success.
+     * @param value The success value.
+     */
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    /**
+     * Returns the state of the result.
+     * @returns The state indicating success.
+     */
+    state() {
+        return ResultState.Success;
+    }
+    /**
+     * Matches the result with the provided matcher functions.
+     * @param matcher The matcher object containing functions for success and error cases.
+     * @returns The result of the matched function.
+     */
+    match(matcher) {
+        return matcher.Ok(this.value);
+    }
+    /**
+     * Chains the result with another operation that returns a new result.
+     * @param fn The function to apply if the result is successful.
+     * @returns The result of the chained operation.
+     */
+    andThen(fn) {
+        return fn(this.value);
+    }
+    /**
+     * Maps the success value to a new value.
+     * @param fn The function to apply to the success value.
+     * @returns A new Success instance containing the mapped value.
+     */
+    map(fn) {
+        return new Success(fn(this.value));
+    }
+    /**
+     * Maps the error value to a new error value.
+     * @param _ The function to apply to the error value.
+     * @returns A new Success instance containing the original success value.
+     */
+    mapError(_) {
+        return new Success(this.value);
+    }
+    /**
+     * Returns the success value or throws an error if the result is an error.
+     * @returns The success value.
+     */
+    throwIfError() {
+        return this.value;
+    }
+    /**
+     * Retrieves the success value or returns the provided default value if the result is an error.
+     * @param _ The value to return if the result is an error.
+     * @returns The success value if the result is a success, otherwise the default value.
+     */
+    unwrapOr(_) {
+        return this.value;
+    }
+    /**
+     * Creates a new Success instance.
+     * @param value The success value.
+     * @returns A new Success instance containing the value.
+     *
+     * @template TSuccess - The type of the success value.
+     * @template TE - The type of the error value (default is Error).
+     *
+     * @static
+     */
+    static Create(value) {
+        return new Success(value);
+    }
+}

package/{src/classes/abstracts/ATresult.ts → dist/esm/src/classes/abstracts/ATresult.d.ts}

@@ -1,44 +1,40 @@
-// type: class
-// description: Abstract class implementing the ITResult interface.
-
 import { ResultState, ITResult } from "../../interfaces/ITResult";
 import { ResultMatch } from "../../types/ResultMatch";
 import { ChainedCallback, ErrorMapCallback, SuccessMapCallback } from "../../types/resultsCallbacks";
-
 /**
  * Abstract class representing a result that can be either a success or an error.
  */
-export abstract class ATresult<Success, E = Error> implements ITResult<Success, E> {
+export declare abstract class ATresult<Success, E = Error> implements ITResult<Success, E> {
     /**
      * Gets the current state of the result.
-     * 
+     *
      * @returns The state of the result, either Success or Error.
      */
     abstract state(): ResultState;
     /**
      * Matches the result with the provided matcher functions.
-     * 
+     *
      * @param matcher - An object containing callback functions for success and error cases.
      * @returns The result of applying the appropriate matcher function.
      */
     abstract match<Result>(matcher: ResultMatch<Success, E, Result>): Result;
     /**
      * Chains the result with another operation that returns a new result.
-     * 
+     *
      * @param fn - A callback function that takes the success value and returns a new result.
      * @returns A new result after applying the chained operation.
      */
     abstract andThen<NewSuccess>(fn: ChainedCallback<Success, NewSuccess, E>): ITResult<NewSuccess, E>;
     /**
      * Maps the success value to a new value.
-     * 
+     *
      * @param fn - A callback function that takes the success value and returns a new success value.
      * @returns A new result with the mapped success value.
      */
     abstract map<NewSuccess>(fn: SuccessMapCallback<Success, NewSuccess>): ITResult<NewSuccess, E>;
     /**
      * Maps the error value to a new value.
-     * 
+     *
      * @param fn - A callback function that takes the error value and returns a new error value.
      * @returns A new result with the mapped error value.
      */
@@ -57,18 +53,14 @@ export abstract class ATresult<Success, E = Error> implements ITResult<Success,
     abstract unwrapOr(defaultValue: Success): Success;
     /**
      * Checks if the result is a success.
-     * 
+     *
      * @returns True if the result is a success, false otherwise.
      */
-    isSuccess(): boolean {
-        return this.state() === ResultState.Success;
-    }
+    isSuccess(): boolean;
     /**
      * Checks if the result is an error.
-     * 
+     *
      * @returns True if the result is an error, false otherwise.
      */
-    isError(): boolean {
-        return this.state() === ResultState.Error;
-    }
-}
+    isError(): boolean;
+}

package/dist/esm/src/classes/abstracts/ATresult.js

@@ -0,0 +1,24 @@
+// type: class
+// description: Abstract class implementing the ITResult interface.
+import { ResultState } from "../../interfaces/ITResult";
+/**
+ * Abstract class representing a result that can be either a success or an error.
+ */
+export class ATresult {
+    /**
+     * Checks if the result is a success.
+     *
+     * @returns True if the result is a success, false otherwise.
+     */
+    isSuccess() {
+        return this.state() === ResultState.Success;
+    }
+    /**
+     * Checks if the result is an error.
+     *
+     * @returns True if the result is an error, false otherwise.
+     */
+    isError() {
+        return this.state() === ResultState.Error;
+    }
+}

package/dist/esm/src/decorators/ErrorPath.d.ts

@@ -0,0 +1,7 @@
+import { ErrorCallback } from "../types/resultsCallbacks";
+/**
+ * Decorator to handle error path operations by executing a callback on errored results.
+ * @param fn Error path callback to be executed on errored results.
+ * @returns A method decorator that wraps the original method with error path handling.
+ */
+export declare function ErrorPath<T>(fn: ErrorCallback<T, void>): (target: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/dist/esm/src/decorators/ErrorPath.internal/functions.d.ts

@@ -0,0 +1,19 @@
+import { ErrorCallback } from "../../types/resultsCallbacks";
+/**
+ * Handles the error path for synchronous functions by executing a callback on errored results.
+ * @param this The context in which the original function is called.
+ * @param original The original function to be wrapped.
+ * @param path The error callback to be executed on errored results.
+ * @param args Arguments to be passed to the original function.
+ * @returns The result of the original function or the result of the error callback.
+ */
+export declare function errorPathSync(this: any, original: Function, path: ErrorCallback<any, any>, ...args: any[]): any;
+/**
+ * Handles the error path for asynchronous functions by executing a callback on errored results.
+ * @param this The context in which the original function is called.
+ * @param original The original function to be wrapped.
+ * @param path The error callback to be executed on errored results.
+ * @param args Arguments to be passed to the original function.
+ * @returns The result of the original function or the result of the error callback.
+ */
+export declare function errorPathAsync(this: any, original: Function, path: ErrorCallback<any, any>, ...args: any[]): Promise<any>;

package/{src/decorators/ErrorPath.internal/functions.ts → dist/esm/src/decorators/ErrorPath.internal/functions.js}

@@ -2,8 +2,6 @@
 //description: Functions to handle error path operations by executing a callback on errored results.
 import { ATresult } from "../../classes/abstracts/ATresult";
 import { applyMatch } from "../../functions/applyMatch";
-import { ErrorCallback } from "../../types/resultsCallbacks";
-
 /**
  * Handles the error path for synchronous functions by executing a callback on errored results.
  * @param this The context in which the original function is called.
@@ -12,14 +10,12 @@ import { ErrorCallback } from "../../types/resultsCallbacks";
  * @param args Arguments to be passed to the original function.
  * @returns The result of the original function or the result of the error callback.
  */
-export function errorPathSync(this: any, original: Function, path: ErrorCallback<any, any>, ...args: any[]): any {
+export function errorPathSync(original, path, ...args) {
     const result = original.call(this, ...args);
-
-    return result instanceof ATresult 
-                        ? applyMatch(result, undefined, path)
-                        : result;
+    return result instanceof ATresult
+        ? applyMatch(result, undefined, path)
+        : result;
 }
-
 /**
  * Handles the error path for asynchronous functions by executing a callback on errored results.
  * @param this The context in which the original function is called.
@@ -28,10 +24,9 @@ export function errorPathSync(this: any, original: Function, path: ErrorCallback
  * @param args Arguments to be passed to the original function.
  * @returns The result of the original function or the result of the error callback.
  */
-export async function errorPathAsync(this: any, original: Function, path: ErrorCallback<any, any>, ...args: any[]): any {
+export async function errorPathAsync(original, path, ...args) {
     const result = await original.call(this, ...args);
-
-    return result instanceof ATresult 
-                        ? applyMatch(result, undefined, path)
-                        : result;
-}
+    return result instanceof ATresult
+        ? applyMatch(result, undefined, path)
+        : result;
+}

package/{src/decorators/ErrorPath.ts → dist/esm/src/decorators/ErrorPath.js}

@@ -1,28 +1,25 @@
 //type: decorator
 //description: Decorator to handle error path operations by executing a callback on errored results.
-
-import { ErrorCallback } from "../types/resultsCallbacks";
 import { errorPathAsync, errorPathSync } from "./ErrorPath.internal/functions";
-
 /**
  * Decorator to handle error path operations by executing a callback on errored results.
  * @param fn Error path callback to be executed on errored results.
  * @returns A method decorator that wraps the original method with error path handling.
  */
-export function ErrorPath<T>(fn: ErrorCallback<T, void>) {
-    return function (target: any, key: string, descriptor: PropertyDescriptor) {
+export function ErrorPath(fn) {
+    return function (target, key, descriptor) {
         const original = descriptor.value;
         const isAsync = original.constructor.name === "AsyncFunction";
-
         if (isAsync) {
-            descriptor.value = async function (this: any, ...args: any[]) {
+            descriptor.value = async function (...args) {
                 return await errorPathAsync.call(this, original, fn, ...args);
             };
-        } else {
-            descriptor.value = function (this: any, ...args: any[]) {
+        }
+        else {
+            descriptor.value = function (...args) {
                 return errorPathSync.call(this, original, fn, ...args);
             };
         }
         return descriptor;
     };
-}
+}

package/dist/esm/src/decorators/HappyPath.d.ts

@@ -0,0 +1,7 @@
+import { SuccessCallback } from "../types/resultsCallbacks";
+/**
+ * Decorator to handle happy path operations by executing a callback on successful results.
+ * @param fn Happy path callback to be executed on successful results.
+ * @returns A method decorator that wraps the original method with happy path handling.
+ */
+export declare function HappyPath<T>(fn: SuccessCallback<T, void>): (target: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/dist/esm/src/decorators/HappyPath.internal/functions.d.ts

@@ -0,0 +1,19 @@
+import { SuccessCallback } from "../../types/resultsCallbacks";
+/**
+ * Handles the happy path for synchronous functions by executing a callback on successful results.
+ * @param this The context in which the original function is called.
+ * @param original The original function to be wrapped.
+ * @param path The success callback to be executed on successful results.
+ * @param args Arguments to be passed to the original function.
+ * @returns The result of the original function or the result of the success callback.
+ */
+export declare function happyPathSync(this: any, original: Function, path: SuccessCallback<any, any>, ...args: any[]): any;
+/**
+ * Handles the happy path for asynchronous functions by executing a callback on successful results.
+ * @param this The context in which the original function is called.
+ * @param original The original function to be wrapped.
+ * @param path The success callback to be executed on successful results.
+ * @param args Arguments to be passed to the original function.
+ * @returns The result of the original function or the result of the success callback.
+ */
+export declare function happyPathASync(this: any, original: Function, path: SuccessCallback<any, any>, ...args: any[]): Promise<any>;

package/{src/decorators/HappyPath.internal/functions.ts → dist/esm/src/decorators/HappyPath.internal/functions.js}

@@ -2,8 +2,6 @@
 //description: Functions to handle happy path operations by executing a callback on successful results.
 import { ATresult } from "../../classes/abstracts/ATresult";
 import { applyMatch } from "../../functions/applyMatch";
-import { SuccessCallback } from "../../types/resultsCallbacks";
-
 /**
  * Handles the happy path for synchronous functions by executing a callback on successful results.
  * @param this The context in which the original function is called.
@@ -12,14 +10,12 @@ import { SuccessCallback } from "../../types/resultsCallbacks";
  * @param args Arguments to be passed to the original function.
  * @returns The result of the original function or the result of the success callback.
  */
-export function happyPathSync(this: any, original: Function, path: SuccessCallback<any, any>, ...args: any[]): any {
+export function happyPathSync(original, path, ...args) {
     const result = original.call(this, ...args);
-
-    return result instanceof ATresult 
-                        ? applyMatch(result, path, undefined)
-                        : result;
+    return result instanceof ATresult
+        ? applyMatch(result, path, undefined)
+        : result;
 }
-
 /**
  * Handles the happy path for asynchronous functions by executing a callback on successful results.
  * @param this The context in which the original function is called.
@@ -28,10 +24,9 @@ export function happyPathSync(this: any, original: Function, path: SuccessCallba
  * @param args Arguments to be passed to the original function.
  * @returns The result of the original function or the result of the success callback.
  */
-export async function happyPathASync(this: any, original: Function, path: SuccessCallback<any, any>, ...args: any[]): any {
+export async function happyPathASync(original, path, ...args) {
     const result = await original.call(this, ...args);
-
-    return result instanceof ATresult 
-                        ? applyMatch(result, path, undefined)
-                        : result;
-}
+    return result instanceof ATresult
+        ? applyMatch(result, path, undefined)
+        : result;
+}