@luxfi/biome-config 1.0.0

package/src/merger.test.js

@@ -0,0 +1,178 @@
+import { describe, expect, test } from 'bun:test'
+import { mergeArrayValues, mergeObjectValues } from './merger.js'
+
+describe('mergeObjectValues', () => {
+  test('should merge global and local object values', () => {
+    const global = {
+      lodash: 'Use lodash-es',
+      moment: 'Use date-fns',
+    }
+
+    const local = {
+      __INCLUDE_GLOBAL_VALUES__: true,
+      react: 'Custom restriction',
+    }
+
+    const result = mergeObjectValues(global, local)
+
+    expect(result).toMatchObject({
+      lodash: 'Use lodash-es',
+      moment: 'Use date-fns',
+      react: 'Custom restriction',
+    })
+
+    expect(result.__INCLUDE_GLOBAL_VALUES__).toBeUndefined()
+  })
+
+  test('should prioritize local values over global', () => {
+    const global = {
+      lodash: 'Use lodash-es',
+      moment: 'Use date-fns',
+    }
+
+    const local = {
+      __INCLUDE_GLOBAL_VALUES__: true,
+      lodash: 'Lodash is fine actually',
+    }
+
+    const result = mergeObjectValues(global, local)
+
+    expect(result.lodash).toBe('Lodash is fine actually')
+    expect(result.moment).toBe('Use date-fns')
+  })
+
+  test('should handle "off" overrides', () => {
+    const global = {
+      lodash: 'Use lodash-es',
+      moment: 'Use date-fns',
+      jquery: 'No jQuery',
+    }
+
+    const local = {
+      __INCLUDE_GLOBAL_VALUES__: true,
+      jquery: 'off',
+      react: 'Custom restriction',
+    }
+
+    const result = mergeObjectValues(global, local)
+
+    expect(result.lodash).toBe('Use lodash-es')
+    expect(result.moment).toBe('Use date-fns')
+    expect(result.jquery).toBeUndefined()
+    expect(result.react).toBe('Custom restriction')
+  })
+
+  test('should remove marker from result', () => {
+    const global = {
+      lodash: 'Use lodash-es',
+    }
+
+    const local = {
+      __INCLUDE_GLOBAL_VALUES__: true,
+      react: 'Custom restriction',
+    }
+
+    const result = mergeObjectValues(global, local)
+
+    expect(result.__INCLUDE_GLOBAL_VALUES__).toBeUndefined()
+  })
+
+  test('should handle empty global object', () => {
+    const global = {}
+
+    const local = {
+      __INCLUDE_GLOBAL_VALUES__: true,
+      react: 'Custom restriction',
+    }
+
+    const result = mergeObjectValues(global, local)
+
+    expect(result).toMatchObject({
+      react: 'Custom restriction',
+    })
+  })
+
+  test('should handle empty local object (except marker)', () => {
+    const global = {
+      lodash: 'Use lodash-es',
+    }
+
+    const local = {
+      __INCLUDE_GLOBAL_VALUES__: true,
+    }
+
+    const result = mergeObjectValues(global, local)
+
+    expect(result).toMatchObject({
+      lodash: 'Use lodash-es',
+    })
+  })
+})
+
+describe('mergeArrayValues', () => {
+  test('should merge global and local arrays', () => {
+    const global = ['event', 'name', 'global']
+    const local = ['__INCLUDE_GLOBAL_VALUES__', 'localStorage', 'sessionStorage']
+
+    const result = mergeArrayValues(global, local)
+
+    expect(result).toEqual(['localStorage', 'sessionStorage', 'event', 'name', 'global'])
+  })
+
+  test('should deduplicate merged arrays', () => {
+    const global = ['event', 'name', 'global']
+    const local = ['__INCLUDE_GLOBAL_VALUES__', 'event', 'localStorage']
+
+    const result = mergeArrayValues(global, local)
+
+    // Should not have duplicates
+    expect(result.filter((x) => x === 'event')).toHaveLength(1)
+
+    // Should maintain local precedence (local items first)
+    expect(result).toEqual(['event', 'localStorage', 'name', 'global'])
+  })
+
+  test('should remove marker from result', () => {
+    const global = ['event', 'name']
+    const local = ['__INCLUDE_GLOBAL_VALUES__', 'localStorage']
+
+    const result = mergeArrayValues(global, local)
+
+    expect(result).not.toContain('__INCLUDE_GLOBAL_VALUES__')
+  })
+
+  test('should handle empty global array', () => {
+    const global = []
+    const local = ['__INCLUDE_GLOBAL_VALUES__', 'localStorage']
+
+    const result = mergeArrayValues(global, local)
+
+    expect(result).toEqual(['localStorage'])
+  })
+
+  test('should handle local array with only marker', () => {
+    const global = ['event', 'name']
+    const local = ['__INCLUDE_GLOBAL_VALUES__']
+
+    const result = mergeArrayValues(global, local)
+
+    expect(result).toEqual(['event', 'name'])
+  })
+
+  test('should deduplicate complex objects', () => {
+    const global = [{ path: 'lodash', message: 'Use lodash-es' }]
+    const local = [
+      '__INCLUDE_GLOBAL_VALUES__',
+      { path: 'lodash', message: 'Use lodash-es' },
+      { path: 'moment', message: 'Use date-fns' },
+      { message: 'Use date-fns', path: 'moment' },
+    ]
+
+    const result = mergeArrayValues(global, local)
+
+    // Should deduplicate based on JSON serialization
+    expect(result).toHaveLength(2)
+    expect(result[0]).toMatchObject({ path: 'lodash', message: 'Use lodash-es' })
+    expect(result[1]).toMatchObject({ path: 'moment', message: 'Use date-fns' })
+  })
+})

package/src/processor.js

@@ -0,0 +1,121 @@
+const { mergeObjectValues, mergeArrayValues } = require('./merger')
+const {
+  detectUniversePackages,
+  generateUniversePackageOverrides,
+  getGlobalRestrictedImportPatterns,
+} = require('./universePackages')
+
+/**
+ * Processes the entire config, resolving markers in all overrides
+ * @param {Object} baseConfig - The base configuration with overrides
+ * @param {Map<string, any>} globalRules - Map of global rule paths to values
+ * @returns {Object} Configuration with markers resolved
+ */
+function processConfig(baseConfig, globalRules) {
+  // Deep clone to avoid mutating original
+  const config = structuredClone(baseConfig)
+
+  // Process each override section
+  if (Array.isArray(config.overrides)) {
+    const processedOverrides = []
+
+    // First pass: expand markers that generate multiple overrides
+    for (const override of config.overrides) {
+      if (override === '__AUTO_GENERATE_UNIVERSE_OVERRIDES__') {
+        const generatedOverrides = expandUniverseOverridesMarker(config)
+        processedOverrides.push(...generatedOverrides)
+      } else {
+        processedOverrides.push(override)
+      }
+    }
+
+    // Second pass: process each override to resolve __INCLUDE_GLOBAL_VALUES__ markers
+    config.overrides = processedOverrides.map((override) =>
+      override.linter?.rules ? resolveIncludeGlobalValuesMarkers(override, globalRules) : override
+    )
+  } else if (config.overrides) {
+    throw new Error('`overrides` must be an array')
+  }
+
+  return config
+}
+
+/**
+ * Expands __AUTO_GENERATE_UNIVERSE_OVERRIDES__ marker into actual override configurations
+ * @param {Object} baseConfig - The base configuration (needed to extract global patterns)
+ * @returns {Array<Object>} Array of generated override configurations
+ */
+function expandUniverseOverridesMarker(baseConfig) {
+  const universePackages = detectUniversePackages()
+  const globalPatterns = getGlobalRestrictedImportPatterns(baseConfig)
+  const generatedOverrides = generateUniversePackageOverrides(universePackages, globalPatterns)
+
+  console.log(`✓ Auto-generated ${generatedOverrides.length} override(s) for @luxfi/* packages`)
+
+  return generatedOverrides
+}
+
+/**
+ * Resolves __INCLUDE_GLOBAL_VALUES__ markers in an override's rule options
+ * @param {Object} override - Override configuration section
+ * @param {Map<string, any>} globalRules - Map of global rule paths to values
+ * @returns {Object} Processed override with markers resolved
+ */
+function resolveIncludeGlobalValuesMarkers(override, globalRules) {
+  // Deep clone to avoid mutation
+  const processed = structuredClone(override)
+
+  /**
+   * Recursively walks override rules tree to find and resolve markers
+   * @param {Object} obj - Current object being walked
+   * @param {Array<string>} pathParts - Path components leading to this object
+   */
+  function walkAndMerge(obj, pathParts) {
+    if (!obj || typeof obj !== 'object') {
+      return
+    }
+
+    for (const [key, value] of Object.entries(obj)) {
+      const currentPath = [...pathParts, key]
+
+      // Check if this is a rule's options object with potential markers
+      if (key === 'options' && value && typeof value === 'object') {
+        const rulePath = pathParts.join('.')
+        const globalRule = globalRules.get(rulePath)
+
+        // Process each option key generically
+        for (const [optionKey, optionValue] of Object.entries(value)) {
+          const globalOptionValue = globalRule?.options?.[optionKey]
+
+          // Check for marker in object-type options
+          const isObjectWithMarker =
+            optionValue &&
+            typeof optionValue === 'object' &&
+            !Array.isArray(optionValue) &&
+            optionValue.__INCLUDE_GLOBAL_VALUES__
+
+          if (isObjectWithMarker) {
+            obj[key][optionKey] = mergeObjectValues(globalOptionValue || {}, optionValue)
+          }
+
+          // Check for marker in array-type options
+          const isArrayWithMarker = Array.isArray(optionValue) && optionValue.includes('__INCLUDE_GLOBAL_VALUES__')
+
+          if (isArrayWithMarker) {
+            obj[key][optionKey] = mergeArrayValues(globalOptionValue || [], optionValue)
+          }
+        }
+      }
+
+      // Continue walking nested objects
+      if (typeof value === 'object' && value !== null) {
+        walkAndMerge(value, currentPath)
+      }
+    }
+  }
+
+  walkAndMerge(processed.linter.rules, ['linter', 'rules'])
+  return processed
+}
+
+module.exports = { processConfig }

package/src/processor.test.js

@@ -0,0 +1,336 @@
+import { describe, expect, test } from 'bun:test'
+import fs from 'node:fs'
+import path from 'node:path'
+import { parse as parseJsonc } from 'jsonc-parser'
+import { extractGlobalRuleValues } from './extractor.js'
+import { processConfig } from './processor.js'
+
+/**
+ * Helper to load and process a fixture file
+ */
+function processFixture(fixtureName) {
+  const fixturePath = path.join(__dirname, 'fixtures', fixtureName)
+  const content = fs.readFileSync(fixturePath, 'utf8')
+  const config = parseJsonc(content)
+  const globalRules = extractGlobalRuleValues(config)
+  return processConfig(config, globalRules)
+}
+
+describe('Biome Config Processor', () => {
+  describe('Object Marker Resolution', () => {
+    test('should merge global paths with override paths', () => {
+      const result = processFixture('simple-config.jsonc')
+
+      const override = result.overrides[0]
+      const paths = override.linter.rules.style.noRestrictedImports.options.paths
+
+      // Should include both global and override paths
+      expect(paths).toMatchObject({
+        lodash: 'Use lodash-es instead',
+        moment: 'Use date-fns instead',
+        react: 'Use preact in tests',
+      })
+
+      // Should not include marker
+      expect(paths.__INCLUDE_GLOBAL_VALUES__).toBeUndefined()
+    })
+
+    test('should handle "off" overrides correctly', () => {
+      const result = processFixture('off-override-config.jsonc')
+
+      const override = result.overrides[0]
+      const paths = override.linter.rules.style.noRestrictedImports.options.paths
+
+      // Should include global paths except the one turned off
+      expect(paths.lodash).toBe('Use lodash-es instead')
+      expect(paths.moment).toBe('Use date-fns instead')
+
+      // Should not include the "off" path
+      expect(paths.jquery).toBeUndefined()
+
+      // Should include override-specific path
+      expect(paths.axios).toBe('Use fetch instead')
+
+      // Should not include marker
+      expect(paths.__INCLUDE_GLOBAL_VALUES__).toBeUndefined()
+    })
+  })
+
+  describe('Array Marker Resolution', () => {
+    test('should merge global array with override array', () => {
+      const result = processFixture('array-merge-config.jsonc')
+
+      const override = result.overrides[0]
+      const patterns = override.linter.rules.style.noRestrictedImports.options.patterns
+
+      // Should include both global and override items
+      expect(patterns).toEqual(
+        expect.arrayContaining([
+          {
+            group: ['global/*'],
+            message: 'Please do not import from global',
+          },
+          {
+            group: ['localStorage/*'],
+            message: 'Please do not import from localStorage',
+          },
+          {
+            group: ['sessionStorage/*'],
+            message: 'Please do not import from sessionStorage',
+          },
+        ])
+      )
+
+      // Should not include marker
+      expect(patterns).not.toContain('__INCLUDE_GLOBAL_VALUES__')
+    })
+
+    test('should deduplicate merged arrays', () => {
+      const config = {
+        linter: {
+          rules: {
+            style: {
+              noRestrictedImports: {
+                level: 'error',
+                options: {
+                  patterns: [
+                    {
+                      group: ['event/*'],
+                      message: 'Do not import from event',
+                    },
+                    {
+                      group: ['name/*'],
+                      message: 'Do not import from name',
+                    },
+                  ],
+                },
+              },
+            },
+          },
+        },
+        overrides: [
+          {
+            include: ['src/**'],
+            linter: {
+              rules: {
+                style: {
+                  noRestrictedImports: {
+                    level: 'error',
+                    options: {
+                      patterns: [
+                        '__INCLUDE_GLOBAL_VALUES__',
+                        {
+                          group: ['event/*'],
+                          message: 'Do not import from event',
+                        },
+                        {
+                          group: ['localStorage/*'],
+                          message: 'Do not import from localStorage',
+                        },
+                      ],
+                    },
+                  },
+                },
+              },
+            },
+          },
+        ],
+      }
+
+      const globalRules = extractGlobalRuleValues(config)
+      const result = processConfig(config, globalRules)
+
+      const patterns = result.overrides[0].linter.rules.style.noRestrictedImports.options.patterns
+
+      // Should not have duplicates
+      const eventPatterns = patterns.filter((x) => JSON.stringify(x.group) === JSON.stringify(['event/*']))
+      expect(eventPatterns).toHaveLength(1)
+
+      // Should maintain override order (local items first)
+      expect(patterns[0]).toMatchObject({
+        group: ['event/*'],
+        message: 'Do not import from event',
+      })
+      expect(patterns[1]).toMatchObject({
+        group: ['localStorage/*'],
+        message: 'Do not import from localStorage',
+      })
+      expect(patterns[2]).toMatchObject({
+        group: ['name/*'],
+        message: 'Do not import from name',
+      })
+    })
+  })
+
+  describe('No Markers', () => {
+    test('should not modify overrides without markers', () => {
+      const result = processFixture('no-markers-config.jsonc')
+
+      const override = result.overrides[0]
+      const paths = override.linter.rules.style.noRestrictedImports.options.paths
+
+      // Should only have override path
+      expect(paths).toMatchObject({
+        react: 'Custom restriction',
+      })
+
+      // Should not include global paths
+      expect(paths.lodash).toBeUndefined()
+    })
+  })
+
+  describe('Edge Cases', () => {
+    test('should handle config with no overrides', () => {
+      const config = {
+        linter: {
+          rules: {
+            style: {
+              noRestrictedImports: {
+                level: 'error',
+                options: {
+                  paths: {
+                    lodash: 'Use lodash-es',
+                  },
+                },
+              },
+            },
+          },
+        },
+      }
+
+      const globalRules = extractGlobalRuleValues(config)
+      const result = processConfig(config, globalRules)
+
+      // Should return unchanged
+      expect(result).toEqual(config)
+    })
+
+    test('should handle override without linter rules', () => {
+      const config = {
+        linter: {
+          rules: {
+            style: {
+              noRestrictedImports: {
+                level: 'error',
+                options: {
+                  paths: {
+                    lodash: 'Use lodash-es',
+                  },
+                },
+              },
+            },
+          },
+        },
+        overrides: [
+          {
+            include: ['src/**'],
+            formatter: {
+              enabled: false,
+            },
+          },
+        ],
+      }
+
+      const globalRules = extractGlobalRuleValues(config)
+      const result = processConfig(config, globalRules)
+
+      // Should handle override without linter rules gracefully
+      expect(result.overrides[0]).toMatchObject({
+        include: ['src/**'],
+        formatter: {
+          enabled: false,
+        },
+      })
+    })
+
+    test('should handle empty global rules', () => {
+      const config = {
+        linter: {
+          rules: {},
+        },
+        overrides: [
+          {
+            include: ['src/**'],
+            linter: {
+              rules: {
+                style: {
+                  noRestrictedImports: {
+                    level: 'error',
+                    options: {
+                      paths: {
+                        __INCLUDE_GLOBAL_VALUES__: true,
+                        react: 'Custom restriction',
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        ],
+      }
+
+      const globalRules = extractGlobalRuleValues(config)
+      const result = processConfig(config, globalRules)
+
+      const paths = result.overrides[0].linter.rules.style.noRestrictedImports.options.paths
+
+      // Should only include override paths
+      expect(paths).toMatchObject({
+        react: 'Custom restriction',
+      })
+
+      // Should remove marker
+      expect(paths.__INCLUDE_GLOBAL_VALUES__).toBeUndefined()
+    })
+  })
+
+  describe('Immutability', () => {
+    test('should not mutate original config', () => {
+      const originalConfig = {
+        linter: {
+          rules: {
+            style: {
+              noRestrictedImports: {
+                level: 'error',
+                options: {
+                  paths: {
+                    lodash: 'Use lodash-es',
+                  },
+                },
+              },
+            },
+          },
+        },
+        overrides: [
+          {
+            include: ['src/**'],
+            linter: {
+              rules: {
+                style: {
+                  noRestrictedImports: {
+                    level: 'error',
+                    options: {
+                      paths: {
+                        __INCLUDE_GLOBAL_VALUES__: true,
+                        react: 'Custom restriction',
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        ],
+      }
+
+      const globalRules = extractGlobalRuleValues(originalConfig)
+      processConfig(originalConfig, globalRules)
+
+      // Original config should still have the marker
+      expect(
+        originalConfig.overrides[0].linter.rules.style.noRestrictedImports.options.paths.__INCLUDE_GLOBAL_VALUES__
+      ).toBe(true)
+    })
+  })
+})