goscript 0.0.2

package/builtin/builtin.ts

@@ -0,0 +1,507 @@
+/**
+ * Creates a new slice (TypeScript array) with the specified length and capacity.
+ * @param elementType The element type of the slice (for type hinting).
+ * @param len The length of the slice.
+ * @param cap The capacity of the slice (optional).
+ * @returns A new TypeScript array representing the slice.
+ */
+export const makeSlice = <T>(elementType: any, len: number, cap?: number): Array<T> & { __capacity?: number } => {
+    const slice = new Array<T>(len) as Array<T> & { __capacity?: number };
+    slice.__capacity = cap !== undefined ? cap : len;
+    return slice;
+};
+
+/**
+ * Creates a new map (TypeScript Map).
+ * @param keyType The key type of the map (for type hinting).
+ * @param valueType The value type of the map (for type hinting).
+ * @returns A new TypeScript Map.
+ */
+export const makeMap = <K, V>(keyType: any, valueType: any): Map<K, V> => {
+    return new 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 const len = <T>(collection: string | Array<T> | Map<any, any>): number => {
+    if (typeof collection === 'string' || Array.isArray(collection)) {
+        return collection.length;
+    } else if (collection instanceof Map) {
+        return collection.size;
+    }
+    return 0; // Default fallback
+};
+
+/**
+ * Returns the capacity of a slice (TypeScript array).
+ * @param slice The slice (TypeScript array).
+ * @returns The capacity of the slice.
+ */
+export const cap = <T>(slice: Array<T> & { __capacity?: number }): number => {
+    return slice.__capacity !== undefined ? slice.__capacity : slice.length;
+};
+
+/**
+ * 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 const stringToRunes = (str: string): number[] => {
+    return Array.from(str).map(c => c.codePointAt(0) || 0);
+};
+
+/**
+ * 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 const mapGet = <K, V>(map: Map<K, V>, key: K, defaultValue: V | null = null): V | null => {
+    return map.has(key) ? map.get(key)! : defaultValue;
+};
+
+/**
+ * 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 const mapSet = <K, V>(map: Map<K, V>, key: K, value: V): void => {
+    map.set(key, value);
+};
+
+/**
+ * Deletes a key from a map.
+ * @param map The map to delete from.
+ * @param key The key to delete.
+ */
+export const deleteMapEntry = <K, V>(map: Map<K, V>, key: K): void => {
+    map.delete(key);
+};
+
+/**
+ * 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 const mapHas = <K, V>(map: Map<K, V>, key: K): boolean => {
+    return map.has(key);
+};
+/**
+ * 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 const append = <T>(slice: Array<T>, ...elements: T[]): Array<T> => {
+    slice.push(...elements);
+    return slice;
+};
+
+/**
+ * Represents the result of a channel receive operation with 'ok' value
+ */
+export interface ChannelReceiveResult<T> {
+    value: T; // Should be T | ZeroValue<T>
+    ok: boolean;
+}
+
+/**
+ * Represents a result from a select operation
+ */
+export interface SelectResult<T> {
+    value: T; // Should be T | ZeroValue<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;
+}
+
+// A simple implementation of buffered channels
+class BufferedChannel<T> implements Channel<T> {
+    private buffer: T[] = [];
+    private closed: boolean = false;
+    private capacity: number;
+    private senders: Array<(value: boolean) => void> = []; // Resolvers for blocked senders
+    private receivers: Array<(value: T) => void> = []; // Resolvers for blocked receivers
+    private receiversWithOk: Array<(result: ChannelReceiveResult<T>) => void> = []; // For receive with ok
+    private zeroValue: T; // Store the zero value for the element type
+
+    constructor(capacity: number, zeroValue: T) {
+        this.capacity = capacity;
+        this.zeroValue = zeroValue;
+    }
+
+    async send(value: T): Promise<void> {
+        if (this.closed) {
+            throw new Error("send on closed channel");
+        }
+
+        // If there are waiting receivers, directly pass the value
+        if (this.receivers.length > 0) {
+            const receiver = this.receivers.shift()!;
+            receiver(value);
+            return;
+        }
+
+        // If there are waiting receivers with ok, directly pass the value and ok=true
+        if (this.receiversWithOk.length > 0) {
+            const receiver = this.receiversWithOk.shift()!;
+            receiver({ value, ok: true });
+            return;
+        }
+
+        // If buffer is not full, add to buffer
+        if (this.buffer.length < this.capacity) {
+            this.buffer.push(value);
+            return;
+        }
+
+        // Buffer is full, block the sender
+        return new Promise<void>((resolve, reject) => {
+            this.senders.push((success: boolean) => {
+                if (success) {
+                    this.buffer.push(value);
+                    resolve();
+                } else {
+                    reject(new Error("send on closed channel"));
+                }
+            });
+        });
+    }
+
+    async receive(): Promise<T> {
+        // If buffer has values, return from buffer
+        if (this.buffer.length > 0) {
+            const value = this.buffer.shift()!;
+
+            // If there are waiting senders, unblock one
+            if (this.senders.length > 0) {
+                const sender = this.senders.shift()!;
+                sender(true); // Unblock with success
+            }
+
+            return value;
+        }
+
+        // If channel is closed and buffer is empty, throw error (receive without ok)
+        if (this.closed) {
+            throw new Error("receive on closed channel");
+        }
+
+        // Buffer is empty, block the receiver
+        return new Promise<T>((resolve) => {
+            this.receivers.push(resolve);
+        });
+    }
+
+    async receiveWithOk(): Promise<ChannelReceiveResult<T>> {
+        // If buffer has values, return from buffer with ok=true
+        if (this.buffer.length > 0) {
+            const value = this.buffer.shift()!;
+
+            // If there are waiting senders, unblock one
+            if (this.senders.length > 0) {
+                const sender = this.senders.shift()!;
+                sender(true); // Unblock with success
+            }
+
+            return { value, ok: true };
+        }
+
+        // If channel is closed and buffer is empty, return zero value with ok=false
+        if (this.closed) {
+            return { value: this.zeroValue, ok: false }; // Return zeroValue
+        }
+
+        // Buffer is empty, block the receiver with ok
+        return new Promise<ChannelReceiveResult<T>>((resolve) => {
+            this.receiversWithOk.push(resolve);
+        });
+    }
+
+    async selectReceive(id: number): Promise<SelectResult<T>> {
+        // If buffer has values, return from buffer with ok=true
+        if (this.buffer.length > 0) {
+            const value = this.buffer.shift()!;
+
+            // If there are waiting senders, unblock one
+            if (this.senders.length > 0) {
+                const sender = this.senders.shift()!;
+                sender(true); // Unblock with success
+            }
+
+            return { value, ok: true, id };
+        }
+
+        // If channel is closed and buffer is empty, return zero value with ok=false
+        if (this.closed) {
+            return { value: this.zeroValue, ok: false, id }; // Return zeroValue
+        }
+
+        // Buffer is empty, return a promise that will be resolved when a value is available
+        return new Promise<SelectResult<T>>((resolve) => {
+            this.receiversWithOk.push((result) => {
+                resolve({ ...result, id });
+            });
+        });
+    }
+
+    async selectSend(value: T, id: number): Promise<SelectResult<boolean>> {
+        if (this.closed) {
+            return { value: false, ok: false, id };
+        }
+
+        // If there are waiting receivers, directly pass the value
+        if (this.receivers.length > 0) {
+            const receiver = this.receivers.shift()!;
+            receiver(value);
+            return { value: true, ok: true, id };
+        }
+
+        // If there are waiting receivers with ok, directly pass the value and ok=true
+        if (this.receiversWithOk.length > 0) {
+            const receiver = this.receiversWithOk.shift()!;
+            receiver({ value, ok: true });
+            return { value: true, ok: true, id };
+        }
+
+        // If buffer is not full, add to buffer
+        if (this.buffer.length < this.capacity) {
+            this.buffer.push(value);
+            return { value: true, ok: true, id };
+        }
+
+        // Buffer is full, return a promise that will be resolved when buffer space is available
+        return new Promise<SelectResult<boolean>>((resolve, reject) => {
+            this.senders.push((success: boolean) => {
+                if (success) {
+                    this.buffer.push(value);
+                    resolve({ value: true, ok: true, id });
+                } else {
+                    resolve({ value: false, ok: false, id });
+                }
+            });
+        });
+    }
+
+    close(): void {
+        if (this.closed) {
+            throw new Error("close of closed channel");
+        }
+
+        this.closed = true;
+
+        // Unblock all waiting senders with failure
+        for (const sender of this.senders) {
+            sender(false);
+        }
+        this.senders = [];
+
+        // Unblock all waiting receivers with the zero value
+        for (const receiver of this.receivers) {
+             // Note: receive() without ok throws on closed channel, this unblocking should not happen in correct Go logic
+             // but for safety, we'll resolve with zero value if it somehow does.
+            receiver(this.zeroValue);
+        }
+        this.receivers = [];
+
+        // Unblock all waiting receivers with ok=false and zero value
+        for (const receiver of this.receiversWithOk) {
+            receiver({ value: this.zeroValue, ok: false });
+        }
+        this.receiversWithOk = [];
+    }
+
+    /**
+     * Checks if the channel has data ready to be received without blocking.
+     * Used for non-blocking select operations.
+     */
+    canReceiveNonBlocking(): boolean {
+        return this.buffer.length > 0 || this.closed;
+    }
+
+    /**
+     * Checks if the channel can accept a send operation without blocking.
+     * Used for non-blocking select operations.
+     */
+    canSendNonBlocking(): boolean {
+        return !this.closed && this.buffer.length < this.capacity;
+    }
+}
+
+/**
+ * Represents a case in a select statement.
+ */
+export interface SelectCase<T> {
+    id: number;
+    isSend: boolean; // true for send, false for receive
+    channel: Channel<any>;
+    value?: any; // Value to send for send cases
+    // Optional handlers for when this case is selected
+    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 async function selectStatement<T>(
+    cases: SelectCase<T>[],
+    hasDefault: boolean = false
+): Promise<void> {
+    if (cases.length === 0 && !hasDefault) {
+         // Go spec: If there are no cases, the select statement blocks forever.
+         // Emulate blocking forever with a promise that never resolves.
+        return new Promise<void>(() => {}); // Promise never resolves
+    }
+
+    // 1. Check for ready (non-blocking) operations
+    const readyCases: SelectCase<T>[] = [];
+    for (const caseObj of cases) {
+        if (caseObj.id === -1) { // Skip default case in this check
+            continue
+        }
+        if (caseObj.isSend) {
+            if (caseObj.channel.canSendNonBlocking()) {
+                readyCases.push(caseObj);
+            }
+        } else {
+            if (caseObj.channel.canReceiveNonBlocking()) {
+                readyCases.push(caseObj);
+            }
+        }
+    }
+
+    if (readyCases.length > 0) {
+        // If one or more cases are ready, choose one pseudo-randomly
+        const selectedCase = readyCases[Math.floor(Math.random() * readyCases.length)];
+
+        // Execute the selected operation and its onSelected handler
+        if (selectedCase.isSend) {
+            const result = await selectedCase.channel.selectSend(selectedCase.value, selectedCase.id);
+             if (selectedCase.onSelected) {
+                await selectedCase.onSelected(result as SelectResult<T>); // Await the handler
+            }
+        } else {
+            const result = await selectedCase.channel.selectReceive(selectedCase.id);
+             if (selectedCase.onSelected) {
+                await selectedCase.onSelected(result); // Await the handler
+            }
+        }
+        return; // Return after executing a ready case
+    }
+
+    // 2. If no operations are ready and there's a default case, select default
+    if (hasDefault) {
+        // Find the default case (it will have id -1)
+        const defaultCase = cases.find(c => c.id === -1);
+        if (defaultCase && defaultCase.onSelected) {
+             // Execute the onSelected handler for the default case
+             await defaultCase.onSelected({ value: undefined, ok: false, id: -1 } as SelectResult<T>); // Await the handler
+        }
+        return; // Return after executing the default case
+    }
+
+    // 3. If no operations are ready and no default case, block until one is ready
+    // Use Promise.race on the blocking promises
+    const blockingPromises = cases.filter(c => c.id !== -1).map(caseObj => { // Exclude default case
+        if (caseObj.isSend) {
+            return caseObj.channel.selectSend(caseObj.value, caseObj.id);
+        } else {
+            return caseObj.channel.selectReceive(caseObj.id);
+        }
+    });
+
+    const result = await Promise.race(blockingPromises);
+     // Execute onSelected handler for the selected case
+    const selectedCase = cases.find(c => c.id === result.id);
+    if (selectedCase && selectedCase.onSelected) {
+        await selectedCase.onSelected(result); // Await the handler
+    }
+    // No explicit return needed here, as the function will implicitly return after the await
+}
+
+/**
+ * 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 const makeChannel = <T>(bufferSize: number, zeroValue: T): Channel<T> => {
+    return new BufferedChannel<T>(bufferSize, zeroValue);
+};

package/cmd/goscript/cmd_compile.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+	"context"
+
+	"github.com/aperturerobotics/cli"
+	"github.com/paralin/goscript/compiler"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+)
+
+var (
+	cliCompiler       *compiler.Compiler
+	cliCompilerConfig compiler.Config
+	cliCompilerPkg    string
+)
+
+// CompileCommands are commands related to compiling code.
+var CompileCommands = []*cli.Command{{
+	Name:     "compile",
+	Category: "compile",
+	Usage:    "compile a Go package to TypeScript",
+	Action:   compilePackage,
+	Before: func(c *cli.Context) (err error) {
+		logger := logrus.New()
+		logger.SetLevel(logrus.DebugLevel)
+		le := logrus.NewEntry(logger)
+		cliCompiler, err = compiler.NewCompiler(&cliCompilerConfig, le, nil)
+		return
+	},
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:        "package",
+			Usage:       "the package to compile",
+			Destination: &cliCompilerPkg,
+		},
+		&cli.StringFlag{
+			Name:        "output",
+			Usage:       "the output typescript path to use",
+			Destination: &cliCompilerConfig.OutputPathRoot,
+			Value:       "./output",
+		},
+		&cli.StringFlag{
+			Name:        "dir",
+			Usage:       "the working directory to use for the compiler (default: current directory)",
+			Destination: &cliCompilerConfig.Dir,
+			Value:       "",
+		},
+	},
+}}
+
+// compilePackage tries to compile the package.
+func compilePackage(c *cli.Context) error {
+	if cliCompilerPkg == "" {
+		return errors.New("package must be specified")
+	}
+
+	return cliCompiler.CompilePackages(context.Background(), cliCompilerPkg)
+}

package/cmd/goscript/main.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"os"
+
+	"github.com/aperturerobotics/cli"
+)
+
+func main() {
+	app := cli.NewApp()
+
+	app.Authors = []*cli.Author{
+		{Name: "Christian Stewart", Email: "christian@aperture.us"},
+	}
+
+	app.Usage = "GoScript compiles Go to Typescript."
+	app.Commands = append(app.Commands, CompileCommands...)
+
+	if err := app.Run(os.Args); err != nil {
+		_, _ = os.Stderr.WriteString(err.Error() + "\n")
+		os.Exit(1)
+	}
+}