@ngageoint/mage.service 6.2.9 → 6.2.10-beta.1

package/lib/export/kmlWriter.js

@@ -1,20 +1,73 @@
 'use strict';
-const moment = require('moment'), path = require('path'), mgrs = require('mgrs'), { default: turfCentroid } = require('@turf/centroid'), { fragment } = require('xmlbuilder2');
-function KmlWriter() { }
-module.exports = new KmlWriter();
-function hexToParts(hex) {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFieldByName = exports.generatePlacemarkCoordinates = exports.generateDescription = exports.generateKMLClose = exports.generateKMLFolderClose = exports.generateKMLDocumentClose = exports.generateLocationPlacemark = exports.generateObservationPlacemark = exports.generateObservationStyles = exports.generateFormStyles = exports.generateEventStyle = exports.generateUserStyle = exports.generateKMLFolderStart = exports.generateKMLDocument = void 0;
+const mgrs = require('mgrs');
+const moment_1 = __importDefault(require("moment"));
+const path_1 = __importDefault(require("path"));
+const centroid_1 = __importDefault(require("@turf/centroid"));
+const xmlbuilder2_1 = require("xmlbuilder2");
+const entities_events_forms_1 = require("../entities/events/entities.events.forms");
+const defaultStyle = {
+    fill: '#5278A2',
+    stroke: '#5278A2',
+    fillOpacity: 0.2,
+    strokeOpacity: 1,
+    strokeWidth: 2
+};
+function requiredStyle(style) {
+    const dup = (0, entities_events_forms_1.copyBaseFormStyle)(style);
+    dup.fill = style.fill || defaultStyle.fill,
+        dup.stroke = style.stroke || defaultStyle.stroke,
+        dup.fillOpacity = isNumber(style.fillOpacity) ? style.fillOpacity : defaultStyle.fillOpacity,
+        dup.strokeOpacity = isNumber(style.strokeOpacity) ? style.strokeOpacity : defaultStyle.strokeOpacity,
+        dup.strokeWidth = isNumber(style.strokeWidth) ? style.strokeWidth : defaultStyle.strokeWidth;
+    return dup;
+}
+function isNumber(x) {
+    return !isNaN(x) && typeof x === 'number';
+}
+function splitRGBHexColor(hex) {
     const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-    return result ? {
-        r: result[1],
-        g: result[2],
-        b: result[3]
-    } : null;
+    if (result) {
+        return { r: result[1], g: result[2], b: result[3] };
+    }
+    return { r: '00', g: '00', b: '00' };
 }
-function convert(integer) {
+function hexStringForInt(integer) {
     const str = Number(integer).toString(16);
     return str.length === 1 ? "0" + str : str;
 }
-KmlWriter.prototype.generateKMLDocument = function () {
+function rgbIntForDecimal(maybeDec) {
+    return ~~(numberOrDefault(maybeDec, 1) * 255);
+}
+function colorHexForDecimal(maybeDec) {
+    return hexStringForInt(rgbIntForDecimal(maybeDec));
+}
+function numberOrDefault(maybeNumber, def) {
+    return typeof maybeNumber === 'number' && !Number.isNaN(maybeNumber) ? maybeNumber : def;
+}
+function kmlColor(rgb, opacityDecimal) {
+    const opacityHex = colorHexForDecimal(opacityDecimal);
+    return opacityHex + rgb.b + rgb.g + rgb.r;
+}
+/**
+ * Return the stroke opacity decimal for the given style if present, or the
+ * default stroke opacity.
+ */
+function ensureStrokeOpacity(maybe) {
+    return numberOrDefault(maybe === null || maybe === void 0 ? void 0 : maybe.strokeOpacity, defaultStyle.strokeOpacity);
+}
+/**
+ * Return the fill opacity decimal for the given style if present, or the
+ * default fill opacity.
+ */
+function ensureFillOpacity(maybe) {
+    return numberOrDefault(maybe === null || maybe === void 0 ? void 0 : maybe.fillOpacity, defaultStyle.fillOpacity);
+}
+function generateKMLDocument() {
     return "<?xml version='1.0' encoding='UTF-8'?>" +
         "<kml xmlns='http://www.opengis.net/kml/2.2' " +
         "xmlns:gx='http://www.google.com/kml/ext/2.2' " +
@@ -23,61 +76,64 @@ KmlWriter.prototype.generateKMLDocument = function () {
         "<Document>" +
         "<name>MAGE-Export.kml</name>" +
         "<open>1</open>";
-};
-KmlWriter.prototype.generateKMLFolderStart = function (name) {
+}
+exports.generateKMLDocument = generateKMLDocument;
+function generateKMLFolderStart(name) {
     return `<Folder><name>${name}</name>`;
-};
-KmlWriter.prototype.generateUserStyle = function (user) {
-    let userStyle = '';
+}
+exports.generateKMLFolderStart = generateKMLFolderStart;
+function generateUserStyle(user) {
     if (user.icon && user.icon.relativePath) {
-        userStyle = fragment({
+        return (0, xmlbuilder2_1.fragment)({
             Style: {
                 '@id': `user-${user._id.toString()}`,
                 IconStyle: {
                     Icon: {
-                        href: path.join('icons/users', user._id.toString())
+                        href: path_1.default.join('icons/users', user._id.toString())
                     }
                 }
             }
         }).end();
     }
-    return userStyle;
-};
-KmlWriter.prototype.generateEventStyle = function (event, icons) {
+    return '';
+}
+exports.generateUserStyle = generateUserStyle;
+function generateEventStyle(event, icons) {
     const defaultIcon = icons.find(icon => !icon.formId && !icon.primary && !icon.variant);
-    const strokeParts = hexToParts(event.style.stroke);
-    const fillParts = hexToParts(event.style.fill);
-    const strokeOpacity = convert(~~(event.style.strokeOpacity * 255));
-    const fillOpacity = convert(~~(event.style.fillOpacity * 255));
-    return fragment({
+    const strokeParts = splitRGBHexColor(event.style.stroke || '');
+    const fillParts = splitRGBHexColor(event.style.fill || '');
+    const strokeOpacity = ensureStrokeOpacity(event.style);
+    const fillOpacity = ensureFillOpacity(event.style);
+    return (0, xmlbuilder2_1.fragment)({
         Style: {
-            '@id': event._id.toString(),
+            '@id': String(event._id),
             IconStyle: {
                 Icon: {
-                    href: path.join('icons', defaultIcon.relativePath)
+                    href: path_1.default.join('icons', defaultIcon.relativePath)
                 }
             },
             LineStyle: {
                 width: event.style.strokeWidth,
-                color: strokeOpacity + strokeParts.b + strokeParts.g + strokeParts.r
+                color: kmlColor(strokeParts, strokeOpacity)
             },
             PolyStyle: {
-                color: fillOpacity + fillParts.b + fillParts.g + fillParts.r
+                color: kmlColor(fillParts, fillOpacity)
             }
         }
     }).end();
-};
-KmlWriter.prototype.generateFormStyles = function (event, form, icons) {
-    const styles = [];
-    const style = form.style || event.style;
-    let defaultIconPath = "";
+}
+exports.generateEventStyle = generateEventStyle;
+function generateFormStyles(event, form, icons) {
+    const styleKmlFragments = [];
+    const style = requiredStyle(form.style || event.style);
+    let defaultIconPath = '';
     const primaryPathMap = {};
     const secondaryPathMap = {};
     let strokeWidth = style.strokeWidth;
-    let strokeParts = hexToParts(style.stroke);
-    let fillParts = hexToParts(style.fill);
-    let strokeOpacity = convert(~~(style.strokeOpacity * 255));
-    let fillOpacity = convert(~~(style.fillOpacity * 255));
+    let strokeParts = splitRGBHexColor(style.stroke || '');
+    let fillParts = splitRGBHexColor(style.fill || '');
+    let strokeOpacity = ensureStrokeOpacity(style);
+    let fillOpacity = ensureFillOpacity(style);
     icons.forEach(icon => {
         if (icon.variant) {
             secondaryPathMap[icon.primary] = secondaryPathMap[icon.primary] || {};
@@ -91,56 +147,57 @@ KmlWriter.prototype.generateFormStyles = function (event, form, icons) {
         }
     });
     // default form style
-    const defaultStyle = fragment({
+    const defaultStyleKml = (0, xmlbuilder2_1.fragment)({
         Style: {
-            '@id': [event._id.toString(), form._id.toString()].join("-"),
+            '@id': `${event._id}-${form._id}`,
             IconStyle: {
                 Icon: {
-                    href: path.join('icons', defaultIconPath)
+                    href: path_1.default.join('icons', defaultIconPath)
                 }
             },
             LineStyle: {
                 width: strokeWidth,
-                color: strokeOpacity + strokeParts.b + strokeParts.g + strokeParts.r
+                color: kmlColor(strokeParts, strokeOpacity)
             },
             PolyStyle: {
-                color: fillOpacity + fillParts.b + fillParts.g + fillParts.r
+                color: kmlColor(fillParts, fillOpacity)
             }
         }
     }).end();
-    styles.push(defaultStyle);
-    const primaryField = this.getFieldByName(form, form.primaryField);
-    if (primaryField) {
+    styleKmlFragments.push(defaultStyleKml);
+    const primaryField = form.primaryField ? getFieldByName(form, form.primaryField) : undefined;
+    if (primaryField && Array.isArray(primaryField.choices)) {
         primaryField.choices.forEach(choice => {
             let iconPath = primaryPathMap[choice.title] ? primaryPathMap[choice.title] : defaultIconPath;
-            if (style[choice.title]) {
-                strokeWidth = style[choice.title].strokeWidth;
-                strokeParts = hexToParts(style[choice.title].stroke);
-                fillParts = hexToParts(style[choice.title].fill);
-                strokeOpacity = convert(~~(style[choice.title].strokeOpacity * 255));
-                fillOpacity = convert(~~(style[choice.title].fillOpacity * 255));
+            const primaryChoiceStyle = style[choice.title];
+            if (primaryChoiceStyle) {
+                strokeWidth = numberOrDefault(primaryChoiceStyle.strokeWidth, strokeWidth);
+                strokeParts = splitRGBHexColor(primaryChoiceStyle.stroke || defaultStyle.stroke);
+                fillParts = splitRGBHexColor(primaryChoiceStyle.fill || defaultStyle.fill);
+                strokeOpacity = ensureStrokeOpacity(primaryChoiceStyle);
+                fillOpacity = ensureFillOpacity(primaryChoiceStyle);
             }
-            const primaryStyle = fragment({
+            const primaryStyleKml = (0, xmlbuilder2_1.fragment)({
                 Style: {
-                    '@id': [event._id.toString(), form._id.toString(), choice.title].join("-"),
+                    '@id': `${event._id}-${form._id.toString()}-${choice.title}`,
                     IconStyle: {
                         Icon: {
-                            href: path.join('icons', iconPath)
+                            href: path_1.default.join('icons', iconPath)
                         }
                     },
                     LineStyle: {
                         width: strokeWidth,
-                        color: strokeOpacity + strokeParts.b + strokeParts.g + strokeParts.r
+                        color: kmlColor(strokeParts, strokeOpacity)
                     },
                     PolyStyle: {
-                        color: fillOpacity + fillParts.b + fillParts.g + fillParts.r
+                        color: kmlColor(fillParts, fillOpacity)
                     }
                 }
             }).end();
-            styles.push(primaryStyle);
+            styleKmlFragments.push(primaryStyleKml);
             // secondary styles for each type
-            const secondaryField = this.getFieldByName(form, form.variantField);
-            if (secondaryField) {
+            const secondaryField = getFieldByName(form, form.variantField || '');
+            if (secondaryField && Array.isArray(secondaryField.choices)) {
                 secondaryField.choices.forEach(secondaryChoice => {
                     if (secondaryPathMap[choice.title] && secondaryPathMap[choice.title][secondaryChoice.title]) {
                         iconPath = secondaryPathMap[choice.title][secondaryChoice.title];
@@ -151,102 +208,106 @@ KmlWriter.prototype.generateFormStyles = function (event, form, icons) {
                     else {
                         iconPath = defaultIconPath;
                     }
-                    if (style[choice.title] && style[choice.title][secondaryChoice.title]) {
-                        strokeWidth = style[choice.title][secondaryChoice.title].strokeWidth;
-                        strokeParts = hexToParts(style[choice.title][secondaryChoice.title].stroke);
-                        fillParts = hexToParts(style[choice.title][secondaryChoice.title].fill);
-                        strokeOpacity = convert(~~(style[choice.title][secondaryChoice.title].strokeOpacity * 255));
-                        fillOpacity = convert(~~(style[choice.title][secondaryChoice.title].fillOpacity * 255));
+                    const variantStyle = primaryChoiceStyle === null || primaryChoiceStyle === void 0 ? void 0 : primaryChoiceStyle[secondaryChoice.title];
+                    if (variantStyle) {
+                        strokeWidth = variantStyle.strokeWidth;
+                        strokeParts = splitRGBHexColor(variantStyle.stroke);
+                        fillParts = splitRGBHexColor(variantStyle.fill);
+                        strokeOpacity = ensureStrokeOpacity(variantStyle);
+                        fillOpacity = ensureFillOpacity(variantStyle);
                     }
-                    const secondaryStyle = fragment({
+                    const variantStyleKml = (0, xmlbuilder2_1.fragment)({
                         Style: {
-                            '@id': [event._id.toString(), form._id.toString(), choice.title, secondaryChoice.title].join("-"),
+                            '@id': `${event._id}-${form._id.toString()}-${choice.title}-${secondaryChoice.title}`,
                             IconStyle: {
                                 Icon: {
-                                    href: path.join('icons', iconPath)
+                                    href: path_1.default.join('icons', iconPath)
                                 }
                             },
                             LineStyle: {
                                 width: strokeWidth,
-                                color: strokeOpacity + strokeParts.b + strokeParts.g + strokeParts.r
+                                color: kmlColor(strokeParts, strokeOpacity)
                             },
                             PolyStyle: {
-                                color: fillOpacity + fillParts.b + fillParts.g + fillParts.r
+                                color: kmlColor(fillParts, fillOpacity)
                             }
                         }
                     }).end();
-                    styles.push(secondaryStyle);
+                    styleKmlFragments.push(variantStyleKml);
                 });
             }
         });
     }
-    return styles;
-};
-KmlWriter.prototype.generateObservationStyles = function (event, icons) {
+    return styleKmlFragments;
+}
+exports.generateFormStyles = generateFormStyles;
+function generateObservationStyles(event, icons) {
     const formStyles = event.forms.map(form => {
-        return this.generateFormStyles(event, form, icons.filter(icon => icon.formId === form._id));
+        return generateFormStyles(event, form, icons.filter(icon => icon.formId === form._id));
     });
-    return [this.generateEventStyle(event, icons), ...formStyles].join("");
-};
-KmlWriter.prototype.generateObservationPlacemark = function (observation, event) {
-    const forms = event.formMap;
+    return [generateEventStyle(event, icons), ...formStyles].join('');
+}
+exports.generateObservationStyles = generateObservationStyles;
+function generateObservationPlacemark(observation, event) {
     const names = [];
-    const firstForm = (observation.properties.forms && observation.properties.forms.length) ? observation.properties.forms[0] : null;
-    if (firstForm) {
-        const form = event.formMap[firstForm.formId];
-        if (firstForm[form.primaryFeedField]) {
-            names.push(firstForm[form.primaryFeedField]);
+    const firstFormEntry = (observation.properties.forms && observation.properties.forms.length) ? observation.properties.forms[0] : null;
+    if (firstFormEntry) {
+        const form = event.formFor(firstFormEntry.formId);
+        if ((form === null || form === void 0 ? void 0 : form.primaryFeedField) && firstFormEntry[form.primaryFeedField]) {
+            names.push(firstFormEntry[form.primaryFeedField]);
         }
-        if (firstForm[form.secondaryFeedField]) {
-            names.push(firstForm[form.secondaryFeedField]);
+        if ((form === null || form === void 0 ? void 0 : form.secondaryFeedField) && firstFormEntry[form === null || form === void 0 ? void 0 : form.secondaryFeedField]) {
+            names.push(firstFormEntry[form.secondaryFeedField]);
         }
     }
-    let sections = [];
-    if (observation.properties.forms) {
-        sections = observation.properties.forms.map(observationForm => {
-            const form = forms[observationForm.formId];
-            const properties = form.fields
-                .filter(field => !field.archived && field.type !== 'password' && field.type !== 'geometry')
-                .filter(field => {
-                let hasValue = false;
-                switch (field.type) {
-                    case 'attachment': {
-                        hasValue = observation.attachments.some(attachment => {
-                            return attachment.fieldName === field.name &&
-                                attachment.observationFormId.toString() === observationForm._id.toString();
-                        });
-                        break;
-                    }
-                    case 'checkbox': {
-                        hasValue = field.value != null;
-                    }
-                    default: {
-                        hasValue = observationForm[field.name];
-                    }
-                }
-                return hasValue;
-            })
-                .sort((a, b) => a.id - b.id)
-                .map(field => {
-                let value = observationForm[field.name];
-                if (field.type === 'attachment') {
-                    value = observation.attachments.filter(attachment => {
+    const formEntries = observation.properties.forms;
+    const sections = formEntries.reduce((sections, formEntry) => {
+        const form = event.formFor(formEntry.formId);
+        if (!form) {
+            return sections;
+        }
+        const properties = form.fields
+            .filter(field => !field.archived && field.type !== 'password' && field.type !== 'geometry')
+            .filter(field => {
+            let hasValue = false;
+            switch (field.type) {
+                case 'attachment':
+                    hasValue = observation.attachments.some(attachment => {
                         return attachment.fieldName === field.name &&
-                            attachment.observationFormId.toString() === observationForm._id.toString();
+                            attachment.observationFormId.toString() === formEntry._id.toString();
                     });
-                }
-                return {
-                    key: field.title,
-                    type: field.type,
-                    value: value
-                };
-            });
+                    break;
+                case 'checkbox':
+                    hasValue = field.value != null;
+                    break;
+                default:
+                    hasValue = !!formEntry[field.name];
+            }
+            return hasValue;
+        })
+            .sort((a, b) => a.id - b.id)
+            .map(field => {
+            let value = formEntry[field.name];
+            if (field.type === 'attachment') {
+                value = observation.attachments.filter(attachment => {
+                    return attachment.fieldName === field.name &&
+                        attachment.observationFormId.toString() === formEntry._id.toString();
+                });
+            }
             return {
-                title: form.name,
-                properties: properties
+                key: field.title,
+                type: field.type,
+                value: value
             };
         });
-    }
+        return [
+            ...sections,
+            {
+                title: form.name,
+                properties: properties
+            }
+        ];
+    }, []);
     const gpsProperties = [];
     const { provider, accuracy } = observation.properties;
     if (provider)
@@ -256,32 +317,35 @@ KmlWriter.prototype.generateObservationPlacemark = function (observation, event)
     if (gpsProperties.length) {
         sections.push({ title: 'GPS', properties: gpsProperties });
     }
-    const styles = [event._id.toString()];
-    if (firstForm) {
-        const form = forms[observation.properties.forms[0].formId];
-        styles.push(form._id.toString());
-        if (firstForm[form.primaryField]) {
-            styles.push(firstForm[form.primaryField]);
-            if (firstForm[form.secondaryField]) {
-                styles.push(firstForm[form.secondaryField]);
+    const styles = [String(event.id)];
+    if (firstFormEntry) {
+        const form = event.formFor(firstFormEntry.formId);
+        if (form) {
+            styles.push(String(form.id));
+            if (form.primaryField && firstFormEntry[form.primaryField]) {
+                styles.push(String(firstFormEntry[form.primaryField]));
+                if (form.variantField && firstFormEntry[form.variantField]) {
+                    styles.push(String(firstFormEntry[form.variantField]));
+                }
             }
         }
     }
-    const coordinates = this.generatePlacemarkCoordinates(observation);
-    const description = this.generateDescription(observation, sections, observation.attachments);
+    const coordinates = generatePlacemarkCoordinates(observation);
+    const description = generateDescription(observation, sections);
     const placemark = {
         name: names.length ? names.join(' - ') : event.name,
         visibility: 0,
         styleUrl: '#' + styles.join('-'),
         TimeStamp: {
-            when: moment(observation.properties.timestamp).utc().format('YYYY-MM-DDTHH:mm:ss') + 'Z'
+            when: (0, moment_1.default)(observation.properties.timestamp).utc().format('YYYY-MM-DDTHH:mm:ss') + 'Z'
         }
     };
-    return fragment({
+    return (0, xmlbuilder2_1.fragment)({
         Placemark: Object.assign(Object.assign(Object.assign({}, placemark), coordinates), description)
     }).end();
-};
-KmlWriter.prototype.generateLocationPlacemark = function (user, location) {
+}
+exports.generateObservationPlacemark = generateObservationPlacemark;
+function generateLocationPlacemark(user, location) {
     const properties = Object.entries(location.properties).map(([key, value]) => {
         return {
             key,
@@ -291,41 +355,50 @@ KmlWriter.prototype.generateLocationPlacemark = function (user, location) {
     const sections = [{
             properties: properties
         }];
-    const coordinates = this.generatePlacemarkCoordinates(location);
-    const description = this.generateDescription(location, sections);
+    const coordinates = generatePlacemarkCoordinates(location);
+    const description = generateDescription(location, sections);
     const placemark = {
-        name: moment(location.properties.timestamp).utc().format('YYYY-MM-DDTHH:mm:ss') + 'Z',
+        name: (0, moment_1.default)(location.properties.timestamp).utc().format('YYYY-MM-DDTHH:mm:ss') + 'Z',
         visibility: 0,
         styleUrl: '#user-' + user._id.toString(),
         TimeStamp: {
-            when: moment(location.properties.timestamp).utc().format('YYYY-MM-DDTHH:mm:ss') + 'Z'
+            when: (0, moment_1.default)(location.properties.timestamp).utc().format('YYYY-MM-DDTHH:mm:ss') + 'Z'
         }
     };
-    return fragment({
+    return (0, xmlbuilder2_1.fragment)({
         Placemark: Object.assign(Object.assign(Object.assign({}, placemark), coordinates), description)
     }).end();
-};
-KmlWriter.prototype.generateKMLDocumentClose = function () {
-    return "</Document>";
-};
-KmlWriter.prototype.generateKMLFolderClose = function () {
-    return "</Folder>";
-};
-KmlWriter.prototype.generateKMLClose = function () {
-    return "</kml>";
-};
-KmlWriter.prototype.generateDescription = function (geojson, sections) {
-    const centroid = turfCentroid(geojson);
+}
+exports.generateLocationPlacemark = generateLocationPlacemark;
+function generateKMLDocumentClose() {
+    return '</Document>';
+}
+exports.generateKMLDocumentClose = generateKMLDocumentClose;
+function generateKMLFolderClose() {
+    return '</Folder>';
+}
+exports.generateKMLFolderClose = generateKMLFolderClose;
+function generateKMLClose() {
+    return '</kml>';
+}
+exports.generateKMLClose = generateKMLClose;
+function generateDescription(feature, sections) {
+    const centroid = (0, centroid_1.default)(feature);
     const header = [{
-            section: [{
-                    span: [{ label: 'Timestamp' }, moment(geojson.properties.timestamp).utc().format('YYYY-MM-DDTHH:mm:ss') + 'Z']
-                }, {
+            section: [
+                {
+                    span: [{ label: 'Timestamp' }, (0, moment_1.default)(feature.properties.timestamp).utc().format('YYYY-MM-DDTHH:mm:ss') + 'Z']
+                },
+                {
                     span: [{ label: 'Latitude' }, centroid.geometry.coordinates[1]]
-                }, {
+                },
+                {
                     span: [{ label: 'Longitude' }, centroid.geometry.coordinates[0]]
-                }, {
+                },
+                {
                     span: [{ label: 'MGRS' }, mgrs.forward(centroid.geometry.coordinates)]
-                }]
+                }
+            ]
         }];
     const properties = [];
     sections.forEach(section => {
@@ -334,12 +407,12 @@ KmlWriter.prototype.generateDescription = function (geojson, sections) {
                 h4: section.title
             });
         }
-        section.properties.forEach(property => {
+        section.properties.forEach((property) => {
             if (property.type === 'attachment') {
                 properties.push({
                     span: { label: property.key }
                 });
-                property.value.forEach(attachment => {
+                property.value.forEach((attachment) => {
                     const group = [];
                     group.push({
                         a: {
@@ -372,7 +445,7 @@ KmlWriter.prototype.generateDescription = function (geojson, sections) {
     };
     return {
         description: {
-            '$': fragment({
+            $: (0, xmlbuilder2_1.fragment)({
                 html: {
                     head: {
                         style: {
@@ -385,18 +458,19 @@ KmlWriter.prototype.generateDescription = function (geojson, sections) {
             }).end()
         }
     };
-};
-KmlWriter.prototype.generatePlacemarkCoordinates = function (geojson) {
-    if (geojson.geometry.type === 'Point') {
+}
+exports.generateDescription = generateDescription;
+function generatePlacemarkCoordinates(feature) {
+    if (feature.geometry.type === 'Point') {
         return {
             Point: {
-                coordinates: geojson.geometry.coordinates.join(',')
+                coordinates: feature.geometry.coordinates.join(',')
             }
         };
     }
-    else if (geojson.geometry.type === 'Polygon') {
+    else if (feature.geometry.type === 'Polygon') {
         // Ignore holes, no holes in MAGE observations
-        const coordinates = geojson.geometry.coordinates[0].reduce((coordinates, points) => {
+        const coordinates = feature.geometry.coordinates[0].reduce((coordinates, points) => {
             return coordinates.concat(points.join(','));
         }, []);
         return {
@@ -410,8 +484,8 @@ KmlWriter.prototype.generatePlacemarkCoordinates = function (geojson) {
             }
         };
     }
-    else if (geojson.geometry.type === 'LineString') {
-        const coordinates = geojson.geometry.coordinates.reduce((coordinates, points) => {
+    else if (feature.geometry.type === 'LineString') {
+        const coordinates = feature.geometry.coordinates.reduce((coordinates, points) => {
             return coordinates.concat(points.join(','));
         }, []);
         return {
@@ -423,9 +497,12 @@ KmlWriter.prototype.generatePlacemarkCoordinates = function (geojson) {
             }
         };
     }
-    return coordinates;
-};
-KmlWriter.prototype.getFieldByName = function (form, name) {
+    // TODO: not sure if this ever happens or what will happen if it does ¯\_(ツ)_/¯
+    return {};
+}
+exports.generatePlacemarkCoordinates = generatePlacemarkCoordinates;
+function getFieldByName(form, name) {
     return form.fields.find(field => field.name === name);
-};
+}
+exports.getFieldByName = getFieldByName;
 //# sourceMappingURL=kmlWriter.js.map