typenative 0.0.20 → 0.1.0

package/bin/main.js

@@ -0,0 +1,31 @@
+// Self-hosting entry point: this file is what TypeNative compiles to produce
+// the native compiler binary. Interactive prompts use the transpilable
+// prompt module (sync stdin) instead of inquirer.
+import { run, createProject } from './index.js';
+import { ask, askMultiline, confirm } from './prompt.js';
+import { parseAstJsonNative } from './parse-native.js';
+(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');
+    let source = sourceIndex > -1 ? process.argv[sourceIndex + 1] : null;
+    const outputIndex = process.argv.findIndex((a) => a === '--output');
+    let output = outputIndex > -1 ? process.argv[outputIndex + 1] : null;
+    if (newCommand) {
+        const projectName = ask('Enter Project Name:');
+        const installDependencies = confirm('Do you want to install dependencies?');
+        createProject(projectName, installDependencies);
+        return;
+    }
+    let tsCode = null;
+    if (!newCommand && !scriptMode && !source) {
+        source = ask('Enter Path to typescript main file:');
+    }
+    if (!newCommand && !scriptMode && !output) {
+        output = ask('Enter Output Path:');
+    }
+    if (!newCommand && scriptMode && !source) {
+        tsCode = askMultiline('Write your typescript code here:');
+    }
+    run({ source, output, scriptMode, tsCode, parse: parseAstJsonNative });
+})();

package/bin/parse-native.js

@@ -0,0 +1,37 @@
+// Self-hosted parser: spawns the tsparser Go tool (tsparser/main.go) to parse
+// TypeScript into the normalized JSON AST. Fully transpilable — used by the
+// native compiler binary instead of the typescript npm package.
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import * as childProcess from 'node:child_process';
+export function parseAstJsonNative(code) {
+    const exe = findTsparser();
+    const result = childProcess.spawnSync(exe, [], { input: code, encoding: 'utf-8' });
+    if (result.status !== 0) {
+        throw new Error('tsparser failed: ' + result.stderr);
+    }
+    return JSON.parse(result.stdout);
+}
+// Locates the tsparser binary: TYPENATIVE_TSPARSER env var, next to this
+// executable, or in a sibling tsparser/ directory (dev checkout layout).
+function findTsparser() {
+    const exeName = platformIsWindows() ? 'tsparser.exe' : 'tsparser';
+    const envPath = process.env.TYPENATIVE_TSPARSER;
+    if (envPath && fs.existsSync(envPath))
+        return envPath;
+    const thisDir = path.dirname(path.resolve(process.argv[0]));
+    const candidates = [
+        path.join(thisDir, exeName),
+        path.join(thisDir, 'tsparser', exeName),
+        path.join(thisDir, '..', 'tsparser', exeName),
+        path.join(thisDir, '..', '..', 'tsparser', exeName)
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    throw new Error('tsparser binary not found; set TYPENATIVE_TSPARSER');
+}
+function platformIsWindows() {
+    return process.platform === 'win32';
+}

package/bin/parse-node.js

@@ -0,0 +1,110 @@
+// Node-side AST adapter: converts a `typescript` npm package AST into the same
+// normalized JSON shape that the `tsparser` Go tool emits
+// (tsparser/main.go). The transpiler consumes this shape, so dev-CLI output and
+// self-hosted (Go parser) output are field-compatible.
+//
+// Node-only module: imports the `typescript` package directly and is injected
+// into the transpiler by the Node CLI wrapper (src/cli.ts). The self-hosted
+// binary uses src/parse-native.ts instead.
+import ts from 'typescript';
+// Internal ts.Node bookkeeping properties that must not leak into the JSON
+const SKIP_PROPS = new Set([
+    'pos',
+    'end',
+    'flags',
+    'modifierFlagsCache',
+    'transformFlags',
+    'parent',
+    'original',
+    'symbol',
+    'id',
+    'jsDoc',
+    'flowNode',
+    'contextFlags',
+    'parserContextFlags',
+    'excludeFlags',
+    'modifierFlags',
+    'flowId',
+    'symbolCount',
+    'identifierCount',
+    'nodeArrayCache',
+    'parsedByParser',
+    'autoGenerateKind',
+    'autoGenerateId',
+    'emitNode',
+    'localSymbol',
+    // 'text'/'escapedText' are only emitted for token-like kinds (TEXT_KINDS);
+    // SourceFile.text would otherwise leak the whole source into the AST
+    'text',
+    'escapedText',
+    'endOfFileToken',
+    'externalModuleIndicator',
+    'commonJsModuleIndicator',
+    'localJsxNamespace',
+    'localJsxFactory',
+    'localJsxFragmentFactory'
+]);
+const TEXT_KINDS = new Set([
+    ts.SyntaxKind.Identifier,
+    ts.SyntaxKind.PrivateIdentifier,
+    ts.SyntaxKind.StringLiteral,
+    ts.SyntaxKind.NumericLiteral,
+    ts.SyntaxKind.BigIntLiteral,
+    ts.SyntaxKind.NoSubstitutionTemplateLiteral,
+    ts.SyntaxKind.RegularExpressionLiteral,
+    ts.SyntaxKind.TemplateHead,
+    ts.SyntaxKind.TemplateMiddle,
+    ts.SyntaxKind.TemplateTail,
+    ts.SyntaxKind.JsxText
+]);
+// Reverse enum map preferring canonical names over aliases
+// (ts.SyntaxKind[8] is "FirstLiteralToken", the alias of NumericLiteral)
+const KIND_NAMES = (() => {
+    const names = {};
+    for (const key of Object.keys(ts.SyntaxKind)) {
+        const val = ts.SyntaxKind[key];
+        if (typeof val === 'number' && names[val] === undefined)
+            names[val] = key;
+    }
+    return names;
+})();
+function isNode(v) {
+    return typeof v === 'object' && v !== null && typeof v.kind === 'number' && typeof v.pos === 'number';
+}
+function convertNode(node) {
+    const obj = { kind: KIND_NAMES[node.kind] ?? String(node.kind) };
+    if (TEXT_KINDS.has(node.kind)) {
+        obj.text = node.text ?? node.escapedText;
+    }
+    for (const key of Object.keys(node)) {
+        if (SKIP_PROPS.has(key))
+            continue;
+        const v = node[key];
+        if (typeof v === 'function')
+            continue;
+        if (v === null || v === undefined)
+            continue;
+        if (isNode(v)) {
+            obj[key] = convertNode(v);
+        }
+        else if (Array.isArray(v)) {
+            const arr = v.filter((e) => isNode(e)).map((e) => convertNode(e));
+            if (arr.length > 0)
+                obj[key] = arr;
+        }
+        else if (typeof v === 'number' && (key === 'operator' || key === 'token')) {
+            // operator / heritage-clause token: emit the kind name (matches the Go producer)
+            obj[key] = KIND_NAMES[v] ?? String(v);
+        }
+        else if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') {
+            if (key !== 'kind')
+                obj[key] = v;
+        }
+    }
+    return obj;
+}
+// Parse TypeScript source into the normalized JSON AST shape.
+export function parseAstJson(code) {
+    const sourceFile = ts.createSourceFile('main.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
+    return convertNode(sourceFile);
+}

package/bin/prompt.js

@@ -0,0 +1,29 @@
+// Interactive prompts for the self-hosted native binary.
+// Implemented exclusively with TypeNative-mapped APIs (node:readline → Go helper)
+// so this module transpiles. Under Node the namespace import of node:readline is
+// valid but `question` is only available once transpiled — the Node CLI wrapper
+// (src/cli.ts) resolves prompts via inquirer instead and never calls these.
+import * as readlineSync from 'node:readline';
+export function ask(message) {
+    let input = readlineSync.question(message + ' ');
+    while (input.trim() === '') {
+        console.log('Please enter a non-empty value.');
+        input = readlineSync.question(message + ' ');
+    }
+    return input.trim();
+}
+export function askMultiline(message) {
+    console.log(message);
+    console.log("(finish with a line containing only 'END')");
+    const lines = [];
+    let line = readlineSync.question('');
+    while (line.trim() !== 'END') {
+        lines.push(line);
+        line = readlineSync.question('');
+    }
+    return lines.join('\n');
+}
+export function confirm(message) {
+    const answer = readlineSync.question(message + ' (y/n): ');
+    return answer.trim().toLowerCase() === 'y';
+}