@10yun/cv-mobile-ui 0.5.27 → 0.5.30

package/uview-plus/libs/function/color/color.js

@@ -0,0 +1,496 @@
+import colorString from './color-string';
+import convert from './color-convert';
+
+const skippedModels = [
+  // To be honest, I don't really feel like keyword belongs in color convert, but eh.
+  'keyword',
+
+  // Gray conflicts with some method names, and has its own method defined.
+  'gray',
+
+  // Shouldn't really be in color-convert either...
+  'hex'
+];
+
+const hashedModelKeys = {};
+for (const model of Object.keys(convert)) {
+  hashedModelKeys[[...convert[model].labels].sort().join('')] = model;
+}
+
+const limiters = {};
+
+function Color(object, model) {
+  if (!(this instanceof Color)) {
+    return new Color(object, model);
+  }
+
+  if (model && model in skippedModels) {
+    model = null;
+  }
+
+  if (model && !(model in convert)) {
+    throw new Error('Unknown model: ' + model);
+  }
+
+  let i;
+  let channels;
+
+  if (object == null) {
+    // eslint-disable-line no-eq-null,eqeqeq
+    this.model = 'rgb';
+    this.color = [0, 0, 0];
+    this.valpha = 1;
+  } else if (object instanceof Color) {
+    this.model = object.model;
+    this.color = [...object.color];
+    this.valpha = object.valpha;
+  } else if (typeof object === 'string') {
+    const result = colorString.get(object);
+    if (result === null) {
+      throw new Error('Unable to parse color from string: ' + object);
+    }
+
+    this.model = result.model;
+    channels = convert[this.model].channels;
+    this.color = result.value.slice(0, channels);
+    this.valpha = typeof result.value[channels] === 'number' ? result.value[channels] : 1;
+  } else if (object.length > 0) {
+    this.model = model || 'rgb';
+    channels = convert[this.model].channels;
+    const newArray = Array.prototype.slice.call(object, 0, channels);
+    this.color = zeroArray(newArray, channels);
+    this.valpha = typeof object[channels] === 'number' ? object[channels] : 1;
+  } else if (typeof object === 'number') {
+    // This is always RGB - can be converted later on.
+    this.model = 'rgb';
+    this.color = [(object >> 16) & 0xff, (object >> 8) & 0xff, object & 0xff];
+    this.valpha = 1;
+  } else {
+    this.valpha = 1;
+
+    const keys = Object.keys(object);
+    if ('alpha' in object) {
+      keys.splice(keys.indexOf('alpha'), 1);
+      this.valpha = typeof object.alpha === 'number' ? object.alpha : 0;
+    }
+
+    const hashedKeys = keys.sort().join('');
+    if (!(hashedKeys in hashedModelKeys)) {
+      throw new Error('Unable to parse color from object: ' + JSON.stringify(object));
+    }
+
+    this.model = hashedModelKeys[hashedKeys];
+
+    const { labels } = convert[this.model];
+    const color = [];
+    for (i = 0; i < labels.length; i++) {
+      color.push(object[labels[i]]);
+    }
+
+    this.color = zeroArray(color);
+  }
+
+  // Perform limitations (clamping, etc.)
+  if (limiters[this.model]) {
+    channels = convert[this.model].channels;
+    for (i = 0; i < channels; i++) {
+      const limit = limiters[this.model][i];
+      if (limit) {
+        this.color[i] = limit(this.color[i]);
+      }
+    }
+  }
+
+  this.valpha = Math.max(0, Math.min(1, this.valpha));
+
+  if (Object.freeze) {
+    Object.freeze(this);
+  }
+}
+
+Color.prototype = {
+  toString() {
+    return this.string();
+  },
+
+  toJSON() {
+    return this[this.model]();
+  },
+
+  string(places) {
+    let self = this.model in colorString.to ? this : this.rgb();
+    self = self.round(typeof places === 'number' ? places : 1);
+    const args = self.valpha === 1 ? self.color : [...self.color, this.valpha];
+    return colorString.to[self.model](args);
+  },
+
+  percentString(places) {
+    const self = this.rgb().round(typeof places === 'number' ? places : 1);
+    const args = self.valpha === 1 ? self.color : [...self.color, this.valpha];
+    return colorString.to.rgb.percent(args);
+  },
+
+  array() {
+    return this.valpha === 1 ? [...this.color] : [...this.color, this.valpha];
+  },
+
+  object() {
+    const result = {};
+    const { channels } = convert[this.model];
+    const { labels } = convert[this.model];
+
+    for (let i = 0; i < channels; i++) {
+      result[labels[i]] = this.color[i];
+    }
+
+    if (this.valpha !== 1) {
+      result.alpha = this.valpha;
+    }
+
+    return result;
+  },
+
+  unitArray() {
+    const rgb = this.rgb().color;
+    rgb[0] /= 255;
+    rgb[1] /= 255;
+    rgb[2] /= 255;
+
+    if (this.valpha !== 1) {
+      rgb.push(this.valpha);
+    }
+
+    return rgb;
+  },
+
+  unitObject() {
+    const rgb = this.rgb().object();
+    rgb.r /= 255;
+    rgb.g /= 255;
+    rgb.b /= 255;
+
+    if (this.valpha !== 1) {
+      rgb.alpha = this.valpha;
+    }
+
+    return rgb;
+  },
+
+  round(places) {
+    places = Math.max(places || 0, 0);
+    return new Color([...this.color.map(roundToPlace(places)), this.valpha], this.model);
+  },
+
+  alpha(value) {
+    if (value !== undefined) {
+      return new Color([...this.color, Math.max(0, Math.min(1, value))], this.model);
+    }
+
+    return this.valpha;
+  },
+
+  // Rgb
+  red: getset('rgb', 0, maxfn(255)),
+  green: getset('rgb', 1, maxfn(255)),
+  blue: getset('rgb', 2, maxfn(255)),
+
+  hue: getset(['hsl', 'hsv', 'hsl', 'hwb', 'hcg'], 0, (value) => ((value % 360) + 360) % 360),
+
+  saturationl: getset('hsl', 1, maxfn(100)),
+  lightness: getset('hsl', 2, maxfn(100)),
+
+  saturationv: getset('hsv', 1, maxfn(100)),
+  value: getset('hsv', 2, maxfn(100)),
+
+  chroma: getset('hcg', 1, maxfn(100)),
+  gray: getset('hcg', 2, maxfn(100)),
+
+  white: getset('hwb', 1, maxfn(100)),
+  wblack: getset('hwb', 2, maxfn(100)),
+
+  cyan: getset('cmyk', 0, maxfn(100)),
+  magenta: getset('cmyk', 1, maxfn(100)),
+  yellow: getset('cmyk', 2, maxfn(100)),
+  black: getset('cmyk', 3, maxfn(100)),
+
+  x: getset('xyz', 0, maxfn(95.047)),
+  y: getset('xyz', 1, maxfn(100)),
+  z: getset('xyz', 2, maxfn(108.833)),
+
+  l: getset('lab', 0, maxfn(100)),
+  a: getset('lab', 1),
+  b: getset('lab', 2),
+
+  keyword(value) {
+    if (value !== undefined) {
+      return new Color(value);
+    }
+
+    return convert[this.model].keyword(this.color);
+  },
+
+  hex(value) {
+    if (value !== undefined) {
+      return new Color(value);
+    }
+
+    return colorString.to.hex(this.rgb().round().color);
+  },
+
+  hexa(value) {
+    if (value !== undefined) {
+      return new Color(value);
+    }
+
+    const rgbArray = this.rgb().round().color;
+
+    let alphaHex = Math.round(this.valpha * 255)
+      .toString(16)
+      .toUpperCase();
+    if (alphaHex.length === 1) {
+      alphaHex = '0' + alphaHex;
+    }
+
+    return colorString.to.hex(rgbArray) + alphaHex;
+  },
+
+  rgbNumber() {
+    const rgb = this.rgb().color;
+    return ((rgb[0] & 0xff) << 16) | ((rgb[1] & 0xff) << 8) | (rgb[2] & 0xff);
+  },
+
+  luminosity() {
+    // http://www.w3.org/TR/WCAG20/#relativeluminancedef
+    const rgb = this.rgb().color;
+
+    const lum = [];
+    for (const [i, element] of rgb.entries()) {
+      const chan = element / 255;
+      lum[i] = chan <= 0.04045 ? chan / 12.92 : ((chan + 0.055) / 1.055) ** 2.4;
+    }
+
+    return 0.2126 * lum[0] + 0.7152 * lum[1] + 0.0722 * lum[2];
+  },
+
+  contrast(color2) {
+    // http://www.w3.org/TR/WCAG20/#contrast-ratiodef
+    const lum1 = this.luminosity();
+    const lum2 = color2.luminosity();
+
+    if (lum1 > lum2) {
+      return (lum1 + 0.05) / (lum2 + 0.05);
+    }
+
+    return (lum2 + 0.05) / (lum1 + 0.05);
+  },
+
+  level(color2) {
+    // https://www.w3.org/TR/WCAG/#contrast-enhanced
+    const contrastRatio = this.contrast(color2);
+    if (contrastRatio >= 7) {
+      return 'AAA';
+    }
+
+    return contrastRatio >= 4.5 ? 'AA' : '';
+  },
+
+  isDark() {
+    // YIQ equation from http://24ways.org/2010/calculating-color-contrast
+    const rgb = this.rgb().color;
+    const yiq = (rgb[0] * 2126 + rgb[1] * 7152 + rgb[2] * 722) / 10000;
+    return yiq < 128;
+  },
+
+  isLight() {
+    return !this.isDark();
+  },
+
+  negate() {
+    const rgb = this.rgb();
+    for (let i = 0; i < 3; i++) {
+      rgb.color[i] = 255 - rgb.color[i];
+    }
+
+    return rgb;
+  },
+
+  lighten(ratio) {
+    const hsl = this.hsl();
+    hsl.color[2] += hsl.color[2] * ratio;
+    return hsl;
+  },
+
+  darken(ratio) {
+    const hsl = this.hsl();
+    hsl.color[2] -= hsl.color[2] * ratio;
+    return hsl;
+  },
+
+  saturate(ratio) {
+    const hsl = this.hsl();
+    hsl.color[1] += hsl.color[1] * ratio;
+    return hsl;
+  },
+
+  desaturate(ratio) {
+    const hsl = this.hsl();
+    hsl.color[1] -= hsl.color[1] * ratio;
+    return hsl;
+  },
+
+  whiten(ratio) {
+    const hwb = this.hwb();
+    hwb.color[1] += hwb.color[1] * ratio;
+    return hwb;
+  },
+
+  blacken(ratio) {
+    const hwb = this.hwb();
+    hwb.color[2] += hwb.color[2] * ratio;
+    return hwb;
+  },
+
+  grayscale() {
+    // http://en.wikipedia.org/wiki/Grayscale#Converting_color_to_grayscale
+    const rgb = this.rgb().color;
+    const value = rgb[0] * 0.3 + rgb[1] * 0.59 + rgb[2] * 0.11;
+    return Color.rgb(value, value, value);
+  },
+
+  fade(ratio) {
+    return this.alpha(this.valpha - this.valpha * ratio);
+  },
+
+  opaquer(ratio) {
+    return this.alpha(this.valpha + this.valpha * ratio);
+  },
+
+  rotate(degrees) {
+    const hsl = this.hsl();
+    let hue = hsl.color[0];
+    hue = (hue + degrees) % 360;
+    hue = hue < 0 ? 360 + hue : hue;
+    hsl.color[0] = hue;
+    return hsl;
+  },
+
+  mix(mixinColor, weight) {
+    // Ported from sass implementation in C
+    // https://github.com/sass/libsass/blob/0e6b4a2850092356aa3ece07c6b249f0221caced/functions.cpp#L209
+    if (!mixinColor || !mixinColor.rgb) {
+      throw new Error('Argument to "mix" was not a Color instance, but rather an instance of ' + typeof mixinColor);
+    }
+
+    const color1 = mixinColor.rgb();
+    const color2 = this.rgb();
+    const p = weight === undefined ? 0.5 : weight;
+
+    const w = 2 * p - 1;
+    const a = color1.alpha() - color2.alpha();
+
+    const w1 = ((w * a === -1 ? w : (w + a) / (1 + w * a)) + 1) / 2;
+    const w2 = 1 - w1;
+
+    return Color.rgb(
+      w1 * color1.red() + w2 * color2.red(),
+      w1 * color1.green() + w2 * color2.green(),
+      w1 * color1.blue() + w2 * color2.blue(),
+      color1.alpha() * p + color2.alpha() * (1 - p)
+    );
+  }
+};
+
+// Model conversion methods and static constructors
+for (const model of Object.keys(convert)) {
+  if (skippedModels.includes(model)) {
+    continue;
+  }
+
+  const { channels } = convert[model];
+
+  // Conversion methods
+  Color.prototype[model] = function (...args) {
+    if (this.model === model) {
+      return new Color(this);
+    }
+
+    if (args.length > 0) {
+      return new Color(args, model);
+    }
+
+    return new Color([...assertArray(convert[this.model][model].raw(this.color)), this.valpha], model);
+  };
+
+  // 'static' construction methods
+  Color[model] = function (...args) {
+    let color = args[0];
+    if (typeof color === 'number') {
+      color = zeroArray(args, channels);
+    }
+
+    return new Color(color, model);
+  };
+}
+
+function roundTo(number, places) {
+  return Number(number.toFixed(places));
+}
+
+function roundToPlace(places) {
+  return function (number) {
+    return roundTo(number, places);
+  };
+}
+
+function getset(model, channel, modifier) {
+  model = Array.isArray(model) ? model : [model];
+
+  for (const m of model) {
+    (limiters[m] || (limiters[m] = []))[channel] = modifier;
+  }
+
+  model = model[0];
+
+  return function (value) {
+    let result;
+
+    if (value !== undefined) {
+      if (modifier) {
+        value = modifier(value);
+      }
+
+      result = this[model]();
+      result.color[channel] = value;
+      return result;
+    }
+
+    result = this[model]().color[channel];
+    if (modifier) {
+      result = modifier(result);
+    }
+
+    return result;
+  };
+}
+
+function maxfn(max) {
+  return function (v) {
+    return Math.max(0, Math.min(max, v));
+  };
+}
+
+function assertArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+function zeroArray(array, length) {
+  for (let i = 0; i < length; i++) {
+    if (typeof array[i] !== 'number') {
+      array[i] = 0;
+    }
+  }
+
+  return array;
+}
+
+export default Color;

package/uview-plus/libs/function/color/index.js

@@ -0,0 +1,158 @@
+import Color from './color';
+
+/**
+ * 转换颜色格式。
+ * @param {Object} params - 参数对象。
+ * @param {string} color - 输入的颜色，默认为 '#fff'。
+ * @param {string} format - 需要转换的格式（支持 'rgb', 'hex', 'hsl', 'hsv', 'hwb'）。
+ * @param {string} type - 转换后的类型（支持 'string', 'object', 'array', 'round'）。
+ * @returns {string|Object|Array} 转换后的颜色表示。
+ */
+function convertFormat(color = '#fff', format = 'rgb', type = 'string') {
+	let colorObj = Color(color);
+	// 如果格式存在
+	if (colorObj[format]) {
+		// hex 无法直接转换为 除string类型外的任何类型
+		// 所以转为rgb 后 获取其他类型
+		if(format == 'hex' && type != 'string') format = 'rgb';
+		// 类型名称
+		let typeName = '';
+		switch (type) {
+			case 'string':
+				typeName = 'toString';
+				break;
+			case 'object':
+				typeName = 'object';
+				break;
+			case 'array':
+				typeName = 'array';
+				break;
+			case 'round':
+				typeName = 'round';
+				break;
+			default:
+				throw Error('Unsupported target type:' + type)
+		}
+		return colorObj[format]()[typeName]();
+	} else {
+		throw Error('Unsupported target format: ' + format);
+	}
+}
+
+/**
+ * 计算两个颜色之间的渐变值。
+ * @param {string} startColor - 开始的颜色，默认为黑色。
+ * @param {string} endColor - 结束的颜色，默认为白色。
+ * @param {number} step - 渐变的步数，默认为10。
+ * @returns {Array<string>} 两个颜色之间的渐变颜色数组。
+ */
+function gradient(startColor = 'rgb(0, 0, 0)', endColor = 'rgb(255, 255, 255)', step = 10) {
+	const startRGB = convertFormat(startColor, 'rgb', 'array') // 转换为rgb数组模式
+	const startR = startRGB[0]
+	const startG = startRGB[1]
+	const startB = startRGB[2]
+
+	const endRGB = convertFormat(endColor, 'rgb', 'array')
+	const endR = endRGB[0]
+	const endG = endRGB[1]
+	const endB = endRGB[2]
+
+	const sR = (endR - startR) / step // 总差值
+	const sG = (endG - startG) / step
+	const sB = (endB - startB) / step
+	const colorArr = []
+	for (let i = 0; i < step; i++) {
+		// 计算每一步的hex值
+		let hex = convertFormat(`rgb(${Math.round((sR * i + startR))},${Math.round((sG * i + startG))},${Math.round((sB
+			* i + startB))})`, 'hex')
+		// 确保第一个颜色值为startColor的值
+		if (i === 0) hex = convertFormat(startColor, 'hex')
+		// 确保最后一个颜色值为endColor的值
+		if (i === step - 1) hex = convertFormat(endColor, 'hex')
+		colorArr.push(hex)
+	}
+	return colorArr
+}
+
+
+
+export default {
+	/**
+	 * 格式转换。
+	 */
+	convertFormat,
+
+	/**
+	 * 计算两个颜色之间的渐变值。
+	 */
+	gradient,
+
+	/**
+	 * 增加颜色的亮度。
+	 * @param {string} color - 输入的颜色。
+	 * @param {number} value - 增加的亮度值（0-1）。
+	 * @returns {string} 调整后的颜色。
+	 */
+	lighten: (color, value, format = 'rgb', type = 'string') => convertFormat(Color(color).lighten(value), format, type),
+
+	/**
+	 * 减少颜色的亮度。
+	 * @param {string} color - 输入的颜色。
+	 * @param {number} value - 减少的亮度值（0-1）。
+	 * @returns {string} 调整后的颜色。
+	 */
+	darken: (color, value, format = 'rgb', type = 'string') => convertFormat(Color(color).darken(value), format, type),
+
+	/**
+	 * 增加颜色的饱和度。
+	 * @param {string} color - 输入的颜色。
+	 * @param {number} value - 增加的饱和度值（0-1）。
+	 * @returns {string} 调整后的颜色。
+	 */
+	saturate: (color, value, format = 'rgb', type = 'string') => convertFormat(Color(color).saturate(value), format, type),
+
+	/**
+	 * 减少颜色的饱和度。
+	 * @param {string} color - 输入的颜色。
+	 * @param {number} value - 减少的饱和度值（0-1）。
+	 * @returns {string} 调整后的颜色。
+	 */
+	desaturate: (color, value, format = 'rgb', type = 'string') => convertFormat(Color(color).desaturate(value), format, type),
+
+	/**
+	 * 旋转颜色的色相。
+	 * @param {string} color - 输入的颜色。
+	 * @param {number} degrees - 旋转的度数。
+	 * @returns {string} 调整后的颜色。
+	 */
+	rotate: (color, degrees, format = 'rgb', type = 'string') => convertFormat(Color(color).rotate(degrees), format, type),
+
+	/**
+	 * 调整颜色的透明度。
+	 * @param {string} color - 输入的颜色。
+	 * @param {number} value - 透明度值（0-1，其中 1 是不透明）。
+	 * @returns {string} 调整后的颜色。
+	 */
+	adjustAlpha: (color, value, format = 'rgb', type = 'string') => convertFormat(Color(color).alpha(value), format, type),
+
+	/**
+	 * 获取颜色的亮度。
+	 * @param {string} color - 输入的颜色。
+	 * @returns {number} 颜色的亮度值（0-1）。
+	 */
+	luminosity: (color, format) => Color(color).luminosity(),
+
+	/**
+	 * 判断颜色是否为暗色。
+	 * @param {string} color - 输入的颜色。
+	 * @returns {boolean} 如果是暗色则返回 true，否则返回 false。
+	 */
+	isDark: (color, format) => Color(color).isDark(),
+
+	/**
+	 * 判断颜色是否为亮色。
+	 * @param {string} color - 输入的颜色。
+	 * @returns {boolean} 如果是亮色则返回 true，否则返回 false。
+	 */
+	isLight: (color, format) => Color(color).isLight()
+};

package/uview-plus/libs/function/color/is-arrayish/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 JD Ballard
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/uview-plus/libs/function/color/is-arrayish/README.md

@@ -0,0 +1,16 @@
+# node-is-arrayish [![Travis-CI.org Build Status](https://img.shields.io/travis/Qix-/node-is-arrayish.svg?style=flat-square)](https://travis-ci.org/Qix-/node-is-arrayish) [![Coveralls.io Coverage Rating](https://img.shields.io/coveralls/Qix-/node-is-arrayish.svg?style=flat-square)](https://coveralls.io/r/Qix-/node-is-arrayish)
+> Determines if an object can be used like an Array
+
+## Example
+```javascript
+var isArrayish = require('is-arrayish');
+
+isArrayish([]); // true
+isArrayish({__proto__: []}); // true
+isArrayish({}); // false
+isArrayish({length:10}); // false
+```
+
+## License
+Licensed under the [MIT License](http://opensource.org/licenses/MIT).
+You can find a copy of it in [LICENSE](LICENSE).

package/uview-plus/libs/function/color/is-arrayish/index.js

@@ -0,0 +1,9 @@
+export default function isArrayish(obj) {
+	if (!obj || typeof obj === 'string') {
+		return false;
+	}
+
+	return obj instanceof Array || Array.isArray(obj) ||
+		(obj.length >= 0 && (obj.splice instanceof Function ||
+			(Object.getOwnPropertyDescriptor(obj, (obj.length - 1)) && obj.constructor.name !== 'String')));
+};