typenative 0.0.19 → 0.0.21

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "typenative",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "description": "Build native applications using Typescript.",
   "type": "module",
   "bin": {
-    "typenative": "bin/index.js"
+    "typenative": "bin/cli.js"
   },
   "types": "./index.d.ts",
   "scripts": {
@@ -40,7 +40,11 @@
     "test25": "node ./bin/index --source test/Test25.spec.ts --script",
     "test25_export": "node ./bin/index --source test/Test25-export.spec.ts --script",
     "test26": "node ./bin/index --source test/Test26.spec.ts --script",
-    "test27": "node ./bin/index --source test/Test27.spec.ts --script"
+    "test27": "node ./bin/index --source test/Test27.spec.ts --script",
+    "test28": "node ./bin/index --source test/test28.spec.ts --script",
+    "test29": "node ./bin/index --source test/test29.spec.ts --script",
+    "test30": "node ./bin/index --source test/test30.spec.ts --script",
+    "test32": "node ./bin/cli.js --source test/test31.spec.ts --script"
   },
   "repository": {
     "type": "git",
@@ -53,16 +57,13 @@
   },
   "homepage": "https://github.com/danisss9/typenative#readme",
   "devDependencies": {
-    "@types/fs-extra": "^11.0.4",
     "@types/inquirer": "^9.0.9",
     "@types/node": "^25.3.5",
+    "execa": "^9.6.1",
     "rimraf": "^6.1.3"
   },
   "dependencies": {
-    "execa": "^9.6.1",
-    "fs-extra": "^11.3.4",
     "inquirer": "^13.3.0",
-    "nanoid": "^5.1.6",
     "typescript": "^5.9.3"
   }
 }

package/tsparser/go.mod

@@ -0,0 +1,14 @@
+module github.com/danisss9/typenative/tsparser
+
+go 1.26.0
+
+require github.com/buke/typescript-go-internal v0.0.2
+
+require (
+	github.com/go-json-experiment/json v0.0.0-20251027170946-4849db3c2f7e // indirect
+	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
+	github.com/zeebo/xxh3 v1.1.0 // indirect
+	golang.org/x/sync v0.20.0 // indirect
+	golang.org/x/sys v0.43.0 // indirect
+	golang.org/x/text v0.36.0 // indirect
+)

package/tsparser/go.sum

@@ -0,0 +1,22 @@
+github.com/buke/typescript-go-internal v0.0.2 h1:JTHAXQfj1HVN4eXh7XqUWZurxjowXoE+5Ud8QLS4uRg=
+github.com/buke/typescript-go-internal v0.0.2/go.mod h1:nZjFbdZyxx5D9s/GafAh6ESVUy3GMAjNMMMBjVEqDgc=
+github.com/go-json-experiment/json v0.0.0-20251027170946-4849db3c2f7e h1:Lf/gRkoycfOBPa42vU2bbgPurFong6zXeFtPoxholzU=
+github.com/go-json-experiment/json v0.0.0-20251027170946-4849db3c2f7e/go.mod h1:uNVvRXArCGbZ508SxYYTC5v1JWoz2voff5pm25jU1Ok=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
+github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/peter-evans/patience v0.3.0 h1:rX0JdJeepqdQl1Sk9c9uvorjYYzL2TfgLX1adqYm9cA=
+github.com/peter-evans/patience v0.3.0/go.mod h1:Kmxu5sY1NmBLFSStvXjX1wS9mIv7wMcP/ubucyMOAu0=
+github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
+github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
+github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
+github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
+golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
+golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg=
+golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164=
+gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
+gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=

package/tsparser/main.go

@@ -0,0 +1,279 @@
+// tsparser: parses TypeScript source into a normalized JSON AST.
+//
+// Used by TypeNative's self-hosting pipeline: the transpiled compiler calls
+// this tool (via node:child_process) instead of the `typescript` npm package.
+// The JSON shape mirrors the TypeScript API AST (kind + spec field names) so
+// the same transpiler code can consume ASTs from either source.
+//
+// Usage: tsparser < file.ts > ast.json
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+	"strings"
+
+	"github.com/buke/typescript-go-internal/pkg/ast"
+	"github.com/buke/typescript-go-internal/pkg/core"
+	"github.com/buke/typescript-go-internal/pkg/parser"
+)
+
+func main() {
+	sourceBytes, err := io.ReadAll(os.Stdin)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "read stdin:", err)
+		os.Exit(1)
+	}
+	sourceFile := parser.ParseSourceFile(
+		ast.SourceFileParseOptions{FileName: "/main.ts"},
+		string(sourceBytes),
+		core.ScriptKindTS,
+	)
+	out := serializeNode(sourceFile.AsNode())
+	enc := json.NewEncoder(os.Stdout)
+	enc.SetIndent("", "  ")
+	if err := enc.Encode(out); err != nil {
+		fmt.Fprintln(os.Stderr, "encode:", err)
+		os.Exit(1)
+	}
+}
+
+
+// Nodes currently being serialized (cycle guard).
+var inProgress = map[*ast.Node]bool{}
+
+// Nodes whose As<Kind> method name doesn't follow the naming patterns.
+var asMethodOverrides = map[string]string{
+	"ForInStatement":       "AsForInOrOfStatement",
+	"ForOfStatement":       "AsForInOrOfStatement",
+	"ArrayBindingPattern":  "AsBindingPattern",
+	"ObjectBindingPattern": "AsBindingPattern",
+	"CaseClause":           "AsCaseOrDefaultClause",
+	"DefaultClause":        "AsCaseOrDefaultClause",
+	"TypeAssertionExpression": "AsTypeAssertion",
+}
+
+// asData returns the typed data struct behind a node via its As<Kind> method.
+// Method names don't always match kind names exactly (GetAccessor →
+// AsGetAccessorDeclaration), so common suffixes are tried in order.
+func asData(n *ast.Node) reflect.Value {
+	kind := n.Kind.String()
+	if strings.HasPrefix(kind, "Kind") {
+		kind = kind[4:] // KindIfStatement → IfStatement
+	}
+	nodeVal := reflect.ValueOf(n)
+	candidates := []string{"As" + kind, "As" + kind + "Declaration", "As" + kind + "Expression", "As" + kind + "Statement", "As" + kind + "Node"}
+	if override, ok := asMethodOverrides[kind]; ok {
+		candidates = append([]string{override}, candidates...)
+	}
+	for _, candidate := range candidates {
+		meth := nodeVal.MethodByName(candidate)
+		if !meth.IsValid() {
+			continue
+		}
+		results := meth.Call(nil)
+		if len(results) == 0 {
+			continue
+		}
+		v := results[0]
+		if v.IsNil() {
+			return reflect.Value{}
+		}
+		return v.Elem()
+	}
+	return reflect.Value{}
+}
+
+// serializeNode converts an ast.Node into a map: {kind, text?, <spec fields>}.
+// inProgress guards against cyclic *Node references (self/parent backlinks).
+func serializeNode(n *ast.Node) any {
+	if n == nil {
+		return nil
+	}
+	if inProgress[n] {
+		return nil
+	}
+	inProgress[n] = true
+	defer delete(inProgress, n)
+	obj := map[string]any{"kind": strings.TrimPrefix(n.Kind.String(), "Kind")}
+	// SourceFile bookkeeping fields are not part of the language AST
+	if n.Kind == ast.KindSourceFile {
+		statements := []any{}
+		for _, stmt := range n.AsSourceFile().Statements.Nodes {
+			if stmt != nil {
+				statements = append(statements, serializeNode(stmt))
+			}
+		}
+		obj["statements"] = statements
+		return obj
+	}
+	// Names and modifiers live in unexported base fields — use accessors
+	if name := n.Name(); name != nil {
+		obj["name"] = serializeNode(name.AsNode())
+	}
+	if mods := n.Modifiers(); mods != nil {
+		arr := []any{}
+		for _, mod := range mods.Nodes {
+			arr = append(arr, serializeNode(mod))
+		}
+		obj["modifiers"] = arr
+	}
+	switch n.Kind {
+	case ast.KindIdentifier, ast.KindPrivateIdentifier, ast.KindStringLiteral,
+		ast.KindNumericLiteral, ast.KindBigIntLiteral, ast.KindNoSubstitutionTemplateLiteral,
+		ast.KindRegularExpressionLiteral, ast.KindTemplateHead, ast.KindTemplateMiddle,
+		ast.KindTemplateTail, ast.KindJsxText:
+		obj["text"] = n.Text()
+	}
+
+	// Binding-pattern holes (`[a, , b]`): ts-go parses them as an empty
+	// BindingElement; the TypeScript API exposes them as OmittedExpression
+	if n.Kind == ast.KindBindingElement {
+		if be := n.AsBindingElement(); be != nil && be.Name() == nil && be.DotDotDotToken == nil {
+			return map[string]any{"kind": "OmittedExpression"}
+		}
+	}
+
+	data := asData(n)
+	if data.IsValid() {
+		collectFields(data, obj)
+	}
+	return obj
+}
+
+// collectFields serializes a typed data struct's fields into obj, recursing
+// into embedded base structs (DeclarationBase, FunctionLikeBase, ...) so their
+// fields are hoisted like the TypeScript API exposes them.
+func collectFields(data reflect.Value, obj map[string]any) {
+	dt := data.Type()
+	for i := 0; i < dt.NumField(); i++ {
+		field := dt.Field(i)
+		if !field.IsExported() {
+			continue
+		}
+		// Embedded base structs are hoisted — except NodeDefault/Node, whose
+		// fields (Kind/Flags/Loc/Parent) are parser bookkeeping, not AST
+		if field.Anonymous && field.Type.Kind() == reflect.Struct {
+			if field.Type.Name() != "NodeDefault" && field.Type.Name() != "Node" {
+				collectFields(data.Field(i), obj)
+			}
+			continue
+		}
+		name, val, ok := serializeField(field.Name, data.Field(i))
+		if ok {
+			obj[name] = val
+		}
+	}
+}
+
+// serializeField normalizes one typed-struct field into the TS-spec JSON shape.
+func serializeField(name string, v reflect.Value) (string, any, bool) {
+	if renamed, ok := fieldRenames[name]; ok {
+		name = renamed
+	} else {
+		name = lowerFirst(name)
+	}
+	// Never emit parser bookkeeping fields from the embedded ast.Node
+	switch name {
+	case "kind", "flags", "loc", "parent", "id", "data":
+		return "", nil, false
+	}
+	switch v.Kind() {
+	case reflect.String:
+		return lowerFirst(name), v.String(), true
+	case reflect.Bool:
+		return lowerFirst(name), v.Bool(), true
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		// Operator fields hold token kinds; emit the kind name (matches the
+		// Node producer, which converts ts.SyntaxKind numbers to names)
+		if name == "operator" { // prelude lowercased the field name
+			kind := ast.Kind(v.Int())
+			return lowerFirst(name), strings.TrimPrefix(kind.String(), "Kind"), true
+		}
+		return "", nil, false
+	case reflect.Ptr:
+		if v.IsNil() {
+			return "", nil, false
+		}
+		if isNodePtr(v.Type()) {
+			return lowerFirst(name), serializeNode(v.Interface().(*ast.Node)), true
+		}
+		// *NodeBody / *EntityName etc. are pointer-to-interface wrappers
+		// whose dynamic value is a *Node
+		if v.Type().Elem().Kind() == reflect.Interface {
+			inner := v.Elem().Elem()
+			if inner.IsValid() && inner.Kind() == reflect.Ptr && !inner.IsNil() {
+				return lowerFirst(name), serializeNode(inner.Interface().(*ast.Node)), true
+			}
+			return "", nil, false
+		}
+		// e.g. *StatementList/*ArgumentList/*ModifierList → array of member
+		// nodes, named after the field (statements/arguments/modifiers)
+		if strings.HasSuffix(v.Type().Elem().Name(), "List") {
+			var arr []any
+			elem := v.Elem()
+			nodesField := elem.FieldByName("Nodes")
+			if nodesField.IsValid() && nodesField.Kind() == reflect.Slice {
+				for _, child := range iterSlice(nodesField) {
+					if child.Kind() == reflect.Ptr && isNodePtr(child.Type()) && !child.IsNil() {
+						arr = append(arr, serializeNode(child.Interface().(*ast.Node)))
+					}
+				}
+			}
+			if len(arr) == 0 {
+				return "", nil, false
+			}
+			return lowerFirst(name), arr, true
+		}
+		return "", nil, false
+	case reflect.Slice:
+		var arr []any
+		for _, el := range iterSlice(v) {
+			if el.Kind() == reflect.Ptr && isNodePtr(el.Type()) && !el.IsNil() {
+				arr = append(arr, serializeNode(el.Interface().(*ast.Node)))
+			}
+		}
+		if arr == nil {
+			arr = []any{}
+		}
+		return lowerFirst(name), arr, true
+	case reflect.Interface:
+		if v.IsNil() {
+			return "", nil, false
+		}
+		// Expression/Statement wrappers hold *Node underneath
+		inner := v.Elem()
+		if inner.Kind() == reflect.Ptr && isNodePtr(inner.Type()) && !inner.IsNil() {
+			return lowerFirst(name), serializeNode(inner.Interface().(*ast.Node)), true
+		}
+		return "", nil, false
+	}
+	return "", nil, false
+}
+
+func isNodePtr(t reflect.Type) bool {
+	return t == reflect.TypeOf((*ast.Node)(nil))
+}
+
+func iterSlice(v reflect.Value) []reflect.Value {
+	out := make([]reflect.Value, 0, v.Len())
+	for i := 0; i < v.Len(); i++ {
+		out = append(out, v.Index(i))
+	}
+	return out
+}
+
+func lowerFirst(s string) string {
+	if s == "" {
+		return s
+	}
+	return strings.ToLower(s[:1]) + s[1:]
+}
+
+// Field renames to match the TypeScript API's names.
+var fieldRenames = map[string]string{
+	"PostfixToken": "questionToken", // optional property `a?: string`
+}

package/types/typenative-npm.d.ts

@@ -2,4 +2,48 @@
 
 declare module 'node:path' {
   export function join(...parts: string[]): string;
+  export function dirname(p: string): string;
+  export function basename(p: string, ext?: string): string;
+  export function extname(p: string): string;
+  export function resolve(...parts: string[]): string;
+}
+
+declare module 'node:fs' {
+  export function readFileSync(path: string): string;
+  export function writeFileSync(path: string, content: string): void;
+  export function appendFileSync(path: string, content: string): void;
+  export function existsSync(path: string): boolean;
+  export function mkdirSync(path: string, options?: { recursive?: boolean }): void;
+  export function readdirSync(path: string): string[];
+  export function copyFileSync(src: string, dest: string): void;
+  export function rmSync(path: string, options?: { recursive?: boolean }): void;
+}
+
+declare module 'node:url' {
+  export function fileURLToPath(url: string): string;
+  export function pathToFileURL(path: string): string;
+}
+
+declare module 'node:os' {
+  export function platform(): string;
+  export function homedir(): string;
+  export function tmpdir(): string;
+}
+
+declare module 'node:child_process' {
+  export interface ExecResult {
+    stdout: string;
+    stderr: string;
+    status: number;
+  }
+  export function exec(command: string): ExecResult;
+  export function execSync(command: string): string;
+  export function spawnSync(file: string, args: string[], options?: object): ExecResult;
+  export function spawnInherit(file: string, ...args: string[]): number;
+}
+
+declare module 'node:readline' {
+  // TypeNative extension: synchronous line reading (mapped to a Go helper).
+  // Not part of Node's real readline API — used by self-hosted prompts.
+  export function question(prompt: string): string;
 }

package/types/typenative.d.ts

@@ -99,6 +99,26 @@ interface Array<T> extends IterableIterator<T> {
    * Returns the value of the first element in the array where callback is true, and undefined otherwise.
    */
   find(callback: (value: T, index?: number, array?: T[]) => boolean): T | undefined;
+  /**
+   * Returns the index of the first element that satisfies the callback, or -1.
+   */
+  findIndex(callback: (value: T, index?: number, array?: T[]) => boolean): number;
+  /**
+   * Determines whether all elements satisfy the callback.
+   */
+  every(callback: (value: T, index?: number, array?: T[]) => boolean): boolean;
+  /**
+   * Performs the callback for each element.
+   */
+  forEach(callback: (value: T, index?: number, array?: T[]) => void): void;
+  /**
+   * Calls the callback function on each element of the array, accumulating a result.
+   */
+  reduce<U>(
+    callback: (accumulator: U, value: T, index?: number, array?: T[]) => U,
+    initialValue: U
+  ): U;
+  reduce(callback: (accumulator: T, value: T, index?: number, array?: T[]) => T): T;
   /**
    * Returns the index of the first occurrence of a value in an array, or -1 if it is not present.
    */
@@ -107,6 +127,38 @@ interface Array<T> extends IterableIterator<T> {
    * Determines whether an array includes a certain element.
    */
   includes(searchElement: T): boolean;
+  /**
+   * Removes the last element from an array and returns it.
+   */
+  pop(): T | undefined;
+  /**
+   * Removes the first element from an array and returns it.
+   */
+  shift(): T | undefined;
+  /**
+   * Inserts elements at the beginning of an array.
+   */
+  unshift(...items: T[]): number;
+  /**
+   * Reverses the elements of an array in place.
+   */
+  reverse(): T[];
+  /**
+   * Sorts the elements of an array in place.
+   */
+  sort(compareFn?: (a: T, b: T) => number): T[];
+  /**
+   * Returns a new array formed by applying callback to each element and then flattening.
+   */
+  flat(): T[];
+  /**
+   * Merges two or more arrays.
+   */
+  concat(...items: T[]): T[];
+  /**
+   * Returns the element at the given index (supports negative indices).
+   */
+  at(index: number): T | undefined;
   /**
    * Returns a string representation of an array.
    */
@@ -152,6 +204,18 @@ interface String {
   repeat(count: number): string;
   /** Concatenates strings. */
   concat(...strings: string[]): string;
+  /** Pads the start of a string with another string to a total length. */
+  padStart(targetLength: number, padString?: string): string;
+  /** Pads the end of a string with another string to a total length. */
+  padEnd(targetLength: number, padString?: string): string;
+  /** Matches a string against a regex and returns the matches. */
+  match(regexp: string | RegExp): string[] | null;
+  /** Matches all occurrences of a regex. */
+  matchAll(regexp: string | RegExp): string[][];
+  /** Searches for a match and returns the index. */
+  search(regexp: string | RegExp): number;
+  /** Returns the element at the given index (supports negative indices). */
+  at(index: number): string | undefined;
   /** Returns a string representation. */
   toString(): string;
   [index: number]: string;
@@ -159,6 +223,7 @@ interface String {
 
 interface Console {
   log(...data: any[]): void;
+  error(...data: any[]): void;
   time(label?: string): void;
   timeEnd(label?: string): void;
 }
@@ -174,11 +239,44 @@ interface Math {
   min(a: number, b: number): number;
   sqrt(x: number): number;
   pow(base: number, exponent: number): number;
+  log(x: number): number;
+  log2(x: number): number;
+  log10(x: number): number;
+  sin(x: number): number;
+  cos(x: number): number;
+  tan(x: number): number;
+  trunc(x: number): number;
+  sign(x: number): number;
 }
 declare var Math: Math;
 
-declare function parseInt(s: string): number;
+declare function parseInt(s: string, radix?: number): number;
 declare function parseFloat(s: string): number;
+declare function String(value: any): string;
+declare function Number(value: any): number;
+declare function Boolean(value: any): boolean;
+
+interface JSON {
+  stringify(value: any, replacer?: any, space?: number | string): string;
+  parse(text: string): any;
+}
+declare var JSON: JSON;
+
+interface ObjectConstructor {
+  keys(obj: any): string[];
+  values(obj: any): any[];
+  entries(obj: any): [string, any][];
+}
+declare var Object: ObjectConstructor;
+
+interface Process {
+  argv: string[];
+  platform: string;
+  exit(code?: number): never;
+  cwd(): string;
+  env: { [key: string]: string | undefined };
+}
+declare var process: Process;
 
 interface Promise<T> {
   then(callback: (value: T) => void): void;