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

package/lib/export/geopackage.js

@@ -1,4 +1,27 @@
 'use strict';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,528 +31,699 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const { RelationType } = require('@ngageoint/geopackage/dist/lib/extension/relatedTables/relationType');
-const { EnvelopeBuilder } = require('@ngageoint/geopackage/dist/lib/geom/envelopeBuilder');
-const util = require('util'), fs = require('fs'), api = require('../api'), archiver = require('archiver'), moment = require('moment'), log = require('winston'), path = require('path'), Exporter = require('./exporter'), GeoPackageAPI = require('@ngageoint/geopackage'), environment = require('../environment/env'), os = require('os'), wkx = require('wkx'), User = require('../models/user');
-const attachmentBase = environment.attachmentBaseDirectory;
-const pathToGeoPackageModule = path.resolve(path.dirname(require.resolve('@ngageoint/geopackage/package.json')));
-GeoPackageAPI.setCanvasKitWasmLocateFile(file => `${pathToGeoPackageModule}/dist/canvaskit/${file}`);
-function GeoPackage(options) {
-    GeoPackage.super_.call(this, options);
-    this.iconMap = {};
-}
-util.inherits(GeoPackage, Exporter);
-module.exports = GeoPackage;
-GeoPackage.prototype.export = function (streamable) {
-    return __awaiter(this, void 0, void 0, function* () {
-        log.info('Export the GeoPackage');
-        const downloadedFileName = 'mage-' + this._event.name;
-        const archive = archiver('zip');
-        archive.pipe(streamable);
-        try {
-            const filePath = yield this.createGeoPackageFile();
-            const gp = yield GeoPackageAPI.GeoPackageAPI.create(filePath);
-            yield this.createUserTable(gp);
-            yield this.createUserFeatureTableStyles(gp);
-            if (this._filter.exportObservations) {
-                yield this.addFormDataToGeoPackage(gp);
-                yield this.createFormAttributeTables(gp);
-                yield this.createObservationTable(gp);
-                yield this.createObservationFeatureTableStyles(gp);
-                yield this.addObservationsToGeoPackage(gp);
-            }
-            if (this._filter.exportLocations) {
-                yield this.addLocationsToGeoPackage(gp);
-            }
-            log.info(`export geopackage created: ${filePath}`);
-            archive.append(fs.createReadStream(filePath), { name: downloadedFileName + '.gpkg' });
-            archive.on('end', function () {
-                log.info(`removing temporary export geopackage file ${filePath}`);
-                fs.unlink(filePath, function () {
-                    gp.close();
-                });
-            });
-            archive.finalize();
-        }
-        catch (err) {
-            log.error(`error exporting geopackage`, err);
-            throw err;
-        }
-    });
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-GeoPackage.prototype.createGeoPackageFile = function () {
-    log.info('Create GeoPackage File');
-    const filename = moment().format('YYYMMDD_hhmmssSSS') + '.gpkg';
-    const filePath = path.join(os.tmpdir(), filename);
-    return new Promise(function (resolve, reject) {
-        fs.unlink(filePath, function () {
-            fs.mkdir(path.dirname(filePath), function () {
-                fs.open(filePath, 'w', function (err) {
-                    if (err)
-                        return reject(err);
-                    resolve(filePath);
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeoPackage = void 0;
+const relationType_1 = require("@ngageoint/geopackage/dist/lib/extension/relatedTables/relationType");
+const envelopeBuilder_1 = require("@ngageoint/geopackage/dist/lib/geom/envelopeBuilder");
+const GPKG = __importStar(require("@ngageoint/geopackage"));
+const geopackage_1 = require("@ngageoint/geopackage");
+const util_1 = __importDefault(require("util"));
+const fs_1 = __importDefault(require("fs"));
+const promises_1 = __importDefault(require("fs/promises"));
+const archiver_1 = __importDefault(require("archiver"));
+const moment_1 = __importDefault(require("moment"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const wkx_1 = __importDefault(require("wkx"));
+const exporter_1 = require("./exporter");
+const api_1 = __importDefault(require("../api"));
+const env_1 = __importDefault(require("../environment/env"));
+const user_1 = __importDefault(require("../models/user"));
+// TODO: we really need to revamp our logging
+const logger = require('../logger');
+const log = ['debug', 'info', 'warn', 'error', 'log'].reduce((log, methodName) => {
+    const logMethod = logger[methodName];
+    return Object.assign(Object.assign({}, log), { [methodName]: (...args) => logMethod('[export:geopackage]', ...args) });
+}, {});
+const attachmentBase = env_1.default.attachmentBaseDirectory;
+class GeoPackage extends exporter_1.Exporter {
+    constructor() {
+        super(...arguments);
+        this.iconCache = new IconTreeCache();
+        this.observationStyles = null;
+    }
+    export(streamable) {
+        return __awaiter(this, void 0, void 0, function* () {
+            log.info(`export geopackage for event ${this._event.id} - ${this._event.name}:\n`, this._filter);
+            const downloadedFileName = 'mage-' + this._event.name;
+            const archive = (0, archiver_1.default)('zip');
+            archive.pipe(streamable);
+            try {
+                const filePath = yield createGeoPackageFile();
+                const gp = yield geopackage_1.GeoPackageAPI.create(filePath);
+                yield this.createUserTable(gp);
+                yield createUserFeatureTableStyles(gp);
+                if (this._filter.exportObservations) {
+                    yield this.addFormDataToGeoPackage(gp);
+                    yield this.createFormAttributeTables(gp);
+                    yield this.createObservationTable(gp);
+                    this.observationStyles = yield this.createObservationFeatureTableStyles(gp);
+                    yield this.addObservationsToGeoPackage(gp);
+                }
+                if (this._filter.exportLocations) {
+                    yield this.addLocationsToGeoPackage(gp);
+                }
+                log.info(`export geopackage created: ${filePath}`);
+                archive.append(fs_1.default.createReadStream(filePath), { name: downloadedFileName + '.gpkg' });
+                archive.on('end', () => {
+                    log.info(`removing temporary export geopackage file ${filePath}`);
+                    fs_1.default.unlink(filePath, (err) => {
+                        if (err) {
+                            console.warn('error removing temporary geopackage', filePath);
+                        }
+                        gp.close();
+                    });
                 });
-            });
-        });
-    });
-};
-GeoPackage.prototype.createObservationTable = function (geopackage) {
-    return __awaiter(this, void 0, void 0, function* () {
-        log.info('Create Observation Table');
-        const columns = [];
-        // TODO columns should be the same as KML file
-        columns.push({
-            name: 'lastModified',
-            dataType: 'DATETIME'
-        });
-        columns.push({
-            name: 'timestamp',
-            dataType: 'DATETIME'
-        });
-        columns.push({
-            name: 'mageId',
-            dataType: 'TEXT'
-        });
-        columns.push({
-            name: 'userId',
-            dataType: 'TEXT'
-        });
-        columns.push({
-            name: 'deviceId',
-            dataType: 'TEXT'
-        });
-        columns.push({
-            name: 'createdAt',
-            dataType: 'DATETIME'
-        });
-        columns.push({
-            name: 'primaryField',
-            dataType: 'TEXT'
-        });
-        columns.push({
-            name: 'variantField',
-            dataType: 'TEXT'
-        });
-        yield geopackage.createFeatureTableFromProperties('Observations', columns);
-        return geopackage;
-    });
-};
-GeoPackage.prototype.createAttachmentTable = function (geopackage) {
-    log.info('Create Attachment Table');
-    const columns = [{
-            name: "name",
-            dataType: "TEXT"
-        }, {
-            name: "size",
-            dataType: "REAL"
-        }];
-    return geopackage.createMediaTable('Attachments', columns);
-};
-GeoPackage.prototype.addUserToUsersTable = function (geopackage, user, usersLastLocation, zoomToEnvelope) {
-    return __awaiter(this, void 0, void 0, function* () {
-        log.info(`add user ${user.username} to users table`);
-        const geoJson = {
-            type: 'Feature',
-            geometry: usersLastLocation.geometry,
-            properties: {
-                timestamp: usersLastLocation.properties.timestamp,
-                username: user.username,
-                displayName: user.displayName,
-                email: user.email,
-                phones: user.phones.join(', '),
-                userId: user._id.toString()
+                archive.finalize();
+            }
+            catch (err) {
+                log.error(`error exporting geopackage`, err);
+                throw err;
             }
-        };
-        const userRowId = geopackage.addGeoJSONFeatureToGeoPackage(geoJson, 'Users');
-        const iconPath = path.join(environment.userBaseDirectory, user._id.toString(), 'icon');
-        let iconBuffer = null;
-        try {
-            iconBuffer = yield util.promisify(fs.readFile)(iconPath);
-        }
-        catch (err) {
-            log.error(`error reading reading user icon for geopackage export: ${iconPath}`, err);
-            return void (0);
-        }
-        const featureTableStyles = new GeoPackageAPI.FeatureTableStyles(geopackage, 'Users');
-        const iconRow = featureTableStyles.getIconDao().newRow();
-        iconRow.data = iconBuffer;
-        iconRow.contentType = 'image/png';
-        iconRow.name = user.username;
-        iconRow.description = `Icon for user ${user.username}`;
-        iconRow.width = 20;
-        iconRow.anchorU = 0.5;
-        iconRow.anchorV = 1.0;
-        featureTableStyles.setIconDefault(userRowId, iconRow);
-        const featureDao = geopackage.getFeatureDao('Users');
-        const rtreeIndex = new GeoPackageAPI.RTreeIndex(geopackage, featureDao);
-        rtreeIndex.create();
-        if (zoomToEnvelope) {
-            this.setContentBounds(geopackage, featureDao, zoomToEnvelope);
-        }
-    });
-};
-GeoPackage.prototype.createLocationTableForUser = function (geopackage, userId) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const columns = [];
-        columns.push({
-            name: 'mageId',
-            dataType: 'TEXT'
-        });
-        columns.push({
-            name: 'userId',
-            dataType: 'TEXT'
-        });
-        columns.push({
-            name: 'timestamp',
-            dataType: 'DATETIME'
-        });
-        columns.push({
-            name: 'deviceId',
-            dataType: 'TEXT'
         });
-        columns.push({
-            name: 'accuracy',
-            dataType: 'REAL'
+    }
+    createObservationTable(geopackage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            log.info('create observation table');
+            const columns = [];
+            // TODO columns should be the same as KML file
+            columns.push({
+                name: 'lastModified',
+                dataType: 'DATETIME'
+            });
+            columns.push({
+                name: 'timestamp',
+                dataType: 'DATETIME'
+            });
+            columns.push({
+                name: 'mageId',
+                dataType: 'TEXT'
+            });
+            columns.push({
+                name: 'userId',
+                dataType: 'TEXT'
+            });
+            columns.push({
+                name: 'deviceId',
+                dataType: 'TEXT'
+            });
+            columns.push({
+                name: 'createdAt',
+                dataType: 'DATETIME'
+            });
+            columns.push({
+                name: 'primaryField',
+                dataType: 'TEXT'
+            });
+            columns.push({
+                name: 'variantField',
+                dataType: 'TEXT'
+            });
+            yield geopackage.createFeatureTableFromProperties('Observations', columns);
         });
-        yield geopackage.createFeatureTableFromProperties('Locations_' + userId, columns);
-        return geopackage;
-    });
-};
-GeoPackage.prototype.addLocationsToGeoPackage = function (geopackage) {
-    return __awaiter(this, void 0, void 0, function* () {
-        log.info('Requesting locations from DB');
-        const startDate = this._filter.startDate ? moment(this._filter.startDate) : null;
-        const endDate = this._filter.endDate ? moment(this._filter.endDate) : null;
-        const cursor = this.requestLocations({ startDate: startDate, endDate: endDate, stream: true });
-        let numLocations = 0;
-        let user = null;
-        let userLastLocation = null;
-        let zoomToEnvelope;
-        return cursor.eachAsync((location) => __awaiter(this, void 0, void 0, function* () {
-            if (!user || user._id.toString() !== location.userId.toString()) {
-                if (zoomToEnvelope) {
-                    //Switching user, so update location
-                    const featureDao = geopackage.getFeatureDao('Locations_' + user._id.toString());
-                    this.setContentBounds(geopackage, featureDao, zoomToEnvelope);
-                    yield this.addUserToUsersTable(geopackage, user, userLastLocation, zoomToEnvelope);
-                }
-                zoomToEnvelope = null;
-                user = yield User.getUserById(location.userId);
-                yield this.createLocationTableForUser(geopackage, location.userId.toString());
-            }
-            zoomToEnvelope = this.calculateBounds(location.geometry, zoomToEnvelope);
-            userLastLocation = location;
-            const geojson = {
+    }
+    createAttachmentTable(geopackage) {
+        log.info('create attachment table');
+        const columns = [{
+                name: "name",
+                dataType: "TEXT"
+            }, {
+                name: "size",
+                dataType: "REAL"
+            }];
+        geopackage.createMediaTable('Attachments', columns);
+    }
+    addUserToUsersTable(geopackage, user, usersLastLocation, zoomToEnvelope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            log.info(`add user ${user.username} to users table`);
+            const feature = {
                 type: 'Feature',
-                geometry: location.geometry,
-                properties: location.properties
+                geometry: usersLastLocation.geometry,
+                properties: {
+                    timestamp: usersLastLocation.properties.timestamp,
+                    username: user.username,
+                    displayName: user.displayName,
+                    email: user.email,
+                    phones: user.phones.join(', '),
+                    userId: user._id.toString()
+                }
             };
-            geojson.properties.mageId = location._id.toString();
-            geojson.properties.userId = location.userId.toString();
-            geojson.properties.deviceId = location.properties.deviceId.toString();
-            if (geojson.properties.id) {
-                delete geojson.properties.id;
+            const userRowId = geopackage.addGeoJSONFeatureToGeoPackage(feature, 'Users');
+            const iconPath = user.icon.relativePath ? path_1.default.join(env_1.default.userBaseDirectory, user.icon.relativePath) : null;
+            if (iconPath) {
+                const featureTableStyles = new GPKG.FeatureTableStyles(geopackage, 'Users');
+                const iconRow = featureTableStyles.getIconDao().newRow();
+                try {
+                    const iconBuffer = yield promises_1.default.readFile(iconPath);
+                    iconRow.data = iconBuffer;
+                    iconRow.contentType = 'image/png';
+                    iconRow.name = user.username;
+                    iconRow.description = `Icon for user ${user.username}`;
+                    iconRow.width = 20;
+                    iconRow.anchorU = 0.5;
+                    iconRow.anchorV = 1.0;
+                    featureTableStyles.setIconDefault(userRowId, iconRow);
+                }
+                catch (err) {
+                    log.error(`error reading user icon for geopackage export: ${iconPath}`, err);
+                    return void (0);
+                }
             }
-            yield geopackage.addGeoJSONFeatureToGeoPackage(geojson, 'Locations_' + location.userId.toString());
-            numLocations++;
-        })).then(() => __awaiter(this, void 0, void 0, function* () {
-            if (cursor)
-                cursor.close;
-            if (zoomToEnvelope && user) {
-                //Process the last user, since it was missed in the loop above
-                const featureDao = geopackage.getFeatureDao('Locations_' + user._id.toString());
-                this.setContentBounds(geopackage, featureDao, zoomToEnvelope);
-                yield this.addUserToUsersTable(geopackage, user, userLastLocation, zoomToEnvelope);
+            const featureDao = geopackage.getFeatureDao('Users');
+            const rtreeIndex = new GPKG.RTreeIndex(geopackage, featureDao);
+            rtreeIndex.create();
+            if (zoomToEnvelope) {
+                setContentBounds(geopackage, featureDao, zoomToEnvelope);
             }
-            log.info('Successfully wrote ' + numLocations + ' locations to Geopackage');
-            return geopackage;
-            ;
-        })).catch(err => { log.warn(err); });
-    });
-};
-GeoPackage.prototype.createFormAttributeTables = function (geopackage) {
-    return __awaiter(this, void 0, void 0, function* () {
-        log.info('Create Form Attribute Tables');
-        const formIds = Object.keys(this._event.formMap);
-        for (let i = 0; i < formIds.length; i++) {
-            const formId = formIds[i];
+        });
+    }
+    createLocationTableForUser(geopackage, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
             const columns = [];
-            const form = this._event.formMap[formId];
-            if (form.primaryField) {
-                columns.push({
-                    name: 'primaryField',
-                    dataType: 'TEXT'
-                });
-            }
-            if (form.variantField) {
-                columns.push({
-                    name: 'variantField',
-                    dataType: 'TEXT'
-                });
-            }
             columns.push({
-                name: 'formId',
-                dataType: 'INTEGER',
-                default: formId
+                name: 'mageId',
+                dataType: 'TEXT'
+            });
+            columns.push({
+                name: 'userId',
+                dataType: 'TEXT'
             });
-            for (let i = 0; i < form.fields.length; i++) {
-                const field = form.fields[i];
+            columns.push({
+                name: 'timestamp',
+                dataType: 'DATETIME'
+            });
+            columns.push({
+                name: 'deviceId',
+                dataType: 'TEXT'
+            });
+            columns.push({
+                name: 'accuracy',
+                dataType: 'REAL'
+            });
+            yield geopackage.createFeatureTableFromProperties('Locations_' + userId, columns);
+        });
+    }
+    addLocationsToGeoPackage(geopackage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            log.info('fetching locations');
+            const { startDate, endDate } = this._filter;
+            const cursor = this.requestLocations({ startDate, endDate });
+            let numLocations = 0;
+            let user = null;
+            let userLastLocation = null;
+            let zoomToEnvelope = null;
+            return cursor.eachAsync((location) => __awaiter(this, void 0, void 0, function* () {
+                if (!user || user._id.toString() !== location.userId.toString()) {
+                    if (zoomToEnvelope) {
+                        // Switching user, so update location
+                        const featureDao = geopackage.getFeatureDao('Locations_' + user._id.toString());
+                        setContentBounds(geopackage, featureDao, zoomToEnvelope);
+                        yield this.addUserToUsersTable(geopackage, user, userLastLocation, zoomToEnvelope);
+                    }
+                    zoomToEnvelope = null;
+                    user = yield user_1.default.getUserById(location.userId);
+                    yield this.createLocationTableForUser(geopackage, location.userId.toString());
+                }
+                zoomToEnvelope = calculateBounds(location.geometry, zoomToEnvelope);
+                userLastLocation = location;
+                const feature = {
+                    type: 'Feature',
+                    geometry: location.geometry,
+                    properties: location.properties
+                };
+                feature.properties.mageId = location._id.toString();
+                feature.properties.userId = location.userId.toString();
+                feature.properties.deviceId = location.properties.deviceId.toString();
+                if (feature.properties.id) {
+                    delete feature.properties.id;
+                }
+                yield geopackage.addGeoJSONFeatureToGeoPackage(feature, 'Locations_' + location.userId.toString());
+                numLocations++;
+            })).then(() => __awaiter(this, void 0, void 0, function* () {
+                if (cursor) {
+                    cursor.close();
+                }
+                if (zoomToEnvelope && user) {
+                    //Process the last user, since it was missed in the loop above
+                    const featureDao = geopackage.getFeatureDao('Locations_' + user._id.toString());
+                    setContentBounds(geopackage, featureDao, zoomToEnvelope);
+                    yield this.addUserToUsersTable(geopackage, user, userLastLocation, zoomToEnvelope);
+                }
+                log.info(`wrote ${numLocations} locations to geopackage`);
+            }))
+                .catch(err => { log.warn(err); });
+        });
+    }
+    createFormAttributeTables(geopackage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            log.info('create form attribute tables');
+            for (const form of this._event.forms) {
+                const columns = [];
+                if (form.primaryField) {
+                    columns.push({
+                        name: 'primaryField',
+                        dataType: 'TEXT'
+                    });
+                }
+                if (form.variantField) {
+                    columns.push({
+                        name: 'variantField',
+                        dataType: 'TEXT'
+                    });
+                }
                 columns.push({
-                    dataColumn: {
-                        column_name: field.name,
-                        table_name: 'Form_' + formId,
-                        name: field.title,
-                        title: field.title
-                    },
-                    name: field.name,
-                    dataType: this.fieldTypeToGeoPackageType(field.type)
+                    name: 'formId',
+                    dataType: 'INTEGER',
+                    default: form.id
                 });
+                for (let i = 0; i < form.fields.length; i++) {
+                    const field = form.fields[i];
+                    columns.push({
+                        dataColumn: {
+                            column_name: field.name,
+                            table_name: 'Form_' + form.id,
+                            name: field.title,
+                            title: field.title
+                        },
+                        name: field.name,
+                        dataType: this.fieldTypeToGeoPackageType(field.type)
+                    });
+                }
+                yield geopackage.createAttributesTableFromProperties('Form_' + form.id, columns);
             }
-            yield geopackage.createAttributesTableFromProperties('Form_' + formId, columns);
+        });
+    }
+    fieldTypeToGeoPackageType(fieldType) {
+        switch (fieldType) {
+            case 'numberfield':
+                return 'INTEGER';
+            case 'attachment':
+            case 'textarea':
+            case 'textfield':
+                return 'TEXT';
+            default:
+                return 'TEXT';
         }
-        return geopackage;
-    });
-};
-GeoPackage.prototype.fieldTypeToGeoPackageType = function (fieldType) {
-    switch (fieldType) {
-        case 'numberfield':
-            return 'INTEGER';
-        case 'attachment':
-        case 'textarea':
-        case 'textfield':
-            return 'TEXT';
-        default:
-            return 'TEXT';
     }
-};
-GeoPackage.prototype.createUserTable = function (geopackage) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const columns = [];
-        columns.push({
-            name: 'username',
-            dataType: 'TEXT'
-        });
-        columns.push({
-            name: 'displayName',
-            dataType: 'TEXT'
-        });
-        columns.push({
-            name: 'email',
-            dataType: 'TEXT'
-        });
-        columns.push({
-            name: 'phones',
-            dataType: 'TEXT'
-        });
-        columns.push({
-            name: 'userId',
-            dataType: 'TEXT'
-        });
-        columns.push({
-            name: 'timestamp',
-            dataType: 'DATETIME'
-        });
-        yield geopackage.createFeatureTableFromProperties('Users', columns);
-        log.info('Create User Avatar Table');
-        yield geopackage.createMediaTable('UserAvatars');
-        return geopackage;
-    });
-};
-GeoPackage.prototype.addFormDataToGeoPackage = function (geopackage) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const columns = [];
-        columns.push({
-            name: 'formName',
-            dataType: 'TEXT'
-        });
-        columns.push({
-            name: 'primaryField',
-            dataType: 'TEXT'
-        });
-        columns.push({
-            name: 'variantField',
-            dataType: 'TEXT'
-        });
-        columns.push({
-            name: 'color',
-            dataType: 'TEXT'
-        });
-        columns.push({
-            name: 'formId',
-            dataType: 'TEXT'
+    createUserTable(geopackage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const columns = [];
+            columns.push({
+                name: 'username',
+                dataType: 'TEXT'
+            });
+            columns.push({
+                name: 'displayName',
+                dataType: 'TEXT'
+            });
+            columns.push({
+                name: 'email',
+                dataType: 'TEXT'
+            });
+            columns.push({
+                name: 'phones',
+                dataType: 'TEXT'
+            });
+            columns.push({
+                name: 'userId',
+                dataType: 'TEXT'
+            });
+            columns.push({
+                name: 'timestamp',
+                dataType: 'DATETIME'
+            });
+            yield geopackage.createFeatureTableFromProperties('Users', columns);
+            log.info('create user avatar table');
+            yield geopackage.createMediaTable('UserAvatars', void (0) /* really is optional */);
         });
-        yield geopackage.createAttributesTableFromProperties('Forms', columns);
-        for (const formId in this._event.formMap) {
-            const form = this._event.formMap[formId];
-            const row = {
-                formName: form.name,
-                primaryField: form.primaryField,
-                variantField: form.variantField,
-                color: form.color,
-                formId: formId
-            };
-            geopackage.addAttributeRow('Forms', row);
-        }
-        return geopackage;
-    });
-};
-GeoPackage.prototype.addObservationsToGeoPackage = function (geopackage) {
-    return __awaiter(this, void 0, void 0, function* () {
-        log.info('Requesting locations from DB');
-        this.createAttachmentTable(geopackage);
-        const cursor = this.requestObservations(this._filter);
-        let numObservations = 0;
-        let zoomToEnvelope;
-        return cursor.eachAsync((observation) => __awaiter(this, void 0, void 0, function* () {
-            numObservations++;
-            let primary;
-            let variant;
-            if (observation.properties.forms && observation.properties.forms.length > 0) {
-                const observationFirstForm = observation.properties.forms[0];
-                const form = this._event.formMap[observationFirstForm.formId];
-                primary = observationFirstForm[form.primaryField];
-                variant = observationFirstForm[form.variantField];
-            }
-            const properties = {
-                lastModified: observation.lastModified,
-                timestamp: observation.properties.timestamp,
-                mageId: observation._id.toString(),
-                createdAt: observation.createdAt,
-                primaryField: primary,
-                variantField: variant
-            };
-            if (observation.userId) {
-                properties.userId = observation.userId.toString();
-            }
-            if (observation.deviceId) {
-                properties.deviceId = observation.deviceId.toString();
+    }
+    addFormDataToGeoPackage(geopackage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const columns = [];
+            columns.push({
+                name: 'formName',
+                dataType: 'TEXT'
+            });
+            columns.push({
+                name: 'primaryField',
+                dataType: 'TEXT'
+            });
+            columns.push({
+                name: 'variantField',
+                dataType: 'TEXT'
+            });
+            columns.push({
+                name: 'color',
+                dataType: 'TEXT'
+            });
+            columns.push({
+                name: 'formId',
+                dataType: 'TEXT'
+            });
+            yield geopackage.createAttributesTableFromProperties('Forms', columns);
+            for (const form of this._event.forms) {
+                const row = {
+                    formName: form.name,
+                    primaryField: form.primaryField || null,
+                    variantField: form.variantField || null,
+                    color: form.color,
+                    formId: form.id
+                };
+                geopackage.addAttributeRow('Forms', row);
             }
-            const geojson = {
-                type: 'Feature',
-                geometry: observation.geometry,
-                properties: properties
-            };
-            zoomToEnvelope = this.calculateBounds(geojson.geometry, zoomToEnvelope);
-            const featureId = geopackage.addGeoJSONFeatureToGeoPackage(geojson, 'Observations');
-            if (observation.properties.forms && observation.properties.forms[0]) {
-                // insert the icon link
-                let iconId = this.iconMap[observation.properties.forms[0].formId]['icon.png'];
-                if (primary && this.iconMap[observation.properties.forms[0].formId][primary]) {
-                    iconId = this.iconMap[observation.properties.forms[0].formId][primary]['icon.png'];
+        });
+    }
+    addObservationsToGeoPackage(geopackage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            log.info('requesting locations from db');
+            this.createAttachmentTable(geopackage);
+            const cursor = this.requestObservations(this._filter);
+            let numObservations = 0;
+            let zoomToEnvelope;
+            return cursor.eachAsync((observation) => __awaiter(this, void 0, void 0, function* () {
+                console.debug('exporting observation', observation.id, '...');
+                numObservations++;
+                if (!Array.isArray(observation.properties.forms)) {
+                    return;
                 }
-                if (variant && this.iconMap[observation.properties.forms[0].formId][primary] && this.iconMap[observation.properties.forms[0].formId][primary][variant]) {
-                    iconId = this.iconMap[observation.properties.forms[0].formId][primary][variant];
+                const primaryEntry = observation.properties.forms[0];
+                if (!primaryEntry) {
+                    return;
                 }
-                const featureTableStyles = new GeoPackageAPI.FeatureTableStyles(geopackage, 'Observations');
-                featureTableStyles.setIconDefault(featureId, iconId);
-            }
-            if (observation.properties.forms) {
-                for (let f = 0; f < observation.properties.forms.length; f++) {
-                    const observationForm = observation.properties.forms[f];
-                    const formDefinition = this._event.formMap[observationForm.formId];
-                    primary = observationForm[formDefinition.primaryField];
-                    variant = observationForm[formDefinition.variantField];
+                const form = this._event.formFor(primaryEntry.formId);
+                const primary = (form === null || form === void 0 ? void 0 : form.primaryField) ? String(primaryEntry[form.primaryField]) : null;
+                const variant = (form === null || form === void 0 ? void 0 : form.primaryField) && (form === null || form === void 0 ? void 0 : form.variantField) ? String(primaryEntry[form.variantField]) : null;
+                const properties = {
+                    lastModified: observation.lastModified,
+                    timestamp: observation.properties.timestamp,
+                    mageId: observation._id.toString(),
+                    createdAt: observation.createdAt,
+                    primaryField: primary,
+                    variantField: variant
+                };
+                if (observation.userId) {
+                    properties.userId = observation.userId.toString();
+                }
+                if (observation.deviceId) {
+                    properties.deviceId = observation.deviceId.toString();
+                }
+                const feature = {
+                    type: 'Feature',
+                    geometry: observation.geometry,
+                    properties
+                };
+                zoomToEnvelope = calculateBounds(feature.geometry, zoomToEnvelope);
+                const featureId = geopackage.addGeoJSONFeatureToGeoPackage(feature, 'Observations');
+                const iconSpec = {
+                    eventId: this._event.id,
+                    formId: primaryEntry.formId,
+                    primary,
+                    variant,
+                };
+                yield this.linkObservationFeatureIcon(iconSpec, featureId);
+                const formEntries = observation.properties.forms || [];
+                for (const formEntry of formEntries) {
+                    const form = this._event.formFor(formEntry.formId);
+                    const primary = form.primaryField ? String(formEntry[form.primaryField]) : null;
+                    const variant = form.primaryField && form.variantField ? String(formEntry[form.variantField]) : null;
                     const formToSave = {
                         primaryField: primary,
                         variantField: variant,
-                        formId: observationForm.formId
+                        formId: formEntry.formId
                     };
                     const attachments = [];
                     if (observation.attachments) {
                         observation.attachments.forEach((attachment) => {
-                            if (attachment.observationFormId.toString() == observationForm._id) {
+                            if (String(attachment.observationFormId) === String(formEntry._id)) {
                                 attachments.push(attachment);
-                                observationForm[attachment.fieldName] = observationForm[attachment.fieldName] || [];
-                                observationForm[attachment.fieldName].push(attachment._id.toString());
+                                const attachmentFieldEntries = (formEntry[attachment.fieldName] || []);
+                                attachmentFieldEntries.push(String(attachment._id));
+                                formEntry[attachment.fieldName] = attachmentFieldEntries;
                             }
                         });
                     }
-                    Object.keys(observationForm).forEach(key => {
-                        if (observationForm[key] == null)
+                    Object.keys(formEntry).forEach(key => {
+                        const fieldEntry = formEntry[key];
+                        if (fieldEntry === null || fieldEntry === undefined) {
                             return;
-                        const fieldDefinition = formDefinition.fields.find(field => field.name === key);
-                        if (!fieldDefinition)
+                        }
+                        const field = this._event.formFieldFor(key, form.id);
+                        if (!field) {
                             return;
-                        if (fieldDefinition.type === 'multiselectdropdown') {
-                            formToSave[key] = observationForm[key].join(', ');
                         }
-                        else if (fieldDefinition.type === 'date') {
-                            formToSave[key] = moment(observationForm[key]).toISOString();
+                        if (field.type === 'multiselectdropdown') {
+                            formToSave[key] = fieldEntry.join(', ');
                         }
-                        else if (fieldDefinition.type === 'checkbox') {
-                            formToSave[key] = observationForm[key].toString();
+                        else if (field.type === 'date') {
+                            formToSave[key] = (0, moment_1.default)(fieldEntry).toISOString();
                         }
-                        else if (fieldDefinition.type === 'geometry') {
-                            formToSave[key] = wkx.Geometry.parseGeoJSON(observationForm[key]).toWkt();
+                        else if (field.type === 'checkbox') {
+                            formToSave[key] = String(fieldEntry);
                         }
-                        else if (fieldDefinition.type === 'attachment') {
-                            formToSave[key] = observationForm[key].join(', ');
+                        else if (field.type === 'geometry') {
+                            formToSave[key] = wkx_1.default.Geometry.parseGeoJSON(fieldEntry).toWkt();
+                        }
+                        else if (field.type === 'attachment') {
+                            formToSave[key] = fieldEntry.join(', ');
                         }
                         else {
-                            formToSave[key] = observationForm[key];
+                            formToSave[key] = fieldEntry;
                         }
                     });
                     try {
                         const rowId = geopackage.addAttributeRow('Form_' + formToSave.formId, formToSave);
                         if (attachments.length) {
-                            yield this.addAttachments(geopackage, attachments, featureId, 'Form_' + formToSave.formId, rowId);
+                            yield addAttachments(geopackage, attachments, featureId, 'Form_' + formToSave.formId, rowId);
                         }
-                        yield geopackage.linkRelatedRows('Observations', featureId, 'Form_' + formToSave.formId, rowId, RelationType.ATTRIBUTES);
+                        yield geopackage.linkRelatedRows('Observations', featureId, 'Form_' + formToSave.formId, rowId, relationType_1.RelationType.ATTRIBUTES);
                     }
                     catch (e) {
-                        console.error('error is ', e);
+                        log.error(`error writing rows for form entry ${formEntry.id} of observation ${observation.id} to geopackage`, e);
                     }
                 }
+            }))
+                .then(() => __awaiter(this, void 0, void 0, function* () {
+                if (cursor) {
+                    yield cursor.close();
+                }
+                const featureDao = geopackage.getFeatureDao('Observations');
+                const rtreeIndex = new GPKG.RTreeIndex(geopackage, featureDao);
+                rtreeIndex.create();
+                if (zoomToEnvelope) {
+                    setContentBounds(geopackage, featureDao, zoomToEnvelope);
+                }
+                log.info(`'wrote ${numObservations} observations to geopackage`);
+            }))
+                .catch(err => {
+                log.warn(err);
+            });
+        });
+    }
+    createObservationFeatureTableStyles(geopackage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const featureTableName = 'Observations';
+            const featureTableStyles = new GPKG.FeatureTableStyles(geopackage, featureTableName);
+            yield geopackage.featureStyleExtension.getOrCreateExtension(featureTableName);
+            yield geopackage.featureStyleExtension.getRelatedTables().getOrCreateExtension();
+            yield geopackage.featureStyleExtension.getContentsId().getOrCreateExtension();
+            featureTableStyles.createRelationships();
+            const defaultIconAccess = new api_1.default.Icon(this._event.id);
+            const defaultIconDoc = yield util_1.default.promisify(defaultIconAccess.getIcon.bind(defaultIconAccess))();
+            if (!defaultIconDoc || isNothing(defaultIconDoc.path)) {
+                return featureTableStyles;
             }
-        })).then(() => __awaiter(this, void 0, void 0, function* () {
-            if (cursor)
-                cursor.close;
-            const featureDao = geopackage.getFeatureDao('Observations');
-            const rtreeIndex = new GeoPackageAPI.RTreeIndex(geopackage, featureDao);
-            rtreeIndex.create();
-            if (zoomToEnvelope) {
-                this.setContentBounds(geopackage, featureDao, zoomToEnvelope);
+            try {
+                const iconBytes = yield promises_1.default.readFile(defaultIconDoc.path);
+                const gpkgIconRow = featureTableStyles.getIconDao().newRow();
+                gpkgIconRow.data = iconBytes;
+                populateGpkgIconRow(gpkgIconRow, defaultIconDoc, this._event);
+                featureTableStyles.setTableIconDefault(gpkgIconRow);
+                this.iconCache.put(defaultIconDoc, gpkgIconRow.id);
             }
-            log.info('Successfully wrote ' + numObservations + ' observations to Geopackage');
-            return geopackage;
-        })).catch(err => { log.warn(err); });
-    });
-};
-GeoPackage.prototype.calculateBounds = function (geometry, zoomToEnvelope) {
-    const wkxGeometry = wkx.Geometry.parseGeoJSON(geometry);
-    const envelope = EnvelopeBuilder.buildEnvelopeWithGeometry(wkxGeometry);
-    if (!zoomToEnvelope) {
-        zoomToEnvelope = envelope;
+            catch (err) {
+                console.warn('error setting default icon', defaultIconDoc.path);
+            }
+            return featureTableStyles;
+        });
+    }
+    linkObservationFeatureIcon(iconSpec, featureId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const iconId = yield this.ensureIconInGeopackage(iconSpec);
+            if (iconId === null) {
+                return;
+            }
+            const styleExt = this.observationStyles.getFeatureStyleExtension();
+            const iconMappingDao = this.observationStyles.getIconMappingDao();
+            styleExt.insertStyleMapping(iconMappingDao, featureId, iconId);
+        });
     }
-    else {
-        if (zoomToEnvelope.maxX < envelope.maxX) {
-            zoomToEnvelope.maxX = envelope.maxX;
+    ensureIconInGeopackage(iconSpec) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cachedIconId = this.iconCache.get(iconSpec);
+            if (cachedIconId === IconTreeCache.ICON_LOAD_ERROR) {
+                return null;
+            }
+            if (cachedIconId !== null) {
+                return cachedIconId;
+            }
+            const iconAccess = new api_1.default.Icon(this._event.id, iconSpec.formId, iconSpec.primary, iconSpec.variant);
+            const iconDoc = yield util_1.default.promisify(iconAccess.getIcon.bind(iconAccess))();
+            if (!iconDoc || isNothing(iconDoc.path)) {
+                return null;
+            }
+            try {
+                const iconBytes = yield promises_1.default.readFile(iconDoc.path);
+                const gpkgIconRow = this.observationStyles.getIconDao().newRow();
+                gpkgIconRow.data = iconBytes;
+                populateGpkgIconRow(gpkgIconRow, iconDoc, this._event);
+                const id = this.observationStyles.getIconDao().create(gpkgIconRow);
+                this.iconCache.put(iconDoc, id);
+                return id;
+            }
+            catch (err) {
+                console.warn('error adding icon', iconDoc.path, err);
+            }
+            this.iconCache.put(iconDoc, IconTreeCache.ICON_LOAD_ERROR);
+            return null;
+        });
+    }
+}
+exports.GeoPackage = GeoPackage;
+function populateGpkgIconRow(gpkgIconRow, iconDoc, mageEvent) {
+    gpkgIconRow.contentType = 'image/png';
+    gpkgIconRow.width = 20;
+    gpkgIconRow.anchorU = 0.5;
+    gpkgIconRow.anchorV = 1.0;
+    const defaultName = `${mageEvent.name} default`;
+    const name = (() => {
+        if (isNothing(iconDoc.formId)) {
+            if (isNothing(iconDoc.primary)) {
+                if (isNothing(iconDoc.variant)) {
+                    return defaultName;
+                }
+                return iconDoc.variant;
+            }
+            return iconDoc.primary;
         }
-        if (zoomToEnvelope.maxY < envelope.maxY) {
-            zoomToEnvelope.maxY = envelope.maxY;
+        const form = mageEvent.formFor(iconDoc.formId);
+        if (!form) {
+            return defaultName;
         }
-        if (zoomToEnvelope.minX > envelope.minX) {
-            zoomToEnvelope.minX = envelope.minX;
+        return `${form.name} icon`;
+    })();
+    gpkgIconRow.name = name;
+    return gpkgIconRow;
+}
+function isNothing(wut) {
+    return wut === null || wut === undefined || wut === '' || (typeof wut === 'number' && isNaN(wut));
+}
+class IconTreeCache {
+    constructor() {
+        this.root = new IconTreeCacheNode();
+    }
+    get(icon) {
+        const { formId, primary, variant } = icon;
+        if (!isNothing(formId)) {
+            const formNode = this.root.children[formId];
+            if (formNode) {
+                if (!isNothing(primary)) {
+                    const primaryNode = formNode.children[primary];
+                    if (primaryNode) {
+                        if (!isNothing(variant)) {
+                            const variantNode = primaryNode.children[variant];
+                            return (variantNode === null || variantNode === void 0 ? void 0 : variantNode.gpkgIconId) || null;
+                        }
+                        return primaryNode.gpkgIconId;
+                    }
+                    return null;
+                }
+                return formNode.gpkgIconId;
+            }
+            return null;
         }
-        if (zoomToEnvelope.minY > envelope.minY) {
-            zoomToEnvelope.minY = envelope.minY;
+        return this.root.gpkgIconId;
+    }
+    put(icon, gpkgIconId) {
+        const node = this.ensurePathNodes(icon);
+        node.gpkgIconId = gpkgIconId;
+        return this;
+    }
+    ensurePathNodes(path) {
+        const { formId, primary, variant } = path;
+        if (!isNothing(formId)) {
+            const formNode = this.root.children[formId] = this.root.children[formId] || new IconTreeCacheNode();
+            if (!isNothing(primary)) {
+                const primaryNode = formNode.children[primary] = formNode.children[primary] || new IconTreeCacheNode();
+                if (!isNothing(variant)) {
+                    return primaryNode.children[variant] = primaryNode.children[variant] || new IconTreeCacheNode();
+                }
+                return primaryNode;
+            }
+            return formNode;
         }
+        return this.root;
+    }
+}
+IconTreeCache.ICON_LOAD_ERROR = Number.MIN_SAFE_INTEGER;
+class IconTreeCacheNode {
+    constructor(gpkgRowId = null, children = {}) {
+        this.gpkgIconId = null;
+        this.gpkgIconId = isNothing(gpkgRowId) ? null : gpkgRowId;
+        this.children = children;
+    }
+}
+function createGeoPackageFile() {
+    const filename = (0, moment_1.default)().format('YYYMMDD_hhmmssSSS') + '.gpkg';
+    const filePath = path_1.default.join(os_1.default.tmpdir(), filename);
+    return new Promise(function (resolve, reject) {
+        fs_1.default.unlink(filePath, function () {
+            fs_1.default.mkdir(path_1.default.dirname(filePath), function () {
+                fs_1.default.open(filePath, 'w', function (err) {
+                    if (err)
+                        return reject(err);
+                    resolve(filePath);
+                });
+            });
+        });
+    });
+}
+function calculateBounds(geometry, zoomToEnvelope) {
+    const wkxGeometry = wkx_1.default.Geometry.parseGeoJSON(geometry);
+    const envelope = envelopeBuilder_1.EnvelopeBuilder.buildEnvelopeWithGeometry(wkxGeometry);
+    if (!zoomToEnvelope) {
+        return envelope;
+    }
+    if (zoomToEnvelope.maxX < envelope.maxX) {
+        zoomToEnvelope.maxX = envelope.maxX;
+    }
+    if (zoomToEnvelope.maxY < envelope.maxY) {
+        zoomToEnvelope.maxY = envelope.maxY;
+    }
+    if (zoomToEnvelope.minX > envelope.minX) {
+        zoomToEnvelope.minX = envelope.minX;
+    }
+    if (zoomToEnvelope.minY > envelope.minY) {
+        zoomToEnvelope.minY = envelope.minY;
     }
     return zoomToEnvelope;
-};
-GeoPackage.prototype.addAttachments = function (geopackage, attachments, observationId, formTable, formRowId) {
+}
+function addAttachments(geopackage, attachments, observationId, formTable, formRowId) {
     return __awaiter(this, void 0, void 0, function* () {
-        log.info('Add Attachments');
+        log.info('add attachments');
         for (let i = 0; i < attachments.length; i++) {
             const attachment = attachments[i];
             if (attachment.relativePath) {
                 yield new Promise(function (resolve, reject) {
-                    fs.readFile(path.join(attachmentBase, attachment.relativePath), (err, dataBuffer) => __awaiter(this, void 0, void 0, function* () {
-                        if (err)
+                    fs_1.default.readFile(path_1.default.join(attachmentBase, attachment.relativePath), (err, dataBuffer) => __awaiter(this, void 0, void 0, function* () {
+                        if (err) {
                             return reject(err);
-                        const mediaId = geopackage.addMedia('Attachments', dataBuffer, attachment.contentType, {
-                            name: attachment.name,
-                            size: attachment.size
+                        }
+                        const mediaId = geopackage.addMedia('Attachments', dataBuffer, attachment.contentType || 'application/octet-stream', {
+                            name: attachment.name || attachment._id,
+                            size: attachment.size || 0
                         });
                         yield geopackage.linkMedia('Observations', observationId, 'Attachments', mediaId);
                         resolve(geopackage.linkMedia(formTable, formRowId, 'Attachments', mediaId));
@@ -538,144 +732,18 @@ GeoPackage.prototype.addAttachments = function (geopackage, attachments, observa
             }
         }
     });
-};
-GeoPackage.prototype.createObservationFeatureTableStyles = function (geopackage) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const featureTableName = 'Observations';
-        const featureTableStyles = new GeoPackageAPI.FeatureTableStyles(geopackage, featureTableName);
-        yield geopackage.featureStyleExtension.getOrCreateExtension(featureTableName);
-        yield geopackage.featureStyleExtension.getRelatedTables().getOrCreateExtension();
-        yield geopackage.featureStyleExtension.getContentsId().getOrCreateExtension();
-        featureTableStyles.createRelationships();
-        yield this.addObservationIcons(geopackage, featureTableStyles);
-        return geopackage;
-    });
-};
-GeoPackage.prototype.createUserFeatureTableStyles = function (geopackage) {
+}
+function createUserFeatureTableStyles(geopackage) {
     return __awaiter(this, void 0, void 0, function* () {
         const featureTableName = 'Users';
-        const featureTableStyles = new GeoPackageAPI.FeatureTableStyles(geopackage, featureTableName);
+        const featureTableStyles = new GPKG.FeatureTableStyles(geopackage, featureTableName);
         yield geopackage.featureStyleExtension.getOrCreateExtension(featureTableName);
         yield geopackage.featureStyleExtension.getRelatedTables().getOrCreateExtension();
         yield geopackage.featureStyleExtension.getContentsId().getOrCreateExtension();
         featureTableStyles.createRelationships();
-        return geopackage;
     });
-};
-GeoPackage.prototype.addObservationIcons = function (geopackage, featureTableStyles) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const rootDir = path.join(new api.Icon(this._event._id).getBasePath());
-        if (!fs.existsSync(path.join(rootDir))) {
-            return geopackage;
-        }
-        const formDirs = fs.readdirSync(path.join(rootDir));
-        for (let i = 0; i < formDirs.length; i++) {
-            const formDir = formDirs[i];
-            this.iconMap[formDir] = this.iconMap[formDir] || {};
-            if (!fs.existsSync(path.join(rootDir, formDir))) {
-                continue;
-            }
-            if (formDir === 'icon.png') {
-                yield new Promise((resolve, reject) => {
-                    fs.readFile(path.join(rootDir, formDir), (err, iconBuffer) => __awaiter(this, void 0, void 0, function* () {
-                        if (err)
-                            return reject(err);
-                        const iconRow = featureTableStyles.getIconDao().newRow();
-                        iconRow.data = iconBuffer;
-                        iconRow.contentType = 'image/png';
-                        iconRow.name = `${this._event.name} icon`;
-                        iconRow.description = `Icon for event ${this._event.name}`;
-                        iconRow.width = 20;
-                        iconRow.anchorU = 0.5;
-                        iconRow.anchorV = 1.0;
-                        this.iconMap[formDir] = iconRow;
-                        yield featureTableStyles.setTableIconDefault(iconRow);
-                        resolve();
-                    }));
-                });
-            }
-            else {
-                const primaryDirs = fs.readdirSync(path.join(rootDir, formDir));
-                for (let p = 0; p < primaryDirs.length; p++) {
-                    const primaryDir = primaryDirs[p];
-                    if (!fs.existsSync(path.join(rootDir, formDir, primaryDir))) {
-                        continue;
-                    }
-                    if (primaryDir === 'icon.png') {
-                        yield new Promise((resolve, reject) => {
-                            fs.readFile(path.join(rootDir, formDir, primaryDir), (err, iconBuffer) => {
-                                if (err)
-                                    return reject(err);
-                                const iconRow = featureTableStyles.getIconDao().newRow();
-                                iconRow.data = iconBuffer;
-                                iconRow.contentType = 'image/png';
-                                iconRow.name = formDir;
-                                iconRow.description = `Icon for form ${formDir}/icon.png`;
-                                iconRow.width = 20;
-                                iconRow.anchorU = 0.5;
-                                iconRow.anchorV = 1.0;
-                                this.iconMap[formDir]['icon.png'] = iconRow;
-                                resolve();
-                            });
-                        });
-                    }
-                    else {
-                        this.iconMap[formDir][primaryDir] = this.iconMap[formDir][primaryDir] || {};
-                        const variantDirs = fs.readdirSync(path.join(rootDir, formDir, primaryDir));
-                        for (let v = 0; v < variantDirs.length; v++) {
-                            const variantDir = variantDirs[v];
-                            if (!fs.existsSync(path.join(rootDir, formDir, primaryDir, variantDir))) {
-                                continue;
-                            }
-                            if (variantDir === 'icon.png') {
-                                yield new Promise((resolve, reject) => {
-                                    fs.readFile(path.join(rootDir, formDir, primaryDir, variantDir), (err, iconBuffer) => {
-                                        if (err)
-                                            return reject(err);
-                                        const iconRow = featureTableStyles.getIconDao().newRow();
-                                        iconRow.data = iconBuffer;
-                                        iconRow.contentType = 'image/png';
-                                        iconRow.name = primaryDir;
-                                        iconRow.description = `Icon for form ${formDir}/${primaryDir}/icon.png`;
-                                        iconRow.width = 20;
-                                        iconRow.anchorU = 0.5;
-                                        iconRow.anchorV = 1.0;
-                                        this.iconMap[formDir][primaryDir]['icon.png'] = iconRow;
-                                        resolve();
-                                    });
-                                });
-                            }
-                            else {
-                                this.iconMap[formDir][primaryDir][variantDir] = this.iconMap[formDir][primaryDir][variantDir] || {};
-                                if (!fs.existsSync(path.join(rootDir, formDir, primaryDir, variantDir, 'icon.png'))) {
-                                    continue;
-                                }
-                                yield new Promise((resolve, reject) => {
-                                    fs.readFile(path.join(rootDir, formDir, primaryDir, variantDir, 'icon.png'), (err, iconBuffer) => {
-                                        if (err)
-                                            return reject(err);
-                                        const iconRow = featureTableStyles.getIconDao().newRow();
-                                        iconRow.data = iconBuffer;
-                                        iconRow.contentType = 'image/png';
-                                        iconRow.name = variantDir;
-                                        iconRow.description = `Icon for form ${formDir}/${primaryDir}/${variantDir}/icon.png`;
-                                        iconRow.width = 20;
-                                        iconRow.anchorU = 0.5;
-                                        iconRow.anchorV = 1.0;
-                                        this.iconMap[formDir][primaryDir][variantDir]['icon.png'] = iconRow;
-                                        resolve();
-                                    });
-                                });
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return geopackage;
-    });
-};
-GeoPackage.prototype.setContentBounds = function (geopackage, featureDao, zoomToEnvelope) {
+}
+function setContentBounds(geopackage, featureDao, zoomToEnvelope) {
     const contents = featureDao.getContents();
     contents.max_x = zoomToEnvelope.maxX;
     contents.max_y = zoomToEnvelope.maxY;
@@ -683,5 +751,5 @@ GeoPackage.prototype.setContentBounds = function (geopackage, featureDao, zoomTo
     contents.min_y = zoomToEnvelope.minY;
     const contentsDao = geopackage.contentsDao;
     contentsDao.update(contents);
-};
+}
 //# sourceMappingURL=geopackage.js.map