goscript 0.0.25 → 0.0.28

package/gs/builtin/defer.ts

@@ -0,0 +1,58 @@
+/**
+ * DisposableStack manages synchronous disposable resources, mimicking Go's defer behavior.
+ * Functions added via `defer` are executed in LIFO order when the stack is disposed.
+ * Implements the `Disposable` interface for use with `using` declarations.
+ */
+export class DisposableStack implements Disposable {
+  private stack: (() => void)[] = []
+
+  /**
+   * Adds a function to be executed when the stack is disposed.
+   * @param fn The function to defer.
+   */
+  defer(fn: () => void): void {
+    this.stack.push(fn)
+  }
+
+  /**
+   * Disposes of the resources in the stack by executing the deferred functions
+   * in Last-In, First-Out (LIFO) order.
+   * If a deferred function throws an error, disposal stops, and the error is rethrown,
+   * similar to Go's panic behavior during defer execution.
+   */
+  [Symbol.dispose](): void {
+    // Emulate Go: if a deferred throws, stop and rethrow
+    while (this.stack.length) {
+      const fn = this.stack.pop()!
+      fn()
+    }
+  }
+}
+
+/**
+ * AsyncDisposableStack manages asynchronous disposable resources, mimicking Go's defer behavior.
+ * Functions added via `defer` are executed sequentially in LIFO order when the stack is disposed.
+ * Implements the `AsyncDisposable` interface for use with `await using` declarations.
+ */
+export class AsyncDisposableStack implements AsyncDisposable {
+  private stack: (() => Promise<void> | void)[] = []
+
+  /**
+   * Adds a synchronous or asynchronous function to be executed when the stack is disposed.
+   * @param fn The function to defer. Can return void or a Promise<void>.
+   */
+  defer(fn: () => Promise<void> | void): void {
+    this.stack.push(fn)
+  }
+
+  /**
+   * Asynchronously disposes of the resources in the stack by executing the deferred functions
+   * sequentially in Last-In, First-Out (LIFO) order. It awaits each function if it returns a promise.
+   */
+  async [Symbol.asyncDispose](): Promise<void> {
+    // Execute in LIFO order, awaiting each potentially async function
+    for (let i = this.stack.length - 1; i >= 0; --i) {
+      await this.stack[i]()
+    }
+  }
+}

package/gs/builtin/index.ts

@@ -0,0 +1 @@
+export * from './builtin.js'

package/gs/builtin/io.ts

@@ -0,0 +1,22 @@
+/**
+ * Implementation of Go's built-in println function
+ * @param args Arguments to print
+ */
+export function println(...args: any[]): void {
+  console.log(...args)
+}
+
+/**
+ * Implementation of Go's built-in panic function
+ * @param args Arguments passed to panic
+ */
+export function panic(...args: any[]): void {
+  throw new Error(`panic: ${args.map((arg) => String(arg)).join(' ')}`)
+}
+
+/**
+ * Represents the Go error type (interface).
+ */
+export type GoError = {
+  Error(): string
+} | null

package/gs/builtin/map.ts

@@ -0,0 +1,50 @@
+/**
+ * Creates a new map (TypeScript Map).
+ * @returns A new TypeScript Map.
+ */
+export const makeMap = <K, V>(): Map<K, V> => {
+  return new Map<K, V>()
+}
+/**
+ * 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)
+}