NlAlertGeo.js

.pragma library

function clampRange(value) {
    var parsed = parseInt(value)
    if (isNaN(parsed)) return 25
    return Math.max(1, Math.min(250, parsed))
}

function validCoordinates(latitude, longitude) {
    return !isNaN(latitude) && !isNaN(longitude)
        && latitude >= -90 && latitude <= 90
        && longitude >= -180 && longitude <= 180
}

function normalizePostcode(value) {
    return String(value || "").toUpperCase().replace(/[^0-9A-Z]/g, "")
}

function validPostcode(value) {
    return /^[1-9][0-9]{3}[A-Z]{2}$/.test(normalizePostcode(value))
}

function formatPostcode(value) {
    var normalized = normalizePostcode(value)
    if (normalized.length !== 6) return normalized
    return normalized.substring(0, 4) + " " + normalized.substring(4)
}

function parseWgs84Point(value) {
    var match = /^POINT\s*\(\s*(-?[0-9]+(?:\.[0-9]+)?)\s+(-?[0-9]+(?:\.[0-9]+)?)\s*\)$/i.exec(String(value || ""))
    if (!match) return null

    var longitude = parseFloat(match[1])
    var latitude = parseFloat(match[2])
    if (!validCoordinates(latitude, longitude)) return null
    return {"latitude": latitude, "longitude": longitude}
}

function parsePostcodeResponse(body, requestedPostcode) {
    var requested = normalizePostcode(requestedPostcode)
    if (!validPostcode(requested) || !body || !body.response || !(body.response.docs instanceof Array)) return null

    for (var i = 0; i < body.response.docs.length; i++) {
        var document = body.response.docs[i]
        if (!document || normalizePostcode(document.postcode) !== requested) continue
        var point = parseWgs84Point(document.centroide_ll)
        if (!point) continue

        var place = document.woonplaatsnaam ? String(document.woonplaatsnaam) : ""
        return {
            "postcode": requested,
            "formattedPostcode": formatPostcode(requested),
            "latitude": point.latitude,
            "longitude": point.longitude,
            "label": place ? formatPostcode(requested) + " " + place : formatPostcode(requested)
        }
    }
    return null
}

function parsePolygon(polygonText) {
    var points = []
    if (!polygonText) return points
    var pairs = String(polygonText).replace(/^\s+|\s+$/g, "").split(/\s+/)

    for (var i = 0; i < pairs.length; i++) {
        var parts = pairs[i].split(",")
        if (parts.length !== 2) continue
        var latitude = parseFloat(parts[0])
        var longitude = parseFloat(parts[1])
        if (validCoordinates(latitude, longitude)) points.push({"lat": latitude, "lon": longitude})
    }
    return points
}

function pointInPolygon(latitude, longitude, polygonText) {
    var points = parsePolygon(polygonText)
    if (points.length < 3) return false
    var inside = false

    for (var i = 0, j = points.length - 1; i < points.length; j = i++) {
        var yi = points[i].lat
        var xi = points[i].lon
        var yj = points[j].lat
        var xj = points[j].lon
        var crosses = ((yi > latitude) !== (yj > latitude))
            && (longitude < (xj - xi) * (latitude - yi) / (yj - yi) + xi)
        if (crosses) inside = !inside
    }
    return inside
}

function pointToSegmentDistanceKm(latitude, longitude, start, end) {
    var kmPerLatitude = 111.32
    var kmPerLongitude = 111.32 * Math.max(0.2, Math.cos(latitude * Math.PI / 180))
    var startX = (start.lon - longitude) * kmPerLongitude
    var startY = (start.lat - latitude) * kmPerLatitude
    var endX = (end.lon - longitude) * kmPerLongitude
    var endY = (end.lat - latitude) * kmPerLatitude
    var deltaX = endX - startX
    var deltaY = endY - startY
    var lengthSquared = deltaX * deltaX + deltaY * deltaY
    var projection = lengthSquared > 0
        ? -(startX * deltaX + startY * deltaY) / lengthSquared
        : 0
    projection = Math.max(0, Math.min(1, projection))
    var closestX = startX + projection * deltaX
    var closestY = startY + projection * deltaY
    return Math.sqrt(closestX * closestX + closestY * closestY)
}

function distanceToPolygonKm(latitude, longitude, polygonText) {
    var points = parsePolygon(polygonText)
    if (points.length < 3) return -1
    if (pointInPolygon(latitude, longitude, polygonText)) return 0

    var minimum = 1000000
    for (var i = 0; i < points.length; i++) {
        var next = points[(i + 1) % points.length]
        minimum = Math.min(minimum, pointToSegmentDistanceKm(latitude, longitude, points[i], next))
    }
    return minimum === 1000000 ? -1 : minimum
}

function distanceToAreasKm(latitude, longitude, areas) {
    if (!validCoordinates(latitude, longitude) || !(areas instanceof Array)) return -1
    var minimum = 1000000

    for (var i = 0; i < areas.length; i++) {
        var distance = distanceToPolygonKm(latitude, longitude, areas[i])
        if (distance >= 0) minimum = Math.min(minimum, distance)
    }
    return minimum === 1000000 ? -1 : minimum
}

function matchesRange(latitude, longitude, areas, rangeKm) {
    var distance = distanceToAreasKm(latitude, longitude, areas)
    return distance >= 0 && distance <= clampRange(rangeKm)
}

function formatDistance(distanceKm) {
    if (distanceKm < 0) return "Onbekende afstand"
    if (distanceKm < 0.05) return "Ingestelde locatie ligt in het waarschuwingsgebied"
    if (distanceKm < 10) return distanceKm.toFixed(1).replace(".", ",") + " km tot het waarschuwingsgebied"
    return Math.round(distanceKm) + " km tot het waarschuwingsgebied"
}