@nlabs/lex 1.58.1 → 1.59.0

package/.github/copilot-instructions.md

@@ -1,194 +1,55 @@
-# Lex: AI Coding Agent Instructions
-
-## Project Overview
-Lex is a zero-configuration React development CLI that provides a complete development environment with AI-powered features. It uses SWC for lightning-fast compilation and includes Vitest testing, Storybook integration, and intelligent code assistance.
-
-## Architecture & Key Components
-
-### Core Structure
-- **Source**: `src/` - TypeScript source code
-- **Compiled**: `lib/` - SWC-compiled JavaScript output
-- **Commands**: `src/commands/` - Individual command modules (build, dev, test, ai, etc.)
-- **Utils**: `src/utils/` - Shared utilities (file operations, logging, AI services)
-- **Config**: `LexConfig.ts` - Configuration management and defaults
-
-### Build System
-- **Compiler**: SWC (10-100x faster than Babel)
-- **Bundler**: Webpack (configurable, defaults to SWC for speed)
-- **Testing**: Vitest with jsdom environment
-- **Linting**: ESLint with AI-powered auto-fixes
-
-## Critical Workflows
-
-### Development Server
-```bash
-lex dev --open  # Start hot-reloading dev server
-lex dev --bundleAnalyzer  # Analyze bundle size
-```
-
-### Building & Compilation
-```bash
-lex build --mode production  # Production build
-lex compile --watch  # Watch mode compilation
-```
-
-### Testing
-```bash
-lex test --watch  # Run tests in watch mode
-lex test --generate  # AI-generated test cases
-lex test --analyze  # AI test coverage analysis
-```
-
-### AI Features
-```bash
-lex ai --task generate --prompt "Create a React component"
-lex ai --task explain --file src/components/Button.tsx
-lex lint --fix  # AI-powered ESLint fixes
-```
-
-## Configuration Patterns
-
-### lex.config.js Structure
-```javascript
-export default {
-  ai: {
-    provider: 'openai', // 'openai' | 'anthropic' | 'cursor' | 'none'
-    apiKey: process.env.OPENAI_API_KEY,
-    model: 'gpt-4o',
-    maxTokens: 4000
-  },
-  useTypescript: true,
-  preset: 'web', // 'web' | 'node' | 'lambda'
-  sourcePath: './src',
-  outputPath: './lib'
-};
-```
-
-### Command Implementation Pattern
-```typescript
-// src/commands/example/example.ts
-import {Command} from 'commander';
-import {LexConfig} from '../../LexConfig.js';
-
-export const example = new Command('example')
-  .option('--option <value>', 'Description')
-  .action(async (options) => {
-    const config = LexConfig.config || {};
-    // Implementation
-  });
-```
-
-## Code Conventions
-
-### File Organization
-- Commands: One file per command in `src/commands/[name]/`
-- Utils: Shared functions in `src/utils/`
-- Types: Centralized in `src/types.ts`
-- Config: All configuration logic in `LexConfig.ts`
-
-### Error Handling
-```typescript
-try {
-  // Operation
-} catch (error) {
-  log(`${chalk.red('Error:')} ${error.message}`, 'error');
-  return {error: error.message};
-}
-```
-
-### Logging
-```typescript
-import {log} from '../utils/log.js';
-log('Success message', 'success');
-log('Info message', 'info');
-log('Warning message', 'warning');
-log('Error message', 'error');
-```
-
-### AI Integration
-- Use `callAIService()` from `utils/aiService.ts`
-- Support multiple providers (OpenAI, Anthropic, Cursor)
-- Include project context when relevant
-- Handle provider-specific authentication
-
-## Testing Patterns
-
-### Unit Tests
-```typescript
-// Use Vitest with jsdom for DOM testing
-import {render, screen} from '@testing-library/react';
-import {Button} from './Button.js';
-
-describe('Button', () => {
-  it('renders correctly', () => {
-    render(<Button>Click me</Button>);
-    expect(screen.getByText('Click me')).toBeInTheDocument();
-  });
-});
-```
-
-### CLI Command Testing
-```typescript
-// Mock commander and test command actions
-import {example} from './example.js';
-
-describe('example command', () => {
-  it('handles options correctly', async () => {
-    // Test implementation
-  });
-});
-```
-
-## Key Files to Reference
-
-- [`src/lex.ts`](src/lex.ts) - Main CLI entry point and command registration
-- [`src/LexConfig.ts`](src/LexConfig.ts) - Configuration management
-- [`src/commands/ai/ai.ts`](src/commands/ai/ai.ts) - AI command implementation
-- [`src/utils/aiService.ts`](src/utils/aiService.ts) - AI service integrations
-- [`package.json`](package.json) - Dependencies and scripts
-- [`README.md`](README.md) - User documentation
-
-## Common Patterns
-
-### Async Command Handlers
-```typescript
-.action(async (options) => {
-  try {
-    await someAsyncOperation(options);
-    process.exit(0);
-  } catch (error) {
-    log(`Error: ${error.message}`, 'error');
-    process.exit(1);
-  }
-})
-```
-
-### Configuration Merging
-```typescript
-import {deepMerge} from '../utils/deepMerge.js';
-const finalConfig = deepMerge(defaultConfig, userConfig);
-```
-
-### File Operations
-```typescript
-import {readFile, writeFile} from '../utils/file.js';
-// Use utility functions instead of fs directly
-```
-
-## AI-Specific Guidelines
-
-- Always check for AI provider configuration before making API calls
-- Include relevant file/directory context in prompts
-- Handle rate limits and API errors gracefully
-- Support both streaming and non-streaming responses
-- Use temperature 0.1 for code generation tasks
-
-## Development Tips
-
-- Use `npm run build` to compile TypeScript to JavaScript
-- Use `npm run lint` to check code quality
-- Use `npm run test` for unit tests
-- Commands should be stateless and configurable
-- Prefer functional programming patterns
-- Document complex logic with comments
-- Follow existing naming conventions (camelCase for variables, PascalCase for types)
+# AI Coding Assistant Instructions
+
+## Shared NLabs Stack
+- Use Lex (`@nlabs/lex`) for CLI workflows, building, compiling, deploying, and testing projects.
+- Use Vitest for unit and integration tests.
+- Use Playwright for end-to-end tests.
+- Use GothamJS (`@nlabs/gothamjs`) for the presentation layer. Obtain components, views, routing, Tailwind setup, and default styles from GothamJS before creating custom project-level components.
+- Use React v19 for frontend work.
+- Use Tailwind v4 for CSS styles.
+- Use MetropolisJS (`@nlabs/metropolisjs`) as the starting point for all frontend API integration. Create custom data types, actions, queries, or mutations only after MetropolisJS has been exhausted.
+- Use Rip-Hunter to access API endpoints.
+- Use `fetch` through Rip-Hunter rather than direct project-level `fetch` calls.
+- Use ArkhamJS (`@nlabs/arkhamjs`) as the frontend data store. Store data, including session-storage-backed data, through Flux actions and event listeners.
+- Prefer listening for Flux events over chaining `.then(...)` to Flux action promises.
+- Flux actions update the data store before dispatching their events.
+- Multiple listeners may listen for the same Flux action event.
+- Read persistent data from the data store, and read event-specific data directly from the Flux action event when appropriate.
+- Send all data as JSON.
+- Use Reaktor (`@nlabs/reaktor`) for actions that interact with the ArangoDB database.
+
+## Database
+- All projects use the ArangoDB instance at `https://db.reaktor.io:8529`.
+- ArangoDB is a document NoSQL database with SQL-style query and graph database features.
+- When adding or deleting documents, check whether associated graph edges also need to be added or deleted.
+
+## Project Structure
+- Web apps should contain at least one microsite.
+- Web apps should include a `src/ui` folder.
+- Web apps with a backend should include a `src/api` folder or microsite.
+- Library projects may use a root source folder without `src/ui` or `src/api`.
+- Shared utility/helper functions should live in a shared file when used in more than one place.
+- Keep one component per file.
+- Each component should have a sibling test file named `MyComponent.test.ts` or `MyComponent.test.tsx`.
+- Group components by component folder, for example `src/ui/components/MyComponent/MyComponent.tsx`.
+
+## Package Scripts
+- All projects should have at least `start`, `test`, and `update` scripts.
+- If a project includes both `api` and `ui` workspaces, use `concurrently` in `start`:
+  `"start": "concurrently \"npm run start -w api\" \"npm run start -w ui\""`
+- Use this workspace test script:
+  `"test": "npm run test --workspaces --ignore-scripts"`
+- Use this workspace update script:
+  `"update": "npm run update --workspaces"`
+
+## Testing
+- Maintain at least 90% unit test coverage.
+- Components that require other components should have integration tests.
+- Provide at least one Playwright e2e test for each happy path.
+
+## Code Style
+- Use arrow functions for functions.
+- Correctly type all variables, props, and arguments unless TypeScript inference already provides the correct type.
+- Sort props and object keys alphabetically.
+- Check and fix all ESLint errors and warnings.
+- Use `eslint-config-styleguide` for linting rules.

package/AGENTS.md

@@ -0,0 +1,55 @@
+# AI Coding Assistant Instructions
+
+## Shared NLabs Stack
+- Use Lex (`@nlabs/lex`) for CLI workflows, building, compiling, deploying, and testing projects.
+- Use Vitest for unit and integration tests.
+- Use Playwright for end-to-end tests.
+- Use GothamJS (`@nlabs/gothamjs`) for the presentation layer. Obtain components, views, routing, Tailwind setup, and default styles from GothamJS before creating custom project-level components.
+- Use React v19 for frontend work.
+- Use Tailwind v4 for CSS styles.
+- Use MetropolisJS (`@nlabs/metropolisjs`) as the starting point for all frontend API integration. Create custom data types, actions, queries, or mutations only after MetropolisJS has been exhausted.
+- Use Rip-Hunter to access API endpoints.
+- Use `fetch` through Rip-Hunter rather than direct project-level `fetch` calls.
+- Use ArkhamJS (`@nlabs/arkhamjs`) as the frontend data store. Store data, including session-storage-backed data, through Flux actions and event listeners.
+- Prefer listening for Flux events over chaining `.then(...)` to Flux action promises.
+- Flux actions update the data store before dispatching their events.
+- Multiple listeners may listen for the same Flux action event.
+- Read persistent data from the data store, and read event-specific data directly from the Flux action event when appropriate.
+- Send all data as JSON.
+- Use Reaktor (`@nlabs/reaktor`) for actions that interact with the ArangoDB database.
+
+## Database
+- All projects use the ArangoDB instance at `https://db.reaktor.io:8529`.
+- ArangoDB is a document NoSQL database with SQL-style query and graph database features.
+- When adding or deleting documents, check whether associated graph edges also need to be added or deleted.
+
+## Project Structure
+- Web apps should contain at least one microsite.
+- Web apps should include a `src/ui` folder.
+- Web apps with a backend should include a `src/api` folder or microsite.
+- Library projects may use a root source folder without `src/ui` or `src/api`.
+- Shared utility/helper functions should live in a shared file when used in more than one place.
+- Keep one component per file.
+- Each component should have a sibling test file named `MyComponent.test.ts` or `MyComponent.test.tsx`.
+- Group components by component folder, for example `src/ui/components/MyComponent/MyComponent.tsx`.
+
+## Package Scripts
+- All projects should have at least `start`, `test`, and `update` scripts.
+- If a project includes both `api` and `ui` workspaces, use `concurrently` in `start`:
+  `"start": "concurrently \"npm run start -w api\" \"npm run start -w ui\""`
+- Use this workspace test script:
+  `"test": "npm run test --workspaces --ignore-scripts"`
+- Use this workspace update script:
+  `"update": "npm run update --workspaces"`
+
+## Testing
+- Maintain at least 90% unit test coverage.
+- Components that require other components should have integration tests.
+- Provide at least one Playwright e2e test for each happy path.
+
+## Code Style
+- Use arrow functions for functions.
+- Correctly type all variables, props, and arguments unless TypeScript inference already provides the correct type.
+- Sort props and object keys alphabetically.
+- Check and fix all ESLint errors and warnings.
+- Use `eslint-config-styleguide` for linting rules.

package/README.md

@@ -1,5 +1,9 @@
 # Lex: The Ultimate React Development CLI
 
+<p align="center">
+  <img src="docs/assets/lex-logo.png" alt="Lex logo" width="520">
+</p>
+
 > **Zero Configuration. Maximum Productivity.**
 
 Lex is the all-in-one development CLI that eliminates the complexity of modern React development. No more juggling webpack configs, testing setups, or build tools. Just install Lex globally and focus on what matters most - building amazing applications.
@@ -315,6 +319,7 @@ export default {
 
   // SWC configuration (defaults to ESM format)
   // SWC is now the default transpiler for all compilation tasks
+  reactCompiler: true,
 
   // Vitest configuration (merged with Lex defaults)
   vitest: {
@@ -345,6 +350,7 @@ Lex provides extensive configuration options through the `lex.config.js` file. H
 | `outputPath` | `string` | `'./lib'` | Output directory path | `outputPath: './build'` |
 | `packageManager` | `'npm' \| 'yarn'` | `'npm'` | Package manager to use | `packageManager: 'yarn'` |
 | `preset` | `'web' \| 'node' \| 'lambda' \| 'mobile'` | `'web'` | Project preset type | `preset: 'node'` |
+| `reactCompiler` | `boolean \| object` | `false` | Enable React Compiler through SWC, optionally with compiler options | `reactCompiler: true` |
 | `sourceFullPath` | `string` | `path.resolve('./src')` | Absolute source code path | `sourceFullPath: '/absolute/path'` |
 | `sourcePath` | `string` | `'./src'` | Source code directory path | `sourcePath: './app'` |
 | `targetEnvironment` | `'web' \| 'node'` | `'web'` | Target runtime environment | `targetEnvironment: 'node'` |
@@ -379,9 +385,30 @@ SWC is automatically configured and doesn't require additional configuration in
 | **Output Format** | JavaScript module format | `esm` |
 | **Target** | JavaScript target version | `es2020` |
 | **JSX Runtime** | React JSX transformation | `automatic` |
+| **React Compiler** | Optional React Compiler SWC plugin | `false` |
 | **Decorators** | TypeScript decorators support | `enabled` |
 | **Source Maps** | Debug information | `inline` |
 
+Enable the React Compiler through Lex's SWC pipeline:
+
+```javascript
+export default {
+  reactCompiler: true
+};
+```
+
+You can also pass SWC React Compiler options:
+
+```javascript
+export default {
+  reactCompiler: {
+    compilationMode: 'infer',
+    panicThreshold: 'none',
+    target: '19'
+  }
+};
+```
+
 ### **Vitest Configuration**
 
 | Option | Type | Default | Description | Example |

package/lib/LexConfig.d.ts

@@ -45,6 +45,7 @@ export interface LexConfigType {
     outputPath?: string;
     packageManager?: 'npm' | 'yarn';
     preset?: 'web' | 'node' | 'lambda' | 'mobile';
+    reactCompiler?: ReactCompilerConfig;
     sourceFullPath?: string;
     sourcePath?: string;
     swc?: SWCOptions;
@@ -54,6 +55,9 @@ export interface LexConfigType {
     webpack?: WebpackConfig;
 }
 export type Config = LexConfigType;
+export type ReactCompilerConfig = boolean | Record<string, unknown>;
+export declare const reactCompilerPluginName = "@swc/react-compiler";
+export declare const defaultReactCompilerOptions: Record<string, unknown>;
 export declare const defaultConfigValues: LexConfigType;
 export declare const getPackageDir: () => string;
 export declare const getTypeScriptConfigPath: (configName: string) => string;
@@ -61,6 +65,7 @@ export declare class LexConfig {
     static config: LexConfigType;
     static set useTypescript(value: boolean);
     static getLexDir(): string;
+    static getSWCConfigWithReactCompiler(swcConfig?: SWCOptions | undefined, reactCompiler?: ReactCompilerConfig | undefined): SWCOptions | undefined;
     static updateConfig(updatedConfig: LexConfigType): LexConfigType;
     static addConfigParams(cmd: Record<string, any>, params: LexConfigType): void;
     static parseConfig(cmd: Record<string, any>, isRoot?: boolean): Promise<void>;

package/lib/LexConfig.js

@@ -21,6 +21,13 @@ import { URL } from 'url';
 import { getLexPackageJsonPath, relativeFilePath } from './utils/file.js';
 import { log } from './utils/log.js';
 const cwd = process.cwd();
+export const reactCompilerPluginName = '@swc/react-compiler';
+export const defaultReactCompilerOptions = {
+    compilationMode: 'infer',
+    panicThreshold: 'none',
+    target: '19'
+};
+const isReactCompilerPlugin = (plugin)=>Array.isArray(plugin) && plugin[0] === reactCompilerPluginName;
 export const defaultConfigValues = {
     ai: {
         maxTokens: 4000,
@@ -34,7 +41,6 @@ export const defaultConfigValues = {
     entryJs: 'index.js',
     env: null,
     eslint: {},
-    vitest: {},
     outputFullPath: pathResolve(cwd, './lib'),
     outputHash: false,
     outputPath: './lib',
@@ -75,6 +81,7 @@ export const defaultConfigValues = {
     targetEnvironment: 'web',
     useGraphQl: false,
     useTypescript: false,
+    vitest: {},
     webpack: {
         staticPath: './src/static'
     }
@@ -204,6 +211,39 @@ export class LexConfig {
     static getLexDir() {
         return dirname(getLexPackageJsonPath());
     }
+    static getSWCConfigWithReactCompiler(swcConfig = LexConfig.config.swc, reactCompiler = LexConfig.config.reactCompiler) {
+        if (reactCompiler === undefined) {
+            return swcConfig;
+        }
+        const currentSwcConfig = swcConfig || defaultConfigValues.swc;
+        const currentJsc = currentSwcConfig?.jsc || {};
+        const currentExperimental = currentJsc.experimental || {};
+        const plugins = Array.isArray(currentExperimental.plugins) ? currentExperimental.plugins.filter((plugin)=>!isReactCompilerPlugin(plugin)) : [];
+        const experimental = reactCompiler === false ? {
+            ...currentExperimental,
+            plugins
+        } : {
+            ...currentExperimental,
+            plugins: [
+                ...plugins,
+                [
+                    reactCompilerPluginName,
+                    typeof reactCompiler === 'object' ? {
+                        ...defaultReactCompilerOptions,
+                        ...reactCompiler
+                    } : defaultReactCompilerOptions
+                ]
+            ]
+        };
+        const swcConfigWithReactCompiler = {
+            ...currentSwcConfig,
+            jsc: {
+                ...currentJsc,
+                experimental
+            }
+        };
+        return swcConfigWithReactCompiler;
+    }
     static updateConfig(updatedConfig) {
         const { outputFullPath, outputPath, sourcePath, sourceFullPath, useTypescript, ai } = updatedConfig;
         const packageDir = getPackageDir();
@@ -229,6 +269,7 @@ export class LexConfig {
             ...LexConfig.config,
             ...updatedConfig
         };
+        LexConfig.config.swc = LexConfig.getSWCConfigWithReactCompiler();
         return LexConfig.config;
     }
     static addConfigParams(cmd, params) {
@@ -421,4 +462,4 @@ _define_property(LexConfig, "config", {
     ...defaultConfigValues
 });
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/LexConfig.ts"],"sourcesContent":["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport findFileUp from 'find-file-up';\nimport {existsSync, readFileSync, writeFileSync} from 'fs';\nimport {\n  dirname,\n  extname as pathExtname,\n  relative as pathRelative,\n  resolve as pathResolve\n} from 'path';\nimport {URL} from 'url';\n\nimport {getLexPackageJsonPath, relativeFilePath} from './utils/file.js';\nimport {log} from './utils/log.js';\n\nimport type {Options} from '@swc/core';\nimport type {Linter} from 'eslint';\n\nconst cwd: string = process.cwd();\n\n\nexport interface VitestConfig {\n  [key: string]: unknown;\n}\n\nexport interface WebpackConfig {\n  [key: string]: unknown;\n  entry?: string | string[];\n  output?: Record<string, unknown>;\n  module?: Record<string, unknown>;\n  plugins?: unknown[];\n  staticPath?: string;\n}\n\nexport interface AIConfig {\n  provider?: 'cursor' | 'copilot' | 'openai' | 'anthropic' | 'none';\n  apiKey?: string;\n  model?: string;\n  maxTokens?: number;\n  temperature?: number;\n}\n\nexport interface DevConfig {\n  port?: number;\n}\n\nexport interface ESLintConfig {\n  [key: string]: unknown;\n  extends?: string[];\n  rules?: Linter.RulesRecord;\n}\n\nexport interface LexConfigType {\n  ai?: AIConfig;\n  configFiles?: string[];\n  copyFiles?: string[];\n  dev?: DevConfig;\n  entryHTML?: string;\n  entryJs?: string;\n  env?: object | null;\n  eslint?: ESLintConfig;\n  gitUrl?: string;\n  vitest?: VitestConfig;\n  libraryName?: string;\n  libraryTarget?: string;\n  outputFile?: string;\n  outputFullPath?: string;\n  outputHash?: boolean;\n  outputPath?: string;\n  packageManager?: 'npm' | 'yarn';\n  preset?: 'web' | 'node' | 'lambda' | 'mobile';\n  sourceFullPath?: string;\n  sourcePath?: string;\n  swc?: SWCOptions;\n  targetEnvironment?: 'node' | 'web';\n  useGraphQl?: boolean;\n  useTypescript?: boolean;\n  webpack?: WebpackConfig;\n}\n\nexport type Config = LexConfigType;\n\nexport const defaultConfigValues: LexConfigType = {\n  ai: {\n    maxTokens: 4000,\n    model: 'gpt-4o',\n    provider: 'none',\n    temperature: 0.1\n  },\n  configFiles: [],\n  copyFiles: [],\n  entryHTML: 'index.html',\n  entryJs: 'index.js',\n  env: null,\n  eslint: {},\n  vitest: {},\n  outputFullPath: pathResolve(cwd, './lib'),\n  outputHash: false,\n  outputPath: './lib',\n  packageManager: 'npm',\n  preset: 'web',\n  sourceFullPath: pathResolve(cwd, './src'),\n  sourcePath: './src',\n  swc: {\n    inlineSourcesContent: true,\n    isModule: true,\n    jsc: {\n      externalHelpers: false,\n      keepClassNames: false,\n      loose: false,\n      parser: {\n        decorators: true,\n        dynamicImport: true,\n        syntax: 'typescript',\n        tsx: true\n      },\n      target: 'es2023',\n      transform: {\n        react: {\n          runtime: 'automatic'\n        }\n      }\n    },\n    minify: false,\n    module: {\n      lazy: false,\n      noInterop: false,\n      strict: false,\n      strictMode: true,\n      type: 'es6'\n    },\n    sourceMaps: 'inline'\n  },\n  targetEnvironment: 'web',\n  useGraphQl: false,\n  useTypescript: false,\n  webpack: {\n    staticPath: './src/static'\n  }\n};\n\nexport const getPackageDir = (): string => {\n  const cwd = process.cwd();\n  const currentPkgPath = pathResolve(cwd, 'package.json');\n\n  if(existsSync(currentPkgPath)) {\n    try {\n      const pkg = JSON.parse(readFileSync(currentPkgPath, 'utf8'));\n      if(!pkg.workspaces) {\n        return cwd;\n      }\n    } catch{\n      return cwd;\n    }\n  }\n\n  let searchDir = cwd;\n\n  for(let i = 0; i < 10; i++) {\n    const pkgPath = pathResolve(searchDir, 'package.json');\n    if(existsSync(pkgPath)) {\n      try {\n        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));\n\n        if(!pkg.workspaces) {\n          return searchDir;\n        }\n      } catch{\n        // Continue searching\n      }\n    }\n\n    const parent = dirname(searchDir);\n\n    if(parent === searchDir) {\n      break;\n    }\n    searchDir = parent;\n  }\n\n  const configFormats = ['js', 'mjs', 'cjs', 'ts', 'json'];\n\n  for(const format of configFormats) {\n    const configPath = findFileUp.sync(`lex.config.${format}`, cwd, 5);\n\n    if(configPath) {\n      return dirname(configPath);\n    }\n  }\n\n  return cwd;\n};\n\nexport const getTypeScriptConfigPath = (configName: string): string => {\n  const packageDir = getPackageDir();\n  const cwd = process.cwd();\n\n  if(configName === 'tsconfig.build.json') {\n    const projectBuildConfig = pathResolve(packageDir, 'tsconfig.build.json');\n\n    if(existsSync(projectBuildConfig)) {\n      return projectBuildConfig;\n    }\n\n    const rootBuildConfig = pathResolve(cwd, 'tsconfig.build.json');\n    if(existsSync(rootBuildConfig)) {\n      return rootBuildConfig;\n    }\n  }\n\n  if(configName === 'tsconfig.lint.json') {\n    const projectLintConfig = pathResolve(packageDir, 'tsconfig.eslint.json');\n    if(existsSync(projectLintConfig)) {\n      return projectLintConfig;\n    }\n\n    const rootLintConfig = pathResolve(cwd, 'tsconfig.eslint.json');\n\n    if(existsSync(rootLintConfig)) {\n      return rootLintConfig;\n    }\n  }\n\n  if(configName === 'tsconfig.test.json') {\n    const projectTestConfig = pathResolve(packageDir, 'tsconfig.test.json');\n    if(existsSync(projectTestConfig)) {\n      return projectTestConfig;\n    }\n\n    const rootTestConfig = pathResolve(cwd, 'tsconfig.test.json');\n\n    if(existsSync(rootTestConfig)) {\n      return rootTestConfig;\n    }\n  }\n\n  const projectConfigPath = pathResolve(packageDir, configName);\n\n  if(existsSync(projectConfigPath)) {\n    return projectConfigPath;\n  }\n\n  const rootConfigPath = pathResolve(cwd, configName);\n\n  if(existsSync(rootConfigPath)) {\n    return rootConfigPath;\n  }\n\n  const lexDir = LexConfig.getLexDir();\n\n  return pathResolve(lexDir, configName);\n};\n\nexport class LexConfig {\n  static config: LexConfigType = {\n    ...defaultConfigValues\n  };\n\n  static set useTypescript(value: boolean) {\n    LexConfig.config.useTypescript = value;\n    const {entryJs, sourceFullPath, targetEnvironment} = LexConfig.config;\n\n    if(entryJs === 'index.js' && value) {\n      const indexPath: string = pathResolve(cwd, sourceFullPath || cwd, 'index.tsx');\n      const hasIndexTsx: boolean = existsSync(indexPath);\n\n      if(hasIndexTsx) {\n        LexConfig.config.entryJs = 'index.tsx';\n      } else {\n        LexConfig.config.entryJs = 'index.ts';\n      }\n    }\n\n    LexConfig.config.swc = LexConfig.config.swc || {...defaultConfigValues.swc!};\n    LexConfig.config.swc.jsc = LexConfig.config.swc.jsc || {...defaultConfigValues.swc!.jsc!};\n    LexConfig.config.swc.jsc.parser = {\n      syntax: 'typescript',\n      tsx: true\n    };\n\n    if(targetEnvironment === 'web') {\n      LexConfig.config.swc.jsc.transform = {\n        react: {\n          runtime: 'automatic'\n        }\n      };\n    }\n  }\n\n  static getLexDir(): string {\n    return dirname(getLexPackageJsonPath());\n  }\n\n  static updateConfig(updatedConfig: LexConfigType): LexConfigType {\n    const {outputFullPath, outputPath, sourcePath, sourceFullPath, useTypescript, ai} = updatedConfig;\n    const packageDir = getPackageDir();\n\n    if(useTypescript !== undefined) {\n      LexConfig.useTypescript = useTypescript;\n    }\n\n    if(outputPath !== undefined && outputFullPath === undefined) {\n      updatedConfig.outputFullPath = pathResolve(packageDir, outputPath);\n    }\n\n    if(sourcePath !== undefined && sourceFullPath === undefined) {\n      updatedConfig.sourceFullPath = pathResolve(packageDir, sourcePath);\n    }\n\n    if(ai) {\n      LexConfig.config.ai = {...LexConfig.config.ai, ...ai};\n\n      if(process.env.CURSOR_IDE === 'true' && LexConfig.config.ai.provider === 'none') {\n        LexConfig.config.ai.provider = 'cursor';\n      }\n    }\n\n    LexConfig.config = {...LexConfig.config, ...updatedConfig};\n\n    return LexConfig.config;\n  }\n\n  static addConfigParams(cmd: Record<string, any>, params: LexConfigType) {\n    const nameProperty: string = '_name';\n    const {environment, outputPath, sourcePath, typescript} = cmd;\n    const packageDir = getPackageDir();\n\n    if(outputPath !== undefined) {\n      params.outputPath = outputPath;\n      params.outputFullPath = pathResolve(packageDir, outputPath);\n    } else if(params.outputPath && !params.outputFullPath) {\n      params.outputFullPath = pathResolve(packageDir, params.outputPath);\n    }\n\n    if(sourcePath !== undefined) {\n      params.sourcePath = sourcePath;\n      params.sourceFullPath = pathResolve(packageDir, sourcePath);\n    } else if(params.sourcePath && !params.sourceFullPath) {\n      params.sourceFullPath = pathResolve(packageDir, params.sourcePath);\n    }\n\n    if(typescript !== undefined) {\n      params.useTypescript = true;\n    }\n\n    if(environment !== undefined) {\n      params.targetEnvironment = environment === 'web' ? 'web' : 'node';\n    }\n\n    process.env.LEX_CONFIG = JSON.stringify(\n      {\n        ...LexConfig.updateConfig(params),\n        commandName: cmd[nameProperty],\n        isStatic: cmd.static\n      }, null, 0\n    );\n  }\n\n  static async parseConfig(cmd: Record<string, any>, isRoot: boolean = true): Promise<void> {\n    const {cliName = 'Lex', lexConfig, lexConfigName, quiet, typescript, debug = false} = cmd;\n    const configFormats = ['js', 'mjs', 'cjs', 'ts', 'json'];\n    const configBaseName: string = lexConfigName || 'lex.config';\n    let configPath: string = lexConfig || '';\n    let configExists: boolean = lexConfig ? existsSync(configPath) : false;\n\n    if(!configPath || !configExists) {\n      if(debug) {\n        log(`Searching for config files with base name: ${configBaseName}`, 'info', quiet);\n      }\n\n      for(const format of configFormats) {\n        const potentialPath = isRoot\n          ? pathResolve(cwd, `./${configBaseName}.${format}`)\n          : relativeFilePath(`${configBaseName}.${format}`, cwd);\n\n        if(debug) {\n          log(`Checking for config file: ${potentialPath}`, 'info', quiet);\n        }\n\n        if(existsSync(potentialPath)) {\n          configPath = potentialPath;\n          configExists = true;\n          break;\n        }\n      }\n    }\n\n    if(configExists) {\n      log(`Using ${cliName} configuration file: ${configPath}`, 'note', quiet);\n      const ext: string = pathExtname(configPath);\n\n      if(ext === '.json') {\n        const configContent: string = readFileSync(configPath, 'utf8');\n\n        if(configContent) {\n          let configJson: LexConfigType;\n\n          try {\n            configJson = JSON.parse(configContent)?.default || {};\n          } catch(error) {\n            log(`\\n${cliName} Error: Failed to parse JSON config: ${error.message}`, 'error', quiet);\n            configJson = {};\n          }\n\n          LexConfig.addConfigParams(cmd, configJson);\n        } else {\n          log(`\\n${cliName} Error: Config file malformed, ${configPath}`, 'error', quiet);\n        }\n      } else if(['.js', '.mjs', '.cjs', '.ts'].includes(ext)) {\n        try {\n          let lexCustomConfig;\n\n          if(ext === '.cjs') {\n            const fileUrl = new URL(`file:///${pathResolve(configPath)}`).href;\n\n            if(debug) {\n              log(`Loading CommonJS config from: ${fileUrl}`, 'info', quiet);\n            }\n            lexCustomConfig = await import(fileUrl);\n          } else {\n            if(debug) {\n              log(`Loading ESM/TS config from: ${configPath}`, 'info', quiet);\n            }\n\n            lexCustomConfig = await import(configPath);\n          }\n\n          const config = lexCustomConfig.default || lexCustomConfig;\n\n          if(debug) {\n            log(`Loaded config: ${JSON.stringify(config, null, 2)}`, 'info', quiet);\n          }\n\n          if(!config) {\n            log(`\\n${cliName} Warning: Config file loaded but no configuration found`, 'warn', quiet);\n          }\n\n          LexConfig.addConfigParams(cmd, config || {});\n        } catch(error) {\n          log(`\\n${cliName} Error: Failed to load config file: ${error.message}`, 'error', quiet);\n          if(debug) {\n            // eslint-disable-next-line no-console\n            console.error(error);\n          }\n        }\n      } else {\n        log(`\\n${cliName} Error: Config file must be a JS, CJS, MJS, TS, or JSON file.`, 'error', quiet);\n      }\n    } else {\n      if(debug) {\n        log('No config file found. Using default configuration.', 'info', quiet);\n      }\n\n      LexConfig.useTypescript = !!typescript;\n      LexConfig.addConfigParams(cmd, LexConfig.config);\n    }\n  }\n\n  static checkTypescriptConfig() {\n    const packageDir = getPackageDir();\n    const tsconfigPath: string = pathResolve(packageDir, './tsconfig.json');\n\n    if(!existsSync(tsconfigPath)) {\n      const lexDir = LexConfig.getLexDir();\n      const baseConfigPath = pathResolve(lexDir, 'tsconfig.base.json');\n      const templateConfigPath = pathResolve(lexDir, 'tsconfig.template.json');\n      const sourcePath = existsSync(baseConfigPath) ? baseConfigPath : templateConfigPath;\n\n      if(existsSync(sourcePath)) {\n        writeFileSync(tsconfigPath, readFileSync(sourcePath));\n      }\n    }\n  }\n\n  static getTypeScriptDeclarationFlags(): string[] {\n    const cwd = process.cwd();\n    const outputPath = LexConfig.config.outputPath || './lib';\n    const outputFullPath = LexConfig.config.outputFullPath || pathResolve(cwd, outputPath);\n    const sourcePath = LexConfig.config.sourcePath || './src';\n    const sourceFullPath = LexConfig.config.sourceFullPath || pathResolve(cwd, sourcePath);\n    const relativeOutDir = pathRelative(cwd, outputFullPath) || './lib';\n    const relativeRootDir = pathRelative(cwd, sourceFullPath) || './src';\n\n    return [\n      '--emitDeclarationOnly', // CRITICAL: Only emit .d.ts files, no JS files\n      '--declaration', // Generate declaration files\n      '--declarationMap', // Generate source maps for declarations\n      '--outDir', relativeOutDir,\n      '--rootDir', relativeRootDir,\n      '--skipLibCheck', // Skip type checking of declaration files (faster, more lenient)\n      '--esModuleInterop',\n      '--allowSyntheticDefaultImports',\n      '--module', 'NodeNext',\n      '--moduleResolution', 'NodeNext',\n      '--target', 'ESNext',\n      '--jsx', 'react-jsx',\n      '--isolatedModules',\n      '--resolveJsonModule',\n      '--allowJs',\n      '--ignoreConfig'\n      // Note: --noUnusedLocals and --noUnusedParameters are not needed for declaration generation\n      // and would actually enable strict checking, which we want to avoid for faster declaration generation\n    ];\n  }\n\n  static checkLintTypescriptConfig() {\n    const lexDir = LexConfig.getLexDir();\n    const tsconfigLintPath: string = pathResolve(lexDir, './tsconfig.lint.json');\n\n    if(!existsSync(tsconfigLintPath)) {\n      const templatePath = pathResolve(lexDir, 'tsconfig.lint.json');\n      if(existsSync(templatePath)) {\n        writeFileSync(tsconfigLintPath, readFileSync(templatePath));\n      }\n    }\n  }\n\n  static checkTestTypescriptConfig() {\n    const lexDir = LexConfig.getLexDir();\n    const tsconfigTestPath: string = pathResolve(lexDir, './tsconfig.test.json');\n\n    if(!existsSync(tsconfigTestPath)) {\n      const templatePath = pathResolve(lexDir, 'tsconfig.test.json');\n      if(existsSync(templatePath)) {\n        writeFileSync(tsconfigTestPath, readFileSync(templatePath));\n      }\n    }\n  }\n}\n\nexport type SWCOptions = Options;\n"],"names":["findFileUp","existsSync","readFileSync","writeFileSync","dirname","extname","pathExtname","relative","pathRelative","resolve","pathResolve","URL","getLexPackageJsonPath","relativeFilePath","log","cwd","process","defaultConfigValues","ai","maxTokens","model","provider","temperature","configFiles","copyFiles","entryHTML","entryJs","env","eslint","vitest","outputFullPath","outputHash","outputPath","packageManager","preset","sourceFullPath","sourcePath","swc","inlineSourcesContent","isModule","jsc","externalHelpers","keepClassNames","loose","parser","decorators","dynamicImport","syntax","tsx","target","transform","react","runtime","minify","module","lazy","noInterop","strict","strictMode","type","sourceMaps","targetEnvironment","useGraphQl","useTypescript","webpack","staticPath","getPackageDir","currentPkgPath","pkg","JSON","parse","workspaces","searchDir","i","pkgPath","parent","configFormats","format","configPath","sync","getTypeScriptConfigPath","configName","packageDir","projectBuildConfig","rootBuildConfig","projectLintConfig","rootLintConfig","projectTestConfig","rootTestConfig","projectConfigPath","rootConfigPath","lexDir","LexConfig","getLexDir","value","config","indexPath","hasIndexTsx","updateConfig","updatedConfig","undefined","CURSOR_IDE","addConfigParams","cmd","params","nameProperty","environment","typescript","LEX_CONFIG","stringify","commandName","isStatic","static","parseConfig","isRoot","cliName","lexConfig","lexConfigName","quiet","debug","configBaseName","configExists","potentialPath","ext","configContent","configJson","default","error","message","includes","lexCustomConfig","fileUrl","href","console","checkTypescriptConfig","tsconfigPath","baseConfigPath","templateConfigPath","getTypeScriptDeclarationFlags","relativeOutDir","relativeRootDir","checkLintTypescriptConfig","tsconfigLintPath","templatePath","checkTestTypescriptConfig","tsconfigTestPath"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/LexConfig.ts"],"sourcesContent":["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport findFileUp from 'find-file-up';\nimport {existsSync, readFileSync, writeFileSync} from 'fs';\nimport {\n  dirname,\n  extname as pathExtname,\n  relative as pathRelative,\n  resolve as pathResolve\n} from 'path';\nimport {URL} from 'url';\n\nimport {getLexPackageJsonPath, relativeFilePath} from './utils/file.js';\nimport {log} from './utils/log.js';\n\nimport type {Options} from '@swc/core';\nimport type {Linter} from 'eslint';\n\nconst cwd: string = process.cwd();\n\n\nexport interface VitestConfig {\n  [key: string]: unknown;\n}\n\nexport interface WebpackConfig {\n  [key: string]: unknown;\n  entry?: string | string[];\n  output?: Record<string, unknown>;\n  module?: Record<string, unknown>;\n  plugins?: unknown[];\n  staticPath?: string;\n}\n\nexport interface AIConfig {\n  provider?: 'cursor' | 'copilot' | 'openai' | 'anthropic' | 'none';\n  apiKey?: string;\n  model?: string;\n  maxTokens?: number;\n  temperature?: number;\n}\n\nexport interface DevConfig {\n  port?: number;\n}\n\nexport interface ESLintConfig {\n  [key: string]: unknown;\n  extends?: string[];\n  rules?: Linter.RulesRecord;\n}\n\nexport interface LexConfigType {\n  ai?: AIConfig;\n  configFiles?: string[];\n  copyFiles?: string[];\n  dev?: DevConfig;\n  entryHTML?: string;\n  entryJs?: string;\n  env?: object | null;\n  eslint?: ESLintConfig;\n  gitUrl?: string;\n  vitest?: VitestConfig;\n  libraryName?: string;\n  libraryTarget?: string;\n  outputFile?: string;\n  outputFullPath?: string;\n  outputHash?: boolean;\n  outputPath?: string;\n  packageManager?: 'npm' | 'yarn';\n  preset?: 'web' | 'node' | 'lambda' | 'mobile';\n  reactCompiler?: ReactCompilerConfig;\n  sourceFullPath?: string;\n  sourcePath?: string;\n  swc?: SWCOptions;\n  targetEnvironment?: 'node' | 'web';\n  useGraphQl?: boolean;\n  useTypescript?: boolean;\n  webpack?: WebpackConfig;\n}\n\nexport type Config = LexConfigType;\n\nexport type ReactCompilerConfig = boolean | Record<string, unknown>;\n\nexport const reactCompilerPluginName = '@swc/react-compiler';\n\nexport const defaultReactCompilerOptions: Record<string, unknown> = {\n  compilationMode: 'infer',\n  panicThreshold: 'none',\n  target: '19'\n};\n\nconst isReactCompilerPlugin = (plugin: unknown): boolean => (\n  Array.isArray(plugin) && plugin[0] === reactCompilerPluginName\n);\n\nexport const defaultConfigValues: LexConfigType = {\n  ai: {\n    maxTokens: 4000,\n    model: 'gpt-4o',\n    provider: 'none',\n    temperature: 0.1\n  },\n  configFiles: [],\n  copyFiles: [],\n  entryHTML: 'index.html',\n  entryJs: 'index.js',\n  env: null,\n  eslint: {},\n  outputFullPath: pathResolve(cwd, './lib'),\n  outputHash: false,\n  outputPath: './lib',\n  packageManager: 'npm',\n  preset: 'web',\n  sourceFullPath: pathResolve(cwd, './src'),\n  sourcePath: './src',\n  swc: {\n    inlineSourcesContent: true,\n    isModule: true,\n    jsc: {\n      externalHelpers: false,\n      keepClassNames: false,\n      loose: false,\n      parser: {\n        decorators: true,\n        dynamicImport: true,\n        syntax: 'typescript',\n        tsx: true\n      },\n      target: 'es2023',\n      transform: {\n        react: {\n          runtime: 'automatic'\n        }\n      }\n    },\n    minify: false,\n    module: {\n      lazy: false,\n      noInterop: false,\n      strict: false,\n      strictMode: true,\n      type: 'es6'\n    },\n    sourceMaps: 'inline'\n  },\n  targetEnvironment: 'web',\n  useGraphQl: false,\n  useTypescript: false,\n  vitest: {},\n  webpack: {\n    staticPath: './src/static'\n  }\n};\n\nexport const getPackageDir = (): string => {\n  const cwd = process.cwd();\n  const currentPkgPath = pathResolve(cwd, 'package.json');\n\n  if(existsSync(currentPkgPath)) {\n    try {\n      const pkg = JSON.parse(readFileSync(currentPkgPath, 'utf8'));\n      if(!pkg.workspaces) {\n        return cwd;\n      }\n    } catch{\n      return cwd;\n    }\n  }\n\n  let searchDir = cwd;\n\n  for(let i = 0; i < 10; i++) {\n    const pkgPath = pathResolve(searchDir, 'package.json');\n    if(existsSync(pkgPath)) {\n      try {\n        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));\n\n        if(!pkg.workspaces) {\n          return searchDir;\n        }\n      } catch{\n        // Continue searching\n      }\n    }\n\n    const parent = dirname(searchDir);\n\n    if(parent === searchDir) {\n      break;\n    }\n    searchDir = parent;\n  }\n\n  const configFormats = ['js', 'mjs', 'cjs', 'ts', 'json'];\n\n  for(const format of configFormats) {\n    const configPath = findFileUp.sync(`lex.config.${format}`, cwd, 5);\n\n    if(configPath) {\n      return dirname(configPath);\n    }\n  }\n\n  return cwd;\n};\n\nexport const getTypeScriptConfigPath = (configName: string): string => {\n  const packageDir = getPackageDir();\n  const cwd = process.cwd();\n\n  if(configName === 'tsconfig.build.json') {\n    const projectBuildConfig = pathResolve(packageDir, 'tsconfig.build.json');\n\n    if(existsSync(projectBuildConfig)) {\n      return projectBuildConfig;\n    }\n\n    const rootBuildConfig = pathResolve(cwd, 'tsconfig.build.json');\n    if(existsSync(rootBuildConfig)) {\n      return rootBuildConfig;\n    }\n  }\n\n  if(configName === 'tsconfig.lint.json') {\n    const projectLintConfig = pathResolve(packageDir, 'tsconfig.eslint.json');\n    if(existsSync(projectLintConfig)) {\n      return projectLintConfig;\n    }\n\n    const rootLintConfig = pathResolve(cwd, 'tsconfig.eslint.json');\n\n    if(existsSync(rootLintConfig)) {\n      return rootLintConfig;\n    }\n  }\n\n  if(configName === 'tsconfig.test.json') {\n    const projectTestConfig = pathResolve(packageDir, 'tsconfig.test.json');\n    if(existsSync(projectTestConfig)) {\n      return projectTestConfig;\n    }\n\n    const rootTestConfig = pathResolve(cwd, 'tsconfig.test.json');\n\n    if(existsSync(rootTestConfig)) {\n      return rootTestConfig;\n    }\n  }\n\n  const projectConfigPath = pathResolve(packageDir, configName);\n\n  if(existsSync(projectConfigPath)) {\n    return projectConfigPath;\n  }\n\n  const rootConfigPath = pathResolve(cwd, configName);\n\n  if(existsSync(rootConfigPath)) {\n    return rootConfigPath;\n  }\n\n  const lexDir = LexConfig.getLexDir();\n\n  return pathResolve(lexDir, configName);\n};\n\nexport class LexConfig {\n  static config: LexConfigType = {\n    ...defaultConfigValues\n  };\n\n  static set useTypescript(value: boolean) {\n    LexConfig.config.useTypescript = value;\n    const {entryJs, sourceFullPath, targetEnvironment} = LexConfig.config;\n\n    if(entryJs === 'index.js' && value) {\n      const indexPath: string = pathResolve(cwd, sourceFullPath || cwd, 'index.tsx');\n      const hasIndexTsx: boolean = existsSync(indexPath);\n\n      if(hasIndexTsx) {\n        LexConfig.config.entryJs = 'index.tsx';\n      } else {\n        LexConfig.config.entryJs = 'index.ts';\n      }\n    }\n\n    LexConfig.config.swc = LexConfig.config.swc || {...defaultConfigValues.swc!};\n    LexConfig.config.swc.jsc = LexConfig.config.swc.jsc || {...defaultConfigValues.swc!.jsc!};\n    LexConfig.config.swc.jsc.parser = {\n      syntax: 'typescript',\n      tsx: true\n    };\n\n    if(targetEnvironment === 'web') {\n      LexConfig.config.swc.jsc.transform = {\n        react: {\n          runtime: 'automatic'\n        }\n      };\n    }\n  }\n\n  static getLexDir(): string {\n    return dirname(getLexPackageJsonPath());\n  }\n\n  static getSWCConfigWithReactCompiler(\n    swcConfig: SWCOptions | undefined = LexConfig.config.swc,\n    reactCompiler: ReactCompilerConfig | undefined = LexConfig.config.reactCompiler\n  ): SWCOptions | undefined {\n    if(reactCompiler === undefined) {\n      return swcConfig;\n    }\n\n    const currentSwcConfig = swcConfig || defaultConfigValues.swc;\n    const currentJsc: Record<string, any> = currentSwcConfig?.jsc || {};\n    const currentExperimental = currentJsc.experimental || {};\n    const plugins = Array.isArray(currentExperimental.plugins)\n      ? currentExperimental.plugins.filter((plugin: unknown) => !isReactCompilerPlugin(plugin))\n      : [];\n\n    const experimental = reactCompiler === false\n      ? {\n        ...currentExperimental,\n        plugins\n      }\n      : {\n        ...currentExperimental,\n        plugins: [\n          ...plugins,\n          [\n            reactCompilerPluginName,\n            typeof reactCompiler === 'object'\n              ? {\n                ...defaultReactCompilerOptions,\n                ...reactCompiler\n              }\n              : defaultReactCompilerOptions\n          ]\n        ]\n      };\n    const swcConfigWithReactCompiler: SWCOptions = {\n      ...currentSwcConfig,\n      jsc: {\n        ...currentJsc,\n        experimental\n      }\n    };\n\n    return swcConfigWithReactCompiler;\n  }\n\n  static updateConfig(updatedConfig: LexConfigType): LexConfigType {\n    const {outputFullPath, outputPath, sourcePath, sourceFullPath, useTypescript, ai} = updatedConfig;\n    const packageDir = getPackageDir();\n\n    if(useTypescript !== undefined) {\n      LexConfig.useTypescript = useTypescript;\n    }\n\n    if(outputPath !== undefined && outputFullPath === undefined) {\n      updatedConfig.outputFullPath = pathResolve(packageDir, outputPath);\n    }\n\n    if(sourcePath !== undefined && sourceFullPath === undefined) {\n      updatedConfig.sourceFullPath = pathResolve(packageDir, sourcePath);\n    }\n\n    if(ai) {\n      LexConfig.config.ai = {...LexConfig.config.ai, ...ai};\n\n      if(process.env.CURSOR_IDE === 'true' && LexConfig.config.ai.provider === 'none') {\n        LexConfig.config.ai.provider = 'cursor';\n      }\n    }\n\n    LexConfig.config = {...LexConfig.config, ...updatedConfig};\n    LexConfig.config.swc = LexConfig.getSWCConfigWithReactCompiler();\n\n    return LexConfig.config;\n  }\n\n  static addConfigParams(cmd: Record<string, any>, params: LexConfigType) {\n    const nameProperty: string = '_name';\n    const {environment, outputPath, sourcePath, typescript} = cmd;\n    const packageDir = getPackageDir();\n\n    if(outputPath !== undefined) {\n      params.outputPath = outputPath;\n      params.outputFullPath = pathResolve(packageDir, outputPath);\n    } else if(params.outputPath && !params.outputFullPath) {\n      params.outputFullPath = pathResolve(packageDir, params.outputPath);\n    }\n\n    if(sourcePath !== undefined) {\n      params.sourcePath = sourcePath;\n      params.sourceFullPath = pathResolve(packageDir, sourcePath);\n    } else if(params.sourcePath && !params.sourceFullPath) {\n      params.sourceFullPath = pathResolve(packageDir, params.sourcePath);\n    }\n\n    if(typescript !== undefined) {\n      params.useTypescript = true;\n    }\n\n    if(environment !== undefined) {\n      params.targetEnvironment = environment === 'web' ? 'web' : 'node';\n    }\n\n    process.env.LEX_CONFIG = JSON.stringify(\n      {\n        ...LexConfig.updateConfig(params),\n        commandName: cmd[nameProperty],\n        isStatic: cmd.static\n      }, null, 0\n    );\n  }\n\n  static async parseConfig(cmd: Record<string, any>, isRoot: boolean = true): Promise<void> {\n    const {cliName = 'Lex', lexConfig, lexConfigName, quiet, typescript, debug = false} = cmd;\n    const configFormats = ['js', 'mjs', 'cjs', 'ts', 'json'];\n    const configBaseName: string = lexConfigName || 'lex.config';\n    let configPath: string = lexConfig || '';\n    let configExists: boolean = lexConfig ? existsSync(configPath) : false;\n\n    if(!configPath || !configExists) {\n      if(debug) {\n        log(`Searching for config files with base name: ${configBaseName}`, 'info', quiet);\n      }\n\n      for(const format of configFormats) {\n        const potentialPath = isRoot\n          ? pathResolve(cwd, `./${configBaseName}.${format}`)\n          : relativeFilePath(`${configBaseName}.${format}`, cwd);\n\n        if(debug) {\n          log(`Checking for config file: ${potentialPath}`, 'info', quiet);\n        }\n\n        if(existsSync(potentialPath)) {\n          configPath = potentialPath;\n          configExists = true;\n          break;\n        }\n      }\n    }\n\n    if(configExists) {\n      log(`Using ${cliName} configuration file: ${configPath}`, 'note', quiet);\n      const ext: string = pathExtname(configPath);\n\n      if(ext === '.json') {\n        const configContent: string = readFileSync(configPath, 'utf8');\n\n        if(configContent) {\n          let configJson: LexConfigType;\n\n          try {\n            configJson = JSON.parse(configContent)?.default || {};\n          } catch(error) {\n            log(`\\n${cliName} Error: Failed to parse JSON config: ${error.message}`, 'error', quiet);\n            configJson = {};\n          }\n\n          LexConfig.addConfigParams(cmd, configJson);\n        } else {\n          log(`\\n${cliName} Error: Config file malformed, ${configPath}`, 'error', quiet);\n        }\n      } else if(['.js', '.mjs', '.cjs', '.ts'].includes(ext)) {\n        try {\n          let lexCustomConfig;\n\n          if(ext === '.cjs') {\n            const fileUrl = new URL(`file:///${pathResolve(configPath)}`).href;\n\n            if(debug) {\n              log(`Loading CommonJS config from: ${fileUrl}`, 'info', quiet);\n            }\n            lexCustomConfig = await import(fileUrl);\n          } else {\n            if(debug) {\n              log(`Loading ESM/TS config from: ${configPath}`, 'info', quiet);\n            }\n\n            lexCustomConfig = await import(configPath);\n          }\n\n          const config = lexCustomConfig.default || lexCustomConfig;\n\n          if(debug) {\n            log(`Loaded config: ${JSON.stringify(config, null, 2)}`, 'info', quiet);\n          }\n\n          if(!config) {\n            log(`\\n${cliName} Warning: Config file loaded but no configuration found`, 'warn', quiet);\n          }\n\n          LexConfig.addConfigParams(cmd, config || {});\n        } catch(error) {\n          log(`\\n${cliName} Error: Failed to load config file: ${error.message}`, 'error', quiet);\n          if(debug) {\n            // eslint-disable-next-line no-console\n            console.error(error);\n          }\n        }\n      } else {\n        log(`\\n${cliName} Error: Config file must be a JS, CJS, MJS, TS, or JSON file.`, 'error', quiet);\n      }\n    } else {\n      if(debug) {\n        log('No config file found. Using default configuration.', 'info', quiet);\n      }\n\n      LexConfig.useTypescript = !!typescript;\n      LexConfig.addConfigParams(cmd, LexConfig.config);\n    }\n  }\n\n  static checkTypescriptConfig() {\n    const packageDir = getPackageDir();\n    const tsconfigPath: string = pathResolve(packageDir, './tsconfig.json');\n\n    if(!existsSync(tsconfigPath)) {\n      const lexDir = LexConfig.getLexDir();\n      const baseConfigPath = pathResolve(lexDir, 'tsconfig.base.json');\n      const templateConfigPath = pathResolve(lexDir, 'tsconfig.template.json');\n      const sourcePath = existsSync(baseConfigPath) ? baseConfigPath : templateConfigPath;\n\n      if(existsSync(sourcePath)) {\n        writeFileSync(tsconfigPath, readFileSync(sourcePath));\n      }\n    }\n  }\n\n  static getTypeScriptDeclarationFlags(): string[] {\n    const cwd = process.cwd();\n    const outputPath = LexConfig.config.outputPath || './lib';\n    const outputFullPath = LexConfig.config.outputFullPath || pathResolve(cwd, outputPath);\n    const sourcePath = LexConfig.config.sourcePath || './src';\n    const sourceFullPath = LexConfig.config.sourceFullPath || pathResolve(cwd, sourcePath);\n    const relativeOutDir = pathRelative(cwd, outputFullPath) || './lib';\n    const relativeRootDir = pathRelative(cwd, sourceFullPath) || './src';\n\n    return [\n      '--emitDeclarationOnly', // CRITICAL: Only emit .d.ts files, no JS files\n      '--declaration', // Generate declaration files\n      '--declarationMap', // Generate source maps for declarations\n      '--outDir', relativeOutDir,\n      '--rootDir', relativeRootDir,\n      '--skipLibCheck', // Skip type checking of declaration files (faster, more lenient)\n      '--esModuleInterop',\n      '--allowSyntheticDefaultImports',\n      '--module', 'NodeNext',\n      '--moduleResolution', 'NodeNext',\n      '--target', 'ESNext',\n      '--jsx', 'react-jsx',\n      '--isolatedModules',\n      '--resolveJsonModule',\n      '--allowJs',\n      '--ignoreConfig'\n      // Note: --noUnusedLocals and --noUnusedParameters are not needed for declaration generation\n      // and would actually enable strict checking, which we want to avoid for faster declaration generation\n    ];\n  }\n\n  static checkLintTypescriptConfig() {\n    const lexDir = LexConfig.getLexDir();\n    const tsconfigLintPath: string = pathResolve(lexDir, './tsconfig.lint.json');\n\n    if(!existsSync(tsconfigLintPath)) {\n      const templatePath = pathResolve(lexDir, 'tsconfig.lint.json');\n      if(existsSync(templatePath)) {\n        writeFileSync(tsconfigLintPath, readFileSync(templatePath));\n      }\n    }\n  }\n\n  static checkTestTypescriptConfig() {\n    const lexDir = LexConfig.getLexDir();\n    const tsconfigTestPath: string = pathResolve(lexDir, './tsconfig.test.json');\n\n    if(!existsSync(tsconfigTestPath)) {\n      const templatePath = pathResolve(lexDir, 'tsconfig.test.json');\n      if(existsSync(templatePath)) {\n        writeFileSync(tsconfigTestPath, readFileSync(templatePath));\n      }\n    }\n  }\n}\n\nexport type SWCOptions = Options;\n"],"names":["findFileUp","existsSync","readFileSync","writeFileSync","dirname","extname","pathExtname","relative","pathRelative","resolve","pathResolve","URL","getLexPackageJsonPath","relativeFilePath","log","cwd","process","reactCompilerPluginName","defaultReactCompilerOptions","compilationMode","panicThreshold","target","isReactCompilerPlugin","plugin","Array","isArray","defaultConfigValues","ai","maxTokens","model","provider","temperature","configFiles","copyFiles","entryHTML","entryJs","env","eslint","outputFullPath","outputHash","outputPath","packageManager","preset","sourceFullPath","sourcePath","swc","inlineSourcesContent","isModule","jsc","externalHelpers","keepClassNames","loose","parser","decorators","dynamicImport","syntax","tsx","transform","react","runtime","minify","module","lazy","noInterop","strict","strictMode","type","sourceMaps","targetEnvironment","useGraphQl","useTypescript","vitest","webpack","staticPath","getPackageDir","currentPkgPath","pkg","JSON","parse","workspaces","searchDir","i","pkgPath","parent","configFormats","format","configPath","sync","getTypeScriptConfigPath","configName","packageDir","projectBuildConfig","rootBuildConfig","projectLintConfig","rootLintConfig","projectTestConfig","rootTestConfig","projectConfigPath","rootConfigPath","lexDir","LexConfig","getLexDir","value","config","indexPath","hasIndexTsx","getSWCConfigWithReactCompiler","swcConfig","reactCompiler","undefined","currentSwcConfig","currentJsc","currentExperimental","experimental","plugins","filter","swcConfigWithReactCompiler","updateConfig","updatedConfig","CURSOR_IDE","addConfigParams","cmd","params","nameProperty","environment","typescript","LEX_CONFIG","stringify","commandName","isStatic","static","parseConfig","isRoot","cliName","lexConfig","lexConfigName","quiet","debug","configBaseName","configExists","potentialPath","ext","configContent","configJson","default","error","message","includes","lexCustomConfig","fileUrl","href","console","checkTypescriptConfig","tsconfigPath","baseConfigPath","templateConfigPath","getTypeScriptDeclarationFlags","relativeOutDir","relativeRootDir","checkLintTypescriptConfig","tsconfigLintPath","templatePath","checkTestTypescriptConfig","tsconfigTestPath"],"mappings":"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"}

package/lib/commands/compile/compile.js

@@ -30,7 +30,8 @@ export const compile = async (cmd, callback = ()=>({}))=>{
     const spinner = createSpinner(quiet);
     log(`${cliName} compiling...`, 'info', quiet);
     await LexConfig.parseConfig(cmd);
-    const { outputFullPath, sourceFullPath, swc: swcConfig, useTypescript } = LexConfig.config;
+    const { outputFullPath, reactCompiler, sourceFullPath, swc: parsedSwcConfig, useTypescript } = LexConfig.config;
+    const swcConfig = LexConfig.getSWCConfigWithReactCompiler(parsedSwcConfig, reactCompiler);
     const outputDir = outputPath ? pathResolve(process.cwd(), outputPath) : outputFullPath || pathResolve(process.cwd(), './lib');
     const sourceDir = sourcePath ? pathResolve(process.cwd(), `./${sourcePath}`) : sourceFullPath || '';
     const dirName = getDirName();
@@ -228,7 +229,6 @@ export const compile = async (cmd, callback = ()=>({}))=>{
                 });
             }
             const sourceCode = readFileSync(sourcePath, 'utf8');
-            const isTSX = file.endsWith('.tsx');
             const swcOptions = {
                 ...swcConfig,
                 filename: file,
@@ -274,4 +274,4 @@ export const compile = async (cmd, callback = ()=>({}))=>{
     return 0;
 };
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/commands/compile/compile.ts"],"sourcesContent":["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {transform} from '@swc/core';\nimport {execa} from 'execa';\nimport {existsSync, lstatSync, readdirSync, readFileSync, writeFileSync, mkdirSync} from 'fs';\nimport {sync as globSync} from 'glob';\nimport {extname as pathExtname, join as pathJoin, relative as pathRelative, resolve as pathResolve, dirname} from 'path';\n\nimport {LexConfig} from '../../LexConfig.js';\nimport {checkLinkedModules, copyConfiguredFiles, copyFiles, createSpinner, getFilesByExt, removeFiles} from '../../utils/app.js';\nimport {getDirName, resolveBinaryPath} from '../../utils/file.js';\nimport {log} from '../../utils/log.js';\n\nimport type {SWCOptions} from '../../LexConfig.js';\n\nexport const hasFileType = (startPath: string, ext: string[]): boolean => {\n  if(!existsSync(startPath)) {\n    return false;\n  }\n\n  const files: string[] = readdirSync(startPath);\n\n  return files.some((file: string) => {\n    const filename: string = pathJoin(startPath, file);\n    const fileExt: string = pathExtname(filename);\n    const stat = lstatSync(filename);\n\n    if(stat.isDirectory()) {\n      return hasFileType(filename, ext);\n    }\n\n    return ext.includes(fileExt);\n  });\n};\n\nexport const compile = async (cmd: any, callback: any = () => ({})): Promise<number> => {\n  const {\n    cliName = 'Lex',\n    config,\n    format = 'esm',\n    outputPath,\n    quiet,\n    remove,\n    sourcePath,\n    watch\n  } = cmd;\n  const spinner = createSpinner(quiet);\n\n  log(`${cliName} compiling...`, 'info', quiet);\n\n  await LexConfig.parseConfig(cmd);\n\n  const {outputFullPath, sourceFullPath, swc: swcConfig, useTypescript} = LexConfig.config;\n  const outputDir: string = outputPath\n    ? pathResolve(process.cwd(), outputPath)\n    : (outputFullPath || pathResolve(process.cwd(), './lib'));\n  const sourceDir: string = sourcePath ? pathResolve(process.cwd(), `./${sourcePath}`) : sourceFullPath || '';\n  const dirName = getDirName();\n\n  checkLinkedModules();\n\n  if(remove) {\n    await removeFiles(outputDir);\n  }\n\n  if(useTypescript) {\n    const typescriptPath: string = resolveBinaryPath('tsc', 'typescript');\n\n    if(!typescriptPath) {\n      log(`\\n${cliName} Error: TypeScript binary not found in Lex's node_modules or monorepo root`, 'error', quiet);\n      log('Please reinstall Lex or check your installation.', 'info', quiet);\n      return 1;\n    }\n\n    const typescriptOptions: string[] = config\n      ? ['-p', config, '--emitDeclarationOnly', '--skipLibCheck'] // User provided custom config, but still only emit declarations\n      : (() => {\n        const globOptions = {\n          absolute: true,\n          cwd: sourceDir,\n          dot: false,\n          nodir: true\n        };\n        const tsFiles = globSync('**/!(*.spec|*.test|*.integration|*.e2e).ts', globOptions);\n        const tsxFiles = globSync('**/!(*.spec|*.test|*.integration|*.e2e).tsx', globOptions);\n        const allSourceFiles = [...tsFiles, ...tsxFiles];\n\n        return [\n          ...LexConfig.getTypeScriptDeclarationFlags(),\n          ...allSourceFiles\n        ];\n      })();\n\n    spinner.start('Generating TypeScript declarations...');\n\n    try {\n      const result = await execa(typescriptPath, typescriptOptions, {\n        all: true,\n        cwd: process.cwd(),\n        encoding: 'utf8',\n        reject: false\n      });\n\n      if(result.exitCode !== 0) {\n        const hasDeclarations = result.all?.includes('Writing') || result.all?.includes('Declaration') || false;\n        const errorOutput = result.stderr || result.stdout || result.all || 'Unknown error';\n\n        if(!hasDeclarations) {\n          log(`\\n${cliName} Error: TypeScript declaration generation failed`, 'error', quiet);\n          log(`\\nExit Code: ${result.exitCode}`, 'error', quiet);\n          log(`\\nTypeScript Command: ${typescriptPath} ${typescriptOptions.join(' ')}`, 'error', quiet);\n          log(`\\nError Output:\\n${errorOutput}`, 'error', quiet);\n\n          const errorLines = errorOutput.split('\\n').filter((line) =>\n            line.includes('error TS') ||\n            line.includes('Error:') ||\n            line.trim().startsWith('src/') ||\n            line.trim().startsWith('TS')\n          );\n\n          if(errorLines.length > 0) {\n            log('\\nKey Errors:', 'error', quiet);\n\n            errorLines.slice(0, 10).forEach((line) => {\n              log(`  ${line}`, 'error', quiet);\n            });\n\n            if(errorLines.length > 10) {\n              log(`  ... and ${errorLines.length - 10} more errors`, 'error', quiet);\n            }\n          }\n\n          spinner.fail('TypeScript declaration generation failed.');\n        } else {\n          log(`\\n${cliName} Warning: TypeScript declaration generation completed with errors`, 'warn', quiet);\n\n          if(!quiet && errorOutput) {\n            log(`\\nWarnings:\\n${errorOutput}`, 'warn', quiet);\n          }\n\n          spinner.succeed('TypeScript declarations generated (with warnings).');\n        }\n      } else {\n        spinner.succeed('Successfully generated TypeScript declarations!');\n      }\n    } catch(error) {\n      log(`\\n${cliName} Error: TypeScript declaration generation exception`, 'error', quiet);\n      log(`\\nError: ${error.message}`, 'error', quiet);\n\n      if(error instanceof Error && error.stack) {\n        log(`\\nStack:\\n${error.stack}`, 'error', quiet);\n      }\n\n      spinner.fail('TypeScript declaration generation had issues, continuing...');\n    }\n  }\n\n  const globOptions = {\n    absolute: true,\n    cwd: sourceDir,\n    dot: false,\n    nodir: true,\n    nosort: true\n  };\n  const tsFiles: string[] = globSync('**/!(*.spec|*.test|*.integration|*.e2e).ts*', globOptions);\n  const jsFiles: string[] = globSync('**/!(*.spec|*.test|*.integration|*.e2e).js', globOptions);\n  const sourceFiles: string[] = [...tsFiles, ...jsFiles];\n\n  const cssFiles: string[] = getFilesByExt('.css', LexConfig.config);\n\n  if(cssFiles.length) {\n    const postcssPath: string = resolveBinaryPath('postcss', 'postcss-cli');\n\n    if(!postcssPath) {\n      log(`\\n${cliName} Error: PostCSS binary not found in Lex's node_modules or monorepo root`, 'error', quiet);\n      log('Please reinstall Lex or check your installation.', 'info', quiet);\n      return 1;\n    }\n\n    const postcssOptions: string[] = [\n      `${sourceDir}/**/**.css`,\n      '--base',\n      sourceDir,\n      '--dir',\n      outputDir,\n      '--config',\n      pathResolve(dirName, '../../postcss.config.js')\n    ];\n\n    try {\n      await execa(postcssPath, postcssOptions, {encoding: 'utf8'});\n      spinner.succeed(`Successfully formatted ${cssFiles.length} css files!`);\n    } catch(error) {\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      spinner.fail('Failed formatting css.');\n\n      callback(1);\n      return 1;\n    }\n  }\n\n  const gifFiles: string[] = getFilesByExt('.gif', LexConfig.config);\n  const jpgFiles: string[] = getFilesByExt('.jpg', LexConfig.config);\n  const pngFiles: string[] = getFilesByExt('.png', LexConfig.config);\n  const svgFiles: string[] = getFilesByExt('.svg', LexConfig.config);\n  const imageFiles: string[] = [...gifFiles, ...jpgFiles, ...pngFiles, ...svgFiles];\n\n  if(imageFiles.length) {\n    try {\n      await copyFiles(imageFiles, 'image', spinner, LexConfig.config);\n    } catch(error) {\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      spinner.fail('Failed to move images to output directory.');\n\n      callback(1);\n      return 1;\n    }\n  }\n\n  const ttfFiles: string[] = getFilesByExt('.ttf', LexConfig.config);\n  const otfFiles: string[] = getFilesByExt('.otf', LexConfig.config);\n  const woffFiles: string[] = getFilesByExt('.woff', LexConfig.config);\n  const woff2Files: string[] = getFilesByExt('.woff2', LexConfig.config);\n  const fontFiles: string[] = [...ttfFiles, ...otfFiles, ...woffFiles, ...woff2Files];\n\n  if(fontFiles.length) {\n    try {\n      await copyFiles(fontFiles, 'font', spinner, LexConfig.config);\n    } catch(error) {\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      spinner.fail('Failed to move fonts to output directory.');\n\n      callback(1);\n      return 1;\n    }\n  }\n\n  const mdFiles: string[] = getFilesByExt('.md', LexConfig.config);\n\n  if(mdFiles.length) {\n    try {\n      await copyFiles(mdFiles, 'documents', spinner, LexConfig.config);\n    } catch(error) {\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      spinner.fail('Failed to move docs to output directory.');\n\n      callback(1);\n      return 1;\n    }\n  }\n\n  if(sourceFiles.length === 0) {\n    log(`\\n${cliName} Warning: No source files found to compile in ${sourceDir}`, 'warn', quiet);\n    spinner.succeed('No files to compile.');\n    callback(0);\n    return 0;\n  }\n\n  spinner.start(watch ? 'Watching for changes...' : 'Compiling with SWC...');\n\n  try {\n    const transformPromises = sourceFiles.map(async (file) => {\n      const fileRelativeToSource = pathRelative(sourceDir, file);\n      const sourcePath = file;\n      const outputFile = fileRelativeToSource.replace(/\\.(ts|tsx)$/, '.js');\n      const outputPath = pathResolve(outputDir, outputFile);\n      const outputDirPath = dirname(outputPath);\n\n      if(!existsSync(outputDirPath)) {\n        mkdirSync(outputDirPath, {recursive: true});\n      }\n\n      const sourceCode = readFileSync(sourcePath, 'utf8');\n      const isTSX = file.endsWith('.tsx');\n      const swcOptions: Partial<SWCOptions> = {\n        ...swcConfig,\n        filename: file,\n        module: {\n          type: format === 'cjs' ? 'commonjs' as const : (swcConfig?.module?.type as 'es6' || 'es6'),\n          ...swcConfig?.module\n        },\n        sourceMaps: swcConfig?.sourceMaps || 'inline'\n      };\n\n      const result = await transform(sourceCode, swcOptions);\n\n      writeFileSync(outputPath, result.code);\n    });\n\n    await Promise.all(transformPromises);\n\n    spinner.succeed('Compile completed successfully!');\n  } catch(error) {\n    log(`\\n${cliName} Error: SWC compilation failed`, 'error', quiet);\n    log(`\\nError: ${error.message}`, 'error', quiet);\n\n    if(error instanceof Error) {\n      if(error.stack) {\n        log(`\\nStack Trace:\\n${error.stack}`, 'error', quiet);\n      }\n\n      if('filename' in error || 'file' in error) {\n        log(`\\nFile: ${(error as any).filename || (error as any).file}`, 'error', quiet);\n      }\n    }\n\n    if(!quiet) {\n      // eslint-disable-next-line no-console\n      console.error('\\nFull Error Details:', error);\n    }\n\n    spinner.fail('Code compiling failed.');\n\n    callback(1);\n    return 1;\n  }\n\n  try {\n    await copyConfiguredFiles(spinner, LexConfig.config, quiet);\n  } catch(copyError) {\n    log(`\\n${cliName} Error: Failed to copy configured files: ${copyError.message}`, 'error', quiet);\n\n    spinner.fail('Failed to copy configured files.');\n\n    callback(1);\n    return 1;\n  }\n\n  callback(0);\n  return 0;\n};\n"],"names":["transform","execa","existsSync","lstatSync","readdirSync","readFileSync","writeFileSync","mkdirSync","sync","globSync","extname","pathExtname","join","pathJoin","relative","pathRelative","resolve","pathResolve","dirname","LexConfig","checkLinkedModules","copyConfiguredFiles","copyFiles","createSpinner","getFilesByExt","removeFiles","getDirName","resolveBinaryPath","log","hasFileType","startPath","ext","files","some","file","filename","fileExt","stat","isDirectory","includes","compile","cmd","callback","cliName","config","format","outputPath","quiet","remove","sourcePath","watch","spinner","parseConfig","outputFullPath","sourceFullPath","swc","swcConfig","useTypescript","outputDir","process","cwd","sourceDir","dirName","typescriptPath","typescriptOptions","globOptions","absolute","dot","nodir","tsFiles","tsxFiles","allSourceFiles","getTypeScriptDeclarationFlags","start","result","all","encoding","reject","exitCode","hasDeclarations","errorOutput","stderr","stdout","errorLines","split","filter","line","trim","startsWith","length","slice","forEach","fail","succeed","error","message","Error","stack","nosort","jsFiles","sourceFiles","cssFiles","postcssPath","postcssOptions","gifFiles","jpgFiles","pngFiles","svgFiles","imageFiles","ttfFiles","otfFiles","woffFiles","woff2Files","fontFiles","mdFiles","transformPromises","map","fileRelativeToSource","outputFile","replace","outputDirPath","recursive","sourceCode","isTSX","endsWith","swcOptions","module","type","sourceMaps","code","Promise","console","copyError"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/commands/compile/compile.ts"],"sourcesContent":["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {transform} from '@swc/core';\nimport {execa} from 'execa';\nimport {existsSync, lstatSync, readdirSync, readFileSync, writeFileSync, mkdirSync} from 'fs';\nimport {sync as globSync} from 'glob';\nimport {extname as pathExtname, join as pathJoin, relative as pathRelative, resolve as pathResolve, dirname} from 'path';\n\nimport {LexConfig} from '../../LexConfig.js';\nimport {checkLinkedModules, copyConfiguredFiles, copyFiles, createSpinner, getFilesByExt, removeFiles} from '../../utils/app.js';\nimport {getDirName, resolveBinaryPath} from '../../utils/file.js';\nimport {log} from '../../utils/log.js';\n\nimport type {SWCOptions} from '../../LexConfig.js';\n\nexport const hasFileType = (startPath: string, ext: string[]): boolean => {\n  if(!existsSync(startPath)) {\n    return false;\n  }\n\n  const files: string[] = readdirSync(startPath);\n\n  return files.some((file: string) => {\n    const filename: string = pathJoin(startPath, file);\n    const fileExt: string = pathExtname(filename);\n    const stat = lstatSync(filename);\n\n    if(stat.isDirectory()) {\n      return hasFileType(filename, ext);\n    }\n\n    return ext.includes(fileExt);\n  });\n};\n\nexport const compile = async (cmd: any, callback: any = () => ({})): Promise<number> => {\n  const {\n    cliName = 'Lex',\n    config,\n    format = 'esm',\n    outputPath,\n    quiet,\n    remove,\n    sourcePath,\n    watch\n  } = cmd;\n  const spinner = createSpinner(quiet);\n\n  log(`${cliName} compiling...`, 'info', quiet);\n\n  await LexConfig.parseConfig(cmd);\n\n  const {outputFullPath, reactCompiler, sourceFullPath, swc: parsedSwcConfig, useTypescript} = LexConfig.config;\n  const swcConfig = LexConfig.getSWCConfigWithReactCompiler(parsedSwcConfig, reactCompiler);\n  const outputDir: string = outputPath\n    ? pathResolve(process.cwd(), outputPath)\n    : (outputFullPath || pathResolve(process.cwd(), './lib'));\n  const sourceDir: string = sourcePath ? pathResolve(process.cwd(), `./${sourcePath}`) : sourceFullPath || '';\n  const dirName = getDirName();\n\n  checkLinkedModules();\n\n  if(remove) {\n    await removeFiles(outputDir);\n  }\n\n  if(useTypescript) {\n    const typescriptPath: string = resolveBinaryPath('tsc', 'typescript');\n\n    if(!typescriptPath) {\n      log(`\\n${cliName} Error: TypeScript binary not found in Lex's node_modules or monorepo root`, 'error', quiet);\n      log('Please reinstall Lex or check your installation.', 'info', quiet);\n      return 1;\n    }\n\n    const typescriptOptions: string[] = config\n      ? ['-p', config, '--emitDeclarationOnly', '--skipLibCheck'] // User provided custom config, but still only emit declarations\n      : (() => {\n        const globOptions = {\n          absolute: true,\n          cwd: sourceDir,\n          dot: false,\n          nodir: true\n        };\n        const tsFiles = globSync('**/!(*.spec|*.test|*.integration|*.e2e).ts', globOptions);\n        const tsxFiles = globSync('**/!(*.spec|*.test|*.integration|*.e2e).tsx', globOptions);\n        const allSourceFiles = [...tsFiles, ...tsxFiles];\n\n        return [\n          ...LexConfig.getTypeScriptDeclarationFlags(),\n          ...allSourceFiles\n        ];\n      })();\n\n    spinner.start('Generating TypeScript declarations...');\n\n    try {\n      const result = await execa(typescriptPath, typescriptOptions, {\n        all: true,\n        cwd: process.cwd(),\n        encoding: 'utf8',\n        reject: false\n      });\n\n      if(result.exitCode !== 0) {\n        const hasDeclarations = result.all?.includes('Writing') || result.all?.includes('Declaration') || false;\n        const errorOutput = result.stderr || result.stdout || result.all || 'Unknown error';\n\n        if(!hasDeclarations) {\n          log(`\\n${cliName} Error: TypeScript declaration generation failed`, 'error', quiet);\n          log(`\\nExit Code: ${result.exitCode}`, 'error', quiet);\n          log(`\\nTypeScript Command: ${typescriptPath} ${typescriptOptions.join(' ')}`, 'error', quiet);\n          log(`\\nError Output:\\n${errorOutput}`, 'error', quiet);\n\n          const errorLines = errorOutput.split('\\n').filter((line) =>\n            line.includes('error TS') ||\n            line.includes('Error:') ||\n            line.trim().startsWith('src/') ||\n            line.trim().startsWith('TS')\n          );\n\n          if(errorLines.length > 0) {\n            log('\\nKey Errors:', 'error', quiet);\n\n            errorLines.slice(0, 10).forEach((line) => {\n              log(`  ${line}`, 'error', quiet);\n            });\n\n            if(errorLines.length > 10) {\n              log(`  ... and ${errorLines.length - 10} more errors`, 'error', quiet);\n            }\n          }\n\n          spinner.fail('TypeScript declaration generation failed.');\n        } else {\n          log(`\\n${cliName} Warning: TypeScript declaration generation completed with errors`, 'warn', quiet);\n\n          if(!quiet && errorOutput) {\n            log(`\\nWarnings:\\n${errorOutput}`, 'warn', quiet);\n          }\n\n          spinner.succeed('TypeScript declarations generated (with warnings).');\n        }\n      } else {\n        spinner.succeed('Successfully generated TypeScript declarations!');\n      }\n    } catch(error) {\n      log(`\\n${cliName} Error: TypeScript declaration generation exception`, 'error', quiet);\n      log(`\\nError: ${error.message}`, 'error', quiet);\n\n      if(error instanceof Error && error.stack) {\n        log(`\\nStack:\\n${error.stack}`, 'error', quiet);\n      }\n\n      spinner.fail('TypeScript declaration generation had issues, continuing...');\n    }\n  }\n\n  const globOptions = {\n    absolute: true,\n    cwd: sourceDir,\n    dot: false,\n    nodir: true,\n    nosort: true\n  };\n  const tsFiles: string[] = globSync('**/!(*.spec|*.test|*.integration|*.e2e).ts*', globOptions);\n  const jsFiles: string[] = globSync('**/!(*.spec|*.test|*.integration|*.e2e).js', globOptions);\n  const sourceFiles: string[] = [...tsFiles, ...jsFiles];\n\n  const cssFiles: string[] = getFilesByExt('.css', LexConfig.config);\n\n  if(cssFiles.length) {\n    const postcssPath: string = resolveBinaryPath('postcss', 'postcss-cli');\n\n    if(!postcssPath) {\n      log(`\\n${cliName} Error: PostCSS binary not found in Lex's node_modules or monorepo root`, 'error', quiet);\n      log('Please reinstall Lex or check your installation.', 'info', quiet);\n      return 1;\n    }\n\n    const postcssOptions: string[] = [\n      `${sourceDir}/**/**.css`,\n      '--base',\n      sourceDir,\n      '--dir',\n      outputDir,\n      '--config',\n      pathResolve(dirName, '../../postcss.config.js')\n    ];\n\n    try {\n      await execa(postcssPath, postcssOptions, {encoding: 'utf8'});\n      spinner.succeed(`Successfully formatted ${cssFiles.length} css files!`);\n    } catch(error) {\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      spinner.fail('Failed formatting css.');\n\n      callback(1);\n      return 1;\n    }\n  }\n\n  const gifFiles: string[] = getFilesByExt('.gif', LexConfig.config);\n  const jpgFiles: string[] = getFilesByExt('.jpg', LexConfig.config);\n  const pngFiles: string[] = getFilesByExt('.png', LexConfig.config);\n  const svgFiles: string[] = getFilesByExt('.svg', LexConfig.config);\n  const imageFiles: string[] = [...gifFiles, ...jpgFiles, ...pngFiles, ...svgFiles];\n\n  if(imageFiles.length) {\n    try {\n      await copyFiles(imageFiles, 'image', spinner, LexConfig.config);\n    } catch(error) {\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      spinner.fail('Failed to move images to output directory.');\n\n      callback(1);\n      return 1;\n    }\n  }\n\n  const ttfFiles: string[] = getFilesByExt('.ttf', LexConfig.config);\n  const otfFiles: string[] = getFilesByExt('.otf', LexConfig.config);\n  const woffFiles: string[] = getFilesByExt('.woff', LexConfig.config);\n  const woff2Files: string[] = getFilesByExt('.woff2', LexConfig.config);\n  const fontFiles: string[] = [...ttfFiles, ...otfFiles, ...woffFiles, ...woff2Files];\n\n  if(fontFiles.length) {\n    try {\n      await copyFiles(fontFiles, 'font', spinner, LexConfig.config);\n    } catch(error) {\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      spinner.fail('Failed to move fonts to output directory.');\n\n      callback(1);\n      return 1;\n    }\n  }\n\n  const mdFiles: string[] = getFilesByExt('.md', LexConfig.config);\n\n  if(mdFiles.length) {\n    try {\n      await copyFiles(mdFiles, 'documents', spinner, LexConfig.config);\n    } catch(error) {\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      spinner.fail('Failed to move docs to output directory.');\n\n      callback(1);\n      return 1;\n    }\n  }\n\n  if(sourceFiles.length === 0) {\n    log(`\\n${cliName} Warning: No source files found to compile in ${sourceDir}`, 'warn', quiet);\n    spinner.succeed('No files to compile.');\n    callback(0);\n    return 0;\n  }\n\n  spinner.start(watch ? 'Watching for changes...' : 'Compiling with SWC...');\n\n  try {\n    const transformPromises = sourceFiles.map(async (file) => {\n      const fileRelativeToSource = pathRelative(sourceDir, file);\n      const sourcePath = file;\n      const outputFile = fileRelativeToSource.replace(/\\.(ts|tsx)$/, '.js');\n      const outputPath = pathResolve(outputDir, outputFile);\n      const outputDirPath = dirname(outputPath);\n\n      if(!existsSync(outputDirPath)) {\n        mkdirSync(outputDirPath, {recursive: true});\n      }\n\n      const sourceCode = readFileSync(sourcePath, 'utf8');\n      const swcOptions: Partial<SWCOptions> = {\n        ...swcConfig,\n        filename: file,\n        module: {\n          type: format === 'cjs' ? 'commonjs' as const : (swcConfig?.module?.type as 'es6' || 'es6'),\n          ...swcConfig?.module\n        },\n        sourceMaps: swcConfig?.sourceMaps || 'inline'\n      };\n\n      const result = await transform(sourceCode, swcOptions);\n\n      writeFileSync(outputPath, result.code);\n    });\n\n    await Promise.all(transformPromises);\n\n    spinner.succeed('Compile completed successfully!');\n  } catch(error) {\n    log(`\\n${cliName} Error: SWC compilation failed`, 'error', quiet);\n    log(`\\nError: ${error.message}`, 'error', quiet);\n\n    if(error instanceof Error) {\n      if(error.stack) {\n        log(`\\nStack Trace:\\n${error.stack}`, 'error', quiet);\n      }\n\n      if('filename' in error || 'file' in error) {\n        log(`\\nFile: ${(error as any).filename || (error as any).file}`, 'error', quiet);\n      }\n    }\n\n    if(!quiet) {\n      // eslint-disable-next-line no-console\n      console.error('\\nFull Error Details:', error);\n    }\n\n    spinner.fail('Code compiling failed.');\n\n    callback(1);\n    return 1;\n  }\n\n  try {\n    await copyConfiguredFiles(spinner, LexConfig.config, quiet);\n  } catch(copyError) {\n    log(`\\n${cliName} Error: Failed to copy configured files: ${copyError.message}`, 'error', quiet);\n\n    spinner.fail('Failed to copy configured files.');\n\n    callback(1);\n    return 1;\n  }\n\n  callback(0);\n  return 0;\n};\n"],"names":["transform","execa","existsSync","lstatSync","readdirSync","readFileSync","writeFileSync","mkdirSync","sync","globSync","extname","pathExtname","join","pathJoin","relative","pathRelative","resolve","pathResolve","dirname","LexConfig","checkLinkedModules","copyConfiguredFiles","copyFiles","createSpinner","getFilesByExt","removeFiles","getDirName","resolveBinaryPath","log","hasFileType","startPath","ext","files","some","file","filename","fileExt","stat","isDirectory","includes","compile","cmd","callback","cliName","config","format","outputPath","quiet","remove","sourcePath","watch","spinner","parseConfig","outputFullPath","reactCompiler","sourceFullPath","swc","parsedSwcConfig","useTypescript","swcConfig","getSWCConfigWithReactCompiler","outputDir","process","cwd","sourceDir","dirName","typescriptPath","typescriptOptions","globOptions","absolute","dot","nodir","tsFiles","tsxFiles","allSourceFiles","getTypeScriptDeclarationFlags","start","result","all","encoding","reject","exitCode","hasDeclarations","errorOutput","stderr","stdout","errorLines","split","filter","line","trim","startsWith","length","slice","forEach","fail","succeed","error","message","Error","stack","nosort","jsFiles","sourceFiles","cssFiles","postcssPath","postcssOptions","gifFiles","jpgFiles","pngFiles","svgFiles","imageFiles","ttfFiles","otfFiles","woffFiles","woff2Files","fontFiles","mdFiles","transformPromises","map","fileRelativeToSource","outputFile","replace","outputDirPath","recursive","sourceCode","swcOptions","module","type","sourceMaps","code","Promise","console","copyError"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nlabs/lex",
-  "version": "1.58.1",
+  "version": "1.59.0",
   "description": "Lex",
   "license": "MIT",
   "type": "module",
@@ -87,27 +87,28 @@
   "dependencies": {
     "@mdx-js/loader": "^3.1.1",
     "@nlabs/webpack-plugin-static-site": "*",
-    "@playwright/test": "^1.55.1",
-    "@storybook/addon-docs": "^10.3.4",
-    "@storybook/addon-links": "^10.3.4",
+    "@playwright/test": "^1.60.0",
+    "@storybook/addon-docs": "^10.4.1",
+    "@storybook/addon-links": "^10.4.1",
     "@storybook/addon-styling-webpack": "^3.0.2",
-    "@storybook/addon-themes": "^10.3.4",
-    "@storybook/cli": "^10.3.4",
-    "@storybook/react": "^10.3.4",
-    "@storybook/react-webpack5": "^10.3.4",
+    "@storybook/addon-themes": "^10.4.1",
+    "@storybook/cli": "^10.4.1",
+    "@storybook/react": "^10.4.1",
+    "@storybook/react-webpack5": "^10.4.1",
     "@swc/cli": "^0.8.1",
-    "@swc/core": "^1.15.24",
+    "@swc/core": "^1.15.40",
+    "@swc/react-compiler": "^1.15.40",
     "@tailwindcss/forms": "^0.5.11",
     "@tailwindcss/nesting": "^0.0.0-insiders.565cd3e",
-    "@tailwindcss/postcss": "4.2.2",
+    "@tailwindcss/postcss": "4.3.0",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.2",
-    "@vitest/coverage-v8": "^4.1.2",
+    "@vitest/coverage-v8": "^4.1.7",
     "assert": "^2.1.0",
-    "autoprefixer": "^10.4.27",
+    "autoprefixer": "^10.5.0",
     "boxen": "8.0.1",
     "buffer": "^6.0.3",
-    "caniuse-lite": "1.0.30001786",
+    "caniuse-lite": "1.0.30001793",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "compare-versions": "^6.1.1",
@@ -117,37 +118,37 @@
     "crypto-js": "^4.2.0",
     "css-loader": "^7.1.4",
     "css-minimizer-webpack-plugin": "^8.0.0",
-    "cssnano": "^7.1.4",
+    "cssnano": "^8.0.1",
     "dotenv-webpack": "^9.0.0",
     "download-npm-package": "^3.1.12",
-    "esbuild": "^0.27.3",
-    "eslint": "^10.2.0",
+    "esbuild": "^0.28.0",
+    "eslint": "^10.4.0",
     "eslint-config-styleguidejs": "^5.0.4",
     "execa": "9.6.1",
-    "expect": "^30.3.0",
+    "expect": "^30.4.1",
     "express": "^5.2.1",
     "favicons-webpack-plugin": "^6.0.1",
     "find-file-up": "^2.0.1",
     "glob": "^13.0.6",
     "global": "^4.4.0",
-    "graphql": "^16.13.2",
+    "graphql": "^16.14.0",
     "graphql-tag": "^2.12.6",
     "html-loader": "^5.1.0",
-    "html-webpack-plugin": "^5.6.6",
+    "html-webpack-plugin": "^5.6.7",
     "https-browserify": "^1.0.0",
     "image-webpack-loader": "^8.1.0",
-    "jsdom": "^29.0.1",
+    "jsdom": "^29.1.1",
     "latest-version": "9.0.0",
     "lodash": "^4.18.1",
     "luxon": "^3.7.2",
     "math-expression-evaluator": "^2.0.7",
     "mini-css-extract-plugin": "^2.10.2",
-    "npm-check-updates": "^20.0.0",
-    "openai": "^6.33.0",
-    "ora": "9.3.0",
+    "npm-check-updates": "^22.2.1",
+    "openai": "^6.39.1",
+    "ora": "9.4.0",
     "os-browserify": "^0.3.0",
     "path-browserify": "^1.0.1",
-    "postcss": "^8.5.14",
+    "postcss": "^8.5.15",
     "postcss-browser-reporter": "^0.7.0",
     "postcss-cli": "^11.0.1",
     "postcss-custom-properties": "^15.0.1",
@@ -156,46 +157,46 @@
     "postcss-import": "16.1.1",
     "postcss-loader": "^8.2.1",
     "postcss-nesting": "^14.0.0",
-    "postcss-preset-env": "^11.2.0",
+    "postcss-preset-env": "^11.3.0",
     "postcss-simple-vars": "^7.0.1",
-    "postcss-svgo": "7.1.1",
-    "postcss-url": "10.1.3",
+    "postcss-svgo": "8.0.0",
+    "postcss-url": "10.1.4",
     "postcss-value-parser": "^4.2.0",
     "process": "^0.11.10",
     "randombytes": "^2.1.0",
-    "react": "^19.2.4",
-    "react-dom": "^19.2.4",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
     "regenerator-runtime": "^0.14.1",
-    "resolve": "^1.22.11",
+    "resolve": "^1.22.12",
     "rimraf": "^6.1.3",
-    "semver": "^7.7.4",
+    "semver": "^7.8.1",
     "source-map-loader": "^5.0.0",
-    "storybook": "^10.3.4",
+    "storybook": "^10.4.1",
     "stream-browserify": "^3.0.0",
     "stream-http": "^3.2.0",
     "style-loader": "^4.0.0",
     "svgo": "4.0.1",
     "swc-loader": "^0.2.7",
-    "tailwindcss": "^4.2.2",
+    "tailwindcss": "^4.3.0",
     "ts-node": "^10.9.2",
     "tsconfig-paths-webpack-plugin": "^4.2.0",
-    "typescript": "^6.0.2",
+    "typescript": "^6.0.3",
     "util": "^0.12.5",
-    "vitest": "^4.1.2",
+    "vitest": "^4.1.7",
     "vm-browserify": "^1.1.2",
-    "webpack": "5.105.4",
+    "webpack": "5.107.2",
     "webpack-bundle-analyzer": "^5.3.0",
-    "webpack-cli": "^7.0.2",
+    "webpack-cli": "^7.0.3",
     "webpack-merge": "^6.0.1",
     "webpack-plugin-serve": "^1.6.0",
-    "ws": "^8.20.0"
+    "ws": "^8.21.0"
   },
   "devDependencies": {
     "@types/express": "^5.0.6",
     "@types/luxon": "^3.7.1",
-    "@types/node": "^25.5.2",
+    "@types/node": "^25.9.1",
     "@types/ora": "^3.2.0",
-    "@types/react": "^19.2.14",
+    "@types/react": "^19.2.15",
     "@types/webpack": "^5.28.5"
   },
   "overrides": {
@@ -207,7 +208,7 @@
     "follow-redirects": "^1.16.0",
     "http-proxy-middleware": "^3.0.5",
     "minimatch": ">=10.2.4",
-    "postcss": "^8.5.14",
+    "postcss": "^8.5.15",
     "semver-regex": "^4.0.5",
     "tmp": "^0.2.5",
     "file-type": "^21.3.1"

package/webpack.config.js

@@ -61,6 +61,7 @@ const {
 const webpackStaticPath = webpackCustom?.staticPath || './src/static';
 
 const {publicPath: _, staticPath: __, ...webpackConfigFiltered} = webpackCustom || {};
+const swcConfig = LexConfig.getSWCConfigWithReactCompiler(lexConfig.swc, lexConfig.reactCompiler);
 
 const plugins = [
   new ProgressPlugin({
@@ -396,18 +397,18 @@ export default (webpackEnv, webpackOptions) => {
           type: 'javascript/esm',
           loader: swcLoaderPath,
           options: {
-            ...LexConfig.config.swc,
+            ...swcConfig,
             jsc: {
-              ...LexConfig.config.swc?.jsc,
+              ...swcConfig?.jsc,
               parser: {
-                ...LexConfig.config.swc?.jsc?.parser,
+                ...swcConfig?.jsc?.parser,
                 tsx: false,
                 dynamicImport: true
               },
-              target: LexConfig.config.swc?.jsc?.target || 'es2020'
+              target: swcConfig?.jsc?.target || 'es2020'
             },
             module: {
-              ...LexConfig.config.swc?.module,
+              ...swcConfig?.module,
               type: 'es6'
             }
           },
@@ -426,7 +427,7 @@ export default (webpackEnv, webpackOptions) => {
           type: 'javascript/esm',
           loader: swcLoaderPath,
           options: {
-            ...LexConfig.config.swc
+            ...swcConfig
           },
           resolve: {
             symlinks: true