Source: OverpassFrontend.js

  1. const ee = require('event-emitter')
  2. const async = require('async')
  3. const weightSort = require('weight-sort')
  4. const BoundingBox = require('boundingbox')
  5. const LokiJS = require('lokijs')
  7. const httpLoad = require('./httpLoad')
  8. const removeNullEntries = require('./removeNullEntries')
  10. const BBoxQueryCache = require('./BBoxQueryCache')
  11. const OverpassObject = require('./OverpassObject')
  12. const OverpassNode = require('./OverpassNode')
  13. const OverpassWay = require('./OverpassWay')
  14. const OverpassRelation = require('./OverpassRelation')
  15. const RequestGet = require('./RequestGet')
  16. const RequestBBox = require('./RequestBBox')
  17. const RequestMulti = require('./RequestMulti')
  18. const defines = require('./defines')
  19. const loadFile = require('./loadFile')
  20. const copyOsm3sMetaFrom = require('./copyOsm3sMeta')
  21. const timestamp = require('./timestamp')
  22. const Filter = require('./Filter')
  23. const isGeoJSON = require('./isGeoJSON')
  24. const boundsIsFullWorld = require('./boundsIsFullWorld')
  25. const isFileURL = require('./isFileURL')
  27. /**
  28.  * An error occured
  29.  * @event OverpassFrontend#error
  30.  * @param {Error} error
  31.  * @param {OverpassFrontend#Context} [context] - context of the request
  32.  */
  34. /**
  35.  * A request to Overpass API is started
  36.  * @event OverpassFrontend#start
  37.  * @param {object} reserved
  38.  * @param {OverpassFrontend#Context} context - context of the request
  39.  */
  41. /**
  42.  * A request to Overpass API was rejected
  43.  * @event OverpassFrontend#reject
  44.  * @param {OverpassFrontend#QueryStatus} queryStatus
  45.  * @param {OverpassFrontend#Context} context - context of the request
  46.  */
  48. /**
  49.  * Status of a query to Overpass API
  50.  * @typedef {Object} OverpassFrontend#QueryStatus
  51.  * @property {int} [status] - result status (e.g. 429 for reject, ...)
  52.  * @property {int} [errorCount] - the nth error in a row
  53.  * @property {boolean} [retry] - true, if the request will be retried (after a 429 error)
  54.  * @property {int} [retryTimeout] - if the query will be retried, the next request will be delayed for n ms
  55.  */
  57. /**
  58.  * When a file is specified as URL, this event notifies, that the file has been completely loaded. When a Overpass API is used, every time when data has been received.
  59.  * @event OverpassFrontend#load
  60.  * @param {object} osm3sMeta Meta data (not all properties of meta data might be set)
  61.  * @param {number} osm3sMeta.version OpenStreetMap API version (currently 0.6)
  62.  * @param {string} osm3sMeta.generator Data generator
  63.  * @param {string} osm3sMeta.timestamp_osm_base RFC8601 timestamp of OpenStreetMap data
  64.  * @param {string} osm3sMeta.copyright Copyright statement
  65.  * @param {BoundingBox} [osm3sMeta.bounds] Bounding Box (only when loading from file)
  66.  * @param {OverpassFrontend#Context} [context] - context of the request
  67.  */
  69. /**
  70.  * When an object is updated (e.g. when loaded; additional information loaded; when a member object got loaded)
  71.  * @event OverpassFrontend#update
  72.  * @param {OverpassNode|OverpassWay|OverpassRelation} object The object which got updated.
  73.  */
  75. /**
  76.  * A connection to an Overpass API Server or an OpenStreetMap file
  77.  * @param {string} url The URL of the API, e.g. 'https://overpass-api.de/api/'. If you omit the protocol, it will use the protocol which is in use for the current page (or https: on nodejs): '//overpass-api.de/api/'. If the url ends in .json, .osm or .osm.bz2 it will load this OpenStreetMap file and use the data from there.
  78.  * @param {object} options Options
  79.  * @param {boolean} [options.isFile] true, if the URL is a file; false if the URL points to an Overpass API server. if unset, will be autodetected.
  80.  * @param {string} [options.filename] override file name; if undefined, the last part of the URL.
  81.  * @param {string} [options.fileFormat] force file format; if undefined, auto-detect.
  82.  * @param {object} [options.fileFormatOptions] options for the file format parser.
  83.  * @param {number} [options.count=0] Only return a maximum of count items. If count=0, no limit is used (default).
  84.  * @param {number} [options.effortPerRequest=1000] To avoid huge requests to the Overpass API, the request will be split into smaller chunks. This value defines, how many objects will be requested per API call (for get() calls see effortNode, effortWay, effortRelation, e.g. up to 1000 nodes or 250 ways or (500 nodes and 125 ways) at default values; for BBoxQuery() calls the setting will be divided by 4).
  85.  * @param {number} [options.effortNode=1] The effort for request a node. Default: 1.
  86.  * @param {number} [options.effortWay=4] The effort for request a way.
  87.  * @param {number} [options.effortRelation=64] The effort for request a relation.
  88.  * @param {number} [options.effortBBoxFeature=4] The effort for requesting an item in a BboxQuery.
  89.  * @param {number} [options.timeGap=10] A short time gap between two requests to the Overpass API (milliseconds).
  90.  * @param {number} [options.timeGap429=500] A longer time gap after a 429 response from Overpass API (milliseconds).
  91.  * @param {number} [options.timeGap429Exp=3] If we keep getting 429 responses, increase the time exponentially with the specified factor (e.g. 2: 500ms, 1000ms, 2000ms, ...; 3: 500ms, 1500ms, 4500ms, ...)
  92.  * @param {number} [options.loadChunkSize=1000] When loading a file (instead connecting to an Overpass URL) load elements in chunks of n items.
  93.  * @property {boolean} hasStretchLon180=false Are there any map features in the cache which stretch over lon=180/-180?
  94.  */
  95. class OverpassFrontend {
  96.   constructor (url, options) {
  97.     this.url = url
  98.     this.options = {
  99.       effortPerRequest: 1000,
  100.       effortNode: 1,
  101.       effortWay: 4,
  102.       effortRelation: 64,
  103.       effortBBoxFeature: 4,
  104.       timeGap: 10,
  105.       timeGap429: 500,
  106.       timeGap429Exp: 3,
  107.       loadChunkSize: 1000
  108.     }
  109.     for (const k in options) {
  110.       this.options[k] = options[k]
  111.     }
  113.     const db = new LokiJS()
  114.     this.db = db.addCollection('osm', { unique: ['id'] })
  115.     this.bboxQueryCache = new BBoxQueryCache(this)
  117.     this.clearCache()
  119.     this.requests = []
  120.     this.requestIsActive = false
  121.     this.errorCount = 0
  123.     this.pendingNotifyMemberUpdate = {}
  124.     this.pendingUpdateEmit = {}
  126.     if (this.options.isFile ?? isFileURL(this.url)) {
  127.       this.options.isFile = true
  128.       this.ready = false
  129.       global.setTimeout(() => this._loadFile(), 0)
  130.     } else {
  131.       this.options.isFile = false
  132.       this.ready = true
  133.     }
  134.   }
  136.   /**
  137.    * clear all caches
  138.    */
  139.   clearCache () {
  140.     if (this.options.isFile) {
  141.       return
  142.     }
  144.     this.cacheElements = {}
  145.     this.cacheElementsMemberOf = {}
  146.     this.cacheTimestamp = timestamp()
  147.     this.db.clear()
  148.     this.bboxQueryCache.clear()
  150.     // Set default properties
  151.     this.hasStretchLon180 = false
  152.   }
  154.   _loadFile () {
  155.     loadFile(this.url, this.options, (err, content, filename) => {
  156.       if (err) {
  157.         console.log('Error loading file', err)
  158.         return this.emit('error', err)
  159.       }
  161.       let handler
  162.       if (this.options.fileFormat) {
  163.         handler = OverpassFrontend.fileFormats.filter(format => format.id === this.options.fileFormat)
  164.       } else {
  165.         handler = OverpassFrontend.fileFormats.filter(format => format.willLoad(filename, content, this.options.fileFormatOptions ?? {}))
  166.       }
  168.       if (!handler.length) {
  169.         console.log('No file format handler found')
  170.         return this.emit('error', new Error('No file format handler found'))
  171.       }
  173.       handler = handler[0]
  175.       handler.load(content, this.options.fileFormatOptions ?? {}, (err, result) => {
  176.         if (err) {
  177.           console.log('Error loading file with handler ' + handler.id, err)
  178.           return this.emit('error', new Error('Error loading file with handler ' + handler.id + ': ' + err.message))
  179.         }
  181.         this._loadFileContent(result)
  182.       })
  183.     })
  184.   }
  186.   _loadFileContent (result) {
  187.     const osm3sMeta = copyOsm3sMetaFrom(result)
  189.     const chunks = []
  190.     for (let i = 0; i < result.elements.length; i += this.options.loadChunkSize) {
  191.       chunks.push(result.elements.slice(i, i + this.options.loadChunkSize))
  192.     }
  194.     // collect all objects, so they can be completed later-on
  195.     const obs = []
  196.     async.eachLimit(
  197.       chunks,
  198.       1,
  199.       (chunk, done) => {
  200.         chunk.forEach(
  201.           (element) => {
  202.             const ob = this.createOrUpdateOSMObject(element, {
  203.               osm3sMeta,
  204.               properties: OverpassFrontend.TAGS | OverpassFrontend.META | OverpassFrontend.MEMBERS
  205.             })
  207.             obs.push(ob)
  208.           }
  209.         )
  211.         global.setTimeout(done, 0)
  212.       },
  213.       (err) => {
  214.         this.pendingNotifies()
  216.         // Set objects to fully known, as no more data can be loaded from the file
  217.         obs.forEach(ob => {
  218.           ob.properties |= OverpassFrontend.ALL
  219.         })
  221.         if (err) {
  222.           return this.emit('error', err)
  223.         }
  225.         this.meta = osm3sMeta
  226.         this.emit('load', osm3sMeta)
  228.         this.ready = true
  229.         this._overpassProcess()
  230.       }
  231.     )
  232.   }
  234.   /**
  235.    * @param {string|string[]} ids - Id or array of Ids of OSM map features, e.g. [ 'n123', 'w2345', 'n123' ]. Illegal IDs will not produce an error but generate a 'null' object.
  236.    * @param {object} options Various options, see below
  237.    * @param {number} [options.priority=0] - Priority for loading these objects. The lower the sooner they will be requested.
  238.    * @param {string|boolean} [options.sort=false] - When set to true or "index", the function featureCallback will be called in order of the "ids" array. When set to false or null, the featureCallback will be called as soon as the object is loaded (e.g. immediately, if it is cached). When set to "BBoxDiagonalLength", the objects are ordered by the length of the diagonal of the bounding box.
  239.    * @param {"asc"|"desc"} [options.sortDir="asc"] Sort direction.
  240.    * @param {BoundingBox|GeoJSON} [options.bounds] - Only return items which intersect these bounds. Boundaries is a BoundingBox, or a Leaflet Bounds object (e.g. from map.getBounds()) or a GeoJSON Polygon/Multipolygon.
  241.    * @param {boolean} [options.members=false] Query relation members of. Default: false
  242.    * @param {function} [options.memberCallback] For every member, call this callback function. (Requires options.members=true)
  243.    * @param {bit_array} [options.memberProperties] Which properties should be loaded for the members. Default: OverpassFrontend.TAGS | OverpassFrontend.MEMBERS | OverpassFrontend.BBOX
  244.    * @param {BoundingBox|GeoJSON} [options.memberBounds] - Only return members which intersect these bounds. Boundaries is a BoundingBox, or a Leaflet Bounds object (e.g. from map.getBounds()) or a GeoJSON Polygon/Multipolygon.
  245.    * @param {function} featureCallback Will be called for each object which is passed in parameter 'ids'. Will be passed: 1. err (if an error occured, otherwise null), 2. the object or null, 3. index of the item in parameter ids.
  246.    * @param {function} finalCallback Will be called after the last feature. Will be passed: 1. err (if an error occured, otherwise null).
  247.    * @return {RequestGet}
  248.    */
  249.   get (ids, options, featureCallback, finalCallback) {
  250.     const request = new RequestGet(this, {
  251.       ids: ids,
  252.       options: options,
  253.       featureCallback: featureCallback,
  254.       finalCallback: finalCallback
  255.     })
  257.     this.requests.push(request)
  259.     this._next()
  261.     return request
  262.   }
  264.   /**
  265.    * return an OSM object, if it is already in the cache
  266.    * @param {string} id - Id of an OSM map feature
  267.    * @param {object} options
  268.    * @param {int} [options.properties] - Which properties have to be known (default: OverpassFrontend.DEFAULT)
  269.    * @return {null|false|OverpassObject} - null: does not exist in the database; false: may exist, but has not been loaded yet (or not enough properties known); OverpassObject: sucessful object
  270.    */
  271.   getCached (id, options) {
  272.     if (typeof options === 'undefined') {
  273.       options = {}
  274.     }
  276.     if (typeof options.properties === 'undefined') {
  277.       options.properties = defines.DEFAULT
  278.     }
  280.     if (!(id in this.cacheElements)) {
  281.       return false
  282.     }
  284.     const ob = this.cacheElements[id]
  286.     if (ob.missingObject) {
  287.       return null
  288.     }
  290.     if ((options.properties & ob.properties) !== options.properties) {
  291.       return false
  292.     }
  294.     return ob
  295.   }
  297.   /**
  298.    * Current request context
  299.    * @typedef {Object} OverpassFrontend#Context
  300.    * @property {string} query - The compiled code of all sub requests
  301.    * @property {string} queryOptions - The compiled queryOptions which will be sent to Overpass API
  302.    * @property {Request[]} requests - List of all requests in the context
  303.    * @property {Request#SubRequest[]} subRequests - List of all subRequests in the context
  304.    * @property {BoundingBox} bbox - when there are any BBox requests, add this global bbox
  305.    * @property {int} maxEffort - how many queries can we still add to this context
  306.    * @property {object} todo - list of items which should be loaded via get requests to avoid duplicates
  307.    */
  309.   _overpassProcess () {
  310.     // currently active - we'll come back later :-)
  311.     if (!this.ready) {
  312.       return
  313.     }
  315.     // preprocess all requests
  316.     // e.g. call featureCallback for elements which were received in the
  317.     // meantime
  318.     this.requests.forEach((request, i) => {
  319.       if (request && request.timestampPreprocess < this.cacheTimestamp) {
  320.         request.preprocess()
  321.         request.timestampPreprocess = this.cacheTimestamp
  323.         if (request.finished) {
  324.           this.requests[i] = null
  325.         } else if (request.mayFinish() || this.options.isFile) {
  326.           request.finish()
  327.         }
  328.       }
  329.     })
  330.     this.requests = removeNullEntries(this.requests)
  332.     // currently active - we'll come back later :-)
  333.     if (this.requestIsActive || !this.ready) {
  334.       return
  335.     }
  337.     // nothing todo ...
  338.     if (!this.requests.length) {
  339.       return
  340.     }
  342.     // now order all requests by priority
  343.     this.requests = weightSort(this.requests, 'priority')
  345.     this.requestIsActive = true
  346.     let request
  347.     let j
  349.     const context = {
  350.       bbox: null,
  351.       todo: {},
  352.       requests: [],
  353.       subRequests: [],
  354.       query: '',
  355.       minPriority: this.requests[0].priority,
  356.       minEffort: 0,
  357.       maxEffort: 0
  358.     }
  360.     for (j = 0; j < this.requests.length; j++) {
  361.       request = this.requests[j]
  363.       if (request.priority > context.minPriority &&
  364.          (context.maxEffort === null || context.maxEffort > this.options.effortPerRequest)) {
  365.         break
  366.       }
  368.       if (request.willInclude(context)) {
  369.         const { minEffort, maxEffort } = request.minMaxEffort()
  371.         if (context.minEffort > 0 && context.minEffort + minEffort > this.options.effortPerRequest) {
  372.           continue
  373.         }
  375.         context.minEffort += minEffort
  376.         if (maxEffort === null) {
  377.           context.maxEffort = null
  378.         } else if (context.maxEffort !== null) {
  379.           context.maxEffort += maxEffort
  380.         }
  382.         context.requests.push(request)
  383.       }
  384.     }
  386.     let effortAvailable = this.options.effortPerRequest
  388.     for (j = 0; j < context.requests.length; j++) {
  389.       request = context.requests[j]
  390.       const remainingRequestsAtPriority = context.requests.slice(j).filter(r => r.priority === request.priority)
  391.       context.maxEffort = Math.ceil(effortAvailable / remainingRequestsAtPriority.length)
  392.       const subRequest = request.compileQuery(context)
  394.       if (subRequest.parts.length === 0) {
  395.         console.log('subRequest has no parts! Why was willInclude true?', subRequest)
  396.         continue
  397.       }
  399.       context.subRequests.push(subRequest)
  401.       if (context.query !== '') {
  402.         context.query += '\nout count;\n'
  403.       }
  405.       effortAvailable -= subRequest.effort
  406.       context.query += subRequest.query
  408.       if (effortAvailable <= 0) {
  409.         break
  410.       }
  411.     }
  413.     if (context.query === '') {
  414.       return this._next()
  415.     }
  417.     context.queryOptions = '[out:json]'
  418.     if (context.bbox && !boundsIsFullWorld(context.bbox)) {
  419.       context.queryOptions += '[bbox:' + context.bbox.toLatLonString() + ']'
  420.     }
  422.     const query = context.queryOptions + ';\n' + context.query
  424.     setTimeout(function () {
  425.       httpLoad(
  426.         this.url,
  427.         null,
  428.         query,
  429.         this._handleResult.bind(this, context)
  430.       )
  432.       this.emit('start', {}, context)
  433.     }.bind(this), this.options.timeGap)
  434.   }
  436.   _handleResult (context, err, results) {
  437.     this.requestIsActive = false
  439.     if (err === null && results.remark) {
  440.       err = results.remark
  441.     }
  443.     const status = {}
  445.     if (err !== null) {
  446.       this.errorCount++
  448.       status.status = err.status
  449.       status.errorCount = this.errorCount
  451.       if (this.errorCount <= 3) {
  452.         // retry
  453.         if (err.status === 429) {
  454.           this.requestIsActive = true
  455.           const timeGap = this.options.timeGap429Exp ** (this.errorCount - 1) * this.options.timeGap429
  457.           status.retry = true
  458.           status.retryTimeout = timeGap
  459.           this.emit('reject', status, context)
  461.           global.setTimeout(() => {
  462.             this.requestIsActive = false
  463.             this._overpassProcess()
  464.           }, timeGap - this.options.timeGap)
  465.         } else {
  466.           this.emit('error', err, context)
  468.           this._overpassProcess()
  469.         }
  470.       } else {
  471.         if (err.status === 429) {
  472.           status.retry = false
  474.           this.emit('reject', status, context)
  475.         }
  477.         this.emit('error', status, context)
  479.         // abort
  480.         // call finalCallback for the request
  481.         context.subRequests.forEach(function (subRequest) {
  482.           subRequest.request.finish(err)
  483.         })
  484.       }
  486.       return
  487.     }
  489.     this.errorCount = 0
  491.     const osm3sMeta = copyOsm3sMetaFrom(results)
  492.     this.meta = osm3sMeta
  493.     this.emit('load', osm3sMeta, context)
  495.     let subRequestsIndex = 0
  496.     let partIndex = 0
  497.     let subRequest = context.subRequests[0]
  498.     let request = subRequest.request
  499.     let part = subRequest.parts[0]
  500.     if (!('count' in part)) {
  501.       part.count = 0
  502.     }
  504.     for (let i = 0; i < results.elements.length; i++) {
  505.       const el = results.elements[i]
  507.       if (isSeparator(el)) {
  508.         partIndex++
  510.         if (partIndex >= subRequest.parts.length) {
  511.           request.finishSubRequest(subRequest)
  513.           if (request.mayFinish() && !request.finished) {
  514.             request.finish()
  515.           }
  517.           subRequestsIndex++
  518.           partIndex = 0
  519.           subRequest = context.subRequests[subRequestsIndex]
  520.           request = subRequest.request
  521.           part = subRequest.parts[0]
  522.           if (!('count' in part)) {
  523.             part.count = 0
  524.           }
  525.         } else {
  526.           part = subRequest.parts[partIndex]
  527.         }
  529.         continue
  530.       }
  532.       part.osm3sMeta = osm3sMeta
  533.       const ob = this.createOrUpdateOSMObject(el, part)
  534.       delete context.todo[ob.id]
  536.       const members = this.cacheElements[ob.id].memberIds()
  537.       if (members) {
  538.         for (let j = 0; j < members.length; j++) {
  539.           if (!(members[j] in this.cacheElementsMemberOf)) {
  540.             this.cacheElementsMemberOf[members[j]] = [this.cacheElements[ob.id]]
  541.           } else {
  542.             this.cacheElementsMemberOf[members[j]].push(this.cacheElements[ob.id])
  543.           }
  544.         }
  545.       }
  547.       part.count++
  548.       if (part.receiveObject) {
  549.         part.receiveObject(ob)
  550.       }
  551.       if (!request.aborted && !request.finished && part.featureCallback && (!part.checkFeatureCallback || part.checkFeatureCallback(ob, part))) {
  552.         part.featureCallback(err, ob)
  553.       }
  554.     }
  556.     if (!(subRequestsIndex === context.subRequests.length - 1 || partIndex === context.subRequests[subRequestsIndex].parts.length - 1)) {
  557.       console.log('too many parts!!!!')
  558.     }
  560.     for (const id in context.todo) {
  561.       if (!(id in this.cacheElements)) {
  562.         const ob = new OverpassObject()
  563.         ob.id = id
  564.         ob.type = { n: 'node', w: 'way', r: 'relation' }[id.substr(0, 1)]
  565.         ob.osm_id = id.substr(1)
  566.         ob.properties = OverpassFrontend.ALL
  567.         ob.missingObject = true
  568.         this.cacheElements[id] = ob
  569.         this.db.insert(ob.dbInsert())
  570.       } else {
  571.         const ob = this.cacheElements[id]
  572.         ob.missingObject = true
  573.         this.db.update(ob.dbInsert())
  574.       }
  575.     }
  577.     this.cacheTimestamp = timestamp()
  579.     this.pendingNotifies()
  581.     request.finishSubRequest(subRequest)
  583.     this._next()
  584.   }
  586.   /**
  587.    * @param {string} query - Query for requesting objects from Overpass API, e.g. "node[amenity=restaurant]" or "(node[amenity];way[highway~'^(primary|secondary)$];)". See <a href='Filter.html'>Filter</a> for details.
  588.    * @param {BoundingBox|GeoJSON} bounds - Boundaries where to load objects, can be a BoundingBox object, Leaflet Bounds object (e.g. from map.getBounds()) or a GeoJSON Polygon/Multipolygon.
  589.    * @param {object} options
  590.    * @param {number} [options.limit=0] - Limit count of results. If 0, no limit will be used.
  591.    * @param {number} [options.priority=0] - Priority for loading these objects. The lower the sooner they will be requested.
  592.    * @param {boolean|string} [options.sort=false] - If false, it will be called as soon as the features are availabe (e.g. immediately when cached).
  593.    * @param {bit_array} [options.properties] Which properties of the features should be downloaded: OVERPASS_ID_ONLY, OVERPASS_BBOX, OVERPASS_TAGS, OVERPASS_GEOM, OVERPASS_META. Combine by binary OR: ``OVERPASS_ID | OVERPASS_BBOX``. Default: OverpassFrontend.TAGS | OverpassFrontend.MEMBERS | OverpassFrontend.BBOX
  594.    * @param {number} [options.split=0] If more than 'split' elements would be returned, split into several smaller requests, with 'split' elements each. Default: 0 (do not split)
  595.    * @param {boolean} [options.members=false] Query relation members of. Default: false
  596.    * @param {function} [options.memberCallback] For every member, call this callback function. (Requires options.members=true)
  597.    * @param {bit_array} [options.memberProperties] Which properties should be loaded for the members. Default: OverpassFrontend.TAGS | OverpassFrontend.MEMBERS | OverpassFrontend.BBOX
  598.    * @param {BoundingBox|GeoJSON} [options.memberBounds] - Only return members which intersect these bounds. Boundaries is a BoundingBox, or a Leaflet Bounds object (e.g. from map.getBounds()) or a GeoJSON Polygon/Multipolygon.
  599.    * @param {number} [options.memberSplit=0] If more than 'memberSplit' member elements would be returned, split into smaller requests (see 'split'). 0 = do not split.
  600.    * @param {string|Filter} [options.filter] Additional filter.
  601.    * @param {boolean} [options.noCacheQuery=false] If true, the local cache will not be queried
  602.    * @param {function} featureCallback Will be called for each matching object. Will be passed: 1. err (if an error occured, otherwise null), 2. the object or null.
  603.    * @param {function} finalCallback Will be called after the last feature. Will be passed: 1. err (if an error occured, otherwise null).
  604.    * @return {RequestBBox}
  605.    */
  606.   BBoxQuery (query, bounds, options, featureCallback, finalCallback) {
  607.     let request
  608.     const bbox = new BoundingBox(bounds)
  610.     if (!isGeoJSON(bounds)) {
  611.       bounds = bbox
  612.     }
  614.     if (bbox.minlon > bbox.maxlon) {
  615.       const bbox1 = new BoundingBox(bbox)
  616.       bbox1.maxlon = 180
  617.       const bbox2 = new BoundingBox(bbox)
  618.       bbox2.minlon = -180
  620.       request = new RequestMulti(this,
  621.         {
  622.           featureCallback: featureCallback,
  623.           finalCallback: finalCallback
  624.         }, [
  625.           new RequestBBox(this, {
  626.             query: query,
  627.             bbox: bbox1,
  628.             bounds: bounds,
  629.             options: options,
  630.             doneFeatures: {}
  631.           }),
  632.           new RequestBBox(this, {
  633.             query: query,
  634.             bbox: bbox2,
  635.             bounds: bounds,
  636.             options: options,
  637.             doneFeatures: {}
  638.           })
  639.         ]
  640.       )
  641.     } else {
  642.       request = new RequestBBox(this, {
  643.         query: query,
  644.         bbox: bbox,
  645.         bounds: bounds,
  646.         options: options,
  647.         doneFeatures: {},
  648.         featureCallback: featureCallback,
  649.         finalCallback: finalCallback
  650.       })
  651.     }
  653.     this.requests.push(request)
  655.     this._next()
  657.     return request
  658.   }
  660.   clearBBoxQuery (query) {
  661.     const cacheDescriptors = new Filter(query).cacheDescriptors()
  663.     cacheDescriptors.forEach(descriptor => {
  664.       this.bboxQueryCache.get(descriptor.id).clear()
  665.     })
  666.   }
  668.   _abortRequest (request) {
  669.     const p = this.requests.indexOf(request)
  671.     if (p === -1) {
  672.       return
  673.     }
  675.     this.requests[p] = null
  676.   }
  678.   _finishRequest (request) {
  679.     const p = this.requests.indexOf(request)
  680.     if (p >= 0) {
  681.       this.requests[p] = null
  682.     }
  683.   }
  685.   _next () {
  686.     async.setImmediate(function () {
  687.       this._overpassProcess()
  688.     }.bind(this))
  689.   }
  691.   abortAllRequests () {
  692.     for (let j = 0; j < this.requests.length; j++) {
  693.       if (this.requests[j] === null) {
  694.         continue
  695.       }
  697.       this.requests[j].abort()
  698.     }
  700.     this.requests = []
  701.     this.requestIsActive = false
  702.   }
  704.   removeFromCache (ids) {
  705.     if (typeof ids === 'string') {
  706.       ids = [ids]
  707.     }
  709.     for (let i = 0; i < ids.length; i++) {
  710.       if (ids[i] in this.cacheElements) {
  711.         const ob = this.cacheElements[ids[i]]
  713.         // remove all memberOf references
  714.         if (ob.members) {
  715.           ob.members.forEach(member => {
  716.             const memberOb = this.cacheElements[member.id]
  717.             memberOb.memberOf = memberOb.memberOf
  718.               .filter(memberOf => memberOf.id !== ob.id)
  719.           })
  720.         }
  722.         const lokiOb = this.cacheElements[ids[i]].dbData
  723.         delete this.cacheElements[ids[i]]
  724.         this.db.remove(lokiOb)
  725.       }
  726.     }
  727.   }
  729.   notifyMemberUpdates () {
  730.     const todo = this.pendingNotifyMemberUpdate
  731.     this.pendingNotifyMemberUpdate = {}
  733.     for (const k in todo) {
  734.       const ob = this.cacheElements[k]
  735.       ob.notifyMemberUpdate(todo[k])
  737.       this.pendingUpdateEmit[ob.id] = ob
  738.     }
  739.   }
  741.   pendingNotifies () {
  742.     this.notifyMemberUpdates()
  744.     const todo = Object.values(this.pendingUpdateEmit)
  745.     this.pendingUpdateEmit = {}
  747.     todo.forEach(ob => {
  748.       ob.emit('update', ob)
  749.       this.db.update(ob.dbInsert())
  750.     })
  751.   }
  753.   createOrUpdateOSMObject (el, options) {
  754.     const id = el.type.substr(0, 1) + el.id
  755.     let ob = null
  756.     let create = true
  758.     if (id in this.cacheElements && !this.cacheElements[id]) {
  759.       console.log('why can this be null?', id)
  760.     }
  762.     if (id in this.cacheElements && this.cacheElements[id]) {
  763.       ob = this.cacheElements[id]
  764.       create = false
  766.       // no new information -> return
  767.       if (~ob.properties & options.properties === 0) {
  768.         return ob
  769.       }
  770.     } else if (el.type === 'relation') {
  771.       ob = new OverpassRelation(id)
  772.     } else if (el.type === 'way') {
  773.       ob = new OverpassWay(id)
  774.     } else if (el.type === 'node') {
  775.       ob = new OverpassNode(id)
  776.     } else {
  777.       ob = new OverpassObject(id)
  778.     }
  780.     ob.overpass = this
  781.     ob.updateData(el, options)
  783.     ob.memberOf.forEach(entry => {
  784.       if (entry.id in this.pendingNotifyMemberUpdate) {
  785.         this.pendingNotifyMemberUpdate[entry.id].push(ob)
  786.       } else {
  787.         this.pendingNotifyMemberUpdate[entry.id] = [ob]
  788.       }
  789.     })
  790.     this.pendingUpdateEmit[ob.id] = ob
  792.     if (create) {
  793.       this.db.insert(ob.dbInsert())
  794.     } else {
  795.       this.db.update(ob.dbInsert())
  796.     }
  798.     this.cacheElements[id] = ob
  799.     return ob
  800.   }
  802.   regexpEscape (str) {
  803.     return str.replace('\\', '\\\\')
  804.       .replace('.', '\\.')
  805.       .replace('|', '\\|')
  806.       .replace('[', '\\[')
  807.       .replace(']', '\\]')
  808.       .replace('(', '\\(')
  809.       .replace(')', '\\)')
  810.       .replace('{', '\\{')
  811.       .replace('}', '\\}')
  812.       .replace('?', '\\?')
  813.       .replace('+', '\\+')
  814.       .replace('*', '\\*')
  815.       .replace('^', '\\^')
  816.       .replace('$', '\\$')
  817.   }
  819.   /**
  820.    * get meta data of last request or - if no request was submitted - the first.
  821.    * @params [function] callback - a callback which will receive (err, meta)
  822.    */
  823.   getMeta (callback) {
  824.     if (this.meta) {
  825.       return callback(null, this.meta)
  826.     }
  828.     this.once('load', () => {
  829.       callback(null, this.meta)
  830.     })
  831.   }
  832. }
  834. OverpassFrontend.fileFormats = [
  835.   require('./fileFormatOSMXML'),
  836.   require('./fileFormatOSMJSON'),
  837.   require('./fileFormatGeoJSON')
  838. ]
  840. OverpassFrontend.registerFileFormat = (format) => {
  841.   OverpassFrontend.fileFormats.push(format)
  842. }
  844. for (const k in defines) {
  845.   OverpassFrontend[k] = defines[k]
  846. }
  848. function isSeparator (el) {
  849.   return ('count' in el || ('type' in el && el.type === 'count'))
  850. }
  852. ee(OverpassFrontend.prototype)
  854. OverpassFrontend.Filter = Filter
  856. module.exports = OverpassFrontend