@zerocarbon/erp-config-sdk 1.0.8 → 1.0.10

package/dist/index.js

@@ -38365,6 +38365,503 @@ const supportsIntensityCalculations = (industry) => {
     const config = getIndustryFieldConfig(industry);
     return config.enableIntensityCalculations || false;
 };
+// Industry-specific mappings from user data to Carbon Intensity API requirements
+const CARBON_INTENSITY_FIELD_MAPPINGS = {
+    // Steel Industry Mapping (API expects: revenue + steel_production)
+    Steel: {
+        revenue: {
+            userDataPath: "additionalConfig.erp.steel.plants.{plantName}.revenue",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Revenue (₹Cr)",
+            industryFieldKey: "revenue",
+        },
+        steel_production: {
+            userDataPath: "additionalConfig.erp.steel.plants.{plantName}.crudeSteel",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Crude Steel Production (tonnes)",
+            industryFieldKey: "crudeSteel",
+        },
+    },
+    // Pharmaceutical Industry Mapping (API expects: area + production)
+    Pharmaceutical: {
+        area: {
+            userDataPath: "additionalConfig.erp.pharmaceutical.plants.{plantName}.productionFacilityArea",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Production Facility Area (m²)",
+            industryFieldKey: "productionFacilityArea",
+        },
+        production: {
+            userDataPath: "additionalConfig.erp.pharmaceutical.plants.{plantName}.annualProductionVolume",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Annual Production Volume (tonnes)",
+            industryFieldKey: "annualProductionVolume",
+        },
+    },
+    // Chemical Industry Mapping (API expects: production only)
+    Chemical: {
+        production: {
+            userDataPath: "additionalConfig.erp.chemical.plants.{plantName}.totalProduction",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Total Chemical Production (tonnes)",
+            industryFieldKey: "totalProduction",
+        },
+    },
+    // Aluminum Industry Mapping (API expects: production only)
+    Aluminum: {
+        production: {
+            userDataPath: "additionalConfig.erp.aluminum.plants.{plantName}.annualProduction",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Annual Production (tonnes)",
+            industryFieldKey: "annualProduction",
+        },
+    },
+    // Alloy Industry Mapping (API expects: area + production)
+    Alloy: {
+        area: {
+            userDataPath: "additionalConfig.erp.alloy.plants.{plantName}.facilityArea",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Facility Area (m²)",
+            industryFieldKey: "facilityArea",
+        },
+        production: {
+            userDataPath: "additionalConfig.erp.alloy.plants.{plantName}.annualProductionVolume",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Annual Production Volume (tonnes)",
+            industryFieldKey: "annualProductionVolume",
+        },
+    },
+    // Textile Industry Mapping (API expects: area + production)
+    Textile: {
+        area: {
+            userDataPath: "additionalConfig.erp.textile.plants.{plantName}.productionFacilityArea",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Production Facility Area (m²)",
+            industryFieldKey: "productionFacilityArea",
+        },
+        production: {
+            userDataPath: "additionalConfig.erp.textile.plants.{plantName}.annualProductionVolume",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Annual Production Volume (tonnes)",
+            industryFieldKey: "annualProductionVolume",
+        },
+    },
+    // Automobile Industry Mapping (API expects: annual_production_units)
+    Automobiles: {
+        annual_production_units: {
+            userDataPath: "additionalConfig.erp.automobiles.plants.{plantName}.annualProductionVolume",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Annual Production Volume (Units)",
+            industryFieldKey: "annualProductionVolume",
+        },
+    },
+    // Aviation Industry Mapping (API expects: area only)
+    Aviation: {
+        area: {
+            userDataPath: "additionalConfig.erp.aviation.plants.{plantName}.facilitiesArea",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Facilities Area (m²)",
+            industryFieldKey: "facilitiesArea",
+        },
+    },
+    // Shipping Industry Mapping (API expects: area + employees)
+    Shipping: {
+        area: {
+            userDataPath: "additionalConfig.erp.shipping.plants.{plantName}.portTerminalFacilitiesArea",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Port & Terminal Facilities Area (m²)",
+            industryFieldKey: "portTerminalFacilitiesArea",
+        },
+        employees: {
+            userDataPath: "additionalConfig.erp.shipping.plants.{plantName}.numberOfEmployees",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Number of Employees",
+            industryFieldKey: "numberOfEmployees",
+        },
+    },
+    // Food & Beverages Industry Mapping (API expects: production_facility_area + production)
+    "Food & Beverages": {
+        production_facility_area: {
+            userDataPath: "additionalConfig.erp.food & beverages.plants.{plantName}.productionFacilityArea",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Production Facility Area (m²)",
+            industryFieldKey: "productionFacilityArea",
+        },
+        production: {
+            userDataPath: "additionalConfig.erp.food & beverages.plants.{plantName}.annualProductionVolume",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Annual Production Volume (tonnes)",
+            industryFieldKey: "annualProductionVolume",
+        },
+    },
+    // Hospitality Industry Mapping (API expects: built_up_area only)
+    Hospitality: {
+        built_up_area: {
+            userDataPath: "additionalConfig.erp.hospitality.plants.{plantName}.totalBuiltUpArea",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Total Built Up Area (m²)",
+            industryFieldKey: "totalBuiltUpArea",
+        },
+    },
+    // Logistics Industry Mapping (API expects: warehouse_area only)
+    Logistics: {
+        warehouse_area: {
+            userDataPath: "additionalConfig.erp.logistics.plants.{plantName}.warehouseSpaceOperated",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Warehouse Space Operated (m²)",
+            industryFieldKey: "warehouseSpaceOperated",
+        },
+    },
+    // Manufacturing Industry Mapping (API expects: manufacturing_facility_area + annual_production)
+    Manufacturing: {
+        manufacturing_facility_area: {
+            userDataPath: "additionalConfig.erp.manufacturing.plants.{plantName}.manufacturingFacilityArea",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Manufacturing Facility Area (m²)",
+            industryFieldKey: "manufacturingFacilityArea",
+        },
+        annual_production: {
+            userDataPath: "additionalConfig.erp.manufacturing.plants.{plantName}.annualProductionVolume",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Annual Production Volume (tonnes)",
+            industryFieldKey: "annualProductionVolume",
+        },
+    },
+    // Metals & Energy Industry Mapping (API expects: power_generated + annual_production)
+    "Metals & Energy": {
+        power_generated: {
+            userDataPath: "additionalConfig.erp.metals & energy.plants.{plantName}.powerGenerated",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Power Generated (MWH)",
+            industryFieldKey: "powerGenerated",
+        },
+        annual_production: {
+            userDataPath: "additionalConfig.erp.metals & energy.plants.{plantName}.annualProductionVolume",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Annual Production Volume (tonnes)",
+            industryFieldKey: "annualProductionVolume",
+        },
+    },
+    // Packaging Industry Mapping (API expects: packaging_units only)
+    Packaging: {
+        packaging_units: {
+            userDataPath: "additionalConfig.erp.packaging.plants.{plantName}.packagingUnitsProduced",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Packaging Units Produced",
+            industryFieldKey: "packagingUnitsProduced",
+        },
+    },
+    // Petrochemical Industry Mapping (API expects: chemical_production only)
+    "Petro Chemical": {
+        chemical_production: {
+            userDataPath: "additionalConfig.erp.petro chemical.plants.{plantName}.annualProductionVolume",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Chemical Production (tonnes)",
+            industryFieldKey: "annualProductionVolume",
+        },
+    },
+    // Real Estate Industry Mapping (API expects: project_site_area only)
+    "Real Estate & Construction": {
+        project_site_area: {
+            userDataPath: "additionalConfig.erp.real estate & construction.plants.{plantName}.projectSiteArea",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Project Site Area (m²)",
+            industryFieldKey: "projectSiteArea",
+        },
+    },
+    // Telecommunications Industry Mapping (API expects: project_site_area only)
+    Telecommunications: {
+        project_site_area: {
+            userDataPath: "additionalConfig.erp.telecommunications.plants.{plantName}.projectSiteArea",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Project Site Area (m²)",
+            industryFieldKey: "projectSiteArea",
+        },
+    },
+    // Utilities Industry Mapping (API expects: total_area + annual_production)
+    Utilities: {
+        total_area: {
+            userDataPath: "additionalConfig.erp.utilities.plants.{plantName}.plantArea",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Plant Area (m²)",
+            industryFieldKey: "plantArea",
+        },
+        annual_production: {
+            userDataPath: "additionalConfig.erp.utilities.plants.{plantName}.annualProductionServiceOutput",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Annual Production/Service Output",
+            industryFieldKey: "annualProductionServiceOutput",
+        },
+    },
+    // Cement Industry Mapping (API expects: manufacturing_facility_area + annual_production)
+    Cement: {
+        manufacturing_facility_area: {
+            userDataPath: "additionalConfig.erp.cement.plants.{plantName}.manufacturingFacilityArea",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Manufacturing Facility Area (m²)",
+            industryFieldKey: "manufacturingFacilityArea",
+        },
+        annual_production: {
+            userDataPath: "additionalConfig.erp.cement.plants.{plantName}.cementProduced",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Cement Produced (tonnes)",
+            industryFieldKey: "cementProduced",
+        },
+    },
+    // Battery & EV Infrastructure (fallback to manufacturing structure)
+    "Battery & EV Infra": {
+        manufacturing_facility_area: {
+            userDataPath: "additionalConfig.erp.battery & ev infra.plants.{plantName}.facilityArea",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Facility Area (m²)",
+            industryFieldKey: "facilityArea",
+        },
+        annual_production: {
+            userDataPath: "additionalConfig.erp.battery & ev infra.plants.{plantName}.annualProduction",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Annual Production (units)",
+            industryFieldKey: "annualProduction",
+        },
+    },
+    // Default mapping for industries without specific configuration
+    default: {
+        manufacturing_facility_area: {
+            userDataPath: "additionalConfig.erp.{industry}.plants.{plantName}.facilityArea",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Facility Area (m²)",
+            industryFieldKey: "facilityArea",
+        },
+        annual_production: {
+            userDataPath: "additionalConfig.erp.{industry}.plants.{plantName}.annualProduction",
+            transform: (value) => parseFloat(value) || 0,
+            required: true,
+            fieldLabel: "Annual Production (tonnes)",
+            industryFieldKey: "annualProduction",
+        },
+    },
+};
+// Helper function to get nested value from object using dot notation
+const getNestedValue = (obj, path) => {
+    if (!obj || !path)
+        return undefined;
+    // Handle array notation like "plants[].plantData.field"
+    if (path.includes("[].")) {
+        const [arrayPath, ...restPath] = path.split("[].", 2);
+        const arrayValue = getNestedValue(obj, arrayPath);
+        if (Array.isArray(arrayValue) && arrayValue.length > 0) {
+            // For now, take the first item in the array
+            return getNestedValue(arrayValue[0], restPath.join("[]."));
+        }
+        return undefined;
+    }
+    return path.split(".").reduce((current, key) => {
+        return current && current[key] !== undefined ? current[key] : undefined;
+    }, obj);
+};
+// Main function to extract carbon intensity data from user data
+const extractCarbonIntensityData = (userData, industry) => {
+    var _a, _b;
+    let mapping = CARBON_INTENSITY_FIELD_MAPPINGS[industry];
+    // If no mapping found, try default mapping
+    if (!mapping) {
+        mapping = CARBON_INTENSITY_FIELD_MAPPINGS.default;
+        console.warn(`No specific carbon intensity mapping found for industry: ${industry}, using default mapping`);
+    }
+    const extractedData = {};
+    // Get the current plant name - use the first available plant or a default
+    const industryData = (_b = (_a = userData.additionalConfig) === null || _a === void 0 ? void 0 : _a.erp) === null || _b === void 0 ? void 0 : _b[industry.toLowerCase()];
+    const plants = industryData === null || industryData === void 0 ? void 0 : industryData.plants;
+    let currentPlantName = "default";
+    if (plants && typeof plants === "object") {
+        if (Array.isArray(plants)) {
+            // Handle array-based plants structure
+            if (plants.length > 0) {
+                // Use the first plant's id or name
+                const firstPlant = plants[0];
+                currentPlantName = firstPlant.id || firstPlant.name || "default";
+                console.log(`Using plant "${currentPlantName}" from array for carbon intensity data extraction`);
+            }
+        }
+        else {
+            // Handle object-based plants structure
+            const plantNames = Object.keys(plants);
+            if (plantNames.length > 0) {
+                currentPlantName = plantNames[0];
+                console.log(`Using plant "${currentPlantName}" from object for carbon intensity data extraction`);
+            }
+        }
+    }
+    Object.entries(mapping).forEach(([apiField, config]) => {
+        // Replace {industry} and {plantName} placeholders
+        let userDataPath = config.userDataPath
+            .replace("{industry}", industry.toLowerCase())
+            .replace("{plantName}", currentPlantName);
+        let value = getNestedValue(userData, userDataPath);
+        // If value not found and we have array-based plants, try alternative path
+        if ((value === undefined || value === null) &&
+            plants &&
+            Array.isArray(plants) &&
+            plants.length > 0) {
+            // Try to get the field directly from the first plant's plantData
+            const firstPlant = plants[0];
+            const fieldKey = config.industryFieldKey;
+            if (firstPlant.plantData &&
+                fieldKey &&
+                firstPlant.plantData[fieldKey] !== undefined) {
+                value = firstPlant.plantData[fieldKey];
+                console.log(`Found ${apiField} in plantData: ${value}`);
+            }
+        }
+        // Apply transformation if provided
+        if (config.transform && value !== undefined) {
+            value = config.transform(value);
+        }
+        // Only use fallback if config explicitly has one and field is not required
+        if (value === undefined || value === null || isNaN(Number(value))) {
+            if (config.required) {
+                // For required fields, set to 0 to indicate missing data (will be caught by validation)
+                value = 0;
+            }
+            else {
+                // For non-required fields, use fallback if available
+                value = config.fallback || 0;
+            }
+        }
+        extractedData[apiField] = Number(value);
+    });
+    return extractedData;
+};
+// Helper function to map frontend industry names to API industry types
+const mapIndustryToApiType = (industryName) => {
+    const industryMapping = {
+        Steel: "steel",
+        Pharmaceutical: "pharma",
+        Chemical: "chemical",
+        Aluminum: "aluminium",
+        Alloy: "alloy",
+        Textile: "textile",
+        Automobiles: "automobile",
+        Aviation: "aviation",
+        Shipping: "shipping",
+        "Food & Beverages": "food_beverages",
+        Hospitality: "hospitality",
+        Logistics: "logistics",
+        Manufacturing: "manufacturing",
+        "Metals & Energy": "metal_energy",
+        "Battery & EV Infra": "manufacturing", // Falls back to manufacturing
+        Packaging: "packaging",
+        "Petro Chemical": "petrochemical",
+        "Real Estate & Construction": "real_estate",
+        Telecommunications: "telecommunication",
+        Utilities: "utilities",
+        Cement: "manufacturing", // Maps cement to manufacturing API
+    };
+    return industryMapping[industryName] || "manufacturing";
+};
+// Helper function to get available fields for an industry from user data
+const getAvailableFieldsForIndustry = (userData, industry) => {
+    const mapping = CARBON_INTENSITY_FIELD_MAPPINGS[industry];
+    if (!mapping)
+        return [];
+    const availableFields = [];
+    Object.entries(mapping).forEach(([apiField, config]) => {
+        const value = getNestedValue(userData, config.userDataPath);
+        if (value !== undefined && value !== null && value !== "") {
+            availableFields.push(apiField);
+        }
+    });
+    return availableFields;
+};
+// Helper function to validate that required data is available
+const validateCarbonIntensityData = (userData, industry) => {
+    var _a, _b;
+    let mapping = CARBON_INTENSITY_FIELD_MAPPINGS[industry];
+    if (!mapping) {
+        mapping = CARBON_INTENSITY_FIELD_MAPPINGS.default;
+    }
+    const extractedData = extractCarbonIntensityData(userData, industry);
+    const missingFields = [];
+    const errors = [];
+    // Get the current plant name for error messages
+    const industryData = (_b = (_a = userData.additionalConfig) === null || _a === void 0 ? void 0 : _a.erp) === null || _b === void 0 ? void 0 : _b[industry.toLowerCase()];
+    const plants = industryData === null || industryData === void 0 ? void 0 : industryData.plants;
+    let currentPlantName = "default";
+    if (plants && typeof plants === "object") {
+        if (Array.isArray(plants)) {
+            // Handle array-based plants structure
+            if (plants.length > 0) {
+                // Use the first plant's id or name
+                const firstPlant = plants[0];
+                currentPlantName = firstPlant.id || firstPlant.name || "default";
+            }
+        }
+        else {
+            // Handle object-based plants structure
+            const plantNames = Object.keys(plants);
+            if (plantNames.length > 0) {
+                currentPlantName = plantNames[0];
+            }
+        }
+    }
+    Object.entries(mapping).forEach(([apiField, config]) => {
+        if (config.required) {
+            const value = extractedData[apiField];
+            if (!value || value === 0) {
+                const userDataPath = config.userDataPath
+                    .replace("{industry}", industry.toLowerCase())
+                    .replace("{plantName}", currentPlantName);
+                missingFields.push({
+                    apiField,
+                    fieldLabel: config.fieldLabel || apiField,
+                    industryFieldKey: config.industryFieldKey || apiField,
+                    userDataPath,
+                });
+                errors.push(`Missing required field: "${config.fieldLabel || apiField}" (Key: ${config.industryFieldKey || apiField}) is required for carbon intensity calculations. Please fill this field in the ${industry} industry configuration for plant "${currentPlantName}".`);
+            }
+        }
+    });
+    return {
+        isValid: missingFields.length === 0,
+        missingFields,
+        errors,
+    };
+};
+// Debug function to see what data is being extracted
+const debugCarbonIntensityMapping = (userData, industry) => {
+    extractCarbonIntensityData(userData, industry);
+};
 
 /**
  * UI Features Configuration System
@@ -40116,12 +40613,15 @@ exports.createBillManager = createBillManager;
 exports.createCapitalizedMonthMapping = createCapitalizedMonthMapping;
 exports.createEmissionSourceGenerator = createEmissionSourceGenerator;
 exports.createMonthMapping = createMonthMapping;
+exports.debugCarbonIntensityMapping = debugCarbonIntensityMapping;
+exports.extractCarbonIntensityData = extractCarbonIntensityData;
 exports.formatEmissionValue = formatEmissionValue;
 exports.formatIntensityValue = formatIntensityValue;
 exports.formatKPIEmission = formatKPIEmission;
 exports.formatMonthlyEmission = formatMonthlyEmission;
 exports.formatPercentage = formatPercentage;
 exports.getApiIndustryType = getApiIndustryType;
+exports.getAvailableFieldsForIndustry = getAvailableFieldsForIndustry;
 exports.getIndustryConfig = getIndustryConfig;
 exports.getIndustryFieldConfig = getIndustryFieldConfig;
 exports.getIntensityFormulas = getIntensityFormulas;
@@ -40130,6 +40630,8 @@ exports.getScope3ConfigByName = getScope3ConfigByName;
 exports.getUserNameWaterManagementConfig = getUserNameWaterManagementConfig;
 exports.hasIntensities = hasIntensities;
 exports.isUIFeatureEnabled = isUIFeatureEnabled;
+exports.mapIndustryToApiType = mapIndustryToApiType;
 exports.sanitizeNumber = sanitizeNumber;
 exports.supportsIntensityCalculations = supportsIntensityCalculations;
+exports.validateCarbonIntensityData = validateCarbonIntensityData;
 //# sourceMappingURL=index.js.map