geo-coordinates-parser 1.5.8 → 1.6.0

package/dist/mjs/converter.js

@@ -0,0 +1,358 @@
+//function for converting coordinates from a string to decimal and verbatim
+//this is just a comment
+import { dd_re, dms_periods, dms_abbr, coords_other } from './regex.js';
+import toCoordinateFormat from './toCoordinateFormat.js';
+/**
+ * Function for converting coordinates in a variety of formats to decimal coordinates
+ * @param {string} coordsString The coordinates string to convert
+ * @param {number} decimalPlaces The number of decimal places for converted coordinates; default is 5
+ * @returns {object} { verbatimCoordinates, decimalCoordinates, decimalLatitude, decimalLongitude }
+ */
+function converter(coordsString, decimalPlaces) {
+    //TODO add exact match to entered string, so that it can be used to filter out superflous text around it
+    if (!decimalPlaces) {
+        decimalPlaces = 5;
+    }
+    coordsString = coordsString.replace(/\s+/g, ' ').trim(); //just to tidy up whitespaces
+    let ddLat = null;
+    let ddLng = null;
+    let latdir = "";
+    let lngdir = "";
+    let match = [];
+    let matchSuccess = false;
+    if (dd_re.test(coordsString)) {
+        match = dd_re.exec(coordsString);
+        matchSuccess = checkMatch(match);
+        if (matchSuccess) {
+            ddLat = match[2];
+            ddLng = match[6];
+            //need to fix if there are ','s instead of '.'
+            if (ddLat.includes(',')) {
+                ddLat = ddLat.replace(',', '.');
+            }
+            if (ddLng.includes(',')) {
+                ddLng = ddLng.replace(',', '.');
+            }
+            //validation, we don't want things like 23.00000
+            //some more validation: no zero coords or degrees only
+            if (Number(Math.round(ddLat)) == Number(ddLat)) {
+                throw new Error('integer only coordinate provided');
+            }
+            if (Number(Math.round(ddLng)) == Number(ddLng)) {
+                throw new Error('integer only coordinate provided');
+            }
+            //get directions
+            if (match[1]) {
+                latdir = match[1];
+                lngdir = match[5];
+            }
+            else if (match[4]) {
+                latdir = match[4];
+                lngdir = match[8];
+            }
+        }
+        else {
+            throw new Error("invalid decimal coordinate format");
+        }
+    }
+    else if (dms_periods.test(coordsString)) {
+        match = dms_periods.exec(coordsString);
+        matchSuccess = checkMatch(match);
+        if (matchSuccess) {
+            ddLat = Math.abs(parseInt(match[2]));
+            if (match[4]) {
+                ddLat += match[4] / 60;
+            }
+            if (match[6]) {
+                ddLat += match[6].replace(',', '.') / 3600;
+            }
+            if (parseInt(match[2]) < 0) {
+                ddLat = -1 * ddLat;
+            }
+            ddLng = Math.abs(parseInt(match[9]));
+            if (match[11]) {
+                ddLng += match[11] / 60;
+            }
+            if (match[13]) {
+                ddLng += match[13].replace(',', '.') / 3600;
+            }
+            if (parseInt(match[9]) < 0) {
+                ddLng = -1 * ddLng;
+            }
+            //the compass directions
+            if (match[1]) {
+                latdir = match[1];
+                lngdir = match[8];
+            }
+            else if (match[7]) {
+                latdir = match[7];
+                lngdir = match[14];
+            }
+        }
+        else {
+            throw new Error("invalid DMS coordinates format");
+        }
+    }
+    else if (dms_abbr.test(coordsString)) {
+        match = dms_abbr.exec(coordsString);
+        matchSuccess = checkMatch(match);
+        if (matchSuccess) {
+            ddLat = Math.abs(parseInt(match[2]));
+            if (match[4]) {
+                ddLat += match[4] / 60;
+            }
+            if (match[6]) {
+                ddLat += match[6] / 3600;
+            }
+            if (parseInt(match[2]) < 0) {
+                ddLat = -1 * ddLat;
+            }
+            ddLng = Math.abs(parseInt(match[10]));
+            if (match[12]) {
+                ddLng += match[12] / 60;
+            }
+            if (match[14]) {
+                ddLng += match[14] / 3600;
+            }
+            if (parseInt(match[10]) < 0) {
+                ddLng = -1 * ddLng;
+            }
+            if (match[1]) {
+                latdir = match[1];
+                lngdir = match[9];
+            }
+            else if (match[8]) {
+                latdir = match[8];
+                lngdir = match[16];
+            }
+        }
+        else {
+            throw new Error("invalid DMS coordinates format");
+        }
+    }
+    else if (coords_other.test(coordsString)) {
+        match = coords_other.exec(coordsString);
+        matchSuccess = checkMatch(match);
+        if (matchSuccess) {
+            ddLat = Math.abs(parseInt(match[2]));
+            if (match[4]) {
+                ddLat += match[4] / 60;
+            }
+            if (match[6]) {
+                ddLat += match[6] / 3600;
+            }
+            if (parseInt(match[2]) < 0) {
+                ddLat = -1 * ddLat;
+            }
+            ddLng = Math.abs(parseInt(match[10]));
+            if (match[12]) {
+                ddLng += match[12] / 60;
+            }
+            if (match[14]) {
+                ddLng += match[14] / 3600;
+            }
+            if (parseInt(match[10]) < 0) {
+                ddLng = -1 * ddLng;
+            }
+            if (match[1]) {
+                latdir = match[1];
+                lngdir = match[9];
+            }
+            else if (match[8]) {
+                latdir = match[8];
+                lngdir = match[16];
+            }
+        }
+        else {
+            throw new Error("invalid coordinates format");
+        }
+    }
+    if (matchSuccess) {
+        //more validation....
+        //check longitude value - it can be wrong!
+        if (Math.abs(ddLng) >= 180) {
+            throw new Error("invalid longitude value");
+        }
+        //just to be safe check latitude also...
+        if (Math.abs(ddLat) >= 90) {
+            throw new Error("invalid latitude value");
+        }
+        //if we have one direction we must have the other
+        if ((latdir || lngdir) && (!latdir || !lngdir)) {
+            throw new Error("invalid coordinates format");
+        }
+        //the directions can't be the same
+        if (latdir && latdir == lngdir) {
+            throw new Error("invalid coordinates format");
+        }
+        //make sure the signs and cardinal directions match
+        let patt = /S|SOUTH/i;
+        if (patt.test(latdir)) {
+            if (ddLat > 0) {
+                ddLat = -1 * ddLat;
+            }
+        }
+        patt = /W|WEST/i;
+        if (patt.test(lngdir)) {
+            if (ddLng > 0) {
+                ddLng = -1 * ddLng;
+            }
+        }
+        //we need to get the verbatim coords from the string
+        //we can't split down the middle because if there are decimals they may have different numbers on each side
+        //so we need to find the separating character, or if none, use the match values to split down the middle
+        const verbatimCoordinates = match[0].trim();
+        let verbatimLat;
+        let verbatimLng;
+        const sepChars = /[,/;\u0020]/g; //comma, forward slash and spacebar
+        const seps = verbatimCoordinates.match(sepChars);
+        if (seps == null) {
+            //split down the middle
+            const middle = Math.floor(coordsString.length / 2);
+            verbatimLat = verbatimCoordinates.substring(0, middle).trim();
+            verbatimLng = verbatimCoordinates.substring(middle).trim();
+        }
+        else { //if length is odd then find the index of the middle value
+            //get the middle index
+            let middle;
+            //easy for odd numbers
+            if (seps.length % 2 == 1) {
+                middle = Math.floor(seps.length / 2);
+            }
+            else {
+                middle = (seps.length / 2) - 1;
+            }
+            //walk through seps until we get to the middle
+            let splitIndex = 0;
+            //it might be only one value
+            if (middle == 0) {
+                splitIndex = verbatimCoordinates.indexOf(seps[0]);
+                verbatimLat = verbatimCoordinates.substring(0, splitIndex).trim();
+                verbatimLng = verbatimCoordinates.substring(splitIndex + 1).trim();
+            }
+            else {
+                let currSepIndex = 0;
+                let startSearchIndex = 0;
+                while (currSepIndex <= middle) {
+                    splitIndex = verbatimCoordinates.indexOf(seps[currSepIndex], startSearchIndex);
+                    startSearchIndex = splitIndex + 1;
+                    currSepIndex++;
+                }
+                verbatimLat = verbatimCoordinates.substring(0, splitIndex).trim();
+                verbatimLng = verbatimCoordinates.substring(splitIndex + 1).trim();
+            }
+        }
+        //validation again...
+        //we only allow zeros after the period if its DM
+        const splitLat = verbatimLat.split('.');
+        if (splitLat.length == 2) {
+            if (splitLat[1] == 0 && splitLat[1].length != 2) {
+                throw new Error('invalid coordinates format');
+            }
+        }
+        const splitLon = verbatimLng.split('.');
+        if (splitLon.length == 2) {
+            if (splitLon[1] == 0 && splitLon[1].length != 2) {
+                throw new Error('invalid coordinates format');
+            }
+        }
+        //no integer coords allowed
+        //validation -- no integer coords
+        if (/^\d+$/.test(verbatimLat) || /^\d+$/.test(verbatimLng)) {
+            throw new Error('degree only coordinate/s provided');
+        }
+        //some tidying up...
+        if (isNaN(ddLat) && ddLat.includes(',')) {
+            ddLat = ddLat.replace(',', '.');
+        }
+        //all done!!
+        //just truncate the decimals appropriately
+        ddLat = Number(Number(ddLat).toFixed(decimalPlaces));
+        if (isNaN(ddLng) && ddLng.includes(',')) {
+            ddLng = ddLng.replace(',', '.');
+        }
+        ddLng = Number(Number(ddLng).toFixed(decimalPlaces));
+        return Object.freeze({
+            verbatimCoordinates,
+            verbatimLatitude: verbatimLat,
+            verbatimLongitude: verbatimLng,
+            decimalLatitude: ddLat,
+            decimalLongitude: ddLng,
+            decimalCoordinates: `${ddLat},${ddLng}`,
+            closeEnough: coordsCloseEnough,
+            toCoordinateFormat
+        });
+    }
+    else {
+        throw new Error("coordinates pattern match failed");
+    }
+}
+function checkMatch(match) {
+    if (!isNaN(match[0])) { //we've matched a number, not what we want....
+        return false;
+    }
+    //first remove the empty values from the array
+    const filteredMatch = [...match];
+    //we need to shift the array because it contains the whole coordinates string in the first item
+    filteredMatch.shift();
+    //check the array length is an even number else exit
+    if (filteredMatch.length % 2 > 0) {
+        return false;
+    }
+    //regex for testing corresponding values match
+    const numerictest = /^[-+]?\d+([\.,]\d+)?$/; //for testing numeric values
+    const stringtest = /[eastsouthnorthwest]+/i; //for testing string values (north, south, etc)
+    const halflen = filteredMatch.length / 2;
+    for (let i = 0; i < halflen; i++) {
+        const leftside = filteredMatch[i];
+        const rightside = filteredMatch[i + halflen];
+        const bothAreNumbers = numerictest.test(leftside) && numerictest.test(rightside);
+        const bothAreStrings = stringtest.test(leftside) && stringtest.test(rightside);
+        const valuesAreEqual = leftside == rightside;
+        if (leftside == undefined && rightside == undefined) { //we have to handle undefined because regex converts it to string 'undefined'!!
+            continue;
+        }
+        else if (leftside == undefined || rightside == undefined) { //no we need to handle the case where one is and the other not...
+            return false;
+        }
+        else if (bothAreNumbers || bothAreStrings || valuesAreEqual) {
+            continue;
+        }
+        else {
+            return false;
+        }
+    }
+    return true;
+}
+//functions for coordinate validation
+//as decimal arithmetic is not straightforward, we approximate
+function decimalsCloseEnough(dec1, dec2) {
+    const originaldiff = Math.abs(dec1 - dec2);
+    const diff = Number(originaldiff.toFixed(6));
+    if (diff <= 0.00001) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+function coordsCloseEnough(coordsToTest) {
+    if (coordsToTest.includes(',')) {
+        const coords = coordsToTest.split(',');
+        if (Number(coords[0]) == NaN || Number(coords[1]) == NaN) {
+            throw new Error("coords are not valid decimals");
+        }
+        else {
+            return decimalsCloseEnough(this.decimalLatitude, Number(coords[0])) && decimalsCloseEnough(this.decimalLongitude, coords[1]); //this here will be the converted coordinates object
+        }
+    }
+    else {
+        throw new Error("coords being tested must be separated by a comma");
+    }
+}
+const to = Object.freeze({
+    DMS: 'DMS',
+    DM: 'DM'
+});
+converter.to = to;
+export default converter;

package/dist/mjs/merge.d.ts

@@ -0,0 +1,2 @@
+export const convert: typeof converter;
+import converter from './converter.js';

package/dist/mjs/merge.js

@@ -0,0 +1,6 @@
+//adds the formats to the convert object
+//we need to use this as the source for the npm package so that the formats are not included in the bundle
+import converter from './converter.js';
+import testFormats from './tests/testformats.js';
+converter.formats = testFormats.map(format => format.verbatimCoordinates);
+export const convert = converter;

package/dist/mjs/package.json

@@ -0,0 +1,3 @@
+{ 
+  "type": "module" 
+} 

package/dist/mjs/regex.d.ts

@@ -0,0 +1,4 @@
+export const dd_re: RegExp;
+export const dms_periods: RegExp;
+export const dms_abbr: RegExp;
+export const coords_other: RegExp;

package/dist/mjs/regex.js

@@ -0,0 +1,10 @@
+//Coordinates pattern matching regex
+//decimal degrees
+const dd_re = /(NORTH|SOUTH|[NS])?[\s]*([+-]?[0-8]?[0-9](?:[\.,]\d{3,}))[\s]*([•º°]?)[\s]*(NORTH|SOUTH|[NS])?[\s]*[,/;]?[\s]*(EAST|WEST|[EW])?[\s]*([+-]?[0-1]?[0-9]?[0-9](?:[\.,]\d{3,}))[\s]*([•º°]?)[\s]*(EAST|WEST|[EW])?/i;
+//degrees minutes seconds with '.' as separator - gives array with 15 values
+const dms_periods = /(NORTH|SOUTH|[NS])?\s*([+-]?[0-8]?[0-9])\s*(\.)\s*([0-5]?[0-9])\s*(\.)\s*((?:[0-5]?[0-9])(?:[\.,]\d{1,3})?)?\s*(NORTH|SOUTH|[NS])?(?:\s*[,/;]\s*|\s*)(EAST|WEST|[EW])?\s*([+-]?[0-1]?[0-9]?[0-9])\s*(\.)\s*([0-5]?[0-9])\s*(\.)\s*((?:[0-5]?[0-9])(?:[\.,]\d{1,3})?)?\s*(EAST|WEST|[EW])?/i;
+//degrees minutes seconds with words 'degrees, minutes, seconds' as separators (needed because the s of seconds messes with the S of SOUTH) - gives array of 17 values
+const dms_abbr = /(NORTH|SOUTH|[NS])?\s*([+-]?[0-8]?[0-9])\s*(D(?:EG)?(?:REES)?)\s*([0-5]?[0-9])\s*(M(?:IN)?(?:UTES)?)\s*((?:[0-5]?[0-9])(?:[\.,]\d{1,3})?)?\s*(S(?:EC)?(?:ONDS)?)?\s*(NORTH|SOUTH|[NS])?(?:\s*[,/;]\s*|\s*)(EAST|WEST|[EW])?\s*([+-]?[0-1]?[0-9]?[0-9])\s*(D(?:EG)?(?:REES)?)\s*([0-5]?[0-9])\s*(M(?:IN)?(?:UTES)?)\s*((?:[0-5]?[0-9])(?:[\.,]\d{1,3})?)?\s*(S(?:EC)?(?:ONDS)?)\s*(EAST|WEST|[EW])?/i;
+//everything else - gives array of 17 values 
+const coords_other = /(NORTH|SOUTH|[NS])?\s*([+-]?[0-8]?[0-9])\s*([•º°\.:]|D(?:EG)?(?:REES)?)?\s*,?([0-5]?[0-9](?:[\.,]\d{1,})?)?\s*(['′´’\.:]|M(?:IN)?(?:UTES)?)?\s*,?((?:[0-5]?[0-9])(?:[\.,]\d{1,3})?)?\s*(''|′′|’’|´´|["″”\.])?\s*(NORTH|SOUTH|[NS])?(?:\s*[,/;]\s*|\s*)(EAST|WEST|[EW])?\s*([+-]?[0-1]?[0-9]?[0-9])\s*([•º°\.:]|D(?:EG)?(?:REES)?)?\s*,?([0-5]?[0-9](?:[\.,]\d{1,})?)?\s*(['′´’\.:]|M(?:IN)?(?:UTES)?)?\s*,?((?:[0-5]?[0-9])(?:[\.,]\d{1,3})?)?\s*(''|′′|´´|’’|["″”\.])?\s*(EAST|WEST|[EW])?/i;
+export { dd_re, dms_periods, dms_abbr, coords_other };

package/dist/mjs/tests/failFormats.d.ts

@@ -0,0 +1,2 @@
+export default failingFormats;
+declare const failingFormats: string[];

package/dist/mjs/tests/failFormats.js

@@ -0,0 +1,24 @@
+//TODO These formats should throw...
+const failingFormats = [
+    '10,10',
+    '46,8',
+    '12.12323, 123',
+    '24.0, 26.0',
+    '33.25°S 18.25°E',
+    '27.0 23.0',
+    '10.00000S 10.000000E',
+    '00.00 01.00',
+    '50°4\'17.698"south, 24.34532',
+    '90°4\'17.698"south, 23°4\'17.698"east',
+    '89°4\'17.698"south, 183°4\'17.698"east',
+    '50°4\'17.698"east, 23°4\'17.698"south',
+    'E23.34355,S25.324234',
+    '23°45\'12.2\'\'S 18.33\'56.7\'\'E',
+    'S 27.45.34 23.23.23',
+    'S 27.45.34 S 23.23.23',
+    'S 90°4\'17.698" S 23°4\'17.698"',
+    '27.45.34 S S 23.23.23',
+    '27.45.34  23.23.23 E',
+    '8°83S 35°67E '
+];
+export default failingFormats;

package/dist/mjs/tests/makeTestFormatsJSON.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mjs/tests/makeTestFormatsJSON.js

@@ -0,0 +1,9 @@
+import fs from 'fs';
+import testFormats from './testformats.js';
+fs.writeFile("testFormats.json", JSON.stringify(testFormats, null, 2), 'utf8', function (err) {
+    if (err) {
+        console.log("An error occured while writing JSON Object to File.");
+        return console.log(err);
+    }
+    console.log("JSON file has been saved.");
+});

package/dist/mjs/tests/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mjs/tests/test.js

@@ -0,0 +1,51 @@
+import convert from '../converter.js';
+import testFormats from '../testformats.js';
+import failingFormats from './failFormats.js';
+let allPassed = true;
+//FORMATS THAT SHOULD BE CONVERTED
+for (const t of testFormats) {
+    try {
+        const converted = convert(t.verbatimCoordinates, 8);
+        const testDecimalCoordsString = `${t.decimalLatitude},${t.decimalLongitude}`;
+        //check the calculation is correct
+        if (!converted.closeEnough(testDecimalCoordsString)) {
+            console.log("Error in decimal conversion");
+            console.log(t.verbatimCoordinates);
+            console.log(t.decimalLatitude);
+            console.log(t.decimalLongitude);
+            allPassed = false;
+        }
+        //check the verbatim coords are correct
+        if (converted.verbatimLatitude != t.verbatimLatitude || converted.verbatimLongitude != t.verbatimLongitude) {
+            console.log("Error in verbatim extraction");
+            console.log('For', t.verbatimCoordinates);
+            console.log('got', converted.verbatimLatitude, 'should be ', t.verbatimLatitude);
+            console.log('got', converted.verbatimLongitude, 'should be', t.verbatimLongitude);
+            allPassed = false;
+        }
+    }
+    catch (err) {
+        console.log("Failed to convert the following format");
+        console.log(t.verbatimCoordinates);
+        console.log(err.message);
+        allPassed = false;
+    }
+}
+//FORMATS THAT SHOULD NOT BE CONVERTED
+const converting = [];
+for (let f of failingFormats) {
+    try {
+        const converted = convert(f);
+        converting.push(f);
+        allPassed = false;
+    }
+    catch {
+        //nothing here
+    }
+}
+if (converting.length) {
+    console.log("The following coordinates should NOT have converted successfully: " + converting.join(' | '));
+}
+if (allPassed) {
+    console.log("all formats successfully converted");
+}

package/dist/mjs/tests/testFormatConverter.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mjs/tests/testFormatConverter.js

@@ -0,0 +1,6 @@
+import toCoordinateFormat from '../src/toCoordinateFormat.js/index.js';
+let test = {
+    decimalCoordinates: '-234.3456, 28.92435',
+    toCoordinateFormat
+};
+console.log(test.toCoordinateFormat('DMS'));

package/dist/mjs/tests/testIndividual.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mjs/tests/testIndividual.js

@@ -0,0 +1,21 @@
+import convert from '../converter.js';
+//const test = '26°44S 29°46E'
+//const test = '00.00, 01.00'
+const test = `8°83S 35°67E`;
+try {
+    let converted = convert(test);
+    console.log(converted);
+    console.log(converted.toCoordinateFormat(convert.to.DM));
+    //and just to make sure it's frozen
+    let previous = converted.decimalLatitude;
+    converted.decimalLatitude = 24;
+    if (converted.decimalLatitude === previous) {
+        console.log('the result is frozen');
+    }
+    else {
+        console.error('!!!The result is not frozen!!!!');
+    }
+}
+catch (err) {
+    console.log(err.message);
+}

package/dist/mjs/tests/testformats.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any[];
+export default _default;