How to use color-string - 10 common examples

var colorClass = function(layer) {
    var style = 'color: ' + colors[layer] + ';'

    // convert rgba to hex and opacity for inkscape compatibility
    if (/rgba/.test(colors[layer])) {
      var rgba = colorString.get.rgb(colors[layer])

      if (rgba) {
        var hex = colorString.to.hex(rgba).slice(0, 7)

        style = 'color: ' + hex + '; opacity: ' + rgba[3] + ';'
      }
    }

    return '.' + prefix + layer + ' {' + style + '}'
  }

// set using rgb value
        pixelcolor = options.rgb || null;
    } else {
        return pixel.color;
    }

    if (pixelcolor != null) {
        // fill out the values for the pixel and then send the message to update
        // it on the strip

        with (pixel.color) {
            r = pixelcolor[0];
            g = pixelcolor[1];
            b = pixelcolor[2];
            hexcode = ColorString.hexString(pixelcolor);
            color = ColorString.keyword(pixelcolor);
            rgb = pixelcolor;
        }

        color = ColorString.colorValue(pixelcolor);
        if (sendmsg) {
            var msg = "{" + pixel.addr + ":" + color + "}";
            pixel.firmata.sp.write(makeSysExString(msg));
        }
    } else {
        console.log("color supplied couldn't be parsed: " + pixelcolor);
    }
};

}

    if (pixelcolor != null) {
        // fill out the values for the pixel and then send the message to update
        // it on the strip

        with (pixel.color) {
            r = pixelcolor[0];
            g = pixelcolor[1];
            b = pixelcolor[2];
            hexcode = ColorString.hexString(pixelcolor);
            color = ColorString.keyword(pixelcolor);
            rgb = pixelcolor;
        }

        color = ColorString.colorValue(pixelcolor);
        if (sendmsg) {
            var msg = "{" + pixel.addr + ":" + color + "}";
            pixel.firmata.sp.write(makeSysExString(msg));
        }
    } else {
        console.log("color supplied couldn't be parsed: " + pixelcolor);
    }
};

if (e instanceof TypeError && ColorString.get(color) === null ) {
                    stripcolor = null;
                }
            }
        }
    }

    if (stripcolor != null) {
        // fill out the values for the pixels and then update the strip

        for (var i = 0; i < strip.pixels.length; i++) {
            strip.pixels[i].color(color, {sendmsg: false});
        }

        // set the whole strip color to the appropriate int value
        this.strip_color(ColorString.colorValue(stripcolor, strip.gtable));

    } else {
        console.log("Supplied colour couldn't be parsed: " + color);
    }
}

stripcolor = ColorString.getRgb(color) || null;

    } else if (opts) {
        // use rgb array to determine color
        stripcolor = opts.rgb || null;
    }

    if (stripcolor != null) {
        // fill out the values for the pixels and then update the strip

        // TODO get this to update all of the pixels
/**        for (pixel in strip.pixels) {
            pixel.
        }**/

        color = ColorString.colorValue(stripcolor);
        var msg = "{a:" + color + "}";
        strip.firmata.sp.write(makeSysExString(msg));
    } else {
        console.log("color supplied couldn't be parsed: " + stripcolor);
    }
}

// fill out the values for the pixel and then send the message to update
        // it on the strip

        pixel.color.r = pixelcolor.value[0];
        pixel.color.g = pixelcolor.value[1];
        pixel.color.b = pixelcolor.value[2];
        pixel.color.hexcode = ColorString.to.hex(pixelcolor.value);
        pixel.color.color = ColorString.to.keyword(pixelcolor.value);
        if (pixelcolor.value.length == 4) {
            pixelcolor.value.pop();
        }
        pixel.color.rgb = pixelcolor.value;


        //console.log(pixel.parent.gtable);
        color = ColorString.colorValue(pixelcolor.value, pixel.parent.gtable);
        if (sendmsg) {
            // TODO probably should be pulling the color off the obj rather than
            // sending it to this function....
            this.pixel_color(color);
        }
    } else {
        console.log("Color supplied couldn't be parsed: " + color);
    }
};

config.templatesDir = resolve(localConfig._templatesDir || './src/templates')
  config.templates = normalizeTemplates(context, config, localConfig)
  config.permalinks = normalizePermalinks(localConfig.permalinks)
  config.componentParsers = []

  config.chainWebpack = localConfig.chainWebpack
  config.configureWebpack = localConfig.configureWebpack
  config.configureServer = localConfig.configureServer

  config.images = {
    defaultBlur: 40,
    backgroundColor: null,
    ...localConfig.images
  }

  if (!colorString.get(config.images.backgroundColor || '')) {
    config.images.backgroundColor = null
  }

  config.runtimeCompiler = localConfig.runtimeCompiler || false

  config.transpileDependencies = Array.isArray(localConfig.transpileDependencies)
    ? localConfig.transpileDependencies.slice()
    : []

  // max cache age for html markup in serve mode
  config.maxCacheAge = localConfig.maxCacheAge || 1000

  config.siteUrl = localConfig.siteUrl || ''
  config.siteName = localConfig.siteName || path.parse(context).name
  config.titleTemplate = localConfig.titleTemplate || `%s - ${config.siteName}`
  config.siteDescription = localConfig.siteDescription || ''

throw new Error('Unknown model: ' + model);
	}

	var i;
	var channels;

	if (!obj) {
		this.model = 'rgb';
		this.color = [0, 0, 0];
		this.valpha = 1;
	} else if (obj instanceof Color) {
		this.model = obj.model;
		this.color = obj.color.slice();
		this.valpha = obj.valpha;
	} else if (typeof obj === 'string') {
		var result = colorString.get(obj);
		if (result === null) {
			throw new Error('Unable to parse color from string: ' + obj);
		}

		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 (obj.length) {
		this.model = model || 'rgb';
		channels = convert[this.model].channels;
		var newArr = _slice.call(obj, 0, channels);
		this.color = zeroArray(newArr, channels);
		this.valpha = typeof obj[channels] === 'number' ? obj[channels] : 1;
	} else if (typeof obj === 'number') {
		// this is always RGB - can be converted later on.

let imageSizes = imageWidths.filter(size => size <= imageWidth)
    const maxWidth = Math.max(...imageSizes, 0)

    if (!options.imageWidths) {
      if (imageWidth > maxWidth || imageSizes.length === 0) {
        imageSizes.push(imageWidth)
      }

      imageSizes = reject(imageSizes, (width, i, arr) => {
        return arr[i + 1] - width < minSizeDistance
      })
    }

    // validate color string
    if (options.background && !colorString.get(options.background)) {
      options.background = this.config.imageBackgroundColor
    } else if (this.config.imageBackgroundColor) {
      options.background = this.config.imageBackgroundColor
    }

    const cacheKey = genHash(filePath + hash + JSON.stringify(options)).substr(0, 7)

    const createDestPath = (filename, imageOptions) => {
      if (process.env.GRIDSOME_MODE === 'serve') {
        const key = process.env.GRIDSOME_TEST ? 'test' : cacheKey
        const query = '?' + createOptionsQuery(imageOptions.concat({ key: 'key', value: key }))
        return path.join('/', imagesDir, forwardSlash(relPath)) + query
      }

      return path.join(imagesDir, filename)
    }

export const getValue = value => {
  /// call getValue recursively for each item in the array
  if (isArray(value)) {
    return value.map(getValue);
  }
  value = String(value);
  // check if it is a color
  if (colorString.get(value)) {
    // returns a rgb array that needs to be further converted into rgb string
    const rgbArr = colorString.get.rgb(value);
    // convert array to rgb/rgba
    const color = colorString.to.rgb(rgbArr);
    return [color, COLOR_UNIT];
  }
  const unitReg = /([-0-9.]+)(cm|mm|in|px|pt|pc|em|ex|ch|%|rem|vw|vh|vmin|vmax|deg)*/;

  const match = value.match(unitReg);
  if (match && match.length === 3) {
    const value = parseFloat(match[1]);
    const unit = match[2] || NO_UNIT;
    return [value, unit];
  }
  throwError(NO_VALUE_SPECIFIED);
};