typenative 0.0.9 → 0.0.11

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 danisss9
+Copyright (c) 2025 danisss9
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -2,18 +2,57 @@
 
 Build native applications using Typescript.
 
+## PreRequisites
+
+- Go 1.21 or newer.
+
 ## Get Started
 
 - Write a file `test.ts` with content `console.log('Hello World!');` or any other message
-- Run `npx typenative --source test.ts`
-- Run `dist/native.exe` in terminal and see your message 
+- Run `npx typenative --source test.ts --script`
+- See your message in the terminal
+
+## Typescript Syntax Support
 
-## Todo 
+TypeNative currently supports a subset of TypeScript syntax elements that are transpiled to Go code:
 
-Develpment:
-- Everything (👉ﾟヮﾟ)👉
+| Feature | Supported | Notes |
+|---------|:---------:|-------|
+| **Basic Types** |  |  |
+| number | ✅ | Transpiled to `float64` |
+| boolean | ✅ | Transpiled to `bool` |
+| string | ✅ | |
+| null | ✅ |  |
+| any | ✅ | Used for type inference |
+| **Variables** |  |  |
+| Variable declarations | ✅ | `let` and `const` |
+| **Operators** |  |  |
+| Arithmetic operators | ✅ | `+`, `-`, etc. |
+| Comparison operators | ✅ | `==`, `!=`, etc. |
+| Logical operators | ✅ | `&&`, `\|\|` |
+| Increment/Decrement | ✅ | `++`, `--` |
+| **Control Flow** |  |  |
+| For loops | ✅ | Standard `for` loops |
+| For...of loops | ✅ | Iteration over arrays |
+| While loops | ✅ | Transpiled to Go's `for` loops |
+| Do...while loops | ✅ | Implemented with conditional break |
+| If/Else statements | ✅ | Fully supported |
+| Switch statements | ✅ | Case and default statements |
+| **Data Structures** |  |  |
+| Arrays | ✅ | Basic array operations |
+| Array methods | ✅ | `push` supported |
+| **Functions** |  |  |
+| console.log | ✅ | Mapped to `fmt.Println` |
+| console.time/timeEnd | ✅ | Performance measurement |
+| Math.random | ✅ | Mapped to Go's `rand.Float64()` |
+| Math.floor | ✅ | Mapped to Go's `math.Floor()` |
+| **Unsupported Features** |  |  |
+| Classes | ❌ | Not implemented |
+| Interfaces | ❌ | Not implemented |
+| Functions | ❌ | Custom function definitions not supported |
+| Arrow Functions | ❌ | Not implemented |
+| Async/Await | ❌ | Not implemented |
+| Modules/Imports | ❌ | Not implemented |
+| Generics | ❌ | Not implemented |
 
-Examples:
-- Database (using sqlite)
-- Web Server (using libmicrohttpd)
-- UI App (using webview)
+TypeNative is currently in early development and new features are being added regularly.

package/bin/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import inquirer from 'inquirer';
-import shell from 'shelljs';
 import fs from 'fs-extra';
 import path from 'path';
-import { transpileToC } from './transpiler.js';
+import { execa } from 'execa';
+import { transpileToNative } from './transpiler.js';
 import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -34,14 +34,22 @@ const __dirname = path.dirname(__filename);
     const tsCode = answers.tsCode
         ? answers.tsCode
         : await fs.readFile(target ?? answers.path, { encoding: 'utf-8' });
-    const cCode = transpileToC(tsCode);
+    const nativeCode = transpileToNative(tsCode);
     await fs.ensureDir('dist');
-    await fs.writeFile('dist/code.c', cCode, { encoding: 'utf-8' });
-    shell.exec(`${__dirname}/tcc/tcc.exe -g ${path.resolve()}/dist/code.c -o ${path.resolve()}/dist/native.exe ${scriptMode ? '-run' : ''}`);
+    await fs.writeFile('dist/code.go', nativeCode, { encoding: 'utf-8' });
+    await execa('go build -o dist/native.exe dist/code.go');
+    // await fs.remove('dist/code.go');
     if (answers.output) {
         await fs.copy('dist/native.exe', answers.output, { overwrite: true });
+        await fs.remove('dist/native.exe');
     }
-    if (!scriptMode) {
+    if (scriptMode) {
+        await execa('dist/native.exe', {
+            stdio: 'inherit'
+        });
+        await fs.remove('dist/native.exe');
+    }
+    else {
         console.log('DONE');
     }
 })();

package/bin/transpiler.js

@@ -1,17 +1,20 @@
 import ts from 'typescript';
 let TypeCheker;
-export function transpileToC(code) {
+let importedPackages = new Set();
+export function transpileToNative(code) {
     const sourceFile = ts.createSourceFile('main.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
     TypeCheker = ts.createProgram(['main.ts'], {}).getTypeChecker();
-    return `#include <stdio.h>
-#include <string.h>
+    importedPackages.clear();
+    const transpiledCode = visit(sourceFile);
+    return `package main
 
-int main() {
-    ${visit(sourceFile)}return 0;
-}
-    `;
+${[...importedPackages].map((pkg) => `import "${pkg}"`).join('\n')}
+
+func main() {
+    ${transpiledCode.trim()}
+}`;
 }
-export function visit(node) {
+export function visit(node, inline = false, extraBlockContent = '') {
     let code = '';
     if (ts.isIdentifier(node)) {
         return node.text;
@@ -20,26 +23,44 @@ export function visit(node) {
         return `"${node.text}"`;
     }
     else if (ts.isNumericLiteral(node)) {
-        return `${node.text}`;
+        return `float64(${node.text})`;
     }
     else if (ts.isToken(node) && node.kind === ts.SyntaxKind.TrueKeyword) {
-        return `1`;
+        return `true`;
     }
     else if (ts.isToken(node) && node.kind === ts.SyntaxKind.FalseKeyword) {
-        return `0`;
+        return `false`;
+    }
+    else if (ts.isArrayLiteralExpression(node)) {
+        const type = ts.isVariableDeclaration(node.parent) ? getType(node.parent.type, true) : '';
+        return `[]${type} {${node.elements.map((e) => visit(e)).join(', ')}}`;
+    }
+    else if (ts.isBlock(node)) {
+        return `{\n\t\t${node.statements.map((n) => visit(n)).join('\t')}${extraBlockContent}}${inline ? '' : '\n\t'}`;
+    }
+    else if (ts.isElementAccessExpression(node)) {
+        return `${visit(node.expression)}[int(${visit(node.argumentExpression)})]`;
     }
     else if (ts.isPropertyAccessExpression(node)) {
-        return `${visit(node.expression)}.${visit(node.name)}`;
+        const leftSide = visit(node.expression);
+        const rightSide = visit(node.name);
+        return getAcessString(leftSide, rightSide);
     }
     else if (ts.isVariableDeclaration(node)) {
-        const type = getCType(node.type);
-        const initializer = node.initializer ? ` = ${visit(node.initializer)}` : '';
-        return `${type.typeStr} ${visit(node.name)}${type.arrayStr}${initializer}`;
+        const type = getType(node.type);
+        const initializer = node.initializer ? `= ${visit(node.initializer)}` : '';
+        return `${type === ':' ? '' : 'var '}${visit(node.name)} ${type}${type === ':' ? '' : ' '}${initializer}`;
     }
     else if (ts.isCallExpression(node)) {
-        const expr = visit(node.expression);
-        const leftSide = expr === 'console.log' ? 'printf' : expr;
-        return `${leftSide}(${node.arguments.map((a) => visit(a)).join(',')})`;
+        const caller = visit(node.expression);
+        const args = node.arguments.map((a) => visit(a));
+        return getCallString(caller, args);
+    }
+    else if (ts.isPrefixUnaryExpression(node)) {
+        return `${getOperatorText(node.operator)}${visit(node.operand)}`;
+    }
+    else if (ts.isPostfixUnaryExpression(node)) {
+        return `${visit(node.operand, true)}${getOperatorText(node.operator)}`;
     }
     else if (ts.isBinaryExpression(node)) {
         return `${visit(node.left)} ${node.operatorToken.getText()} ${visit(node.right)}`;
@@ -48,29 +69,117 @@ export function visit(node) {
         return `(${visit(node.expression)})`;
     }
     else if (ts.isVariableDeclarationList(node)) {
-        return node.declarations.map((n) => visit(n)).join(';\n\t') + ';\n\t';
+        return (node.declarations.map((n) => visit(n)).join(inline ? ';' : ';\n\t') + (inline ? '' : ';\n\t'));
     }
     else if (ts.isExpressionStatement(node)) {
-        return visit(node.expression) + ';\n\t';
+        return visit(node.expression) + (inline ? '' : ';\n\t');
+    }
+    else if (ts.isForStatement(node)) {
+        return `for ${visit(node.initializer, true)}; ${visit(node.condition, true)}; ${visit(node.incrementor, true)}${visit(node.statement)}`;
+    }
+    else if (ts.isForOfStatement(node)) {
+        return `for _,${visit(node.initializer, true)}= range ${visit(node.expression, true)}${visit(node.statement)}`;
+    }
+    else if (ts.isWhileStatement(node)) {
+        return `for ${visit(node.expression, true)}${visit(node.statement)}`;
+    }
+    else if (ts.isDoStatement(node)) {
+        const condition = `\tif !(${visit(node.expression, true)}) {\n\t\t\tbreak \n\t\t}\n\t`;
+        return `for ${visit(node.statement, false, condition)}`;
+    }
+    else if (ts.isIfStatement(node)) {
+        const condition = `if ${visit(node.expression, true)} ${visit(node.thenStatement, true)}`;
+        if (node.elseStatement) {
+            return `${condition} else ${visit(node.elseStatement)}`;
+        }
+        return condition;
+    }
+    const syntaxKind = ts.SyntaxKind[node.kind];
+    if (!['SourceFile', 'FirstStatement', 'EndOfFileToken'].includes(syntaxKind)) {
+        console.log(ts.SyntaxKind[node.kind], node.getText());
     }
-    console.log(ts.SyntaxKind[node.kind], node.getText());
     ts.forEachChild(node, (subNode) => {
         code += visit(subNode);
         return null;
     });
     return code;
 }
-function getCType(typeNode) {
+function getType(typeNode, getArrayType = false) {
     const type = TypeCheker.getTypeFromTypeNode(typeNode);
-    const typeName = TypeCheker.typeToString(type);
+    let typeName = TypeCheker.typeToString(type);
+    const isArray = typeNode?.kind & ts.SyntaxKind.ArrayType;
+    if (isArray) {
+        if (getArrayType) {
+            typeName = typeName.replace('[]', '');
+        }
+        else {
+            return ':';
+        }
+    }
     switch (typeName) {
-        case 'string':
-            return { typeStr: 'char', arrayStr: '[]' };
         case 'number':
-            return { typeStr: 'double', arrayStr: '' };
+            return 'float64';
         case 'boolean':
-            return { typeStr: 'int', arrayStr: '' };
+            return 'bool';
+        case 'any':
+            return ':';
         default:
-            return { typeStr: typeName, arrayStr: '' };
+            return typeName;
     }
 }
+function getAcessString(leftSide, rightSide) {
+    if (rightSide === 'length') {
+        return 'float64(len(arr))';
+    }
+    return `${leftSide}.${rightSide}`;
+}
+function getCallString(caller, args) {
+    if (caller === 'console.log') {
+        importedPackages.add('fmt');
+        return `fmt.Println(${args.join(', ')})`;
+    }
+    else if (caller === 'console.time') {
+        importedPackages.add('time');
+        return `${getTimerName(args[0])} := time.Now()`;
+    }
+    else if (caller === 'console.timeEnd') {
+        importedPackages.add('time');
+        importedPackages.add('fmt');
+        return `fmt.Println("Elapsed time:", time.Since(${getTimerName(args[0])}))`;
+    }
+    else if (caller === 'Math.random') {
+        importedPackages.add('math/rand');
+        return 'rand.Float64()';
+    }
+    else if (caller === 'Math.floor') {
+        importedPackages.add('math');
+        return `math.Floor(${args.join(', ')})`;
+    }
+    else if (caller.endsWith('.push')) {
+        const arrayName = caller.substring(0, caller.length - '.push'.length);
+        return `${arrayName} = append(${arrayName},${args.join(', ')})`;
+    }
+    return `${caller}(${args.join(', ')})`;
+}
+function getOperatorText(operator) {
+    switch (operator) {
+        case ts.SyntaxKind.PlusToken:
+            return '+';
+        case ts.SyntaxKind.MinusToken:
+            return '-';
+        case ts.SyntaxKind.TildeToken:
+            return '~';
+        case ts.SyntaxKind.ExclamationToken:
+            return '!';
+        case ts.SyntaxKind.PlusPlusToken:
+            return '++';
+        case ts.SyntaxKind.MinusMinusToken:
+            return '--';
+        default:
+            console.error('Did not find operator', operator);
+            return '';
+    }
+}
+function getTimerName(name) {
+    return `__timer_${name.replaceAll(' ', '_').replaceAll('"', '')}__`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typenative",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "Build native applications using Typescript.",
   "type": "module",
   "bin": {
@@ -12,6 +12,12 @@
     "start:compiler": "node ./bin/index",
     "start:script": "node ./bin/index --script",
     "test": "node ./bin/index --source test/test.ts --script",
+    "test2": "node ./bin/index --source test/test2.ts --script",
+    "test3": "node ./bin/index --source test/test3.ts --script",
+    "test3_node": "tsc test/test3.ts && node test/test3.js && rimraf test/test3.js",
+    "test4": "node ./bin/index --source test/test4.ts --script",
+    "test5": "node ./bin/index --source test/test5.ts --script",
+    "test6": "node ./bin/index --source test/test6.ts --script",
     "release": "npm publish"
   },
   "repository": {
@@ -26,14 +32,14 @@
   "homepage": "https://github.com/danisss9/typenative#readme",
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
-    "@types/inquirer": "^9.0.7",
-    "@types/node": "^20.11.20",
-    "@types/shelljs": "^0.8.15"
+    "@types/inquirer": "^9.0.8",
+    "@types/node": "^22.15.21",
+    "rimraf": "^6.0.1"
   },
   "dependencies": {
-    "fs-extra": "^11.2.0",
-    "inquirer": "^9.2.15",
-    "shelljs": "^0.8.5",
-    "typescript": "^5.3.3"
+    "execa": "^9.5.3",
+    "fs-extra": "^11.3.0",
+    "inquirer": "^12.6.1",
+    "typescript": "^5.8.3"
   }
 }

package/types/typenative.d.ts

@@ -1,4 +1,33 @@
-interface Array<T> {
+interface SymbolConstructor {
+  readonly iterator: unique symbol;
+}
+
+declare var Symbol: SymbolConstructor;
+
+interface IteratorYieldResult<TYield> {
+  done?: false;
+  value: TYield;
+}
+
+interface IteratorReturnResult<TReturn> {
+  done: true;
+  value: TReturn;
+}
+
+type IteratorResult<T, TReturn = any> = IteratorYieldResult<T> | IteratorReturnResult<TReturn>;
+
+interface Iterator<T, TReturn = any, TNext = any> {
+  // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
+  next(...[value]: [] | [TNext]): IteratorResult<T, TReturn>;
+  return?(value?: TReturn): IteratorResult<T, TReturn>;
+  throw?(e?: any): IteratorResult<T, TReturn>;
+}
+
+interface IterableIterator<T, TReturn = any, TNext = any> extends Iterator<T, TReturn, TNext> {
+  [Symbol.iterator](): IterableIterator<T, TReturn, TNext>;
+}
+
+interface Array<T> extends IterableIterator<T> {
   /**
    * Gets or sets the length of the array. This is a number one higher than the highest index in the array.
    */
@@ -6,14 +35,20 @@ interface Array<T> {
   /**
    * Returns a string representation of an array.
    */
-  toString(): string;
+  push(element: T): void;
 
   [n: number]: T;
 }
 
 interface Console {
   log(...data: any[]): void;
+  time(label?: string): void;
+  timeEnd(label?: string): void;
 }
 declare var console: Console;
 
-declare var getchar: () => void;
+interface Math {
+  random(): number;
+  floor(x: number): number;
+}
+declare var Math: Math;