color-name-list 13.0.0 → 13.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "color-name-list",
-  "version": "13.0.0",
+  "version": "13.2.0",
   "description": "long list of color names",
   "main": "dist/colornames.json",
   "browser": "dist/colornames.umd.js",
@@ -24,10 +24,8 @@
   "scripts": {
     "commit": "git-cz",
     "pull-colors": "curl -L 'https://docs.google.com/spreadsheets/d/e/2PACX-1vQube6Y0wHyEtJnjg0eU3N7VseoxVnD4L9uDqvWZdl_tzzrHDVN10IPP7cdFipX8j70atNMLfPCB0Q6/pub?gid=40578722&single=true&output=csv' -o src/colornames.csv",
-    "test": "npm run test:precommit && vitest run",
+    "test": "vitest run",
     "test:watch": "vitest",
-    "test:precommit": "npm run build:test",
-    "build:test": "node scripts/build.js --testonly",
     "build": "node scripts/build.js && npm run prettier",
     "prettier": "prettier --write ./dist/*",
     "lint": "npm run lint:scripts && npm run lint:markdown",

package/scripts/lib.js

@@ -160,7 +160,8 @@ export const findNearDuplicateNameConflicts = (items, options = {}) => {
       .normalize('NFD')
       .replace(/[\u0300-\u036f]/g, '');
     const tokens = base.match(/[a-z0-9]+/g) || [];
-    const filtered = foldStopwords && stopSet && stopSet.size ? tokens.filter((t) => !stopSet.has(t)) : tokens;
+    const filtered =
+      foldStopwords && stopSet && stopSet.size ? tokens.filter((t) => !stopSet.has(t)) : tokens;
     return filtered.length ? filtered.join('') : normalizeNameForDuplicates(name);
   };
 

package/scripts/sortSrc.js

@@ -45,7 +45,7 @@ const readAndSortCSV = () => {
     });
 
     // Combine header & sorted lines (no blank line). Ensure exactly one final newline.
-    const sortedData = [header, ...sortedColorLines].join('\n') + '\n';
+    const sortedData = [header, ...sortedColorLines].join('\n');
 
     // Write back
     fs.writeFileSync(csvPath, sortedData, 'utf8');

package/src/colornames.csv

@@ -215,8 +215,6 @@ Afternoon Stroll,#d9c5a1,
 Afternoon Tea,#594e40,
 Agapanthus,#bbc5de,
 Agate Brown,#956a60,
-Agate Green,#52928d,
-Agate Grey,#acaa99,
 Agate Violet,#5a5b74,
 Agave,#879d99,
 Agave Frond,#5a6e6a,
@@ -1014,7 +1012,7 @@ April Sunshine,#fbe198,
 April Tears,#b4cbd4,
 April Wedding,#c5cfb1,
 April Winds,#d5e2e5,
-Aqua,#00ffff,x
+Aqua,#0ff0fe,x
 Aqua Bay,#b5dfc9,
 Aqua Belt,#7acad0,
 Aqua Bloom,#96d3d8,
@@ -1923,6 +1921,7 @@ Barberry Bush,#d2c61f,
 Barberry Sand,#e1d4bc,
 Barberry Yellow,#f3bd32,
 Barbie Pink,#fe46a5,
+Barbiecore,#e15acb,x
 Barcelona Beige,#c4b39c,
 Barcelona Brown,#926a46,
 Barcelona Orange,#ff9500,
@@ -6975,7 +6974,7 @@ Cuticle Pink,#e3a49a,
 Cutlery Polish,#f4dda5,
 Cuttlefish,#7fbbc2,x
 Cutty Sark,#5c8173,
-Cyan,#0ff0fe,x
+Cyan,#00ffff,x
 Cyan Azure,#4e82b4,
 Cyan Blue,#14a3c7,
 Cyan Cobalt Blue,#28589c,
@@ -7792,6 +7791,7 @@ Dig It,#8e6e57,
 Digger’s Gold,#a37336,
 Digital,#636365,
 Digital Garage,#b7b3a4,
+Digital Lavender,#cac0e1,x
 Digital Violets,#aa00ff,
 Digital Yellow,#ffeb7e,
 Dignified,#3b695f,
@@ -10683,6 +10683,7 @@ Gemini,#b4d6cb,
 Gemini Mustard Momento,#fca750,
 Gemstone Blue,#004f6d,
 Gemstone Green,#4b6331,
+Gen Z Yellow,#f4e386,
 Generic Viridian,#007f66,
 Genestealer Purple,#7761ab,
 Genetic Code,#18515d,
@@ -11519,7 +11520,7 @@ Green,#00ff00,x
 Green 383,#3e3d29,
 Green Acres,#53a144,
 Green Adirondack,#688878,
-Green Agate,#3f6253,
+Green Agate,#52928d,
 Green Alabaster,#c8ccba,
 Green Amazons,#98a893,
 Green Andara,#afc1a3,
@@ -11672,6 +11673,7 @@ Green Olive,#8d8b55,x
 Green Olive Pit,#bdaa89,
 Green Onion,#c1e089,
 Green Onyx,#989a82,
+Green Ooze,#e1fe52,x
 Green Papaya,#e5ce77,
 Green Parakeet,#7bd5bf,
 Green Parlor,#cfddb9,
@@ -15186,7 +15188,6 @@ Lima Green,#b1b787,
 Lima Sombrio,#7aac21,
 Limbert Leather,#988870,
 Lime,#aaff32,x
-Lime Acid,#afff01,
 Lime Blossom,#f4f2d3,
 Lime Bright,#f1e4b0,
 Lime Cake,#dae3d0,
@@ -16808,6 +16809,7 @@ Milky Yellow,#f8dd74,
 Mill Creek,#876e59,
 Millbrook,#595648,
 Mille-Feuille,#efc87d,x
+Millennial Grey,#7b7b7d,
 Millennial Pink,#f6c8c1,x
 Millennium Silver,#8c9595,
 Million Grey,#999999,x
@@ -20832,6 +20834,7 @@ Popular Beige,#d4ccc3,
 Porcelain,#dddcdb,x
 Porcelain Basin,#d9d0c4,
 Porcelain Blue,#95c0cb,
+Porcelain Blush,#f0dbd5,x
 Porcelain Crab,#e9b7a8,
 Porcelain Earth,#eeffbb,
 Porcelain Figurines,#a9998c,
@@ -30117,4 +30120,4 @@ Zumthor,#cdd5d5,
 Zunda Green,#6bc026,x
 Zuni,#008996,
 Zürich Blue,#248bcc,
-Zürich White,#e6e1d9,
+Zürich White,#e6e1d9,

package/tests/duplicate-allowlist.json

@@ -35,5 +35,6 @@
   "In the Dark",
   "Dark as Night",
   "Green With Envy",
-  "Lost in Space"
+  "Lost in Space",
+  "Fruit of Passion"
 ]

package/tests/duplicates.test.js

@@ -11,6 +11,109 @@ describe('Duplicate-like color names', () => {
     csvTestData.load();
   });
 
+  // Shared stopwords for normalization across tests
+  const STOPWORDS = [
+    'of',
+    'the',
+    'and',
+    'a',
+    'an',
+    'in',
+    'on',
+    'at',
+    'to',
+    'for',
+    'by',
+    'with',
+    'from',
+    'as',
+    'is',
+    'it',
+    'this',
+    'that',
+    'these',
+    'those',
+    'be',
+    'are',
+    'was',
+    'were',
+    'or',
+  ];
+
+  // Helper: normalize a phrase similar to scripts/lib normalization but keeping token boundaries
+  const normalize = (s) =>
+    String(s)
+      .toLowerCase()
+      .normalize('NFD')
+      .replace(/[\u0300-\u036f]/g, '')
+      .replace(/[^a-z0-9]+/g, ' ')
+      .trim();
+
+  const tokenize = (name) => {
+    const base = normalize(name);
+    const tokens = base.match(/[a-z0-9]+/g) || [];
+    const stopSet = new Set(STOPWORDS.map((w) => normalize(w)));
+    return tokens.filter((t) => t && !stopSet.has(t));
+  };
+
+  // Detect two-word names that are exact reversals of each other (after stopword filtering)
+  function findTwoWordReversedPairs(items) {
+    const groups = new Map(); // key: sorted pair "a|b" -> list of { name, lineNumber, order: "a b" }
+
+    for (const item of items) {
+      if (!item || typeof item.name !== 'string') continue;
+      const tokens = tokenize(item.name);
+      if (tokens.length !== 2) continue; // only 2-token (after stopword removal)
+      const [a, b] = tokens;
+      if (!a || !b) continue;
+      if (a === b) continue; // "blue blue" reversed is the same – ignore
+
+      const key = [a, b].sort().join('|');
+      const order = `${a} ${b}`;
+      if (!groups.has(key)) groups.set(key, []);
+      groups.get(key).push({ name: item.name, lineNumber: item.lineNumber, order });
+    }
+
+    const conflicts = [];
+    for (const [key, entries] of groups.entries()) {
+      // We have a potential conflict if we see both orders "a b" and "b a"
+      const uniqOrders = [...new Set(entries.map((e) => e.order))];
+      if (uniqOrders.length < 2) continue;
+
+      const [t1, t2] = key.split('|');
+      const forward = `${t1} ${t2}`;
+      const backward = `${t2} ${t1}`;
+
+      const hasForward = uniqOrders.includes(forward);
+      const hasBackward = uniqOrders.includes(backward);
+
+      if (hasForward && hasBackward) {
+        // Keep entries unique by name@line and sorted by line number for stable output
+        const seen = new Set();
+        const unique = entries
+          .filter((e) => {
+            const k = `${e.name}@${e.lineNumber}`;
+            if (seen.has(k)) return false;
+            seen.add(k);
+            return true;
+          })
+          .sort((a, b) => a.lineNumber - b.lineNumber);
+
+        // Respect allowlist: if either direction string is allowlisted, skip
+        const allowSet = new Set(
+          (Array.isArray(allowlist) ? allowlist : [])
+            .filter((v) => typeof v === 'string' && v.trim().length)
+            .map((v) => normalize(v))
+        );
+        if (allowSet.has(forward) || allowSet.has(backward)) continue;
+
+        conflicts.push({ key, tokens: [t1, t2], entries: unique });
+      }
+    }
+
+    return conflicts;
+  }
+
   it('should not contain the same name twice', () => {
     expect(csvTestData.lineCount).toBeGreaterThan(1);
 
@@ -45,13 +148,7 @@ describe('Duplicate-like color names', () => {
       foldPlurals: true,
       pluralAllowlist,
       foldStopwords: true,
-      stopwords: [
-        'of', 'the', 'and', 'a', 'an',
-        'in', 'on', 'at', 'to', 'for',
-        'by', 'with', 'from', 'as', 'is',
-        'it', 'this', 'that', 'these', 'those',
-        'be', 'are', 'was', 'were', 'or'
-      ],
+      stopwords: STOPWORDS,
     });
 
     if (conflicts.length) {
@@ -81,7 +178,8 @@ describe('Duplicate-like color names', () => {
 
       throw new Error(
         buildFailureMessage({
-          title: 'Found {n} duplicate-like {items} (case/accents/punctuation/stopwords-insensitive):',
+          title:
+            'Found {n} duplicate-like {items} (case/accents/punctuation/stopwords-insensitive):',
           offenders: [...allOffendingNames],
           offenderLabel: 'name',
           details: [
@@ -142,24 +240,57 @@ describe('Duplicate-like color names', () => {
   });
 
   it('should detect names that only differ by stopwords when enabled', () => {
-    const items = [
-      { name: 'Heart Gold' },
-      { name: 'Heart of Gold' },
-    ];
-    const stopwords = [
-      'of', 'the', 'and', 'a', 'an',
-      'in', 'on', 'at', 'to', 'for',
-      'by', 'with', 'from', 'as', 'is',
-      'it', 'this', 'that', 'these', 'those',
-      'be', 'are', 'was', 'were', 'or',
-    ];
-
+    const items = [{ name: 'Heart Gold' }, { name: 'Heart of Gold' }];
     const conflicts = findNearDuplicateNameConflicts(items, {
       foldStopwords: true,
-      stopwords,
+      stopwords: STOPWORDS,
     });
 
     expect(conflicts.length).toBe(1);
     expect(conflicts[0].entries.length).toBe(2);
   });
+
+  it.skip('should not contain two-word names that are exact reversals of each other', () => {
+    expect(csvTestData.lineCount).toBeGreaterThan(1);
+
+    const conflicts = findTwoWordReversedPairs(csvTestData.items);
+
+    if (conflicts.length) {
+      // Build helpful details with line numbers
+      const details = [];
+      const offenderNames = new Set();
+
+      conflicts
+        .sort((a, b) => a.tokens.join(' ').localeCompare(b.tokens.join(' ')))
+        .forEach(({ tokens, entries }) => {
+          const [a, b] = tokens;
+          details.push(`  • ${a} / ${b}:`);
+          entries.forEach((e) => {
+            offenderNames.add(e.name);
+            details.push(`      - line ${e.lineNumber}: "${e.name}"`);
+          });
+          details.push('');
+        });
+
+      throw new Error(
+        buildFailureMessage({
+          title: 'Found {n} word-order reversed {items}:',
+          offenders: [...offenderNames],
+          offenderLabel: 'name',
+          details: [
+            ...details,
+            'Names that only differ by word order (e.g., "Beach Sand" vs "Sand Beach") should be unified.',
+            'Please keep a single preferred order and remove the other.',
+          ],
+          tips: [
+            'Edit src/colornames.csv and keep only one order for each two-word pair.',
+            'After changes, run: npm run sort-colors',
+          ],
+          count: conflicts.length,
+        })
+      );
+    }
+
+    expect(conflicts.length).toBe(0);
+  });
 });