@luxfi/biome-config 1.0.3 → 1.0.4

package/project.json

@@ -1,27 +0,0 @@
-{
-  "tags": ["scope:biome-config", "type:tooling"],
-  "targets": {
-    "prepare": {
-      "command": "bun ./scripts/generate.js && biome check --write",
-      "options": {
-        "cwd": "{projectRoot}"
-      },
-      "cache": true,
-      "inputs": [
-        "{projectRoot}/base.jsonc",
-        "{projectRoot}/scripts/**",
-        "{projectRoot}/src/**",
-        "{projectRoot}/package.json"
-      ],
-      "outputs": ["{projectRoot}/compiled/base.json"]
-    },
-    "test": {
-      "command": "bun test",
-      "options": {
-        "cwd": "{projectRoot}"
-      },
-      "cache": true,
-      "inputs": ["{projectRoot}/src/**", "{projectRoot}/scripts/**"]
-    }
-  }
-}

package/src/extractor.js

@@ -1,44 +0,0 @@
-/**
- * Extracts all rule values from main linter config into a path-keyed lookup map
- * @param {Object} mainConfig - The main linter configuration object
- * @returns {Map<string, any>} Map of rule paths (e.g., "linter.rules.style.noRestrictedImports") to their values
- */
-function extractGlobalRuleValues(mainConfig) {
-  const ruleMap = new Map()
-
-  /**
-   * Recursively walks rules tree to extract all rule configurations
-   * @param {Object} obj - Current object being walked
-   * @param {Array<string>} pathParts - Path components leading to this object
-   */
-  function walkRules(obj, pathParts) {
-    if (!obj || typeof obj !== 'object') {
-      return
-    }
-
-    for (const [key, value] of Object.entries(obj)) {
-      const currentPath = [...pathParts, key]
-      const pathString = currentPath.join('.')
-
-      // Store this rule value if it looks like a rule configuration
-      // Rules have a "level" property, or are "off"/"error"/"warn" strings
-      if (value && typeof value === 'object' && (value.level || value.options)) {
-        ruleMap.set(pathString, value)
-      }
-
-      // Continue walking nested objects (but not arrays)
-      if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-        walkRules(value, currentPath)
-      }
-    }
-  }
-
-  // Start walking from linter.rules
-  if (mainConfig.linter?.rules) {
-    walkRules(mainConfig.linter.rules, ['linter', 'rules'])
-  }
-
-  return ruleMap
-}
-
-module.exports = { extractGlobalRuleValues }

package/src/extractor.test.js

@@ -1,138 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { extractGlobalRuleValues } from './extractor.js'
-
-describe('extractGlobalRuleValues', () => {
-  test('should extract simple rule values', () => {
-    const config = {
-      linter: {
-        rules: {
-          style: {
-            noRestrictedImports: {
-              level: 'error',
-              options: {
-                paths: {
-                  lodash: 'Use lodash-es',
-                },
-              },
-            },
-          },
-        },
-      },
-    }
-
-    const result = extractGlobalRuleValues(config)
-
-    expect(result.has('linter.rules.style.noRestrictedImports')).toBe(true)
-    expect(result.get('linter.rules.style.noRestrictedImports')).toMatchObject({
-      level: 'error',
-      options: {
-        paths: {
-          lodash: 'Use lodash-es',
-        },
-      },
-    })
-  })
-
-  test('should extract nested rule values', () => {
-    const config = {
-      linter: {
-        rules: {
-          complexity: {
-            noExtraBooleanCast: {
-              level: 'error',
-            },
-          },
-          style: {
-            noNegationElse: {
-              level: 'warn',
-            },
-          },
-        },
-      },
-    }
-
-    const result = extractGlobalRuleValues(config)
-
-    expect(result.size).toBe(2)
-    expect(result.has('linter.rules.complexity.noExtraBooleanCast')).toBe(true)
-    expect(result.has('linter.rules.style.noNegationElse')).toBe(true)
-  })
-
-  test('should handle config without linter rules', () => {
-    const config = {
-      formatter: {
-        enabled: true,
-      },
-    }
-
-    const result = extractGlobalRuleValues(config)
-
-    expect(result.size).toBe(0)
-  })
-
-  test('should handle empty linter rules', () => {
-    const config = {
-      linter: {
-        rules: {},
-      },
-    }
-
-    const result = extractGlobalRuleValues(config)
-
-    expect(result.size).toBe(0)
-  })
-
-  test('should only extract objects with level or options', () => {
-    const config = {
-      linter: {
-        rules: {
-          style: {
-            noRestrictedImports: {
-              level: 'error',
-              options: {
-                paths: {
-                  lodash: 'Use lodash-es',
-                },
-              },
-            },
-            someOtherKey: {
-              randomProperty: 'value',
-            },
-          },
-        },
-      },
-    }
-
-    const result = extractGlobalRuleValues(config)
-
-    // Should only extract the rule with level/options
-    expect(result.size).toBe(1)
-    expect(result.has('linter.rules.style.noRestrictedImports')).toBe(true)
-    expect(result.has('linter.rules.style.someOtherKey')).toBe(false)
-  })
-
-  test('should not walk into arrays', () => {
-    const config = {
-      linter: {
-        rules: {
-          style: {
-            noRestrictedGlobals: {
-              level: 'error',
-              options: {
-                deniedGlobals: ['event', 'name'],
-              },
-            },
-          },
-        },
-      },
-    }
-
-    const result = extractGlobalRuleValues(config)
-
-    expect(result.size).toBe(1)
-    expect(result.has('linter.rules.style.noRestrictedGlobals')).toBe(true)
-
-    const rule = result.get('linter.rules.style.noRestrictedGlobals')
-    expect(Array.isArray(rule.options.deniedGlobals)).toBe(true)
-  })
-})

package/src/fixtures/array-merge-config.jsonc

@@ -1,52 +0,0 @@
-{
-  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "style": {
-        "noRestrictedImports": {
-          "level": "error",
-          "options": {
-            "patterns": [
-              {
-                "group": ["localStorage/*"],
-                "message": "Please do not import from localStorage"
-              },
-              {
-                "group": ["global/*"],
-                "message": "Please do not import from global"
-              }
-            ]
-          }
-        }
-      }
-    }
-  },
-  "overrides": [
-    {
-      "include": ["src/legacy/**"],
-      "linter": {
-        "rules": {
-          "style": {
-            "noRestrictedImports": {
-              "level": "error",
-              "options": {
-                "patterns": [
-                  "__INCLUDE_GLOBAL_VALUES__",
-                  {
-                    "group": ["localStorage/*"],
-                    "message": "Please do not import from localStorage"
-                  },
-                  {
-                    "group": ["sessionStorage/*"],
-                    "message": "Please do not import from sessionStorage"
-                  }
-                ]
-              }
-            }
-          }
-        }
-      }
-    }
-  ]
-}

package/src/fixtures/no-markers-config.jsonc

@@ -1,37 +0,0 @@
-{
-  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "style": {
-        "noRestrictedImports": {
-          "level": "error",
-          "options": {
-            "paths": {
-              "lodash": "Use lodash-es instead"
-            }
-          }
-        }
-      }
-    }
-  },
-  "overrides": [
-    {
-      "include": ["src/custom/**"],
-      "linter": {
-        "rules": {
-          "style": {
-            "noRestrictedImports": {
-              "level": "error",
-              "options": {
-                "paths": {
-                  "react": "Custom restriction"
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  ]
-}

package/src/fixtures/off-override-config.jsonc

@@ -1,41 +0,0 @@
-{
-  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "style": {
-        "noRestrictedImports": {
-          "level": "error",
-          "options": {
-            "paths": {
-              "lodash": "Use lodash-es instead",
-              "moment": "Use date-fns instead",
-              "jquery": "No jQuery allowed"
-            }
-          }
-        }
-      }
-    }
-  },
-  "overrides": [
-    {
-      "include": ["src/vendor/**"],
-      "linter": {
-        "rules": {
-          "style": {
-            "noRestrictedImports": {
-              "level": "error",
-              "options": {
-                "paths": {
-                  "__INCLUDE_GLOBAL_VALUES__": true,
-                  "jquery": "off",
-                  "axios": "Use fetch instead"
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  ]
-}

package/src/fixtures/simple-config.jsonc

@@ -1,45 +0,0 @@
-{
-  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "style": {
-        "noRestrictedImports": {
-          "level": "error",
-          "options": {
-            "paths": {
-              "lodash": "Use lodash-es instead",
-              "moment": "Use date-fns instead"
-            }
-          }
-        },
-        "noRestrictedGlobals": {
-          "level": "error",
-          "options": {
-            "deniedGlobals": ["event", "name"]
-          }
-        }
-      }
-    }
-  },
-  "overrides": [
-    {
-      "include": ["src/test/**"],
-      "linter": {
-        "rules": {
-          "style": {
-            "noRestrictedImports": {
-              "level": "error",
-              "options": {
-                "paths": {
-                  "__INCLUDE_GLOBAL_VALUES__": true,
-                  "react": "Use preact in tests"
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  ]
-}

package/src/merger.js

@@ -1,100 +0,0 @@
-/**
- * Merges global object values into local object values (generic first-level merge)
- *
- * Performs first-level merging only - merges top-level keys but does not merge
- * nested properties within each key's value. When both global and local define
- * the same key, the local version completely replaces the global version.
- *
- * Works with any object-type option (paths, deniedGlobals, elements, etc.)
- *
- * Special handling:
- * - "off" values: removes that global key from the result
- * - Local precedence: local value completely replaces global for the same key
- *
- * @param {Object} globalValues - Global values from main config
- * @param {Object} localValues - Local values from override (includes marker)
- * @returns {Object} Merged object (marker removed)
- */
-function mergeObjectValues(globalValues, localValues) {
-  const merged = {}
-
-  // Add all global keys (except those explicitly turned off or overridden)
-  for (const [key, globalValue] of Object.entries(globalValues)) {
-    const localValue = localValues[key]
-
-    // Skip if explicitly disabled
-    if (localValue === 'off') {
-      continue
-    }
-
-    // Use local value if present, otherwise use global
-    merged[key] = localValue !== undefined ? localValue : globalValue
-  }
-
-  // Add local-only keys (except marker and "off" values)
-  for (const [key, value] of Object.entries(localValues)) {
-    const shouldSkip = key === '__INCLUDE_GLOBAL_VALUES__' || key in globalValues || value === 'off'
-    if (!shouldSkip) {
-      merged[key] = value
-    }
-  }
-
-  return merged
-}
-
-/**
- * Normalizes an item for comparison by sorting object keys
- * This ensures objects with the same properties but different order are treated as equal
- *
- * @param {*} item - Item to normalize (object, primitive, etc.)
- * @returns {string} Normalized JSON string representation
- */
-function normalizeForComparison(item) {
-  if (typeof item !== 'object' || item === null) {
-    return JSON.stringify(item)
-  }
-
-  // Sort object keys to ensure consistent serialization
-  const sortedKeys = Object.keys(item).sort()
-  const normalized = {}
-  for (const key of sortedKeys) {
-    normalized[key] = item[key]
-  }
-
-  return JSON.stringify(normalized)
-}
-
-/**
- * Merges global array values into local array values (generic array merge)
- *
- * Concatenates global and local arrays, removing duplicates based on JSON serialization.
- * Works with any array-type option (patterns, etc.)
- *
- * @param {Array} globalValues - Global array from main config
- * @param {Array} localValues - Local array from override (includes marker)
- * @returns {Array} Merged array (marker removed)
- */
-function mergeArrayValues(globalValues, localValues) {
-  // Filter out marker and deduplicate local values
-  const seen = new Set()
-  const cleanLocal = []
-
-  for (const item of localValues) {
-    if (item === '__INCLUDE_GLOBAL_VALUES__') {
-      continue
-    }
-
-    const normalized = normalizeForComparison(item)
-    if (!seen.has(normalized)) {
-      seen.add(normalized)
-      cleanLocal.push(item)
-    }
-  }
-
-  // Add global items that don't already exist in local
-  const newItems = globalValues.filter((item) => !seen.has(normalizeForComparison(item)))
-
-  return [...cleanLocal, ...newItems]
-}
-
-module.exports = { mergeObjectValues, mergeArrayValues }

package/src/merger.test.js

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