@ohuoy/easymap 1.0.24 → 1.0.26

package/{src/components/control → lib/mapbox-gl-draw/src}/extendMode/direct_select_rect.js

@@ -1,4 +1,4 @@
-import MapboxDraw from "../../../../lib/mapbox-gl-draw";
+import MapboxDraw from "../../index.js";
 import * as CommonSelectors from "../lib/common_selectors.js";
 import constrainFeatureMovement from '../lib/constrain_feature_movement.js';
 import * as Constants from '../constants.js';

package/{src/components/control → lib/mapbox-gl-draw/src}/extendMode/simple_select_rect.js

@@ -1,4 +1,4 @@
-import MapboxDraw from "../../../../lib/mapbox-gl-draw";
+import MapboxDraw from ".././../index.js";
 import * as CommonSelectors from "../lib/common_selectors.js";
 import * as Constants from '../constants.js';
 //import createSupplementaryPoints from '@mapbox/mapbox-gl-draw/src/lib/create_supplementary_points.js'

package/lib/mapbox-gl-draw/src/lib/common_selectors.js

@@ -55,6 +55,10 @@ export function isEscapeKey(e) {
   return e.keyCode === 27;
 }
 
+export function isRKey(e) {
+  return e.keyCode === 82;
+}
+
 export function isEnterKey(e) {
   return e.keyCode === 13;
 }

package/lib/mapbox-gl-draw/src/lib/geojson-area.js

@@ -0,0 +1,92 @@
+// var wgs84 = require('wgs84');
+import wgs84 from 'wgs84'
+
+// module.exports.geometry = geometry;
+// module.exports.ring = ringArea;
+
+export function geometry(_) {
+    var area = 0, i;
+    switch (_.type) {
+        case 'Polygon':
+            return polygonArea(_.coordinates);
+        case 'MultiPolygon':
+            for (i = 0; i < _.coordinates.length; i++) {
+                area += polygonArea(_.coordinates[i]);
+            }
+            return area;
+        case 'Point':
+        case 'MultiPoint':
+        case 'LineString':
+        case 'MultiLineString':
+            return 0;
+        case 'GeometryCollection':
+            for (i = 0; i < _.geometries.length; i++) {
+                area += geometry(_.geometries[i]);
+            }
+            return area;
+    }
+}
+
+function polygonArea(coords) {
+    var area = 0;
+    if (coords && coords.length > 0) {
+        area += Math.abs(ringArea(coords[0]));
+        for (var i = 1; i < coords.length; i++) {
+            area -= Math.abs(ringArea(coords[i]));
+        }
+    }
+    return area;
+}
+
+/**
+ * Calculate the approximate area of the polygon were it projected onto
+ *     the earth.  Note that this area will be positive if ring is oriented
+ *     clockwise, otherwise it will be negative.
+ *
+ * Reference:
+ * Robert. G. Chamberlain and William H. Duquette, "Some Algorithms for
+ *     Polygons on a Sphere", JPL Publication 07-03, Jet Propulsion
+ *     Laboratory, Pasadena, CA, June 2007 http://trs-new.jpl.nasa.gov/dspace/handle/2014/40409
+ *
+ * Returns:
+ * {float} The approximate signed geodesic area of the polygon in square
+ *     meters.
+ */
+
+function ringArea(coords) {
+    var p1, p2, p3, lowerIndex, middleIndex, upperIndex, i,
+    area = 0,
+    coordsLength = coords.length;
+
+    if (coordsLength > 2) {
+        for (i = 0; i < coordsLength; i++) {
+            if (i === coordsLength - 2) {// i = N-2
+                lowerIndex = coordsLength - 2;
+                middleIndex = coordsLength -1;
+                upperIndex = 0;
+            } else if (i === coordsLength - 1) {// i = N-1
+                lowerIndex = coordsLength - 1;
+                middleIndex = 0;
+                upperIndex = 1;
+            } else { // i = 0 to N-3
+                lowerIndex = i;
+                middleIndex = i+1;
+                upperIndex = i+2;
+            }
+            p1 = coords[lowerIndex];
+            p2 = coords[middleIndex];
+            p3 = coords[upperIndex];
+            area += ( rad(p3[0]) - rad(p1[0]) ) * Math.sin( rad(p2[1]));
+        }
+
+        area = area * wgs84.RADIUS * wgs84.RADIUS / 2;
+    }
+
+    return area;
+}
+
+function rad(_) {
+    return _ * Math.PI / 180;
+}
+
+export const ring = ringArea;

package/lib/mapbox-gl-draw/src/lib/mouse_event_point.js

@@ -1,4 +1,4 @@
-import Point from '@mapbox/point-geometry';
+import * as Point from './point-geometry';
 
 /**
  * Returns a Point representing a mouse event's position

package/lib/mapbox-gl-draw/src/lib/point-geometry.js

@@ -0,0 +1,314 @@
+'use strict';
+
+// module.exports = Point;
+
+/**
+ * A standalone point geometry with useful accessor, comparison, and
+ * modification methods.
+ *
+ * @class Point
+ * @param {Number} x the x-coordinate. this could be longitude or screen
+ * pixels, or any other sort of unit.
+ * @param {Number} y the y-coordinate. this could be latitude or screen
+ * pixels, or any other sort of unit.
+ * @example
+ * var point = new Point(-77, 38);
+ */
+function Point(x, y) {
+    this.x = x;
+    this.y = y;
+}
+
+Point.prototype = {
+
+    /**
+     * Clone this point, returning a new point that can be modified
+     * without affecting the old one.
+     * @return {Point} the clone
+     */
+    clone: function() { return new Point(this.x, this.y); },
+
+    /**
+     * Add this point's x & y coordinates to another point,
+     * yielding a new point.
+     * @param {Point} p the other point
+     * @return {Point} output point
+     */
+    add:     function(p) { return this.clone()._add(p); },
+
+    /**
+     * Subtract this point's x & y coordinates to from point,
+     * yielding a new point.
+     * @param {Point} p the other point
+     * @return {Point} output point
+     */
+    sub:     function(p) { return this.clone()._sub(p); },
+
+    /**
+     * Multiply this point's x & y coordinates by point,
+     * yielding a new point.
+     * @param {Point} p the other point
+     * @return {Point} output point
+     */
+    multByPoint:    function(p) { return this.clone()._multByPoint(p); },
+
+    /**
+     * Divide this point's x & y coordinates by point,
+     * yielding a new point.
+     * @param {Point} p the other point
+     * @return {Point} output point
+     */
+    divByPoint:     function(p) { return this.clone()._divByPoint(p); },
+
+    /**
+     * Multiply this point's x & y coordinates by a factor,
+     * yielding a new point.
+     * @param {Point} k factor
+     * @return {Point} output point
+     */
+    mult:    function(k) { return this.clone()._mult(k); },
+
+    /**
+     * Divide this point's x & y coordinates by a factor,
+     * yielding a new point.
+     * @param {Point} k factor
+     * @return {Point} output point
+     */
+    div:     function(k) { return this.clone()._div(k); },
+
+    /**
+     * Rotate this point around the 0, 0 origin by an angle a,
+     * given in radians
+     * @param {Number} a angle to rotate around, in radians
+     * @return {Point} output point
+     */
+    rotate:  function(a) { return this.clone()._rotate(a); },
+
+    /**
+     * Rotate this point around p point by an angle a,
+     * given in radians
+     * @param {Number} a angle to rotate around, in radians
+     * @param {Point} p Point to rotate around
+     * @return {Point} output point
+     */
+    rotateAround:  function(a,p) { return this.clone()._rotateAround(a,p); },
+
+    /**
+     * Multiply this point by a 4x1 transformation matrix
+     * @param {Array<Number>} m transformation matrix
+     * @return {Point} output point
+     */
+    matMult: function(m) { return this.clone()._matMult(m); },
+
+    /**
+     * Calculate this point but as a unit vector from 0, 0, meaning
+     * that the distance from the resulting point to the 0, 0
+     * coordinate will be equal to 1 and the angle from the resulting
+     * point to the 0, 0 coordinate will be the same as before.
+     * @return {Point} unit vector point
+     */
+    unit:    function() { return this.clone()._unit(); },
+
+    /**
+     * Compute a perpendicular point, where the new y coordinate
+     * is the old x coordinate and the new x coordinate is the old y
+     * coordinate multiplied by -1
+     * @return {Point} perpendicular point
+     */
+    perp:    function() { return this.clone()._perp(); },
+
+    /**
+     * Return a version of this point with the x & y coordinates
+     * rounded to integers.
+     * @return {Point} rounded point
+     */
+    round:   function() { return this.clone()._round(); },
+
+    /**
+     * Return the magitude of this point: this is the Euclidean
+     * distance from the 0, 0 coordinate to this point's x and y
+     * coordinates.
+     * @return {Number} magnitude
+     */
+    mag: function() {
+        return Math.sqrt(this.x * this.x + this.y * this.y);
+    },
+
+    /**
+     * Judge whether this point is equal to another point, returning
+     * true or false.
+     * @param {Point} other the other point
+     * @return {boolean} whether the points are equal
+     */
+    equals: function(other) {
+        return this.x === other.x &&
+               this.y === other.y;
+    },
+
+    /**
+     * Calculate the distance from this point to another point
+     * @param {Point} p the other point
+     * @return {Number} distance
+     */
+    dist: function(p) {
+        return Math.sqrt(this.distSqr(p));
+    },
+
+    /**
+     * Calculate the distance from this point to another point,
+     * without the square root step. Useful if you're comparing
+     * relative distances.
+     * @param {Point} p the other point
+     * @return {Number} distance
+     */
+    distSqr: function(p) {
+        var dx = p.x - this.x,
+            dy = p.y - this.y;
+        return dx * dx + dy * dy;
+    },
+
+    /**
+     * Get the angle from the 0, 0 coordinate to this point, in radians
+     * coordinates.
+     * @return {Number} angle
+     */
+    angle: function() {
+        return Math.atan2(this.y, this.x);
+    },
+
+    /**
+     * Get the angle from this point to another point, in radians
+     * @param {Point} b the other point
+     * @return {Number} angle
+     */
+    angleTo: function(b) {
+        return Math.atan2(this.y - b.y, this.x - b.x);
+    },
+
+    /**
+     * Get the angle between this point and another point, in radians
+     * @param {Point} b the other point
+     * @return {Number} angle
+     */
+    angleWith: function(b) {
+        return this.angleWithSep(b.x, b.y);
+    },
+
+    /*
+     * Find the angle of the two vectors, solving the formula for
+     * the cross product a x b = |a||b|sin(θ) for θ.
+     * @param {Number} x the x-coordinate
+     * @param {Number} y the y-coordinate
+     * @return {Number} the angle in radians
+     */
+    angleWithSep: function(x, y) {
+        return Math.atan2(
+            this.x * y - this.y * x,
+            this.x * x + this.y * y);
+    },
+
+    _matMult: function(m) {
+        var x = m[0] * this.x + m[1] * this.y,
+            y = m[2] * this.x + m[3] * this.y;
+        this.x = x;
+        this.y = y;
+        return this;
+    },
+
+    _add: function(p) {
+        this.x += p.x;
+        this.y += p.y;
+        return this;
+    },
+
+    _sub: function(p) {
+        this.x -= p.x;
+        this.y -= p.y;
+        return this;
+    },
+
+    _mult: function(k) {
+        this.x *= k;
+        this.y *= k;
+        return this;
+    },
+
+    _div: function(k) {
+        this.x /= k;
+        this.y /= k;
+        return this;
+    },
+
+    _multByPoint: function(p) {
+        this.x *= p.x;
+        this.y *= p.y;
+        return this;
+    },
+
+    _divByPoint: function(p) {
+        this.x /= p.x;
+        this.y /= p.y;
+        return this;
+    },
+
+    _unit: function() {
+        this._div(this.mag());
+        return this;
+    },
+
+    _perp: function() {
+        var y = this.y;
+        this.y = this.x;
+        this.x = -y;
+        return this;
+    },
+
+    _rotate: function(angle) {
+        var cos = Math.cos(angle),
+            sin = Math.sin(angle),
+            x = cos * this.x - sin * this.y,
+            y = sin * this.x + cos * this.y;
+        this.x = x;
+        this.y = y;
+        return this;
+    },
+
+    _rotateAround: function(angle, p) {
+        var cos = Math.cos(angle),
+            sin = Math.sin(angle),
+            x = p.x + cos * (this.x - p.x) - sin * (this.y - p.y),
+            y = p.y + sin * (this.x - p.x) + cos * (this.y - p.y);
+        this.x = x;
+        this.y = y;
+        return this;
+    },
+
+    _round: function() {
+        this.x = Math.round(this.x);
+        this.y = Math.round(this.y);
+        return this;
+    }
+};
+
+/**
+ * Construct a point from an array if necessary, otherwise if the input
+ * is already a Point, or an unknown type, return it unchanged
+ * @param {Array<Number>|Point|*} a any kind of input value
+ * @return {Point} constructed point, or passed-through value.
+ * @example
+ * // this
+ * var point = Point.convert([0, 1]);
+ * // is equivalent to
+ * var point = new Point(0, 1);
+ */
+Point.convert = function (a) {
+    if (a instanceof Point) {
+        return a;
+    }
+    if (Array.isArray(a)) {
+        return new Point(a[0], a[1]);
+    }
+    return a;
+};
+
+export default Point;

package/lib/mapbox-gl-draw/src/lib/sort_features.js

@@ -1,4 +1,4 @@
-import area from '@mapbox/geojson-area';
+import * as area from './geojson-area.js';
 import * as Constants from '../constants.js';
 
 const FEATURE_SORT_RANKS = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ohuoy/easymap",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "description": "self map easy use",
   "main": "main.js",
   "scripts": {

package/src/components/control/DrawBar.js

@@ -1,9 +1,9 @@
 
 import MapboxDraw from "../../../lib/mapbox-gl-draw";
-import rect from './extendMode/rectmode'
+import rect from '../../../lib/mapbox-gl-draw/src/extendMode/rectmode'
 import ExtendControlList from './ExtendControlList.js'
-import simple_select_rect from "./extendMode/simple_select_rect.js";
-import direct_select_rect from "./extendMode/direct_select_rect.js"; 
+import simple_select_rect from "../../../lib/mapbox-gl-draw/src/extendMode/simple_select_rect.js";
+import direct_select_rect from "../../../lib/mapbox-gl-draw/src/extendMode/direct_select_rect.js"; 
 export default class DrawBar {
     drawEntity = null
     drawing = false

package/src/components/control/constants.js

@@ -1,101 +0,0 @@
-export const classes = {
-  CANVAS: 'mapboxgl-canvas',
-  CONTROL_BASE: 'mapboxgl-ctrl',
-  CONTROL_PREFIX: 'mapboxgl-ctrl-',
-  CONTROL_BUTTON: 'mapbox-gl-draw_ctrl-draw-btn',
-  CONTROL_BUTTON_LINE: 'mapbox-gl-draw_line',
-  CONTROL_BUTTON_POLYGON: 'mapbox-gl-draw_polygon',
-  CONTROL_BUTTON_POINT: 'mapbox-gl-draw_point',
-  CONTROL_BUTTON_TRASH: 'mapbox-gl-draw_trash',
-  CONTROL_BUTTON_COMBINE_FEATURES: 'mapbox-gl-draw_combine',
-  CONTROL_BUTTON_UNCOMBINE_FEATURES: 'mapbox-gl-draw_uncombine',
-  CONTROL_GROUP: 'mapboxgl-ctrl-group',
-  ATTRIBUTION: 'mapboxgl-ctrl-attrib',
-  ACTIVE_BUTTON: 'active',
-  BOX_SELECT: 'mapbox-gl-draw_boxselect'
-};
-
-export const sources = {
-  HOT: 'mapbox-gl-draw-hot',
-  COLD: 'mapbox-gl-draw-cold'
-};
-
-export const cursors = {
-  ADD: 'add',
-  MOVE: 'move',
-  DRAG: 'drag',
-  POINTER: 'pointer',
-  NONE: 'none'
-};
-
-export const types = {
-  POLYGON: 'polygon',
-  LINE: 'line_string',
-  POINT: 'point'
-};
-
-export const geojsonTypes = {
-  FEATURE: 'Feature',
-  POLYGON: 'Polygon',
-  LINE_STRING: 'LineString',
-  POINT: 'Point',
-  FEATURE_COLLECTION: 'FeatureCollection',
-  MULTI_PREFIX: 'Multi',
-  MULTI_POINT: 'MultiPoint',
-  MULTI_LINE_STRING: 'MultiLineString',
-  MULTI_POLYGON: 'MultiPolygon'
-};
-
-export const modes = {
-  DRAW_LINE_STRING: 'draw_line_string',
-  DRAW_POLYGON: 'draw_polygon',
-  DRAW_POINT: 'draw_point',
-  SIMPLE_SELECT: 'simple_select',
-  DIRECT_SELECT: 'direct_select'
-};
-
-export const events = {
-  CREATE: 'draw.create',
-  DELETE: 'draw.delete',
-  UPDATE: 'draw.update',
-  SELECTION_CHANGE: 'draw.selectionchange',
-  MODE_CHANGE: 'draw.modechange',
-  ACTIONABLE: 'draw.actionable',
-  RENDER: 'draw.render',
-  COMBINE_FEATURES: 'draw.combine',
-  UNCOMBINE_FEATURES: 'draw.uncombine'
-};
-
-export const updateActions = {
-  MOVE: 'move',
-  CHANGE_PROPERTIES: 'change_properties',
-  CHANGE_COORDINATES: 'change_coordinates'
-};
-
-export const meta = {
-  FEATURE: 'feature',
-  MIDPOINT: 'midpoint',
-  VERTEX: 'vertex'
-};
-
-export const activeStates = {
-  ACTIVE: 'true',
-  INACTIVE: 'false'
-};
-
-export const interactions = [
-  'scrollZoom',
-  'boxZoom',
-  'dragRotate',
-  'dragPan',
-  'keyboard',
-  'doubleClickZoom',
-  'touchZoomRotate'
-];
-
-export const LAT_MIN = -90;
-export const LAT_RENDERED_MIN = -85;
-export const LAT_MAX = 90;
-export const LAT_RENDERED_MAX = 85;
-export const LNG_MIN = -270;
-export const LNG_MAX = 270;

package/src/components/control/lib/common_selectors.js

@@ -1,68 +0,0 @@
-import * as Constants from '../constants.js';
-
-export function isOfMetaType(type) {
-  return function(e) {
-    const featureTarget = e.featureTarget;
-    if (!featureTarget) return false;
-    if (!featureTarget.properties) return false;
-    return featureTarget.properties.meta === type;
-  };
-}
-
-export function isShiftMousedown(e) {
-  if (!e.originalEvent) return false;
-  if (!e.originalEvent.shiftKey) return false;
-  return e.originalEvent.button === 0;
-}
-
-export function isActiveFeature(e) {
-  if (!e.featureTarget) return false;
-  if (!e.featureTarget.properties) return false;
-  return e.featureTarget.properties.active === Constants.activeStates.ACTIVE &&
-    e.featureTarget.properties.meta === Constants.meta.FEATURE;
-}
-
-export function isInactiveFeature(e) {
-  if (!e.featureTarget) return false;
-  if (!e.featureTarget.properties) return false;
-  return e.featureTarget.properties.active === Constants.activeStates.INACTIVE &&
-    e.featureTarget.properties.meta === Constants.meta.FEATURE;
-}
-
-export function noTarget(e) {
-  return e.featureTarget === undefined;
-}
-
-export function isFeature(e) {
-  if (!e.featureTarget) return false;
-  if (!e.featureTarget.properties) return false;
-  return e.featureTarget.properties.meta === Constants.meta.FEATURE;
-}
-
-export function isVertex(e) {
-  const featureTarget = e.featureTarget;
-  if (!featureTarget) return false;
-  if (!featureTarget.properties) return false;
-  return featureTarget.properties.meta === Constants.meta.VERTEX;
-}
-
-export function isShiftDown(e) {
-  if (!e.originalEvent) return false;
-  return e.originalEvent.shiftKey === true;
-}
-
-export function isEscapeKey(e) {
-  return e.keyCode === 27;
-}
-
-export function isRKey(e) {
-  return e.keyCode === 82;
-}
-
-export function isEnterKey(e) {
-  return e.keyCode === 13;
-}
-
-export function isTrue() {
-  return true;
-}