typenative 0.0.13 → 0.0.14

package/.github/dependabot.yml

@@ -0,0 +1,11 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  - package-ecosystem: "npm" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"

package/.github/workflows/npm-publish-github-packages.yml

@@ -0,0 +1,36 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: npm test
+
+  publish-gpr:
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://npm.pkg.github.com/
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/CHANGELOG.md

@@ -0,0 +1,44 @@
+# Changelog
+
+All notable changes to TypeNative will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.0.14] - 2025-05-25
+
+### Added
+- Project creation with new `--new` command
+- Support for functions and arrow functions
+- Support for switch statements
+- If statements, while loops, and for...of loops for arrays
+
+### Changed
+- Replaced shelljs dependency with execa for improved process execution
+
+### Fixed
+- Project creation issues
+
+## [0.0.12] - 2025-05-23
+
+### Changed
+- Switched transpilation target to Go language
+
+## [0.0.9] - 2024-03-01
+
+### Added
+- Basic types support (number, boolean, string, null, any)
+- Support for variable declarations
+- Support for binary expressions
+- Arithmetic, comparison, logical, and increment/decrement operators
+
+## [0.0.1] - 2024-02-24
+
+### Added
+- Initial project setup
+- Basic project structure
+
+## [0.0.0] - 2022-12-20
+
+### Added
+- Initial commit

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-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
-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.
+MIT License
+
+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
+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

@@ -1,65 +1,65 @@
-# TypeNative
-
-Build native applications using Typescript.
-
-## PreRequisites
-
-- [Nodejs v20](https://nodejs.org/en) or newer.
-- [Go 1.21](https://go.dev/doc/install) 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 --script`
-- See your message in the terminal
-
-## Create a TypeNative Project
-
-- Run `npx typenative --new`
-- Give your project a name
-- Start writing code
-
-## Typescript Syntax Support
-
-TypeNative currently supports a subset of TypeScript syntax elements that are transpiled to Go code:
-
-| 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** |  |  |
-| Function declarations | ✅ | Transpiled to Go functions |
-| Arrow Functions | ✅ | Transpiled to anonymous 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 |
-| Async/Await | ❌ | Not implemented |
-| Modules/Imports | ❌ | Not implemented |
-| Generics | ❌ | Not implemented |
-
+# TypeNative
+
+Build native applications using Typescript.
+
+## PreRequisites
+
+- [Nodejs v20](https://nodejs.org/en) or newer.
+- [Go 1.21](https://go.dev/doc/install) 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 --script`
+- See your message in the terminal
+
+## Create a TypeNative Project
+
+- Run `npx typenative --new`
+- Give your project a name
+- Start writing code
+
+## Typescript Syntax Support
+
+TypeNative currently supports a subset of TypeScript syntax elements that are transpiled to Go code:
+
+| 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** |  |  |
+| Function declarations | ✅ | Transpiled to Go functions |
+| Arrow Functions | ✅ | Transpiled to anonymous 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 |
+| Async/Await | ❌ | Not implemented |
+| Modules/Imports | ❌ | Not implemented |
+| Generics | ❌ | Not implemented |
+
 TypeNative is currently in early development and new features are being added regularly.

package/bin/index.js

@@ -8,143 +8,146 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 (async function main() {
-    const scriptMode = process.argv.findIndex((a) => a === '--script') > -1;
-    const newCommand = process.argv.findIndex((a) => a === '--new') > -1;
-    const sourceIndex = process.argv.findIndex((a) => a === '--source');
-    const source = sourceIndex > -1 ? process.argv[sourceIndex + 1] : null;
-    const outputIndex = process.argv.findIndex((a) => a === '--output');
-    const output = outputIndex > -1 ? process.argv[outputIndex + 1] : null;
-    const answers = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'projectName',
-            message: 'Enter Project Name:',
-            when: newCommand,
-            validate: (input) => input.trim() !== ''
-        },
-        {
-            type: 'confirm',
-            name: 'installDependencies',
-            message: 'Do you want to install dependencies?',
-            when: newCommand
-        },
-        {
-            type: 'input',
-            name: 'path',
-            message: 'Enter Path to typescript main file:',
-            when: !newCommand && !scriptMode && !source,
-            validate: (input) => input.trim() !== ''
-        },
-        {
-            type: 'input',
-            name: 'output',
-            message: 'Enter Output Path:',
-            when: !newCommand && !scriptMode && !output,
-            validate: (input) => input.trim() !== ''
-        },
-        {
-            type: 'editor',
-            name: 'tsCode',
-            message: 'Write your typescript code here:',
-            when: !newCommand && scriptMode && !source,
-            default: `console.log('Hello, World!');`
-        }
-    ]);
-    if (newCommand) {
-        const projectName = answers.projectName.trim();
-        await fs.ensureDir(projectName);
-        await fs.writeFile(path.join(projectName, 'main.ts'), `// Write your TypeScript code here\nconsole.log('Hello, World!');\n`, { encoding: 'utf-8' });
-        await fs.writeFile(path.join(projectName, 'tsconfig.json'), getTsConfig(), {
-            encoding: 'utf-8'
-        });
-        await fs.writeFile(path.join(projectName, 'package.json'), getPackageJson(projectName), {
-            encoding: 'utf-8'
-        });
-        await fs.writeFile(path.join(projectName, '.gitignore'), getGitIgnore(), {
-            encoding: 'utf-8'
-        });
-        await fs.writeFile(path.join(projectName, 'README.md'), getReadMe(projectName), {
-            encoding: 'utf-8'
-        });
-        console.log(`Project "${projectName}" created successfully!`);
-        if (answers.installDependencies) {
-            console.log('Installing dependencies...');
-            await execa('npm install', { cwd: projectName, stdio: 'inherit' });
-            console.log('Dependencies installed successfully!');
-        }
-        return;
+  const scriptMode = process.argv.findIndex((a) => a === '--script') > -1;
+  const newCommand = process.argv.findIndex((a) => a === '--new') > -1;
+  const sourceIndex = process.argv.findIndex((a) => a === '--source');
+  const source = sourceIndex > -1 ? process.argv[sourceIndex + 1] : null;
+  const outputIndex = process.argv.findIndex((a) => a === '--output');
+  const output = outputIndex > -1 ? process.argv[outputIndex + 1] : null;
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'projectName',
+      message: 'Enter Project Name:',
+      when: newCommand,
+      validate: (input) => input.trim() !== ''
+    },
+    {
+      type: 'confirm',
+      name: 'installDependencies',
+      message: 'Do you want to install dependencies?',
+      when: newCommand
+    },
+    {
+      type: 'input',
+      name: 'path',
+      message: 'Enter Path to typescript main file:',
+      when: !newCommand && !scriptMode && !source,
+      validate: (input) => input.trim() !== ''
+    },
+    {
+      type: 'input',
+      name: 'output',
+      message: 'Enter Output Path:',
+      when: !newCommand && !scriptMode && !output,
+      validate: (input) => input.trim() !== ''
+    },
+    {
+      type: 'editor',
+      name: 'tsCode',
+      message: 'Write your typescript code here:',
+      when: !newCommand && scriptMode && !source,
+      default: `console.log('Hello, World!');`
     }
-    const tsCode = answers.tsCode
-        ? answers.tsCode
-        : await fs.readFile(source ?? answers.path, { encoding: 'utf-8' });
-    const nativeCode = transpileToNative(tsCode);
-    await fs.ensureDir('dist');
-    await fs.writeFile('dist/code.go', nativeCode, { encoding: 'utf-8' });
-    await execa('go build -o dist/native.exe dist/code.go', {
-        stdio: 'inherit'
+  ]);
+  if (newCommand) {
+    const projectName = answers.projectName.trim();
+    await fs.ensureDir(projectName);
+    await fs.writeFile(
+      path.join(projectName, 'main.ts'),
+      `// Write your TypeScript code here\nconsole.log('Hello, World!');\n`,
+      { encoding: 'utf-8' }
+    );
+    await fs.writeFile(path.join(projectName, 'tsconfig.json'), getTsConfig(), {
+      encoding: 'utf-8'
     });
-    // await fs.remove('dist/code.go');
-    if (scriptMode) {
-        await execa('dist/native.exe', {
-            stdio: 'inherit'
-        });
-        //await fs.remove('dist/native.exe');
-    }
-    else if (output || answers.output) {
-        await fs.copy('dist/native.exe', output ?? answers.output, { overwrite: true });
-        //await fs.remove('dist/native.exe');
-        console.log(`Created native executable at: ${output ?? answers.output}`);
+    await fs.writeFile(path.join(projectName, 'package.json'), getPackageJson(projectName), {
+      encoding: 'utf-8'
+    });
+    await fs.writeFile(path.join(projectName, '.gitignore'), getGitIgnore(), {
+      encoding: 'utf-8'
+    });
+    await fs.writeFile(path.join(projectName, 'README.md'), getReadMe(projectName), {
+      encoding: 'utf-8'
+    });
+    console.log(`Project "${projectName}" created successfully!`);
+    if (answers.installDependencies) {
+      console.log('Installing dependencies...');
+      await execa('npm install', { cwd: projectName, stdio: 'inherit' });
+      console.log('Dependencies installed successfully!');
     }
+    return;
+  }
+  const tsCode = answers.tsCode
+    ? answers.tsCode
+    : await fs.readFile(source ?? answers.path, { encoding: 'utf-8' });
+  const nativeCode = transpileToNative(tsCode);
+  await fs.ensureDir('dist');
+  await fs.writeFile('dist/code.go', nativeCode, { encoding: 'utf-8' });
+  await execa('go build -o dist/native.exe dist/code.go', {
+    stdio: 'inherit'
+  });
+  // await fs.remove('dist/code.go');
+  if (scriptMode) {
+    await execa('dist/native.exe', {
+      stdio: 'inherit'
+    });
+    //await fs.remove('dist/native.exe');
+  } else if (output || answers.output) {
+    await fs.copy('dist/native.exe', output ?? answers.output, { overwrite: true });
+    //await fs.remove('dist/native.exe');
+    console.log(`Created native executable at: ${output ?? answers.output}`);
+  }
 })();
 function getPackageJson(projectName) {
-    const pckg = {
-        name: projectName,
-        version: '1.0.0',
-        scripts: {
-            execute: 'npx typenative --source main.ts --script',
-            build: `npx typenative --source main.ts --output bin/${projectName}.exe`
-        },
-        devDependencies: {
-            typenative: '^0.0.13'
-        }
-    };
-    return JSON.stringify(pckg, null, 2);
+  const pckg = {
+    name: projectName,
+    version: '1.0.0',
+    scripts: {
+      execute: 'npx typenative --source main.ts --script',
+      build: `npx typenative --source main.ts --output bin/${projectName}.exe`
+    },
+    devDependencies: {
+      typenative: '^0.0.14'
+    }
+  };
+  return JSON.stringify(pckg, null, 2);
 }
 function getTsConfig() {
-    const tsConfig = {
-        include: ['**/*.ts'],
-        compilerOptions: {
-            target: 'es2020',
-            lib: [],
-            types: ['./node_modules/typenative/types/typenative.d.ts'],
-            rootDir: '.',
-            strict: true,
-            noImplicitAny: true
-        }
-    };
-    return JSON.stringify(tsConfig, null, 2);
+  const tsConfig = {
+    include: ['**/*.ts'],
+    compilerOptions: {
+      target: 'es2020',
+      lib: [],
+      types: ['./node_modules/typenative/types/typenative.d.ts'],
+      rootDir: '.',
+      strict: true,
+      noImplicitAny: true
+    }
+  };
+  return JSON.stringify(tsConfig, null, 2);
 }
 function getGitIgnore() {
-    return `# TypeNative generated files
-node_modules/
-dist/
-bin/
+  return `# TypeNative generated files
+node_modules/
+dist/
+bin/
 `;
 }
 function getReadMe(projectName) {
-    return `# ${projectName}
-
-This project was created using TypeNative, a tool to transpile TypeScript code to native Go code.
-
-## How to Run
-
-You can write your TypeScript code in the \`main.ts\` file. The code will be transpiled to Go and compiled into a native executable.
-You can also run the code directly in script mode using \`npm run execute\`.
-
-## How to Build
-
-1. Install dependencies: \`npm install\` (if not done already)
-2. Build the project: \`npm run build\`
-3. Run the executable: \`./bin/${projectName}.exe\`
+  return `# ${projectName}
+
+This project was created using TypeNative, a tool to transpile TypeScript code to native Go code.
+
+## How to Run
+
+You can write your TypeScript code in the \`main.ts\` file. The code will be transpiled to Go and compiled into a native executable.
+You can also run the code directly in script mode using \`npm run execute\`.
+
+## How to Build
+
+1. Install dependencies: \`npm install\` (if not done already)
+2. Build the project: \`npm run build\`
+3. Run the executable: \`./bin/${projectName}.exe\`
 `;
 }

package/bin/transpiler.js

@@ -1,253 +1,253 @@
-import ts from 'typescript';
-let TypeCheker;
-const importedPackages = new Set();
-let outsideNodes = [];
-export function transpileToNative(code) {
-    const sourceFile = ts.createSourceFile('main.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
-    TypeCheker = ts.createProgram(['main.ts'], {}).getTypeChecker();
-    importedPackages.clear();
-    outsideNodes = [];
-    const transpiledCode = visit(sourceFile, { addFunctionOutside: true });
-    const transpiledCodeOutside = outsideNodes.map((n) => visit(n, { isOutside: true })).join('\n');
-    return `package main
-
-${[...importedPackages].map((pkg) => `import "${pkg}"`).join('\n')}
-
-func main() {
-    ${transpiledCode.trim()}
-}
- 
-${transpiledCodeOutside.trim()}`;
-}
-export function visit(node, options = {}) {
-    let code = '';
-    if (ts.isSourceFile(node)) {
-        return node.statements
-            .map((n) => visit(n, { addFunctionOutside: true }))
-            .filter((n) => !!n)
-            .join(options.inline ? '' : '\n\t');
-    }
-    else if (ts.isIdentifier(node)) {
-        return node.text;
-    }
-    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.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')}${options.extraBlockContent ?? ''}}${options.inline ? '' : '\n\t'}`;
-    }
-    else if (ts.isElementAccessExpression(node)) {
-        return `${visit(node.expression)}[int(${visit(node.argumentExpression)})]`;
-    }
-    else if (ts.isPropertyAccessExpression(node)) {
-        const leftSide = visit(node.expression);
-        const rightSide = visit(node.name);
-        return getAcessString(leftSide, rightSide);
-    }
-    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 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, { inline: 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(options.inline ? ';' : ';\n\t') +
-            (options.inline ? '' : ';\n\t'));
-    }
-    else if (ts.isExpressionStatement(node)) {
-        return visit(node.expression) + (options.inline ? '' : ';\n\t');
-    }
-    else if (ts.isForStatement(node)) {
-        return `for ${visit(node.initializer, { inline: true })}; ${visit(node.condition, {
-            inline: true
-        })}; ${visit(node.incrementor, { inline: true })}${visit(node.statement)}`;
-    }
-    else if (ts.isForOfStatement(node)) {
-        return `for _,${visit(node.initializer, { inline: true })}= range ${visit(node.expression, {
-            inline: true
-        })}${visit(node.statement)}`;
-    }
-    else if (ts.isWhileStatement(node)) {
-        return `for ${visit(node.expression, { inline: true })}${visit(node.statement)}`;
-    }
-    else if (ts.isDoStatement(node)) {
-        const condition = `\tif !(${visit(node.expression, {
-            inline: true
-        })}) {\n\t\t\tbreak \n\t\t}\n\t`;
-        return `for ${visit(node.statement, { inline: true, extraBlockContent: condition })}`;
-    }
-    else if (ts.isIfStatement(node)) {
-        const condition = `if ${visit(node.expression, { inline: true })} ${visit(node.thenStatement, {
-            inline: !!node.elseStatement
-        })}`;
-        if (node.elseStatement) {
-            return `${condition} else ${visit(node.elseStatement)}`;
-        }
-        return condition;
-    }
-    else if (ts.isSwitchStatement(node)) {
-        return `switch ${visit(node.expression)} ${visit(node.caseBlock)}`;
-    }
-    else if (ts.isCaseBlock(node)) {
-        return `{\n\t\t${node.clauses.map((c) => visit(c)).join('\n\t\t')}\n\t}`;
-    }
-    else if (ts.isCaseClause(node)) {
-        const isFallThrough = !node.statements.some((c) => ts.isBreakStatement(c));
-        return `case ${visit(node.expression, { inline: true })}: \n\t\t\t${node.statements
-            .filter((n) => !ts.isBreakStatement(n))
-            .map((s) => visit(s))
-            .join('')}${isFallThrough ? 'fallthrough\n\t' : ''}`;
-    }
-    else if (ts.isDefaultClause(node)) {
-        return `default: \n\t\t\t${node.statements
-            .filter((n) => !ts.isBreakStatement(n))
-            .map((s) => visit(s))
-            .join('')}`;
-    }
-    else if (ts.isBreakStatement(node)) {
-        return 'break';
-    }
-    else if (ts.isReturnStatement(node)) {
-        return (`return ${node.expression ? visit(node.expression) : ''}` + (options.inline ? '' : ';\n\t'));
-    }
-    else if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {
-        if (options.addFunctionOutside) {
-            outsideNodes.push(node);
-            return '';
-        }
-        const name = visit(node.name, { inline: true });
-        const parameters = node.parameters
-            .map((p) => `${visit(p.name)} ${getType(p.type)}`)
-            .join(', ');
-        const returnType = node.type ? ` ${getType(node.type)}` : '';
-        if (options.isOutside) {
-            return `func ${name}(${parameters})${returnType} ${visit(node.body)}`;
-        }
-        return `${name} := func(${parameters})${returnType} ${visit(node.body)}`;
-    }
-    else if (ts.isArrowFunction(node)) {
-        const parameters = node.parameters
-            .map((p) => `${visit(p.name)} ${getType(p.type)}`)
-            .join(', ');
-        const returnType = node.type ? ` ${getType(node.type)}` : '';
-        return `func(${parameters})${returnType} ${visit(node.body)}`;
-    }
-    const syntaxKind = ts.SyntaxKind[node.kind];
-    if (!['FirstStatement', 'EndOfFileToken'].includes(syntaxKind)) {
-        console.log(ts.SyntaxKind[node.kind], node.getText());
-    }
-    ts.forEachChild(node, (subNode) => {
-        code += visit(subNode);
-    });
-    return code;
-}
-function getType(typeNode, getArrayType = false) {
-    const type = TypeCheker.getTypeFromTypeNode(typeNode);
-    let typeName = TypeCheker.typeToString(type);
-    const isArray = typeName.includes('[]');
-    if (isArray) {
-        if (getArrayType) {
-            typeName = typeName.replace('[]', '');
-        }
-        else {
-            return ':';
-        }
-    }
-    switch (typeName) {
-        case 'number':
-            return 'float64';
-        case 'boolean':
-            return 'bool';
-        case 'any':
-            return ':';
-        case 'void':
-            return '';
-        default:
-            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('"', '')}__`;
-}
+import ts from 'typescript';
+let TypeCheker;
+const importedPackages = new Set();
+let outsideNodes = [];
+export function transpileToNative(code) {
+    const sourceFile = ts.createSourceFile('main.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
+    TypeCheker = ts.createProgram(['main.ts'], {}).getTypeChecker();
+    importedPackages.clear();
+    outsideNodes = [];
+    const transpiledCode = visit(sourceFile, { addFunctionOutside: true });
+    const transpiledCodeOutside = outsideNodes.map((n) => visit(n, { isOutside: true })).join('\n');
+    return `package main
+
+${[...importedPackages].map((pkg) => `import "${pkg}"`).join('\n')}
+
+func main() {
+    ${transpiledCode.trim()}
+}
+ 
+${transpiledCodeOutside.trim()}`;
+}
+export function visit(node, options = {}) {
+    let code = '';
+    if (ts.isSourceFile(node)) {
+        return node.statements
+            .map((n) => visit(n, { addFunctionOutside: true }))
+            .filter((n) => !!n)
+            .join(options.inline ? '' : '\n\t');
+    }
+    else if (ts.isIdentifier(node)) {
+        return node.text;
+    }
+    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.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')}${options.extraBlockContent ?? ''}}${options.inline ? '' : '\n\t'}`;
+    }
+    else if (ts.isElementAccessExpression(node)) {
+        return `${visit(node.expression)}[int(${visit(node.argumentExpression)})]`;
+    }
+    else if (ts.isPropertyAccessExpression(node)) {
+        const leftSide = visit(node.expression);
+        const rightSide = visit(node.name);
+        return getAcessString(leftSide, rightSide);
+    }
+    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 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, { inline: 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(options.inline ? ';' : ';\n\t') +
+            (options.inline ? '' : ';\n\t'));
+    }
+    else if (ts.isExpressionStatement(node)) {
+        return visit(node.expression) + (options.inline ? '' : ';\n\t');
+    }
+    else if (ts.isForStatement(node)) {
+        return `for ${visit(node.initializer, { inline: true })}; ${visit(node.condition, {
+            inline: true
+        })}; ${visit(node.incrementor, { inline: true })}${visit(node.statement)}`;
+    }
+    else if (ts.isForOfStatement(node)) {
+        return `for _,${visit(node.initializer, { inline: true })}= range ${visit(node.expression, {
+            inline: true
+        })}${visit(node.statement)}`;
+    }
+    else if (ts.isWhileStatement(node)) {
+        return `for ${visit(node.expression, { inline: true })}${visit(node.statement)}`;
+    }
+    else if (ts.isDoStatement(node)) {
+        const condition = `\tif !(${visit(node.expression, {
+            inline: true
+        })}) {\n\t\t\tbreak \n\t\t}\n\t`;
+        return `for ${visit(node.statement, { inline: true, extraBlockContent: condition })}`;
+    }
+    else if (ts.isIfStatement(node)) {
+        const condition = `if ${visit(node.expression, { inline: true })} ${visit(node.thenStatement, {
+            inline: !!node.elseStatement
+        })}`;
+        if (node.elseStatement) {
+            return `${condition} else ${visit(node.elseStatement)}`;
+        }
+        return condition;
+    }
+    else if (ts.isSwitchStatement(node)) {
+        return `switch ${visit(node.expression)} ${visit(node.caseBlock)}`;
+    }
+    else if (ts.isCaseBlock(node)) {
+        return `{\n\t\t${node.clauses.map((c) => visit(c)).join('\n\t\t')}\n\t}`;
+    }
+    else if (ts.isCaseClause(node)) {
+        const isFallThrough = !node.statements.some((c) => ts.isBreakStatement(c));
+        return `case ${visit(node.expression, { inline: true })}: \n\t\t\t${node.statements
+            .filter((n) => !ts.isBreakStatement(n))
+            .map((s) => visit(s))
+            .join('')}${isFallThrough ? 'fallthrough\n\t' : ''}`;
+    }
+    else if (ts.isDefaultClause(node)) {
+        return `default: \n\t\t\t${node.statements
+            .filter((n) => !ts.isBreakStatement(n))
+            .map((s) => visit(s))
+            .join('')}`;
+    }
+    else if (ts.isBreakStatement(node)) {
+        return 'break';
+    }
+    else if (ts.isReturnStatement(node)) {
+        return (`return ${node.expression ? visit(node.expression) : ''}` + (options.inline ? '' : ';\n\t'));
+    }
+    else if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {
+        if (options.addFunctionOutside) {
+            outsideNodes.push(node);
+            return '';
+        }
+        const name = visit(node.name, { inline: true });
+        const parameters = node.parameters
+            .map((p) => `${visit(p.name)} ${getType(p.type)}`)
+            .join(', ');
+        const returnType = node.type ? ` ${getType(node.type)}` : '';
+        if (options.isOutside) {
+            return `func ${name}(${parameters})${returnType} ${visit(node.body)}`;
+        }
+        return `${name} := func(${parameters})${returnType} ${visit(node.body)}`;
+    }
+    else if (ts.isArrowFunction(node)) {
+        const parameters = node.parameters
+            .map((p) => `${visit(p.name)} ${getType(p.type)}`)
+            .join(', ');
+        const returnType = node.type ? ` ${getType(node.type)}` : '';
+        return `func(${parameters})${returnType} ${visit(node.body)}`;
+    }
+    const syntaxKind = ts.SyntaxKind[node.kind];
+    if (!['FirstStatement', 'EndOfFileToken'].includes(syntaxKind)) {
+        console.log(ts.SyntaxKind[node.kind], node.getText());
+    }
+    ts.forEachChild(node, (subNode) => {
+        code += visit(subNode);
+    });
+    return code;
+}
+function getType(typeNode, getArrayType = false) {
+    const type = TypeCheker.getTypeFromTypeNode(typeNode);
+    let typeName = TypeCheker.typeToString(type);
+    const isArray = typeName.includes('[]');
+    if (isArray) {
+        if (getArrayType) {
+            typeName = typeName.replace('[]', '');
+        }
+        else {
+            return ':';
+        }
+    }
+    switch (typeName) {
+        case 'number':
+            return 'float64';
+        case 'boolean':
+            return 'bool';
+        case 'any':
+            return ':';
+        case 'void':
+            return '';
+        default:
+            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,49 +1,48 @@
-{
-  "name": "typenative",
-  "version": "0.0.13",
-  "description": "Build native applications using Typescript.",
-  "type": "module",
-  "bin": {
-    "typenative": "bin/index.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "watch": "tsc --watch",
-    "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",
-    "test7": "node ./bin/index --source test/test7.ts --script",
-    "test8": "node ./bin/index --source test/test8.ts --script",
-    "test9": "node ./bin/index --source test/test9.ts --script",
-    "test10": "node ./bin/index --source test/test10.ts --script",
-    "release": "npm publish"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/danisss9/typenative.git"
-  },
-  "author": "Dani Santos",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/danisss9/typenative/issues"
-  },
-  "homepage": "https://github.com/danisss9/typenative#readme",
-  "devDependencies": {
-    "@types/fs-extra": "^11.0.4",
-    "@types/inquirer": "^9.0.8",
-    "@types/node": "^22.15.21",
-    "rimraf": "^6.0.1"
-  },
-  "dependencies": {
-    "execa": "^9.5.3",
-    "fs-extra": "^11.3.0",
-    "inquirer": "^12.6.1",
-    "typescript": "^5.8.3"
-  }
-}
+{
+  "name": "typenative",
+  "version": "0.0.14",
+  "description": "Build native applications using Typescript.",
+  "type": "module",
+  "bin": {
+    "typenative": "bin/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "test": "echo \"No tests specified\" && exit 0",
+    "release": "npm publish",
+    "test1": "node ./bin/index --source test/test1.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",
+    "test7": "node ./bin/index --source test/test7.ts --script",
+    "test8": "node ./bin/index --source test/test8.ts --script",
+    "test9": "node ./bin/index --source test/test9.ts --script",
+    "test10": "node ./bin/index --source test/test10.ts --script"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/danisss9/typenative.git"
+  },
+  "author": "Dani Santos",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/danisss9/typenative/issues"
+  },
+  "homepage": "https://github.com/danisss9/typenative#readme",
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^9.0.8",
+    "@types/node": "^22.15.21",
+    "rimraf": "^6.0.1"
+  },
+  "dependencies": {
+    "execa": "^9.5.3",
+    "fs-extra": "^11.3.0",
+    "inquirer": "^12.6.1",
+    "typescript": "^5.8.3"
+  }
+}

package/types/typenative.d.ts

@@ -1,54 +1,54 @@
-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.
-   */
-  length: number;
-  /**
-   * Returns a string representation of an array.
-   */
-  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;
-
-interface Math {
-  random(): number;
-  floor(x: number): number;
-}
-declare var Math: Math;
+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.
+   */
+  length: number;
+  /**
+   * Returns a string representation of an array.
+   */
+  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;
+
+interface Math {
+  random(): number;
+  floor(x: number): number;
+}
+declare var Math: Math;