tweak: simplify code, reduce json generation

Author: AvarianKnight

README.md

@@ -12,6 +12,7 @@ NativeCodeGen is a code generation tool for RDR3 (Red Dead Redemption 3) native
 - Parses C-style enum definitions with hexadecimal values
 - Parses C-style struct definitions with field attributes
 - Generates TypeScript wrapper classes with proper type mappings
+- Generates Lua wrapper classes with proper type annotations
 - Generates JSON database for web-based documentation
 - Generates Protocol Buffer binary files for efficient data transfer
 - Validates native definitions with error accumulation and reporting
@@ -84,9 +85,10 @@ dotnet run --project src/NativeCodeGen.Cli -- generate -i <input> -o <output> [o
 
 | Option | Description | Default |
 |--------|-------------|---------|
-| `-f, --format` | Output format: `typescript`, `json`, `proto` | `typescript` |
+| `-f, --format` | Output format: `typescript`, `lua`, `json`, `proto` | `typescript` |
 | `-n, --namespaces` | Filter specific namespaces (comma-separated) | All namespaces |
-| `--raw` | Generate raw native declarations without wrapper classes (TypeScript only) | `false` |
+| `--raw` | Generate raw native declarations without wrapper classes (TypeScript/Lua) | `false` |
+| `--single-file` | Combine all natives into a single file (requires `--raw`) | `false` |
 | `--strict` | Treat warnings as errors | `false` |
 
 #### Examples
@@ -97,12 +99,36 @@ Generate TypeScript wrapper classes:
 nativegen generate -i /path/to/rdr3-natives -o ./output -f typescript
 ```
 
-Generate raw TypeScript declarations (no classes):
+Generate raw TypeScript declarations (no classes, one file per namespace):
 
 ```bash
 nativegen generate -i /path/to/rdr3-natives -o ./output -f typescript --raw
 ```
 
+Generate raw TypeScript declarations (single file with all natives):
+
+```bash
+nativegen generate -i /path/to/rdr3-natives -o ./output -f typescript --raw --single-file
+```
+
+Generate Lua wrapper classes:
+
+```bash
+nativegen generate -i /path/to/rdr3-natives -o ./output -f lua
+```
+
+Generate raw Lua declarations (no classes, one file per namespace):
+
+```bash
+nativegen generate -i /path/to/rdr3-natives -o ./output -f lua --raw
+```
+
+Generate raw Lua declarations (single file with all natives):
+
+```bash
+nativegen generate -i /path/to/rdr3-natives -o ./output -f lua --raw --single-file
+```
+
 Generate JSON database:
 
 ```bash
@@ -141,6 +167,64 @@ dotnet run --project src/NativeCodeGen.Cli -- validate -i <input> [options]
 nativegen validate -i /path/to/rdr3-natives --strict
 ```
 
+## Generation Modes
+
+The `--raw` and `--single-file` flags control how native functions are generated:
+
+### Default Mode (Classes)
+
+Without flags, generates OOP-style wrapper classes where natives are organized as methods on entity classes:
+
+```typescript
+// classes/Entity.ts
+export class Entity implements IHandle {
+  constructor(public handle: number) {}
+
+  getCoords(alive: boolean): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0x...', this.handle, alive, rav()));
+  }
+}
+
+// Usage
+const ped = new Ped(pedHandle);
+const coords = ped.getCoords(true);
+```
+
+### Raw Mode (`--raw`)
+
+Generates standalone exported functions with handles as plain numbers. One file per namespace:
+
+```typescript
+// natives/ENTITY.ts
+export function GetEntityCoords(entity: number, alive: boolean): Vector3 {
+  return Vector3.fromArray(inv('0x...', entity, alive, rav()));
+}
+
+// Usage
+const coords = GetEntityCoords(pedHandle, true);
+```
+
+### Single File Mode (`--raw --single-file`)
+
+Generates all natives in a single file as global functions. Useful for smaller bundles:
+
+```typescript
+// natives.ts
+globalThis.GetEntityCoords = function(entity: number, alive: boolean): Vector3 {
+  return Vector3.fromArray(inv('0x...', entity, alive, rav()));
+};
+
+// Usage (functions are on globalThis)
+const coords = GetEntityCoords(pedHandle, true);
+```
+
+### Lua Modes
+
+Lua follows the same pattern:
+
+- **Raw mode**: Module tables per namespace (`Water.GetWaterHeight(...)`)
+- **Single file mode**: Global functions (`GetWaterHeight(...)`)
+
 ## Output Formats
 
 ### TypeScript (default)
@@ -167,7 +251,7 @@ output/
     └── *.ts              # Static utility classes
 ```
 
-With `--raw` flag, generates standalone functions without class wrappers:
+With `--raw` flag, generates standalone functions without class wrappers (one file per namespace):
 
 ```
 output/
@@ -176,7 +260,63 @@ output/
 ├── enums/
 ├── structs/
 └── natives/
-    └── *.ts              # Raw native function exports
+    └── *.ts              # Raw native function exports per namespace
+```
+
+With `--raw --single-file` flags, generates all natives in a single file:
+
+```
+output/
+├── index.ts
+├── types/
+├── enums/
+├── structs/
+└── natives.ts            # All native functions in one file
+```
+
+### Lua
+
+Generates typed wrapper classes with LuaLS annotations:
+
+```
+output/
+├── init.lua              # Re-exports all modules
+├── types/
+│   ├── IHandle.lua       # Handle interface
+│   ├── Vector3.lua       # Vector3 class
+│   └── BufferedClass.lua # Base class for structs
+├── enums/
+│   └── *.lua             # Enum definitions
+├── structs/
+│   └── *.lua             # Struct classes (BufferedClass)
+├── classes/
+│   ├── Entity.lua        # Base entity class
+│   ├── Ped.lua           # Ped class (extends Entity)
+│   ├── Vehicle.lua       # Vehicle class (extends Entity)
+│   └── *.lua             # Other handle classes
+└── namespaces/
+    └── *.lua             # Static utility classes
+```
+
+With `--raw` flag, generates standalone functions (one file per namespace):
+
+```
+output/
+├── fxmanifest.lua
+├── enums/
+├── structs/
+└── natives/
+    └── *.lua             # Raw native function exports per namespace (module tables)
+```
+
+With `--raw --single-file` flags, generates all natives in a single file:
+
+```
+output/
+├── fxmanifest.lua
+├── enums/
+├── structs/
+└── natives.lua           # All native functions in one file (global functions)
 ```
 
 ### JSON
@@ -300,5 +440,8 @@ NativeCodeGen/
     ├── NativeCodeGen.TypeScript/    # TypeScript generation
     │   ├── Generation/              # Code generators
     │   └── Utilities/               # Name conversion, etc.
+    ├── NativeCodeGen.Lua/           # Lua generation
+    │   ├── Generation/              # Code generators
+    │   └── Utilities/               # Name conversion, etc.
     └── NativeCodeGen.Cli/           # Command-line interface
 ```

src/NativeCodeGen.Cli/Program.cs

@@ -40,7 +40,12 @@ static async Task<int> Main(string[] args)
 
         var rawOption = new Option<bool>(
             aliases: new[] { "--raw" },
-            description: "Generate raw native declarations without wrapper classes (typescript only)",
+            description: "Generate raw native declarations without wrapper classes",
+            getDefaultValue: () => false);
+
+        var singleFileOption = new Option<bool>(
+            aliases: new[] { "--single-file" },
+            description: "Generate all natives in a single file (requires --raw)",
             getDefaultValue: () => false);
 
         var strictOption = new Option<bool>(
@@ -53,12 +58,13 @@ static async Task<int> Main(string[] args)
         generateCommand.AddOption(formatOption);
         generateCommand.AddOption(namespacesOption);
         generateCommand.AddOption(rawOption);
+        generateCommand.AddOption(singleFileOption);
         generateCommand.AddOption(strictOption);
 
-        generateCommand.SetHandler(async (input, output, format, namespaces, raw, strict) =>
+        generateCommand.SetHandler(async (input, output, format, namespaces, raw, singleFile, strict) =>
         {
-            await Generate(input, output, format, namespaces, raw, strict);
-        }, inputOption, outputOption, formatOption, namespacesOption, rawOption, strictOption);
+            await Generate(input, output, format, namespaces, raw, singleFile, strict);
+        }, inputOption, outputOption, formatOption, namespacesOption, rawOption, singleFileOption, strictOption);
 
         // Validate command
         var validateCommand = new Command("validate", "Validate MDX files without generating output");
@@ -87,12 +93,19 @@ static async Task<int> Main(string[] args)
         return await rootCommand.InvokeAsync(args);
     }
 
-    static async Task Generate(string input, string output, string format, string[]? namespaces, bool raw, bool strict)
+    static async Task Generate(string input, string output, string format, string[]? namespaces, bool raw, bool singleFile, bool strict)
     {
         Console.WriteLine($"Generating {format} output...");
         Console.WriteLine($"Input: {input}");
         Console.WriteLine($"Output: {output}");
 
+        if (singleFile && !raw)
+        {
+            Console.Error.WriteLine("Error: --single-file requires --raw");
+            Environment.ExitCode = 1;
+            return;
+        }
+
         var (db, errors, warnings) = await ParseAllFiles(input);
 
         // Report issues
@@ -126,6 +139,7 @@ static async Task Generate(string input, string output, string format, string[]?
         var options = new ExportOptions
         {
             Raw = raw,
+            SingleFile = singleFile,
             Strict = strict,
             Namespaces = namespaces?.Length > 0
                 ? new HashSet<string>(namespaces.SelectMany(n => n.Split(',')), StringComparer.OrdinalIgnoreCase)
@@ -225,21 +239,14 @@ static async Task Validate(string input, bool strict)
 
                 if (result.Value != null)
                 {
-                    allNatives.Add(result.Value);
-
-                    foreach (var enumName in result.Value.UsedEnums)
+                    // Resolve enum types for parameters and return type
+                    foreach (var param in result.Value.Parameters)
                     {
-                        if (!enumRegistry.Contains(enumName))
-                        {
-                            allWarnings.Add(new ParseWarning
-                            {
-                                FilePath = file,
-                                Line = 1,
-                                Column = 1,
-                                Message = $"Referenced enum '{enumName}' not found in registry"
-                            });
-                        }
+                        param.Type.ResolveEnumType(enumRegistry.GetBaseType);
                     }
+                    result.Value.ReturnType.ResolveEnumType(enumRegistry.GetBaseType);
+
+                    allNatives.Add(result.Value);
                 }
 
                 Interlocked.Increment(ref processedCount);
@@ -261,18 +268,6 @@ static async Task Validate(string input, bool strict)
             .GroupBy(n => n.Namespace, StringComparer.OrdinalIgnoreCase)
             .ToDictionary(g => g.Key, g => g.ToList(), StringComparer.OrdinalIgnoreCase);
 
-        // Track enum usage (single-threaded, after parallel processing)
-        foreach (var native in allNatives)
-        {
-            foreach (var enumName in native.UsedEnums)
-            {
-                if (enumRegistry.Contains(enumName))
-                {
-                    enumRegistry.TrackUsage(enumName, native.Hash);
-                }
-            }
-        }
-
         // Track struct usage - check parameter types for struct references
         var structDict = structRegistry.GetAllStructs();
         foreach (var native in allNatives)
@@ -298,7 +293,6 @@ static async Task Validate(string input, bool strict)
             .OrderBy(n => n.Name)
             .ToList();
 
-        // Update enums with usage tracking
         db.Enums = enumRegistry.GetAllEnums();
 
         return (db, allErrors.ToList(), allWarnings.ToList());

src/NativeCodeGen.Core/Export/BaseExporter.cs

@@ -24,7 +24,12 @@ public void Export(NativeDatabase db, string outputPath, ExportOptions options)
             };
         }
 
-        Generator.Generate(db, outputPath, !options.Raw);
+        var generatorOptions = new GeneratorOptions
+        {
+            UseClasses = !options.Raw,
+            SingleFile = options.SingleFile
+        };
+        Generator.Generate(db, outputPath, generatorOptions);
 
         // Output any warnings from code generation
         foreach (var warning in Generator.Warnings)