lt-script 1.0.0 → 1.0.3

package/README.md

@@ -1,33 +1,274 @@
-# LT Language Compiler
+# LT Language
 
-A compiler for the LT language, targeting FiveM Lua.
+<p align="center">
+  <img src="https://img.shields.io/npm/v/lt-script?color=blue&label=npm" alt="npm version">
+  <img src="https://img.shields.io/github/license/laot7490/lt-script" alt="license">
+  <img src="https://img.shields.io/badge/FiveM-Ready-green" alt="FiveM Ready">
+</p>
 
-## Installation
+**LT** is a modern, developer-friendly language that compiles to FiveM Lua. It brings TypeScript-like syntax, modern JavaScript features, and FiveM-specific sugar to the Lua ecosystem — making your scripts cleaner, safer, and more enjoyable to write.
+
+## ✨ Why LT?
+
+Writing vanilla Lua for FiveM can be tedious. LT fixes that with:
+
+- **Modern Syntax**: Arrow functions, destructuring, spread operator, optional chaining
+- **FiveM Sugar**: Built-in `thread`, `wait`, `netevent`, `addcmd`, `export` keywords
+- **Type Safety**: Static type checking catches errors at compile time
+- **Clean Code**: No more boilerplate — just write what you mean
+
+## 📦 Installation
 
 ```bash
-npm install -g lt-compiler
+npm install -g lt-script
 ```
 
-## Usage
+## 🚀 Quick Start
 
-```bash
-ltc help
+Create a file called `main.lt`:
+
+```typescript
+// Variables with modern scoping
+let health: number = 100
+const MAX_HEALTH = 200
+
+// Arrow functions
+let double = (x) => x * 2
+
+// String interpolation
+print("Health: $health / $MAX_HEALTH")
+
+// FiveM thread with wait
+thread
+    loop (true)
+        wait 1000
+        print("Tick...")
+    end
+end
+
+// Register a command easily
+addcmd "heal" (source, args)
+    health = MAX_HEALTH
+    print("Player healed!")
+end
+
+// Network events without boilerplate
+netevent "player:spawn" (data)
+    print("Player spawned: $data")
+end
 ```
 
-### Compiler
+Compile it:
 
 ```bash
-ltc build <sourceDir> <outDir>
+ltc build .
 ```
 
-### Watch Mode
+Output `main.lua`:
+```lua
+local health = 100
+local MAX_HEALTH <const> = 200
 
-```bash
-ltc watch <sourceDir> <outDir>
+local double = function(x) return x * 2 end
+
+print("Health: " .. tostring(health) .. " / " .. tostring(MAX_HEALTH))
+
+CreateThread(function()
+    while true do
+        Wait(1000)
+        print("Tick...")
+    end
+end)
+
+RegisterCommand("heal", function(source, args)
+    health = MAX_HEALTH
+    print("Player healed!")
+end, false)
+
+RegisterNetEvent("player:spawn")
+AddEventHandler("player:spawn", function(data)
+    print("Player spawned: " .. tostring(data))
+end)
+```
+
+## 🛠️ CLI Commands
+
+| Command | Description |
+|---------|-------------|
+| `ltc build <dir>` | Compile all `.lt` files in directory |
+| `ltc watch <dir>` | Watch mode — auto-compile on save |
+
+## 🎯 Feature Highlights
+
+### Variables & Constants
+```typescript
+var globalVar = "I am global"     // Global variable
+let localVar = 10                 // Local variable
+const MAX = 100                   // Constant (Lua 5.4 <const>)
+```
+
+### Type System
+```typescript
+// Explicit types
+let name: string = "John"
+let age: number = 25
+let active: boolean = true
+
+// Type Aliases
+interface PlayerData = {
+    name: string,
+    level: number,
+    isVip: boolean
+}
+
+func Calculate(a: number, b: number)
+    return a + b
+end
+```
+
+### Arrow Functions
+```typescript
+let add = (a, b) => a + b
+let greet = (name) => print("Hello, $name!")
+```
+
+### Destructuring
+```typescript
+let player = { name: "Alex", level: 50 }
+let { name, level } = player
+
+let coords = [100, 200, 300]
+let [x, y, z] = coords
+```
+
+### Optional Chaining & Null Coalescing
+```typescript
+let job = player?.metadata?.job?.label ?? "Unemployed"
+```
+
+### Vector Literals
+```typescript
+let pos = <100.0, 50.0, 20.0>   // vector3
+let rot = <0.0, 90.0>           // vector2
+```
+
+### Switch/Case
+```typescript
+switch weather
+    case "RAIN", "THUNDER"
+        print("Stay inside!")
+    case "CLEAR"
+        print("Nice day!")
+    default
+        print("Unknown weather")
+end
+```
+
+### For Loops
+```typescript
+// Range loop
+for i in 1..10 do
+    print(i)
+end
+
+// Range with step
+for i in 10..1 by -1 do
+    print(i)
+end
+
+// C-style loop
+for i = 0, 100, 5 do
+    print(i)
+end
+```
+
+### FiveM Specific
+
+#### Threads & Wait
+```typescript
+thread
+    wait 1000
+    print("After 1 second")
+end
+```
+
+#### Events
+```typescript
+netevent "myResource:sync" (data)
+    -- RegisterNetEvent + AddEventHandler
+end
+
+event "localEvent" (data)
+    -- AddEventHandler only
+end
+```
+
+#### Commands
+```typescript
+addcmd "teleport" (source, args)
+    print("Teleporting...")
+end
+```
+
+#### Exports
+```typescript
+export func GetPlayerData(id)
+    return players[id]
+end
 ```
 
-## Features
+#### Guard Statements
+```typescript
+guard player return              // Early return if nil/false
+guard player.job == "police" return print("Access denied")
+
+// Guard with else block
+guard isValid else
+    print("Invalid state")
+    return
+end
+```
+
+#### Try/Catch
+```typescript
+try
+    riskyOperation()
+catch err
+    print("Error: $err")
+end
+```
+
+## 📁 Project Structure
+
+```
+my-resource/
+├── src/
+│   ├── client.lt
+│   └── server.lt
+├── client.lua        (generated)
+├── server.lua        (generated)
+└── fxmanifest.lua
+```
+
+Run `ltc watch .` in your resource folder for automatic compilation.
+
+## 🔧 VS Code Extension
+
+Get syntax highlighting and IntelliSense for `.lt` files:
+
+**[LT Language Extension](https://marketplace.visualstudio.com/items?itemName=laot.lt-language)**
+
+- Syntax Highlighting
+- IntelliSense for Variables & Functions
+- **Native FiveM Autocompletion** (GetHashKey, CreateVehicle, etc.)
+- Snippets for common patterns
+
+## 📜 License
+
+MIT © [LaotScripts](https://github.com/laot7490)
+
+---
 
-- Transpiles LT to Lua 5.4 (FiveM compatible)
-- Supports static typing syntax (transpiled to comments or checked)
-- FiveM native function support
+<p align="center">
+  Made with ❤️ for the FiveM community
+</p>

package/dist/cli/ltc.js

@@ -2,7 +2,7 @@
 import { compile } from '../index.js';
 import * as fs from 'fs';
 import * as path from 'path';
-import { getAllFiles, ensureDirectoryExistence } from './utils.js';
+import { getAllFiles, ensureDirectoryExistence, style } from './utils.js';
 const args = process.argv.slice(2);
 const command = args[0];
 if (!command) {
@@ -17,52 +17,59 @@ switch (command) {
         handleBuild(args.slice(1));
         break;
     default:
-        console.error(`Unknown command: ${command}`);
+        console.error(style.red(`\n[LT] Error: Unknown command '${command}'`));
         printUsage();
         process.exit(1);
 }
 function printUsage() {
     console.log(`
-Usage:
-  ltc watch <targetDir>               # Watches <targetDir>/src and builds to <targetDir>/build
-  ltc watch <sourceDir> <outDir>      # Watches <sourceDir> and builds to <outDir>
-  ltc build <targetDir>               # Builds <targetDir>/src to <targetDir>/build once
-  ltc build <sourceDir> <outDir>      # Builds <sourceDir> to <outDir> once
+${style.bold('LT Language Compiler')} ${style.gray('(v1.0.0)')}
+${style.gray('----------------------------------------')}
+
+${style.bold('Usage:')}
+  ${style.cyan('ltc watch')} ${style.yellow('<targetDir>')}
+  ${style.cyan('ltc watch')} ${style.yellow('<srcDir> <outDir>')}
+  ${style.cyan('ltc build')} ${style.yellow('<targetDir>')}
+  ${style.cyan('ltc build')} ${style.yellow('<srcDir> <outDir>')}
+
+${style.bold('Examples:')}
+  ${style.gray('$')} ltc watch lt-fuel
+  ${style.gray('$')} ltc build src dist
 `);
 }
 function parsePaths(cmdArgs) {
-    if (cmdArgs.length === 0)
+    if (cmdArgs.length === 0) {
+        console.error(style.red(`\n[LT] Error: Missing arguments.`));
+        printUsage();
         return null;
+    }
     let srcDir = '';
     let outDir = '';
     const target = cmdArgs[0];
     if (cmdArgs.length === 1) {
-        // Convention mode: ltc watch lt-fuel
         const potentialSrc = path.join(target, 'src');
         if (fs.existsSync(potentialSrc) && fs.statSync(potentialSrc).isDirectory()) {
             srcDir = potentialSrc;
-            outDir = path.join(target, 'build');
-            console.log(`[LT] Auto-detected structure. Source: ${srcDir}, Output: ${outDir}`);
+            outDir = target;
+            console.log(`${style.blue('[LT]')} Auto-detected project structure:`);
+            console.log(`     ${style.gray('Source:')} ${srcDir}`);
+            console.log(`     ${style.gray('Output:')} ${outDir}`);
         }
         else {
-            // Fallback? Or strict? 
-            // If just passing a folder that HAS .lt files but no src/ folder?
-            // Let's assume strict src/build convention for single argument or error
-            console.error(`[LT] Error: Could not find 'src' directory in '${target}'.`);
-            console.error(`     Please use 'ltc ${command} <sourceDir> <outDir>' for explicit paths.`);
+            console.error(style.red(`\n[LT] Error: Could not find 'src' directory in '${target}'.`));
+            console.error(`     Expected: ${potentialSrc}`);
+            console.error(`     To specify custom paths, use: ${style.cyan('ltc ' + command + ' <srcDir> <outDir>')}`);
             return null;
         }
     }
     else {
-        // Explicit mode
         srcDir = cmdArgs[0];
         outDir = cmdArgs[1];
     }
-    // Resolve to absolute
     srcDir = path.resolve(srcDir);
     outDir = path.resolve(outDir);
     if (!fs.existsSync(srcDir)) {
-        console.error(`[LT] Error: Source directory '${srcDir}' does not exist.`);
+        console.error(style.red(`\n[LT] Error: Source directory '${srcDir}' does not exist.`));
         return null;
     }
     return { srcDir, outDir };
@@ -71,64 +78,67 @@ function compileFile(srcPath, srcRoot, outRoot) {
     try {
         const relative = path.relative(srcRoot, srcPath);
         const outPath = path.join(outRoot, relative.replace(/\.lt$/, '.lua'));
-        console.log(`[LT] Compiling: ${relative}`);
+        process.stdout.write(`${style.blue('[LT]')} Compiling ${style.yellow(relative)}... `);
         const content = fs.readFileSync(srcPath, 'utf-8');
         const start = performance.now();
         const lua = compile(content);
         const end = performance.now();
         ensureDirectoryExistence(outPath);
         fs.writeFileSync(outPath, lua, 'utf8');
-        console.log(`[LT] ✓ Success (${(end - start).toFixed(2)}ms)`);
+        console.log(style.green(`✓ ${(end - start).toFixed(0)}ms`));
     }
     catch (e) {
-        console.error(`[LT] ✗ Error compiling ${srcPath}:`);
-        console.error(e.message);
+        console.log(style.red('✗'));
+        console.error(`${style.red('[LT] Error compiling')} ${style.bold(srcPath)}:`);
+        console.error(style.yellow(e.message));
     }
 }
 function handleBuild(cmdArgs) {
+    console.log(style.bold(`\nStarting Build...`));
     const paths = parsePaths(cmdArgs);
     if (!paths)
         process.exit(1);
     const { srcDir, outDir } = paths;
-    console.log(`[LT] Building from '${srcDir}' to '${outDir}'...`);
     const files = getAllFiles(srcDir, '.lt');
+    if (files.length === 0) {
+        console.log(style.yellow(`[LT] No .lt files found in ${srcDir}`));
+        return;
+    }
     files.forEach(file => compileFile(file, srcDir, outDir));
-    console.log(`[LT] Build complete. ${files.length} files processed.`);
+    console.log(style.green(`\n[LT] Build complete. ${files.length} files processed.`));
 }
 function handleWatch(cmdArgs) {
+    console.log(style.bold(`\nStarting Watch Mode...`));
     const paths = parsePaths(cmdArgs);
     if (!paths)
         process.exit(1);
     const { srcDir, outDir } = paths;
-    // Initial build
     handleBuild(cmdArgs);
-    console.log(`[LT] Watching for changes in '${srcDir}'...`);
+    console.log(style.blue(`\n[LT] Watching for changes in '${srcDir}'...`));
+    console.log(style.gray(`     (Press Ctrl+C to stop)`));
     let fsWait = null;
-    // Recursive watch
     fs.watch(srcDir, { recursive: true }, (event, filename) => {
         if (!filename)
             return;
-        // Windows/Mac returning filename
         if (!filename.endsWith('.lt'))
-            return; // Ignore non-lt files
+            return;
         const fullPath = path.join(srcDir, filename);
         if (fsWait)
             clearTimeout(fsWait);
         fsWait = setTimeout(() => {
             fsWait = null;
             if (fs.existsSync(fullPath)) {
-                // Modified or Created
+                console.log(style.gray(`\n[LT] File changed: ${filename}`));
                 compileFile(fullPath, srcDir, outDir);
             }
             else {
-                // Deleted
                 const relative = path.relative(srcDir, fullPath);
                 const outPath = path.join(outDir, relative.replace(/\.lt$/, '.lua'));
                 if (fs.existsSync(outPath)) {
                     fs.unlinkSync(outPath);
-                    console.log(`[LT] Removed: ${relative.replace(/\.lt$/, '.lua')}`);
+                    console.log(style.red(`[LT] Removed: ${relative.replace(/\.lt$/, '.lua')}`));
                 }
             }
-        }, 100); // 100ms debounce
+        }, 100);
     });
 }

package/dist/cli/utils.d.ts

@@ -1,2 +1,42 @@
 export declare function getAllFiles(dir: string, extension: string, fileList?: string[]): string[];
 export declare function ensureDirectoryExistence(filePath: string): void;
+export declare const colors: {
+    reset: string;
+    bright: string;
+    dim: string;
+    underscore: string;
+    blink: string;
+    reverse: string;
+    hidden: string;
+    fg: {
+        black: string;
+        red: string;
+        green: string;
+        yellow: string;
+        blue: string;
+        magenta: string;
+        cyan: string;
+        white: string;
+        gray: string;
+    };
+    bg: {
+        black: string;
+        red: string;
+        green: string;
+        yellow: string;
+        blue: string;
+        magenta: string;
+        cyan: string;
+        white: string;
+    };
+};
+export declare const style: {
+    green: (text: string) => string;
+    red: (text: string) => string;
+    yellow: (text: string) => string;
+    blue: (text: string) => string;
+    cyan: (text: string) => string;
+    gray: (text: string) => string;
+    bold: (text: string) => string;
+    white: (text: string) => string;
+};

package/dist/cli/utils.js

@@ -24,3 +24,43 @@ export function ensureDirectoryExistence(filePath) {
     ensureDirectoryExistence(dirname);
     fs.mkdirSync(dirname);
 }
+export const colors = {
+    reset: "\x1b[0m",
+    bright: "\x1b[1m",
+    dim: "\x1b[2m",
+    underscore: "\x1b[4m",
+    blink: "\x1b[5m",
+    reverse: "\x1b[7m",
+    hidden: "\x1b[8m",
+    fg: {
+        black: "\x1b[30m",
+        red: "\x1b[31m",
+        green: "\x1b[32m",
+        yellow: "\x1b[33m",
+        blue: "\x1b[34m",
+        magenta: "\x1b[35m",
+        cyan: "\x1b[36m",
+        white: "\x1b[37m",
+        gray: "\x1b[90m",
+    },
+    bg: {
+        black: "\x1b[40m",
+        red: "\x1b[41m",
+        green: "\x1b[42m",
+        yellow: "\x1b[43m",
+        blue: "\x1b[44m",
+        magenta: "\x1b[45m",
+        cyan: "\x1b[46m",
+        white: "\x1b[47m",
+    }
+};
+export const style = {
+    green: (text) => `${colors.fg.green}${text}${colors.reset}`,
+    red: (text) => `${colors.fg.red}${text}${colors.reset}`,
+    yellow: (text) => `${colors.fg.yellow}${text}${colors.reset}`,
+    blue: (text) => `${colors.fg.blue}${text}${colors.reset}`,
+    cyan: (text) => `${colors.fg.cyan}${text}${colors.reset}`,
+    gray: (text) => `${colors.fg.gray}${text}${colors.reset}`,
+    bold: (text) => `${colors.bright}${text}${colors.reset}`,
+    white: (text) => `${colors.fg.white}${text}${colors.reset}`,
+};

package/dist/compiler/codegen/LuaEmitter.js

@@ -148,6 +148,9 @@ export class LuaEmitter {
             case AST.NodeType.CommandStmt:
                 this.emitCommandStmt(stmt);
                 break;
+            case AST.NodeType.TypeDecl:
+                // Type declarations are compile-time only, no Lua output
+                break;
             default:
                 // Expression statement
                 // Optimize UpdateExpr used as statement (i++)
@@ -299,7 +302,13 @@ export class LuaEmitter {
                 this.emitStatement(s);
             }
         }
-        this.line('return');
+        // Emit return with optional value
+        if (stmt.returnValue) {
+            this.line(`return ${this.emitExpr(stmt.returnValue)}`);
+        }
+        else {
+            this.line('return');
+        }
         this.indent--;
         this.line('end');
     }
@@ -509,11 +518,18 @@ export class LuaEmitter {
         let op = expr.operator;
         if (op === '!=')
             op = '~=';
+        if (op === '&&')
+            op = 'and';
+        if (op === '||')
+            op = 'or';
         return `(${left} ${op} ${right})`;
     }
     emitUnaryExpr(expr) {
-        const space = expr.operator === 'not' ? ' ' : '';
-        return `${expr.operator}${space}${this.emitExpr(expr.operand)}`;
+        let op = expr.operator;
+        if (op === '!')
+            op = 'not';
+        const space = (op === 'not' || op === 'and' || op === 'or') ? ' ' : '';
+        return `${op}${space}${this.emitExpr(expr.operand)}`;
     }
     emitCallExpr(expr) {
         const callee = this.emitExpr(expr.callee);

package/dist/compiler/lexer/Lexer.js

@@ -7,10 +7,12 @@ export class Lexer {
     source;
     tokens = [];
     pos = 0;
-    line = 1;
-    column = 1;
+    line;
+    column;
     constructor(source) {
         this.source = source;
+        this.line = 1;
+        this.column = 1;
     }
     tokenize() {
         while (!this.isEOF()) {
@@ -75,6 +77,8 @@ export class Lexer {
         // Two-char operators
         const twoChar = ch + next;
         const twoCharMap = {
+            '&&': TokenType.AND,
+            '||': TokenType.OR,
             '=>': TokenType.ARROW,
             '?.': TokenType.OPT_DOT,
             '?[': TokenType.OPT_BRACKET,
@@ -120,6 +124,7 @@ export class Lexer {
             '.': TokenType.DOT,
             ':': TokenType.COLON,
             ';': TokenType.SEMICOLON,
+            '!': TokenType.NOT,
             '?': TokenType.QUESTION,
         };
         if (singleCharMap[ch]) {

package/dist/compiler/lexer/Token.d.ts

@@ -48,7 +48,8 @@ export declare enum TokenType {
     EVENT = "EVENT",
     NETEVENT = "NETEVENT",
     EXPORT = "EXPORT",
-    COMMAND = "COMMAND",
+    ADDCMD = "ADDCMD",
+    INTERFACE = "INTERFACE",
     AND = "AND",
     OR = "OR",
     NOT = "NOT",

package/dist/compiler/lexer/Token.js

@@ -55,7 +55,9 @@ export var TokenType;
     TokenType["EVENT"] = "EVENT";
     TokenType["NETEVENT"] = "NETEVENT";
     TokenType["EXPORT"] = "EXPORT";
-    TokenType["COMMAND"] = "COMMAND";
+    TokenType["ADDCMD"] = "ADDCMD";
+    // Type System
+    TokenType["INTERFACE"] = "INTERFACE";
     // Logical
     TokenType["AND"] = "AND";
     TokenType["OR"] = "OR";
@@ -157,7 +159,9 @@ export const KEYWORDS = {
     event: TokenType.EVENT,
     netevent: TokenType.NETEVENT,
     export: TokenType.EXPORT,
-    command: TokenType.COMMAND,
+    addcmd: TokenType.ADDCMD,
+    // Type System
+    interface: TokenType.INTERFACE,
     // Logical
     and: TokenType.AND,
     or: TokenType.OR,

package/dist/compiler/parser/AST.d.ts

@@ -28,6 +28,7 @@ export declare enum NodeType {
     EmitStmt = "EmitStmt",
     EventHandler = "EventHandler",
     ExportDecl = "ExportDecl",
+    TypeDecl = "TypeDecl",
     BinaryExpr = "BinaryExpr",
     UnaryExpr = "UnaryExpr",
     UpdateExpr = "UpdateExpr",// ++, --
@@ -83,10 +84,20 @@ export interface Parameter {
     typeAnnotation?: string;
     defaultValue?: Expression;
 }
+export interface TypeField {
+    name: string;
+    type: string;
+}
+export interface TypeDecl extends Statement {
+    kind: NodeType.TypeDecl;
+    name: Identifier;
+    fields: TypeField[];
+}
 export interface AssignmentStmt extends Statement {
     kind: NodeType.AssignmentStmt;
     targets: Expression[];
     values: Expression[];
+    typeAnnotation?: string;
 }
 export interface CompoundAssignment extends Statement {
     kind: NodeType.CompoundAssignment;
@@ -151,6 +162,7 @@ export interface GuardStmt extends Statement {
     kind: NodeType.GuardStmt;
     condition: Expression;
     elseBody?: Statement[];
+    returnValue?: Expression;
 }
 export interface SafeCallStmt extends Statement {
     kind: NodeType.SafeCallStmt;