@luxfi/biome-config 1.0.0

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@luxfi/biome-config",
+  "version": "1.0.0",
+  "description": "Shared Biome configuration for Lux Universe",
+  "devDependencies": {
+    "jsonc-parser": "3.2.0"
+  },
+  "exports": {
+    ".": "./compiled/base.json"
+  },
+  "scripts": {
+    "prepare": "nx prepare biome-config",
+    "test": "nx test biome-config"
+  },
+  "nx": {
+    "includedScripts": []
+  },
+  "keywords": [
+    "biome",
+    "config",
+    "linting",
+    "formatting"
+  ],
+  "license": "MIT"
+}

package/project.json

@@ -0,0 +1,27 @@
+{
+  "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/scripts/generate.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+
+const fs = require('node:fs')
+const path = require('node:path')
+const { parse: parseJsonc } = require('jsonc-parser')
+const { extractGlobalRuleValues } = require('../src/extractor')
+const { processConfig } = require('../src/processor')
+
+const BASE_FILE = path.join(__dirname, '..', 'base.jsonc')
+const OUTPUT_DIR = path.join(__dirname, '..', 'compiled')
+const OUTPUT_FILE = path.join(OUTPUT_DIR, 'base.json')
+
+/**
+ * Generic Biome Config Marker System
+ *
+ * This script processes base.jsonc and resolves __INCLUDE_GLOBAL_VALUES__ markers
+ * by merging values from the main linter config into override sections.
+ *
+ * Key features:
+ * - Generic rule extraction: walks main linter.rules tree to build lookup map
+ * - Generic marker detection: finds __INCLUDE_GLOBAL_VALUES__ in any option key
+ * - First-level merging: merges top-level keys only, not nested properties
+ * - Works with any option key: paths, patterns, deniedGlobals, etc.
+ *
+ * Process:
+ * 1. Parse base.jsonc with global restrictions in main linter config
+ * 2. Extract all rule values from main linter.rules into a lookup map
+ * 3. For each override with __INCLUDE_GLOBAL_VALUES__ markers:
+ *    - Look up the corresponding global rule value
+ *    - Merge using the appropriate strategy based on value type (object/array)
+ *    - Handle special cases: "off" overrides for objects, deduplication for arrays
+ * 4. Write compiled output to compiled/base.json
+ */
+
+/**
+ * Main entry point - generates compiled config with markers resolved
+ */
+function generate() {
+  // Validate base.jsonc exists
+  if (!fs.existsSync(BASE_FILE)) {
+    console.error('Base config file not found:', BASE_FILE)
+    process.exit(1)
+  }
+
+  // Clean and create output directory
+  if (fs.existsSync(OUTPUT_DIR)) {
+    fs.rmSync(OUTPUT_DIR, { recursive: true, force: true })
+  }
+  fs.mkdirSync(OUTPUT_DIR, { recursive: true })
+
+  // Read and parse base.jsonc
+  const baseContent = fs.readFileSync(BASE_FILE, 'utf8')
+  let baseConfig
+  try {
+    baseConfig = parseJsonc(baseContent)
+  } catch (error) {
+    console.error('Failed to parse base config file:', BASE_FILE, error.message)
+    process.exit(1)
+  }
+
+  let processedConfig
+  try {
+    // Extract global rule values from main linter config
+    const globalRules = extractGlobalRuleValues(baseConfig)
+    // Process all overrides to resolve markers
+    processedConfig = processConfig(baseConfig, globalRules)
+  } catch (error) {
+    console.error('Failed to generate biome config file:', BASE_FILE, error.message)
+    process.exit(1)
+  }
+  // Write compiled output
+  try {
+    fs.writeFileSync(OUTPUT_FILE, `${JSON.stringify(processedConfig, null, 2)}\n`)
+    console.log('✓ Generated biome.json')
+  } catch (error) {
+    console.error('Failed to write compiled config:', OUTPUT_FILE, error.message)
+    process.exit(1)
+  }
+}
+
+generate()

package/src/extractor.js

@@ -0,0 +1,44 @@
+/**
+ * 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

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

@@ -0,0 +1,52 @@
+{
+  "$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

@@ -0,0 +1,37 @@
+{
+  "$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

@@ -0,0 +1,41 @@
+{
+  "$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

@@ -0,0 +1,45 @@
+{
+  "$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

@@ -0,0 +1,100 @@
+/**
+ * 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 }