@rotomeca/rop 1.0.0 → 2.0.0

package/README.md

@@ -98,13 +98,16 @@ Automatically wraps the method execution in a `try/catch` block.
 * If the method throws, it becomes `Fail(error)`.
 * Works with `async/await` and synchronous code.
 
+#### `@RiskyPath()`
+Same as Risky, but use it with ErrorPath and HappyPath.
+
 #### `@HappyPath(fn)` & `@ErrorPath(fn)`
 Perfect for **Side Effects** (logging, notifications) without polluting your business logic. These decorators act as "Taps": they inspect the result but **do not** modify the return value.
 
 ```typescript
 @ErrorPath((e) => Sentry.captureException(e)) // Only if fails
 @HappyPath((data) => Analytics.track('success', data)) // Only if success
-@Risky()
+@RiskyPath()
 saveData(data: any) { ... }
 ```
 

package/dist/cjs/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Result = void 0;
 // Décorateurs (API Publique principale)
 __exportStar(require("./src/decorators/Risky"), exports);
+__exportStar(require("./src/decorators/RiskyPath"), exports);
 __exportStar(require("./src/decorators/HappyPath"), exports);
 __exportStar(require("./src/decorators/ErrorPath"), exports);
 // Classes & Abstractions (Pour le typage et création manuelle)

package/dist/cjs/src/decorators/ErrorPath.internal/functions.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.errorPathAsync = exports.errorPathSync = void 0;
+exports.errorPathSync = errorPathSync;
+exports.errorPathAsync = errorPathAsync;
 //type: functions
 //description: Functions to handle error path operations by executing a callback on errored results.
 const ATresult_1 = require("../../classes/abstracts/ATresult");
-const applyMatch_1 = require("../../functions/applyMatch");
 /**
  * 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.
@@ -15,11 +15,14 @@ const applyMatch_1 = require("../../functions/applyMatch");
  */
 function errorPathSync(original, path, ...args) {
     const result = original.call(this, ...args);
-    return result instanceof ATresult_1.ATresult
-        ? (0, applyMatch_1.applyMatch)(result, undefined, path)
-        : result;
+    if (result instanceof ATresult_1.ATresult) {
+        return result.match({
+            Ok: (_) => result,
+            Err: (val) => val,
+        });
+    }
+    return path(result);
 }
-exports.errorPathSync = errorPathSync;
 /**
  * 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.
@@ -30,8 +33,11 @@ exports.errorPathSync = errorPathSync;
  */
 async function errorPathAsync(original, path, ...args) {
     const result = await original.call(this, ...args);
-    return result instanceof ATresult_1.ATresult
-        ? (0, applyMatch_1.applyMatch)(result, undefined, path)
-        : result;
+    if (result instanceof ATresult_1.ATresult) {
+        return result.match({
+            Ok: (_) => result,
+            Err: (val) => val,
+        });
+    }
+    return path(result);
 }
-exports.errorPathAsync = errorPathAsync;

package/dist/cjs/src/decorators/ErrorPath.js

@@ -1,8 +1,9 @@
 "use strict";
-//type: decorator
+//type: decorators
 //description: Decorator to handle error path operations by executing a callback on errored results.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorPath = void 0;
+exports.ErrorPath = ErrorPath;
+exports.ErrorPathAsync = ErrorPathAsync;
 const functions_1 = require("./ErrorPath.internal/functions");
 /**
  * Decorator to handle error path operations by executing a callback on errored results.
@@ -10,20 +11,21 @@ const functions_1 = require("./ErrorPath.internal/functions");
  * @returns A method decorator that wraps the original method with error path handling.
  */
 function ErrorPath(fn) {
-    return function (target, key, descriptor) {
-        const original = descriptor.value;
-        const isAsync = original.constructor.name === "AsyncFunction";
-        if (isAsync) {
-            descriptor.value = async function (...args) {
-                return await functions_1.errorPathAsync.call(this, original, fn, ...args);
-            };
-        }
-        else {
-            descriptor.value = function (...args) {
-                return functions_1.errorPathSync.call(this, original, fn, ...args);
-            };
-        }
-        return descriptor;
+    return function (originalMethod, context) {
+        return function (...args) {
+            return functions_1.errorPathSync.call(this, originalMethod, fn, ...args);
+        };
+    };
+}
+/**
+ * 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.
+ */
+function ErrorPathAsync(fn) {
+    return function (originalMethod, context) {
+        return async function (...args) {
+            return functions_1.errorPathAsync.call(this, originalMethod, fn, ...args);
+        };
     };
 }
-exports.ErrorPath = ErrorPath;

package/dist/cjs/src/decorators/HappyPath.internal/functions.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.happyPathASync = exports.happyPathSync = void 0;
+exports.happyPathSync = happyPathSync;
+exports.happyPathASync = happyPathASync;
 //type: functions
 //description: Functions to handle happy path operations by executing a callback on successful results.
 const ATresult_1 = require("../../classes/abstracts/ATresult");
-const applyMatch_1 = require("../../functions/applyMatch");
 /**
  * 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.
@@ -15,11 +15,14 @@ const applyMatch_1 = require("../../functions/applyMatch");
  */
 function happyPathSync(original, path, ...args) {
     const result = original.call(this, ...args);
-    return result instanceof ATresult_1.ATresult
-        ? (0, applyMatch_1.applyMatch)(result, path, undefined)
-        : result;
+    if (result instanceof ATresult_1.ATresult) {
+        return result.match({
+            Ok: (val) => path(val),
+            Err: (e) => result
+        });
+    }
+    return path(result);
 }
-exports.happyPathSync = happyPathSync;
 /**
  * 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.
@@ -30,8 +33,11 @@ exports.happyPathSync = happyPathSync;
  */
 async function happyPathASync(original, path, ...args) {
     const result = await original.call(this, ...args);
-    return result instanceof ATresult_1.ATresult
-        ? (0, applyMatch_1.applyMatch)(result, path, undefined)
-        : result;
+    if (result instanceof ATresult_1.ATresult) {
+        return result.match({
+            Ok: (val) => path(val),
+            Err: (e) => result
+        });
+    }
+    return path(result);
 }
-exports.happyPathASync = happyPathASync;

package/dist/cjs/src/decorators/HappyPath.js

@@ -1,29 +1,31 @@
 "use strict";
-//type: decorator
-//description: Decorator to handle happy path operations by executing a callback on successful results.
+//type: decorators
+//description: Decorator to handle error path operations by executing a callback on errored results.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HappyPath = void 0;
+exports.HappyPath = HappyPath;
+exports.HappyPathAsync = HappyPathAsync;
 const functions_1 = require("./HappyPath.internal/functions");
 /**
  * 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.
+ * @param fn A success callback to be executed on successful results.
+ * @returns Returns a method decorator that wraps the original method with happy path handling.
  */
 function HappyPath(fn) {
-    return function (target, key, descriptor) {
-        const original = descriptor.value;
-        const isAsync = original.constructor.name === "AsyncFunction";
-        if (isAsync) {
-            descriptor.value = async function (...args) {
-                return await functions_1.happyPathASync.call(this, original, fn, ...args);
-            };
-        }
-        else {
-            descriptor.value = function (...args) {
-                return functions_1.happyPathSync.call(this, original, fn, ...args);
-            };
-        }
-        return descriptor;
+    return function (originalMethod, context) {
+        return function (...args) {
+            return functions_1.happyPathSync.call(this, originalMethod, fn, ...args);
+        };
+    };
+}
+/**
+ * Decorator to handle happy path operations by executing a callback on successful results.
+ * @param fn A success callback to be executed on successful results.
+ * @returns Returns a method decorator that wraps the original method with happy path handling.
+ */
+function HappyPathAsync(fn) {
+    return function (originalMethod, context) {
+        return async function (...args) {
+            return await functions_1.happyPathASync.call(this, originalMethod, fn, ...args);
+        };
     };
 }
-exports.HappyPath = HappyPath;

package/dist/cjs/src/decorators/Risky.internal/functions.js

@@ -2,7 +2,8 @@
 // type: functions
 // description: Functions to handle risky operations by converting exceptions into Result types.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.riskyAsync = exports.riskySync = void 0;
+exports.riskySync = riskySync;
+exports.riskyAsync = riskyAsync;
 const ATresult_1 = require("../../classes/abstracts/ATresult");
 const Fail_1 = require("../../classes/Fail");
 const Success_1 = require("../../classes/Success");
@@ -22,7 +23,6 @@ function riskySync(original, ...args) {
         return error instanceof ATresult_1.ATresult ? error : Fail_1.Fail.Create(error);
     }
 }
-exports.riskySync = riskySync;
 /**
  * Handles asynchronous risky operations by converting exceptions into Result types.
  * @param this The context in which the original function is called.
@@ -39,4 +39,3 @@ async function riskyAsync(original, ...args) {
         return error instanceof ATresult_1.ATresult ? error : Fail_1.Fail.Create(error);
     }
 }
-exports.riskyAsync = riskyAsync;

package/dist/cjs/src/decorators/Risky.js

@@ -1,28 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Risky = void 0;
-// type: decorator
-// description: Decorator to handle risky operations by converting exceptions into Result types.
+exports.Risky = Risky;
+exports.RiskyAsync = RiskyAsync;
 const functions_1 = require("./Risky.internal/functions");
 /**
  * Decorator to handle risky operations by converting exceptions into Result types.
  * @returns A method decorator that wraps the original method with error handling.
  */
 function Risky() {
-    return function (target, key, descriptor) {
-        const original = descriptor.value;
-        const isAsync = original.constructor.name === "AsyncFunction";
-        if (isAsync) {
-            descriptor.value = async function (...args) {
-                return functions_1.riskyAsync.call(this, original, ...args);
-            };
+    return function (originalMethod, context) {
+        if (context.kind !== "method") {
+            throw new Error("Risky can only be applied to methods.");
         }
-        else {
-            descriptor.value = function (...args) {
-                return functions_1.riskySync.call(this, original, ...args);
-            };
+        return (function (...args) {
+            return functions_1.riskySync.call(this, originalMethod, ...args);
+        });
+    };
+}
+/**
+ * Decorator to handle risky async operations by converting exceptions into Result types.
+ * @returns A method decorator that wraps the original method with error handling.
+ */
+function RiskyAsync() {
+    return function (originalMethod, context) {
+        if (context.kind !== "method") {
+            throw new Error("RiskyAsync can only be applied to methods.");
         }
-        return descriptor;
+        return (async function (...args) {
+            return await functions_1.riskyAsync.call(this, originalMethod, ...args);
+        });
     };
 }
-exports.Risky = Risky;

package/dist/cjs/src/decorators/RiskyPath.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RiskyPath = RiskyPath;
+exports.RiskyPathAsync = RiskyPathAsync;
+const functions_1 = require("./Risky.internal/functions");
+/**
+ * Decorator to handle risky operations by converting exceptions into Result types.
+ * Use with HappyPath or ErrorPath to handle the respective paths.
+ * @returns A method decorator that wraps the original method with error handling.
+ */
+function RiskyPath() {
+    return function (originalMethod, context) {
+        if (context.kind !== "method") {
+            throw new Error("RiskyPath can only be applied to methods.");
+        }
+        return (function (...args) {
+            return functions_1.riskySync.call(this, originalMethod, ...args);
+        });
+    };
+}
+/**
+ * Decorator to handle risky async operations by converting exceptions into Result types.
+ * Use with HappyPath or ErrorPath to handle the respective paths.
+ * @returns A method decorator that wraps the original method with error handling.
+ */
+function RiskyPathAsync() {
+    return function (originalMethod, context) {
+        if (context.kind !== "method") {
+            throw new Error("RiskyPathAsync can only be applied to methods.");
+        }
+        return (async function (...args) {
+            return await functions_1.riskyAsync.call(this, originalMethod, ...args);
+        });
+    };
+}

package/dist/cjs/src/interfaces/ITResult.js

@@ -16,4 +16,4 @@ var ResultState;
      * The result represents an error outcome.
      */
     ResultState[ResultState["Error"] = 1] = "Error";
-})(ResultState = exports.ResultState || (exports.ResultState = {}));
+})(ResultState || (exports.ResultState = ResultState = {}));

package/dist/esm/index.d.ts

@@ -1,4 +1,5 @@
 export * from './src/decorators/Risky';
+export * from './src/decorators/RiskyPath';
 export * from './src/decorators/HappyPath';
 export * from './src/decorators/ErrorPath';
 export * from './src/classes/Fail';

package/dist/esm/index.js

@@ -1,5 +1,6 @@
 // Décorateurs (API Publique principale)
 export * from './src/decorators/Risky';
+export * from './src/decorators/RiskyPath';
 export * from './src/decorators/HappyPath';
 export * from './src/decorators/ErrorPath';
 // Classes & Abstractions (Pour le typage et création manuelle)

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

@@ -4,4 +4,10 @@ import { ErrorCallback } from "../types/resultsCallbacks";
  * @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;
+export declare function ErrorPath<T>(fn: ErrorCallback<T, void>): (this: any, originalMethod: Function, context: ClassMethodDecoratorContext) => (this: any, ...args: any[]) => any;
+/**
+ * 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 ErrorPathAsync<T>(fn: ErrorCallback<T, void>): (this: any, originalMethod: Function, context: ClassMethodDecoratorContext) => (this: any, ...args: any[]) => Promise<any>;

package/dist/esm/src/decorators/ErrorPath.internal/functions.js

@@ -1,7 +1,6 @@
 //type: functions
 //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";
 /**
  * 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,9 +11,13 @@ import { applyMatch } from "../../functions/applyMatch";
  */
 export function errorPathSync(original, path, ...args) {
     const result = original.call(this, ...args);
-    return result instanceof ATresult
-        ? applyMatch(result, undefined, path)
-        : result;
+    if (result instanceof ATresult) {
+        return result.match({
+            Ok: (_) => result,
+            Err: (val) => val,
+        });
+    }
+    return path(result);
 }
 /**
  * Handles the error path for asynchronous functions by executing a callback on errored results.
@@ -26,7 +29,11 @@ export function errorPathSync(original, path, ...args) {
  */
 export async function errorPathAsync(original, path, ...args) {
     const result = await original.call(this, ...args);
-    return result instanceof ATresult
-        ? applyMatch(result, undefined, path)
-        : result;
+    if (result instanceof ATresult) {
+        return result.match({
+            Ok: (_) => result,
+            Err: (val) => val,
+        });
+    }
+    return path(result);
 }

package/dist/esm/src/decorators/ErrorPath.js

@@ -1,4 +1,4 @@
-//type: decorator
+//type: decorators
 //description: Decorator to handle error path operations by executing a callback on errored results.
 import { errorPathAsync, errorPathSync } from "./ErrorPath.internal/functions";
 /**
@@ -7,19 +7,21 @@ import { errorPathAsync, errorPathSync } from "./ErrorPath.internal/functions";
  * @returns A method decorator that wraps the original method with error path handling.
  */
 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 (...args) {
-                return await errorPathAsync.call(this, original, fn, ...args);
-            };
-        }
-        else {
-            descriptor.value = function (...args) {
-                return errorPathSync.call(this, original, fn, ...args);
-            };
-        }
-        return descriptor;
+    return function (originalMethod, context) {
+        return function (...args) {
+            return errorPathSync.call(this, originalMethod, fn, ...args);
+        };
+    };
+}
+/**
+ * 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 ErrorPathAsync(fn) {
+    return function (originalMethod, context) {
+        return async function (...args) {
+            return errorPathAsync.call(this, originalMethod, fn, ...args);
+        };
     };
 }

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

@@ -1,7 +1,13 @@
 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.
+ * @param fn A success callback to be executed on successful results.
+ * @returns 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;
+export declare function HappyPath<TSuccess, TReturn>(fn: SuccessCallback<TSuccess, TReturn>): (this: any, originalMethod: Function, context: ClassMethodDecoratorContext) => (this: any, ...args: any[]) => any;
+/**
+ * Decorator to handle happy path operations by executing a callback on successful results.
+ * @param fn A success callback to be executed on successful results.
+ * @returns Returns a method decorator that wraps the original method with happy path handling.
+ */
+export declare function HappyPathAsync<TSuccess, TReturn>(fn: SuccessCallback<TSuccess, TReturn>): (this: any, originalMethod: Function, context: ClassMethodDecoratorContext) => (this: any, ...args: any[]) => Promise<any>;

package/dist/esm/src/decorators/HappyPath.internal/functions.js

@@ -1,7 +1,6 @@
 //type: functions
 //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";
 /**
  * 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,9 +11,13 @@ import { applyMatch } from "../../functions/applyMatch";
  */
 export function happyPathSync(original, path, ...args) {
     const result = original.call(this, ...args);
-    return result instanceof ATresult
-        ? applyMatch(result, path, undefined)
-        : result;
+    if (result instanceof ATresult) {
+        return result.match({
+            Ok: (val) => path(val),
+            Err: (e) => result
+        });
+    }
+    return path(result);
 }
 /**
  * Handles the happy path for asynchronous functions by executing a callback on successful results.
@@ -26,7 +29,11 @@ export function happyPathSync(original, path, ...args) {
  */
 export async function happyPathASync(original, path, ...args) {
     const result = await original.call(this, ...args);
-    return result instanceof ATresult
-        ? applyMatch(result, path, undefined)
-        : result;
+    if (result instanceof ATresult) {
+        return result.match({
+            Ok: (val) => path(val),
+            Err: (e) => result
+        });
+    }
+    return path(result);
 }

package/dist/esm/src/decorators/HappyPath.js

@@ -1,25 +1,27 @@
-//type: decorator
-//description: Decorator to handle happy path operations by executing a callback on successful results.
+//type: decorators
+//description: Decorator to handle error path operations by executing a callback on errored results.
 import { happyPathASync, happyPathSync } from "./HappyPath.internal/functions";
 /**
  * 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.
+ * @param fn A success callback to be executed on successful results.
+ * @returns Returns a method decorator that wraps the original method with happy path handling.
  */
 export function HappyPath(fn) {
-    return function (target, key, descriptor) {
-        const original = descriptor.value;
-        const isAsync = original.constructor.name === "AsyncFunction";
-        if (isAsync) {
-            descriptor.value = async function (...args) {
-                return await happyPathASync.call(this, original, fn, ...args);
-            };
-        }
-        else {
-            descriptor.value = function (...args) {
-                return happyPathSync.call(this, original, fn, ...args);
-            };
-        }
-        return descriptor;
+    return function (originalMethod, context) {
+        return function (...args) {
+            return happyPathSync.call(this, originalMethod, fn, ...args);
+        };
+    };
+}
+/**
+ * Decorator to handle happy path operations by executing a callback on successful results.
+ * @param fn A success callback to be executed on successful results.
+ * @returns Returns a method decorator that wraps the original method with happy path handling.
+ */
+export function HappyPathAsync(fn) {
+    return function (originalMethod, context) {
+        return async function (...args) {
+            return await happyPathASync.call(this, originalMethod, fn, ...args);
+        };
     };
 }

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

@@ -1,5 +1,11 @@
+import { ATresult } from "../classes/abstracts/ATresult";
 /**
  * Decorator to handle risky operations by converting exceptions into Result types.
  * @returns A method decorator that wraps the original method with error handling.
  */
-export declare function Risky(): (target: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function Risky(): (originalMethod: Function, context: ClassMethodDecoratorContext) => (this: any, ...args: any[]) => ATresult<any>;
+/**
+ * Decorator to handle risky async operations by converting exceptions into Result types.
+ * @returns A method decorator that wraps the original method with error handling.
+ */
+export declare function RiskyAsync(): (originalMethod: Function, context: ClassMethodDecoratorContext) => (this: any, ...args: any[]) => Promise<ATresult<any>>;

package/dist/esm/src/decorators/Risky.js

@@ -1,24 +1,29 @@
-// type: decorator
-// description: Decorator to handle risky operations by converting exceptions into Result types.
 import { riskyAsync, riskySync } from "./Risky.internal/functions";
 /**
  * Decorator to handle risky operations by converting exceptions into Result types.
  * @returns A method decorator that wraps the original method with error handling.
  */
 export function Risky() {
-    return function (target, key, descriptor) {
-        const original = descriptor.value;
-        const isAsync = original.constructor.name === "AsyncFunction";
-        if (isAsync) {
-            descriptor.value = async function (...args) {
-                return riskyAsync.call(this, original, ...args);
-            };
+    return function (originalMethod, context) {
+        if (context.kind !== "method") {
+            throw new Error("Risky can only be applied to methods.");
         }
-        else {
-            descriptor.value = function (...args) {
-                return riskySync.call(this, original, ...args);
-            };
+        return (function (...args) {
+            return riskySync.call(this, originalMethod, ...args);
+        });
+    };
+}
+/**
+ * Decorator to handle risky async operations by converting exceptions into Result types.
+ * @returns A method decorator that wraps the original method with error handling.
+ */
+export function RiskyAsync() {
+    return function (originalMethod, context) {
+        if (context.kind !== "method") {
+            throw new Error("RiskyAsync can only be applied to methods.");
         }
-        return descriptor;
+        return (async function (...args) {
+            return await riskyAsync.call(this, originalMethod, ...args);
+        });
     };
 }

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

@@ -0,0 +1,12 @@
+/**
+ * Decorator to handle risky operations by converting exceptions into Result types.
+ * Use with HappyPath or ErrorPath to handle the respective paths.
+ * @returns A method decorator that wraps the original method with error handling.
+ */
+export declare function RiskyPath(): (originalMethod: Function, context: ClassMethodDecoratorContext) => any;
+/**
+ * Decorator to handle risky async operations by converting exceptions into Result types.
+ * Use with HappyPath or ErrorPath to handle the respective paths.
+ * @returns A method decorator that wraps the original method with error handling.
+ */
+export declare function RiskyPathAsync(): (originalMethod: Function, context: ClassMethodDecoratorContext) => any;

package/dist/esm/src/decorators/RiskyPath.js

@@ -0,0 +1,31 @@
+import { riskyAsync, riskySync } from "./Risky.internal/functions";
+/**
+ * Decorator to handle risky operations by converting exceptions into Result types.
+ * Use with HappyPath or ErrorPath to handle the respective paths.
+ * @returns A method decorator that wraps the original method with error handling.
+ */
+export function RiskyPath() {
+    return function (originalMethod, context) {
+        if (context.kind !== "method") {
+            throw new Error("RiskyPath can only be applied to methods.");
+        }
+        return (function (...args) {
+            return riskySync.call(this, originalMethod, ...args);
+        });
+    };
+}
+/**
+ * Decorator to handle risky async operations by converting exceptions into Result types.
+ * Use with HappyPath or ErrorPath to handle the respective paths.
+ * @returns A method decorator that wraps the original method with error handling.
+ */
+export function RiskyPathAsync() {
+    return function (originalMethod, context) {
+        if (context.kind !== "method") {
+            throw new Error("RiskyPathAsync can only be applied to methods.");
+        }
+        return (async function (...args) {
+            return await riskyAsync.call(this, originalMethod, ...args);
+        });
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rotomeca/rop",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "type": "module", 
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
@@ -30,6 +30,6 @@
     "eslint": "^8.57.1",
     "prettier": "^3.8.1",
     "prettier-eslint": "^16.4.2",
-    "typescript": "^4.9.5"
+    "typescript": "^5.6.3"
   }
 }

package/dist/cjs/src/functions/applyMatch.js

@@ -1,27 +0,0 @@
-"use strict";
-//type: function
-//description: Function to apply match on a result with optional callbacks.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyMatch = void 0;
-/**
- * Applies match on the given result with optional success and error callbacks.
- * @param result Result to apply match on.
- * @param onSuccess Additional callback for success case.
- * @param onError Additional callback for error case.
- * @returns Returns the original result after applying the match.
- */
-function applyMatch(result, onSuccess, onError) {
-    return result.match({
-        Ok: (val) => {
-            if (onSuccess)
-                onSuccess(val);
-            return result;
-        },
-        Err: (err) => {
-            if (onError)
-                onError(err);
-            return result;
-        }
-    });
-}
-exports.applyMatch = applyMatch;

package/dist/esm/src/functions/applyMatch.d.ts

@@ -1,10 +0,0 @@
-import { ATresult } from "../classes/abstracts/ATresult";
-import { SuccessCallback, ErrorCallback } from "../types/resultsCallbacks";
-/**
- * Applies match on the given result with optional success and error callbacks.
- * @param result Result to apply match on.
- * @param onSuccess Additional callback for success case.
- * @param onError Additional callback for error case.
- * @returns Returns the original result after applying the match.
- */
-export declare function applyMatch(result: ATresult<any>, onSuccess?: SuccessCallback<any, any>, onError?: ErrorCallback<any, any>): ATresult<any>;

package/dist/esm/src/functions/applyMatch.js

@@ -1,23 +0,0 @@
-//type: function
-//description: Function to apply match on a result with optional callbacks.
-/**
- * Applies match on the given result with optional success and error callbacks.
- * @param result Result to apply match on.
- * @param onSuccess Additional callback for success case.
- * @param onError Additional callback for error case.
- * @returns Returns the original result after applying the match.
- */
-export function applyMatch(result, onSuccess, onError) {
-    return result.match({
-        Ok: (val) => {
-            if (onSuccess)
-                onSuccess(val);
-            return result;
-        },
-        Err: (err) => {
-            if (onError)
-                onError(err);
-            return result;
-        }
-    });
-}