@supermapgis/vue-iclient-leaflet 11.2.0

package/src/common/_utils/util.js

@@ -0,0 +1,251 @@
+// 获取当前时间返回置顶格式
+import { geti18n } from 'vue-iclient/src/common/_lang/index';
+import colorcolor from 'colorcolor';
+import getCenter from '@turf/center';
+import omit from 'omit.js';
+import tinyColor from 'tinycolor2';
+import { min, max as statisticsMax, mean, sum, mode, median, variance, standardDeviation } from 'simple-statistics';
+
+export function getDateTime(timeType) {
+  return geti18n().d(new Date(), timeType.replace(/\+/g, '_'));
+}
+// hex -> rgba
+export function hexToRgba(hex, opacity) {
+  return (
+    'rgba(' +
+    parseInt('0x' + hex.slice(1, 3)) +
+    ',' +
+    parseInt('0x' + hex.slice(3, 5)) +
+    ',' +
+    parseInt('0x' + hex.slice(5, 7)) +
+    ',' +
+    opacity +
+    ')'
+  );
+}
+export function formatFontSize(fontSize) {
+  return typeof fontSize === 'number' ? fontSize + 'px' : fontSize;
+}
+
+export function isTransparent(color) {
+  const rgba = colorcolor(color, 'rgba');
+  return +rgba.match(/(\d(\.\d+)?)+/g)[3] === 0;
+}
+// 保留指定位数的小数
+export function reservedDecimal(val, precise) {
+  return Number(val).toFixed(precise);
+}
+// 清除数字（字符串型的）的逗号
+export function clearNumberComma(num) {
+  if (num.replace) {
+    num = num.replace(/,/g, '');
+  }
+  return num;
+}
+/**
+ * 判断是否地理X坐标
+ * @param data
+ */
+export function isXField(data) {
+  let lowerdata = data.toLowerCase();
+  return (
+    lowerdata === 'x' ||
+    lowerdata === 'smx' ||
+    lowerdata === 'jd' ||
+    lowerdata === '经度' ||
+    lowerdata === '东经' ||
+    lowerdata === 'longitude' ||
+    lowerdata === 'lot' ||
+    lowerdata === 'lon' ||
+    lowerdata === 'long' ||
+    lowerdata === 'lng' ||
+    lowerdata === 'x坐标'
+  );
+}
+
+/**
+ * 判断是否地理Y坐标
+ * @param data
+ */
+export function isYField(data) {
+  let lowerdata = data.toLowerCase();
+  return (
+    lowerdata === 'y' ||
+    lowerdata === 'smy' ||
+    lowerdata === 'wd' ||
+    lowerdata === '纬度' ||
+    lowerdata === '北纬' ||
+    lowerdata === 'latitude' ||
+    lowerdata === 'lat' ||
+    lowerdata === 'y坐标'
+  );
+}
+
+export function getColorWithOpacity(color, opacity, isStack = true) {
+  if (!color) {
+    return color;
+  }
+  const originColor = tinyColor(color);
+  const originOpacity = originColor.getAlpha();
+  if (isStack) {
+    originColor.setAlpha(originOpacity * opacity);
+  } else {
+    originColor.setAlpha(opacity);
+  }
+  const nextColor = originColor.toRgbString();
+  return nextColor;
+}
+
+export function getDerivedColorsByTextColor(textColor, opacity) {
+  if (!textColor) {
+    return textColor;
+  }
+  if (textColor.includes('var')) {
+    return `var(--alpha${opacity * 100})`;
+  }
+  const baseTextColorOpacity = 0.65;
+  const originTextColor = tinyColor(textColor);
+  const originOpacity = originTextColor.getAlpha();
+  originTextColor.setAlpha((originOpacity * opacity) / baseTextColorOpacity);
+  const derivedColor = originTextColor.toRgbString();
+  return derivedColor;
+}
+
+export function parseUrl(url) {
+  const urlRe = /^(\w+):\/\/([^/?]*)(\/[^?]+)?\??(.+)?/;
+  return url.match(urlRe);
+}
+
+export function getDataType(data) {
+  return Object.prototype.toString.call(data);
+}
+
+// 判断输入的地址是否符合地址格式
+export function isMatchUrl(str) {
+  let reg = new RegExp('(https?|http|file|ftp)://[-A-Za-z0-9+&@#/%?=~_|!:,.;]+[-A-Za-z0-9+&@#/%=~_|]');
+  return reg.test(str);
+}
+// 判断是否为日期
+export function isDate(data) {
+  let reg = /((^((1[8-9]\d{2})|([2-9]\d{3}))([-\/\._])(10|12|0?[13578])([-\/\._])(3[01]|[12][0-9]|0?[1-9])$)|(^((1[8-9]\d{2})|([2-9]\d{3}))([-\/\._])(11|0?[469])([-\/\._])(30|[12][0-9]|0?[1-9])$)|(^((1[8-9]\d{2})|([2-9]\d{3}))([-\/\._])(0?2)([-\/\._])(2[0-8]|1[0-9]|0?[1-9])$)|(^([2468][048]00)([-\/\._])(0?2)([-\/\._])(29)$)|(^([3579][26]00)([-\/\._])(0?2)([-\/\._])(29)$)|(^([1][89][0][48])([-\/\._])(0?2)([-\/\._])(29)$)|(^([2-9][0-9][0][48])([-\/\._])(0?2)([-\/\._])(29)$)|(^([1][89][2468][048])([-\/\._])(0?2)([-\/\._])(29)$)|(^([2-9][0-9][2468][048])([-\/\._])(0?2)([-\/\._])(29)$)|(^([1][89][13579][26])([-\/\._])(0?2)([-\/\._])(29)$)|(^([2-9][0-9][13579][26])([-\/\._])(0?2)([-\/\._])(29)$))/gi;
+  return reg.test(data);
+}
+
+// 判断是否为数值
+export function isNumber(data) {
+  let mdata = Number(data);
+  if (mdata === 0) {
+    return true;
+  }
+  return !isNaN(mdata);
+}
+
+export function getFeatureCenter(feature) {
+  const coordinates = ((feature || {}).geometry || {}).coordinates;
+  const hasCoordinates = coordinates && !!coordinates.length;
+  if (!hasCoordinates) {
+    return;
+  }
+  let featureType = feature.geometry.type;
+  let center;
+  if (featureType === 'LineString') {
+    center = coordinates[parseInt(coordinates.length / 2)];
+  } else if (featureType === 'MultiLineString') {
+    let coord = coordinates[parseInt(coordinates.length / 2)];
+    center = coord[parseInt(coord.length / 2)];
+  } else {
+    center = getCenter(feature).geometry.coordinates;
+  }
+  return center;
+}
+
+export function getValueCaseInsensitive(properties, searchKey) {
+  const isObj = getDataType(properties) === '[object Object]';
+  if (!searchKey || !isObj) {
+    return '';
+  }
+  const lowerSearchKey = searchKey.toLocaleLowerCase();
+  for (let key in properties) {
+    if (key.toLocaleLowerCase() === lowerSearchKey) {
+      return properties[key];
+    }
+  }
+  return '';
+}
+
+export function filterInvalidData(datasetOptions, features) {
+  const xFields = datasetOptions.map(item => item.xField);
+  const yFields = datasetOptions.map(item => item.yField);
+  const nextFeatures = features.filter(feature => {
+    const matchXField = xFields.find(item => Object.prototype.hasOwnProperty.call(feature.properties, item));
+    const matchYField = yFields.find(item => ![undefined, null, ''].includes(feature.properties[item]));
+    return !!(matchXField && matchYField);
+  });
+  return nextFeatures;
+}
+export function handleWithCredentials(url, iportalServiceProxyUrl, defaultValue = false) {
+  if (!iportalServiceProxyUrl) {
+    return defaultValue;
+  }
+  return url.indexOf(iportalServiceProxyUrl) >= 0 || defaultValue;
+}
+
+export function handleDataParentRes(url, parentResId, parentResType = 'DATA') {
+  if (!parentResId) {
+    return url;
+  }
+  return urlAppend(url, `parentResType=${parentResType}&parentResId=${parentResId}`);
+}
+export function urlAppend(url, paramStr) {
+  let newUrl = url;
+  if (paramStr) {
+    if (paramStr.indexOf('?') === 0) {
+      paramStr = paramStr.substring(1);
+    }
+    let parts = (url + ' ').split(/[?&]/);
+    newUrl += parts.pop() === ' ' ? paramStr : parts.length ? '&' + paramStr : '?' + paramStr;
+  }
+  return newUrl;
+}
+
+export function objectWithoutProperties(obj, omitKeys = []) {
+  return omit(obj, omitKeys);
+}
+
+export function getDarkenColor(color, amount) {
+  return tinyColor(color).darken(amount).toString();
+}
+
+const ARROW_POSITION_MAP = {
+  top: 'Bottom',
+  bottom: 'Top',
+  left: 'Right',
+  right: 'Left'
+};
+
+export function setPopupArrowStyle(color) {
+  const popup = document.querySelectorAll('.sm-mapboxgl-tabel-popup');
+  if (popup) {
+    popup.forEach(item => {
+      let position = item.className.replace(/.+mapboxgl-popup-anchor-([a-z]+)/, '$1');
+      if (ARROW_POSITION_MAP[position]) {
+        const popupArrow = item.querySelector('.mapboxgl-popup-tip');
+        if (popupArrow) {
+          popupArrow.style[`border${ARROW_POSITION_MAP[position]}Color`] = color;
+        }
+      }
+    });
+  }
+}
+
+export function strip(num, precision = 12) {
+  if (typeof num === 'number') {
+    return +parseFloat(num.toPrecision(precision));
+  }
+}
+
+export function numberEqual(num1, num2, precision = 10E-6) {
+  return Math.abs(+num1 - +num2) <= precision;
+}
+
+export const statisticFunctions = { min, max: statisticsMax, mean, sum, mode, median, variance, standardDeviation, count: fieldValues => fieldValues.length };

package/src/common/_utils/vue-types/index.js

@@ -0,0 +1,267 @@
+import isPlainObject from 'lodash.isplainobject';
+import {
+  toType,
+  getType,
+  isFunction,
+  validateType,
+  isInteger,
+  isArray,
+  warn
+} from 'vue-iclient/src/common/_utils/vue-types/utils';
+
+const VuePropTypes = {
+  get any() {
+    return toType('any', {
+      type: null
+    });
+  },
+
+  get func() {
+    return toType('function', {
+      type: Function
+    }).def(currentDefaults.func);
+  },
+
+  get bool() {
+    return toType('boolean', {
+      type: Boolean
+    }).def(currentDefaults.bool);
+  },
+
+  get string() {
+    return toType('string', {
+      type: String
+    }).def(currentDefaults.string);
+  },
+
+  get number() {
+    return toType('number', {
+      type: Number
+    }).def(currentDefaults.number);
+  },
+
+  get array() {
+    return toType('array', {
+      type: Array
+    }).def(currentDefaults.array);
+  },
+
+  get object() {
+    return toType('object', {
+      type: Object
+    }).def(currentDefaults.object);
+  },
+
+  get integer() {
+    return toType('integer', {
+      type: Number,
+      validator(value) {
+        return isInteger(value);
+      }
+    }).def(currentDefaults.integer);
+  },
+
+  get symbol() {
+    return toType('symbol', {
+      type: null,
+      validator(value) {
+        return typeof value === 'symbol';
+      }
+    });
+  },
+
+  custom(validatorFn, warnMsg = 'custom validation failed') {
+    if (typeof validatorFn !== 'function') {
+      throw new TypeError('[VueTypes error]: You must provide a function as argument');
+    }
+
+    return toType(validatorFn.name || '<<anonymous function>>', {
+      validator(...args) {
+        const valid = validatorFn(...args);
+        if (!valid) warn(`${this._vueTypes_name} - ${warnMsg}`);
+        return valid;
+      }
+    });
+  },
+
+  oneOf(arr) {
+    if (!isArray(arr)) {
+      throw new TypeError('[VueTypes error]: You must provide an array as argument');
+    }
+    const msg = `oneOf - value should be one of "${arr.join('", "')}"`;
+    const allowedTypes = arr.reduce((ret, v) => {
+      if (v !== null && v !== undefined) {
+        ret.indexOf(v.constructor) === -1 && ret.push(v.constructor);
+      }
+      return ret;
+    }, []);
+
+    return toType('oneOf', {
+      type: allowedTypes.length > 0 ? allowedTypes : null,
+      validator(value) {
+        const valid = arr.indexOf(value) !== -1;
+        if (!valid) warn(msg);
+        return valid;
+      }
+    });
+  },
+
+  instanceOf(instanceConstructor) {
+    return toType('instanceOf', {
+      type: instanceConstructor
+    });
+  },
+
+  oneOfType(arr) {
+    if (!isArray(arr)) {
+      throw new TypeError('[VueTypes error]: You must provide an array as argument');
+    }
+
+    let hasCustomValidators = false;
+
+    const nativeChecks = arr.reduce((ret, type) => {
+      if (isPlainObject(type)) {
+        if (type._vueTypes_name === 'oneOf') {
+          return ret.concat(type.type || []);
+        }
+        if (type.type && !isFunction(type.validator)) {
+          if (isArray(type.type)) return ret.concat(type.type);
+          ret.push(type.type);
+        } else if (isFunction(type.validator)) {
+          hasCustomValidators = true;
+        }
+        return ret;
+      }
+      ret.push(type);
+      return ret;
+    }, []);
+
+    if (!hasCustomValidators) {
+      // we got just native objects (ie: Array, Object)
+      // delegate to Vue native prop check
+      return toType('oneOfType', {
+        type: nativeChecks
+      }).def(undefined);
+    }
+
+    const typesStr = arr
+      .map(type => {
+        if (type && isArray(type.type)) {
+          return type.type.map(getType);
+        }
+        return getType(type);
+      })
+      .reduce((ret, type) => ret.concat(isArray(type) ? type : [type]), [])
+      .join('", "');
+
+    return this.custom(function oneOfType(value) {
+      const valid = arr.some(type => {
+        if (type._vueTypes_name === 'oneOf') {
+          return type.type ? validateType(type.type, value, true) : true;
+        }
+        return validateType(type, value, true);
+      });
+      if (!valid) warn(`oneOfType - value type should be one of "${typesStr}"`);
+      return valid;
+    }).def(undefined);
+  },
+
+  arrayOf(type) {
+    return toType('arrayOf', {
+      type: Array,
+      validator(values) {
+        const valid = values.every(value => validateType(type, value));
+        if (!valid) warn(`arrayOf - value must be an array of "${getType(type)}"`);
+        return valid;
+      }
+    });
+  },
+
+  objectOf(type) {
+    return toType('objectOf', {
+      type: Object,
+      validator(obj) {
+        const valid = Object.keys(obj).every(key => validateType(type, obj[key]));
+        if (!valid) warn(`objectOf - value must be an object of "${getType(type)}"`);
+        return valid;
+      }
+    });
+  },
+
+  shape(obj) {
+    const keys = Object.keys(obj);
+    const requiredKeys = keys.filter(key => obj[key] && obj[key].required === true);
+
+    const type = toType('shape', {
+      type: Object,
+      validator(value) {
+        if (!isPlainObject(value)) {
+          return false;
+        }
+        const valueKeys = Object.keys(value);
+
+        // check for required keys (if any)
+        if (requiredKeys.length > 0 && requiredKeys.some(req => valueKeys.indexOf(req) === -1)) {
+          warn(`shape - at least one of required properties "${requiredKeys.join('", "')}" is not present`);
+          return false;
+        }
+
+        return valueKeys.every(key => {
+          if (keys.indexOf(key) === -1) {
+            if (this._vueTypes_isLoose === true) return true;
+            warn(`shape - object is missing "${key}" property`);
+            return false;
+          }
+          const type = obj[key];
+          return validateType(type, value[key]);
+        });
+      }
+    });
+
+    Object.defineProperty(type, '_vueTypes_isLoose', {
+      enumerable: false,
+      writable: true,
+      value: false
+    });
+
+    Object.defineProperty(type, 'loose', {
+      get() {
+        this._vueTypes_isLoose = true;
+        return this;
+      },
+      enumerable: false
+    });
+
+    return type;
+  }
+};
+
+const typeDefaults = () => ({
+  func: undefined,
+  bool: undefined,
+  string: undefined,
+  number: undefined,
+  array: undefined,
+  object: undefined,
+  integer: undefined
+});
+
+let currentDefaults = typeDefaults();
+
+Object.defineProperty(VuePropTypes, 'sensibleDefaults', {
+  enumerable: false,
+  set(value) {
+    if (value === false) {
+      currentDefaults = {};
+    } else if (value === true) {
+      currentDefaults = typeDefaults();
+    } else if (isPlainObject(value)) {
+      currentDefaults = value;
+    }
+  },
+  get() {
+    return currentDefaults;
+  }
+});
+
+export default VuePropTypes;

package/src/common/_utils/vue-types/utils.js

@@ -0,0 +1,194 @@
+import isPlainObject from 'lodash.isplainobject';
+
+const ObjProto = Object.prototype;
+export const hasOwn = ObjProto.hasOwnProperty;
+
+const FN_MATCH_REGEXP = /^\s*function (\w+)/;
+
+// https://github.com/vuejs/vue/blob/dev/src/core/util/props.js#L159
+export const getType = fn => {
+  const type = fn !== null && fn !== undefined ? (fn.type ? fn.type : fn) : null;
+  const match = type && type.toString().match(FN_MATCH_REGEXP);
+  return match && match[1];
+};
+
+export const getNativeType = value => {
+  if (value === null || value === undefined) return null;
+  const match = value.constructor.toString().match(FN_MATCH_REGEXP);
+  return match && match[1];
+};
+
+/**
+ * Checks for a own property in an object
+ *
+ * @param {object} obj - Object
+ * @param {string} prop - Property to check
+ */
+export const has = (obj, prop) => hasOwn.call(obj, prop);
+
+/**
+ * Determines whether the passed value is an integer. Uses `Number.isInteger` if available
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger
+ * @param {*} value - The value to be tested for being an integer.
+ * @returns {boolean}
+ */
+export const isInteger =
+  Number.isInteger ||
+  function(value) {
+    return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
+  };
+
+/**
+ * Determines whether the passed value is an Array.
+ *
+ * @param {*} value - The value to be tested for being an array.
+ * @returns {boolean}
+ */
+export const isArray =
+  Array.isArray ||
+  function(value) {
+    return Object.prototype.toString.call(value) === '[object Array]';
+  };
+
+/**
+ * Checks if a value is a function
+ *
+ * @param {any} value - Value to check
+ * @returns {boolean}
+ */
+export const isFunction = value => Object.prototype.toString.call(value) === '[object Function]';
+
+/**
+ * Adds a `def` method to the object returning a new object with passed in argument as `default` property
+ *
+ * @param {object} type - Object to enhance
+ */
+export const withDefault = function(type) {
+  Object.defineProperty(type, 'def', {
+    value(def) {
+      if (def === undefined && this.default === undefined) {
+        this.default = undefined;
+        return this;
+      }
+      if (!isFunction(def) && !validateType(this, def)) {
+        warn(`${this._vueTypes_name} - invalid default value: "${def}"`, def);
+        return this;
+      }
+      this.default =
+        isArray(def) || isPlainObject(def)
+          ? function() {
+            return def;
+          }
+          : def;
+
+      return this;
+    },
+    enumerable: false,
+    writable: false
+  });
+};
+
+/**
+ * Adds a `isRequired` getter returning a new object with `required: true` key-value
+ *
+ * @param {object} type - Object to enhance
+ */
+export const withRequired = function(type) {
+  Object.defineProperty(type, 'isRequired', {
+    get() {
+      this.required = true;
+      return this;
+    },
+    enumerable: false
+  });
+};
+
+/**
+ * Adds `isRequired` and `def` modifiers to an object
+ *
+ * @param {string} name - Type internal name
+ * @param {object} obj - Object to enhance
+ * @returns {object}
+ */
+export const toType = (name, obj) => {
+  Object.defineProperty(obj, '_vueTypes_name', {
+    enumerable: false,
+    writable: false,
+    value: name
+  });
+  withRequired(obj);
+  withDefault(obj);
+
+  if (isFunction(obj.validator)) {
+    obj.validator = obj.validator.bind(obj);
+  }
+  return obj;
+};
+
+/**
+ * Validates a given value against a prop type object
+ *
+ * @param {Object|*} type - Type to use for validation. Either a type object or a constructor
+ * @param {*} value - Value to check
+ * @param {boolean} silent - Silence warnings
+ * @returns {boolean}
+ */
+export const validateType = (type, value, silent = false) => {
+  let typeToCheck = type;
+  let valid = true;
+  let expectedType;
+  if (!isPlainObject(type)) {
+    typeToCheck = { type };
+  }
+  const namePrefix = typeToCheck._vueTypes_name ? typeToCheck._vueTypes_name + ' - ' : '';
+
+  if (hasOwn.call(typeToCheck, 'type') && typeToCheck.type !== null) {
+    if (isArray(typeToCheck.type)) {
+      valid = typeToCheck.type.some(type => validateType(type, value, true));
+      expectedType = typeToCheck.type.map(type => getType(type)).join(' or ');
+    } else {
+      expectedType = getType(typeToCheck);
+
+      if (expectedType === 'Array') {
+        valid = isArray(value);
+      } else if (expectedType === 'Object') {
+        valid = isPlainObject(value);
+      } else if (
+        expectedType === 'String' ||
+        expectedType === 'Number' ||
+        expectedType === 'Boolean' ||
+        expectedType === 'Function'
+      ) {
+        valid = getNativeType(value) === expectedType;
+      } else {
+        valid = value instanceof typeToCheck.type;
+      }
+    }
+  }
+
+  if (!valid) {
+    silent === false && warn(`${namePrefix}value "${value}" should be of type "${expectedType}"`);
+    return false;
+  }
+
+  if (hasOwn.call(typeToCheck, 'validator') && isFunction(typeToCheck.validator)) {
+    valid = typeToCheck.validator(value);
+    if (!valid && silent === false) warn(`${namePrefix}custom validation failed`);
+    return valid;
+  }
+  return valid;
+};
+
+let warn = () => {};
+
+if (process.env.NODE_ENV !== 'production') {
+  const hasConsole = typeof console !== 'undefined';
+  warn = msg => {
+    if (hasConsole) {
+      console.warn(`[VueTypes warn]: ${msg}`);
+    }
+  };
+}
+
+export { warn };