geojs 1.6.2 → 1.6.6

package/src/mapInteractor.js

@@ -2037,26 +2037,26 @@ var mapInteractor = function (args) {
    *    map in pixels relative to the map's div.
    * @param {geo.screenPosition} [options.center] The position of a touch
    *    event center relative to the window.
-   * @param {string} [button] One of `left`, `middle`, or `right` for mouse
-   *    events.
-   * @param {string} [modifiers] A space-separated list of metakeys that are
-   *    down on mouse events.
-   * @param {geo.screenPosition} [wheelDelta] The amount the wheel moved in
-   *    both directions for wheel events.  One step is often 20 units of
-   *    vement.
-   * @param {number} [wheelMode] The wheel delta mode.  See
+   * @param {string} [options.button] One of `left`, `middle`, or `right` for
+   *    mouse events.
+   * @param {string} [options.modifiers] A space-separated list of metakeys
+   *    that are down on mouse events.
+   * @param {geo.screenPosition} [options.wheelDelta] The amount the wheel
+   *    moved in both directions for wheel events.  One step is often 20 units
+   *    of movement.
+   * @param {number} [options.wheelMode] The wheel delta mode.  See
    *    https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent .
-   * @param {boolean} [touch] `truthy` if this is a touch event.
-   * @param {number} [rotation] Touch event rotation in degrees.
-   * @param {number} [scale] Touch event scale.  Initial events should have a
-   *    scale of 1; subsequent events should increase or decrease this to
-   *    simulate spread and pinch actions.
-   * @param {number[]} [pointers] A list of pointer numbers involved in a
-   *    touch event.  Pointers are number from one up, so `[1]` is the first
+   * @param {boolean} [options.touch] `truthy` if this is a touch event.
+   * @param {number} [options.rotation] Touch event rotation in degrees.
+   * @param {number} [options.scale] Touch event scale.  Initial events should
+   *    have a scale of 1; subsequent events should increase or decrease this
+   *    to simulate spread and pinch actions.
+   * @param {number[]} [options.pointers] A list of pointer numbers involved in
+   *    a touch event.  Pointers are number from one up, so `[1]` is the first
    *    touch point, `[1, 2]` are two touch points, and `[2]` is when the first
    *    point was released but the second is still touching.
-   * @param {string} [pointerType] `mouse` if this is a mouse action rather
-   *    than a touch action.
+   * @param {string} [options.pointerType] `mouse` if this is a mouse action
+   *    rather than a touch action.
    * @returns {mapInteractor}
    */
   this.simulateEvent = function (type, options) {

package/src/markerFeature.js

@@ -442,7 +442,7 @@ markerFeature.primitiveShapes = pointFeature.primitiveShapes;
 
 /**
  * Marker symbols
- * @enum
+ * @enum {number}
  */
 markerFeature.symbols = {
   // for circle (alias ellipse), the symbolValue is the ratio of the minor to
@@ -499,7 +499,7 @@ markerFeature.symbols = {
 
 /**
  * Marker scale modes
- * @enum
+ * @enum {number}
  */
 markerFeature.scaleMode = {
   none: 0,

package/src/meshFeature.js

@@ -21,7 +21,7 @@ var feature = require('./feature');
  * of these properties can be functions, which get passed `data`.
  *
  * @typedef {object} geo.meshFeature.meshSpec
- * @property {number[]|array.<number[]>} [elements] If specified, a list of
+ * @property {number[]|Array.<number[]>} [elements] If specified, a list of
  *      indices into the data array that form elements.  If this is an array of
  *      arrays, each subarray must have at least either 3 values for triangular
  *      elements or 4 values for square elements.  If this is a single array,

package/src/osmLayer.js

@@ -13,6 +13,8 @@ var quadFeature = require('./quadFeature');
  *   specified, use this as the layer opacity.
  * @property {string} [source] If specified, use the predefined tile source
  *   (see {@link geo.osmLayer.tileSources}).
+ * @property {string} [crossDomain='anonymous'] Image CORS attribute.  This is
+ *   used for the `crossorigin` property when loading images.
  */
 
 /**

package/src/pixelmapFeature.js

@@ -1,7 +1,6 @@
 var $ = require('jquery');
 var inherit = require('./inherit');
 var feature = require('./feature');
-var geo_event = require('./event');
 var util = require('./util');
 
 /**
@@ -72,12 +71,8 @@ var pixelmapFeature = function (arg) {
    * @private
    */
   var m_this = this,
-      m_quadFeature,
-      m_srcImage,
-      m_info,
       s_update = this._update,
-      s_init = this._init,
-      s_exit = this._exit;
+      s_init = this._init;
 
   this.featureType = 'pixelmap';
 
@@ -113,7 +108,7 @@ var pixelmapFeature = function (arg) {
     if (val === undefined) {
       return m_this.style('url');
     } else if (val !== m_this.style('url')) {
-      m_srcImage = m_info = undefined;
+      m_this.m_srcImage = m_this.m_info = undefined;
       m_this.style('url', val);
       m_this.dataTime().modified();
       m_this.modified();
@@ -121,28 +116,6 @@ var pixelmapFeature = function (arg) {
     return m_this;
   };
 
-  /**
-   * Get the maximum index value from the pixelmap.  This is a value present in
-   * the pixelmap.
-   *
-   * @returns {number} The maximum index value.
-   */
-  this.maxIndex = function () {
-    if (m_info) {
-      /* This isn't just m_info.mappedColors.length - 1, since there
-       * may be more data than actual indices. */
-      if (m_info.maxIndex === undefined) {
-        m_info.maxIndex = 0;
-        for (var idx in m_info.mappedColors) {
-          if (m_info.mappedColors.hasOwnProperty(idx)) {
-            m_info.maxIndex = Math.max(m_info.maxIndex, idx);
-          }
-        }
-      }
-      return m_info.maxIndex;
-    }
-  };
-
   /**
    * Get/Set color accessor.
    *
@@ -162,35 +135,51 @@ var pixelmapFeature = function (arg) {
   };
 
   /**
-   * If the specified coordinates are in the rendered quad, use the basis
-   * information from the quad to determine the pixelmap index value so that it
-   * can be included in the `found` results.
+   * Update.
    *
-   * @param {geo.geoPosition} geo Coordinate.
-   * @param {string|geo.transform|null} [gcs] Input gcs.  `undefined` to use
-   *    the interface gcs, `null` to use the map gcs, or any other transform.
-   * @returns {geo.feature.searchResult} An object with a list of features and
-   *    feature indices that are located at the specified point.
+   * @returns {this}
    */
-  this.pointSearch = function (geo, gcs) {
-    if (m_quadFeature && m_info) {
-      var result = m_quadFeature.pointSearch(geo, gcs);
-      if (result.index.length === 1 && result.extra && result.extra[result.index[0]].basis) {
-        var basis = result.extra[result.index[0]].basis, x, y, idx;
-        x = Math.floor(basis.x * m_info.width);
-        y = Math.floor(basis.y * m_info.height);
-        if (x >= 0 && x < m_info.width &&
-            y >= 0 && y < m_info.height) {
-          idx = m_info.indices[y * m_info.width + x];
-          result = {
-            index: [idx],
-            found: [m_this.data()[idx]]
-          };
-          return result;
+  this._update = function () {
+    s_update.call(m_this);
+    if (m_this.buildTime().timestamp() <= m_this.dataTime().timestamp() ||
+        m_this.updateTime().timestamp() < m_this.timestamp()) {
+      m_this._build();
+    }
+
+    m_this.updateTime().modified();
+    return m_this;
+  };
+
+  /**
+   * Get the maximum index value from the pixelmap.  This is a value present in
+   * the pixelmap.
+   *
+   * @returns {number} The maximum index value.
+   */
+  this.maxIndex = function () {
+    if (m_this.m_info) {
+      /* This isn't just m_info.mappedColors.length - 1, since there
+       * may be more data than actual indices. */
+      if (m_this.m_info.maxIndex === undefined) {
+        m_this.m_info.maxIndex = 0;
+        for (var idx in m_this.m_info.mappedColors) {
+          if (m_this.m_info.mappedColors.hasOwnProperty(idx)) {
+            m_this.m_info.maxIndex = Math.max(m_this.m_info.maxIndex, idx);
+          }
         }
       }
+      return m_this.m_info.maxIndex;
     }
-    return {index: [], found: []};
+  };
+
+  /**
+   * Given the loaded pixelmap image, create a canvas the size of the image.
+   * Compute a color for each distinct index and recolor the canvas based on
+   * these colors, then draw the resultant image as a quad.
+   *
+   * @fires geo.event.pixelmap.prepared
+   */
+  this._computePixelmap = function () {
   };
 
   /**
@@ -204,42 +193,42 @@ var pixelmapFeature = function (arg) {
      * checks if this feature is built.  Setting the build time avoids calling
      * this a second time. */
     m_this.buildTime().modified();
-    if (!m_srcImage) {
+    if (!m_this.m_srcImage) {
       var src = m_this.style.get('url')();
       if (util.isReadyImage(src)) {
         /* we have an already loaded image, so we can just use it. */
-        m_srcImage = src;
+        m_this.m_srcImage = src;
         m_this._computePixelmap();
       } else if (src) {
         var defer = $.Deferred(), prev_onload, prev_onerror;
         if (src instanceof Image) {
           /* we have an unloaded image.  Hook to the load and error callbacks
            * so that when it is loaded we can use it. */
-          m_srcImage = src;
+          m_this.m_srcImage = src;
           prev_onload = src.onload;
           prev_onerror = src.onerror;
         } else {
           /* we were given a url, so construct a new image */
-          m_srcImage = new Image();
+          m_this.m_srcImage = new Image();
           // Only set the crossOrigin parameter if this is going across origins.
           if (src.indexOf(':') >= 0 &&
               src.indexOf('/') === src.indexOf(':') + 1) {
-            m_srcImage.crossOrigin = m_this.style.get('crossDomain')() || 'anonymous';
+            m_this.m_srcImage.crossOrigin = m_this.style.get('crossDomain')() || 'anonymous';
           }
         }
-        m_srcImage.onload = function () {
+        m_this.m_srcImage.onload = function () {
           if (prev_onload) {
             prev_onload.apply(m_this, arguments);
           }
           /* Only use this image if our pixelmap hasn't changed since we
            * attached our handler */
           if (m_this.style.get('url')() === src) {
-            m_info = undefined;
+            m_this.m_info = undefined;
             m_this._computePixelmap();
           }
           defer.resolve();
         };
-        m_srcImage.onerror = function () {
+        m_this.m_srcImage.onerror = function () {
           if (prev_onerror) {
             prev_onerror.apply(m_this, arguments);
           }
@@ -248,180 +237,15 @@ var pixelmapFeature = function (arg) {
         defer.promise(m_this);
         m_this.layer().addPromise(m_this);
         if (!(src instanceof Image)) {
-          m_srcImage.src = src;
+          m_this.m_srcImage.src = src;
         }
       }
-    } else if (m_info) {
+    } else if (m_this.m_info) {
       m_this._computePixelmap();
     }
     return m_this;
   };
 
-  /**
-   * Compute information for this pixelmap image.  It is wasteful to call this
-   * if the pixelmap has already been prepared (it is invalidated by a change
-   * in the image).
-   *
-   * @returns {geo.pixelmapFeature.info}
-   */
-  this._preparePixelmap = function () {
-    var i, idx, pixelData;
-
-    if (!util.isReadyImage(m_srcImage)) {
-      return;
-    }
-    m_info = {
-      width: m_srcImage.naturalWidth,
-      height: m_srcImage.naturalHeight,
-      canvas: document.createElement('canvas')
-    };
-
-    m_info.canvas.width = m_info.width;
-    m_info.canvas.height = m_info.height;
-    m_info.context = m_info.canvas.getContext('2d');
-
-    m_info.context.drawImage(m_srcImage, 0, 0);
-    m_info.imageData = m_info.context.getImageData(
-      0, 0, m_info.canvas.width, m_info.canvas.height);
-    pixelData = m_info.imageData.data;
-    m_info.indices = new Array(pixelData.length / 4);
-    m_info.area = pixelData.length / 4;
-
-    m_info.mappedColors = {};
-    for (i = 0; i < pixelData.length; i += 4) {
-      idx = pixelData[i] + (pixelData[i + 1] << 8) + (pixelData[i + 2] << 16);
-      m_info.indices[i / 4] = idx;
-      if (!m_info.mappedColors[idx]) {
-        m_info.mappedColors[idx] = {first: i / 4};
-      }
-      m_info.mappedColors[idx].last = i / 4;
-    }
-    return m_info;
-  };
-
-  /**
-   * Given the loaded pixelmap image, create a canvas the size of the image.
-   * Compute a color for each distinct index and recolor the canvas based on
-   * these colors, then draw the resultant image as a quad.
-   *
-   * @fires geo.event.pixelmap.prepared
-   */
-  this._computePixelmap = function () {
-    var data = m_this.data() || [],
-        colorFunc = m_this.style.get('color'),
-        i, idx, lastidx, color, pixelData, indices, mappedColors,
-        updateFirst, updateLast = -1, update, prepared;
-
-    if (!m_info) {
-      if (!m_this._preparePixelmap()) {
-        return;
-      }
-      prepared = true;
-    }
-    mappedColors = m_info.mappedColors;
-    updateFirst = m_info.area;
-    for (idx in mappedColors) {
-      if (mappedColors.hasOwnProperty(idx)) {
-        color = colorFunc(data[idx], +idx) || {};
-        color = [
-          (color.r || 0) * 255,
-          (color.g || 0) * 255,
-          (color.b || 0) * 255,
-          color.a === undefined ? 255 : (color.a * 255)
-        ];
-        mappedColors[idx].update = (
-          !mappedColors[idx].color ||
-          mappedColors[idx].color[0] !== color[0] ||
-          mappedColors[idx].color[1] !== color[1] ||
-          mappedColors[idx].color[2] !== color[2] ||
-          mappedColors[idx].color[3] !== color[3]);
-        if (mappedColors[idx].update) {
-          mappedColors[idx].color = color;
-          updateFirst = Math.min(mappedColors[idx].first, updateFirst);
-          updateLast = Math.max(mappedColors[idx].last, updateLast);
-        }
-      }
-    }
-    /* If nothing was updated, we are done */
-    if (updateFirst >= updateLast) {
-      return;
-    }
-    /* Update only the extent that has changed */
-    pixelData = m_info.imageData.data;
-    indices = m_info.indices;
-    for (i = updateFirst; i <= updateLast; i += 1) {
-      idx = indices[i];
-      if (idx !== lastidx) {
-        lastidx = idx;
-        color = mappedColors[idx].color;
-        update = mappedColors[idx].update;
-      }
-      if (update) {
-        pixelData[i * 4] = color[0];
-        pixelData[i * 4 + 1] = color[1];
-        pixelData[i * 4 + 2] = color[2];
-        pixelData[i * 4 + 3] = color[3];
-      }
-    }
-    /* Place the updated area into the canvas */
-    m_info.context.putImageData(
-      m_info.imageData, 0, 0, 0, Math.floor(updateFirst / m_info.width),
-      m_info.width, Math.ceil((updateLast + 1) / m_info.width));
-
-    /* If we haven't made a quad feature, make one now.  The quad feature needs
-     * to have the canvas capability. */
-    if (!m_quadFeature) {
-      m_quadFeature = m_this.layer().createFeature('quad', {
-        selectionAPI: false,
-        gcs: m_this.gcs(),
-        visible: m_this.visible(undefined, true)
-      });
-      m_this.dependentFeatures([m_quadFeature]);
-      m_quadFeature.style({
-        image: m_info.canvas,
-        position: m_this.style.get('position')})
-      .data([{}])
-      .draw();
-    }
-    /* If we prepared the pixelmap and rendered it, send a prepared event */
-    if (prepared) {
-      m_this.geoTrigger(geo_event.pixelmap.prepared, {
-        pixelmap: m_this
-      });
-    }
-  };
-
-  /**
-   * Update.
-   *
-   * @returns {this}
-   */
-  this._update = function () {
-    s_update.call(m_this);
-    if (m_this.buildTime().timestamp() <= m_this.dataTime().timestamp() ||
-        m_this.updateTime().timestamp() < m_this.timestamp()) {
-      m_this._build();
-    }
-
-    m_this.updateTime().modified();
-    return m_this;
-  };
-
-  /**
-   * Destroy.  Deletes the associated quadFeature.
-   *
-   * @returns {this}
-   */
-  this._exit = function () {
-    if (m_quadFeature && m_this.layer()) {
-      m_this.layer().deleteFeature(m_quadFeature);
-      m_quadFeature = null;
-      m_this.dependentFeatures([]);
-    }
-    s_exit();
-    return m_this;
-  };
-
   /**
    * Initialize.
    *

package/src/pointFeature.js

@@ -554,7 +554,7 @@ pointFeature.capabilities = {
 
 /**
  * Support primitive shapes
- * @enum
+ * @enum {string}
  */
 pointFeature.primitiveShapes = {
   auto: 'auto',

package/src/polygonFeature.js

@@ -565,9 +565,9 @@ var polygonFeature = function (arg) {
    *
    * @param {array} data A new data array.
    * @param {number} [tolerance] The maximum variation allowed in map.gcs
-   *    units.  A value of zero will only remove perfectly colinear points.  If
-   *    not specified, this is set to a half display pixel at the map's current
-   *    zoom level.
+   *    units.  A value of zero will only remove perfectly collinear points.
+   *    If not specified, this is set to a half display pixel at the map's
+   *    current zoom level.
    * @param {function} [posFunc=this.style.get('position')] The function to
    *    get the position of each vertex.
    * @param {function} [polyFunc=this.style.get('polygon')] The function to

package/src/quadFeature.js

@@ -232,7 +232,7 @@ var quadFeature = function (arg) {
             coordbasis.y = 1 - coordbasis.y;
           }
           if (coordbasis) {
-            extra[quad.idx] = {basis: coordbasis};
+            extra[quad.idx] = {basis: coordbasis, _quad: quad};
           }
         }
       });

package/src/registry.js

@@ -60,7 +60,7 @@ util.registerRenderer = function (name, func) {
  * @param {geo.layer} layer The layer associated with the renderer.
  * @param {HTMLCanvasElement} [canvas] A canvas object to share between
  *      renderers.
- * @param {object} options Options for the new renderer.
+ * @param {object} [options] Options for the new renderer.
  * @returns {geo.renderer|null} The new renderer or null if no such name is
  *      registered.
  */
@@ -83,7 +83,7 @@ util.createRenderer = function (name, layer, canvas, options) {
  *
  * @alias geo.checkRenderer
  * @param {string|null} name Name of the desired renderer.
- * @param {boolean} noFallback If truthy, don't recommend a fallback.
+ * @param {boolean} [noFallback] If truthy, don't recommend a fallback.
  * @returns {string|null|false} The name of the renderer that should be used
  *      or false if no valid renderer can be determined.
  */

package/src/svg/svgRenderer.js

@@ -484,10 +484,10 @@ var svgRenderer = function (arg) {
    * Create a new feature element from an object that describes the feature
    * attributes.  To be called from feature classes only.
    *
-   * @param {object} arg Options for the features.
+   * @param {object} arg
    * @param {string} arg.id A unique string identifying the feature.
    * @param {array} arg.data Array of data objects used in a d3 data method.
-   * @param {function} [aeg.dataIndex] A function that returns a unique id for
+   * @param {function} [arg.dataIndex] A function that returns a unique id for
    *    each data element.  This is passed to the data access function.
    * @param {object} arg.style An object with style values or functions.
    * @param {object} arg.attributes An object containing element attributes.
@@ -500,7 +500,7 @@ var svgRenderer = function (arg) {
    *    attributes and styles set when new.  If falsy, features always have
    *    attributes and styles updated.
    * @param {boolean} [arg.sortByZ] If truthy, sort features by the `d.zIndex`.
-   * @param {string} [parentId] If set, the group ID of the parent element.
+   * @param {string} [arg.parentId] If set, the group ID of the parent element.
    * @returns {this}
    */
   this._drawFeatures = function (arg) {

package/src/tileCache.js

@@ -55,7 +55,7 @@ var tileCache = function (options) {
    * Remove a tile from the cache.
    *
    * @param {string|geo.tile} tile The tile or its hash.
-   * @returns {booliean} `true` if a tile was removed.
+   * @returns {boolean} `true` if a tile was removed.
    */
   this.remove = function (tile) {
     var hash = typeof tile === 'string' ? tile : tile.toString();

package/src/tileLayer.js

@@ -525,7 +525,7 @@ var tileLayer = function (arg) {
   /**
    * Returns a tile's bounds in a gcs.
    *
-   * @param {object|tile} indexOrTile Either a tile or an object with
+   * @param {object|geo.tile} indexOrTile Either a tile or an object with
    *    {x, y, level}` specifying a tile.
    * @param {string|geo.transform|null} [gcs] `undefined` to use the
    *    interface gcs, `null` to use the map gcs, or any other transform.
@@ -668,7 +668,7 @@ var tileLayer = function (arg) {
    * @param {number} maxLevel The zoom level
    * @param {geo.geoBounds} bounds The map bounds
    * @param {boolean} sorted Return a sorted list
-   * @param {boolean} onlyIfChanged If the set of tiles have not changed
+   * @param {boolean} [onlyIfChanged] If the set of tiles have not changed
    *     (even if their desired order has), return undefined instead of an
    *     array of tiles.
    * @returns {geo.tile[]} An array of tile objects
@@ -1134,7 +1134,7 @@ var tileLayer = function (arg) {
    * origin.
    *
    * @param {object} pt A point in world space coordinates with `x` and `y`.
-   * @param {number|undefined} zoom If unspecified, use the map zoom.
+   * @param {number} [zoom] If unspecified, use the map zoom.
    * @returns {object} Local coordinates with `x` and `y`.
    */
   this.toLocal = function (pt, zoom) {
@@ -1180,7 +1180,7 @@ var tileLayer = function (arg) {
    * create the element if it doesn't already exist.
    *
    * @param {number} level The zoom level of the layer to fetch.
-   * @returns {DOM} The layer's DOM element.
+   * @returns {HTMLElement} The layer's DOM element.
    */
   this._getSubLayer = function (level) {
     if (!m_this.canvas()) {
@@ -1512,8 +1512,8 @@ var tileLayer = function (arg) {
    * @param {geo.geoBounds} [bounds] The view bounds (if unspecified, assume
    *      global bounds)
    * @param {number} bounds.level The zoom level the bounds are given as.
-   * @param {number} zoom Keep in bound tile at this zoom level.
-   * @param {boolean} doneLoading If true, allow purging additional tiles.
+   * @param {number} [zoom] Keep in bound tile at this zoom level.
+   * @param {boolean} [doneLoading] If true, allow purging additional tiles.
    * @returns {boolean}
    */
   this._canPurge = function (tile, bounds, zoom, doneLoading) {
@@ -1604,9 +1604,9 @@ var tileLayer = function (arg) {
   /**
    * Get or set the subdomains used for templating.
    *
-   * @param {string|list} [subdomains] A comma-separated list, a string of
+   * @param {string|string[]} [subdomains] A comma-separated list, a string of
    *      single character subdomains, or a list.
-   * @returns {string|list|this}
+   * @returns {string|string[]|this}
    */
   this.subdomains = function (subdomains) {
     if (subdomains === undefined) {
@@ -1644,8 +1644,8 @@ var tileLayer = function (arg) {
   /**
    * Get/Set visibility of the layer.
    *
-   * @param {boolean|undefined} val If unspecified, return the visibility,
-   *    otherwise set it.
+   * @param {boolean} [val] If unspecified, return the visibility, otherwise
+   *    set it.
    * @returns {boolean|this} Either the visibility (if getting) or the layer
    *    (if setting).
    */