layer.js

'use strict';
// TODO consider splitting this module into different modules.  in particular,
//      file-based stuff vs server based stuff, and layer creation vs layer support
// TODO convert internal function header comments to JSDoc, and use the @private tag
const csv2geojson = require('csv2geojson');
const Terraformer = require('terraformer');
const shp = require('shpjs');
const ogc = require('./layer/ogc.js');
const bbox = require('./layer/bbox.js');
const layerRecord = require('./layer/layerRec/main.js');
const defaultRenderers = require('./defaultRenderers.json');
Terraformer.ArcGIS = require('terraformer-arcgis-parser');
/**
* Maps GeoJSON geometry types to a set of default renders defined in GlobalStorage.DefaultRenders
* @property featureTypeToRenderer {Object}
* @private
*/
const featureTypeToRenderer = {
    Point: 'circlePoint',
    MultiPoint: 'circlePoint',
    LineString: 'solidLine',
    MultiLineString: 'solidLine',
    Polygon: 'outlinedPoly',
    MultiPolygon: 'outlinedPoly'
};
/**
* Different types of services that a URL could point to
* @property serviceType {Object}
*/
const serviceType = {
    CSV: 'csv',
    GeoJSON: 'geojson',
    Shapefile: 'shapefile',
    FeatureLayer: 'featurelayer',
    RasterLayer: 'rasterlayer',
    GroupLayer: 'grouplayer',
    TileService: 'tileservice',
    FeatureService: 'featureservice',
    DynamicService: 'dynamicservice',
    ImageService: 'imageservice',
    WMS: 'wms',
    Unknown: 'unknown',
    Error: 'error'
};
// attempts to determine if a path points to a location on the internet,
// or is a local file.  Returns true if internetish
function isServerFile(url) {
    // TODO possibly enhance to be better check, or support more cases
    const lowUrl = url.toLowerCase();
    const tests = [/^http:/, /^https:/, /^ftp:/, /^\/\//];
    return tests.some(test => lowUrl.match(test));
}
// will grab a file from a server address as binary.
// returns a promise that resolves with the file data.
function getServerFile(url, esriBundle) {
    return new Promise((resolve, reject) => {
        // extract info for this service
        const defService = esriBundle.esriRequest({
            url: url,
            handleAs: 'arraybuffer'
        });
        defService.then(srvResult => {
            resolve(srvResult);
        }, error => {
            // something went wrong
            reject(error);
        });
    });
}
// returns a standard information object with serviceType
// supports predictLayerUrl
// type is serviceType enum value
function makeInfo(type) {
    return {
        serviceType: type
    };
}
// returns a standard information object with serviceType and name
// common for most ESRI endpoints
// supports predictLayerUrl
// type is serviceType enum value
// name is property in json containing a service name
// json is json result from service
function makeLayerInfo(type, name, json) {
    const info = makeInfo(type);
    info.name = json[name] || '';
    return info;
}
// returns promise of standard information object with serviceType
// and fileData if file is located online (not on disk).
function makeFileInfo(type, url, esriBundle) {
    return new Promise(resolve => {
        const info = makeInfo(type);
        if (url && isServerFile(url)) {
            // be a pal and download the file content
            getServerFile(url, esriBundle).then(data => {
                info.fileData = data;
                resolve(info);
            }).catch(() => {
                info.type = serviceType.Error;
                resolve(info);
            });
        } else {
            resolve(info);
        }
    });
}
// inspects the JSON that was returned from a service.
// if the JSON belongs to an ESRI endpoint, we do some terrible dog-logic to attempt
// to derive what type of endpoint it is (mainly by looking for properties that are
// unique to that type of service).
// returns an enumeration value (string) from serviceType based on the match found.
// non-esri services or unexpected esri services will return the .Unknown value
function crawlEsriService(srvJson) {
    if (srvJson.type) {
        // a layer endpoint (i.e. url ends with integer index)
        const mapper = {
            'Feature Layer': serviceType.FeatureLayer,
            'Raster Layer': serviceType.RasterLayer,
            'Group Layer': serviceType.GroupLayer
        };
        return mapper[srvJson.type] || serviceType.Unknown;
    } else if (srvJson.hasOwnProperty('singleFusedMapCache')) {
        if (srvJson.singleFusedMapCache) {
            // a tile server
            return serviceType.TileService;
        } else {
            // a map server
            return serviceType.DynamicService;
        }
    } else if (srvJson.hasOwnProperty('allowGeometryUpdates')) {
        // a feature server
        return serviceType.FeatureService;
    } else if (srvJson.hasOwnProperty('allowedMosaicMethods')) {
        // an image server
        return serviceType.ImageService;
    } else {
        return serviceType.Unknown;
    }
}
// given a URL, attempt to read it as an ESRI rest endpoint.
// returns a promise that resovles with an information object.
// at minimum, the object will have a .serviceType property with a value from the above enumeration.
// if the type is .Unknown, then we were unable to determine the url was an ESRI rest endpoint.
// otherwise, we were successful, and the information object will have other properties depending on the service type
// - .name : scraped from service, but may be rubbish (depends on service publisher). used as UI suggestion only
// - .fields : for feature layer service only. list of fields to allow user to pick name field
// - .geometryType : for feature layer service only.  for help in defining the renderer, if required.
// - .layers : for dynamic layer service only. lists the child layers
function pokeEsriService(url, esriBundle, hint) {
    // reaction functions to different esri services
    const srvHandler = {};
    // feature layer gets some extra treats
    srvHandler[serviceType.FeatureLayer] = srvJson => {
        const info = makeLayerInfo(serviceType.FeatureLayer, 'name', srvJson);
        info.fields = srvJson.fields;
        info.geometryType = srvJson.geometryType;
        info.smartDefaults = {
            // TODO: try to find a name field if possible
            primary: info.fields[0].name // pick the first field as primary and return its name for ui binding
        };
        return info;
    };
    // no treats for raster (for now)
    srvHandler[serviceType.RasterLayer] = srvJson => {
        return makeLayerInfo(serviceType.RasterLayer, 'name', srvJson);
    };
    // no treats for group (for now)
    srvHandler[serviceType.GroupLayer] = srvJson => {
        return makeLayerInfo(serviceType.GroupLayer, 'name', srvJson);
    };
    // no treats for tile (for now)
    srvHandler[serviceType.TileService] = srvJson => {
        return makeLayerInfo(serviceType.TileService, 'mapName', srvJson);
    };
    // no treats for mapserver / dynamic (for now)
    srvHandler[serviceType.DynamicService] = srvJson => {
        const info = makeLayerInfo(serviceType.DynamicService, 'mapName', srvJson);
        info.layers = srvJson.layers;
        return info;
    };
    // no treats for imageserver (for now)
    srvHandler[serviceType.ImageService] = srvJson => {
        const info = makeLayerInfo(serviceType.ImageService, 'name', srvJson);
        info.fields = srvJson.fields;
        return info;
    };
    // couldnt figure it out
    srvHandler[serviceType.Unknown] = () => {
        return makeInfo(serviceType.Unknown);
    };
    return new Promise(resolve => {
        // extract info for this service
        const defService = esriBundle.esriRequest({
            url: url,
            content: { f: 'json' },
            callbackParamName: 'callback',
            handleAs: 'json',
        });
        defService.then(srvResult => {
            // request didnt fail, indicating it is likely an ArcGIS Server endpoint
            let resultType = crawlEsriService(srvResult);
            if (hint && resultType !== hint) {
                // our hint doesn't match the service
                resultType = serviceType.Unknown;
            }
            resolve(srvHandler[resultType](srvResult));
        }, () => {
            // something went wrong, but that doesnt mean our service is invalid yet
            // it's likely not ESRI.  return Error and let main predictor keep investigating
            resolve(makeInfo(serviceType.Error));
        });
    });
}
// tests a URL to see if the value is a file
// providing the known type as a hint will cause the function to run the
// specific logic for that file type, rather than guessing and trying everything
// resolves with promise of information object
// - serviceType : the type of file (CSV, Shape, GeoJSON, Unknown)
// - fileData : if the file is located on a server, will xhr
function pokeFile(url, esriBundle, hint) {
    // reaction functions to different files
    // overkill right now, as files just identify the type right now
    // but structure will let us enhance for custom things if we need to
    const fileHandler = {};
    // csv
    fileHandler[serviceType.CSV] = () => {
        return makeFileInfo(serviceType.CSV, url, esriBundle);
    };
    // geojson
    fileHandler[serviceType.GeoJSON] = () => {
        return makeFileInfo(serviceType.GeoJSON, url, esriBundle);
    };
    // csv
    fileHandler[serviceType.Shapefile] = () => {
        return makeFileInfo(serviceType.Shapefile, url, esriBundle);
    };
    // couldnt figure it out
    fileHandler[serviceType.Unknown] = () => {
        // dont supply url, as we don't want to download random files
        return makeFileInfo(serviceType.Unknown);
    };
    return new Promise(resolve => {
        if (hint) {
            // force the data extraction of the hinted format
            resolve(fileHandler[hint]());
        } else {
            // inspect the url for file extensions
            let guessType = serviceType.Unknown;
            switch (url.substr(url.lastIndexOf('.') + 1).toLowerCase()) {
                // check for file extensions
                case 'csv':
                    guessType = serviceType.CSV;
                    break;
                case 'zip':
                    guessType = serviceType.Shapefile;
                    break;
                case 'json':
                    guessType = serviceType.GeoJSON;
                    break;
            }
            resolve(fileHandler[guessType]());
        }
    });
}
// tests a URL to see if the value is a wms
// resolves with promise of information object
// - serviceType : the type of service (WMS, Unknown)
function pokeWms(url, esriBundle) {
    // FIXME add some WMS detection logic.  that would be nice
    console.log(url, esriBundle); // to stop jslint from quacking. remove when params are actually used
    return Promise.resolve(makeInfo(serviceType.WMS));
}
function predictLayerUrlBuilder(esriBundle) {
    /**
    * Attempts to determine what kind of layer the URL most likely is, and
    * if possible, return back some useful information about the layer
    *
    * - serviceType: the type of layer the function thinks the url is referring to. is a value of serviceType enumeration (string)
    * - fileData: file contents in an array buffer. only present if the URL points to a file that exists on an internet server (i.e. not a local disk drive)
    * - name: best attempt at guessing the name of the service (string). only present for ESRI service URLs
    * - fields: array of field definitions for the layer. conforms to ESRI's REST field standard. only present for feature layer and image service URLs.
    * - geometryType: describes the geometry of the layer (string). conforms to ESRI's REST geometry type enum values. only present for feature layer URLs.
    * - groupIdx: property only available if a group layer is queried. it is the layer index of the group layer in the list under its parent dynamic layer
    *
    * @method predictLayerUrl
    * @param {String} url a url to something that is hopefully a map service
    * @param {String} hint optional. allows the caller to specify the url type, forcing the function to run the data logic for that type
    * @returns {Promise} a promise resolving with an infomation object
    */
    return (url, hint) => {
        // TODO this function has lots of room to improve.  there are many valid urls that it will
        //      fail to identify correctly in it's current state
        // TODO refactor how this function works.
        //      wait for the web service request library to not be esri/request
        //      use new library to make a head call on the url provided
        //      examine the content type of the head call result
        //        if xml, assume WMS
        //        if json, assume esri  (may need extra logic to differentiate from json file?)
        //        file case is explicit (e.g text/json)
        //      then hit appropriate handler, do a second web request for content if required
        if (hint) {
            // go directly to appropriate logic block
            const hintToFlavour = {}; // why? cuz cyclomatic complexity + OBEY RULES
            const flavourToHandler = {};
            // hint type to hint flavour
            hintToFlavour[serviceType.CSV] = 'F_FILE';
            hintToFlavour[serviceType.GeoJSON] = 'F_FILE';
            hintToFlavour[serviceType.Shapefile] = 'F_FILE';
            hintToFlavour[serviceType.FeatureLayer] = 'F_ESRI';
            hintToFlavour[serviceType.RasterLayer] = 'F_ESRI';
            hintToFlavour[serviceType.GroupLayer] = 'F_ESRI';
            hintToFlavour[serviceType.TileService] = 'F_ESRI';
            hintToFlavour[serviceType.DynamicService] = 'F_ESRI';
            hintToFlavour[serviceType.ImageService] = 'F_ESRI';
            hintToFlavour[serviceType.WMS] = 'F_WMS';
            // hint flavour to flavour-handler
            flavourToHandler.F_FILE = () => {
                return pokeFile(url, esriBundle, hint);
            };
            flavourToHandler.F_ESRI = () => {
                return pokeEsriService(url, esriBundle, hint);
            };
            flavourToHandler.F_WMS = () => {
                // FIXME REAL LOGIC COMING SOON
                return pokeWms(url, esriBundle);
            };
            // execute handler.  hint -> flavour -> handler -> run it -> promise
            return flavourToHandler[hintToFlavour[hint]]();
        } else {
            // TODO restructure.  this approach cleans up the pyramid of doom.
            //      Needs to add check for empty tests, resolve as unknown.
            //      Still a potential to take advantage of the nice structure.  Will depend
            //      what comes first:  WMS logic (adding a 3rd test), or changing the request
            //      library, meaning we get the type early from the head request.
            /*
            tests = [pokeFile, pokeService];
            function runTests() {
                test = tests.pop();
                test(url, esriBundle).then(info => {
                    if (info.serviceType !== serviceType.Unknown) {
                        resolve(info);
                        return;
                    }
                    runTests();
                });
            }
            runTests();
            */
            return new Promise(resolve => {
                // no hint. run tests until we find a match.
                // test for file
                pokeFile(url, esriBundle).then(infoFile => {
                    if (infoFile.serviceType === serviceType.Unknown ||
                        infoFile.serviceType === serviceType.Error) {
                        // not a file, test for ESRI
                        pokeEsriService(url, esriBundle).then(infoEsri => {
                            if (infoEsri.serviceType === serviceType.Unknown ||
                                infoEsri.serviceType === serviceType.Error) {
                                // FIXME REAL LOGIC COMING SOON
                                // pokeWMS
                                resolve(infoEsri);
                            } else {
                                // it was a esri service. rejoice.
                                // shortlived rejoice because grouped layers lul
                                if (infoEsri.serviceType === serviceType.GroupLayer) {
                                    const lastSlash = url.lastIndexOf('/');
                                    const layerIdx = parseInt(url.substring(lastSlash + 1));
                                    url = url.substring(0, lastSlash);
                                    pokeEsriService(url, esriBundle).then(infoDynamic => {
                                        infoDynamic.groupIdx = layerIdx;
                                        resolve(infoDynamic);
                                    });
                                } else {
                                    resolve(infoEsri);
                                }
                            }
                        });
                    } else {
                        // it was a file. rejoice.
                        resolve(infoFile);
                    }
                });
            });
        }
    };
}
/**
* Converts an array buffer to a string
*
* @method arrayBufferToString
* @private
* @param {Arraybuffer} buffer an array buffer containing stuff (ideally string-friendly)
* @returns {String} array buffer in string form
*/
function arrayBufferToString(buffer) {
    // handles UTF8 encoding
    return new TextDecoder('utf-8').decode(new Uint8Array(buffer));
}
/**
* Performs validation on GeoJson object. Returns a promise resolving with the validation object.
* Worker function for validateFile, see that file for return value specs
*
* @method validateGeoJson
* @private
* @param {Object} geoJson feature collection in geojson form
* @returns {Promise} promise resolving with information on the geoJson object
*/
function validateGeoJson(geoJson) {
    // GeoJSON geometry type to ESRI geometry type
    const geomMap = {
        Point: 'esriGeometryPoint',
        MultiPoint: 'esriGeometryMultipoint',
        LineString: 'esriGeometryPolyline',
        MultiLineString: 'esriGeometryPolyline',
        Polygon: 'esriGeometryPolygon',
        MultiPolygon: 'esriGeometryPolygon'
    };
    const fields = extractFields(geoJson);
    const res = {
        fields: fields,
        geometryType: geomMap[geoJson.features[0].geometry.type],
        formattedData: geoJson,
        smartDefaults: {
            // TODO: try to find a name field if possible
            primary: fields[0].name // pick the first field as primary and return its name for ui binding
        }
    };
    if (!res.geometryType) {
        return Promise.reject(new Error('Unexpected geometry type in GeoJSON'));
    }
    // TODO optional check: iterate through every feature, ensure geometry type and properties are all identical
    return Promise.resolve(res);
}
/**
* Performs validation on csv data. Returns a promise resolving with the validation object.
* Worker function for validateFile, see that file for return value specs
*
* @method validateCSV
* @private
* @param {Object} data csv data as string
* @returns {Promise} promise resolving with information on the csv data
*/
function validateCSV(data) {
    const formattedData = arrayBufferToString(data); // convert from arraybuffer to string to parsed csv. store string format for later
    const rows = csvPeek(formattedData, ','); // FIXME: this assumes delimiter is a `,`; need validation
    let errorMessage; // error message if any to return
    // validations
    if (rows.length === 0) {
        // fail, no rows
        errorMessage = 'File has no rows';
    } else {
        // field count of first row.
        const fc = rows[0].length;
        if (fc < 2) {
            // fail not enough columns
            errorMessage = 'File has less than two columns';
        } else {
            // check field counts of each row
            if (rows.every(rowArr => rowArr.length === fc)) {
                const res = {
                    formattedData,
                    smartDefaults: guessCSVfields(rows), // calculate smart defaults
                    // make field list esri-ish for consistancy
                    fields: rows[0].map(field => ({
                        name: field,
                        type: 'esriFieldTypeString'
                    })),
                    geometryType: 'esriGeometryPoint' // always point for CSV
                };
                return Promise.resolve(res);
            } else {
                errorMessage = 'File has inconsistent column counts';
            }
        }
    }
    return Promise.reject(new Error(errorMessage));
}
/**
* Validates file content.  Does some basic checking for errors. Attempts to get field list, and
* if possible, provide the file in a more useful format. Promise rejection indicates failed validation
*
* - formattedData: file contents in a more useful format. JSON for GeoJSON and Shapefile. String for CSV
* - fields: array of field definitions for the file. conforms to ESRI's REST field standard.
* - geometryType: describes the geometry of the file (string). conforms to ESRI's REST geometry type enum values.
*
* @method validateFile
* @param {String} type the format of file. aligns to serviceType enum (CSV, Shapefile, GeoJSON)
* @param {Arraybuffer} data the file content in binary
* @returns {Promise} a promise resolving with an infomation object
*/
function validateFile(type, data) {
    const fileHandler = { // maps handlers for different file types
        [serviceType.CSV]: data => validateCSV(data),
        [serviceType.GeoJSON]: data => {
            const geoJson = JSON.parse(arrayBufferToString(data));
            return validateGeoJson(geoJson);
        },
        // convert from arraybuffer (containing zipped shapefile) to json (using shp library)
        [serviceType.Shapefile]: data =>
            shp(data).then(geoJson =>
                validateGeoJson(geoJson))
    };
    // trigger off the appropriate handler, return promise
    return fileHandler[type](data);
}
/**
 * From provided CSV data, guesses which columns are long and lat. If guessing is no successful, returns null for one or both fields.
 *
 * @method guessCSVfields
 * @private
 * @param  {Array} rows csv data
 * @return {Object}      an object with lat and long string properties indicating corresponding field names
 */
function guessCSVfields(rows) {
    // magic regexes
    // TODO: in case of performance issues with running regexes on large csv files, limit to, say, the first hundred rows
    // TODO: explain regexes
    const latValueRegex = new RegExp(/^[-+]?([1-8]?\d(\.\d+)?|90(\.0+)?)$/); // filters by field value
    const longValueRegex = new RegExp(/^[-+]?(180(\.0+)?|((1[0-7]\d)|([1-9]?\d))(\.\d+)?)$/);
    const latNameRegex = new RegExp(/^.*(y|la).*$/i); // filters by field name
    const longNameRegex = new RegExp(/^.*(x|lo).*$/i);
    const latCandidates = findCandidates(rows, latValueRegex, latNameRegex); // filter out all columns that are not lat based on row values
    const longCandidates = findCandidates(rows, longValueRegex, longNameRegex); // filter out all columns that are not long based on row values
    // console.log(latCandidates);
    // console.log(longCandidates);
    // pick the first lat guess or null
    const lat = latCandidates[0] || null;
    // pick the first long guess or null
    const long = longCandidates.find(field => field !== lat) || null;
    // for primary field, pick the first on that is not lat or long field or null
    const primary = rows[0].find(field => field !== lat && field !== long) || null;
    return {
        lat,
        long,
        primary
    };
    function findCandidates(rows, valueRegex, nameRegex) {
        const fields = rows[0]; // first row must be headers
        const candidates =
            fields.filter((field, index) =>
                rows.every((row, rowIndex) =>
                    rowIndex === 0 || valueRegex.test(row[index]))) // skip first row as its just headers
            .filter(field => nameRegex.test(field));
        return candidates;
    }
}
function serverLayerIdentifyBuilder(esriBundle) {
    // TODO we are using layerIds option property as it aligns with what the ESRI identify parameter
    //      object uses.  However, in r2 terminology, a layerId is specific to a full map layer, not
    //      indexes of a single dynamic layer.  for clarity, could consider renaming to .visibleLayers
    //      and then map the value to the .layerIds property inside this function.
    /**
    * Perform a server-side identify on a layer (usually an ESRI dynamic layer)
    * Accepts the following options:
    *   - geometry: Required. geometry in map co-ordinates for the area to identify.
    *     will usually be an ESRI Point, though a polygon would work.
    *   - mapExtent: Required. ESRI Extent of the current map view
    *   - width: Required. Width of the map in pixels
    *   - height: Required. Height of the map in pixels
    *   - layerIds: an array of integers specifying the layer indexes to be examined. Will override the current
    *     visible indexes in the layer parameter
    *   - returnGeometry: a boolean indicating if result geometery should be returned with results.  Defaults to false
    *   - tolerance: an integer indicating how many screen pixels away from the mouse is valid for a hit.  Defaults to 5
    *
    * @method serverLayerIdentify
    * @param {Object} layer an ESRI dynamic layer object
    * @param {Object} opts An object for supplying additional parameters
    * @returns {Promise} a promise resolving with an array of identify results (empty array if no hits)
    */
    return (layer, opts) => {
        const identParams = new esriBundle.IdentifyParameters();
        // pluck treats from options parameter
        if (opts) {
            const reqOpts = ['geometry', 'mapExtent', 'height', 'width'];
            reqOpts.forEach(optProp => {
                if (opts[optProp]) {
                    identParams[optProp] = opts[optProp];
                } else {
                    throw new Error(`serverLayerIdentify - missing opts.${ optProp } arguement`);
                }
            });
            identParams.layerIds = opts.layerIds || layer.visibleLayers;
            identParams.returnGeometry = opts.returnGeometry || false;
            identParams.layerOption = esriBundle.IdentifyParameters.LAYER_OPTION_ALL;
            identParams.spatialReference = opts.geometry.spatialReference;
            identParams.tolerance = opts.tolerance || 5;
            // TODO add support for identParams.layerDefinitions once attribute filtering is implemented
        } else {
            throw new Error('serverLayerIdentify - missing opts arguement');
        }
        // asynch an identify task
        return new Promise((resolve, reject) => {
            const identify = new esriBundle.IdentifyTask(layer.url);
            // TODO possibly tack on the layer.id to the resolved thing so we know which parent layer returned?
            //      would only be required if the caller is mashing promises together and using Promise.all()
            identify.on('complete', result => {
                resolve(result.results);
            });
            identify.on('error', err => {
                reject(err.error);
            });
            identify.execute(identParams);
        });
    };
}
/**
* Performs in place assignment of integer ids for a GeoJSON FeatureCollection.
* If at least one feature has an existing id outside the geoJson properties section,
* the original id value is copied in a newly created property ID_FILE of the properties object
* and the existing id value is replaced by an autogenerated number.
* Features without existing id from that same dataset will get a new properties ID_FILE
* with an empty string as value.
**************************************
* If at least one feature has an existing OBJECTID inside the geoJson properties section,
* the original OBJECTID value is copied in a newly created property OBJECTID_FILE of the properties object
* and the existing OBJECTID value is replaced by an autogenerated number.
* Features without existing OBJECTID from that same dataset will get a new properties OBJECTID_FILE
* with an empty string as value.
*/
function assignIds(geoJson) {
    if (geoJson.type !== 'FeatureCollection') {
        throw new Error('Assignment can only be performed on FeatureCollections');
    }
    let emptyID = true;
    let emptyObjID = true;
    // for every feature, if it does not have an id property, add it.
    // 0 is not a valid object id
    geoJson.features.forEach(function (val, idx) {
        Object.assign(val.properties, { ID_FILE: '', OBJECTID_FILE: '' });
        // to avoid double ID columns outside properties
        if ('id' in val && typeof val.id !== 'undefined') {
            val.properties.ID_FILE = val.id;
            emptyID = false;
        }
        // to avoid double OBJECTID columns. Useful for both geojson and CSV file.
        if ('OBJECTID' in val.properties) {
            val.properties.OBJECTID_FILE = val.properties.OBJECTID;
            delete val.properties.OBJECTID;
            emptyObjID = false;
        }
        val.id = idx + 1;
    });
    // remove ID_FILE if all empty
    if (emptyID) {
        geoJson.features.forEach(function (val) {
            delete val.properties.ID_FILE;
        });
    }
    // remove OBJECTID_FILE if all empty
    if (emptyObjID) {
        geoJson.features.forEach(function (val) {
            delete val.properties.OBJECTID_FILE;
        });
    }
}
/**
 * Extracts fields from the first feature in the feature collection, does no
 * guesswork on property types and calls everything a string.
 */
function extractFields(geoJson) {
    if (geoJson.features.length < 1) {
        throw new Error('Field extraction requires at least one feature');
    }
    return Object.keys(geoJson.features[0].properties).map(function (prop) {
        return { name: prop, type: 'esriFieldTypeString' };
    });
}
/**
 * Makes an attempt to load and register a projection definition.
 * Returns promise resolving when process is complete
 * projModule - proj module from geoApi
 * projCode - the string or int epsg code we want to lookup
 * epsgLookup - function that will do the epsg lookup, taking code and returning promise of result or null
 */
function projectionLookup(projModule, projCode, epsgLookup) {
    // look up projection definitions if it's not already loaded and we have enough info
    if (!projModule.getProjection(projCode) && epsgLookup && projCode) {
        return epsgLookup(projCode).then(projDef => {
            if (projDef) {
                // register projection
                projModule.addProjection(projCode, projDef);
            }
            return projDef;
        });
    } else {
        return Promise.resolve(null);
    }
}
function makeGeoJsonLayerBuilder(esriBundle, geoApi) {
    /**
    * Converts a GeoJSON object into a FeatureLayer.  Expects GeoJSON to be formed as a FeatureCollection
    * containing a uniform feature type (FeatureLayer type will be set according to the type of the first
    * feature entry).  Accepts the following options:
    *   - targetWkid: Required. an integer for an ESRI wkid to project geometries to
    *   - renderer: a string identifying one of the properties in defaultRenders
    *   - sourceProjection: a string matching a proj4.defs projection to be used for the source data (overrides
    *     geoJson.crs)
    *   - fields: an array of fields to be appended to the FeatureLayer layerDefinition (OBJECTID is set by default)
    *   - epsgLookup: a function that takes an EPSG code (string or number) and returns a promise of a proj4 style
    *     definition or null if not found
    *   - layerId: a string to use as the layerId
    *   - colour: a hex string to define the symbol colour. e.g. '#33DD6A'
    *
    * @method makeGeoJsonLayer
    * @param {Object} geoJson An object following the GeoJSON specification, should be a FeatureCollection with
    * Features of only one type
    * @param {Object} opts An object for supplying additional parameters
    * @returns {Promise} a promise resolving with a {FeatureLayer}
    */
    return (geoJson, opts) => {
        // TODO add documentation on why we only support layers with WKID (and not WKT).
        let targetWkid;
        let srcProj = 'EPSG:4326'; // 4326 is the default for GeoJSON with no projection defined
        let layerId;
        const layerDefinition = {
            objectIdField: 'OBJECTID',
            fields: [
                {
                    name: 'OBJECTID',
                    type: 'esriFieldTypeOID',
                },
            ],
        };
        // ensure our features have ids
        assignIds(geoJson);
        layerDefinition.drawingInfo =
            defaultRenderers[featureTypeToRenderer[geoJson.features[0].geometry.type]];
        // attempt to get spatial reference from geoJson
        if (geoJson.crs && geoJson.crs.type === 'name') {
            srcProj = geoJson.crs.properties.name;
        }
        // pluck treats from options parameter
        if (opts) {
            if (opts.sourceProjection) {
                srcProj = opts.sourceProjection;
            }
            if (opts.targetWkid) {
                targetWkid = opts.targetWkid;
            } else {
                throw new Error('makeGeoJsonLayer - missing opts.targetWkid arguement');
            }
            if (opts.fields) {
                layerDefinition.fields = layerDefinition.fields.concat(opts.fields);
            }
            if (opts.layerId) {
                layerId = opts.layerId;
            } else {
                layerId = geoApi.shared.generateUUID();
            }
            // TODO add support for renderer option, or drop the option
        } else {
            throw new Error('makeGeoJsonLayer - missing opts arguement');
        }
        if (layerDefinition.fields.length === 1) {
            // caller has not supplied custom field list. so take them all.
            layerDefinition.fields = layerDefinition.fields.concat(extractFields(geoJson));
        }
        const destProj = 'EPSG:' + targetWkid;
        // look up projection definitions if they don't already exist and we have enough info
        const srcLookup = projectionLookup(geoApi.proj, srcProj, opts.epsgLookup);
        const destLookup = projectionLookup(geoApi.proj, destProj, opts.epsgLookup);
        // make the layer
        const buildLayer = new Promise(resolve => {
            // project data and convert to esri json format
            // console.log('reprojecting ' + srcProj + ' -> EPSG:' + targetWkid);
            geoApi.proj.projectGeojson(geoJson, destProj, srcProj);
            const esriJson = Terraformer.ArcGIS.convert(geoJson, { sr: targetWkid });
            const geometryType = layerDefinition.drawingInfo.geometryType;
            const fs = {
                features: esriJson,
                geometryType
            };
            const layer = new esriBundle.FeatureLayer(
                {
                    layerDefinition: layerDefinition,
                    featureSet: fs
                }, {
                    mode: esriBundle.FeatureLayer.MODE_SNAPSHOT,
                    id: layerId
                });
            // ＼(｀O´)／ manually setting SR because it will come out as 4326
            layer.spatialReference = new esriBundle.SpatialReference({ wkid: targetWkid });
            if (opts.colour) {
                layer.renderer.symbol.color = new esriBundle.Color(opts.colour);
            }
            // initializing layer using JSON does not set this property. do it manually.
            layer.geometryType = geometryType;
            resolve(layer);
        });
        // call promises in order
        return srcLookup
            .then(() => destLookup)
            .then(() => buildLayer);
    };
}
function makeCsvLayerBuilder(esriBundle, geoApi) {
    /**
    * Constructs a FeatureLayer from CSV data. Accepts the following options:
    *   - targetWkid: Required. an integer for an ESRI wkid the spatial reference the returned layer should be in
    *   - renderer: a string identifying one of the properties in defaultRenders
    *   - fields: an array of fields to be appended to the FeatureLayer layerDefinition (OBJECTID is set by default)
    *   - latfield: a string identifying the field containing latitude values ('Lat' by default)
    *   - lonfield: a string identifying the field containing longitude values ('Long' by default)
    *   - delimiter: a string defining the delimiter character of the file (',' by default)
    *   - epsgLookup: a function that takes an EPSG code (string or number) and returns a promise of a proj4 style
    *     definition or null if not found
    *   - layerId: a string to use as the layerId
    *   - colour: a hex string to define the symbol colour. e.g. '#33DD6A'
    * @param {string} csvData the CSV data to be processed
    * @param {object} opts options to be set for the parser
    * @returns {Promise} a promise resolving with a {FeatureLayer}
    */
    return (csvData, opts) => {
        const csvOpts = { // default values
            latfield: 'Lat',
            lonfield: 'Long',
            delimiter: ','
        };
        // user options if
        if (opts) {
            if (opts.latfield) {
                csvOpts.latfield = opts.latfield;
            }
            if (opts.lonfield) {
                csvOpts.lonfield = opts.lonfield;
            }
            if (opts.delimiter) {
                csvOpts.delimiter = opts.delimiter;
            }
        }
        return new Promise((resolve, reject) => {
            csv2geojson.csv2geojson(csvData, csvOpts, (err, data) => {
                if (err) {
                    console.warn('csv conversion error');
                    console.log(err);
                    reject(err);
                } else {
                    // csv2geojson will not include the lat and long in the feature
                    data.features.map(feature => {
                        // add new property Long and Lat before layer is generated
                        feature.properties[csvOpts.lonfield] = feature.geometry.coordinates[0];
                        feature.properties[csvOpts.latfield] = feature.geometry.coordinates[1];
                    });
                    // TODO are we at risk adding params to the var that was passed in? should we make a copy and modify the copy?
                    opts.sourceProjection = 'EPSG:4326'; // csv is always latlong
                    opts.renderer = 'circlePoint'; // csv is always latlong
                    // NOTE: since makeGeoJsonLayer is a "built" function, grab the built version from our link to api object
                    geoApi.layer.makeGeoJsonLayer(data, opts).then(jsonLayer => {
                        resolve(jsonLayer);
                    });
                }
            });
        });
    };
}
/**
* Peek at the CSV output (useful for checking headers)
* @param {string} csvData the CSV data to be processed
* @param {string} delimiter the delimiter used by the data
* @returns {Array} an array of arrays containing the parsed CSV
*/
function csvPeek(csvData, delimiter) {
    return csv2geojson.dsv(delimiter).parseRows(csvData);
}
function makeShapeLayerBuilder(esriBundle, geoApi) {
    /**
    * Constructs a FeatureLayer from Shapefile data. Accepts the following options:
    *   - targetWkid: Required. an integer for an ESRI wkid the spatial reference the returned layer should be in
    *   - renderer: a string identifying one of the properties in defaultRenders
    *   - sourceProjection: a string matching a proj4.defs projection to be used for the source data (overrides
    *     geoJson.crs)
    *   - fields: an array of fields to be appended to the FeatureLayer layerDefinition (OBJECTID is set by default)
    *   - epsgLookup: a function that takes an EPSG code (string or number) and returns a promise of a proj4 style
    *     definition or null if not found
    *   - layerId: a string to use as the layerId
    *   - colour: a hex string to define the symbol colour. e.g. '#33DD6A'
    * @param {ArrayBuffer} shapeData an ArrayBuffer of the Shapefile in zip format
    * @param {object} opts options to be set for the parser
    * @returns {Promise} a promise resolving with a {FeatureLayer}
    */
    return (shapeData, opts) => {
        return new Promise((resolve, reject) => {
            // turn shape into geojson
            shp(shapeData).then(geoJson => {
                // turn geojson into feature layer
                // NOTE: since makeGeoJsonLayer is a "built" function, grab the built version from our link to api object
                geoApi.layer.makeGeoJsonLayer(geoJson, opts).then(jsonLayer => {
                    resolve(jsonLayer);
                });
            }).catch(err => {
                reject(err);
            });
        });
    };
}
function getFeatureInfoBuilder(esriBundle) {
    /**
    * Fetches feature information, including geometry, from esri servers for feature layer.
    * @param {layerUrl} layerUrl linking to layer where feature layer resides
    * @param {objectId} objectId for feature to be retrived from a feature layer
    * @returns {Promise} promise resolves with an esri Graphic (http://resources.arcgis.com/en/help/arcgis-rest-api/#/Feature_Map_Service_Layer/02r3000000r9000000/)
    */
    return (layerUrl, objectId) => {
        return new Promise(
            (resolve, reject) => {
                const defData = esriBundle.esriRequest({
                    url: layerUrl + objectId,
                    content: {
                        f: 'json',
                    },
                    callbackParamName: 'callback',
                    handleAs: 'json'
                });
                defData.then(
                    layerObj => {
                        console.log(layerObj);
                        resolve(layerObj);
                    }, error => {
                        console.warn(error);
                        reject(error);
                    }
                );
            });
    };
}
function createImageRecordBuilder(esriBundle, geoApi, classBundle) {
    /**
    * Creates an Image Layer Record class
    * @param {Object} config         layer config values
    * @param {Object} esriLayer      an optional pre-constructed layer
    * @param {Function} epsgLookup   an optional lookup function for EPSG codes (see geoService for signature)
    * @returns {Object}              instantited ImageRecord class
    */
    return (config, esriLayer, epsgLookup) => {
        return new classBundle.ImageRecord(esriBundle.ArcGISImageServiceLayer, geoApi, config, esriLayer, epsgLookup);
    };
}
function createFeatureRecordBuilder(esriBundle, geoApi, classBundle) {
    /**
    * Creates an Feature Layer Record class
    * @param {Object} config         layer config values
    * @param {Object} esriLayer      an optional pre-constructed layer
    * @param {Function} epsgLookup   an optional lookup function for EPSG codes (see geoService for signature)
    * @returns {Object}              instantited FeatureRecord class
    */
    return (config, esriLayer, epsgLookup) => {
        return new classBundle.FeatureRecord(esriBundle.FeatureLayer, esriBundle.esriRequest,
            geoApi, config, esriLayer, epsgLookup);
    };
}
function createDynamicRecordBuilder(esriBundle, geoApi, classBundle) {
    /**
     * Creates an Dynamic Layer Record class
     * See DynamicRecord constructor for more detailed info on configIsComplete.
     *
     * @param {Object} config              layer config values
     * @param {Object} esriLayer           an optional pre-constructed layer
     * @param {Function} epsgLookup        an optional lookup function for EPSG codes (see geoService for signature)
     * @param {Boolean} configIsComplete   an optional flag to indicate all child state values are provided in the config and should be used.
     * @returns {Object}                   instantited DynamicRecord class
     */
    return (config, esriLayer, epsgLookup, configIsComplete = false) => {
        return new classBundle.DynamicRecord(esriBundle.ArcGISDynamicMapServiceLayer, esriBundle.esriRequest,
            geoApi, config, esriLayer, epsgLookup, configIsComplete);
    };
}
function createTileRecordBuilder(esriBundle, geoApi, classBundle) {
    /**
    * Creates an Tile Layer Record class
    * @param {Object} config         layer config values
    * @param {Object} esriLayer      an optional pre-constructed layer
    * @param {Function} epsgLookup   an optional lookup function for EPSG codes (see geoService for signature)
    * @returns {Object}              instantited TileRecord class
    */
    return (config, esriLayer, epsgLookup) => {
        return new classBundle.TileRecord(esriBundle.ArcGISTiledMapServiceLayer, geoApi, config,
            esriLayer, epsgLookup);
    };
}
function createWmsRecordBuilder(esriBundle, geoApi, classBundle) {
    /**
    * Creates an WMS Layer Record class
    * @param {Object} config         layer config values
    * @param {Object} esriLayer      an optional pre-constructed layer
    * @param {Function} epsgLookup   an optional lookup function for EPSG codes (see geoService for signature)
    * @returns {Object}              instantited WmsRecord class
    */
    return (config, esriLayer, epsgLookup) => {
        return new classBundle.WmsRecord(esriBundle.WmsLayer, geoApi, config, esriLayer, epsgLookup);
    };
}
/**
* Given 2D array in column x row format, check if all entries in the two given columns are numeric.
*
* @param {Array} arr is a 2D array based on the CSV file that contains row information for all of the rows
* @param {Integer} ind1 is a user specified index when uploading the CSV that specifies lat or long column (whichever isn't specified by ind2)
* @param {Integer} ind2 is a user specified index when uploading the CSV that specifies lat or long column (whichever isn't specified by ind1)
* @return {Boolean} returns true or false based on whether or not all all columns at ind1 and ind2 are numbers
*/
function validateLatLong(arr, ind1, ind2) {
    return arr.every(row => {
        return !(isNaN(row[ind1]) || isNaN(row[ind2]));
    });
}
// CAREFUL NOW!
// we are passing in a reference to geoApi.  it is a pointer to the object that contains this module,
// along with other modules. it lets us access other modules without re-instantiating them in here.
module.exports = function (esriBundle, geoApi) {
    const layerClassBundle = layerRecord(esriBundle, geoApi);
    return {
        ArcGISDynamicMapServiceLayer: esriBundle.ArcGISDynamicMapServiceLayer,
        ArcGISImageServiceLayer: esriBundle.ArcGISImageServiceLayer,
        GraphicsLayer: esriBundle.GraphicsLayer,
        FeatureLayer: esriBundle.FeatureLayer,
        ScreenPoint: esriBundle.ScreenPoint,
        Query: esriBundle.Query,
        TileLayer: esriBundle.ArcGISTiledMapServiceLayer,
        ogc: ogc(esriBundle),
        bbox: bbox(esriBundle, geoApi),
        createImageRecord: createImageRecordBuilder(esriBundle, geoApi, layerClassBundle),
        createWmsRecord: createWmsRecordBuilder(esriBundle, geoApi, layerClassBundle),
        createTileRecord: createTileRecordBuilder(esriBundle, geoApi, layerClassBundle),
        createDynamicRecord: createDynamicRecordBuilder(esriBundle, geoApi, layerClassBundle),
        createFeatureRecord: createFeatureRecordBuilder(esriBundle, geoApi, layerClassBundle),
        LayerDrawingOptions: esriBundle.LayerDrawingOptions,
        getFeatureInfo: getFeatureInfoBuilder(esriBundle),
        makeGeoJsonLayer: makeGeoJsonLayerBuilder(esriBundle, geoApi),
        makeCsvLayer: makeCsvLayerBuilder(esriBundle, geoApi),
        makeShapeLayer: makeShapeLayerBuilder(esriBundle, geoApi),
        serverLayerIdentify: serverLayerIdentifyBuilder(esriBundle),
        predictLayerUrl: predictLayerUrlBuilder(esriBundle),
        validateFile,
        csvPeek,
        serviceType,
        validateLatLong
    };
};