goscript 0.1.0 → 0.1.1

package/gs/runtime/runtime.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  Compiler,
+  FuncForPC,
+  ReadTrace,
+  StartTrace,
+  StopTrace,
+} from './runtime.js'
+
+describe('runtime override', () => {
+  it('exposes stack and trace compatibility helpers', () => {
+    expect(Compiler).toBe('gc')
+    expect(FuncForPC(0)).toBeNull()
+    expect(StartTrace()).toBeNull()
+    expect(ReadTrace()).toBeNull()
+    expect(() => StopTrace()).not.toThrow()
+  })
+})

package/gs/runtime/runtime.ts

@@ -1,9 +1,12 @@
+import * as $ from '@goscript/builtin/index.js'
+
 // Runtime constants for the JavaScript/WebAssembly target
-export const GOOS = 'js'
-export const GOARCH = 'wasm'
+export const GOOS: string = 'js'
+export const GOARCH: string = 'wasm'
+export const Compiler: string = 'gc'
 
 // Version returns the Go version as a string
-export const GOVERSION = 'go1.25.3'
+export const GOVERSION: string = 'go1.25.3'
 export function Version(): string {
   return GOVERSION
 }
@@ -79,6 +82,79 @@ export function Caller(_skip: number): [number, string, number, boolean] {
   return [pc, file, line, ok]
 }
 
+// Func represents metadata for a function in a stack frame.
+export class Func {
+  public Entry(): number {
+    return 0
+  }
+
+  public FileLine(_pc: number): [string, number] {
+    return ['', 0]
+  }
+
+  public Name(): string {
+    return ''
+  }
+}
+
+// FuncForPC returns function metadata for a program counter.
+export function FuncForPC(_pc: number): Func | null {
+  return null
+}
+
+// StartTrace enables execution tracing.
+export function StartTrace(): $.GoError {
+  return null
+}
+
+// StopTrace stops execution tracing.
+export function StopTrace(): void {}
+
+// ReadTrace returns the next execution trace chunk.
+export function ReadTrace(): $.Slice<number> {
+  return null
+}
+
+// Frame represents a single call frame.
+export class Frame {
+  public PC = 0
+  public Func: Func | null = null
+  public Function = ''
+  public File = ''
+  public Line = 0
+  public Entry = 0
+}
+
+// Frames iterates over call frames.
+export class Frames {
+  private readonly frames: Frame[]
+  private index = 0
+
+  constructor(frames: Frame[] = []) {
+    this.frames = frames
+  }
+
+  public Next(): [Frame, boolean] {
+    if (this.index >= this.frames.length) {
+      return [new Frame(), false]
+    }
+
+    const frame = this.frames[this.index]
+    this.index++
+    return [frame, this.index < this.frames.length]
+  }
+}
+
+// Callers fills pc with return program counters from the current stack.
+export function Callers(_skip: number, _pc: $.Slice<number>): number {
+  return 0
+}
+
+// CallersFrames returns an iterator over call frames for pcs.
+export function CallersFrames(_callers: $.Slice<number>): Frames {
+  return new Frames()
+}
+
 // Stack returns a formatted stack trace of the calling goroutine.
 // In JavaScript, we use Error.stack
 export function Stack(): Uint8Array {
@@ -167,6 +243,25 @@ export function SetFinalizer(
   )
 }
 
+// Cleanup is a handle to a cleanup call for a specific object.
+export class Cleanup {
+  public Stop(): void {}
+
+  public clone(): Cleanup {
+    return new Cleanup()
+  }
+}
+
+// AddCleanup registers cleanup to run when ptr is no longer reachable.
+export function AddCleanup<T, S>(
+  _ptr: T,
+  _cleanup: (arg: S) => void | Promise<void>,
+  _arg: S,
+): Cleanup {
+  // JavaScript runtimes do not provide Go's cleanup scheduling contract here.
+  return new Cleanup()
+}
+
 // KeepAlive keeps obj reachable until the point where KeepAlive is called
 export function KeepAlive(obj: any): void {
   // In JavaScript, just accessing the object keeps it alive for this call

package/gs/slices/slices.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import {
+  Backward,
+  IsSorted,
+  IsSortedFunc,
+  Max,
+  Sorted,
+  SortStableFunc,
+} from './slices.js'
+
+describe('slices.SortStableFunc', () => {
+  it('preserves original order for equal elements', () => {
+    const values = $.arrayToSlice([
+      { group: 2, label: 'a' },
+      { group: 1, label: 'b' },
+      { group: 2, label: 'c' },
+      { group: 1, label: 'd' },
+    ])
+
+    SortStableFunc(values, (a, b) => a.group - b.group)
+
+    expect(values?.map((value) => value.label)).toEqual(['b', 'd', 'a', 'c'])
+  })
+})
+
+describe('slices.Sorted', () => {
+  it('collects and sorts iterator values', () => {
+    const values = Sorted<string>((yieldValue) => {
+      yieldValue('c')
+      yieldValue('a')
+      yieldValue('b')
+    })
+
+    expect(values).toEqual(['a', 'b', 'c'])
+  })
+})
+
+describe('slices.Backward', () => {
+  it('yields index-value pairs from the end', () => {
+    const visited: Array<[number, string]> = []
+    Backward($.arrayToSlice(['a', 'b', 'c']))((index, value) => {
+      visited.push([index, value])
+      return true
+    })
+
+    expect(visited).toEqual([
+      [2, 'c'],
+      [1, 'b'],
+      [0, 'a'],
+    ])
+  })
+
+  it('accepts async yield callbacks', async () => {
+    const visited: Array<[number, string]> = []
+    await Backward($.arrayToSlice(['a', 'b', 'c']))(async (index, value) => {
+      visited.push([index, value])
+      return index > 1
+    })
+
+    expect(visited).toEqual([
+      [2, 'c'],
+      [1, 'b'],
+    ])
+  })
+})
+
+describe('slices.IsSorted', () => {
+  it('reports ordered and unordered slices', () => {
+    expect(IsSorted($.arrayToSlice([1, 2, 3]))).toBe(true)
+    expect(IsSorted($.arrayToSlice([1, 3, 2]))).toBe(false)
+    expect(
+      IsSortedFunc($.arrayToSlice(['aa', 'b']), (a, b) => a.length - b.length),
+    ).toBe(false)
+    expect(
+      IsSortedFunc($.arrayToSlice(['b', 'aa']), (a, b) => a.length - b.length),
+    ).toBe(true)
+  })
+})
+
+describe('slices.Max', () => {
+  it('returns the greatest ordered value', () => {
+    expect(Max($.arrayToSlice([3, 1, 4, 2]))).toBe(4)
+    expect(Max($.arrayToSlice(['beta', 'alpha', 'gamma']))).toBe('gamma')
+  })
+
+  it('panics for empty slices', () => {
+    expect(() => Max($.arrayToSlice<number>([]))).toThrow(
+      'slices.Max: empty list',
+    )
+  })
+})

package/gs/slices/slices.ts

@@ -1,6 +1,7 @@
 // TypeScript implementation of Go's slices package
 import * as $ from '@goscript/builtin/index.js'
 import * as cmp from '../cmp/index.js'
+import * as iter from '../iter/index.js'
 
 /**
  * Compare compares the elements of s1 and s2 using cmp.Compare.
@@ -41,6 +42,22 @@ export function Compare<T extends string | number>(
   return 0
 }
 
+/**
+ * Clone returns a shallow copy of s while preserving nilness.
+ * @param s The slice to clone
+ * @returns A new slice with the same elements, or null for a nil slice
+ */
+export function Clone<T>(s: $.Slice<T>): $.Slice<T> {
+  if (s == null) {
+    return null
+  }
+  const out = $.makeSlice<T>($.len(s))
+  for (let i = 0; i < $.len(s); i++) {
+    ;(out as any)[i] = (s as any)[i] as T
+  }
+  return out
+}
+
 /**
  * All returns an iterator over index-value pairs in the slice.
  * This is equivalent to Go's slices.All function.
@@ -61,15 +78,79 @@ export function All<T>(
   }
 }
 
-/**
- * Sort sorts a slice in ascending order.
- * This is equivalent to Go's slices.Sort function.
- * @param s The slice to sort in place
- */
+export function Backward<T>(
+  s: $.Slice<T>,
+): (
+  _yield: (index: number, value: T) => boolean | globalThis.Promise<boolean>
+) => void | globalThis.Promise<void> {
+  return function (
+    _yield: (index: number, value: T) => boolean | globalThis.Promise<boolean>,
+  ): void | globalThis.Promise<void> {
+    const walk = (i: number): void | globalThis.Promise<void> => {
+      for (; i >= 0; i--) {
+        const keepGoing = _yield(i, (s as any)[i] as T)
+        if (keepGoing instanceof Promise) {
+          return keepGoing.then((next) => {
+            if (next) {
+              return walk(i - 1)
+            }
+          })
+        }
+        if (!keepGoing) {
+          break
+        }
+      }
+    }
+    const length = $.len(s)
+    if (length === 0) {
+      return
+    }
+    return walk(length - 1)
+  }
+}
+
 export function Sort<T extends string | number>(s: $.Slice<T>): void {
   $.sortSlice(s)
 }
 
+export function IsSorted<T extends string | number>(x: $.Slice<T>): boolean {
+  for (let i = $.len(x) - 1; i > 0; i--) {
+    if (cmp.Compare((x as any)[i] as T, (x as any)[i - 1] as T) < 0) {
+      return false
+    }
+  }
+  return true
+}
+
+export function Max<T extends cmp.Ordered>(x: $.Slice<T>): T {
+  if ($.len(x) === 0) {
+    throw new Error('slices.Max: empty list')
+  }
+  let max = (x as any)[0] as T
+  for (let i = 1; i < $.len(x); i++) {
+    const value = (x as any)[i] as T
+    if (cmp.Compare(max, value) < 0) {
+      max = value
+    }
+  }
+  return max
+}
+
+export function Collect<T>(seq: iter.Seq<T>): $.Slice<T> {
+  const out: T[] = []
+  seq((value) => {
+    out.push(value)
+    return true
+  })
+  return out.length === 0 ? null : out
+}
+
+export function Sorted<T extends string | number>(seq: iter.Seq<T>): $.Slice<T> {
+  const out = Collect(seq)
+  Sort(out)
+  return out
+}
+
 /**
  * Delete removes the elements s[i:j] from s, returning the modified slice.
  * Delete panics if j > len(s) or s[i:j] is not a valid slice of s.
@@ -102,6 +183,112 @@ export function Delete<T>(s: $.Slice<T>, i: number, j: number): $.Slice<T> {
   return $.goSlice(s, 0, length - deleteCount) as $.Slice<T>
 }
 
+export function DeleteFunc<T>(
+  s: $.Slice<T>,
+  del: (value: T) => boolean,
+): $.Slice<T> {
+  if (s === null || s === undefined) {
+    return s
+  }
+  let w = 0
+  for (let i = 0; i < s.length; i++) {
+    const value = s[i] as T
+    if (!del(value)) {
+      ;(s as any)[w] = value
+      w++
+    }
+  }
+  for (let i = w; i < s.length; i++) {
+    ;(s as any)[i] = clearValue(s)
+  }
+  return $.goSlice(s, 0, w) as $.Slice<T>
+}
+
+export function Equal<T>(s1: $.Slice<T>, s2: $.Slice<T>): boolean {
+  const len1 = $.len(s1)
+  if (len1 !== $.len(s2)) {
+    return false
+  }
+  for (let i = 0; i < len1; i++) {
+    if ((s1 as any)[i] !== (s2 as any)[i]) {
+      return false
+    }
+  }
+  return true
+}
+
+export function EqualFunc<T, U>(
+  s1: $.Slice<T>,
+  s2: $.Slice<U>,
+  eq: (v1: T, v2: U) => boolean,
+): boolean {
+  const len1 = $.len(s1)
+  if (len1 !== $.len(s2)) {
+    return false
+  }
+  for (let i = 0; i < len1; i++) {
+    if (!eq((s1 as any)[i] as T, (s2 as any)[i] as U)) {
+      return false
+    }
+  }
+  return true
+}
+
+export function Index<T>(s: $.Slice<T>, v: T): number {
+  for (let i = 0; i < $.len(s); i++) {
+    if ((s as any)[i] === v) {
+      return i
+    }
+  }
+  return -1
+}
+
+export function IndexFunc<T>(s: $.Slice<T>, f: (v: T) => boolean): number {
+  for (let i = 0; i < $.len(s); i++) {
+    if (f((s as any)[i] as T)) {
+      return i
+    }
+  }
+  return -1
+}
+
+export function Contains<T>(s: $.Slice<T>, v: T): boolean {
+  return Index(s, v) >= 0
+}
+
+export function ContainsFunc<T>(s: $.Slice<T>, f: (v: T) => boolean): boolean {
+  return IndexFunc(s, f) >= 0
+}
+
+export function Insert<T>(s: $.Slice<T>, i: number, ...v: T[]): $.Slice<T> {
+  const length = $.len(s)
+  if (i < 0 || i > length) {
+    throw new Error(`slice bounds out of range [${i}:${i}] with length ${length}`)
+  }
+  if (v.length === 0) {
+    return s
+  }
+  const out = $.makeSlice<T>(length + v.length)
+  for (let idx = 0; idx < i; idx++) {
+    ;(out as any)[idx] = (s as any)[idx]
+  }
+  for (let idx = 0; idx < v.length; idx++) {
+    ;(out as any)[i + idx] = v[idx]
+  }
+  for (let idx = i; idx < length; idx++) {
+    ;(out as any)[idx + v.length] = (s as any)[idx]
+  }
+  return out
+}
+
+export function Reverse<T>(s: $.Slice<T>): void {
+  for (let i = 0, j = $.len(s) - 1; i < j; i++, j--) {
+    const tmp = (s as any)[i]
+    ;(s as any)[i] = (s as any)[j]
+    ;(s as any)[j] = tmp
+  }
+}
+
 /**
  * Grow increases the slice's capacity, if necessary, to guarantee space for
  * another n elements. After Grow(n), at least n elements can be appended
@@ -154,6 +341,59 @@ export function SortFunc<T>(s: $.Slice<T>, cmp: (a: T, b: T) => number): void {
   arr.sort(cmp)
 }
 
+export function IsSortedFunc<T>(
+  x: $.Slice<T>,
+  cmp: (a: T, b: T) => number,
+): boolean {
+  for (let i = $.len(x) - 1; i > 0; i--) {
+    if (cmp((x as any)[i] as T, (x as any)[i - 1] as T) < 0) {
+      return false
+    }
+  }
+  return true
+}
+
+export function SortStableFunc<T>(
+  s: $.Slice<T>,
+  cmp: (a: T, b: T) => number,
+): void {
+  if (s === null || s === undefined) {
+    return
+  }
+  const sorted = (s as any as T[])
+    .map((value, index) => ({ value, index }))
+    .sort((a, b) => {
+      const result = cmp(a.value, b.value)
+      if (result !== 0) {
+        return result
+      }
+      return a.index - b.index
+    })
+  for (let i = 0; i < sorted.length; i++) {
+    ;(s as any)[i] = sorted[i].value
+  }
+}
+
+function clearValue<T>(s: $.Slice<T>): T | null {
+  if (s instanceof Uint8Array) {
+    return 0 as T
+  }
+  for (const value of s ?? []) {
+    if (value !== null && value !== undefined) {
+      switch (typeof value) {
+        case 'number':
+          return 0 as T
+        case 'string':
+          return '' as T
+        case 'boolean':
+          return false as T
+      }
+      break
+    }
+  }
+  return null
+}
+
 /**
  * BinarySearchFunc works like BinarySearch, but uses a custom comparison function.
  * The slice must be sorted in increasing order, where "increasing" is defined by cmp.

package/gs/sort/meta.json

@@ -0,0 +1,7 @@
+{
+  "asyncFunctions": {
+    "Slice": true,
+    "SliceIsSorted": true,
+    "SliceStable": true
+  }
+}

package/gs/sort/slice.gs.ts

@@ -27,25 +27,31 @@ function swapInSlice<T>(slice: $.Slice<T>, i: number, j: number): void {
 }
 
 // Slice sorts the slice x given the provided less function
-export function Slice(x: $.Slice<any>, less: (i: number, j: number) => boolean): void {
+export async function Slice(
+  x: $.Slice<any>,
+  less: (i: number, j: number) => boolean | globalThis.Promise<boolean>
+): globalThis.Promise<void> {
   if (!x) return
   
   // Simple insertion sort using the provided less function
   const n = $.len(x)
   for (let i = 1; i < n; i++) {
-    for (let j = i; j > 0 && less(j, j - 1); j--) {
+    for (let j = i; j > 0 && await less(j, j - 1); j--) {
       swapInSlice(x, j, j - 1)
     }
   }
 }
 
 // SliceIsSorted reports whether the slice x is sorted according to the provided less function
-export function SliceIsSorted(x: $.Slice<any>, less: (i: number, j: number) => boolean): boolean {
+export async function SliceIsSorted(
+  x: $.Slice<any>,
+  less: (i: number, j: number) => boolean | globalThis.Promise<boolean>
+): globalThis.Promise<boolean> {
   if (!x) return true
   
   const n = $.len(x)
   for (let i = n - 1; i > 0; i--) {
-    if (less(i, i - 1)) {
+    if (await less(i, i - 1)) {
       return false
     }
   }
@@ -53,7 +59,10 @@ export function SliceIsSorted(x: $.Slice<any>, less: (i: number, j: number) => b
 }
 
 // SliceStable sorts the slice x while keeping the original order of equal elements
-export function SliceStable(x: $.Slice<any>, less: (i: number, j: number) => boolean): void {
+export async function SliceStable(
+  x: $.Slice<any>,
+  less: (i: number, j: number) => boolean | globalThis.Promise<boolean>
+): globalThis.Promise<void> {
   // For simplicity, use the same sort - can be improved later
-  Slice(x, less)
-} 
+  await Slice(x, less)
+}

package/gs/sort/sort.gs.ts

@@ -94,27 +94,29 @@ export class StringSlice {
 }
 
 // Sort sorts data in ascending order as determined by the Less method
-export function Sort(data: Interface): void {
+export function Sort(data: Interface | null): void {
+  const sortData = $.pointerValue(data)
   // Use a simple insertion sort for now - can be optimized later
-  const n = data.Len()
+  const n = sortData.Len()
   for (let i = 1; i < n; i++) {
-    for (let j = i; j > 0 && data.Less(j, j - 1); j--) {
-      data.Swap(j, j - 1)
+    for (let j = i; j > 0 && sortData.Less(j, j - 1); j--) {
+      sortData.Swap(j, j - 1)
     }
   }
 }
 
 // Stable sorts data while keeping the original order of equal elements
-export function Stable(data: Interface): void {
+export function Stable(data: Interface | null): void {
   // For simplicity, use the same sort - can be improved later
   Sort(data)
 }
 
 // IsSorted reports whether data is sorted
-export function IsSorted(data: Interface): boolean {
-  const n = data.Len()
+export function IsSorted(data: Interface | null): boolean {
+  const sortData = $.pointerValue(data)
+  const n = sortData.Len()
   for (let i = n - 1; i > 0; i--) {
-    if (data.Less(i, i - 1)) {
+    if (sortData.Less(i, i - 1)) {
       return false
     }
   }
@@ -122,11 +124,12 @@ export function IsSorted(data: Interface): boolean {
 }
 
 // Reverse returns the reverse order for data
-export function Reverse(data: Interface): Interface {
+export function Reverse(data: Interface | null): Interface {
+  const sortData = $.pointerValue(data)
   return {
-    Len: () => data.Len(),
-    Less: (i: number, j: number) => data.Less(j, i),
-    Swap: (i: number, j: number) => data.Swap(i, j)
+    Len: () => sortData.Len(),
+    Less: (i: number, j: number) => sortData.Less(j, i),
+    Swap: (i: number, j: number) => sortData.Swap(i, j)
   }
 }
 
@@ -224,4 +227,4 @@ export function StringsAreSorted(x: $.Slice<string>): boolean {
     }
   }
   return true
-} 
+}

package/gs/strings/builder.ts

@@ -60,12 +60,13 @@ export class Builder {
 
   // Write appends the contents of p to b's buffer.
   // Write always returns len(p), nil.
-  public Write(p: Uint8Array): [number, $.GoError] {
+  public Write(p: $.Bytes): [number, $.GoError] {
     this.copyCheck()
     // Convert byte array to string
-    const str = new TextDecoder('utf-8').decode(p)
+    const bytes = $.bytesToUint8Array(p)
+    const str = new TextDecoder('utf-8').decode(bytes)
     this._content += str
-    return [p.length, null]
+    return [$.len(p), null]
   }
 
   // WriteByte appends the byte c to b's buffer.