@sailboat-computer/validation/dist/examples/basic-usage.js

Validation framework for sailboat computer v3

"use strict";
/**
 * Basic usage examples for the validation framework
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.runAllExamples = exports.errorHandlingExample = exports.customRuleExample = exports.basicValidationExample = void 0;
const index_1 = require("../index");
// Define constants for inventory and common types
const VesselLocation = {
    MAST_HEAD: 'location_mast_head',
    BATTERY_COMPARTMENT: 'location_battery_compartment'
};
const SecondaryState = {
    SAILING: 'vessel_sailing'
};
/**
 * Example: Basic validation engine setup
 */
async function basicValidationExample() {
    // Create validation engine with default configuration
    const engine = (0, index_1.createValidationEngine)({
        enableBatchValidation: true,
        batchSize: 10,
        parallelProcessing: true
    });
    // Register marine-specific validation rules
    const marineRules = (0, index_1.createMarineValidationRules)();
    engine.registerRules(marineRules);
    // Example sensor data
    const gpsData = {
        sensorId: 'gps-001',
        sensorType: index_1.MarineSensorType.GPS,
        timestamp: new Date(),
        value: {
            latitude: 37.7749,
            longitude: -122.4194
        },
        unit: 'degrees',
        operationalContext: SecondaryState.SAILING,
        source: {
            interface: index_1.SensorInterface.SIGNAL_K,
            device: 'Garmin GPS',
            protocol: 'NMEA 0183'
        }
    };
    const windData = {
        sensorId: 'wind-001',
        sensorType: index_1.MarineSensorType.WIND,
        timestamp: new Date(),
        value: 15.5,
        unit: 'knots',
        location: VesselLocation.MAST_HEAD,
        operationalContext: SecondaryState.SAILING,
        source: {
            interface: index_1.SensorInterface.SIGNAL_K,
            device: 'B&G Wind Sensor',
            protocol: 'NMEA 0183'
        }
    };
    const batteryData = {
        sensorId: 'battery-48v-001',
        sensorType: index_1.MarineSensorType.BATTERY_MONITOR,
        timestamp: new Date(),
        value: 52.1,
        unit: 'volts',
        location: VesselLocation.BATTERY_COMPARTMENT,
        operationalContext: SecondaryState.SAILING,
        source: {
            interface: index_1.SensorInterface.I2C,
            device: 'Victron SmartShunt',
            protocol: 'VE.Direct'
        }
    };
    // Create validation context
    const context = {
        operationalContext: SecondaryState.SAILING,
        environmentalConditions: {
            seaState: 'moderate',
            weather: 'clear'
        },
        recentData: [],
        sensorHealth: {},
        crossSensorData: {}
    };
    try {
        // Validate individual sensor readings
        console.log('=== Individual Validation Results ===');
        const gpsResult = await engine.validate(gpsData, context);
        console.log('GPS Validation:', {
            passed: gpsResult.isValid,
            confidence: gpsResult.confidence,
            warnings: gpsResult.warnings
        });
        const windResult = await engine.validate(windData, context);
        console.log('Wind Validation:', {
            passed: windResult.isValid,
            confidence: windResult.confidence,
            warnings: windResult.warnings
        });
        const batteryResult = await engine.validate(batteryData, context);
        console.log('Battery Validation:', {
            passed: batteryResult.isValid,
            confidence: batteryResult.confidence,
            warnings: batteryResult.warnings
        });
        // Batch validation
        console.log('\n=== Batch Validation Results ===');
        const batchResults = await engine.validateBatch([gpsData, windData, batteryData], context);
        batchResults.forEach((result, index) => {
            const sensorTypes = ['GPS', 'Wind', 'Battery'];
            console.log(`${sensorTypes[index]} - Valid: ${result.isValid}, Confidence: ${result.confidence.toFixed(3)}`);
        });
        // Get validation metrics
        console.log('\n=== Validation Metrics ===');
        const metrics = engine.getMetrics();
        console.log('Metrics:', {
            averageValidationTime: `${metrics.throughput.averageValidationTime.toFixed(2)}ms`,
            overallPassRate: `${(metrics.qualityMetrics.overallPassRate * 100).toFixed(1)}%`
        });
    }
    catch (error) {
        console.error('Validation failed:', error);
    }
}
exports.basicValidationExample = basicValidationExample;
/**
 * Example: Custom validation rule
 */
function customRuleExample() {
    console.log('\n=== Marine Validation Ranges ===');
    console.log('GPS Position Ranges:', index_1.MARINE_RANGES.navigation.gps.position);
    console.log('Wind Speed Ranges:', index_1.MARINE_RANGES.navigation.wind.speed);
    console.log('Battery 48V Ranges:', index_1.MARINE_RANGES.electrical.battery48v.voltage);
    console.log('Engine Temperature Ranges:', index_1.MARINE_RANGES.engine.temperature);
}
exports.customRuleExample = customRuleExample;
/**
 * Example: Error handling and edge cases
 */
async function errorHandlingExample() {
    const engine = (0, index_1.createValidationEngine)();
    const marineRules = (0, index_1.createMarineValidationRules)();
    engine.registerRules(marineRules);
    // Invalid GPS data
    const invalidGpsData = {
        sensorId: 'gps-002',
        sensorType: index_1.MarineSensorType.GPS,
        timestamp: new Date(),
        value: {
            latitude: 91, // Invalid latitude
            longitude: -200 // Invalid longitude
        },
        unit: 'degrees',
        operationalContext: SecondaryState.SAILING,
        source: {
            interface: index_1.SensorInterface.SIGNAL_K,
            device: 'Test GPS',
            protocol: 'NMEA 0183'
        }
    };
    // Out of range wind speed
    const extremeWindData = {
        sensorId: 'wind-002',
        sensorType: index_1.MarineSensorType.WIND,
        timestamp: new Date(),
        value: 150, // Extreme wind speed
        unit: 'knots',
        operationalContext: SecondaryState.SAILING,
        source: {
            interface: index_1.SensorInterface.SIGNAL_K,
            device: 'Test Wind Sensor',
            protocol: 'NMEA 0183'
        }
    };
    const context = {
        operationalContext: SecondaryState.SAILING,
        environmentalConditions: {},
        recentData: [],
        sensorHealth: {},
        crossSensorData: {}
    };
    console.log('\n=== Error Handling Examples ===');
    try {
        const invalidGpsResult = await engine.validate(invalidGpsData, context);
        console.log('Invalid GPS Result:', {
            passed: invalidGpsResult.isValid,
            errors: invalidGpsResult.validationResults.filter(r => !r.passed).map(r => r.message)
        });
        const extremeWindResult = await engine.validate(extremeWindData, context);
        console.log('Extreme Wind Result:', {
            passed: extremeWindResult.isValid,
            errors: extremeWindResult.validationResults.filter(r => !r.passed).map(r => r.message)
        });
    }
    catch (error) {
        console.error('Validation error:', error);
    }
}
exports.errorHandlingExample = errorHandlingExample;
/**
 * Run all examples
 */
async function runAllExamples() {
    console.log('🚢 Sailboat Computer v3 - Validation Framework Examples\n');
    await basicValidationExample();
    customRuleExample();
    await errorHandlingExample();
    console.log('\n✅ All examples completed!');
}
exports.runAllExamples = runAllExamples;
// Run examples if this file is executed directly
if (require.main === module) {
    runAllExamples().catch(console.error);
}
//# sourceMappingURL=basic-usage.js.map