typenative 0.0.8 → 0.0.10

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,51 @@
 
 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 |
+| **Data Structures** |  |  |
+| Arrays | ✅ | Basic array operations |
+| **Functions** |  |  |
+| console.log | ✅ | Mapped to `fmt.Println` |
+| **Unsupported Features** |  |  |
+| Classes | ❌ | Not implemented |
+| Interfaces | ❌ | Not implemented |
+| Functions | ❌ | Custom function definitions not supported |
+| Arrow Functions | ❌ | Not implemented |
+| If/Else statements | ❌ | Not implemented |
+| While/Do loops | ❌ | Not implemented |
+| Switch statements | ❌ | 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

@@ -3,7 +3,7 @@ import inquirer from 'inquirer';
 import shell from 'shelljs';
 import fs from 'fs-extra';
 import path from 'path';
-import { transpileToC } from './transpiler.js';
+import { transpileToNative } from './transpiler.js';
 import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -34,14 +34,20 @@ 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' });
+    shell.exec('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) {
+        shell.exec(path.join('dist', 'native.exe'));
+        await fs.remove('dist/native.exe');
+    }
+    else {
         console.log('DONE');
     }
 })();

package/bin/transpiler.js

@@ -1,16 +1,17 @@
 import ts from 'typescript';
-export function transpileToC(code) {
+let TypeCheker;
+export function transpileToNative(code) {
     const sourceFile = ts.createSourceFile('main.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
-    return `#include <stdio.h>
-#include <string.h>
+    TypeCheker = ts.createProgram(['main.ts'], {}).getTypeChecker();
+    return `package main
 
-int main() {
+import "fmt"
+
+func main() {
     ${visit(sourceFile)}
-    return 0;
-}
-    `;
+}`;
 }
-export function visit(node) {
+export function visit(node, inline = false) {
     let code = '';
     if (ts.isIdentifier(node)) {
         return node.text;
@@ -18,18 +19,93 @@ export function visit(node) {
     else if (ts.isStringLiteral(node)) {
         return `"${node.text}"`;
     }
+    else if (ts.isNumericLiteral(node)) {
+        return `float64(${node.text})`;
+    }
+    else if (ts.isToken(node) && node.kind === ts.SyntaxKind.TrueKeyword) {
+        return `true`;
+    }
+    else if (ts.isToken(node) && node.kind === ts.SyntaxKind.FalseKeyword) {
+        return `false`;
+    }
+    else if (ts.isBlock(node)) {
+        return `{\n\t\t${node.statements.map((n) => visit(n)).join('\t')}}\n\t`;
+    }
     else if (ts.isPropertyAccessExpression(node)) {
         return `${visit(node.expression)}.${visit(node.name)}`;
     }
+    else if (ts.isVariableDeclaration(node)) {
+        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(',')})`;
+        return `${getFunction(expr)}(${node.arguments.map((a) => visit(a)).join(',')})`;
+    }
+    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)}`;
+    }
+    else if (ts.isParenthesizedExpression(node)) {
+        return `(${visit(node.expression)})`;
+    }
+    else if (ts.isVariableDeclarationList(node)) {
+        return (node.declarations.map((n) => visit(n)).join(inline ? ';' : ';\n\t') + (inline ? ';' : ';\n\t'));
     }
     else if (ts.isExpressionStatement(node)) {
-        return visit(node.expression) + ';\n';
+        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)}`;
     }
-    // console.log(ts.SyntaxKind[node.kind], node.getText());
-    ts.forEachChild(node, (subNode) => (code = code + visit(subNode)));
+    console.log(ts.SyntaxKind[node.kind], node.getText());
+    ts.forEachChild(node, (subNode) => {
+        code += visit(subNode);
+        return null;
+    });
     return code;
 }
+function getType(typeNode) {
+    const type = TypeCheker.getTypeFromTypeNode(typeNode);
+    const typeName = TypeCheker.typeToString(type);
+    switch (typeName) {
+        case 'number':
+            return 'float64';
+        case 'boolean':
+            return 'bool';
+        case 'any':
+            return ':';
+        default:
+            return typeName;
+    }
+}
+function getFunction(expr) {
+    switch (expr) {
+        case 'console.log':
+            return 'fmt.Println';
+        default:
+            return expr;
+    }
+}
+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 '--';
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typenative",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "Build native applications using Typescript.",
   "type": "module",
   "bin": {
@@ -12,6 +12,9 @@
     "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",
+    "test4": "node ./bin/index --source test/test4.ts --script",
     "release": "npm publish"
   },
   "repository": {
@@ -26,14 +29,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",
+    "@types/shelljs": "^0.8.16"
   },
   "dependencies": {
-    "fs-extra": "^11.2.0",
-    "inquirer": "^9.2.15",
-    "shelljs": "^0.8.5",
-    "typescript": "^5.3.3"
+    "fs-extra": "^11.3.0",
+    "inquirer": "^12.6.1",
+    "shelljs": "^0.10.0",
+    "typescript": "^5.8.3"
   }
 }

package/types/typenative.d.ts

@@ -6,7 +6,7 @@ interface Array<T> {
   /**
    * Returns a string representation of an array.
    */
-  toString(): string;
+  push(element: T): void;
 
   [n: number]: T;
 }
@@ -15,5 +15,3 @@ interface Console {
   log(...data: any[]): void;
 }
 declare var console: Console;
-
-declare var getchar: () => void;