lt-script 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 LT Language Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,33 @@
+# LT Language Compiler
+
+A compiler for the LT language, targeting FiveM Lua.
+
+## Installation
+
+```bash
+npm install -g lt-compiler
+```
+
+## Usage
+
+```bash
+ltc help
+```
+
+### Compiler
+
+```bash
+ltc build <sourceDir> <outDir>
+```
+
+### Watch Mode
+
+```bash
+ltc watch <sourceDir> <outDir>
+```
+
+## Features
+
+- Transpiles LT to Lua 5.4 (FiveM compatible)
+- Supports static typing syntax (transpiled to comments or checked)
+- FiveM native function support

package/dist/cli/ltc.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/ltc.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+import { compile } from '../index.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import { getAllFiles, ensureDirectoryExistence } from './utils.js';
+const args = process.argv.slice(2);
+const command = args[0];
+if (!command) {
+    printUsage();
+    process.exit(1);
+}
+switch (command) {
+    case 'watch':
+        handleWatch(args.slice(1));
+        break;
+    case 'build':
+        handleBuild(args.slice(1));
+        break;
+    default:
+        console.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
+`);
+}
+function parsePaths(cmdArgs) {
+    if (cmdArgs.length === 0)
+        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}`);
+        }
+        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.`);
+            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.`);
+        return null;
+    }
+    return { srcDir, outDir };
+}
+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}`);
+        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)`);
+    }
+    catch (e) {
+        console.error(`[LT] ✗ Error compiling ${srcPath}:`);
+        console.error(e.message);
+    }
+}
+function handleBuild(cmdArgs) {
+    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');
+    files.forEach(file => compileFile(file, srcDir, outDir));
+    console.log(`[LT] Build complete. ${files.length} files processed.`);
+}
+function handleWatch(cmdArgs) {
+    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}'...`);
+    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
+        const fullPath = path.join(srcDir, filename);
+        if (fsWait)
+            clearTimeout(fsWait);
+        fsWait = setTimeout(() => {
+            fsWait = null;
+            if (fs.existsSync(fullPath)) {
+                // Modified or Created
+                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')}`);
+                }
+            }
+        }, 100); // 100ms debounce
+    });
+}

package/dist/cli/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function getAllFiles(dir: string, extension: string, fileList?: string[]): string[];
+export declare function ensureDirectoryExistence(filePath: string): void;

package/dist/cli/utils.js

@@ -0,0 +1,26 @@
+import * as fs from 'fs';
+import * as path from 'path';
+export function getAllFiles(dir, extension, fileList = []) {
+    const files = fs.readdirSync(dir);
+    files.forEach(file => {
+        const filePath = path.join(dir, file);
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+            getAllFiles(filePath, extension, fileList);
+        }
+        else {
+            if (path.extname(file) === extension) {
+                fileList.push(filePath);
+            }
+        }
+    });
+    return fileList;
+}
+export function ensureDirectoryExistence(filePath) {
+    const dirname = path.dirname(filePath);
+    if (fs.existsSync(dirname)) {
+        return;
+    }
+    ensureDirectoryExistence(dirname);
+    fs.mkdirSync(dirname);
+}

package/dist/cli/watch.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/watch.js

@@ -0,0 +1,42 @@
+import { compile } from '../index.js';
+import * as fs from 'fs';
+const args = process.argv.slice(2);
+if (args.length === 0) {
+    console.error("Usage: node watch.js <file.lt>");
+    process.exit(1);
+}
+const sourcePath = args[0];
+const targetPath = sourcePath.replace(/\.lt$/, '.lua');
+if (!fs.existsSync(sourcePath)) {
+    console.error(`Error: File '${sourcePath}' not found.`);
+    process.exit(1);
+}
+console.log(`[LT] Watching '${sourcePath}'...`);
+function recompile() {
+    try {
+        console.log(`[LT] File changed. Compiling...`);
+        const content = fs.readFileSync(sourcePath, 'utf-8');
+        const start = performance.now();
+        const lua = compile(content);
+        const end = performance.now();
+        fs.writeFileSync(targetPath, lua, 'utf8');
+        console.log(`[LT] ✓ Success! (${(end - start).toFixed(2)}ms) -> ${targetPath}`);
+    }
+    catch (e) {
+        console.error(`[LT] ✗ Error: ${e.message}`);
+    }
+}
+// Initial compile
+recompile();
+// Watch for changes with debouncing and error recovery
+let fsWait = null;
+fs.watch(sourcePath, (event) => {
+    if (event === 'change') {
+        if (fsWait)
+            clearTimeout(fsWait);
+        fsWait = setTimeout(() => {
+            fsWait = null;
+            recompile();
+        }, 150); // Increased debounce for stability
+    }
+});

package/dist/compiler/codegen/LuaEmitter.d.ts

@@ -0,0 +1,59 @@
+import * as AST from '../parser/AST.js';
+/**
+ * LT → Lua Code Emitter
+ * Generates clean, readable Lua 5.4 code
+ */
+export declare class LuaEmitter {
+    private indent;
+    private output;
+    private tempId;
+    private usedVars;
+    private nextTemp;
+    emit(program: AST.Program): string;
+    private analyzeUsages;
+    private emitStatement;
+    private emitVariableDecl;
+    private hasSideEffects;
+    private emitArrayLiteral;
+    private emitAssignment;
+    private emitCompoundAssignment;
+    private emitIfStmt;
+    private emitForStmt;
+    private emitRangeForStmt;
+    private emitWhileStmt;
+    private emitReturnStmt;
+    private emitGuardStmt;
+    private emitSafeCall;
+    private emitThreadStmt;
+    private emitLoopStmt;
+    private emitWaitStmt;
+    private emitTimeoutStmt;
+    private emitIntervalStmt;
+    private emitTryCatch;
+    private emitEmitStmt;
+    private emitEventHandler;
+    private emitFunctionDecl;
+    private emitSwitchStmt;
+    private emitExportDecl;
+    private emitCommandStmt;
+    private emitExpr;
+    private emitInterpolatedString;
+    private emitBinaryExpr;
+    private emitUnaryExpr;
+    private emitCallExpr;
+    private emitMemberExpr;
+    private emitOptionalChain;
+    private emitNullCoalesce;
+    private emitArrowFunc;
+    private emitFunctionExpr;
+    private emitTableLiteral;
+    private emitVectorLiteral;
+    private emitUpdateExpr;
+    private emitConditionalExpr;
+    private emitStatementInline;
+    private hasContinue;
+    private emitBlock;
+    private emitBlockWithContinue;
+    private line;
+    private isSimpleExpr;
+}