From 81845487ef68604e4e2a9e7bdef56a57f74240ef Mon Sep 17 00:00:00 2001 From: john gravois Date: Wed, 19 Apr 2017 16:31:50 -0700 Subject: [PATCH] build 2.0.2 --- dist/esri-leaflet-gp-debug.js | 339 ++++++++++++++++++++++++++++++++++ dist/esri-leaflet-gp.js | 2 + dist/esri-leaflet-gp.js.map | 1 + 3 files changed, 342 insertions(+) create mode 100644 dist/esri-leaflet-gp-debug.js create mode 100644 dist/esri-leaflet-gp.js create mode 100644 dist/esri-leaflet-gp.js.map diff --git a/dist/esri-leaflet-gp-debug.js b/dist/esri-leaflet-gp-debug.js new file mode 100644 index 0000000..d24403b --- /dev/null +++ b/dist/esri-leaflet-gp-debug.js @@ -0,0 +1,339 @@ +/* esri-leaflet-gp - v2.0.2 - Wed Apr 19 2017 16:31:50 GMT-0700 (PDT) + * Copyright (c) 2017 Environmental Systems Research Institute, Inc. + * Apache-2.0 */ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('leaflet'), require('esri-leaflet')) : + typeof define === 'function' && define.amd ? define(['exports', 'leaflet', 'esri-leaflet'], factory) : + (factory((global.L = global.L || {}, global.L.esri = global.L.esri || {}, global.L.esri.GP = global.L.esri.GP || {}),global.L,global.L.esri)); +}(this, function (exports,L,esriLeaflet) { 'use strict'; + + L = 'default' in L ? L['default'] : L; + + var version = "2.0.2"; + + var Task$1 = esriLeaflet.Task.extend({ + + includes: L.Evented.prototype, + + // setters: {}, we don't use these because we don't know the ParamName OR value of custom GP services + params: {}, + resultParams: {}, + + initialize: function (options) { + // don't replace parent initialize + esriLeaflet.Task.prototype.initialize.call(this, options); + + // if path isn't supplied in options, try and determine if its sync or async to set automatically + if (!this.options.path) { + // assume initially, that service is synchronous + this.options.async = false; + this.options.path = 'execute'; + + // the parameters below seem wonky to me, but work for both CORS and JSONP requests + this._service.metadata(function (error, results) { + if (!error) { + if (results.executionType === 'esriExecutionTypeSynchronous') { + this.options.async = false; + this.options.path = 'execute'; + } else { + this.options.async = true; + this.options.path = 'submitJob'; + } + this.fire('initialized'); + } else { + // if check fails, hopefully its synchronous + this.options.async = false; + this.options.path = 'execute'; + return; + } + }, this); + } else { + // if path is custom, hopefully its synchronous + if (this.options.async !== true && this.options.path !== 'submitJob') { + this.options.async = false; + } + } + }, + + // doc for various GPInput types can be found here + // http://resources.arcgis.com/en/help/arcgis-rest-api/index.html#/GP_Result/02r3000000q7000000/ + + // set booleans, numbers, strings + setParam: function (paramName, paramValue) { + if (typeof paramValue === 'boolean') { + this.params[paramName] = paramValue; + return; + } else if (typeof paramValue !== 'object') { // strings, numbers + this.params[paramName] = paramValue; + return; + } else if (typeof paramValue === 'object' && paramValue.units) { + // pass through GPLinearUnit params unmolested + this.params[paramName] = paramValue; + return; + } else { + // otherwise assume its latlng, marker, bounds or geojson + if (paramName === 'geometry') { + this.params[paramName] = this._setGeometry(paramValue); + } else { // package up an array of esri features if the parameter name is anything other than geometry + var esriFeatures = { + 'geometryType': this._setGeometryType(paramValue), + 'features': [] + }; + + if (paramValue.type === 'FeatureCollection') { + for (var i = 0; i < paramValue.features.length; i++) { + esriFeatures.features.push({'geometry': esriLeaflet.Util.geojsonToArcGIS(paramValue.features[i].geometry)}); + } + } else { + esriFeatures.features.push({'geometry': this._setGeometry(paramValue)}); + } + + this.params[paramName] = esriFeatures; + } + } + }, + + // give developer opportunity to point out where the output is going to be available + setOutputParam: function (paramName) { + this.params.outputParam = paramName; + }, + + /* async elevation services need resultParams in order to return Zs (unnecessarily confusing)*/ + gpAsyncResultParam: function (paramName, paramValue) { + this.resultParams[paramName] = paramValue; + }, + + // we currently expect a single geometry or feature (ported from: Tasks.Query._setGeometry) + _setGeometry: function (geometry) { + // convert bounds to extent and finish + if (geometry instanceof L.LatLngBounds) { + return L.esri.Util.boundsToExtent(geometry); + } + + // convert L.Marker > L.LatLng + if (geometry.getLatLng) { + geometry = geometry.getLatLng(); + } + + // convert L.LatLng to a geojson point and continue; + if (geometry instanceof L.LatLng) { + geometry = { + type: 'Point', + coordinates: [geometry.lng, geometry.lat] + }; + } + + // handle L.GeoJSON, pull out the first geometry + if (geometry instanceof L.GeoJSON) { + // reassign geometry to the GeoJSON value (we assume one feature is present) + geometry = geometry.getLayers()[0].feature.geometry; + // processedInput.geometryType = Util.geojsonTypeToArcGIS(geometry.type); + return esriLeaflet.Util.geojsonToArcGIS(geometry); + } + + // Handle L.Polyline and L.Polygon + if (geometry.toGeoJSON) { + geometry = geometry.toGeoJSON(); + } + + // handle GeoJSON feature by pulling out the geometry + if (geometry.type === 'Feature') { + // get the geometry of the geojson feature + geometry = geometry.geometry; + } + + // confirm that our GeoJSON is a point, line or polygon + if (geometry.type === 'Point' || geometry.type === 'LineString' || geometry.type === 'Polygon') { + return esriLeaflet.Util.geojsonToArcGIS(geometry); + // processedInput.geometryType = Util.geojsonTypeToArcGIS(geometry.type); + } else { + esriLeaflet.Util.warn('invalid geometry passed as GP input. Should be an L.LatLng, L.LatLngBounds, L.Marker or GeoJSON Point Line or Polygon object'); + } + }, + + _setGeometryType: function (geometry) { + if (geometry instanceof L.LatLngBounds) { + return 'esriGeometryEnvelope'; + } + + // convert L.Marker > L.LatLng + if (geometry.getLatLng || geometry instanceof L.LatLng) { + return 'esriGeometryPoint'; + } + + // handle L.GeoJSON, pull out the first geometry + if (geometry instanceof L.GeoJSON) { + geometry = geometry.getLayers()[0].feature.geometry; + return esriLeaflet.Util.geojsonTypeToArcGIS(geometry.type); + } + + // Handle L.Polyline and L.Polygon + if (geometry.toGeoJSON) { + geometry = geometry.toGeoJSON(); + } + + // handle GeoJSON feature by pulling out the geometry + if (geometry.type === 'Feature') { + // get the geometry of the geojson feature + geometry = geometry.geometry; + } + + // confirm that our GeoJSON is a point, line or polygon + if (geometry.type === 'Point' || geometry.type === 'LineString' || geometry.type === 'Polygon') { + return esriLeaflet.Util.geojsonTypeToArcGIS(geometry.type); + } else if (geometry.type === 'FeatureCollection') { + return esriLeaflet.Util.geojsonTypeToArcGIS(geometry.features[0].type); + } else { + return null; + } + }, + + run: function (callback, context) { + this._done = false; + + if (this.options.async === true) { + /* eslint-disable */ + this._service.request(this.options.path, this.params, function (error, response) { + this._currentJobId = response.jobId; + this.checkJob(this._currentJobId, callback, context); + }, this); + /* eslint-enable */ + } else { + return this._service.request(this.options.path, this.params, function (error, response) { + if (!error) { + if (response.results) { + callback.call(context, error, (response && this._processGPOutput(response)), response); + } else if (response.histograms) { + callback.call(context, error, response, response); + } else if (response.routes) { + callback.call(context, error, (response && this._processNetworkAnalystOutput(response)), response); + } + } else { + callback.call(context, error, null, null); + } + }, this); + } + }, + + checkJob: function (jobId, callback, context) { + var pollJob = function () { + /* eslint-disable */ + this._service.request('jobs/' + jobId, {}, function polledJob (error, response) { + if (response.jobStatus === 'esriJobSucceeded') { + if (!this._done) { + this._done = true; + // to do: + // refactor to make an array of async requests for output + this._service.request('jobs/' + jobId + '/results/' + this.params.outputParam, this.resultParams, function processJobResult (error, response) { + callback.call(context, error, (response && this._processAsyncOutput(response)), response); + }, this); + } + window.clearInterval(counter); + } else if (response.jobStatus === 'esriJobFailed') { + callback.call(context, 'Job Failed', null); + window.clearInterval(counter); + } + }, this); + /* eslint-enable */ + }.bind(this); + + var counter = window.setInterval(pollJob, this._service.options.asyncInterval * 1000); + }, + + _processGPOutput: function (response) { + var processedResponse = {}; + + var results = response.results; + // grab syncronous results + if (this.options.async === false) { + // loop through results and pass back, parsing esri json + for (var i = 0; i < results.length; i++) { + /* jshint ignore:start */ + processedResponse[results[i].paramName]; + /* jshint ignore:end */ + if (results[i].dataType === 'GPFeatureRecordSetLayer') { + var featureCollection = esriLeaflet.Util.responseToFeatureCollection(results[i].value); + processedResponse[results[i].paramName] = featureCollection; + } else { + processedResponse[results[i].paramName] = results[i].value; + } + } + } else { // grab async results slightly differently + processedResponse.jobId = this._currentJobId; + // var responseValue = response.value; + } + + // if output is a raster layer, we also need to stub out a MapService url using jobid + if (this.options.async === true && response.dataType === 'GPRasterDataLayer') { + var baseURL = this.options.url; + var n = baseURL.indexOf('GPServer'); + var serviceURL = baseURL.slice(0, n) + 'MapServer/'; + processedResponse.outputMapService = serviceURL + 'jobs/' + this._currentJobId; + } + + return processedResponse; + }, + + _processNetworkAnalystOutput: function (response) { + var processedResponse = {}; + + if (response.routes.features.length > 0) { + var featureCollection = esriLeaflet.Util.responseToFeatureCollection(response.routes); + processedResponse.routes = featureCollection; + } + + return processedResponse; + }, + + _processAsyncOutput: function (response) { + var processedResponse = {}; + processedResponse.jobId = this._currentJobId; + + // if output is a raster layer, we also need to stub out a MapService url using jobid + if (this.options.async === true && response.dataType === 'GPRasterDataLayer') { + var baseURL = this.options.url; + var n = baseURL.indexOf('GPServer'); + var serviceURL = baseURL.slice(0, n) + 'MapServer/'; + processedResponse.outputMapService = serviceURL + 'jobs/' + this._currentJobId; + } + + // if output is GPFeatureRecordSetLayer, convert to GeoJSON + if (response.dataType === 'GPFeatureRecordSetLayer') { + var featureCollection = esriLeaflet.Util.responseToFeatureCollection(response.value); + processedResponse[response.paramName] = featureCollection; + } else { + processedResponse[response.paramName] = response.value; + } + + return processedResponse; + } + + }); + + function task (options) { + return new Task$1(options); + } + + var Service$1 = esriLeaflet.Service.extend({ + options: { + asyncInterval: 1 + }, + + createTask: function () { + return new Task$1(this, this.options); + } + + }); + + function service (options) { + return new Service$1(options); + } + + exports.VERSION = version; + exports.Task = Task$1; + exports.task = task; + exports.Service = Service$1; + exports.service = service; + +})); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"esri-leaflet-gp-debug.js","sources":["../package.json","../src/Tasks/Geoprocessing.js","../src/Services/Geoprocessing.js"],"sourcesContent":["{\n  \"name\": \"esri-leaflet-gp\",\n  \"description\": \"A Leaflet plugin for interacting with ArcGIS geoprocessing services.\",\n  \"version\": \"2.0.2\",\n  \"author\": \"John Gravois <jgravois@esri.com> (http://johngravois.com)\",\n  \"browser\": \"dist/esri-leaflet-gp-debug.js\",\n  \"bugs\": {\n    \"url\": \"https://github.com/jgravois/esri-leaflet-gp/issues\"\n  },\n  \"contributors\": [\n    \"John Gravois <jgravois@esri.com> (http://johngravois.com)\",\n    \"Nicholas Furness <nfurness@esri.com> (http://nixta.github.io/)\",\n    \"Patrick Arlt <parlt@esri.com> (http://patrickarlt.com)\",\n    \"Rowan Winsemius\"\n  ],\n  \"dependencies\": {\n    \"leaflet\": \"^1.0.0\",\n    \"esri-leaflet\": \"^2.0.0\"\n  },\n  \"devDependencies\": {\n    \"chai\": \"2.3.0\",\n    \"gh-release\": \"^2.0.0\",\n    \"highlight.js\": \"^8.0.0\",\n    \"http-server\": \"^0.8.5\",\n    \"isparta\": \"^3.0.3\",\n    \"istanbul\": \"^0.4.2\",\n    \"karma\": \"^0.12.24\",\n    \"karma-chai-sinon\": \"^0.1.3\",\n    \"karma-coverage\": \"^0.5.3\",\n    \"karma-mocha\": \"^0.1.0\",\n    \"karma-mocha-reporter\": \"^0.2.5\",\n    \"karma-phantomjs-launcher\": \"^0.2.0\",\n    \"karma-sourcemap-loader\": \"^0.3.5\",\n    \"mkdirp\": \"^0.5.1\",\n    \"phantomjs\": \"^1.9.17\",\n    \"rollup\": \"^0.25.4\",\n    \"rollup-plugin-json\": \"^2.0.0\",\n    \"rollup-plugin-node-resolve\": \"^1.4.0\",\n    \"rollup-plugin-uglify\": \"^0.1.0\",\n    \"semistandard\": \"^7.0.5\",\n    \"sinon\": \"^1.11.1\",\n    \"sinon-chai\": \"2.7.0\",\n    \"snazzy\": \"^2.0.1\",\n    \"uglify-js\": \"^2.6.1\",\n    \"watch\": \"^0.17.1\"\n  },\n  \"homepage\": \"https://github.com/jgravois/esri-leaflet-gp\",\n  \"jsnext:main\": \"src/EsriLeafletGP.js\",\n  \"jspm\": {\n    \"registry\": \"npm\",\n    \"format\": \"es6\",\n    \"main\": \"src/EsriLeafletGP.js\"\n  },\n  \"license\": \"Apache-2.0\",\n  \"main\": \"dist/esri-leaflet-gp-debug.js\",\n  \"readmeFilename\": \"README.md\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/jgravois/esri-leaflet-gp.git\"\n  },\n  \"scripts\": {\n    \"prebuild\": \"mkdirp dist\",\n    \"build\": \"rollup -c profiles/debug.js & rollup -c profiles/production.js\",\n    \"lint\": \"semistandard src/**/*.js | snazzy\",\n    \"prepublish\": \"npm run build\",\n    \"pretest\": \"npm run build\",\n    \"test\": \"npm run lint && karma start\",\n    \"release\": \"./scripts/release.sh\",\n    \"start\": \"watch 'npm run build' src & http-server -p 5000 -c-1 -o\"\n  }\n}\n","/*\nto do:\nsetParam([])\n*/\n\nimport L from 'leaflet';\nimport { Task as BaseTask, Util } from 'esri-leaflet';\n\nexport var Task = BaseTask.extend({\n\n  includes: L.Evented.prototype,\n\n  // setters: {}, we don't use these because we don't know the ParamName OR value of custom GP services\n  params: {},\n  resultParams: {},\n\n  initialize: function (options) {\n    // don't replace parent initialize\n    BaseTask.prototype.initialize.call(this, options);\n\n    // if path isn't supplied in options, try and determine if its sync or async to set automatically\n    if (!this.options.path) {\n      // assume initially, that service is synchronous\n      this.options.async = false;\n      this.options.path = 'execute';\n\n      // the parameters below seem wonky to me, but work for both CORS and JSONP requests\n      this._service.metadata(function (error, results) {\n        if (!error) {\n          if (results.executionType === 'esriExecutionTypeSynchronous') {\n            this.options.async = false;\n            this.options.path = 'execute';\n          } else {\n            this.options.async = true;\n            this.options.path = 'submitJob';\n          }\n          this.fire('initialized');\n        } else {\n          // if check fails, hopefully its synchronous\n          this.options.async = false;\n          this.options.path = 'execute';\n          return;\n        }\n      }, this);\n    } else {\n      // if path is custom, hopefully its synchronous\n      if (this.options.async !== true && this.options.path !== 'submitJob') {\n        this.options.async = false;\n      }\n    }\n  },\n\n  // doc for various GPInput types can be found here\n  // http://resources.arcgis.com/en/help/arcgis-rest-api/index.html#/GP_Result/02r3000000q7000000/\n\n  // set booleans, numbers, strings\n  setParam: function (paramName, paramValue) {\n    if (typeof paramValue === 'boolean') {\n      this.params[paramName] = paramValue;\n      return;\n    } else if (typeof paramValue !== 'object') { // strings, numbers\n      this.params[paramName] = paramValue;\n      return;\n    } else if (typeof paramValue === 'object' && paramValue.units) {\n      // pass through GPLinearUnit params unmolested\n      this.params[paramName] = paramValue;\n      return;\n    } else {\n      // otherwise assume its latlng, marker, bounds or geojson\n      if (paramName === 'geometry') {\n        this.params[paramName] = this._setGeometry(paramValue);\n      } else { // package up an array of esri features if the parameter name is anything other than geometry\n        var esriFeatures = {\n          'geometryType': this._setGeometryType(paramValue),\n          'features': []\n        };\n\n        if (paramValue.type === 'FeatureCollection') {\n          for (var i = 0; i < paramValue.features.length; i++) {\n            esriFeatures.features.push({'geometry': Util.geojsonToArcGIS(paramValue.features[i].geometry)});\n          }\n        } else {\n          esriFeatures.features.push({'geometry': this._setGeometry(paramValue)});\n        }\n\n        this.params[paramName] = esriFeatures;\n      }\n    }\n  },\n\n  // give developer opportunity to point out where the output is going to be available\n  setOutputParam: function (paramName) {\n    this.params.outputParam = paramName;\n  },\n\n  /* async elevation services need resultParams in order to return Zs (unnecessarily confusing)*/\n  gpAsyncResultParam: function (paramName, paramValue) {\n    this.resultParams[paramName] = paramValue;\n  },\n\n  // we currently expect a single geometry or feature (ported from: Tasks.Query._setGeometry)\n  _setGeometry: function (geometry) {\n    // convert bounds to extent and finish\n    if (geometry instanceof L.LatLngBounds) {\n      return L.esri.Util.boundsToExtent(geometry);\n    }\n\n    // convert L.Marker > L.LatLng\n    if (geometry.getLatLng) {\n      geometry = geometry.getLatLng();\n    }\n\n    // convert L.LatLng to a geojson point and continue;\n    if (geometry instanceof L.LatLng) {\n      geometry = {\n        type: 'Point',\n        coordinates: [geometry.lng, geometry.lat]\n      };\n    }\n\n    // handle L.GeoJSON, pull out the first geometry\n    if (geometry instanceof L.GeoJSON) {\n      // reassign geometry to the GeoJSON value  (we assume one feature is present)\n      geometry = geometry.getLayers()[0].feature.geometry;\n      // processedInput.geometryType = Util.geojsonTypeToArcGIS(geometry.type);\n      return Util.geojsonToArcGIS(geometry);\n    }\n\n    // Handle L.Polyline and L.Polygon\n    if (geometry.toGeoJSON) {\n      geometry = geometry.toGeoJSON();\n    }\n\n    // handle GeoJSON feature by pulling out the geometry\n    if (geometry.type === 'Feature') {\n      // get the geometry of the geojson feature\n      geometry = geometry.geometry;\n    }\n\n    // confirm that our GeoJSON is a point, line or polygon\n    if (geometry.type === 'Point' || geometry.type === 'LineString' || geometry.type === 'Polygon') {\n      return Util.geojsonToArcGIS(geometry);\n      // processedInput.geometryType = Util.geojsonTypeToArcGIS(geometry.type);\n    } else {\n      Util.warn('invalid geometry passed as GP input. Should be an L.LatLng, L.LatLngBounds, L.Marker or GeoJSON Point Line or Polygon object');\n    }\n  },\n\n  _setGeometryType: function (geometry) {\n    if (geometry instanceof L.LatLngBounds) {\n      return 'esriGeometryEnvelope';\n    }\n\n    // convert L.Marker > L.LatLng\n    if (geometry.getLatLng || geometry instanceof L.LatLng) {\n      return 'esriGeometryPoint';\n    }\n\n    // handle L.GeoJSON, pull out the first geometry\n    if (geometry instanceof L.GeoJSON) {\n      geometry = geometry.getLayers()[0].feature.geometry;\n      return Util.geojsonTypeToArcGIS(geometry.type);\n    }\n\n    // Handle L.Polyline and L.Polygon\n    if (geometry.toGeoJSON) {\n      geometry = geometry.toGeoJSON();\n    }\n\n    // handle GeoJSON feature by pulling out the geometry\n    if (geometry.type === 'Feature') {\n      // get the geometry of the geojson feature\n      geometry = geometry.geometry;\n    }\n\n    // confirm that our GeoJSON is a point, line or polygon\n    if (geometry.type === 'Point' || geometry.type === 'LineString' || geometry.type === 'Polygon') {\n      return Util.geojsonTypeToArcGIS(geometry.type);\n    } else if (geometry.type === 'FeatureCollection') {\n      return Util.geojsonTypeToArcGIS(geometry.features[0].type);\n    } else {\n      return null;\n    }\n  },\n\n  run: function (callback, context) {\n    this._done = false;\n\n    if (this.options.async === true) {\n      /* eslint-disable */\n      this._service.request(this.options.path, this.params, function (error, response) {\n        this._currentJobId = response.jobId;\n        this.checkJob(this._currentJobId, callback, context);\n      }, this);\n      /* eslint-enable */\n    } else {\n      return this._service.request(this.options.path, this.params, function (error, response) {\n        if (!error) {\n          if (response.results) {\n            callback.call(context, error, (response && this._processGPOutput(response)), response);\n          } else if (response.histograms) {\n            callback.call(context, error, response, response);\n          } else if (response.routes) {\n            callback.call(context, error, (response && this._processNetworkAnalystOutput(response)), response);\n          }\n        } else {\n          callback.call(context, error, null, null);\n        }\n      }, this);\n    }\n  },\n\n  checkJob: function (jobId, callback, context) {\n    var pollJob = function () {\n      /* eslint-disable */\n      this._service.request('jobs/' + jobId, {}, function polledJob (error, response) {\n        if (response.jobStatus === 'esriJobSucceeded') {\n          if (!this._done) {\n            this._done = true;\n            // to do:\n            // refactor to make an array of async requests for output\n            this._service.request('jobs/' + jobId + '/results/' + this.params.outputParam, this.resultParams, function processJobResult (error, response) {\n              callback.call(context, error, (response && this._processAsyncOutput(response)), response);\n            }, this);\n          }\n          window.clearInterval(counter);\n        } else if (response.jobStatus === 'esriJobFailed') {\n          callback.call(context, 'Job Failed', null);\n          window.clearInterval(counter);\n        }\n      }, this);\n      /* eslint-enable */\n    }.bind(this);\n\n    var counter = window.setInterval(pollJob, this._service.options.asyncInterval * 1000);\n  },\n\n  _processGPOutput: function (response) {\n    var processedResponse = {};\n\n    var results = response.results;\n    // grab syncronous results\n    if (this.options.async === false) {\n      // loop through results and pass back, parsing esri json\n      for (var i = 0; i < results.length; i++) {\n        /* jshint ignore:start */\n        processedResponse[results[i].paramName];\n        /* jshint ignore:end */\n        if (results[i].dataType === 'GPFeatureRecordSetLayer') {\n          var featureCollection = Util.responseToFeatureCollection(results[i].value);\n          processedResponse[results[i].paramName] = featureCollection;\n        } else {\n          processedResponse[results[i].paramName] = results[i].value;\n        }\n      }\n    } else { // grab async results slightly differently\n      processedResponse.jobId = this._currentJobId;\n      // var responseValue = response.value;\n    }\n\n    // if output is a raster layer, we also need to stub out a MapService url using jobid\n    if (this.options.async === true && response.dataType === 'GPRasterDataLayer') {\n      var baseURL = this.options.url;\n      var n = baseURL.indexOf('GPServer');\n      var serviceURL = baseURL.slice(0, n) + 'MapServer/';\n      processedResponse.outputMapService = serviceURL + 'jobs/' + this._currentJobId;\n    }\n\n    return processedResponse;\n  },\n\n  _processNetworkAnalystOutput: function (response) {\n    var processedResponse = {};\n\n    if (response.routes.features.length > 0) {\n      var featureCollection = Util.responseToFeatureCollection(response.routes);\n      processedResponse.routes = featureCollection;\n    }\n\n    return processedResponse;\n  },\n\n  _processAsyncOutput: function (response) {\n    var processedResponse = {};\n    processedResponse.jobId = this._currentJobId;\n\n    // if output is a raster layer, we also need to stub out a MapService url using jobid\n    if (this.options.async === true && response.dataType === 'GPRasterDataLayer') {\n      var baseURL = this.options.url;\n      var n = baseURL.indexOf('GPServer');\n      var serviceURL = baseURL.slice(0, n) + 'MapServer/';\n      processedResponse.outputMapService = serviceURL + 'jobs/' + this._currentJobId;\n    }\n\n    // if output is GPFeatureRecordSetLayer, convert to GeoJSON\n    if (response.dataType === 'GPFeatureRecordSetLayer') {\n      var featureCollection = Util.responseToFeatureCollection(response.value);\n      processedResponse[response.paramName] = featureCollection;\n    } else {\n      processedResponse[response.paramName] = response.value;\n    }\n\n    return processedResponse;\n  }\n\n});\n\nexport function task (options) {\n  return new Task(options);\n}\n\nexport default task;\n","import { Service as BaseService } from 'esri-leaflet';\nimport { Task } from '../Tasks/Geoprocessing';\n\nexport var Service = BaseService.extend({\n  options: {\n    asyncInterval: 1\n  },\n\n  createTask: function () {\n    return new Task(this, this.options);\n  }\n\n});\n\nexport function service (options) {\n  return new Service(options);\n}\n\nexport default service;\n"],"names":["Task","BaseTask","Util","Service","BaseService"],"mappings":"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"} \ No newline at end of file diff --git a/dist/esri-leaflet-gp.js b/dist/esri-leaflet-gp.js new file mode 100644 index 0000000..48e776b --- /dev/null +++ b/dist/esri-leaflet-gp.js @@ -0,0 +1,2 @@ +!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("leaflet"),require("esri-leaflet")):"function"==typeof define&&define.amd?define(["exports","leaflet","esri-leaflet"],t):t((e.L=e.L||{},e.L.esri=e.L.esri||{},e.L.esri.GP=e.L.esri.GP||{}),e.L,e.L.esri)}(this,function(e,t,s){"use strict";function o(e){return new r(e)}function i(e){return new n(e)}t="default"in t?t.default:t;var r=s.Task.extend({includes:t.Evented.prototype,params:{},resultParams:{},initialize:function(e){s.Task.prototype.initialize.call(this,e),this.options.path?!0!==this.options.async&&"submitJob"!==this.options.path&&(this.options.async=!1):(this.options.async=!1,this.options.path="execute",this._service.metadata(function(e,t){if(e)return this.options.async=!1,void(this.options.path="execute");"esriExecutionTypeSynchronous"===t.executionType?(this.options.async=!1,this.options.path="execute"):(this.options.async=!0,this.options.path="submitJob"),this.fire("initialized")},this))},setParam:function(e,t){if("boolean"==typeof t)return void(this.params[e]=t);if("object"!=typeof t)return void(this.params[e]=t);if("object"==typeof t&&t.units)return void(this.params[e]=t);if("geometry"===e)this.params[e]=this._setGeometry(t);else{var o={geometryType:this._setGeometryType(t),features:[]};if("FeatureCollection"===t.type)for(var i=0;i0){var o=s.Util.responseToFeatureCollection(e.routes);t.routes=o}return t},_processAsyncOutput:function(e){var t={};if(t.jobId=this._currentJobId,!0===this.options.async&&"GPRasterDataLayer"===e.dataType){var o=this.options.url,i=o.indexOf("GPServer"),r=o.slice(0,i)+"MapServer/";t.outputMapService=r+"jobs/"+this._currentJobId}if("GPFeatureRecordSetLayer"===e.dataType){var n=s.Util.responseToFeatureCollection(e.value);t[e.paramName]=n}else t[e.paramName]=e.value;return t}}),n=s.Service.extend({options:{asyncInterval:1},createTask:function(){return new r(this,this.options)}});e.VERSION="2.0.2",e.Task=r,e.task=o,e.Service=n,e.service=i}); +//# sourceMappingURL=esri-leaflet-gp.js.map \ No newline at end of file diff --git a/dist/esri-leaflet-gp.js.map b/dist/esri-leaflet-gp.js.map new file mode 100644 index 0000000..cf1730f --- /dev/null +++ b/dist/esri-leaflet-gp.js.map @@ -0,0 +1 @@ +{"version":3,"file":"esri-leaflet-gp.js","sources":["../package.json","../src/Tasks/Geoprocessing.js","../src/Services/Geoprocessing.js"],"sourcesContent":["{\n \"name\": \"esri-leaflet-gp\",\n \"description\": \"A Leaflet plugin for interacting with ArcGIS geoprocessing services.\",\n \"version\": \"2.0.2\",\n \"author\": \"John Gravois (http://johngravois.com)\",\n \"browser\": \"dist/esri-leaflet-gp-debug.js\",\n \"bugs\": {\n \"url\": \"https://github.com/jgravois/esri-leaflet-gp/issues\"\n },\n \"contributors\": [\n \"John Gravois (http://johngravois.com)\",\n \"Nicholas Furness (http://nixta.github.io/)\",\n \"Patrick Arlt (http://patrickarlt.com)\",\n \"Rowan Winsemius\"\n ],\n \"dependencies\": {\n \"leaflet\": \"^1.0.0\",\n \"esri-leaflet\": \"^2.0.0\"\n },\n \"devDependencies\": {\n \"chai\": \"2.3.0\",\n \"gh-release\": \"^2.0.0\",\n \"highlight.js\": \"^8.0.0\",\n \"http-server\": \"^0.8.5\",\n \"isparta\": \"^3.0.3\",\n \"istanbul\": \"^0.4.2\",\n \"karma\": \"^0.12.24\",\n \"karma-chai-sinon\": \"^0.1.3\",\n \"karma-coverage\": \"^0.5.3\",\n \"karma-mocha\": \"^0.1.0\",\n \"karma-mocha-reporter\": \"^0.2.5\",\n \"karma-phantomjs-launcher\": \"^0.2.0\",\n \"karma-sourcemap-loader\": \"^0.3.5\",\n \"mkdirp\": \"^0.5.1\",\n \"phantomjs\": \"^1.9.17\",\n \"rollup\": \"^0.25.4\",\n \"rollup-plugin-json\": \"^2.0.0\",\n \"rollup-plugin-node-resolve\": \"^1.4.0\",\n \"rollup-plugin-uglify\": \"^0.1.0\",\n \"semistandard\": \"^7.0.5\",\n \"sinon\": \"^1.11.1\",\n \"sinon-chai\": \"2.7.0\",\n \"snazzy\": \"^2.0.1\",\n \"uglify-js\": \"^2.6.1\",\n \"watch\": \"^0.17.1\"\n },\n \"homepage\": \"https://github.com/jgravois/esri-leaflet-gp\",\n \"jsnext:main\": \"src/EsriLeafletGP.js\",\n \"jspm\": {\n \"registry\": \"npm\",\n \"format\": \"es6\",\n \"main\": \"src/EsriLeafletGP.js\"\n },\n \"license\": \"Apache-2.0\",\n \"main\": \"dist/esri-leaflet-gp-debug.js\",\n \"readmeFilename\": \"README.md\",\n \"repository\": {\n \"type\": \"git\",\n \"url\": \"https://github.com/jgravois/esri-leaflet-gp.git\"\n },\n \"scripts\": {\n \"prebuild\": \"mkdirp dist\",\n \"build\": \"rollup -c profiles/debug.js & rollup -c profiles/production.js\",\n \"lint\": \"semistandard src/**/*.js | snazzy\",\n \"prepublish\": \"npm run build\",\n \"pretest\": \"npm run build\",\n \"test\": \"npm run lint && karma start\",\n \"release\": \"./scripts/release.sh\",\n \"start\": \"watch 'npm run build' src & http-server -p 5000 -c-1 -o\"\n }\n}\n","/*\nto do:\nsetParam([])\n*/\n\nimport L from 'leaflet';\nimport { Task as BaseTask, Util } from 'esri-leaflet';\n\nexport var Task = BaseTask.extend({\n\n includes: L.Evented.prototype,\n\n // setters: {}, we don't use these because we don't know the ParamName OR value of custom GP services\n params: {},\n resultParams: {},\n\n initialize: function (options) {\n // don't replace parent initialize\n BaseTask.prototype.initialize.call(this, options);\n\n // if path isn't supplied in options, try and determine if its sync or async to set automatically\n if (!this.options.path) {\n // assume initially, that service is synchronous\n this.options.async = false;\n this.options.path = 'execute';\n\n // the parameters below seem wonky to me, but work for both CORS and JSONP requests\n this._service.metadata(function (error, results) {\n if (!error) {\n if (results.executionType === 'esriExecutionTypeSynchronous') {\n this.options.async = false;\n this.options.path = 'execute';\n } else {\n this.options.async = true;\n this.options.path = 'submitJob';\n }\n this.fire('initialized');\n } else {\n // if check fails, hopefully its synchronous\n this.options.async = false;\n this.options.path = 'execute';\n return;\n }\n }, this);\n } else {\n // if path is custom, hopefully its synchronous\n if (this.options.async !== true && this.options.path !== 'submitJob') {\n this.options.async = false;\n }\n }\n },\n\n // doc for various GPInput types can be found here\n // http://resources.arcgis.com/en/help/arcgis-rest-api/index.html#/GP_Result/02r3000000q7000000/\n\n // set booleans, numbers, strings\n setParam: function (paramName, paramValue) {\n if (typeof paramValue === 'boolean') {\n this.params[paramName] = paramValue;\n return;\n } else if (typeof paramValue !== 'object') { // strings, numbers\n this.params[paramName] = paramValue;\n return;\n } else if (typeof paramValue === 'object' && paramValue.units) {\n // pass through GPLinearUnit params unmolested\n this.params[paramName] = paramValue;\n return;\n } else {\n // otherwise assume its latlng, marker, bounds or geojson\n if (paramName === 'geometry') {\n this.params[paramName] = this._setGeometry(paramValue);\n } else { // package up an array of esri features if the parameter name is anything other than geometry\n var esriFeatures = {\n 'geometryType': this._setGeometryType(paramValue),\n 'features': []\n };\n\n if (paramValue.type === 'FeatureCollection') {\n for (var i = 0; i < paramValue.features.length; i++) {\n esriFeatures.features.push({'geometry': Util.geojsonToArcGIS(paramValue.features[i].geometry)});\n }\n } else {\n esriFeatures.features.push({'geometry': this._setGeometry(paramValue)});\n }\n\n this.params[paramName] = esriFeatures;\n }\n }\n },\n\n // give developer opportunity to point out where the output is going to be available\n setOutputParam: function (paramName) {\n this.params.outputParam = paramName;\n },\n\n /* async elevation services need resultParams in order to return Zs (unnecessarily confusing)*/\n gpAsyncResultParam: function (paramName, paramValue) {\n this.resultParams[paramName] = paramValue;\n },\n\n // we currently expect a single geometry or feature (ported from: Tasks.Query._setGeometry)\n _setGeometry: function (geometry) {\n // convert bounds to extent and finish\n if (geometry instanceof L.LatLngBounds) {\n return L.esri.Util.boundsToExtent(geometry);\n }\n\n // convert L.Marker > L.LatLng\n if (geometry.getLatLng) {\n geometry = geometry.getLatLng();\n }\n\n // convert L.LatLng to a geojson point and continue;\n if (geometry instanceof L.LatLng) {\n geometry = {\n type: 'Point',\n coordinates: [geometry.lng, geometry.lat]\n };\n }\n\n // handle L.GeoJSON, pull out the first geometry\n if (geometry instanceof L.GeoJSON) {\n // reassign geometry to the GeoJSON value (we assume one feature is present)\n geometry = geometry.getLayers()[0].feature.geometry;\n // processedInput.geometryType = Util.geojsonTypeToArcGIS(geometry.type);\n return Util.geojsonToArcGIS(geometry);\n }\n\n // Handle L.Polyline and L.Polygon\n if (geometry.toGeoJSON) {\n geometry = geometry.toGeoJSON();\n }\n\n // handle GeoJSON feature by pulling out the geometry\n if (geometry.type === 'Feature') {\n // get the geometry of the geojson feature\n geometry = geometry.geometry;\n }\n\n // confirm that our GeoJSON is a point, line or polygon\n if (geometry.type === 'Point' || geometry.type === 'LineString' || geometry.type === 'Polygon') {\n return Util.geojsonToArcGIS(geometry);\n // processedInput.geometryType = Util.geojsonTypeToArcGIS(geometry.type);\n } else {\n Util.warn('invalid geometry passed as GP input. Should be an L.LatLng, L.LatLngBounds, L.Marker or GeoJSON Point Line or Polygon object');\n }\n },\n\n _setGeometryType: function (geometry) {\n if (geometry instanceof L.LatLngBounds) {\n return 'esriGeometryEnvelope';\n }\n\n // convert L.Marker > L.LatLng\n if (geometry.getLatLng || geometry instanceof L.LatLng) {\n return 'esriGeometryPoint';\n }\n\n // handle L.GeoJSON, pull out the first geometry\n if (geometry instanceof L.GeoJSON) {\n geometry = geometry.getLayers()[0].feature.geometry;\n return Util.geojsonTypeToArcGIS(geometry.type);\n }\n\n // Handle L.Polyline and L.Polygon\n if (geometry.toGeoJSON) {\n geometry = geometry.toGeoJSON();\n }\n\n // handle GeoJSON feature by pulling out the geometry\n if (geometry.type === 'Feature') {\n // get the geometry of the geojson feature\n geometry = geometry.geometry;\n }\n\n // confirm that our GeoJSON is a point, line or polygon\n if (geometry.type === 'Point' || geometry.type === 'LineString' || geometry.type === 'Polygon') {\n return Util.geojsonTypeToArcGIS(geometry.type);\n } else if (geometry.type === 'FeatureCollection') {\n return Util.geojsonTypeToArcGIS(geometry.features[0].type);\n } else {\n return null;\n }\n },\n\n run: function (callback, context) {\n this._done = false;\n\n if (this.options.async === true) {\n /* eslint-disable */\n this._service.request(this.options.path, this.params, function (error, response) {\n this._currentJobId = response.jobId;\n this.checkJob(this._currentJobId, callback, context);\n }, this);\n /* eslint-enable */\n } else {\n return this._service.request(this.options.path, this.params, function (error, response) {\n if (!error) {\n if (response.results) {\n callback.call(context, error, (response && this._processGPOutput(response)), response);\n } else if (response.histograms) {\n callback.call(context, error, response, response);\n } else if (response.routes) {\n callback.call(context, error, (response && this._processNetworkAnalystOutput(response)), response);\n }\n } else {\n callback.call(context, error, null, null);\n }\n }, this);\n }\n },\n\n checkJob: function (jobId, callback, context) {\n var pollJob = function () {\n /* eslint-disable */\n this._service.request('jobs/' + jobId, {}, function polledJob (error, response) {\n if (response.jobStatus === 'esriJobSucceeded') {\n if (!this._done) {\n this._done = true;\n // to do:\n // refactor to make an array of async requests for output\n this._service.request('jobs/' + jobId + '/results/' + this.params.outputParam, this.resultParams, function processJobResult (error, response) {\n callback.call(context, error, (response && this._processAsyncOutput(response)), response);\n }, this);\n }\n window.clearInterval(counter);\n } else if (response.jobStatus === 'esriJobFailed') {\n callback.call(context, 'Job Failed', null);\n window.clearInterval(counter);\n }\n }, this);\n /* eslint-enable */\n }.bind(this);\n\n var counter = window.setInterval(pollJob, this._service.options.asyncInterval * 1000);\n },\n\n _processGPOutput: function (response) {\n var processedResponse = {};\n\n var results = response.results;\n // grab syncronous results\n if (this.options.async === false) {\n // loop through results and pass back, parsing esri json\n for (var i = 0; i < results.length; i++) {\n /* jshint ignore:start */\n processedResponse[results[i].paramName];\n /* jshint ignore:end */\n if (results[i].dataType === 'GPFeatureRecordSetLayer') {\n var featureCollection = Util.responseToFeatureCollection(results[i].value);\n processedResponse[results[i].paramName] = featureCollection;\n } else {\n processedResponse[results[i].paramName] = results[i].value;\n }\n }\n } else { // grab async results slightly differently\n processedResponse.jobId = this._currentJobId;\n // var responseValue = response.value;\n }\n\n // if output is a raster layer, we also need to stub out a MapService url using jobid\n if (this.options.async === true && response.dataType === 'GPRasterDataLayer') {\n var baseURL = this.options.url;\n var n = baseURL.indexOf('GPServer');\n var serviceURL = baseURL.slice(0, n) + 'MapServer/';\n processedResponse.outputMapService = serviceURL + 'jobs/' + this._currentJobId;\n }\n\n return processedResponse;\n },\n\n _processNetworkAnalystOutput: function (response) {\n var processedResponse = {};\n\n if (response.routes.features.length > 0) {\n var featureCollection = Util.responseToFeatureCollection(response.routes);\n processedResponse.routes = featureCollection;\n }\n\n return processedResponse;\n },\n\n _processAsyncOutput: function (response) {\n var processedResponse = {};\n processedResponse.jobId = this._currentJobId;\n\n // if output is a raster layer, we also need to stub out a MapService url using jobid\n if (this.options.async === true && response.dataType === 'GPRasterDataLayer') {\n var baseURL = this.options.url;\n var n = baseURL.indexOf('GPServer');\n var serviceURL = baseURL.slice(0, n) + 'MapServer/';\n processedResponse.outputMapService = serviceURL + 'jobs/' + this._currentJobId;\n }\n\n // if output is GPFeatureRecordSetLayer, convert to GeoJSON\n if (response.dataType === 'GPFeatureRecordSetLayer') {\n var featureCollection = Util.responseToFeatureCollection(response.value);\n processedResponse[response.paramName] = featureCollection;\n } else {\n processedResponse[response.paramName] = response.value;\n }\n\n return processedResponse;\n }\n\n});\n\nexport function task (options) {\n return new Task(options);\n}\n\nexport default task;\n","import { Service as BaseService } from 'esri-leaflet';\nimport { Task } from '../Tasks/Geoprocessing';\n\nexport var Service = BaseService.extend({\n options: {\n asyncInterval: 1\n },\n\n createTask: function () {\n return new Task(this, this.options);\n }\n\n});\n\nexport function service (options) {\n return new Service(options);\n}\n\nexport default service;\n"],"names":["task","options","Task","service","Service","BaseTask","extend","includes","L","Evented","prototype","params","resultParams","initialize","call","this","path","async","_service","metadata","error","results","executionType","fire","setParam","paramName","paramValue","units","_setGeometry","esriFeatures","geometryType","_setGeometryType","features","type","i","length","push","geometry","Util","geojsonToArcGIS","setOutputParam","outputParam","gpAsyncResultParam","LatLngBounds","esri","boundsToExtent","getLatLng","LatLng","coordinates","lng","lat","GeoJSON","getLayers","feature","toGeoJSON","warn","geojsonTypeToArcGIS","run","callback","context","_done","request","response","_processGPOutput","histograms","routes","_processNetworkAnalystOutput","_currentJobId","jobId","checkJob","pollJob","jobStatus","_processAsyncOutput","window","clearInterval","counter","bind","setInterval","asyncInterval","processedResponse","dataType","featureCollection","responseToFeatureCollection","value","baseURL","url","n","indexOf","serviceURL","slice","outputMapService","BaseService","createTask"],"mappings":"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"} \ No newline at end of file