goscript 0.0.25 → 0.0.28

package/gs/builtin/varRef.ts

@@ -0,0 +1,25 @@
+/**
+ * VarRef represents a Go variable which can be referred to by other variables.
+ *
+ * For example:
+ *   var myVariable int // variable referenced
+ *   myOtherVar := &myVariable
+ */
+export type VarRef<T> = { value: T }
+
+/** Wrap a non-null T in a variable reference. */
+export function varRef<T>(v: T): VarRef<T> {
+  // We create a new object wrapper for every varRef call to ensure
+  // distinct pointer identity, crucial for pointer comparisons (p1 == p2).
+  return { value: v }
+}
+
+/** Dereference a variable reference, throws on null → simulates Go panic. */
+export function unref<T>(b: VarRef<T>): T {
+  if (b === null) {
+    throw new Error(
+      'runtime error: invalid memory address or nil pointer dereference',
+    )
+  }
+  return b.value
+}

package/gs/cmp/godoc.txt

@@ -0,0 +1,8 @@
+package cmp // import "cmp"
+
+Package cmp provides types and functions related to comparing ordered values.
+
+func Compare[T Ordered](x, y T) int
+func Less[T Ordered](x, y T) bool
+func Or[T comparable](vals ...T) T
+type Ordered interface{ ... }

package/gs/cmp/index.ts

@@ -0,0 +1,29 @@
+// Minimal stub for cmp package
+// This provides the Ordered type and comparison functions needed by slices
+
+// Ordered represents types that can be ordered (comparable)
+export type Ordered = number | string | boolean | bigint
+
+// Compare compares two values and returns:
+// -1 if a < b
+//  0 if a == b
+//  1 if a > b
+export function Compare<T extends Ordered>(a: T, b: T): number {
+  if (a < b) return -1
+  if (a > b) return 1
+  return 0
+}
+
+// Less reports whether a < b
+export function Less<T extends Ordered>(a: T, b: T): boolean {
+  return a < b
+}
+
+// Or returns the first non-zero result from the comparison functions,
+// or zero if all comparisons return zero
+export function Or(...comparisons: number[]): number {
+  for (const cmp of comparisons) {
+    if (cmp !== 0) return cmp
+  }
+  return 0
+}

package/gs/context/context.ts

@@ -0,0 +1,401 @@
+import * as $ from '@goscript/builtin/builtin.js'
+
+export const Canceled = new Error('context canceled')
+Canceled.name = 'CanceledError'
+
+export class DeadlineExceededError extends Error {
+  constructor() {
+    super('context deadline exceeded')
+    this.name = 'DeadlineExceededError'
+  }
+}
+export const DeadlineExceeded = new DeadlineExceededError()
+
+// Function types
+export type CancelFunc = () => void
+export type CancelCauseFunc = (cause: Error | null) => void
+
+// Context interface matching Go's context.Context
+export interface Context {
+  // Deadline returns the time when work done on behalf of this context should be canceled
+  Deadline(): [Date | null, boolean]
+
+  // Done returns a channel that's closed when work done on behalf of this context should be canceled
+  Done(): $.Channel<{}>
+
+  // Err returns a non-nil error value after Done is closed
+  Err(): Error | null
+
+  // Value returns the value associated with this context for key, or null
+  Value(key: any): any
+}
+
+// Base implementation for all contexts
+abstract class baseContext implements Context {
+  abstract Deadline(): [Date | null, boolean]
+  abstract Done(): $.Channel<{}>
+  abstract Err(): Error | null
+  abstract Value(key: any): any
+}
+
+// Background/TODO context that is never canceled
+class backgroundContext extends baseContext {
+  private static readonly neverClosedChannel = $.makeChannel<{}>(0, {}, 'both')
+
+  static getNeverClosedChannel(): $.Channel<{}> {
+    return backgroundContext.neverClosedChannel
+  }
+
+  Deadline(): [Date | null, boolean] {
+    return [null, false]
+  }
+
+  Done(): $.Channel<{}> {
+    return backgroundContext.neverClosedChannel
+  }
+
+  Err(): Error | null {
+    return null
+  }
+
+  Value(key: any): any {
+    return null
+  }
+}
+
+// Value context wraps a parent and adds a key-value pair
+class valueContext extends baseContext {
+  constructor(
+    private parent: Context,
+    private key: any,
+    private val: any,
+  ) {
+    super()
+  }
+
+  getParent(): Context {
+    return this.parent
+  }
+
+  Deadline(): [Date | null, boolean] {
+    return this.parent.Deadline()
+  }
+
+  Done(): $.Channel<{}> {
+    return this.parent.Done()
+  }
+
+  Err(): Error | null {
+    return this.parent.Err()
+  }
+
+  Value(key: any): any {
+    if (this.key === key) {
+      return this.val
+    }
+    return this.parent.Value(key)
+  }
+}
+
+// Cancel context that can be canceled
+class cancelContext extends baseContext {
+  protected doneChannel: $.Channel<{}>
+  protected err: Error | null = null
+  protected cause: Error | null = null
+  protected children: Set<cancelContext> = new Set()
+  protected parent: Context
+  protected parentCancelCtx: cancelContext | null = null
+  protected removeFromParent: (() => void) | null = null
+
+  constructor(parent: Context) {
+    super()
+    this.parent = parent
+    this.doneChannel = $.makeChannel<{}>(0, {}, 'both')
+  }
+
+  Deadline(): [Date | null, boolean] {
+    return this.parent.Deadline()
+  }
+
+  Done(): $.Channel<{}> {
+    return this.doneChannel
+  }
+
+  Err(): Error | null {
+    return this.err
+  }
+
+  Value(key: any): any {
+    return this.parent.Value(key)
+  }
+
+  getCause(): Error | null {
+    if (this.cause !== null) {
+      return this.cause
+    }
+    return this.err
+  }
+
+  cancel(removeFromParent: boolean, err: Error, cause: Error | null): void {
+    if (this.err !== null) {
+      return // Already canceled
+    }
+
+    this.err = err
+    this.cause = cause
+    this.doneChannel.close()
+
+    // Cancel all children
+    for (const child of this.children) {
+      child.cancel(false, err, cause)
+    }
+    this.children.clear()
+
+    // Remove from parent's children if requested
+    if (removeFromParent && this.removeFromParent) {
+      this.removeFromParent()
+      this.removeFromParent = null
+    }
+  }
+
+  propagateCancel(): void {
+    // Find parent cancelContext if any
+    let parent = this.parent
+    while (parent instanceof valueContext) {
+      parent = (parent as valueContext).getParent()
+    }
+
+    if (parent instanceof cancelContext) {
+      // Parent is a cancel context, register as child
+      this.parentCancelCtx = parent
+      if (parent.err !== null) {
+        // Parent already canceled
+        this.cancel(false, parent.err, parent.cause)
+      } else {
+        parent.children.add(this)
+        this.removeFromParent = () => {
+          parent.children.delete(this)
+        }
+      }
+    } else {
+      // Watch parent's Done channel
+      this.watchParentDone()
+    }
+  }
+
+  private watchParentDone(): void {
+    const parentDone = this.parent.Done()
+    ;(async () => {
+      try {
+        await parentDone.receive()
+      } catch {
+        // Channel closed
+      }
+      // Parent is done, cancel this context
+      const parentErr = this.parent.Err()
+      if (parentErr && this.err === null) {
+        this.cancel(false, parentErr, null)
+      }
+    })()
+  }
+}
+
+// Timer context with deadline
+class timerContext extends cancelContext {
+  private deadline: Date
+  private timer: any
+
+  constructor(parent: Context, deadline: Date) {
+    super(parent)
+    this.deadline = deadline
+  }
+
+  Deadline(): [Date | null, boolean] {
+    return [this.deadline, true]
+  }
+
+  startTimer(): void {
+    const now = Date.now()
+    const duration = this.deadline.getTime() - now
+
+    if (duration <= 0) {
+      // Already expired
+      this.cancel(true, DeadlineExceeded, null)
+      return
+    }
+
+    this.timer = setTimeout(() => {
+      this.cancel(true, DeadlineExceeded, null)
+    }, duration)
+  }
+
+  cancel(removeFromParent: boolean, err: Error, cause: Error | null): void {
+    super.cancel(removeFromParent, err, cause)
+    if (this.timer) {
+      clearTimeout(this.timer)
+      this.timer = null
+    }
+  }
+}
+
+// Without cancel context - inherits values but not cancellation
+class withoutCancelContext extends baseContext {
+  constructor(private parent: Context) {
+    super()
+  }
+
+  Deadline(): [Date | null, boolean] {
+    return [null, false]
+  }
+
+  Done(): $.Channel<{}> {
+    return backgroundContext.getNeverClosedChannel()
+  }
+
+  Err(): Error | null {
+    return null
+  }
+
+  Value(key: any): any {
+    return this.parent.Value(key)
+  }
+}
+
+// Singleton contexts
+const background = new backgroundContext()
+const todo = new backgroundContext()
+
+// Background returns a non-nil, empty Context that is never canceled
+export function Background(): Context {
+  return background
+}
+
+// TODO returns a non-nil, empty Context
+export function TODO(): Context {
+  return todo
+}
+
+// WithCancel returns a copy of parent with a new Done channel
+export function WithCancel(parent: Context): [Context, CancelFunc] {
+  const ctx = new cancelContext(parent)
+  ctx.propagateCancel()
+
+  return [
+    ctx,
+    () => {
+      ctx.cancel(true, Canceled, null)
+    },
+  ]
+}
+
+// WithCancelCause returns a copy of parent with a new Done channel and cause recording
+export function WithCancelCause(parent: Context): [Context, CancelCauseFunc] {
+  const ctx = new cancelContext(parent)
+  ctx.propagateCancel()
+
+  return [
+    ctx,
+    (cause: Error | null) => {
+      ctx.cancel(true, Canceled, cause)
+    },
+  ]
+}
+
+// WithDeadline returns a copy of parent with the deadline adjusted to be no later than d
+export function WithDeadline(parent: Context, d: Date): [Context, CancelFunc] {
+  return WithDeadlineCause(parent, d, null)
+}
+
+// WithDeadlineCause is like WithDeadline but also sets the cause
+export function WithDeadlineCause(
+  parent: Context,
+  d: Date,
+  cause: Error | null,
+): [Context, CancelFunc] {
+  // Check if parent deadline is already earlier
+  const [parentDeadline, ok] = parent.Deadline()
+  if (ok && parentDeadline && parentDeadline <= d) {
+    // Parent deadline is already sooner
+    return WithCancel(parent)
+  }
+
+  const ctx = new timerContext(parent, d)
+  ctx.propagateCancel()
+  ctx.startTimer()
+
+  return [
+    ctx,
+    () => {
+      ctx.cancel(true, Canceled, cause)
+    },
+  ]
+}
+
+// WithTimeout returns WithDeadline(parent, Date.now() + timeout)
+export function WithTimeout(
+  parent: Context,
+  timeout: number,
+): [Context, CancelFunc] {
+  return WithDeadline(parent, new Date(Date.now() + timeout))
+}
+
+// WithTimeoutCause is like WithTimeout but also sets the cause
+export function WithTimeoutCause(
+  parent: Context,
+  timeout: number,
+  cause: Error | null,
+): [Context, CancelFunc] {
+  return WithDeadlineCause(parent, new Date(Date.now() + timeout), cause)
+}
+
+// WithValue returns a copy of parent with the value associated with key
+export function WithValue(parent: Context, key: any, val: any): Context {
+  return new valueContext(parent, key, val)
+}
+
+// WithoutCancel returns a context that inherits values but not cancellation
+export function WithoutCancel(parent: Context): Context {
+  return new withoutCancelContext(parent)
+}
+
+// Cause returns the underlying cause of the context's cancellation
+export function Cause(ctx: Context): Error | null {
+  let c = ctx
+  // Unwrap value contexts
+  while (c instanceof valueContext) {
+    c = (c as valueContext).getParent()
+  }
+
+  if (c instanceof cancelContext) {
+    return c.getCause()
+  }
+
+  return c.Err()
+}
+
+// AfterFunc runs f in a separate goroutine after ctx is done
+export function AfterFunc(ctx: Context, f: () => void): () => boolean {
+  let stopped = false
+  let done = false
+
+  const promise = (async () => {
+    try {
+      await ctx.Done().receive()
+    } catch {
+      // Channel closed
+    }
+    if (!stopped) {
+      done = true
+      // Run in next tick to simulate goroutine
+      setImmediate(f)
+    }
+  })()
+
+  return () => {
+    if (!done) {
+      stopped = true
+      return true
+    }
+    return false
+  }
+}

package/gs/context/godoc.txt

@@ -0,0 +1,69 @@
+package context // import "context"
+
+Package context defines the Context type, which carries deadlines, cancellation
+signals, and other request-scoped values across API boundaries and between
+processes.
+
+Incoming requests to a server should create a Context, and outgoing calls to
+servers should accept a Context. The chain of function calls between them must
+propagate the Context, optionally replacing it with a derived Context created
+using WithCancel, WithDeadline, WithTimeout, or WithValue.
+
+A Context may be canceled to indicate that work done on its behalf should stop.
+A Context with a deadline is canceled after the deadline passes. When a Context
+is canceled, all Contexts derived from it are also canceled.
+
+The WithCancel, WithDeadline, and WithTimeout functions take a Context (the
+parent) and return a derived Context (the child) and a CancelFunc. Calling the
+CancelFunc directly cancels the child and its children, removes the parent's
+reference to the child, and stops any associated timers. Failing to call the
+CancelFunc leaks the child and its children until the parent is canceled.
+The go vet tool checks that CancelFuncs are used on all control-flow paths.
+
+The WithCancelCause, WithDeadlineCause, and WithTimeoutCause functions return a
+CancelCauseFunc, which takes an error and records it as the cancellation cause.
+Calling Cause on the canceled context or any of its children retrieves the
+cause. If no cause is specified, Cause(ctx) returns the same value as ctx.Err().
+
+Programs that use Contexts should follow these rules to keep interfaces
+consistent across packages and enable static analysis tools to check context
+propagation:
+
+Do not store Contexts inside a struct type; instead, pass a Context
+explicitly to each function that needs it. This is discussed further in
+https://go.dev/blog/context-and-structs. The Context should be the first
+parameter, typically named ctx:
+
+    func DoSomething(ctx context.Context, arg Arg) error {
+    	// ... use ctx ...
+    }
+
+Do not pass a nil Context, even if a function permits it. Pass context.TODO if
+you are unsure about which Context to use.
+
+Use context Values only for request-scoped data that transits processes and
+APIs, not for passing optional parameters to functions.
+
+The same Context may be passed to functions running in different goroutines;
+Contexts are safe for simultaneous use by multiple goroutines.
+
+See https://go.dev/blog/context for example code for a server that uses
+Contexts.
+
+var Canceled = errors.New("context canceled")
+var DeadlineExceeded error = deadlineExceededError{}
+func AfterFunc(ctx Context, f func()) (stop func() bool)
+func Cause(c Context) error
+func WithCancel(parent Context) (ctx Context, cancel CancelFunc)
+func WithCancelCause(parent Context) (ctx Context, cancel CancelCauseFunc)
+func WithDeadline(parent Context, d time.Time) (Context, CancelFunc)
+func WithDeadlineCause(parent Context, d time.Time, cause error) (Context, CancelFunc)
+func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
+func WithTimeoutCause(parent Context, timeout time.Duration, cause error) (Context, CancelFunc)
+type CancelCauseFunc func(cause error)
+type CancelFunc func()
+type Context interface{ ... }
+    func Background() Context
+    func TODO() Context
+    func WithValue(parent Context, key, val any) Context
+    func WithoutCancel(parent Context) Context

package/gs/context/index.ts

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