goscript 0.2.2 → 0.2.4

package/gs/slices/slices.test.ts

@@ -22,9 +22,20 @@ import {
   MinFunc,
   Replace,
   Sorted,
+  SortFunc,
   SortStableFunc,
 } from './slices.js'
 
+describe('slices.SortFunc', () => {
+  it('awaits async comparison callbacks', async () => {
+    const values = $.arrayToSlice([3, 1, 2])
+
+    await SortFunc(values, async (a, b) => a - b)
+
+    expect(Array.from(values ?? [])).toEqual([1, 2, 3])
+  })
+})
+
 describe('slices.SortStableFunc', () => {
   it('preserves original order for equal elements', () => {
     const values = $.arrayToSlice([
@@ -43,14 +54,22 @@ describe('slices.SortStableFunc', () => {
 describe('slices compatibility helpers', () => {
   it('implements comparison, min/max, compact, replace, clip, and search helpers', () => {
     expect(
-      CompareFunc($.arrayToSlice(['a', 'c']), $.arrayToSlice(['a', 'b']), (a, b) =>
-        a.localeCompare(b),
+      CompareFunc(
+        $.arrayToSlice(['a', 'c']),
+        $.arrayToSlice(['a', 'b']),
+        (a, b) => a.localeCompare(b),
       ),
     ).toBeGreaterThan(0)
     expect(Min($.arrayToSlice([3, 1, 2]))).toBe(1)
-    expect(MaxFunc($.arrayToSlice([{ v: 1 }, { v: 4 }]), (a, b) => a.v - b.v).v).toBe(4)
-    expect(MinFunc($.arrayToSlice([{ v: 3 }, { v: 2 }]), (a, b) => a.v - b.v).v).toBe(2)
-    expect(Array.from(Compact($.arrayToSlice([1, 1, 2, 2, 3])) ?? [])).toEqual([1, 2, 3])
+    expect(
+      MaxFunc($.arrayToSlice([{ v: 1 }, { v: 4 }]), (a, b) => a.v - b.v).v,
+    ).toBe(4)
+    expect(
+      MinFunc($.arrayToSlice([{ v: 3 }, { v: 2 }]), (a, b) => a.v - b.v).v,
+    ).toBe(2)
+    expect(Array.from(Compact($.arrayToSlice([1, 1, 2, 2, 3])) ?? [])).toEqual([
+      1, 2, 3,
+    ])
     expect(
       Array.from(
         CompactFunc(
@@ -59,9 +78,9 @@ describe('slices compatibility helpers', () => {
         ) ?? [],
       ),
     ).toEqual(['a', 'b'])
-    expect(Array.from(Replace($.arrayToSlice([1, 2, 3, 4]), 1, 3, 9, 8)) ?? []).toEqual([
-      1, 9, 8, 4,
-    ])
+    expect(
+      Array.from(Replace($.arrayToSlice([1, 2, 3, 4]), 1, 3, 9, 8)) ?? [],
+    ).toEqual([1, 9, 8, 4])
     expect(Array.from(Clip($.arrayToSlice([1, 2])) ?? [])).toEqual([1, 2])
     expect(BinarySearch($.arrayToSlice([1, 3, 5]), 3)).toEqual([1, true])
   })
@@ -69,22 +88,37 @@ describe('slices compatibility helpers', () => {
   it('concatenates slices and preserves empty concat nilness', () => {
     expect(Concat()).toBeNull()
     expect(Concat($.arrayToSlice<number>([]))).toBeNull()
-    expect(Array.from(Concat($.arrayToSlice([1]), null, $.arrayToSlice([2, 3])) ?? [])).toEqual([
-      1, 2, 3,
-    ])
-    expect(Array.from(Concat(new Uint8Array([1, 2]), new Uint8Array([3])) ?? [])).toEqual([
-      1, 2, 3,
-    ])
+    expect(
+      Array.from(
+        Concat($.arrayToSlice([1]), null, $.arrayToSlice([2, 3])) ?? [],
+      ),
+    ).toEqual([1, 2, 3])
+    expect(
+      Array.from(Concat(new Uint8Array([1, 2]), new Uint8Array([3])) ?? []),
+    ).toEqual([1, 2, 3])
   })
 
   it('accepts generated possibly-async callback types for sync helpers', () => {
-    const compare: (a: number, b: number) => number | Promise<number> = (a, b) => a - b
-    const keepOdd: (v: number) => boolean | Promise<boolean> = (v) => v % 2 === 0
-    const equal: (a: string, b: string) => boolean | Promise<boolean> = (a, b) => a === b
+    const compare: (a: number, b: number) => number | Promise<number> = (
+      a,
+      b,
+    ) => a - b
+    const keepOdd: (v: number) => boolean | Promise<boolean> = (v) =>
+      v % 2 === 0
+    const equal: (a: string, b: string) => boolean | Promise<boolean> = (
+      a,
+      b,
+    ) => a === b
 
-    expect(CompareFunc($.arrayToSlice([1]), $.arrayToSlice([2]), compare)).toBeLessThan(0)
-    expect(Array.from(DeleteFunc($.arrayToSlice([1, 2, 3]), keepOdd) ?? [])).toEqual([1, 3])
-    expect(EqualFunc($.arrayToSlice(['a']), $.arrayToSlice(['a']), equal)).toBe(true)
+    expect(
+      CompareFunc($.arrayToSlice([1]), $.arrayToSlice([2]), compare),
+    ).toBeLessThan(0)
+    expect(
+      Array.from(DeleteFunc($.arrayToSlice([1, 2, 3]), keepOdd) ?? []),
+    ).toEqual([1, 3])
+    expect(EqualFunc($.arrayToSlice(['a']), $.arrayToSlice(['a']), equal)).toBe(
+      true,
+    )
     expect(IndexFunc($.arrayToSlice([1, 2, 3]), keepOdd)).toBe(1)
     expect(IsSortedFunc($.arrayToSlice([1, 2, 3]), compare)).toBe(true)
     expect(BinarySearch($.arrayToSlice([1, 2, 3]), 2)).toEqual([1, true])
@@ -92,7 +126,11 @@ describe('slices compatibility helpers', () => {
 
   it('rejects actual async callback results in sync helpers', () => {
     expect(() =>
-      CompareFunc($.arrayToSlice([1]), $.arrayToSlice([2]), async (a, b) => a - b),
+      CompareFunc(
+        $.arrayToSlice([1]),
+        $.arrayToSlice([2]),
+        async (a, b) => a - b,
+      ),
     ).toThrow('slices: asynchronous callback result is not supported')
   })
 })

package/gs/slices/slices.ts

@@ -4,9 +4,13 @@ import * as cmp from '../cmp/index.js'
 import * as iter from '../iter/index.js'
 
 type SyncCallbackResult<T> = T | globalThis.Promise<T>
-type CompareCallback<T, U = T> = ((v1: T, v2: U) => SyncCallbackResult<number>) | null
+type CompareCallback<T, U = T> =
+  | ((v1: T, v2: U) => SyncCallbackResult<number>)
+  | null
 type PredicateCallback<T> = ((value: T) => SyncCallbackResult<boolean>) | null
-type EqualCallback<T, U = T> = ((v1: T, v2: U) => SyncCallbackResult<boolean>) | null
+type EqualCallback<T, U = T> =
+  | ((v1: T, v2: U) => SyncCallbackResult<boolean>)
+  | null
 
 /**
  * Compare compares the elements of s1 and s2 using cmp.Compare.
@@ -59,9 +63,7 @@ export function CompareFunc<T, U>(
   const len2 = $.len(s2)
   const minLen = len1 < len2 ? len1 : len2
   for (let i = 0; i < minLen; i++) {
-    const result = syncNumber(
-      compare((s1 as any)[i] as T, (s2 as any)[i] as U),
-    )
+    const result = syncNumber(compare((s1 as any)[i] as T, (s2 as any)[i] as U))
     if (result !== 0) {
       return result
     }
@@ -131,7 +133,9 @@ export function Concat<T>(...slices: $.Slice<T>[]): $.Slice<T> {
  */
 export function All<T>(
   s: $.Slice<T>,
-): (yieldFunc: (index: number, value: T) => iter.YieldResult) => void | globalThis.Promise<void> {
+): (
+  yieldFunc: (index: number, value: T) => iter.YieldResult,
+) => void | globalThis.Promise<void> {
   return function (
     _yield: (index: number, value: T) => iter.YieldResult,
   ): void | globalThis.Promise<void> {
@@ -228,10 +232,7 @@ export function Min<T extends cmp.Ordered>(x: $.Slice<T>): T {
   return min
 }
 
-export function MaxFunc<T>(
-  x: $.Slice<T>,
-  compare: CompareCallback<T>,
-): T {
+export function MaxFunc<T>(x: $.Slice<T>, compare: CompareCallback<T>): T {
   if (compare == null) {
     throw new Error('slices.MaxFunc: nil comparison function')
   }
@@ -248,10 +249,7 @@ export function MaxFunc<T>(
   return max
 }
 
-export function MinFunc<T>(
-  x: $.Slice<T>,
-  compare: CompareCallback<T>,
-): T {
+export function MinFunc<T>(x: $.Slice<T>, compare: CompareCallback<T>): T {
   if (compare == null) {
     throw new Error('slices.MinFunc: nil comparison function')
   }
@@ -476,7 +474,10 @@ export function Contains<T>(s: $.Slice<T>, v: T): boolean {
   return Index(s, v) >= 0
 }
 
-export function ContainsFunc<T>(s: $.Slice<T>, f: PredicateCallback<T>): boolean {
+export function ContainsFunc<T>(
+  s: $.Slice<T>,
+  f: PredicateCallback<T>,
+): boolean {
   return IndexFunc(s, f) >= 0
 }
 
@@ -555,18 +556,58 @@ export function Grow<T>(s: $.Slice<T>, n: number): $.Slice<T> {
  * @param s The slice to sort in place
  * @param cmp Comparison function
  */
-export function SortFunc<T>(
+export async function SortFunc<T>(
   s: $.Slice<T>,
   cmp: CompareCallback<T>,
-): void {
+): globalThis.Promise<void> {
   if (cmp == null) {
     throw new Error('slices.SortFunc: nil comparison function')
   }
-  if (s === null || s === undefined) {
+  if (s === null || s === undefined || $.len(s) < 2) {
     return
   }
-  const arr = s as any as T[]
-  arr.sort((a, b) => syncNumber(cmp(a, b)))
+  const sorted = await asyncMergeSort(Array.from(s as any as T[]), cmp)
+  for (let i = 0; i < sorted.length; i++) {
+    ;(s as any)[i] = sorted[i]
+  }
+}
+
+async function asyncMergeSort<T>(
+  values: T[],
+  cmp: CompareCallback<T>,
+): globalThis.Promise<T[]> {
+  if (values.length < 2) {
+    return values
+  }
+  const mid = Math.floor(values.length / 2)
+  const left = await asyncMergeSort(values.slice(0, mid), cmp)
+  const right = await asyncMergeSort(values.slice(mid), cmp)
+  return asyncMerge(left, right, cmp)
+}
+
+async function asyncMerge<T>(
+  left: T[],
+  right: T[],
+  cmp: CompareCallback<T>,
+): globalThis.Promise<T[]> {
+  const out: T[] = []
+  let li = 0
+  let ri = 0
+  while (li < left.length && ri < right.length) {
+    const order = await cmp!(left[li], right[ri])
+    if (order <= 0) {
+      out.push(left[li++])
+    } else {
+      out.push(right[ri++])
+    }
+  }
+  while (li < left.length) {
+    out.push(left[li++])
+  }
+  while (ri < right.length) {
+    out.push(right[ri++])
+  }
+  return out
 }
 
 export function IsSortedFunc<T>(

package/gs/strconv/complex.test.ts

@@ -48,10 +48,22 @@ describe('strconv complex helpers', () => {
   })
 
   it('rejects whitespace and malformed imaginary forms', () => {
-    for (const input of [' 1+2i', '1+2i ', '1 +2i', 'i', '+i', '-i', '1++2i', '1-+2i', '0xp1']) {
+    for (const input of [
+      ' 1+2i',
+      '1+2i ',
+      '1 +2i',
+      'i',
+      '+i',
+      '-i',
+      '1++2i',
+      '1-+2i',
+      '0xp1',
+    ]) {
       const [, err] = ParseComplex(input, 128)
 
-      expect(err?.Error(), input).toBe(`strconv.ParseComplex: parsing "${input}": invalid syntax`)
+      expect(err?.Error(), input).toBe(
+        `strconv.ParseComplex: parsing "${input}": invalid syntax`,
+      )
     }
   })
 
@@ -60,6 +72,8 @@ describe('strconv complex helpers', () => {
 
     expect($.real(value)).toBe(Infinity)
     expect($.imag(value)).toBe(0)
-    expect(err?.Error()).toBe('strconv.ParseComplex: parsing "0x1p1025": value out of range')
+    expect(err?.Error()).toBe(
+      'strconv.ParseComplex: parsing "0x1p1025": value out of range',
+    )
   })
 })

package/gs/sync/atomic/doc_64.test.ts

@@ -1,12 +1,7 @@
 import { describe, expect, test } from 'vitest'
 
 import * as $ from '../../builtin/index.js'
-import {
-  AddInt64,
-  AddUint64,
-  AndUint64,
-  OrUint64,
-} from './doc_64.gs.js'
+import { AddInt64, AddUint64, AndUint64, OrUint64 } from './doc_64.gs.js'
 
 function asBigInt(value: number): bigint {
   return typeof value === 'bigint' ? value : BigInt(value)
@@ -23,9 +18,7 @@ describe('sync/atomic 64-bit operations', () => {
   test('preserves high uint64 bits for bitwise operations', () => {
     const value = $.varRef($.uint('9223372036854775808', 64))
 
-    expect(asBigInt(OrUint64(value, $.uint(1, 64)))).toBe(
-      9223372036854775808n,
-    )
+    expect(asBigInt(OrUint64(value, $.uint(1, 64)))).toBe(9223372036854775808n)
     expect(asBigInt(value.value)).toBe(9223372036854775809n)
 
     expect(asBigInt(AndUint64(value, $.uint('18446744073709551614', 64)))).toBe(

package/gs/sync/sync.test.ts

@@ -94,14 +94,24 @@ describe('sync.Map', () => {
 
   it('matches boxed comparable interface keys', async () => {
     const m = new Map()
-    const first = $.namedValueInterfaceValue(8, 'uint16', {}, {
-      kind: $.TypeKind.Basic,
-      name: 'uint16',
-    })
-    const second = $.namedValueInterfaceValue(8, 'uint16', {}, {
-      kind: $.TypeKind.Basic,
-      name: 'uint16',
-    })
+    const first = $.namedValueInterfaceValue(
+      8,
+      'uint16',
+      {},
+      {
+        kind: $.TypeKind.Basic,
+        name: 'uint16',
+      },
+    )
+    const second = $.namedValueInterfaceValue(
+      8,
+      'uint16',
+      {},
+      {
+        kind: $.TypeKind.Basic,
+        name: 'uint16',
+      },
+    )
 
     await m.Store(first, 'compressor')
     expect(await m.Load(second)).toEqual(['compressor', true])

package/gs/syscall/js/index.test.ts

@@ -7,10 +7,15 @@ import { ValueOf } from './index.js'
 describe('syscall/js override', () => {
   test('ValueOf unwraps generated interface numeric boxes', () => {
     const value = ValueOf(
-      $.namedValueInterfaceValue(41, 'int', {}, {
-        kind: $.TypeKind.Basic,
-        name: 'int',
-      }),
+      $.namedValueInterfaceValue(
+        41,
+        'int',
+        {},
+        {
+          kind: $.TypeKind.Basic,
+          name: 'int',
+        },
+      ),
     )
 
     expect(value.Int()).toBe(41)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "goscript",
   "description": "Go to TypeScript transpiler",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "author": {
     "name": "Aperture Robotics LLC.",
     "email": "support@aperture.us",
@@ -48,8 +48,8 @@
     "example": "cd ./example/simple && bash run.bash",
     "test": "bun run test:go && bun run test:js",
     "test:go": "go test ./...",
-    "test:go:browser": "go run ./cmd/goscript test --browser --timeout 1m --dir compiler/gotest/testdata/browserapi --run TestBrowserAPI .",
-    "test:go:browser:shim": "mkdir -p .tmp/bin && go build -o .tmp/bin/go_js_wasm_exec ./cmd/go_js_wasm_exec && sh -c 'exec_path=\"$PWD/.tmp/bin/go_js_wasm_exec\"; cd compiler/gotest/testdata/browserapi && GOOS=js GOARCH=wasm go test -exec \"$exec_path\" -run TestBrowserAPI -count=1'",
+    "test:go:browser": "go run ./cmd/goscript test --browser --timeout 1m --dir compiler/gotest/testdata/browserapi --run TestBrowser .",
+    "test:go:browser:shim": "mkdir -p .tmp/bin && go build -o .tmp/bin/go_js_wasm_exec ./cmd/go_js_wasm_exec && sh -c 'exec_path=\"$PWD/.tmp/bin/go_js_wasm_exec\"; cd compiler/gotest/testdata/browserapi && GOOS=js GOARCH=wasm go test -exec \"$exec_path\" -run TestBrowser -count=1'",
     "test:js": "bun run typecheck && vitest run",
     "test:browser": "bun run scripts/generate-browser-tests.ts && vitest run --config vitest.browser.config.ts",
     "test:browser:ui": "bun run scripts/generate-browser-tests.ts && vitest --config vitest.browser.config.ts --ui",
@@ -108,13 +108,14 @@
     "husky": "^9.1.7",
     "lint-staged": "^17.0.0",
     "prettier": "^3.8.1",
-    "starpc": "0.49.17",
+    "starpc": "0.49.18",
     "typescript": "^6.0.0",
     "typescript-eslint": "^8.58.0",
     "vitest": "^4.1.2"
   },
   "dependencies": {
     "@noble/ciphers": "2.2.0",
+    "@noble/hashes": "2.2.0",
     "globals": "^17.4.0"
   },
   "resolutions": {