@carbonbox/domain 0.1.5 → 0.2.2

package/build/carbonbox/emission-calculation-process/calculation-processes/domain/entity/CalculationProcess.js

@@ -218,3 +218,14 @@ exports.CalculationProcess = CalculationProcess;
 _CalculationProcess_carbonClient = new WeakMap(), _CalculationProcess_footprintConfiguration = new WeakMap(), _CalculationProcess_scheduledAt = new WeakMap(), _CalculationProcess_estimatedDuration = new WeakMap(), _CalculationProcess_priority = new WeakMap(), _CalculationProcess_dependencies = new WeakMap(), _CalculationProcess_executedByStakeholder = new WeakMap(), _CalculationProcess_startedAt = new WeakMap(), _CalculationProcess_completedAt = new WeakMap(), _CalculationProcess_actualDuration = new WeakMap(), _CalculationProcess_status = new WeakMap(), _CalculationProcess_errorMessage = new WeakMap(), _CalculationProcess_progressPercentage = new WeakMap(), _CalculationProcess_submissionsToProcess = new WeakMap(), _CalculationProcess_calculationsGenerated = new WeakMap(), _CalculationProcess_totalEmissionsCalculated = new WeakMap(), _CalculationProcess_processNotes = new WeakMap(), _CalculationProcess_retryCount = new WeakMap(), _CalculationProcess_maxRetries = new WeakMap();
 // TODO: Validar que todo lo que herede de String, Boolean, Numeric, PositiveInteger, DateTimeString
 // AggregateId, AggregateIdList, Code, CodeList, tenga guardas en el create
+// TODO: Auditar proyecto con
+/*
+ Auditar y corregir negaciones implícitas (!)
+      Convertir métodos privados a sintaxis # en módulo
+      Todo método público , ya sea estático o no debe de tener la palabra clave public
+      Eliminar todos los 'any' y mejorar tipado en módulo
+     Implementar null safety apropiado en módulo
+     Verificar tipado fuerte y corregir type assertions
+
+     Tampoco usamos new Error, creamos las expetions específicas para el caso y ser lanzadas, por favor valida lo que has planteado y corríge según sea necesario
+*/

package/build/carbonbox/shared/either/domain/exceptions/FilterOperationNotImplementedError.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterOperationNotImplementedError = void 0;
+const RootError_1 = require("../../../domain/exceptions/RootError");
+class FilterOperationNotImplementedError extends RootError_1.RootError {
+    constructor(message) {
+        super(message);
+        this.name = 'FilterOperationNotImplementedError';
+    }
+    static create(context) {
+        return new FilterOperationNotImplementedError(`Filter operation must be implemented via EitherUtils${context ? ` in ${context}` : ''}`);
+    }
+    logError() {
+        return `${this.name}: ${this.message}`;
+    }
+}
+exports.FilterOperationNotImplementedError = FilterOperationNotImplementedError;

package/build/carbonbox/shared/either/domain/exceptions/SwapOperationNotImplementedError.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapOperationNotImplementedError = void 0;
+const RootError_1 = require("../../../domain/exceptions/RootError");
+class SwapOperationNotImplementedError extends RootError_1.RootError {
+    constructor(message) {
+        super(message);
+        this.name = 'SwapOperationNotImplementedError';
+    }
+    static create(context) {
+        return new SwapOperationNotImplementedError(`Swap operation must be implemented via EitherUtils${context ? ` in ${context}` : ''}`);
+    }
+    logError() {
+        return `${this.name}: ${this.message}`;
+    }
+}
+exports.SwapOperationNotImplementedError = SwapOperationNotImplementedError;

package/build/carbonbox/shared/either/domain/factories/EitherFactory.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EitherFactory = void 0;
+const LeftEitherImpl_1 = require("../implementations/LeftEitherImpl");
+const RightEitherImpl_1 = require("../implementations/RightEitherImpl");
+const EitherUtils_1 = require("../utils/EitherUtils");
+/**
+ * Factory para crear instancias de Either
+ * Resuelve las dependencias circulares al separar la creación de la implementación
+ */
+class EitherFactory {
+    // ─── Factory Methods ─────────────────────────────────────────────────────────
+    /** Crea un Either Left que contiene un valor de error */
+    static left(value) {
+        return new LeftEitherImpl_1.LeftEitherImpl(value);
+    }
+    /** Crea un Either Right que contiene un valor de éxito */
+    static right(value) {
+        return new RightEitherImpl_1.RightEitherImpl(value);
+    }
+    // ─── Factory Methods para manejo de errores ─────────────────────────────────
+    /** Factory method para manejo seguro de operaciones que pueden fallar */
+    static fromTryCatch(operation, errorMapper) {
+        try {
+            return EitherFactory.right(operation());
+        }
+        catch (error) {
+            return EitherFactory.left(errorMapper(error));
+        }
+    }
+    /** Factory method para promesas */
+    static async fromPromise(promise, errorMapper) {
+        try {
+            const result = await promise;
+            return EitherFactory.right(result);
+        }
+        catch (error) {
+            return EitherFactory.left(errorMapper(error));
+        }
+    }
+    /** Factory method para valores que pueden ser null o undefined */
+    static fromNullable(value, errorFactory) {
+        return value !== null && value !== undefined
+            ? EitherFactory.right(value)
+            : EitherFactory.left(errorFactory());
+    }
+    /** Factory method para operaciones condicionales */
+    static fromCondition(condition, rightValue, leftValue) {
+        return condition === true
+            ? EitherFactory.right(rightValue())
+            : EitherFactory.left(leftValue());
+    }
+    // ─── Factory Methods para colecciones ───────────────────────────────────────
+    /** Combina múltiples Either en uno solo - falla en el primer Left */
+    static sequence(eithers) {
+        return EitherUtils_1.EitherUtils.sequence(eithers);
+    }
+    /** Aplica una función que puede fallar a cada elemento */
+    static traverse(items, fn) {
+        return EitherUtils_1.EitherUtils.traverse(items, fn);
+    }
+    /** Combina dos Either con una función */
+    static lift2(fn, eitherA, eitherB) {
+        return EitherUtils_1.EitherUtils.lift2(fn, eitherA, eitherB);
+    }
+    /** Combina tres Either con una función */
+    static lift3(fn, eitherA, eitherB, eitherC) {
+        return EitherUtils_1.EitherUtils.lift3(fn, eitherA, eitherB, eitherC);
+    }
+    /** Acumula errores en lugar de fallar en el primero */
+    static accumulate(eithers) {
+        return EitherUtils_1.EitherUtils.accumulate(eithers);
+    }
+    /** Ejecuta Either en paralelo y acumula todos los errores */
+    static async parallel(operations) {
+        return EitherUtils_1.EitherUtils.parallel(operations);
+    }
+    // ─── Factory Methods para transformaciones complejas ────────────────────────
+    /** Aplica una transformación solo si se cumple una condición */
+    static when(condition, transform) {
+        return EitherUtils_1.EitherUtils.when(condition, transform);
+    }
+    /** Aplica una transformación solo si NO se cumple una condición */
+    static unless(condition, transform) {
+        return EitherUtils_1.EitherUtils.unless(condition, transform);
+    }
+}
+exports.EitherFactory = EitherFactory;

package/build/carbonbox/shared/either/domain/factories/ResultFactory.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultFactory = void 0;
+const EitherFactory_1 = require("./EitherFactory");
+/**
+ * Factory especializado para crear Result (Either con DomainFailure)
+ * Proporciona métodos específicos para el manejo de errores de dominio
+ */
+class ResultFactory {
+    // ─── Factory Methods básicos ─────────────────────────────────────────────────
+    /** Crea un Result de fallo con un solo error */
+    static fail(error) {
+        return EitherFactory_1.EitherFactory.left({ type: 'single', error });
+    }
+    /** Crea un Result de fallo con múltiples errores */
+    static failMultiple(errors) {
+        return EitherFactory_1.EitherFactory.left({ type: 'multiple', errors });
+    }
+    /** Crea un Result de éxito */
+    static ok(value) {
+        return EitherFactory_1.EitherFactory.right(value);
+    }
+    // ─── Factory Methods para conversiones ───────────────────────────────────────
+    /** Convierte un Either simple a Result */
+    static fromEither(either) {
+        return either.mapLeft((error) => ({ type: 'single', error }));
+    }
+    /** Convierte un Either con múltiples errores a Result */
+    static fromEitherMultiple(either) {
+        return either.mapLeft((errors) => ({ type: 'multiple', errors }));
+    }
+    /** Convierte un valor nullable a Result */
+    static fromNullable(value, errorFactory) {
+        return value !== null && value !== undefined
+            ? ResultFactory.ok(value)
+            : ResultFactory.fail(errorFactory());
+    }
+    /** Convierte una condición a Result */
+    static fromCondition(condition, valueFactory, errorFactory) {
+        return condition === true
+            ? ResultFactory.ok(valueFactory())
+            : ResultFactory.fail(errorFactory());
+    }
+    // ─── Factory Methods para operaciones complejas ─────────────────────────────
+    /** Ejecuta una operación que puede fallar */
+    static fromTryCatch(operation, errorMapper) {
+        return EitherFactory_1.EitherFactory.fromTryCatch(operation, errorMapper).mapLeft((error) => ({ type: 'single', error }));
+    }
+    /** Ejecuta una promesa que puede fallar */
+    static async fromPromise(promise, errorMapper) {
+        const result = await EitherFactory_1.EitherFactory.fromPromise(promise, errorMapper);
+        return result.mapLeft((error) => ({ type: 'single', error }));
+    }
+    // ─── Factory Methods para colecciones ───────────────────────────────────────
+    /** Combina múltiples Result en uno solo - falla en el primer error */
+    static sequence(results) {
+        return EitherFactory_1.EitherFactory.sequence(results);
+    }
+    /** Aplica una función que puede fallar a cada elemento */
+    static traverse(items, fn) {
+        return EitherFactory_1.EitherFactory.traverse(items, fn);
+    }
+    /** Acumula todos los errores en lugar de fallar en el primero */
+    static accumulate(results) {
+        const lefts = [];
+        const rights = [];
+        for (const result of results) {
+            result.fold((failure) => lefts.push(failure), (value) => rights.push(value));
+        }
+        if (lefts.length === 0) {
+            return ResultFactory.ok(rights);
+        }
+        // Combinar todos los errores
+        const allErrors = [];
+        for (const failure of lefts) {
+            if (failure.type === 'single') {
+                allErrors.push(failure.error);
+            }
+            else {
+                allErrors.push(...failure.errors);
+            }
+        }
+        return ResultFactory.failMultiple(allErrors);
+    }
+    /** Ejecuta validaciones en paralelo */
+    static async parallel(operations) {
+        const results = await Promise.all(operations.map((op) => op()));
+        return ResultFactory.accumulate(results);
+    }
+    // ─── Factory Methods para validaciones ──────────────────────────────────────
+    /** Crea una cadena de validaciones */
+    static chain(...validations) {
+        return (value) => {
+            let result = ResultFactory.ok(value);
+            for (const validation of validations) {
+                result = result.flatMap(validation);
+                if (result.isLeft === true) {
+                    break;
+                }
+            }
+            return result;
+        };
+    }
+    /** Aplica múltiples validaciones y acumula errores */
+    static validate(value, ...validations) {
+        const results = validations.map((validation) => validation(value));
+        return ResultFactory.accumulate(results).map(() => value);
+    }
+    /** Crea un validador condicional */
+    static when(condition, validation) {
+        return (value) => {
+            if (condition(value) === true) {
+                return validation(value);
+            }
+            return ResultFactory.ok(value);
+        };
+    }
+    /** Crea un validador que se ejecuta solo si NO se cumple la condición */
+    static unless(condition, validation) {
+        return ResultFactory.when((value) => condition(value) !== true, validation);
+    }
+}
+exports.ResultFactory = ResultFactory;

package/build/carbonbox/shared/either/domain/implementations/LeftEitherImpl.js

@@ -0,0 +1,92 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _LeftEitherImpl_value;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeftEitherImpl = void 0;
+const CannotAccessRightOnLeftValueError_1 = require("../exceptions/CannotAccessRightOnLeftValueError");
+const SwapOperationNotImplementedError_1 = require("../exceptions/SwapOperationNotImplementedError");
+/**
+ * Implementación concreta de LeftEither
+ * Representa el estado de fallo en el patrón Either
+ */
+class LeftEitherImpl {
+    constructor(value) {
+        this.state = 'left';
+        _LeftEitherImpl_value.set(this, void 0);
+        __classPrivateFieldSet(this, _LeftEitherImpl_value, value, "f");
+    }
+    // ─── Predicados tipo-seguros ─────────────────────────────────────────────────
+    get isLeft() {
+        return true;
+    }
+    get isRight() {
+        return false;
+    }
+    // ─── Métodos de acceso seguros ───────────────────────────────────────────────
+    getLeft() {
+        return __classPrivateFieldGet(this, _LeftEitherImpl_value, "f");
+    }
+    getRight() {
+        return undefined;
+    }
+    // ─── Métodos de acceso que lanzan excepción ──────────────────────────────────
+    left() {
+        return __classPrivateFieldGet(this, _LeftEitherImpl_value, "f");
+    }
+    right() {
+        throw CannotAccessRightOnLeftValueError_1.CannotAccessRightOnLeftValueError.create(__classPrivateFieldGet(this, _LeftEitherImpl_value, "f"));
+    }
+    // ─── Transformaciones funcionales ────────────────────────────────────────────
+    map() {
+        // No se ejecuta la transformación en Left, solo cambia el tipo
+        return new LeftEitherImpl(__classPrivateFieldGet(this, _LeftEitherImpl_value, "f"));
+    }
+    mapLeft(fn) {
+        // Aplica la transformación al valor Left
+        return new LeftEitherImpl(fn(__classPrivateFieldGet(this, _LeftEitherImpl_value, "f")));
+    }
+    flatMap() {
+        // No se ejecuta la transformación en Left, solo cambia el tipo
+        return new LeftEitherImpl(__classPrivateFieldGet(this, _LeftEitherImpl_value, "f"));
+    }
+    // ─── Métodos de utilidad ─────────────────────────────────────────────────────
+    fold(onLeft) {
+        return onLeft(__classPrivateFieldGet(this, _LeftEitherImpl_value, "f"));
+    }
+    getOrElse(fallback) {
+        return typeof fallback === 'function' ? fallback() : fallback;
+    }
+    // ─── Validaciones y filtros ──────────────────────────────────────────────────
+    filter() {
+        // No se aplica filtro en Left
+        return this;
+    }
+    chain() {
+        // Alias para flatMap
+        return this.flatMap();
+    }
+    // ─── Conversiones ────────────────────────────────────────────────────────────
+    toOptional() {
+        return undefined;
+    }
+    swap() {
+        // Implementación delegada al factory para evitar dependencia circular
+        throw SwapOperationNotImplementedError_1.SwapOperationNotImplementedError.create('LeftEitherImpl');
+    }
+    // ─── Debugging ───────────────────────────────────────────────────────────────
+    inspect() {
+        return `Left(${JSON.stringify(__classPrivateFieldGet(this, _LeftEitherImpl_value, "f"))})`;
+    }
+}
+exports.LeftEitherImpl = LeftEitherImpl;
+_LeftEitherImpl_value = new WeakMap();

package/build/carbonbox/shared/either/domain/implementations/RightEitherImpl.js

@@ -0,0 +1,97 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _RightEitherImpl_value;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RightEitherImpl = void 0;
+const CannotAccessLeftOnRightValueError_1 = require("../exceptions/CannotAccessLeftOnRightValueError");
+const SwapOperationNotImplementedError_1 = require("../exceptions/SwapOperationNotImplementedError");
+const FilterOperationNotImplementedError_1 = require("../exceptions/FilterOperationNotImplementedError");
+/**
+ * Implementación concreta de RightEither
+ * Representa el estado de éxito en el patrón Either
+ */
+class RightEitherImpl {
+    constructor(value) {
+        this.state = 'right';
+        _RightEitherImpl_value.set(this, void 0);
+        __classPrivateFieldSet(this, _RightEitherImpl_value, value, "f");
+    }
+    // ─── Predicados tipo-seguros ─────────────────────────────────────────────────
+    get isLeft() {
+        return false;
+    }
+    get isRight() {
+        return true;
+    }
+    // ─── Métodos de acceso seguros ───────────────────────────────────────────────
+    getLeft() {
+        return undefined;
+    }
+    getRight() {
+        return __classPrivateFieldGet(this, _RightEitherImpl_value, "f");
+    }
+    // ─── Métodos de acceso que lanzan excepción ──────────────────────────────────
+    left() {
+        throw CannotAccessLeftOnRightValueError_1.CannotAccessLeftOnRightValueError.create(__classPrivateFieldGet(this, _RightEitherImpl_value, "f"));
+    }
+    right() {
+        return __classPrivateFieldGet(this, _RightEitherImpl_value, "f");
+    }
+    // ─── Transformaciones funcionales ────────────────────────────────────────────
+    map(fn) {
+        // Aplica la transformación al valor Right
+        return new RightEitherImpl(fn(__classPrivateFieldGet(this, _RightEitherImpl_value, "f")));
+    }
+    mapLeft() {
+        // No se ejecuta la transformación en Right, solo cambia el tipo
+        return new RightEitherImpl(__classPrivateFieldGet(this, _RightEitherImpl_value, "f"));
+    }
+    flatMap(fn) {
+        // Ejecuta la transformación monádica
+        return fn(__classPrivateFieldGet(this, _RightEitherImpl_value, "f"));
+    }
+    // ─── Métodos de utilidad ─────────────────────────────────────────────────────
+    fold(_onLeft, onRight) {
+        return onRight(__classPrivateFieldGet(this, _RightEitherImpl_value, "f"));
+    }
+    getOrElse() {
+        // Retorna el valor Right directamente
+        return __classPrivateFieldGet(this, _RightEitherImpl_value, "f");
+    }
+    // ─── Validaciones y filtros ──────────────────────────────────────────────────
+    filter(predicate) {
+        // Implementación delegada al factory para evitar dependencia circular
+        if (predicate(__classPrivateFieldGet(this, _RightEitherImpl_value, "f")) === true) {
+            return this;
+        }
+        throw FilterOperationNotImplementedError_1.FilterOperationNotImplementedError.create('RightEitherImpl');
+    }
+    chain(fn) {
+        // Alias para flatMap
+        return this.flatMap(fn);
+    }
+    // ─── Conversiones ────────────────────────────────────────────────────────────
+    toOptional() {
+        return __classPrivateFieldGet(this, _RightEitherImpl_value, "f");
+    }
+    swap() {
+        // Implementación delegada al factory para evitar dependencia circular
+        throw SwapOperationNotImplementedError_1.SwapOperationNotImplementedError.create('RightEitherImpl');
+    }
+    // ─── Debugging ───────────────────────────────────────────────────────────────
+    inspect() {
+        return `Right(${JSON.stringify(__classPrivateFieldGet(this, _RightEitherImpl_value, "f"))})`;
+    }
+}
+exports.RightEitherImpl = RightEitherImpl;
+_RightEitherImpl_value = new WeakMap();

package/build/carbonbox/shared/either/domain/implementations/RightEitherImplNew.js

@@ -0,0 +1,97 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _RightEitherImpl_value;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RightEitherImpl = void 0;
+const CannotAccessLeftOnRightValueError_1 = require("../exceptions/CannotAccessLeftOnRightValueError");
+const SwapOperationNotImplementedError_1 = require("../exceptions/SwapOperationNotImplementedError");
+const FilterOperationNotImplementedError_1 = require("../exceptions/FilterOperationNotImplementedError");
+/**
+ * Implementación concreta de RightEither
+ * Representa el estado de éxito en el patrón Either
+ */
+class RightEitherImpl {
+    constructor(value) {
+        this.state = 'right';
+        _RightEitherImpl_value.set(this, void 0);
+        __classPrivateFieldSet(this, _RightEitherImpl_value, value, "f");
+    }
+    // ─── Predicados tipo-seguros ─────────────────────────────────────────────────
+    get isLeft() {
+        return false;
+    }
+    get isRight() {
+        return true;
+    }
+    // ─── Métodos de acceso seguros ───────────────────────────────────────────────
+    getLeft() {
+        return undefined;
+    }
+    getRight() {
+        return __classPrivateFieldGet(this, _RightEitherImpl_value, "f");
+    }
+    // ─── Métodos de acceso que lanzan excepción ──────────────────────────────────
+    left() {
+        throw CannotAccessLeftOnRightValueError_1.CannotAccessLeftOnRightValueError.create(__classPrivateFieldGet(this, _RightEitherImpl_value, "f"));
+    }
+    right() {
+        return __classPrivateFieldGet(this, _RightEitherImpl_value, "f");
+    }
+    // ─── Transformaciones funcionales ────────────────────────────────────────────
+    map(fn) {
+        // Aplica la transformación al valor Right
+        return new RightEitherImpl(fn(__classPrivateFieldGet(this, _RightEitherImpl_value, "f")));
+    }
+    mapLeft() {
+        // No se ejecuta la transformación en Right, solo cambia el tipo
+        return new RightEitherImpl(__classPrivateFieldGet(this, _RightEitherImpl_value, "f"));
+    }
+    flatMap(fn) {
+        // Ejecuta la transformación monádica
+        return fn(__classPrivateFieldGet(this, _RightEitherImpl_value, "f"));
+    }
+    // ─── Métodos de utilidad ─────────────────────────────────────────────────────
+    fold(_onLeft, onRight) {
+        return onRight(__classPrivateFieldGet(this, _RightEitherImpl_value, "f"));
+    }
+    getOrElse() {
+        // Retorna el valor Right directamente
+        return __classPrivateFieldGet(this, _RightEitherImpl_value, "f");
+    }
+    // ─── Validaciones y filtros ──────────────────────────────────────────────────
+    filter(predicate) {
+        // Implementación delegada al factory para evitar dependencia circular
+        if (predicate(__classPrivateFieldGet(this, _RightEitherImpl_value, "f")) === true) {
+            return this;
+        }
+        throw FilterOperationNotImplementedError_1.FilterOperationNotImplementedError.create('RightEitherImpl');
+    }
+    chain(fn) {
+        // Alias para flatMap
+        return this.flatMap(fn);
+    }
+    // ─── Conversiones ────────────────────────────────────────────────────────────
+    toOptional() {
+        return __classPrivateFieldGet(this, _RightEitherImpl_value, "f");
+    }
+    swap() {
+        // Implementación delegada al factory para evitar dependencia circular
+        throw SwapOperationNotImplementedError_1.SwapOperationNotImplementedError.create('RightEitherImpl');
+    }
+    // ─── Debugging ───────────────────────────────────────────────────────────────
+    inspect() {
+        return `Right(${JSON.stringify(__classPrivateFieldGet(this, _RightEitherImpl_value, "f"))})`;
+    }
+}
+exports.RightEitherImpl = RightEitherImpl;
+_RightEitherImpl_value = new WeakMap();

package/build/carbonbox/shared/either/domain/types/Result.js

@@ -1,21 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Result = void 0;
-const Either_1 = require("../models/Either");
+const EitherFactory_1 = require("../factories/EitherFactory");
 // eslint-disable-next-line @typescript-eslint/no-redeclare
 var Result;
 (function (Result) {
     // Factory methods
     function fail(error) {
-        return Either_1.Either.left({ type: 'single', error });
+        return EitherFactory_1.EitherFactory.left({ type: 'single', error });
     }
     Result.fail = fail;
     function failMultiple(errors) {
-        return Either_1.Either.left({ type: 'multiple', errors });
+        return EitherFactory_1.EitherFactory.left({ type: 'multiple', errors });
     }
     Result.failMultiple = failMultiple;
     function ok(value) {
-        return Either_1.Either.right(value);
+        return EitherFactory_1.EitherFactory.right(value);
     }
     Result.ok = ok;
     // Conversiones