goscript 0.0.2 → 0.0.4

package/cmd/goscript/main.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Go up two levels from cmd/goscript/ to the project root
+const projectRoot = path.join(__dirname, '..', '..');
+
+// Get arguments passed to the script, excluding node executable and script path
+const args = process.argv.slice(2);
+
+// Construct the go run command with the absolute path to the goscript executable
+// Use path.join for robustness
+const goscriptCmd = `go run "${path.join(projectRoot, "cmd", "goscript")}"`;
+
+// Combine the goscript command with the arguments
+const command = `${goscriptCmd} ${args.join(" ")}`;
+
+// Execute the command
+const child = spawn(command, {
+  shell: true, // Use shell to correctly parse the command string
+  stdio: 'inherit', // Inherit stdin, stdout, and stderr
+  cwd: process.cwd(), // Execute in the current working directory where the script is run
+});
+
+child.on('error', (error) => {
+  console.error(`Failed to start subprocess: ${error.message}`);
+  process.exit(1);
+});
+
+child.on('exit', (code) => {
+  process.exit(code ?? 0); // Exit with the child process's exit code
+});

package/compiler/compile_expr.go

@@ -359,48 +359,14 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 			// Handle make for slices: make([]T, len, cap) or make([]T, len)
 			if len(exp.Args) >= 1 {
 				// Handle map creation: make(map[K]V)
-				if mapType, ok := exp.Args[0].(*ast.MapType); ok {
-					c.tsw.WriteLiterally("goscript.makeMap(")
-
-					// Get key type
-					if keyType := c.pkg.TypesInfo.TypeOf(mapType.Key); keyType != nil {
-						// Use the underlying type for basic types
-						underlyingKeyType := keyType.Underlying()
-						c.tsw.WriteLiterally(fmt.Sprintf("%q", underlyingKeyType.String()))
-					} else {
-						// If type info is not available, this is an error condition
-						return errors.New("could not determine key type for makeMap")
-					}
-
-					c.tsw.WriteLiterally(", ")
-
-					// Get value type
-					if valueType := c.pkg.TypesInfo.TypeOf(mapType.Value); valueType != nil {
-						// Use the underlying type for basic types
-						underlyingValueType := valueType.Underlying()
-						c.tsw.WriteLiterally(fmt.Sprintf("%q", underlyingValueType.String()))
-					} else {
-						// If type info is not available, this is an error condition
-						return errors.New("could not determine value type for makeMap")
-					}
-
-					c.tsw.WriteLiterally(")")
+				if _, ok := exp.Args[0].(*ast.MapType); ok {
+					c.tsw.WriteLiterally("goscript.makeMap()")
 					return nil // Handled make for map
 				}
 
 				// Handle slice creation
-				if arrayType, ok := exp.Args[0].(*ast.ArrayType); ok {
+				if _, ok := exp.Args[0].(*ast.ArrayType); ok {
 					c.tsw.WriteLiterally("goscript.makeSlice(")
-					// Get and write the string representation of the element type
-					if typ := c.pkg.TypesInfo.TypeOf(arrayType.Elt); typ != nil {
-						// Use the underlying type for basic types like int, string, etc.
-						underlyingType := typ.Underlying()
-						c.tsw.WriteLiterally(fmt.Sprintf("%q", underlyingType.String()))
-					} else {
-						// If type info is not available, this is an error condition for makeSlice
-						return errors.New("could not determine element type for makeSlice")
-					}
-					c.tsw.WriteLiterally(", ")
 					if len(exp.Args) >= 2 {
 						if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
 							return err

package/compiler/index.test.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { compile } from "./index";
+import * as path from "path";
+import * as fs from "fs/promises";
+
+const exampleDir = path.resolve(__dirname, "../example/simple");
+const outputDir = path.join(exampleDir, "output"); // Use a separate output dir for tests
+const expectedOutputFile = path.join(outputDir, "@go", "example", "main.gs.ts");
+
+describe("GoScript Compiler API", () => {
+  // Clean up before and after tests
+  beforeAll(async () => {
+    await fs.rm(outputDir, { recursive: true, force: true });
+  });
+  afterAll(async () => {
+    await fs.rm(outputDir, { recursive: true, force: true });
+  });
+
+  it("should compile the simple example package", async () => {
+    const config = {
+      pkg: ".", // Compile the package in the exampleDir
+      dir: exampleDir,
+      output: outputDir,
+    };
+
+    await expect(compile(config)).resolves.toBeUndefined();
+    await expect(fs.access(expectedOutputFile)).resolves.toBeUndefined();
+  }, 30000); // 30 second timeout for compilation
+});

package/compiler/index.ts

@@ -0,0 +1,85 @@
+import * as path from "path";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+
+const __filename = fileURLToPath(import.meta.url);
+const execAsync = promisify(exec);
+const __dirname = dirname(__filename);
+const projectRoot = dirname(__dirname); // Go up one level from src/ to the project root
+
+/**
+ * Configuration options for the GoScript compiler.
+ */
+export interface CompileConfig {
+  /** The Go package path or pattern to compile. */
+  pkg: string;
+  /** The output directory for the generated TypeScript files. Defaults to './output'. */
+  output?: string;
+  /** The working directory for the compiler. Defaults to the current working directory. */
+  dir?: string;
+  /** The path to the goscript executable. Defaults to 'go run github.com/paralin/goscript/cmd/goscript'. */
+  goscriptPath?: string;
+}
+
+/**
+ * Compiles a Go package to TypeScript using the goscript compiler.
+ * @param config - The compilation configuration.
+ * @returns A promise that resolves when compilation is complete, or rejects on error.
+ */
+export async function compile(config: CompileConfig): Promise<void> {
+  if (!config.pkg) {
+    throw new Error("Package path (pkg) must be specified.");
+  }
+
+  // Construct the go run command with the absolute path to the goscript executable
+  const goscriptCmd =
+    config.goscriptPath ??
+    `go run "${path.join(projectRoot, "./cmd/goscript")}"`;
+
+  const args: string[] = ["compile", "--package", `"${config.pkg}"`];
+
+  if (config.output) {
+    args.push("--output", `"${path.resolve(config.output)}"`);
+  } else {
+    // Default output path if not specified, relative to the working directory
+    args.push("--output", `"./output"`);
+  }
+
+  // Pass the working directory to the goscript command
+  if (config.dir) {
+    args.push("--dir", `"${path.resolve(config.dir)}"`);
+  }
+
+  const command = `${goscriptCmd} ${args.join(" ")}`;
+  // Execute go run from the specified working directory (or current)
+  const cwd = config.dir ? path.resolve(config.dir) : process.cwd();
+
+  try {
+    const { stdout, stderr } = await execAsync(command, { cwd });
+    if (stdout) {
+      console.log(`GoScript stdout:\n${stdout}`);
+    }
+    if (stderr) {
+      // Go compiler often prints status messages to stderr, treat as info unless exit code is non-zero
+      console.info(`GoScript stderr:\n${stderr}`);
+    }
+  } catch (error: any) { // eslint-disable-line
+    console.error(`GoScript compilation failed: ${error.message}`);
+    if (error.stderr) {
+      console.error(`GoScript stderr:\n${error.stderr}`);
+    }
+    if (error.stdout) {
+      console.error(`GoScript stdout:\n${error.stdout}`);
+    }
+    throw new Error(`GoScript compilation failed: ${error.message}`);
+  }
+}
+
+/**
+ * Default export for convenience.
+ */
+export default {
+  compile,
+};

package/dist/builtin/builtin.d.ts

@@ -0,0 +1,168 @@
+/**
+ * Creates a new slice (TypeScript array) with the specified length and capacity.
+ * @param len The length of the slice.
+ * @param cap The capacity of the slice (optional).
+ * @returns A new TypeScript array representing the slice.
+ */
+export declare const makeSlice: <T>(len: number, cap?: number) => Array<T> & {
+    __capacity?: number;
+};
+/**
+ * Creates a new map (TypeScript Map).
+ * @returns A new TypeScript Map.
+ */
+export declare const makeMap: <K, V>() => Map<K, V>;
+/**
+ * Returns the length of a collection (string, array, or map).
+ * @param collection The collection to get the length of.
+ * @returns The length of the collection.
+ */
+export declare const len: <T>(collection: string | Array<T> | Map<unknown, unknown>) => number;
+/**
+ * Returns the capacity of a slice (TypeScript array).
+ * @param slice The slice (TypeScript array).
+ * @returns The capacity of the slice.
+ */
+export declare const cap: <T>(slice: Array<T> & {
+    __capacity?: number;
+}) => number;
+/**
+ * Converts a string to an array of Unicode code points (runes).
+ * @param str The input string.
+ * @returns An array of numbers representing the Unicode code points.
+ */
+export declare const stringToRunes: (str: string) => number[];
+/**
+ * Gets a value from a map, with a default value if the key doesn't exist.
+ * @param map The map to get from.
+ * @param key The key to get.
+ * @param defaultValue The default value to return if the key doesn't exist (defaults to 0).
+ * @returns The value for the key, or the default value if the key doesn't exist.
+ */
+export declare const mapGet: <K, V>(map: Map<K, V>, key: K, defaultValue?: V | null) => V | null;
+/**
+ * Sets a value in a map.
+ * @param map The map to set in.
+ * @param key The key to set.
+ * @param value The value to set.
+ */
+export declare const mapSet: <K, V>(map: Map<K, V>, key: K, value: V) => void;
+/**
+ * Deletes a key from a map.
+ * @param map The map to delete from.
+ * @param key The key to delete.
+ */
+export declare const deleteMapEntry: <K, V>(map: Map<K, V>, key: K) => void;
+/**
+ * Checks if a key exists in a map.
+ * @param map The map to check in.
+ * @param key The key to check.
+ * @returns True if the key exists, false otherwise.
+ */
+export declare const mapHas: <K, V>(map: Map<K, V>, key: K) => boolean;
+/**
+ * Appends elements to a slice (TypeScript array).
+ * Note: In Go, append can return a new slice if the underlying array is reallocated.
+ * This helper emulates that by returning the modified array.
+ * @param slice The slice (TypeScript array) to append to.
+ * @param elements The elements to append.
+ * @returns The modified slice (TypeScript array).
+ */
+export declare const append: <T>(slice: Array<T>, ...elements: T[]) => Array<T>;
+/**
+ * Represents the result of a channel receive operation with 'ok' value
+ */
+export interface ChannelReceiveResult<T> {
+    value: T;
+    ok: boolean;
+}
+/**
+ * Represents a result from a select operation
+ */
+export interface SelectResult<T> {
+    value: T;
+    ok: boolean;
+    id: number;
+}
+/**
+ * Represents a Go channel in TypeScript.
+ * Supports asynchronous sending and receiving of values.
+ */
+export interface Channel<T> {
+    /**
+     * Sends a value to the channel.
+     * Returns a promise that resolves when the value is accepted by the channel.
+     * @param value The value to send.
+     */
+    send(value: T): Promise<void>;
+    /**
+     * Receives a value from the channel.
+     * Returns a promise that resolves with the received value.
+     * If the channel is closed, it throws an error.
+     */
+    receive(): Promise<T>;
+    /**
+     * Receives a value from the channel along with a boolean indicating
+     * whether the channel is still open.
+     * Returns a promise that resolves with {value, ok}.
+     * - If channel is open and has data: {value: <data>, ok: true}
+     * - If channel is closed and empty: {value: <zero value>, ok: false}
+     * - If channel is closed but has remaining buffered data: {value: <data>, ok: true}
+     */
+    receiveWithOk(): Promise<ChannelReceiveResult<T>>;
+    /**
+     * Closes the channel.
+     * No more values can be sent to a closed channel.
+     * Receive operations on a closed channel return the zero value and ok=false.
+     */
+    close(): void;
+    /**
+     * Used in select statements to create a receive operation promise.
+     * @param id An identifier for this case in the select statement
+     * @returns Promise that resolves when this case is selected
+     */
+    selectReceive(id: number): Promise<SelectResult<T>>;
+    /**
+     * Used in select statements to create a send operation promise.
+     * @param value The value to send
+     * @param id An identifier for this case in the select statement
+     * @returns Promise that resolves when this case is selected
+     */
+    selectSend(value: T, id: number): Promise<SelectResult<boolean>>;
+    /**
+     * Checks if the channel has data ready to be received without blocking.
+     * Used for non-blocking select operations.
+     */
+    canReceiveNonBlocking(): boolean;
+    /**
+     * Checks if the channel can accept a send operation without blocking.
+     * Used for non-blocking select operations.
+     */
+    canSendNonBlocking(): boolean;
+}
+/**
+ * Represents a case in a select statement.
+ */
+export interface SelectCase<T> {
+    id: number;
+    isSend: boolean;
+    channel: Channel<any>;
+    value?: any;
+    onSelected?: (result: SelectResult<T>) => Promise<void>;
+}
+/**
+ * Helper for 'select' statements. Takes an array of select cases
+ * and resolves when one of them completes, following Go's select rules.
+ *
+ * @param cases Array of SelectCase objects
+ * @param hasDefault Whether there is a default case
+ * @returns A promise that resolves with the result of the selected case
+ */
+export declare function selectStatement<T>(cases: SelectCase<T>[], hasDefault?: boolean): Promise<void>;
+/**
+ * Creates a new channel with the specified buffer size and zero value.
+ * @param bufferSize The size of the channel buffer. If 0, creates an unbuffered channel.
+ * @param zeroValue The zero value for the channel's element type.
+ * @returns A new channel instance.
+ */
+export declare const makeChannel: <T>(bufferSize: number, zeroValue: T) => Channel<T>;