color-name-list 13.1.0 → 13.3.0

package/tests/duplicate-allowlist.json

@@ -36,5 +36,48 @@
   "Dark as Night",
   "Green With Envy",
   "Lost in Space",
-  "Fruit of Passion"
+  "Fruit of Passion",
+  "Aroma Garden",
+  "Back in Black",
+  "Tea Rose",
+  "Red Violet",
+  "Blue Green",
+  "Blue Grey",
+  "Pink Red",
+  "Black Green",
+  "Red Purple",
+  "Red Revival",
+  "Purple Pink",
+  "Pearl White",
+  "Milk Chocolate",
+  "Violet Blue",
+  "Black Violet",
+  "Black Velvet",
+  "Rose Pearl",
+  "Yellow Orange",
+  "Red Orange",
+  "Pink Orange",
+  "Pine Mountain",
+  "Star of the Morning",
+  "Rose Madder",
+  "Lily the Pink",
+  "Purple Grey",
+  "Yellow Green",
+  "White Green",
+  "Turquoise Green",
+  "Green Teal",
+  "Yellow Brown",
+  "Grey Green",
+  "Grape Wine",
+  "Blue Light",
+  "Indigo Blue",
+  "Blue Purple",
+  "Blue Turquoise",
+  "Brown Green",
+  "Brown Grey",
+  "Brown Orange",
+  "Brown Red",
+  "Brown Rose",
+  "Honey Butter",
+  "Custard Cream"
 ]

package/tests/duplicates.test.js

@@ -13,20 +13,41 @@ describe('Duplicate-like color names', () => {
 
   // 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',
+    '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 normalize = (s) =>
+    String(s)
+      .toLowerCase()
+      .normalize('NFD')
+      .replace(/[\u0300-\u036f]/g, '')
+      .replace(/[^a-z0-9]+/g, ' ')
+      .trim();
 
   const tokenize = (name) => {
     const base = normalize(name);
@@ -53,6 +74,13 @@ describe('Duplicate-like color names', () => {
       groups.get(key).push({ name: item.name, lineNumber: item.lineNumber, order });
     }
 
+    // Build allowlist set once
+    const allowSet = new Set(
+      (Array.isArray(allowlist) ? allowlist : [])
+        .filter((v) => typeof v === 'string' && v.trim().length)
+        .map((v) => normalize(v))
+    );
+
     const conflicts = [];
     for (const [key, entries] of groups.entries()) {
       // We have a potential conflict if we see both orders "a b" and "b a"
@@ -78,13 +106,9 @@ describe('Duplicate-like color names', () => {
           })
           .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;
+        // Respect allowlist: check if any of the actual names are allowlisted
+        const hasAllowlisted = unique.some((e) => allowSet.has(normalize(e.name)));
+        if (hasAllowlisted) continue;
 
         conflicts.push({ key, tokens: [t1, t2], entries: unique });
       }
@@ -157,7 +181,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: [
@@ -218,10 +243,7 @@ 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 items = [{ name: 'Heart Gold' }, { name: 'Heart of Gold' }];
     const conflicts = findNearDuplicateNameConflicts(items, {
       foldStopwords: true,
       stopwords: STOPWORDS,
@@ -231,7 +253,7 @@ describe('Duplicate-like color names', () => {
     expect(conflicts[0].entries.length).toBe(2);
   });
 
-  it.skip('should not contain two-word names that are exact reversals of each other', () => {
+  it('should not contain two-word names that are exact reversals of each other', () => {
     expect(csvTestData.lineCount).toBeGreaterThan(1);
 
     const conflicts = findTwoWordReversedPairs(csvTestData.items);

package/tests/title-case.test.js

@@ -8,7 +8,7 @@ describe('APA Title Case Validation', () => {
     csvTestData.load();
   });
 
-    /**
+  /**
    * Determine if a word should be capitalized according to APA title case rules
    * @param {string} word - The word to check
    * @param {boolean} isFirstWordOrAfterPunctuation - True if this is the first word or after punctuation
@@ -16,7 +16,12 @@ describe('APA Title Case Validation', () => {
    * @param {boolean} isLastWord - True if this is the last word in the title
    * @returns {boolean} - True if the word should be capitalized
    */
-  function shouldBeCapitalized(word, isFirstWordOrAfterPunctuation, isAfterPunctuation, isLastWord = false) {
+  function shouldBeCapitalized(
+    word,
+    isFirstWordOrAfterPunctuation,
+    isAfterPunctuation,
+    isLastWord = false
+  ) {
     // Always capitalize first words, words after punctuation, and last words
     if (isFirstWordOrAfterPunctuation || isAfterPunctuation || isLastWord) {
       return true;
@@ -30,13 +35,44 @@ describe('APA Title Case Validation', () => {
     // Short words (3 letters or fewer) that should be lowercase (unless first, after punctuation, or last)
     const minorWords = new Set([
       // Short conjunctions
-      'and', 'as', 'but', 'for', 'if', 'nor', 'or', 'so', 'yet',
+      'and',
+      'as',
+      'but',
+      'for',
+      'if',
+      'nor',
+      'or',
+      'so',
+      'yet',
       // Articles
-      'a', 'an', 'the',
+      'a',
+      'an',
+      'the',
       // Short prepositions
-      'at', 'by', 'in', 'of', 'off', 'on', 'per', 'to', 'up', 'via',
+      'at',
+      'by',
+      'in',
+      'of',
+      'off',
+      'on',
+      'per',
+      'to',
+      'up',
+      'via',
       // for short prepositions
-      'de', 'la', 'le', 'les', 'un', 'une', 'du', 'des', 'et', 'ou', 'à', 'au', 'aux'
+      'de',
+      'la',
+      'le',
+      'les',
+      'un',
+      'une',
+      'du',
+      'des',
+      'et',
+      'ou',
+      'à',
+      'au',
+      'aux',
     ]);
 
     return !minorWords.has(word.toLowerCase());
@@ -147,12 +183,22 @@ describe('APA Title Case Validation', () => {
 
       // Patterns that suggest Los Angeles context
       const losAngelesIndicators = [
-        'vibes', 'style', 'sunset', 'beach', 'hollywood', 'california', 'west coast',
-        'city', 'metro', 'downtown', 'freeway', 'boulevard'
+        'vibes',
+        'style',
+        'sunset',
+        'beach',
+        'hollywood',
+        'california',
+        'west coast',
+        'city',
+        'metro',
+        'downtown',
+        'freeway',
+        'boulevard',
       ];
 
       // If the name contains any LA indicators, treat "la" as Los Angeles
-      if (losAngelesIndicators.some(indicator => lowerName.includes(indicator))) {
+      if (losAngelesIndicators.some((indicator) => lowerName.includes(indicator))) {
         return true;
       }
 
@@ -160,7 +206,7 @@ describe('APA Title Case Validation', () => {
       const nextWord = words[wordIndex + 2]; // +2 to skip whitespace
       if (nextWord) {
         const nonFrenchPatterns = ['vibes', 'style', 'sunset', 'beach'];
-        if (nonFrenchPatterns.some(pattern => nextWord.toLowerCase().includes(pattern))) {
+        if (nonFrenchPatterns.some((pattern) => nextWord.toLowerCase().includes(pattern))) {
           return true;
         }
       }
@@ -187,8 +233,8 @@ describe('APA Title Case Validation', () => {
 
       // Check for alphanumeric patterns that should stay uppercase (like model numbers)
       // Exclude ordinal numbers (1st, 2nd, 3rd, 18th, etc.)
-      const isAlphanumericPattern = /^[0-9]+[A-Z]+$/i.test(segment) &&
-        !/^\d+(st|nd|rd|th)$/i.test(segment);
+      const isAlphanumericPattern =
+        /^[0-9]+[A-Z]+$/i.test(segment) && !/^\d+(st|nd|rd|th)$/i.test(segment);
 
       // Handle hyphenated words - both parts should follow title case rules
       if (segment.includes('-')) {
@@ -219,11 +265,20 @@ describe('APA Title Case Validation', () => {
 
           // Check if this is the last part of the last word in the title
           const isLastPart = partIndex === parts.length - 1;
-          const isLastWordInTitle = i === words.length - 1 || (i === words.length - 2 && /^\s+$/.test(words[words.length - 1]));
+          const isLastWordInTitle =
+            i === words.length - 1 ||
+            (i === words.length - 2 && /^\s+$/.test(words[words.length - 1]));
           const isLastWord = isLastPart && isLastWordInTitle;
 
-          const shouldCap = shouldBeCapitalized(part, isFirstWord || partIndex > 0, isAfterPunctuation, isLastWord);
-          return shouldCap ? part.charAt(0).toUpperCase() + part.slice(1).toLowerCase() : part.toLowerCase();
+          const shouldCap = shouldBeCapitalized(
+            part,
+            isFirstWord || partIndex > 0,
+            isAfterPunctuation,
+            isLastWord
+          );
+          return shouldCap
+            ? part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()
+            : part.toLowerCase();
         });
         result += capitalizedParts.join('-');
       } else {
@@ -242,9 +297,18 @@ describe('APA Title Case Validation', () => {
           result += 'LA';
         } else {
           // Regular word - check if this is the last non-whitespace word
-          const isLastWordInTitle = i === words.length - 1 || (i === words.length - 2 && /^\s+$/.test(words[words.length - 1]));
-          const shouldCap = shouldBeCapitalized(segment, isFirstWord, isAfterPunctuation, isLastWordInTitle);
-          result += shouldCap ? segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase() : segment.toLowerCase();
+          const isLastWordInTitle =
+            i === words.length - 1 ||
+            (i === words.length - 2 && /^\s+$/.test(words[words.length - 1]));
+          const shouldCap = shouldBeCapitalized(
+            segment,
+            isFirstWord,
+            isAfterPunctuation,
+            isLastWordInTitle
+          );
+          result += shouldCap
+            ? segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase()
+            : segment.toLowerCase();
         }
       }
 

package/vitest.config.js

@@ -1,8 +1,13 @@
 import { defineConfig } from 'vitest/config';
 
+// Only run heavy/dist-dependent tests in CI
+const isCI = !!process.env.CI;
+
 export default defineConfig({
   test: {
     include: ['tests/**/*.test.js'],
+    // Exclude CI-only tests locally. GitHub Actions sets CI=true, so these will run in CI.
+    exclude: isCI ? [] : ['tests/*.ci.test.js'],
     environment: 'node',
   },
 });