@dimensional-innovations/tool-config 4.0.0 → 5.0.1

package/src/tools/typescript/checker-detection.js

@@ -1,113 +0,0 @@
-import { existsSync } from 'fs'
-import { join } from 'path'
-
-/**
- * Detect which TypeScript checker to use
- * Priority: tsgo (fastest) -> vue-tsc (Vue SFCs) -> tsc (fallback)
- *
- * @param {string} framework - Detected framework
- * @param {string} preference - User preference: 'auto' | 'modern' | 'legacy'
- * @param {string} cwd - Current working directory
- * @returns {string} Checker to use: 'tsgo' | 'vue-tsc' | 'tsc'
- */
-export function detectTypeChecker(framework, preference = 'auto', cwd = process.cwd()) {
-  // User explicitly requested legacy
-  if (preference === 'legacy') {
-    return framework === 'vue' ? 'vue-tsc' : 'tsc'
-  }
-
-  // User explicitly requested modern
-  if (preference === 'modern') {
-    return 'tsgo'
-  }
-
-  // Auto-detection (default)
-  if (preference === 'auto') {
-    // Vue needs vue-tsc for SFC support (tsgo doesn't support .vue yet)
-    if (framework === 'vue') {
-      const hasVueTsc = hasPackageInstalled('vue-tsc', cwd)
-      if (hasVueTsc) return 'vue-tsc'
-
-      console.warn(
-        '⚠️  Vue project detected but vue-tsc not found.\n' +
-          '   Install with: npm install -D vue-tsc\n' +
-          "   Falling back to tsgo/tsc (won't check .vue files)"
-      )
-    }
-
-    // Check if tsgo is available
-    const hasTsgo = hasPackageInstalled('@typescript/native-preview', cwd)
-    if (hasTsgo) {
-      return 'tsgo'
-    }
-
-    // Fallback to standard tsc
-    return 'tsc'
-  }
-
-  throw new Error(`Unknown checker preference: ${preference}`)
-}
-
-/**
- * Check if package is installed in node_modules
- *
- * @param {string} packageName - Package to check for
- * @param {string} cwd - Current working directory
- * @returns {boolean} True if package is installed
- */
-function hasPackageInstalled(packageName, cwd) {
-  try {
-    const packagePath = join(cwd, 'node_modules', packageName, 'package.json')
-    return existsSync(packagePath)
-  } catch {
-    return false
-  }
-}
-
-/**
- * Get the command to run for type checking
- *
- * @param {string} checker - Checker to use: 'tsgo' | 'tsc' | 'vue-tsc'
- * @param {Object} options - Command options
- * @param {boolean} [options.watch=false] - Enable watch mode
- * @param {boolean} [options.noEmit=true] - Skip emit (type check only)
- * @param {string} [options.project='.'] - Project path
- * @returns {string} Command string
- */
-export function getTypeCheckCommand(checker, options = {}) {
-  const { watch = false, noEmit = true, project = '.' } = options
-
-  const baseCmd = checker // 'tsgo', 'tsc', or 'vue-tsc'
-  const flags = []
-
-  if (noEmit) flags.push('--noEmit')
-  if (watch) flags.push('--watch')
-  if (project !== '.') flags.push(`-p ${project}`)
-
-  return `${baseCmd} ${flags.join(' ')}`.trim()
-}
-
-/**
- * Get fallback chain for script generation
- * Example: "tsgo --noEmit || tsc --noEmit"
- *
- * @param {string} checker - Primary checker to use
- * @param {string} framework - Framework name
- * @returns {string} Command with fallback
- */
-export function getTypeCheckCommandWithFallback(checker, framework) {
-  const primary = getTypeCheckCommand(checker, { noEmit: true })
-
-  // No fallback needed for vue-tsc or tsc (they're already fallbacks)
-  if (checker === 'vue-tsc' || checker === 'tsc') {
-    return primary
-  }
-
-  // tsgo with fallback
-  const fallback =
-    framework === 'vue'
-      ? getTypeCheckCommand('vue-tsc', { noEmit: true })
-      : getTypeCheckCommand('tsc', { noEmit: true })
-
-  return `${primary} || ${fallback}`
-}

package/src/tools/typescript/index.js

@@ -1,202 +0,0 @@
-import { autoDetect } from '../../detectors.js'
-
-import { detectTypeChecker } from './checker-detection.js'
-import basePreset from './presets/base.js'
-import browserEnv from './presets/environments/browser.js'
-import nodeEnv from './presets/environments/node.js'
-import universalEnv from './presets/environments/universal.js'
-import angularFramework from './presets/frameworks/angular.js'
-import astroFramework from './presets/frameworks/astro.js'
-import electronFramework from './presets/frameworks/electron.js'
-import nodeFramework from './presets/frameworks/node.js'
-import reactFramework from './presets/frameworks/react.js'
-import solidFramework from './presets/frameworks/solid.js'
-import svelteFramework from './presets/frameworks/svelte.js'
-import vanillaFramework from './presets/frameworks/vanilla.js'
-import vueFramework from './presets/frameworks/vue.js'
-
-/**
- * Create TypeScript configuration with auto-detection
- *
- * @param {Object} options - Configuration options
- * @param {string} [options.framework='auto'] - Framework to configure for
- * @param {string} [options.environment='auto'] - Target environment
- * @param {boolean} [options.typescript=true] - Enable TypeScript (always true for this tool)
- * @param {string} [options.checker='auto'] - Which checker: 'auto', 'modern' (tsgo), 'legacy' (tsc)
- * @param {boolean} [options.strict=true] - Enable strict mode
- * @param {Object} [options.compilerOptions={}] - User compiler option overrides
- * @param {string} [options.cwd=process.cwd()] - Working directory
- * @returns {Object} TypeScript configuration object
- */
-export function createTypescriptConfig(options = {}) {
-  const {
-    framework: frameworkOption = 'auto',
-    environment: environmentOption = 'auto',
-    checker: checkerPreference = 'auto',
-    strict = true,
-    electron: electronOption,
-    renderer: rendererOption,
-    compilerOptions: userCompilerOptions = {},
-    cwd = process.cwd()
-  } = options
-
-  // Auto-detect framework, environment, and Electron
-  const detected =
-    frameworkOption === 'auto' || environmentOption === 'auto' || electronOption === undefined
-      ? autoDetect(cwd)
-      : { framework: frameworkOption, environment: environmentOption, electron: electronOption }
-
-  const framework = frameworkOption === 'auto' ? detected.framework : frameworkOption
-  const environment = environmentOption === 'auto' ? detected.environment : environmentOption
-  const isElectron = electronOption !== undefined ? electronOption : detected.electron
-
-  // Handle Electron multi-config
-  if (isElectron) {
-    const renderer = rendererOption || framework
-    const checker = detectTypeChecker(framework, checkerPreference, cwd)
-
-    console.log(
-      `⚡ Electron TypeScript Config: ${renderer} renderer | Checker: ${checker}${checker === 'tsgo' ? ' (10x faster!)' : ''}`
-    )
-
-    const configs = electronFramework(renderer)
-
-    return {
-      ...configs,
-      _meta: {
-        framework: 'electron',
-        renderer,
-        checker,
-        multiConfig: true,
-        experimental: checker === 'tsgo',
-        generatedBy: '@dimensional-innovations/tool-config'
-      }
-    }
-  }
-
-  // Detect which type checker to use
-  const checker = detectTypeChecker(framework, checkerPreference, cwd)
-
-  // Log detection
-  console.log(
-    `🔍 TypeScript Config: ${framework} | ${environment} | Checker: ${checker}${checker === 'tsgo' ? ' (10x faster!)' : ''}`
-  )
-
-  // Load presets
-  const config = loadPresets(framework, environment, strict)
-
-  // Merge user overrides
-  if (userCompilerOptions && Object.keys(userCompilerOptions).length > 0) {
-    config.compilerOptions = {
-      ...config.compilerOptions,
-      ...userCompilerOptions
-    }
-  }
-
-  // Add metadata
-  config._meta = {
-    framework,
-    environment,
-    checker,
-    experimental: checker === 'tsgo',
-    generatedBy: '@dimensional-innovations/tool-config'
-  }
-
-  return config
-}
-
-/**
- * Load and merge configuration presets
- *
- * @param {string} framework - Framework name
- * @param {string} environment - Environment name
- * @param {boolean} strict - Enable strict mode
- * @returns {Object} Merged configuration
- */
-function loadPresets(framework, environment, strict) {
-  const config = JSON.parse(JSON.stringify(basePreset)) // Deep clone
-
-  // Load environment preset (synchronous imports)
-  const envPreset = loadEnvironmentPreset(environment)
-  mergeConfig(config, envPreset)
-
-  // Load framework preset (synchronous imports)
-  const frameworkPreset = loadFrameworkPreset(framework)
-  mergeConfig(config, frameworkPreset)
-
-  // Apply strict mode overrides if disabled
-  if (!strict) {
-    config.compilerOptions.strict = false
-    config.compilerOptions.noImplicitAny = false
-    // Keep other strict checks, just disable the master switch
-  }
-
-  return config
-}
-
-/**
- * Load environment-specific preset
- *
- * @param {string} environment - Environment name
- * @returns {Object} Environment preset
- */
-function loadEnvironmentPreset(environment) {
-  switch (environment) {
-    case 'browser':
-      return browserEnv
-    case 'node':
-      return nodeEnv
-    case 'universal':
-      return universalEnv
-    default:
-      return {}
-  }
-}
-
-/**
- * Load framework-specific preset
- *
- * @param {string} framework - Framework name
- * @returns {Object} Framework preset
- */
-function loadFrameworkPreset(framework) {
-  switch (framework) {
-    case 'react':
-      return reactFramework
-    case 'vue':
-      return vueFramework
-    case 'svelte':
-      return svelteFramework
-    case 'solid':
-      return solidFramework
-    case 'astro':
-      return astroFramework
-    case 'angular':
-      return angularFramework
-    case 'node':
-      return nodeFramework
-    case 'vanilla':
-    default:
-      return vanillaFramework
-  }
-}
-
-/**
- * Deep merge configuration objects
- *
- * @param {Object} target - Target configuration
- * @param {Object} source - Source configuration to merge
- */
-function mergeConfig(target, source) {
-  for (const key in source) {
-    if (key === 'compilerOptions' && target.compilerOptions) {
-      Object.assign(target.compilerOptions, source.compilerOptions)
-    } else if (key === 'include' && Array.isArray(source.include)) {
-      target.include = [...new Set([...(target.include || []), ...source.include])]
-    } else if (key === 'exclude' && Array.isArray(source.exclude)) {
-      target.exclude = [...new Set([...(target.exclude || []), ...source.exclude])]
-    } else {
-      target[key] = source[key]
-    }
-  }
-}

package/src/tools/typescript/presets/base.js

@@ -1,58 +0,0 @@
-/**
- * Base TypeScript configuration
- * Strict, modern defaults that work across all frameworks
- *
- * Based on TypeScript 5.x best practices with ES2022 target
- */
-export default {
-  compilerOptions: {
-    // Language and Environment
-    target: 'ES2022',
-    lib: ['ES2022'],
-
-    // Modules
-    module: 'ESNext',
-    moduleResolution: 'Bundler',
-    resolveJsonModule: true,
-
-    // Emit
-    declaration: true,
-    declarationMap: true,
-    sourceMap: true,
-    removeComments: false,
-
-    // Interop Constraints
-    esModuleInterop: true,
-    allowSyntheticDefaultImports: true,
-    forceConsistentCasingInFileNames: true,
-    isolatedModules: true,
-
-    // Type Checking (Strict Mode)
-    strict: true,
-    noImplicitAny: true,
-    strictNullChecks: true,
-    strictFunctionTypes: true,
-    strictBindCallApply: true,
-    strictPropertyInitialization: true,
-    noImplicitThis: true,
-    alwaysStrict: true,
-
-    // Additional Checks
-    noUnusedLocals: true,
-    noUnusedParameters: true,
-    noImplicitReturns: true,
-    noFallthroughCasesInSwitch: true,
-    noUncheckedIndexedAccess: true,
-    noImplicitOverride: true,
-    noPropertyAccessFromIndexSignature: false,
-
-    // Completeness
-    skipLibCheck: true, // Faster, skip checking .d.ts files
-
-    // Advanced
-    allowUnusedLabels: false,
-    allowUnreachableCode: false
-  },
-  include: ['src/**/*'],
-  exclude: ['node_modules', 'dist', 'build', 'out', 'coverage', '.nyc_output']
-}

package/src/tools/typescript/presets/environments/browser.js

@@ -1,10 +0,0 @@
-/**
- * Browser environment TypeScript configuration
- * For client-side applications running in web browsers
- */
-export default {
-  compilerOptions: {
-    lib: ['ES2022', 'DOM', 'DOM.Iterable'],
-    target: 'ES2020' // Good browser support
-  }
-}

package/src/tools/typescript/presets/environments/node.js

@@ -1,11 +0,0 @@
-/**
- * Node.js environment TypeScript configuration
- * For server-side applications and CLIs
- */
-export default {
-  compilerOptions: {
-    lib: ['ES2022'],
-    target: 'ES2022',
-    types: ['node']
-  }
-}

package/src/tools/typescript/presets/environments/universal.js

@@ -1,11 +0,0 @@
-/**
- * Universal (SSR/Isomorphic) environment TypeScript configuration
- * For applications that run in both browser and Node.js contexts
- */
-export default {
-  compilerOptions: {
-    lib: ['ES2022', 'DOM', 'DOM.Iterable'],
-    target: 'ES2020',
-    types: ['node'] // Include Node types for server-side code
-  }
-}

package/src/tools/typescript/presets/frameworks/angular.js

@@ -1,11 +0,0 @@
-/**
- * Angular TypeScript configuration
- * Strict mode enabled by default (Angular best practice)
- */
-export default {
-  compilerOptions: {
-    lib: ['ES2022', 'DOM', 'DOM.Iterable'],
-    experimentalDecorators: true,
-    emitDecoratorMetadata: true
-  }
-}

package/src/tools/typescript/presets/frameworks/astro.js

@@ -1,11 +0,0 @@
-/**
- * Astro TypeScript configuration
- * Multi-framework support with islands architecture
- */
-export default {
-  compilerOptions: {
-    jsx: 'react-jsx', // Astro uses React-style JSX
-    lib: ['ES2022', 'DOM', 'DOM.Iterable'],
-    types: ['astro/client']
-  }
-}

package/src/tools/typescript/presets/frameworks/electron.js

@@ -1,100 +0,0 @@
-/**
- * Electron TypeScript preset - generates multi-config setup
- * Replaces @electron-toolkit/tsconfig with framework-aware configs
- *
- * Generates 4 separate tsconfig files:
- * - tsconfig.json: Root orchestrator with project references
- * - tsconfig.node.json: Main process + Preload scripts (Node.js environment)
- * - tsconfig.web.json: Renderer process (browser environment with framework)
- * - tsconfig.tests.json: Test environment (Vitest + Playwright)
- */
-
-/**
- * Create Electron multi-config preset
- * @param {string} renderer - Renderer framework ('vue', 'react', 'svelte', 'vanilla')
- * @returns {Object} Object containing all 4 tsconfig configurations
- */
-export default function createElectronPreset(renderer = 'vue') {
-  // Determine renderer-specific file extensions
-  const rendererExtensions = renderer === 'vue' ? ['src/renderer/**/*.vue'] : []
-
-  return {
-    // Root tsconfig.json - orchestrator with project references
-    root: {
-      files: [],
-      references: [{ path: './tsconfig.node.json' }, { path: './tsconfig.web.json' }]
-    },
-
-    // tsconfig.node.json - Main process + Preload scripts
-    node: {
-      $schema: 'https://json.schemastore.org/tsconfig',
-      include: ['electron.vite.config.*', 'package.json', 'src/main/*', 'src/preload/*'],
-      compilerOptions: {
-        composite: true,
-        target: 'ES2024',
-        lib: ['ES2024', 'ESNext'],
-        module: 'NodeNext',
-        moduleResolution: 'NodeNext',
-        types: ['electron-vite/node'],
-        baseUrl: '.',
-        paths: {
-          '@/*': ['src/*'],
-          '@main/*': ['src/main/*'],
-          '@preload/*': ['src/preload/*']
-        },
-        resolveJsonModule: true
-      }
-    },
-
-    // tsconfig.web.json - Renderer process (browser)
-    web: {
-      $schema: 'https://json.schemastore.org/tsconfig',
-      include: [
-        'src/renderer/env.d.ts',
-        'src/renderer/**/*',
-        ...rendererExtensions,
-        'src/preload/*.d.ts',
-        'package.json'
-      ],
-      compilerOptions: {
-        composite: true,
-        target: 'ES2024',
-        lib: ['ES2024', 'ESNext', 'DOM', 'DOM.Iterable'],
-        baseUrl: '.',
-        paths: {
-          '@/*': ['src/*'],
-          '@renderer/*': ['src/renderer/*'],
-          '@main/*': ['src/main/*'],
-          '@preload/*': ['src/preload/*']
-        },
-        strict: true,
-        noUnusedParameters: true,
-        noFallthroughCasesInSwitch: true,
-        noUncheckedIndexedAccess: true
-      }
-    },
-
-    // tsconfig.tests.json - Test environment
-    tests: {
-      $schema: 'https://json.schemastore.org/tsconfig',
-      include: ['tests/**/*', 'src/renderer/**/*.vue', 'src/renderer/env.d.ts'],
-      compilerOptions: {
-        composite: true,
-        baseUrl: '.',
-        paths: {
-          '@/*': ['src/*'],
-          '@renderer/*': ['src/renderer/*'],
-          '@main/*': ['src/main/*'],
-          '@preload/*': ['src/preload/*'],
-          '@tests/*': ['tests/*'],
-          '@unit/*': ['tests/unit/*'],
-          '@integration/*': ['tests/integration/*'],
-          '@fixtures/*': ['tests/fixtures/*'],
-          '@setup/*': ['tests/setup/*']
-        },
-        types: ['vitest/globals', '@playwright/test'],
-        strict: false
-      }
-    }
-  }
-}

package/src/tools/typescript/presets/frameworks/node.js

@@ -1,12 +0,0 @@
-/**
- * Node.js backend TypeScript configuration
- * For server-side applications, APIs, and CLIs
- */
-export default {
-  compilerOptions: {
-    lib: ['ES2022'],
-    module: 'NodeNext',
-    moduleResolution: 'NodeNext',
-    types: ['node']
-  }
-}

package/src/tools/typescript/presets/frameworks/react.js

@@ -1,10 +0,0 @@
-/**
- * React TypeScript configuration
- * Supports modern React 17+ with automatic JSX runtime
- */
-export default {
-  compilerOptions: {
-    jsx: 'react-jsx', // Modern React 17+ automatic runtime
-    lib: ['ES2022', 'DOM', 'DOM.Iterable']
-  }
-}

package/src/tools/typescript/presets/frameworks/solid.js

@@ -1,11 +0,0 @@
-/**
- * Solid.js TypeScript configuration
- * Uses JSX similar to React
- */
-export default {
-  compilerOptions: {
-    jsx: 'preserve', // Solid uses its own JSX transform
-    jsxImportSource: 'solid-js',
-    lib: ['ES2022', 'DOM', 'DOM.Iterable']
-  }
-}

package/src/tools/typescript/presets/frameworks/svelte.js

@@ -1,10 +0,0 @@
-/**
- * Svelte TypeScript configuration
- * Note: Use svelte-check for .svelte file type checking
- */
-export default {
-  compilerOptions: {
-    lib: ['ES2022', 'DOM', 'DOM.Iterable'],
-    types: ['svelte']
-  }
-}

package/src/tools/typescript/presets/frameworks/vanilla.js

@@ -1,9 +0,0 @@
-/**
- * Vanilla TypeScript configuration
- * Plain TypeScript without any framework
- */
-export default {
-  compilerOptions: {
-    lib: ['ES2022', 'DOM', 'DOM.Iterable']
-  }
-}

package/src/tools/typescript/presets/frameworks/vue.js

@@ -1,17 +0,0 @@
-/**
- * Vue.js TypeScript configuration
- * Requires vue-tsc for Single File Component (.vue) support
- */
-export default {
-  compilerOptions: {
-    jsx: 'preserve', // Vue compiler handles JSX transformation
-    jsxImportSource: 'vue',
-    lib: ['ES2022', 'DOM', 'DOM.Iterable'],
-    types: ['vite/client'] // Common for Vue + Vite projects
-  },
-  // Vue-specific options (for vue-tsc)
-  vueCompilerOptions: {
-    extensions: ['.vue'],
-    vitePressExtensions: ['.md']
-  }
-}