color-name-list 9.8.0 → 9.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "color-name-list",
-  "version": "9.8.0",
+  "version": "9.9.0",
   "description": "long list of color names",
   "main": "dist/colornames.json",
   "browser": "dist/colornames.umd.js",
@@ -33,10 +33,12 @@
   "homepage": "https://github.com/meodai/color-names#readme",
   "devDependencies": {
     "closestvector": "^0.6.0",
+    "color-name-lists": "^1.1.0",
     "commitizen": "^4.2.4",
     "eslint": "^5.15.1",
     "eslint-config-google": "^0.10.0",
     "ghooks": "^2.0.4",
+    "seedrandom": "^3.0.5",
     "semantic-release": "^17.4.2"
   },
   "engines": {

package/scripts/findColors.js

@@ -2,7 +2,7 @@ const lib = require('./lib.js');
 const ClosestVector = require('closestvector');
 
 /**
- * entriches color object and fills RGB color arrays
+ * enriches color object and fills RGB color arrays
  * Warning: Not a pure function at all :D
  * @param   {object} colorObj hex representation of color
  * @param   {array} rgbColorArrRef reference to RGB color array
@@ -24,24 +24,34 @@ const enrichColorObj = (colorObj, rgbColorArrRef) => {
 };
 
 module.exports = class FindColors {
-  constructor(colors, colorsBestOf) {
-
-    this.colors = colors;
-    this.colorsBestOf = colorsBestOf;
+  constructor(colorsListsObj) {
+    this.colorLists = colorsListsObj;
 
     // object containing the name:hex pairs for nearestColor()
-    this.rgbColorsArr = [];
-    this.rgbColorsArrBestOf = [];
+    this.colorListsRGBArrays = {};
+    this.closestInstances = {};
 
     // prepare color array
-    this.colors.forEach((c) => enrichColorObj(c, this.rgbColorsArr));
-    this.colorsBestOf.forEach((c) => enrichColorObj(c, this.rgbColorsArrBestOf));
+    Object.keys(this.colorLists).forEach((listName) => {
+      this.colorListsRGBArrays[listName] = [];
+
+      this.colorLists[listName].forEach(c => {
+        enrichColorObj(c, this.colorListsRGBArrays[listName]);
+      });
 
-    Object.freeze(this.colors);
-    Object.freeze(this.colorsBestOf);
+      Object.freeze(this.colorLists[listName]);
+      this.closestInstances[listName] = new ClosestVector(
+        this.colorListsRGBArrays[listName]
+      );
+    });
+  }
 
-    this.closest = new ClosestVector(this.rgbColorsArr);
-    this.closestBestOf = new ClosestVector(this.rgbColorsArrBestOf);
+  _validateListKey (listKey) {
+    if (!this.colorLists[listKey]) {
+      throw new Error(`List key "${listKey}" is not valid.`);
+    } else {
+      return true;
+    }
   }
 
   /**
@@ -49,9 +59,11 @@ module.exports = class FindColors {
    * @param {string} searchStr search term
    * @param {boolen} bestOf    if set only returns good names
    */
-  searchNames (searchStr, bestOf = false) {
-    const colors = bestOf ? this.colorsBestOf : this.colors;
-    return colors.filter(color => color.name.toLowerCase().includes(searchStr.toLowerCase()));
+  searchNames (searchStr, listKey = 'default') {
+    this._validateListKey(listKey);
+    return this.colorLists[listKey].filter(
+      color => color.name.toLowerCase().includes(searchStr.toLowerCase())
+    );
   }
 
   /**
@@ -61,24 +73,30 @@ module.exports = class FindColors {
    * @param   {boolean} bestOf if set only returns good names
    * @return  {object}         object containing all nearest colors
    */
-  getNamesForValues (colorArr, unique = false, bestOf = false) {
-    let localClosest = bestOf ? this.closestBestOf : this.closest;
+  getNamesForValues(colorArr, unique = false, listKey = 'default') {
+    let localClosest = this.closestInstances[listKey];
 
     if (unique) {
       localClosest = new ClosestVector(
-        bestOf ? this.rgbColorsArrBestOf : this.rgbColorsArr,
+        this.colorListsRGBArrays[listKey],
         true
       );
     }
 
+    let lastResult = null;
+
     const colorResp = colorArr.map((hex) => {
       // calculate RGB values for passed color
       const rgb = lib.hexToRgb(hex);
 
       // get the closest named colors
-      const closestColor = localClosest.get([rgb.r, rgb.g, rgb.b]);
-      const color = bestOf ? this.colorsBestOf[closestColor.index] :
-        this.colors[closestColor.index];
+      let closestColor = localClosest.get([rgb.r, rgb.g, rgb.b]);
+      if (closestColor && unique) {
+        lastResult = closestColor;
+      } else if (unique) {
+        closestColor = lastResult;
+      }
+      const color = this.colorLists[listKey][closestColor.index];
 
       return {
         ...color,

package/scripts/generatePaletteName.js

@@ -0,0 +1,48 @@
+const seedrandom = require('seedrandom');
+
+/**
+ * getPaletteTitle
+ * @param {string[]} namesArr
+ * @param {int(0-1)} rnd1
+ * @param {int(0-1)} rnd2
+ * @param {int(0-1)} longPartFirst
+ * @param {RegExp} separatorRegex
+ * @returns {string}
+ */
+
+module.exports = function getPaletteTitle(
+    namesArr, // array of names
+    separatorRegex = /(\s|-)+/g
+) {
+  let localnames = [...namesArr];
+
+  const rng = seedrandom(namesArr.join('-'));
+  const rnd1 = rng();
+  const rnd2 = rng();
+  const longPartFirst = rng() < .5;
+
+  // select a random name from the list for the first word in the palette title
+  const indexFirst = Math.round(rnd1 * (localnames.length - 1));
+
+  // remove the selected name from the list
+  const firstName = localnames.splice(indexFirst, 1)[0];
+
+  // select a random name from the list as a last word in the palette title
+  const lastIndex = Math.round(rnd2 * (localnames.length - 1));
+  const lastName = localnames[lastIndex];
+
+  const partsFirst = firstName.split(separatorRegex);
+  const partsLast = lastName.split(separatorRegex);
+
+  if (longPartFirst) {
+    partsFirst.length > 1 ?
+      partsFirst.pop() :
+      partsFirst[0] = `${partsFirst[0]} `;
+    return partsFirst.join('') + partsLast.pop();
+  } else {
+    partsLast.length > 1 ?
+      partsLast.shift() :
+      partsLast[0] = ` ${partsLast[0]}`;
+    return partsFirst.shift() + partsLast.join('');
+  }
+}

package/scripts/server.js

@@ -2,6 +2,7 @@ const http = require('http');
 const url = require('url');
 const fs = require('fs');
 const zlib = require('zlib');
+const colorNameLists = require('color-name-lists');
 const colors = JSON.parse(
     fs.readFileSync(__dirname + '/../dist/colornames.json', 'utf8')
 );
@@ -9,6 +10,7 @@ const colorsBestOf = JSON.parse(
     fs.readFileSync(__dirname + '/../dist/colornames.bestof.json', 'utf8')
 );
 const FindColors = require('./findColors.js');
+const getPaletteTitle = require('./generatePaletteName.js');
 const port = process.env.PORT || 8080;
 const currentVersion = 'v1';
 const urlNameSubpath = 'names';
@@ -26,7 +28,18 @@ const responseHeaderObj = {
   'Content-Type': 'application/json; charset=utf-8',
 };
 
-const findColors = new FindColors(colors, colorsBestOf);
+// [{name: 'red', value: '#f00'}, ...]
+const colorsLists = {
+  default: colors,
+  colors: colors,
+  bestOf: colorsBestOf,
+};
+
+Object.assign(colorsLists, colorNameLists);
+
+const avalibleColorNameLists = Object.keys(colorsLists);
+
+const findColors = new FindColors(colorsLists);
 
 /**
  * validates a hex color
@@ -53,7 +66,7 @@ const httpRespond = (response, responseObj = {}, statusCode = 200) => {
 
 const respondNameSearch = (
     searchParams = new URLSearchParams(''),
-    goodNamesMode = false,
+    listKey = 'default',
     requestUrl,
     request,
     response
@@ -77,13 +90,13 @@ const respondNameSearch = (
   }
 
   return httpRespond(response, {
-    colors: findColors.searchNames(searchString, goodNamesMode),
+    colors: findColors.searchNames(searchString, listKey),
   }, 200);
 };
 
 const respondValueSearch = (
     searchParams = new URLSearchParams(''),
-    goodNamesMode = false,
+    listKey = 'default',
     requestUrl,
     request,
     response
@@ -116,10 +129,32 @@ const respondValueSearch = (
     }}, 404);
   }
 
+  let paletteTitle;
+  let colorsResponse;
+
+  if (urlColorList[0]) {
+    colorsResponse = findColors.getNamesForValues(
+        urlColorList, uniqueMode, listKey
+    );
+  } else {
+    colorsResponse = colorsLists[listKey];
+  }
+
+  if (urlColorList.length === 1) {
+    // if there is only one color, just return its name as palette title
+    paletteTitle = colorsResponse[0].name;
+  } else if (urlColorList.length > 1) {
+    // get a palette title for the returned colors
+    paletteTitle = getPaletteTitle(colorsResponse.map((color) => color.name));
+  } else {
+    // return all colors if no colors were given
+    paletteTitle = `All the ${listKey} names`;
+  }
+
+  // actual http response
   return httpRespond(response, {
-    colors: urlColorList[0] ?
-    findColors.getNamesForValues(urlColorList, uniqueMode, goodNamesMode):
-    (goodNamesMode ? colorsBestOf : colors),
+    paletteTitle,
+    colors: colorsResponse,
   }, 200);
 };
 
@@ -159,10 +194,25 @@ const requestHandler = (request, response) => {
   const goodNamesMode = searchParams.has('goodnamesonly')
                         && searchParams.get('goodnamesonly') === 'true';
 
+  let listKey = searchParams.has('list')
+                && searchParams.get('list');
+
+  listKey = goodNamesMode ? 'bestOf' : listKey;
+  listKey = listKey || 'default';
+
+  const isValidListKey = listKey && avalibleColorNameLists.includes(listKey);
+
+  if (!isValidListKey) {
+    return httpRespond(response, {error: {
+      status: 404,
+      message: `invalid list key: '${listKey}, available keys are: ${avalibleColorNameLists.join(', ')}`,
+    }}, 404);
+  }
+
   if (!isNamesAPI) {
     return respondValueSearch(
         searchParams,
-        goodNamesMode,
+        listKey,
         requestUrl,
         request,
         response
@@ -170,7 +220,7 @@ const requestHandler = (request, response) => {
   } else {
     return respondNameSearch(
         searchParams,
-        goodNamesMode,
+        listKey,
         requestUrl,
         request,
         response