@rotomeca/rop 0.0.2 → 1.0.0

package/README.md

@@ -108,6 +108,15 @@ Perfect for **Side Effects** (logging, notifications) without polluting your bus
 saveData(data: any) { ... }
 ```
 
+**Note:** To use the decorators, ensure you have enabled experimentalDecorators in your tsconfig.json:
+```json
+{
+  "compilerOptions": {
+    "experimentalDecorators": true
+  }
+}
+```
+
 ## 📚 API Reference
 
 ### `Result<T, E>` Methods

package/dist/cjs/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+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/HappyPath"), exports);
+__exportStar(require("./src/decorators/ErrorPath"), exports);
+// Classes & Abstractions (Pour le typage et création manuelle)
+__exportStar(require("./src/classes/Fail"), exports);
+__exportStar(require("./src/classes/Success"), exports);
+var ATresult_1 = require("./src/classes/abstracts/ATresult");
+Object.defineProperty(exports, "Result", { enumerable: true, get: function () { return ATresult_1.ATresult; } });
+// Types (Pour l'IntelliSense)
+__exportStar(require("./src/types/resultsCallbacks"), exports);
+__exportStar(require("./src/types/ResultMatch"), exports);

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

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

@@ -0,0 +1,91 @@
+"use strict";
+// type: class
+// description: Class representing a error result.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fail = void 0;
+const ITResult_1 = require("../interfaces/ITResult");
+const ATresult_1 = require("./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).
+ */
+class Fail extends ATresult_1.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 ITResult_1.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);
+    }
+}
+exports.Fail = Fail;

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

@@ -0,0 +1,90 @@
+"use strict";
+// type: class
+// description: Class representing a successful result.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Success = void 0;
+const ITResult_1 = require("../interfaces/ITResult");
+const ATresult_1 = require("./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).
+ */
+class Success extends ATresult_1.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 ITResult_1.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);
+    }
+}
+exports.Success = Success;

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

@@ -0,0 +1,28 @@
+"use strict";
+// type: class
+// description: Abstract class implementing the ITResult interface.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ATresult = void 0;
+const ITResult_1 = require("../../interfaces/ITResult");
+/**
+ * Abstract class representing a result that can be either a success or an error.
+ */
+class ATresult {
+    /**
+     * Checks if the result is a success.
+     *
+     * @returns True if the result is a success, false otherwise.
+     */
+    isSuccess() {
+        return this.state() === ITResult_1.ResultState.Success;
+    }
+    /**
+     * Checks if the result is an error.
+     *
+     * @returns True if the result is an error, false otherwise.
+     */
+    isError() {
+        return this.state() === ITResult_1.ResultState.Error;
+    }
+}
+exports.ATresult = ATresult;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorPathAsync = exports.errorPathSync = void 0;
+//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.
+ * @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.
+ */
+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;
+}
+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.
+ * @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.
+ */
+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;
+}
+exports.errorPathAsync = errorPathAsync;

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

@@ -0,0 +1,29 @@
+"use strict";
+//type: decorator
+//description: Decorator to handle error path operations by executing a callback on errored results.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorPath = void 0;
+const functions_1 = require("./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.
+ */
+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;
+    };
+}
+exports.ErrorPath = ErrorPath;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.happyPathASync = exports.happyPathSync = void 0;
+//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.
+ * @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.
+ */
+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;
+}
+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.
+ * @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.
+ */
+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;
+}
+exports.happyPathASync = happyPathASync;

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

@@ -0,0 +1,29 @@
+"use strict";
+//type: decorator
+//description: Decorator to handle happy path operations by executing a callback on successful results.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HappyPath = void 0;
+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.
+ */
+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;
+    };
+}
+exports.HappyPath = HappyPath;

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

@@ -0,0 +1,42 @@
+"use strict";
+// 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;
+const ATresult_1 = require("../../classes/abstracts/ATresult");
+const Fail_1 = require("../../classes/Fail");
+const Success_1 = require("../../classes/Success");
+/**
+ * Handles synchronous risky operations by converting exceptions into Result types.
+ * @param this The context in which the original function is called.
+ * @param original The original function to be executed.
+ * @param args Arguments to be passed to the original function.
+ * @returns An ATresult representing success or failure.
+ */
+function riskySync(original, ...args) {
+    try {
+        const result = original.apply(this, args);
+        return result instanceof ATresult_1.ATresult ? result : Success_1.Success.Create(result);
+    }
+    catch (error) {
+        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.
+ * @param original The original function to be executed.
+ * @param args Arguments to be passed to the original function.
+ * @returns A Promise that resolves to an ATresult representing success or failure.
+ */
+async function riskyAsync(original, ...args) {
+    try {
+        const result = await original.apply(this, args);
+        return result instanceof ATresult_1.ATresult ? result : Success_1.Success.Create(result);
+    }
+    catch (error) {
+        return error instanceof ATresult_1.ATresult ? error : Fail_1.Fail.Create(error);
+    }
+}
+exports.riskyAsync = riskyAsync;

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

@@ -0,0 +1,28 @@
+"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.
+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);
+            };
+        }
+        else {
+            descriptor.value = function (...args) {
+                return functions_1.riskySync.call(this, original, ...args);
+            };
+        }
+        return descriptor;
+    };
+}
+exports.Risky = Risky;

package/{src/functions/applyMatch.ts → dist/cjs/src/functions/applyMatch.js}

@@ -1,9 +1,8 @@
+"use strict";
 //type: function
 //description: Function to apply match on a result with optional callbacks.
-
-import { ATresult } from "../classes/abstracts/ATresult";
-import { SuccessCallback, ErrorCallback } from "../types/resultsCallbacks";
-
+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.
@@ -11,19 +10,18 @@ import { SuccessCallback, ErrorCallback } from "../types/resultsCallbacks";
  * @param onError Additional callback for error case.
  * @returns Returns the original result after applying the match.
  */
-export function applyMatch(
-    result: ATresult<any>, 
-    onSuccess?: SuccessCallback<any, any>, 
-    onError?: ErrorCallback<any, any>
-): ATresult<any> {
+function applyMatch(result, onSuccess, onError) {
     return result.match({
         Ok: (val) => {
-            if (onSuccess) onSuccess(val);
+            if (onSuccess)
+                onSuccess(val);
             return result;
         },
         Err: (err) => {
-            if (onError) onError(err);
+            if (onError)
+                onError(err);
             return result;
         }
     });
-}
+}
+exports.applyMatch = applyMatch;

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

@@ -0,0 +1,19 @@
+"use strict";
+// type: interface
+// description: Interface for a result type that can represent either a success or an error.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultState = void 0;
+/**
+ * Enumeration representing the state of the result.
+ */
+var ResultState;
+(function (ResultState) {
+    /**
+     * The result represents a successful outcome.
+     */
+    ResultState[ResultState["Success"] = 0] = "Success";
+    /**
+     * The result represents an error outcome.
+     */
+    ResultState[ResultState["Error"] = 1] = "Error";
+})(ResultState = exports.ResultState || (exports.ResultState = {}));

package/dist/cjs/src/types/ResultMatch.js

@@ -0,0 +1,4 @@
+"use strict";
+// type: type
+// description: Type representing the matcher functions for a result type.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/src/types/resultsCallbacks.js

@@ -0,0 +1,4 @@
+"use strict";
+// type: types
+// description: Callback types for handling results in a functional way.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/index.d.ts

@@ -0,0 +1,8 @@
+export * from './src/decorators/Risky';
+export * from './src/decorators/HappyPath';
+export * from './src/decorators/ErrorPath';
+export * from './src/classes/Fail';
+export * from './src/classes/Success';
+export { ATresult as Result } from './src/classes/abstracts/ATresult';
+export * from './src/types/resultsCallbacks';
+export * from './src/types/ResultMatch';

package/{index.ts → dist/esm/index.js}

@@ -2,13 +2,10 @@
 export * from './src/decorators/Risky';
 export * from './src/decorators/HappyPath';
 export * from './src/decorators/ErrorPath';
-
 // Classes & Abstractions (Pour le typage et création manuelle)
 export * from './src/classes/Fail';
 export * from './src/classes/Success';
-export {ATresult as Result} from './src/classes/abstracts/ATresult';
-
+export { ATresult as Result } from './src/classes/abstracts/ATresult';
 // Types (Pour l'IntelliSense)
-export * from './src/types/resultsCallbacks'; 
+export * from './src/types/resultsCallbacks';
 export * from './src/types/ResultMatch';
-