@luxfi/biome-config 1.0.3 → 1.0.4

package/src/processor.js

@@ -1,121 +0,0 @@
-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

@@ -1,336 +0,0 @@
-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)
-    })
-  })
-})

package/src/universePackages.js

@@ -1,144 +0,0 @@
-const { readCachedProjectGraph, readProjectsConfigurationFromProjectGraph } = require('@nx/devkit')
-const path = require('node:path')
-
-/**
- * Detects all @luxfi/* packages using NX project graph
- * @returns {Array<{dir: string, name: string, fullName: string}>} Array of package info objects
- */
-function detectUniversePackages() {
-  try {
-    // Read the NX project graph (cached for performance)
-    const projectGraph = readCachedProjectGraph()
-    const projectsConfig = readProjectsConfigurationFromProjectGraph(projectGraph)
-
-    const universePackages = []
-
-    // Iterate through all projects in the workspace
-    for (const [projectName, config] of Object.entries(projectsConfig.projects)) {
-      // NX project names are the same as package names (from package.json)
-      if (projectName.startsWith('@luxfi/')) {
-        // Extract the package name without @luxfi/ prefix
-        const shortName = projectName.replace('@luxfi/', '')
-
-        // Extract directory name from root path (e.g., "pkgs/api" -> "api")
-        const dir = path.basename(config.root)
-
-        universePackages.push({
-          dir,
-          name: shortName,
-          fullName: projectName,
-        })
-      }
-    }
-
-    return universePackages
-  } catch (error) {
-    console.warn(`Warning: Could not read project graph: ${error.message}`)
-    console.warn('Falling back to empty package list')
-    return []
-  }
-}
-
-/**
- * Generates override configurations for @luxfi/* packages
- * Each package gets an override that:
- * - Applies to files within that package
- * - Allows the package to deep-import into itself
- *
- * @param {Array<{dir: string, name: string, fullName: string}>} universePackages - Detected packages
- * @param {Array<Object>} globalPatterns - Global restriction patterns
- * @returns {Array<Object>} Array of override configurations
- */
-function generateUniversePackageOverrides(universePackages, globalPatterns) {
-  const overrides = []
-
-  for (const pkg of universePackages) {
-    // For each @luxfi/* package, we need to:
-    // 1. Allow deep imports to ITSELF (@luxfi/api can use @luxfi/api/src/...)
-    // 2. Block deep imports to OTHER @luxfi/* packages
-    //
-    // Strategy: Replace the wildcard pattern @luxfi/*/src with explicit patterns
-    // for all OTHER packages (excluding the current package)
-
-    const filteredPatterns = globalPatterns
-      .map((pattern) => {
-        if (!pattern.group || !Array.isArray(pattern.group)) {
-          return pattern // Keep non-group patterns as-is
-        }
-
-        // Check if this is the @luxfi/* wildcard pattern
-        const hasUniverseWildcard = pattern.group.some((g) => g.includes('@luxfi/*/src') || g === '@luxfi/*/src/*')
-
-        if (!hasUniverseWildcard) {
-          return pattern // Keep other patterns unchanged
-        }
-
-        // Replace wildcard with explicit patterns for OTHER @luxfi/* packages
-        const otherPackages = universePackages.filter((p) => p.name !== pkg.name)
-        const explicitGroup = []
-
-        for (const otherPkg of otherPackages) {
-          explicitGroup.push(`@luxfi/${otherPkg.name}/src`)
-          explicitGroup.push(`@luxfi/${otherPkg.name}/src/*`)
-        }
-
-        // Return new pattern with explicit group (or empty if no other packages)
-        return explicitGroup.length > 0
-          ? {
-              ...pattern,
-              group: explicitGroup,
-            }
-          : null // Will be filtered out below
-      })
-      .filter((p) => p !== null) // Remove null entries
-
-    const override = {
-      includes: [
-        `pkgs/${pkg.dir}/**`,
-        `!pkgs/${pkg.dir}/.eslintrc.js`,
-        `!pkgs/${pkg.dir}/**/__generated__/**`,
-        `!pkgs/${pkg.dir}/scripts/**`,
-      ],
-      linter: {
-        rules: {
-          style: {
-            noRestrictedImports: {
-              level: 'error',
-              options: {
-                paths: {
-                  __INCLUDE_GLOBAL_VALUES__: true,
-                },
-                patterns: filteredPatterns,
-              },
-            },
-          },
-        },
-      },
-    }
-
-    overrides.push(override)
-  }
-
-  return overrides
-}
-
-/**
- * Gets the global noRestrictedImports patterns from the config
- * @param {Object} config - The base configuration
- * @returns {Array<Object>} Array of pattern objects
- */
-function getGlobalRestrictedImportPatterns(config) {
-  const patterns = config?.linter?.rules?.style?.noRestrictedImports?.options?.patterns
-
-  if (!Array.isArray(patterns)) {
-    return []
-  }
-
-  return patterns
-}
-
-module.exports = {
-  detectUniversePackages,
-  generateUniversePackageOverrides,
-  getGlobalRestrictedImportPatterns,
-}