@ohos-ports/jsvectormap 1.7.0-beta.0

package/src/js/projection.js

@@ -0,0 +1,127 @@
+
+/**
+ * ------------------------------------------------------------------------
+ * Object
+ * ------------------------------------------------------------------------
+ */
+const Proj = {
+
+  /* sgn(n){
+    if (n > 0) {
+      return 1;
+    } else if (n < 0) {
+      return -1;
+    } else {
+      return n;
+    }
+  }, */
+
+  mill(lat, lng, c) {
+    return {
+      x: this.radius * (lng - c) * this.radDeg,
+      y: - this.radius * Math.log(Math.tan((45 + 0.4 * lat) * this.radDeg)) / 0.8
+    };
+  },
+
+  /* mill_inv(x, y, c) {
+    return {
+      lat: (2.5 * Math.atan(Math.exp(0.8 * y / this.radius)) - 5 * Math.PI / 8) * this.degRad,
+      lng: (c * this.radDeg + x / this.radius) * this.degRad
+    };
+  }, */
+
+  merc(lat, lng, c) {
+    return {
+      x: this.radius * (lng - c) * this.radDeg,
+      y: - this.radius * Math.log(Math.tan(Math.PI / 4 + lat * Math.PI / 360))
+    };
+  },
+
+  /* merc_inv(x, y, c) {
+    return {
+      lat: (2 * Math.atan(Math.exp(y / this.radius)) - Math.PI / 2) * this.degRad,
+      lng: (c * this.radDeg + x / this.radius) * this.degRad
+    };
+  }, */
+
+  aea(lat, lng, c) {
+    var fi0 = 0,
+        lambda0 = c * this.radDeg,
+        fi1 = 29.5 * this.radDeg,
+        fi2 = 45.5 * this.radDeg,
+        fi = lat * this.radDeg,
+        lambda = lng * this.radDeg,
+        n = (Math.sin(fi1)+Math.sin(fi2)) / 2,
+        C = Math.cos(fi1)*Math.cos(fi1)+2*n*Math.sin(fi1),
+        theta = n*(lambda-lambda0),
+        ro = Math.sqrt(C-2*n*Math.sin(fi))/n,
+        ro0 = Math.sqrt(C-2*n*Math.sin(fi0))/n;
+
+    return {
+      x: ro * Math.sin(theta) * this.radius,
+      y: - (ro0 - ro * Math.cos(theta)) * this.radius
+    };
+  },
+
+  /* aea_inv(xCoord, yCoord, c) {
+    var x = xCoord / this.radius,
+        y = yCoord / this.radius,
+        fi0 = 0,
+        lambda0 = c * this.radDeg,
+        fi1 = 29.5 * this.radDeg,
+        fi2 = 45.5 * this.radDeg,
+        n = (Math.sin(fi1)+Math.sin(fi2)) / 2,
+        C = Math.cos(fi1)*Math.cos(fi1)+2*n*Math.sin(fi1),
+        ro0 = Math.sqrt(C-2*n*Math.sin(fi0))/n,
+        ro = Math.sqrt(x*x+(ro0-y)*(ro0-y)),
+        theta = Math.atan( x / (ro0 - y) );
+
+    return {
+      lat: (Math.asin((C - ro * ro * n * n) / (2 * n))) * this.degRad,
+      lng: (lambda0 + theta / n) * this.degRad
+    };
+  }, */
+
+  lcc(lat, lng, c) {
+    var fi0 = 0,
+        lambda0 = c * this.radDeg,
+        lambda = lng * this.radDeg,
+        fi1 = 33 * this.radDeg,
+        fi2 = 45 * this.radDeg,
+        fi = lat * this.radDeg,
+        n = Math.log(Math.cos(fi1) * (1 / Math.cos(fi2)) ) / Math.log(Math.tan(Math.PI / 4 + fi2 / 2) * (1 / Math.tan(Math.PI / 4 + fi1 / 2) )),
+        F = (Math.cos(fi1) * Math.pow(Math.tan(Math.PI / 4 + fi1 / 2 ), n )) / n,
+        ro = F * Math.pow(1 / Math.tan(Math.PI / 4 + fi / 2), n),
+        ro0 = F * Math.pow(1 / Math.tan(Math.PI / 4 + fi0 / 2), n);
+
+    return {
+      x: ro * Math.sin(n * (lambda - lambda0)) * this.radius,
+      y: - (ro0 - ro * Math.cos(n * (lambda - lambda0))) * this.radius
+    };
+  },
+
+  /* lcc_inv(xCoord, yCoord, c) {
+    var x = xCoord / this.radius,
+        y = yCoord / this.radius,
+        fi0 = 0,
+        lambda0 = c * this.radDeg,
+        fi1 = 33 * this.radDeg,
+        fi2 = 45 * this.radDeg,
+        n = Math.log( Math.cos(fi1) * (1 / Math.cos(fi2)) ) / Math.log( Math.tan( Math.PI / 4 + fi2 / 2) * (1 / Math.tan( Math.PI / 4 + fi1 / 2) ) ),
+        F = ( Math.cos(fi1) * Math.pow( Math.tan( Math.PI / 4 + fi1 / 2 ), n ) ) / n,
+        ro0 = F * Math.pow( 1 / Math.tan( Math.PI / 4 + fi0 / 2 ), n ),
+        ro = this.sgn(n) * Math.sqrt(x*x+(ro0-y)*(ro0-y)),
+        theta = Math.atan( x / (ro0 - y) );
+
+    return {
+      lat: (2 * Math.atan(Math.pow(F/ro, 1/n)) - Math.PI / 2) * this.degRad,
+      lng: (lambda0 + theta / n) * this.degRad
+    };
+  } */
+}
+
+Proj.degRad = 180 / Math.PI
+Proj.radDeg = Math.PI / 180
+Proj.radius = 6381372
+
+export default Proj

package/src/js/scales/ordinalScale.js

@@ -0,0 +1,21 @@
+class OrdinalScale {
+  constructor(scale) {
+    this._scale = scale
+  }
+
+  getValue(value){
+    return this._scale[value]
+  }
+
+  getTicks() {
+    const ticks = []
+
+    for (let key in this._scale) {
+      ticks.push({ label: key, value: this._scale[key] })
+    }
+
+    return ticks
+  }
+}
+
+export default OrdinalScale

package/src/js/series.js

@@ -0,0 +1,68 @@
+import { merge } from './util/index'
+import Legend from './legend'
+import OrdinalScale from './scales/ordinalScale'
+
+class Series {
+  constructor(config = {}, elements, map) {
+    // Private
+    this._map = map
+    this._elements = elements // Could be markers or regions
+    this._values = config.values || {}
+
+    // Protected
+    this.config = config
+    this.config.attribute = config.attribute || 'fill'
+
+    // Set initial attributes
+    if (config.attributes) {
+      this.setAttributes(config.attributes)
+    }
+
+    if (typeof config.scale === 'object') {
+      this.scale = new OrdinalScale(config.scale)
+    }
+
+    if (this.config.legend) {
+      this.legend = new Legend(
+        merge({ map: this._map, series: this }, this.config.legend)
+      )
+    }
+
+    this.setValues(this._values)
+  }
+
+  setValues(values) {
+    let attrs = {}
+
+    for (let key in values) {
+      if (values[key]) {
+        attrs[key] = this.scale.getValue(values[key])
+      }
+    }
+
+    this.setAttributes(attrs)
+  }
+
+  setAttributes(attrs) {
+    for (let code in attrs) {
+      if (this._elements[code]) {
+        this._elements[code].element.setStyle(this.config.attribute, attrs[code])
+      }
+    }
+  }
+
+  clear() {
+    let key, attrs = {}
+
+    for (key in this._values) {
+      if (this._elements[key]) {
+        attrs[key] = this._elements[key].element.shape.style.initial[this.config.attribute]
+      }
+    }
+
+    this.setAttributes(attrs)
+    this._values = {}
+  }
+}
+
+export default Series

package/src/js/svg/baseElement.js

@@ -0,0 +1,53 @@
+import {
+  hyphenate,
+  removeElement
+} from '../util/index'
+
+class SVGElement {
+  constructor(name, config) {
+    this.node = this._createElement(name)
+
+    if (config) {
+      this.set(config)
+    }
+  }
+
+  // Create new SVG element `svg`, `g`, `path`, `line`, `circle`, `image`, etc.
+  // https://developer.mozilla.org/en-US/docs/Web/API/Document/createElementNS#important_namespace_uris
+  _createElement(tagName) {
+    return document.createElementNS('http://www.w3.org/2000/svg', tagName)
+  }
+
+  addClass(className) {
+    this.node.setAttribute('class', className)
+  }
+
+  getBBox() {
+    return this.node.getBBox()
+  }
+
+  // Apply attributes on the current node element
+  set(property, value) {
+    if (typeof property === 'object') {
+      for (let attr in property) {
+        this.applyAttr(attr, property[attr])
+      }
+    } else {
+      this.applyAttr(property, value)
+    }
+  }
+
+  get(property) {
+    return this.style.initial[property]
+  }
+
+  applyAttr(property, value) {
+    this.node.setAttribute(hyphenate(property), value)
+  }
+
+  remove() {
+    removeElement(this.node)
+  }
+}
+
+export default SVGElement

package/src/js/svg/canvasElement.js

@@ -0,0 +1,99 @@
+import SVGElement from './baseElement'
+import SVGShapeElement from './shapeElement'
+import SVGTextElement from './textElement'
+import SVGImageElement from './imageElement'
+
+class SVGCanvasElement extends SVGElement {
+  constructor(container) {
+    super('svg') // Create svg element for holding the whole map
+
+    this._container = container
+
+    // Create the defs element
+    this._defsElement = new SVGElement('defs')
+
+    // Create group element which will hold the paths (regions)
+    this._rootElement = new SVGElement('g', { id: 'jvm-regions-group' })
+
+    // Append the defs element to the this.node (SVG tag)
+    this.node.appendChild(this._defsElement.node)
+
+    // Append the group to this.node (SVG tag)
+    this.node.appendChild(this._rootElement.node)
+
+    // Append this.node (SVG tag) to the container
+    this._container.appendChild(this.node)
+  }
+
+  setSize(width, height) {
+    this.node.setAttribute('width', width)
+    this.node.setAttribute('height', height)
+  }
+
+  applyTransformParams(scale, transX, transY) {
+    this._rootElement.node.setAttribute('transform', `scale(${scale}) translate(${transX}, ${transY})`)
+  }
+
+  // Create `path` element
+  createPath(config, style, group) {
+    const path = new SVGShapeElement('path', config, style)
+
+    path.node.setAttribute('fill-rule', 'evenodd')
+
+    return this._add(path, group)
+  }
+
+  // Create `circle` element
+  createCircle(config, style, group) {
+    const circle = new SVGShapeElement('circle', config, style)
+
+    return this._add(circle, group)
+  }
+
+  // Create `line` element
+  createLine(config, style, group) {
+    const line = new SVGShapeElement('line', config, style)
+
+    return this._add(line, group)
+  }
+
+  // Create `text` element
+  createText(config, style, group) {
+    const text = new SVGTextElement(config, style)
+
+    return this._add(text, group)
+  }
+
+  // Create `image` element
+  createImage(config, style, group) {
+    const image = new SVGImageElement(config, style)
+
+    return this._add(image, group)
+  }
+
+  // Create `g` element
+  createGroup(id) {
+    const group = new SVGElement('g')
+
+    this.node.appendChild(group.node)
+
+    if (id) {
+      group.node.id = id
+    }
+
+    group.canvas = this
+
+    return group
+  }
+
+  // Add some element to a spcific group or the root element if the group isn't given
+  _add(element, group) {
+    group = group || this._rootElement
+
+    group.node.appendChild(element.node)
+
+    return element
+  }
+}
+
+export default SVGCanvasElement

package/src/js/svg/imageElement.js

@@ -0,0 +1,49 @@
+import SVGShapeElement from './shapeElement'
+
+class SVGImageElement extends SVGShapeElement {
+  constructor(config, style) {
+    super('image', config, style)
+  }
+
+  applyAttr(attr, value) {
+    let imageUrl
+
+    if (attr === 'image') {
+      // This get executed when we have url in series.markers[0].scale.someScale.url
+      if (typeof value === 'object') {
+        imageUrl = value.url
+        this.offset = value.offset || [0, 0]
+      } else {
+        imageUrl = value
+        this.offset = [0, 0]
+      }
+
+      this.node.setAttributeNS('http://www.w3.org/1999/xlink', 'href', imageUrl)
+
+      // Set width and height then call this `applyAttr` again
+      this.width = 23
+      this.height = 23
+      this.applyAttr('width', this.width)
+      this.applyAttr('height', this.height)
+      this.applyAttr('x', this.cx - this.width / 2 + this.offset[0])
+      this.applyAttr('y', this.cy - this.height / 2 + this.offset[1])
+    } else if (attr == 'cx') {
+      this.cx = value
+
+      if (this.width) {
+        this.applyAttr('x', value - this.width / 2 + this.offset[0])
+      }
+    } else if (attr == 'cy') {
+      this.cy = value
+
+      if (this.height) {
+        this.applyAttr('y', value - this.height / 2 + this.offset[1])
+      }
+    } else {
+      // This time Call SVGElement
+      super.applyAttr.apply(this, arguments)
+    }
+  }
+}
+
+export default SVGImageElement

package/src/js/svg/shapeElement.js

@@ -0,0 +1,48 @@
+import { merge } from '../util/index'
+import SVGElement from './baseElement'
+
+class SVGShapeElement extends SVGElement {
+  constructor(name, config, style = {}) {
+    super(name, config)
+
+    this.isHovered = false
+    this.isSelected = false
+    this.style = style
+    this.style.current = {}
+
+    this.updateStyle()
+  }
+
+  setStyle(property, value) {
+    if (typeof property === 'object') {
+      merge(this.style.current, property)
+    } else {
+      merge(this.style.current, { [property]: value })
+    }
+
+    this.updateStyle()
+  }
+
+  updateStyle() {
+    const attrs = {}
+
+    merge(attrs, this.style.initial)
+    merge(attrs, this.style.current)
+
+    if (this.isHovered) {
+      merge(attrs, this.style.hover)
+    }
+
+    if (this.isSelected) {
+      merge(attrs, this.style.selected)
+
+      if (this.isHovered) {
+        merge(attrs, this.style.selectedHover)
+      }
+    }
+
+    this.set(attrs)
+  }
+}
+
+export default SVGShapeElement

package/src/js/svg/textElement.js

@@ -0,0 +1,13 @@
+import SVGShapeElement from './shapeElement'
+
+class SVGTextElement extends SVGShapeElement {
+  constructor(config, style) {
+    super('text', config, style)
+  }
+
+  applyAttr(attr, value) {
+    attr === 'text' ? this.node.textContent = value : super.applyAttr(attr, value)
+  }
+}
+
+export default SVGTextElement

package/src/js/util/deepMerge.js

@@ -0,0 +1,129 @@
+/**
+ * By https://github.com/TehShrike/deepmerge
+ */
+'use strict'
+
+var isMergeableObject = function isMergeableObject(value) {
+	return isNonNullObject(value)
+		&& !isSpecial(value)
+}
+
+function isNonNullObject(value) {
+	return !!value && typeof value === 'object'
+}
+
+function isSpecial(value) {
+	var stringValue = Object.prototype.toString.call(value)
+
+	return stringValue === '[object RegExp]'
+		|| stringValue === '[object Date]'
+    || isNode(value)
+		|| isReactElement(value)
+}
+
+// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25
+var canUseSymbol = typeof Symbol === 'function' && Symbol.for
+var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7
+
+function isReactElement(value) {
+	return value.$$typeof === REACT_ELEMENT_TYPE
+}
+
+function isNode(value) {
+  return value instanceof Node
+}
+
+function emptyTarget(val) {
+	return Array.isArray(val) ? [] : {}
+}
+
+function cloneUnlessOtherwiseSpecified(value, options) {
+	return (options.clone !== false && options.isMergeableObject(value))
+		? deepmerge(emptyTarget(value), value, options)
+		: value
+}
+
+function defaultArrayMerge(target, source, options) {
+	return target.concat(source).map(function(element) {
+		return cloneUnlessOtherwiseSpecified(element, options)
+	})
+}
+
+function getMergeFunction(key, options) {
+	if (!options.customMerge) {
+		return deepmerge
+	}
+	var customMerge = options.customMerge(key)
+	return typeof customMerge === 'function' ? customMerge : deepmerge
+}
+
+function getEnumerableOwnPropertySymbols(target) {
+	return Object.getOwnPropertySymbols
+		? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+			return target.propertyIsEnumerable(symbol)
+		})
+		: []
+}
+
+function getKeys(target) {
+	return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))
+}
+
+function propertyIsOnObject(object, property) {
+	try {
+		return property in object
+	} catch(_) {
+		return false
+	}
+}
+
+// Protects from prototype poisoning and unexpected merging up the prototype chain.
+function propertyIsUnsafe(target, key) {
+	return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,
+		&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,
+			&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.
+}
+
+function mergeObject(target, source, options) {
+	var destination = {}
+	if (options.isMergeableObject(target)) {
+		getKeys(target).forEach(function(key) {
+			destination[key] = cloneUnlessOtherwiseSpecified(target[key], options)
+		})
+	}
+	getKeys(source).forEach(function(key) {
+		if (propertyIsUnsafe(target, key)) {
+			return
+		}
+
+		if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
+			destination[key] = getMergeFunction(key, options)(target[key], source[key], options)
+		} else {
+			destination[key] = cloneUnlessOtherwiseSpecified(source[key], options)
+		}
+	})
+	return destination
+}
+
+var deepmerge = function (target, source, options) {
+	options = options || {}
+	options.arrayMerge = options.arrayMerge || defaultArrayMerge
+	options.isMergeableObject = options.isMergeableObject || isMergeableObject
+	// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()
+	// implementations can use it. The caller may not replace it.
+	options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified
+
+	var sourceIsArray = Array.isArray(source)
+	var targetIsArray = Array.isArray(target)
+	var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray
+
+	if (!sourceAndTargetTypesMatch) {
+		return cloneUnlessOtherwiseSpecified(source, options)
+	} else if (sourceIsArray) {
+		return options.arrayMerge(target, source, options)
+	} else {
+		return mergeObject(target, source, options)
+	}
+}
+
+export default deepmerge

package/src/js/util/index.js

@@ -0,0 +1,81 @@
+import DeepMerge from './deepMerge'
+
+/**
+ * --------------------------------------------------------------------------
+ * Public Util Api
+ * --------------------------------------------------------------------------
+ */
+const getElement = selector => {
+  if (typeof selector === 'object' && typeof selector.nodeType !== 'undefined') {
+    return selector
+  }
+
+  if (typeof selector === 'string') {
+    return document.querySelector(selector)
+  }
+
+  return null
+}
+
+const createElement = (type, classes, content, html = false) => {
+  let el = document.createElement(type)
+
+  if (content) {
+    el[!html ? 'textContent' : 'innerHTML'] = content
+  }
+
+  if (classes) {
+    el.className = classes
+  }
+
+  return el
+}
+
+const findElement = (parentElement, selector) => {
+  return Element.prototype.querySelector.call(parentElement, selector)
+}
+
+const removeElement = target => {
+  target.parentNode.removeChild(target)
+}
+
+const isImageUrl = url => {
+  return /\.(jpg|gif|png)$/.test(url)
+}
+
+const hyphenate = string => {
+  return string.replace(/[\w]([A-Z])/g, m => `${m[0]}-${m[1]}`).toLowerCase()
+}
+
+const merge = (target, source, deep = false) => {
+  if (deep) {
+    return DeepMerge(target, source)
+  }
+
+  return Object.assign(target, source)
+}
+
+const keys = object => {
+  return Object.keys(object)
+}
+
+const getLineUid = (from, to) => {
+  return `${from.toLowerCase()}:to:${to.toLowerCase()}`
+}
+
+const inherit = (target, source) => {
+  Object.assign(target.prototype, source)
+}
+
+export {
+  getElement,
+  createElement,
+  findElement,
+  removeElement,
+  isImageUrl,
+  hyphenate,
+  merge,
+  keys,
+  getLineUid,
+  inherit,
+}