@carbonbox/domain 0.21.2 → 0.23.0

package/build/carbonbox/emission-calculation-formulas/calculation-variables/domain/entity/CalculationVariable.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _CalculationVariable_code, _CalculationVariable_symbol, _CalculationVariable_name, _CalculationVariable_description, _CalculationVariable_dataType, _CalculationVariable_resolutionStrategy, _CalculationVariable_activityDataConditions, _CalculationVariable_defaultValue;
+var _CalculationVariable_code, _CalculationVariable_symbol, _CalculationVariable_name, _CalculationVariable_description, _CalculationVariable_dataType, _CalculationVariable_resolutionStrategy, _CalculationVariable_activityDataConditions, _CalculationVariable_defaultValue, _CalculationVariable_options;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CalculationVariable = void 0;
 const AggregateRoot_1 = require("../../../../shared/domain/entities/AggregateRoot");
@@ -21,6 +21,7 @@ const CalculationVariableDefaultValue_1 = require("../value-objects/CalculationV
 const CalculationVariableDescription_1 = require("../value-objects/CalculationVariableDescription");
 const CalculationVariableId_1 = require("../value-objects/CalculationVariableId");
 const CalculationVariableName_1 = require("../value-objects/CalculationVariableName");
+const CalculationVariableOptions_1 = require("../value-objects/CalculationVariableOptions");
 const CalculationVariableResolutionStrategy_1 = require("../value-objects/CalculationVariableResolutionStrategy");
 const CalculationVariableSymbol_1 = require("../value-objects/CalculationVariableSymbol");
 const InvalidCalculationVariableActivityDataConditionsForStrategyError_1 = require("../exceptions/InvalidCalculationVariableActivityDataConditionsForStrategyError");
@@ -38,6 +39,7 @@ class CalculationVariable extends AggregateRoot_1.AggregateRoot {
         _CalculationVariable_resolutionStrategy.set(this, void 0);
         _CalculationVariable_activityDataConditions.set(this, void 0);
         _CalculationVariable_defaultValue.set(this, void 0);
+        _CalculationVariable_options.set(this, void 0);
         if (skipDomainValidation === false) {
             // Initialize with domain validation
             __classPrivateFieldSet(this, _CalculationVariable_code, CalculationVariableCode_1.CalculationVariableCode.create(props.code), "f");
@@ -48,6 +50,9 @@ class CalculationVariable extends AggregateRoot_1.AggregateRoot {
             __classPrivateFieldSet(this, _CalculationVariable_resolutionStrategy, CalculationVariableResolutionStrategy_1.CalculationVariableResolutionStrategy.create(props.resolutionStrategy), "f");
             __classPrivateFieldSet(this, _CalculationVariable_activityDataConditions, CalculationVariableActivityDataConditions_1.CalculationVariableActivityDataConditions.create(props.activityDataConditions), "f");
             __classPrivateFieldSet(this, _CalculationVariable_defaultValue, CalculationVariableDefaultValue_1.CalculationVariableDefaultValue.create(props.defaultValue), "f");
+            __classPrivateFieldSet(this, _CalculationVariable_options, props.options !== null
+                ? CalculationVariableOptions_1.CalculationVariableOptions.create(props.options)
+                : CalculationVariableOptions_1.CalculationVariableOptions.create([]), "f");
         }
         else {
             // Initialize from primitives (no per-VO domain validation)
@@ -59,6 +64,9 @@ class CalculationVariable extends AggregateRoot_1.AggregateRoot {
             __classPrivateFieldSet(this, _CalculationVariable_resolutionStrategy, CalculationVariableResolutionStrategy_1.CalculationVariableResolutionStrategy.fromPrimitives(props.resolutionStrategy), "f");
             __classPrivateFieldSet(this, _CalculationVariable_activityDataConditions, CalculationVariableActivityDataConditions_1.CalculationVariableActivityDataConditions.fromPrimitives(props.activityDataConditions), "f");
             __classPrivateFieldSet(this, _CalculationVariable_defaultValue, CalculationVariableDefaultValue_1.CalculationVariableDefaultValue.fromPrimitives(props.defaultValue), "f");
+            __classPrivateFieldSet(this, _CalculationVariable_options, props.options !== null
+                ? CalculationVariableOptions_1.CalculationVariableOptions.fromPrimitives(props.options)
+                : CalculationVariableOptions_1.CalculationVariableOptions.fromPrimitives([]), "f");
         }
         // Cross-field invariant is enforced ALWAYS, even when constructing
         // via `fromPrimitives`. Per-VO validation can be skipped (because
@@ -82,6 +90,7 @@ class CalculationVariable extends AggregateRoot_1.AggregateRoot {
             resolutionStrategy: primitives.resolutionStrategy,
             activityDataConditions: primitives.activityDataConditions,
             defaultValue: primitives.defaultValue,
+            options: primitives.options,
         };
         return new CalculationVariable(props, true);
     }
@@ -96,6 +105,7 @@ class CalculationVariable extends AggregateRoot_1.AggregateRoot {
             resolutionStrategy: __classPrivateFieldGet(this, _CalculationVariable_resolutionStrategy, "f").toPrimitives(),
             activityDataConditions: __classPrivateFieldGet(this, _CalculationVariable_activityDataConditions, "f").toPrimitives(),
             defaultValue: __classPrivateFieldGet(this, _CalculationVariable_defaultValue, "f").toPrimitives(),
+            options: __classPrivateFieldGet(this, _CalculationVariable_options, "f").isEmpty() ? null : __classPrivateFieldGet(this, _CalculationVariable_options, "f").toPrimitives(),
         };
     }
     get code() {
@@ -122,6 +132,9 @@ class CalculationVariable extends AggregateRoot_1.AggregateRoot {
     get defaultValue() {
         return __classPrivateFieldGet(this, _CalculationVariable_defaultValue, "f");
     }
+    get options() {
+        return __classPrivateFieldGet(this, _CalculationVariable_options, "f");
+    }
     /**
      * Cross-field invariant: the relationship between `resolutionStrategy`
      * and `activityDataConditions` is owned by the aggregate root, not by
@@ -145,4 +158,4 @@ class CalculationVariable extends AggregateRoot_1.AggregateRoot {
     }
 }
 exports.CalculationVariable = CalculationVariable;
-_CalculationVariable_code = new WeakMap(), _CalculationVariable_symbol = new WeakMap(), _CalculationVariable_name = new WeakMap(), _CalculationVariable_description = new WeakMap(), _CalculationVariable_dataType = new WeakMap(), _CalculationVariable_resolutionStrategy = new WeakMap(), _CalculationVariable_activityDataConditions = new WeakMap(), _CalculationVariable_defaultValue = new WeakMap();
+_CalculationVariable_code = new WeakMap(), _CalculationVariable_symbol = new WeakMap(), _CalculationVariable_name = new WeakMap(), _CalculationVariable_description = new WeakMap(), _CalculationVariable_dataType = new WeakMap(), _CalculationVariable_resolutionStrategy = new WeakMap(), _CalculationVariable_activityDataConditions = new WeakMap(), _CalculationVariable_defaultValue = new WeakMap(), _CalculationVariable_options = new WeakMap();

package/build/carbonbox/emission-calculation-formulas/calculation-variables/domain/types/CalculationVariableOption.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/carbonbox/emission-calculation-formulas/calculation-variables/domain/types/CalculationVariableOptionOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/carbonbox/emission-calculation-formulas/calculation-variables/domain/types/CalculationVariableOptionPrimitives.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/carbonbox/emission-calculation-formulas/calculation-variables/domain/value-objects/CalculationVariableOptions.js

@@ -0,0 +1,197 @@
+"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 _a, _CalculationVariableOptions_options, _CalculationVariableOptions_guardAgainstInvalidType, _CalculationVariableOptions_guardAgainstInvalidEmptyArray, _CalculationVariableOptions_guardAgainstDuplicatedValues, _CalculationVariableOptions_guardAgainstDuplicatedDisplayOrders, _CalculationVariableOptions_guardAgainstInvalidOption;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalculationVariableOptions = void 0;
+const ValueObject_1 = require("../../../../shared/domain/value-objects/ValueObject");
+const String_1 = require("../../../../shared/domain/value-objects/String");
+const PositiveInteger_1 = require("../../../../shared/domain/value-objects/PositiveInteger");
+const InvalidPropertyTypeError_1 = require("../../../../shared/domain/exceptions/InvalidPropertyTypeError");
+const InvalidPropertyValueError_1 = require("../../../../shared/domain/exceptions/InvalidPropertyValueError");
+/**
+ * Structured list of selectable options for a `dataType === SELECT` calculation
+ * variable (e.g. tipo de combustible: Diesel / Gasolina / Eléctrico). Mirrors the
+ * canonical `CollectionFieldOptions` value object (`FieldOption` shape) but lives
+ * in the `calculation-variables` bounded context so the two contexts stay
+ * independent.
+ *
+ * The value object is permissive (`allowEmpty: true`): a SELECT variable can exist
+ * with an empty list initially. Whether options are required/forbidden for a given
+ * `dataType` is an application-layer concern (gated in the Create/Update DTO +
+ * handler against `DataTypeEnum.SELECT`), exactly like `CollectionFieldOptions`.
+ */
+class CalculationVariableOptions extends ValueObject_1.ValueObject {
+    constructor(value, skipDomainValidation, propertyName = _a.DEFAULT_PROPERTY_NAME, options = _a.DEFAULT_OPTIONS) {
+        const finalOptions = { ..._a.DEFAULT_OPTIONS, ...options };
+        if (skipDomainValidation === false) {
+            _a.validateOptions(value, propertyName, finalOptions);
+        }
+        const primitives = _a.toPrimitivesArray(value);
+        super(primitives, skipDomainValidation, propertyName, 'The provided value must be an array of CalculationVariableOption from the domain layer');
+        _CalculationVariableOptions_options.set(this, void 0);
+        __classPrivateFieldSet(this, _CalculationVariableOptions_options, _a.toCleanOptions(value), "f");
+    }
+    static create(value) {
+        return new _a(value, false);
+    }
+    static fromPrimitives(primitives) {
+        const value = primitives.map((primitive) => ({
+            value: primitive.value,
+            label: primitive.label,
+            displayOrder: primitive.displayOrder,
+            isActive: primitive.isActive,
+            metadata: primitive.metadata,
+        }));
+        return new _a(value, true);
+    }
+    static validateOptions(value, propertyName, options) {
+        __classPrivateFieldGet(this, _a, "m", _CalculationVariableOptions_guardAgainstInvalidType).call(this, value, propertyName);
+        __classPrivateFieldGet(this, _a, "m", _CalculationVariableOptions_guardAgainstInvalidEmptyArray).call(this, value, options, propertyName);
+        if (options.allowDuplicates === false) {
+            __classPrivateFieldGet(this, _a, "m", _CalculationVariableOptions_guardAgainstDuplicatedValues).call(this, value, propertyName);
+        }
+        value.forEach((option, index) => {
+            __classPrivateFieldGet(this, _a, "m", _CalculationVariableOptions_guardAgainstInvalidOption).call(this, option, index, propertyName);
+        });
+        __classPrivateFieldGet(this, _a, "m", _CalculationVariableOptions_guardAgainstDuplicatedDisplayOrders).call(this, value, propertyName);
+    }
+    static toPrimitivesArray(value) {
+        return value.map((option) => ({
+            value: option.value.trim(),
+            label: option.label.trim(),
+            displayOrder: option.displayOrder,
+            isActive: option.isActive,
+            metadata: option.metadata,
+        }));
+    }
+    static toCleanOptions(value) {
+        return value.map((option) => ({
+            value: option.value.trim(),
+            label: option.label.trim(),
+            displayOrder: option.displayOrder,
+            isActive: option.isActive,
+            metadata: option.metadata,
+        }));
+    }
+    get options() {
+        return Object.freeze([...__classPrivateFieldGet(this, _CalculationVariableOptions_options, "f")]);
+    }
+    get count() {
+        return __classPrivateFieldGet(this, _CalculationVariableOptions_options, "f").length;
+    }
+    isEmpty() {
+        return __classPrivateFieldGet(this, _CalculationVariableOptions_options, "f").length === 0;
+    }
+    hasOptions() {
+        return __classPrivateFieldGet(this, _CalculationVariableOptions_options, "f").length > 0;
+    }
+    getValues() {
+        return __classPrivateFieldGet(this, _CalculationVariableOptions_options, "f").map((option) => option.value);
+    }
+    getByValue(value) {
+        return __classPrivateFieldGet(this, _CalculationVariableOptions_options, "f").find((option) => option.value.toUpperCase() === value.trim().toUpperCase());
+    }
+    hasValue(value) {
+        return __classPrivateFieldGet(this, _CalculationVariableOptions_options, "f").some((option) => option.value.toUpperCase() === value.trim().toUpperCase());
+    }
+    sortByDisplayOrder() {
+        return [...__classPrivateFieldGet(this, _CalculationVariableOptions_options, "f")].sort((a, b) => a.displayOrder - b.displayOrder);
+    }
+    equals(other) {
+        if (!(other instanceof _a)) {
+            return false;
+        }
+        if (__classPrivateFieldGet(this, _CalculationVariableOptions_options, "f").length !== __classPrivateFieldGet(other, _CalculationVariableOptions_options, "f").length) {
+            return false;
+        }
+        const thisValues = new Set(this.getValues().map((v) => v.toUpperCase()));
+        const otherValues = new Set(other.getValues().map((v) => v.toUpperCase()));
+        if (thisValues.size !== otherValues.size) {
+            return false;
+        }
+        for (const value of thisValues) {
+            if (otherValues.has(value) === false) {
+                return false;
+            }
+            const thisOption = this.getByValue(value);
+            const otherOption = other.getByValue(value);
+            if (thisOption?.label !== otherOption?.label
+                || thisOption?.displayOrder !== otherOption?.displayOrder
+                || thisOption?.isActive !== otherOption?.isActive) {
+                return false;
+            }
+        }
+        return true;
+    }
+    toPrimitives() {
+        return __classPrivateFieldGet(this, _CalculationVariableOptions_options, "f").map((option) => ({
+            value: option.value,
+            label: option.label,
+            displayOrder: option.displayOrder,
+            isActive: option.isActive,
+            metadata: option.metadata,
+        }));
+    }
+}
+exports.CalculationVariableOptions = CalculationVariableOptions;
+_a = CalculationVariableOptions, _CalculationVariableOptions_options = new WeakMap(), _CalculationVariableOptions_guardAgainstInvalidType = function _CalculationVariableOptions_guardAgainstInvalidType(value, propertyName) {
+    if (Array.isArray(value) === false) {
+        throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(propertyName, 'array of CalculationVariableOption', typeof value);
+    }
+}, _CalculationVariableOptions_guardAgainstInvalidEmptyArray = function _CalculationVariableOptions_guardAgainstInvalidEmptyArray(value, options, propertyName) {
+    if (options.allowEmpty === false && value.length === 0) {
+        throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(propertyName, 'non-empty array', 'empty array');
+    }
+}, _CalculationVariableOptions_guardAgainstDuplicatedValues = function _CalculationVariableOptions_guardAgainstDuplicatedValues(value, propertyName) {
+    const values = value.map((option) => option.value.trim().toUpperCase());
+    const uniqueValues = new Set(values);
+    if (values.length !== uniqueValues.size) {
+        throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(`${propertyName}.values`, 'array with unique option values', 'array with duplicated option values');
+    }
+}, _CalculationVariableOptions_guardAgainstDuplicatedDisplayOrders = function _CalculationVariableOptions_guardAgainstDuplicatedDisplayOrders(value, propertyName) {
+    const displayOrders = value.map((option) => option.displayOrder);
+    const uniqueDisplayOrders = new Set(displayOrders);
+    if (displayOrders.length !== uniqueDisplayOrders.size) {
+        throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(`${propertyName}.displayOrders`, 'array with unique display orders', 'array with duplicated display orders');
+    }
+}, _CalculationVariableOptions_guardAgainstInvalidOption = function _CalculationVariableOptions_guardAgainstInvalidOption(option, index, basePropertyName) {
+    const propertyName = `${basePropertyName}[${index}]`;
+    if (option === null || option === undefined || typeof option !== 'object') {
+        throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(propertyName, 'CalculationVariableOption object', typeof option);
+    }
+    if (typeof option.value !== 'string') {
+        throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(`${propertyName}.value`, 'string', typeof option.value);
+    }
+    if (typeof option.label !== 'string') {
+        throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(`${propertyName}.label`, 'string', typeof option.label);
+    }
+    if (typeof option.displayOrder !== 'number') {
+        throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(`${propertyName}.displayOrder`, 'number', typeof option.displayOrder);
+    }
+    if (typeof option.isActive !== 'boolean') {
+        throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(`${propertyName}.isActive`, 'boolean', typeof option.isActive);
+    }
+    if (option.metadata !== null && typeof option.metadata !== 'object') {
+        throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(`${propertyName}.metadata`, 'object or null', typeof option.metadata);
+    }
+    String_1.String.guardAgainstEmptyValue(option.value, `${propertyName}.value`);
+    String_1.String.guardAgainstEmptyValue(option.label, `${propertyName}.label`);
+    if (!PositiveInteger_1.PositiveInteger.isValidPositiveInteger(option.displayOrder)) {
+        throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(`${propertyName}.displayOrder`, 'positive integer', option.displayOrder.toString());
+    }
+};
+CalculationVariableOptions.DEFAULT_PROPERTY_NAME = 'calculationVariableOptions';
+CalculationVariableOptions.DEFAULT_OPTIONS = {
+    allowEmpty: true, // SELECT variables can be created without options initially
+    allowDuplicates: false, // Option values must be unique
+};

package/build/carbonbox/emission-calculation-results/emission-calculations/domain/entity/EmissionCalculation.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _EmissionCalculation_activityDataSubmission, _EmissionCalculation_emissionCalculationFormula, _EmissionCalculation_emissionSource, _EmissionCalculation_carbonClient, _EmissionCalculation_footprintConfiguration, _EmissionCalculation_calculatedAt, _EmissionCalculation_calculatedByStakeholder, _EmissionCalculation_activityDataUncertainty, _EmissionCalculation_emissionFactorUncertainty, _EmissionCalculation_combinedUncertainty, _EmissionCalculation_status, _EmissionCalculation_errorMessage, _EmissionCalculation_calculationNotes;
+var _EmissionCalculation_activityDataSubmission, _EmissionCalculation_emissionCalculationFormula, _EmissionCalculation_emissionSource, _EmissionCalculation_carbonClient, _EmissionCalculation_footprintConfiguration, _EmissionCalculation_calculatedAt, _EmissionCalculation_calculatedByStakeholder, _EmissionCalculation_activityDataUncertainty, _EmissionCalculation_emissionFactorUncertainty, _EmissionCalculation_combinedUncertainty, _EmissionCalculation_status, _EmissionCalculation_errorMessage, _EmissionCalculation_calculationNotes, _EmissionCalculation_dimensions;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EmissionCalculation = void 0;
 const AggregateRoot_1 = require("../../../../shared/domain/entities/AggregateRoot");
@@ -21,6 +21,7 @@ const EmissionCalculationCalculatedByStakeholder_1 = require("../value-objects/E
 const EmissionCalculationCalculationNotes_1 = require("../value-objects/EmissionCalculationCalculationNotes");
 const EmissionCalculationCarbonClient_1 = require("../value-objects/EmissionCalculationCarbonClient");
 const EmissionCalculationCombinedUncertainty_1 = require("../value-objects/EmissionCalculationCombinedUncertainty");
+const EmissionCalculationDimensions_1 = require("../value-objects/EmissionCalculationDimensions");
 const EmissionCalculationEmissionCalculationFormula_1 = require("../value-objects/EmissionCalculationEmissionCalculationFormula");
 const EmissionCalculationEmissionFactorUncertainty_1 = require("../value-objects/EmissionCalculationEmissionFactorUncertainty");
 const EmissionCalculationEmissionSource_1 = require("../value-objects/EmissionCalculationEmissionSource");
@@ -47,6 +48,7 @@ class EmissionCalculation extends AggregateRoot_1.AggregateRoot {
         _EmissionCalculation_status.set(this, void 0);
         _EmissionCalculation_errorMessage.set(this, void 0);
         _EmissionCalculation_calculationNotes.set(this, void 0);
+        _EmissionCalculation_dimensions.set(this, void 0);
         if (skipDomainValidation === false) {
             // Initialize with domain validation
             __classPrivateFieldSet(this, _EmissionCalculation_activityDataSubmission, EmissionCalculationActivityDataSubmission_1.EmissionCalculationActivityDataSubmission.create(props.activityDataSubmission), "f");
@@ -62,6 +64,9 @@ class EmissionCalculation extends AggregateRoot_1.AggregateRoot {
             __classPrivateFieldSet(this, _EmissionCalculation_status, EmissionCalculationStatus_1.EmissionCalculationStatus.create(props.status), "f");
             __classPrivateFieldSet(this, _EmissionCalculation_errorMessage, EmissionCalculationErrorMessage_1.EmissionCalculationErrorMessage.create(props.errorMessage), "f");
             __classPrivateFieldSet(this, _EmissionCalculation_calculationNotes, EmissionCalculationCalculationNotes_1.EmissionCalculationCalculationNotes.create(props.calculationNotes), "f");
+            __classPrivateFieldSet(this, _EmissionCalculation_dimensions, props.dimensions === null
+                ? null
+                : EmissionCalculationDimensions_1.EmissionCalculationDimensions.create(props.dimensions), "f");
         }
         else {
             // Initialize from primitives (no domain validation)
@@ -78,6 +83,9 @@ class EmissionCalculation extends AggregateRoot_1.AggregateRoot {
             __classPrivateFieldSet(this, _EmissionCalculation_status, EmissionCalculationStatus_1.EmissionCalculationStatus.fromPrimitives(props.status), "f");
             __classPrivateFieldSet(this, _EmissionCalculation_errorMessage, EmissionCalculationErrorMessage_1.EmissionCalculationErrorMessage.fromPrimitives(props.errorMessage), "f");
             __classPrivateFieldSet(this, _EmissionCalculation_calculationNotes, EmissionCalculationCalculationNotes_1.EmissionCalculationCalculationNotes.fromPrimitives(props.calculationNotes), "f");
+            __classPrivateFieldSet(this, _EmissionCalculation_dimensions, props.dimensions === null
+                ? null
+                : EmissionCalculationDimensions_1.EmissionCalculationDimensions.fromPrimitives(props.dimensions), "f");
         }
     }
     static create(props) {
@@ -99,6 +107,7 @@ class EmissionCalculation extends AggregateRoot_1.AggregateRoot {
             status: primitives.status,
             errorMessage: primitives.errorMessage,
             calculationNotes: primitives.calculationNotes,
+            dimensions: primitives.dimensions,
         };
         return new EmissionCalculation(props, true);
     }
@@ -118,6 +127,7 @@ class EmissionCalculation extends AggregateRoot_1.AggregateRoot {
             status: __classPrivateFieldGet(this, _EmissionCalculation_status, "f").toEnum(),
             errorMessage: __classPrivateFieldGet(this, _EmissionCalculation_errorMessage, "f").toPrimitives(),
             calculationNotes: __classPrivateFieldGet(this, _EmissionCalculation_calculationNotes, "f").toPrimitives(),
+            dimensions: __classPrivateFieldGet(this, _EmissionCalculation_dimensions, "f") === null ? null : __classPrivateFieldGet(this, _EmissionCalculation_dimensions, "f").toPrimitives(),
         };
     }
     get activityDataSubmission() {
@@ -159,6 +169,9 @@ class EmissionCalculation extends AggregateRoot_1.AggregateRoot {
     get calculationNotes() {
         return __classPrivateFieldGet(this, _EmissionCalculation_calculationNotes, "f");
     }
+    get dimensions() {
+        return __classPrivateFieldGet(this, _EmissionCalculation_dimensions, "f");
+    }
 }
 exports.EmissionCalculation = EmissionCalculation;
-_EmissionCalculation_activityDataSubmission = new WeakMap(), _EmissionCalculation_emissionCalculationFormula = new WeakMap(), _EmissionCalculation_emissionSource = new WeakMap(), _EmissionCalculation_carbonClient = new WeakMap(), _EmissionCalculation_footprintConfiguration = new WeakMap(), _EmissionCalculation_calculatedAt = new WeakMap(), _EmissionCalculation_calculatedByStakeholder = new WeakMap(), _EmissionCalculation_activityDataUncertainty = new WeakMap(), _EmissionCalculation_emissionFactorUncertainty = new WeakMap(), _EmissionCalculation_combinedUncertainty = new WeakMap(), _EmissionCalculation_status = new WeakMap(), _EmissionCalculation_errorMessage = new WeakMap(), _EmissionCalculation_calculationNotes = new WeakMap();
+_EmissionCalculation_activityDataSubmission = new WeakMap(), _EmissionCalculation_emissionCalculationFormula = new WeakMap(), _EmissionCalculation_emissionSource = new WeakMap(), _EmissionCalculation_carbonClient = new WeakMap(), _EmissionCalculation_footprintConfiguration = new WeakMap(), _EmissionCalculation_calculatedAt = new WeakMap(), _EmissionCalculation_calculatedByStakeholder = new WeakMap(), _EmissionCalculation_activityDataUncertainty = new WeakMap(), _EmissionCalculation_emissionFactorUncertainty = new WeakMap(), _EmissionCalculation_combinedUncertainty = new WeakMap(), _EmissionCalculation_status = new WeakMap(), _EmissionCalculation_errorMessage = new WeakMap(), _EmissionCalculation_calculationNotes = new WeakMap(), _EmissionCalculation_dimensions = new WeakMap();

package/build/carbonbox/emission-calculation-results/emission-calculations/domain/types/EmissionCalculationDimensionSegment.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/carbonbox/emission-calculation-results/emission-calculations/domain/types/EmissionCalculationDimensionSegmentPrimitives.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/carbonbox/emission-calculation-results/emission-calculations/domain/types/EmissionCalculationDimensions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/carbonbox/emission-calculation-results/emission-calculations/domain/types/EmissionCalculationDimensionsPrimitives.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/carbonbox/emission-calculation-results/emission-calculations/domain/value-objects/EmissionCalculationDimensions.js

@@ -0,0 +1,72 @@
+"use strict";
+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 _a, _EmissionCalculationDimensions_validate, _EmissionCalculationDimensions_validateSegment, _EmissionCalculationDimensions_toPrimitives;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmissionCalculationDimensions = void 0;
+const ValueObject_1 = require("../../../../shared/domain/value-objects/ValueObject");
+const String_1 = require("../../../../shared/domain/value-objects/String");
+const InvalidPropertyTypeError_1 = require("../../../../shared/domain/exceptions/InvalidPropertyTypeError");
+/**
+ * Value object wrapping the dimensional attributes denormalized on the
+ * EmissionCalculation at calculation time (CALC-001). Required string
+ * fields (`emissionScope`, `periodStart`, segment `id/name/code`) are
+ * validated non-empty; `subScope`, `subsegment` and `country` are nullable.
+ */
+class EmissionCalculationDimensions extends ValueObject_1.ValueObject {
+    constructor(value, skipDomainValidation) {
+        if (skipDomainValidation === false) {
+            __classPrivateFieldGet(_a, _a, "m", _EmissionCalculationDimensions_validate).call(_a, value);
+        }
+        super(__classPrivateFieldGet(_a, _a, "m", _EmissionCalculationDimensions_toPrimitives).call(_a, value), skipDomainValidation, _a.PROPERTY_NAME, 'The provided value must be a valid EmissionCalculationDimensions object');
+    }
+    static create(value) {
+        return new _a(value, false);
+    }
+    static fromPrimitives(primitives) {
+        return new _a(primitives, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.EmissionCalculationDimensions = EmissionCalculationDimensions;
+_a = EmissionCalculationDimensions, _EmissionCalculationDimensions_validate = function _EmissionCalculationDimensions_validate(value) {
+    if (value === null || value === undefined || typeof value !== 'object') {
+        throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(_a.PROPERTY_NAME, 'EmissionCalculationDimensions object', typeof value);
+    }
+    String_1.String.guardAgainstEmptyValue(value.emissionScope, `${_a.PROPERTY_NAME}.emissionScope`);
+    String_1.String.guardAgainstEmptyValue(value.periodStart, `${_a.PROPERTY_NAME}.periodStart`);
+    __classPrivateFieldGet(_a, _a, "m", _EmissionCalculationDimensions_validateSegment).call(_a, value.segment, 'segment');
+    if (value.subsegment !== null) {
+        __classPrivateFieldGet(_a, _a, "m", _EmissionCalculationDimensions_validateSegment).call(_a, value.subsegment, 'subsegment');
+    }
+    if (value.subScope !== null && typeof value.subScope !== 'string') {
+        throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(`${_a.PROPERTY_NAME}.subScope`, 'string or null', typeof value.subScope);
+    }
+    if (value.country !== null && typeof value.country !== 'string') {
+        throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(`${_a.PROPERTY_NAME}.country`, 'string or null', typeof value.country);
+    }
+}, _EmissionCalculationDimensions_validateSegment = function _EmissionCalculationDimensions_validateSegment(segment, field) {
+    if (segment === null || segment === undefined || typeof segment !== 'object') {
+        throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(`${_a.PROPERTY_NAME}.${field}`, '{ id, name, code } object', typeof segment);
+    }
+    String_1.String.guardAgainstEmptyValue(segment.id, `${_a.PROPERTY_NAME}.${field}.id`);
+    String_1.String.guardAgainstEmptyValue(segment.name, `${_a.PROPERTY_NAME}.${field}.name`);
+    String_1.String.guardAgainstEmptyValue(segment.code, `${_a.PROPERTY_NAME}.${field}.code`);
+}, _EmissionCalculationDimensions_toPrimitives = function _EmissionCalculationDimensions_toPrimitives(value) {
+    return {
+        emissionScope: value.emissionScope,
+        subScope: value.subScope,
+        segment: { id: value.segment.id, name: value.segment.name, code: value.segment.code },
+        subsegment: value.subsegment === null
+            ? null
+            : { id: value.subsegment.id, name: value.subsegment.name, code: value.subsegment.code },
+        periodStart: value.periodStart,
+        country: value.country,
+    };
+};
+EmissionCalculationDimensions.PROPERTY_NAME = 'dimensions';