goscript 0.1.1 → 0.1.2

package/gs/io/fs/readlink.ts

@@ -9,56 +9,48 @@ export type ReadLinkFS =
       Lstat(name: string): [FileInfo, $.GoError]
     } & FS)
 
-$.registerInterfaceType(
-  'ReadLinkFS',
-  null,
-  [
-    {
-      name: 'ReadLink',
-      args: [
-        { name: 'name', type: { kind: $.TypeKind.Basic, name: 'string' } },
-      ],
-      returns: [
-        { type: { kind: $.TypeKind.Basic, name: 'string' } },
-        {
-          type: {
-            kind: $.TypeKind.Interface,
-            name: 'GoError',
-            methods: [
-              {
-                name: 'Error',
-                args: [],
-                returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
-              },
-            ],
-          },
+$.registerInterfaceType('ReadLinkFS', null, [
+  {
+    name: 'ReadLink',
+    args: [{ name: 'name', type: { kind: $.TypeKind.Basic, name: 'string' } }],
+    returns: [
+      { type: { kind: $.TypeKind.Basic, name: 'string' } },
+      {
+        type: {
+          kind: $.TypeKind.Interface,
+          name: 'GoError',
+          methods: [
+            {
+              name: 'Error',
+              args: [],
+              returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
+            },
+          ],
         },
-      ],
-    },
-    {
-      name: 'Lstat',
-      args: [
-        { name: 'name', type: { kind: $.TypeKind.Basic, name: 'string' } },
-      ],
-      returns: [
-        { type: 'FileInfo' },
-        {
-          type: {
-            kind: $.TypeKind.Interface,
-            name: 'GoError',
-            methods: [
-              {
-                name: 'Error',
-                args: [],
-                returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
-              },
-            ],
-          },
+      },
+    ],
+  },
+  {
+    name: 'Lstat',
+    args: [{ name: 'name', type: { kind: $.TypeKind.Basic, name: 'string' } }],
+    returns: [
+      { type: 'FileInfo' },
+      {
+        type: {
+          kind: $.TypeKind.Interface,
+          name: 'GoError',
+          methods: [
+            {
+              name: 'Error',
+              args: [],
+              returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
+            },
+          ],
         },
-      ],
-    },
-  ],
-)
+      },
+    ],
+  },
+])
 
 export function ReadLink(fsys: FS, name: string): [string, $.GoError] {
   const { value: sym, ok } = $.typeAssert<ReadLinkFS>(fsys, 'ReadLinkFS')

package/gs/io/fs/walk.ts

@@ -12,7 +12,11 @@ export let SkipDir: $.GoError = errors.New('skip this directory')
 export let SkipAll: $.GoError = errors.New('skip everything and stop the walk')
 
 export type WalkDirFunc =
-  | ((path: string, d: DirEntry, err: $.GoError) => $.GoError | Promise<$.GoError>)
+  | ((
+      path: string,
+      d: DirEntry,
+      err: $.GoError,
+    ) => $.GoError | Promise<$.GoError>)
   | null
 
 // walkDir recursively descends path, calling walkDirFn.
@@ -79,7 +83,11 @@ export async function walkDir(
 //
 // WalkDir does not follow symbolic links found in directories,
 // but if root itself is a symbolic link, its target will be walked.
-export async function WalkDir(fsys: FS, root: string, fn: WalkDirFunc): Promise<$.GoError> {
+export async function WalkDir(
+  fsys: FS,
+  root: string,
+  fn: WalkDirFunc,
+): Promise<$.GoError> {
   let [info, err] = Stat(fsys, root)
   if (err != null) {
     err = await fn!(root, null, err)

package/gs/io/io.ts

@@ -547,7 +547,10 @@ export async function ReadAtLeast(
 }
 
 // ReadFull reads exactly len(buf) bytes from r into buf
-export async function ReadFull(r: Reader, buf: $.Bytes): Promise<[number, $.GoError]> {
+export async function ReadFull(
+  r: Reader,
+  buf: $.Bytes,
+): Promise<[number, $.GoError]> {
   return await ReadAtLeast(r, buf, $.len(buf))
 }
 

package/gs/iter/iter.ts

@@ -1,11 +1,17 @@
 // TypeScript implementation of Go's iter package
 // This provides iterator types and functions
 
+export type YieldResult = boolean | globalThis.Promise<boolean>
+
 // Seq is an iterator over sequences of individual values
-export type Seq<V> = (_yield: (value: V) => boolean) => void
+export type Seq<V> = (
+  _yield: ((value: V) => YieldResult) | null,
+) => void | globalThis.Promise<void>
 
 // Seq2 is an iterator over sequences of pairs of values
-export type Seq2<K, V> = (_yield: (key: K, value: V) => boolean) => void
+export type Seq2<K, V> = (
+  _yield: ((key: K, value: V) => YieldResult) | null,
+) => void | globalThis.Promise<void>
 
 // Pull converts the "push-style" iterator sequence seq into a "pull-style" iterator
 // Returns a function that returns the next value and a boolean indicating if iteration should continue

package/gs/maps/iter.ts

@@ -5,51 +5,39 @@ import * as iter from '@goscript/iter/index.js'
 // All returns an iterator over key-value pairs from m.
 // The iteration order is not specified and is not guaranteed
 // to be the same from one call to the next.
-export function All<K extends $.Comparable, V>(
+export function All<K extends $.Comparable | null, V>(
   m: Map<K, V> | null,
 ): iter.Seq2<K, V> {
-  return (_yield: ((p0: K, p1: V) => boolean) | null): void => {
-    for (const [k, v] of m?.entries() ?? []) {
-      if (!_yield!(k, v)) {
-        return
-      }
-    }
-  }
+  return (_yield: ((p0: K, p1: V) => iter.YieldResult) | null):
+    | void
+    | globalThis.Promise<void> => iteratePairs(m?.entries() ?? [], _yield)
 }
 
 // Keys returns an iterator over keys in m.
 // The iteration order is not specified and is not guaranteed
 // to be the same from one call to the next.
-export function Keys<K extends $.Comparable, V>(
+export function Keys<K extends $.Comparable | null, V>(
   m: Map<K, V> | null,
 ): iter.Seq<K> {
-  return (_yield: ((p0: K) => boolean) | null): void => {
-    for (const [k, _v] of m?.entries() ?? []) {
-      if (!_yield!(k)) {
-        return
-      }
-    }
-  }
+  return (_yield: ((p0: K) => iter.YieldResult) | null):
+    | void
+    | globalThis.Promise<void> => iterateValues(mapKeys(m), _yield)
 }
 
 // Values returns an iterator over values in m.
 // The iteration order is not specified and is not guaranteed
 // to be the same from one call to the next.
-export function Values<K extends $.Comparable, V>(
+export function Values<K extends $.Comparable | null, V>(
   m: Map<K, V> | null,
 ): iter.Seq<V> {
-  return (_yield: ((p0: V) => boolean) | null): void => {
-    for (const [_k, v] of m?.entries() ?? []) {
-      if (!_yield!(v)) {
-        return
-      }
-    }
-  }
+  return (_yield: ((p0: V) => iter.YieldResult) | null):
+    | void
+    | globalThis.Promise<void> => iterateValues(mapValues(m), _yield)
 }
 
 // Insert adds the key-value pairs from seq to m.
 // If a key in seq already exists in m, its value will be overwritten.
-export function Insert<K extends $.Comparable, V>(
+export function Insert<K extends $.Comparable | null, V>(
   m: Map<K, V>,
   seq: iter.Seq2<K, V>,
 ): void {
@@ -64,10 +52,65 @@ export function Insert<K extends $.Comparable, V>(
 
 // Collect collects key-value pairs from seq into a new map
 // and returns it.
-export function Collect<K extends $.Comparable, V>(
+export function Collect<K extends $.Comparable | null, V>(
   seq: iter.Seq2<K, V>,
 ): Map<K, V> {
   let m = $.makeMap<K, V>()
   Insert(m, seq)
   return m
 }
+
+function mapKeys<K extends $.Comparable | null, V>(m: Map<K, V> | null): K[] {
+  return Array.from(m?.keys() ?? [])
+}
+
+function mapValues<K extends $.Comparable | null, V>(m: Map<K, V> | null): V[] {
+  return Array.from(m?.values() ?? [])
+}
+
+function iterateValues<T>(
+  values: Iterable<T>,
+  yieldValue: ((value: T) => iter.YieldResult) | null,
+): void | globalThis.Promise<void> {
+  const items = Array.from(values)
+  const walk = (idx: number): void | globalThis.Promise<void> => {
+    for (; idx < items.length; idx++) {
+      const keepGoing = yieldValue!(items[idx])
+      if (keepGoing instanceof Promise) {
+        return keepGoing.then((next) => {
+          if (next) {
+            return walk(idx + 1)
+          }
+        })
+      }
+      if (!keepGoing) {
+        return
+      }
+    }
+  }
+  return walk(0)
+}
+
+function iteratePairs<K, V>(
+  entries: Iterable<[K, V]>,
+  yieldValue: ((key: K, value: V) => iter.YieldResult) | null,
+): void | globalThis.Promise<void> {
+  const items = Array.from(entries)
+  const walk = (idx: number): void | globalThis.Promise<void> => {
+    for (; idx < items.length; idx++) {
+      const [key, value] = items[idx]
+      const keepGoing = yieldValue!(key, value)
+      if (keepGoing instanceof Promise) {
+        return keepGoing.then((next) => {
+          if (next) {
+            return walk(idx + 1)
+          }
+        })
+      }
+      if (!keepGoing) {
+        return
+      }
+    }
+  }
+  return walk(0)
+}

package/gs/maps/maps.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest'
+
+import { Clone, Values } from './index.js'
+
+describe('maps overrides', () => {
+  it('accept nilable comparable keys', () => {
+    const source = new Map<object | null, number>()
+    const key = { name: 'type' }
+    source.set(null, 1)
+    source.set(key, 2)
+
+    const cloned = Clone(source)
+    expect(cloned?.get(null)).toBe(1)
+    expect(cloned?.get(key)).toBe(2)
+
+    const values: number[] = []
+    Values(cloned)((value) => {
+      values.push(value)
+      return true
+    })
+    expect(values.sort()).toEqual([1, 2])
+  })
+})

package/gs/maps/maps.ts

@@ -4,7 +4,7 @@ import * as _ from '@goscript/unsafe/index.js'
 
 // Equal reports whether two maps contain the same key/value pairs.
 // Values are compared using ==.
-export function Equal<K extends $.Comparable, V extends $.Comparable>(
+export function Equal<K extends $.Comparable | null, V extends $.Comparable | null>(
   m1: Map<K, V>,
   m2: Map<K, V>,
 ): boolean {
@@ -22,7 +22,7 @@ export function Equal<K extends $.Comparable, V extends $.Comparable>(
 
 // EqualFunc is like Equal, but compares values using eq.
 // Keys are still compared with ==.
-export function EqualFunc<K extends $.Comparable, V1, V2>(
+export function EqualFunc<K extends $.Comparable | null, V1, V2>(
   m1: Map<K, V1>,
   m2: Map<K, V2>,
   eq: ((p0: V1, p1: V2) => boolean) | null,
@@ -40,7 +40,7 @@ export function EqualFunc<K extends $.Comparable, V1, V2>(
 }
 
 // clone returns a shallow copy of the map.
-export function clone<K extends $.Comparable, V>(
+export function clone<K extends $.Comparable | null, V>(
   m: Map<K, V> | null,
 ): Map<K, V> | null {
   if (m == null) {
@@ -55,7 +55,7 @@ export function clone<K extends $.Comparable, V>(
 
 // Clone returns a copy of m.  This is a shallow clone:
 // the new keys and values are set using ordinary assignment.
-export function Clone<K extends $.Comparable, V>(
+export function Clone<K extends $.Comparable | null, V>(
   m: Map<K, V> | null,
 ): Map<K, V> | null {
   // Preserve nil in case it matters.
@@ -69,7 +69,7 @@ export function Clone<K extends $.Comparable, V>(
 // When a key in src is already present in dst,
 // the value in dst will be overwritten by the value associated
 // with the key in src.
-export function Copy<K extends $.Comparable, V>(
+export function Copy<K extends $.Comparable | null, V>(
   dst: Map<K, V> | null,
   src: Map<K, V> | null,
 ): void {
@@ -79,7 +79,7 @@ export function Copy<K extends $.Comparable, V>(
 }
 
 // DeleteFunc deletes any key/value pairs from m for which del returns true.
-export function DeleteFunc<K extends $.Comparable, V>(
+export function DeleteFunc<K extends $.Comparable | null, V>(
   m: Map<K, V>,
   del: ((p0: K, p1: V) => boolean) | null,
 ): void {

package/gs/math/bits/index.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest'
+
+import { Mul64 } from './index.js'
+
+describe('math/bits override', () => {
+  it('returns the full 128-bit product from Mul64', () => {
+    expect(Mul64(0xffffffffffffffffn, 0xffffffffffffffffn)).toEqual([
+      0xfffffffffffffffen,
+      1n,
+    ])
+    expect(Mul64(0x1fffffffffffffn, 0x1fffffffffffffn)).toEqual([
+      0x3ffffffffffn,
+      0xffc0000000000001n,
+    ])
+    expect(Mul64(0x1fffffffffffff, 0x1fffffffffffff)).toEqual([
+      0x3ffffffffff,
+      0xffc0000000000001n,
+    ])
+  })
+})

package/gs/math/bits/index.ts

@@ -17,7 +17,9 @@ function useBigIntResult(...values: Word64[]): boolean {
 }
 
 function word64Result(value: bigint, useBigInt: boolean): Word64 {
-  return useBigInt ? value : Number(value)
+  return useBigInt || value > BigInt(Number.MAX_SAFE_INTEGER) ?
+      value
+    : Number(value)
 }
 
 // --- Leading zeros ---
@@ -209,20 +211,16 @@ export function Reverse64(x: Word64): Word64 {
     ((word & 0x0000ffff0000ffffn) << 16n)
   // Swap 8-bit chunks
   word =
-    ((word & 0xff00ff00ff00ff00n) >> 8n) |
-    ((word & 0x00ff00ff00ff00ffn) << 8n)
+    ((word & 0xff00ff00ff00ff00n) >> 8n) | ((word & 0x00ff00ff00ff00ffn) << 8n)
   // Swap 4-bit chunks
   word =
-    ((word & 0xf0f0f0f0f0f0f0f0n) >> 4n) |
-    ((word & 0x0f0f0f0f0f0f0f0fn) << 4n)
+    ((word & 0xf0f0f0f0f0f0f0f0n) >> 4n) | ((word & 0x0f0f0f0f0f0f0f0fn) << 4n)
   // Swap 2-bit chunks
   word =
-    ((word & 0xccccccccccccccccn) >> 2n) |
-    ((word & 0x3333333333333333n) << 2n)
+    ((word & 0xccccccccccccccccn) >> 2n) | ((word & 0x3333333333333333n) << 2n)
   // Swap 1-bit chunks
   word =
-    ((word & 0xaaaaaaaaaaaaaaaan) >> 1n) |
-    ((word & 0x5555555555555555n) << 1n)
+    ((word & 0xaaaaaaaaaaaaaaaan) >> 1n) | ((word & 0x5555555555555555n) << 1n)
 
   return word64Result(word & uint64Mask, useBigInt)
 }
@@ -307,25 +305,14 @@ export function Mul64(x: Word64, y: Word64): [Word64, Word64] {
   const useBigInt = useBigIntResult(x, y)
   x = toUint64(x)
   y = toUint64(y)
-  const mask32 = 0xffffffffn
-
-  // Split into 32-bit parts
-  const x0 = x & mask32
-  const x1 = x >> 32n
-  const y0 = y & mask32
-  const y1 = y >> 32n
-
-  // Multiply parts
-  const p00 = x0 * y0
-  const p01 = x0 * y1
-  const p10 = x1 * y0
-  const p11 = x1 * y1
-
-  // Combine results
-  const lo = p00 + ((p01 + p10) << 32n)
-  const hi = p11 + ((p01 + p10) >> 32n) + (lo < p00 ? 1n : 0n)
-
-  return [word64Result(hi & uint64Mask, useBigInt), word64Result(lo & uint64Mask, useBigInt)]
+  const product = x * y
+  const lo = product & uint64Mask
+  const hi = product >> 64n
+
+  return [
+    word64Result(hi & uint64Mask, useBigInt),
+    word64Result(lo, useBigInt),
+  ]
 }
 
 // --- Division functions ---

package/gs/mime/index.ts

@@ -1,9 +1,15 @@
-export function FormatMediaType(t: string, param: Map<string, string> | Record<string, string> | null): string {
+export function FormatMediaType(
+  t: string,
+  param: Map<string, string> | Record<string, string> | null,
+): string {
   if (!isToken(t)) {
     return ''
   }
   let out = t
-  const entries = param instanceof Map ? Array.from(param.entries()) : Object.entries(param ?? {})
+  const entries =
+    param instanceof Map ?
+      Array.from(param.entries())
+    : Object.entries(param ?? {})
   entries.sort(([a], [b]) => a.localeCompare(b))
   for (const [key, value] of entries) {
     if (!isToken(key)) {

package/gs/net/http/httptest/index.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import { Handler, Header_Get, Header_Set, MethodGet, NewRequest, StatusPartialContent } from '../index.js'
+import { NewServer, NewUnstartedServer, Server_Start } from './index.js'
+
+describe('net/http/httptest override', () => {
+  it('exports server helpers for typechecked server tests', () => {
+    const handler: Handler = {
+      ServeHTTP: () => undefined,
+    }
+
+    const srv = NewServer(handler)
+    expect(srv.URL).toBe('http://127.0.0.1')
+    expect(srv.Client()).toBeTruthy()
+    expect(srv.Config().Handler).toBe(handler)
+    expect(Server_Start(NewUnstartedServer(handler))?.Error()).toBe(
+      'net/http/httptest: Server.Start is not implemented in GoScript',
+    )
+  })
+
+  it('routes Client.Do through the in-memory server handler', async () => {
+    const srv = NewServer({
+      ServeHTTP(w, r) {
+        Header_Set(w!.Header(), 'Content-Range', 'bytes 0-3/4')
+        const range = Header_Get($.pointerValue(r)!.Header, 'Range')
+        if (range !== 'bytes=0-3') {
+          w!.WriteHeader(400)
+          w!.Write($.stringToBytes(range))
+          return
+        }
+        w!.WriteHeader(StatusPartialContent)
+        w!.Write($.stringToBytes('data'))
+      },
+    })
+    const [req, reqErr] = NewRequest(MethodGet, srv.URL + '/pack.kvf', null)
+    expect(reqErr).toBeNull()
+    Header_Set(req!.Header, 'Range', 'bytes=0-3')
+
+    const [resp, err] = await srv.Client().Do(req)
+
+    expect(err).toBeNull()
+    expect(resp?.StatusCode).toBe(StatusPartialContent)
+    expect(Header_Get(resp!.Header, 'Content-Range')).toBe('bytes 0-3/4')
+    const buf = new Uint8Array(4)
+    const [n, readErr] = resp!.Body!.Read(buf)
+    expect(readErr).toBeNull()
+    expect(n).toBe(4)
+    expect(Buffer.from(buf).toString('utf8')).toBe('data')
+    expect(resp!.Body!.Close()).toBeNull()
+  })
+})

package/gs/net/http/httptest/index.ts

@@ -1,25 +1,120 @@
 import * as $ from '@goscript/builtin/index.js'
+import * as bytes from '@goscript/bytes/index.js'
+import * as errors from '@goscript/errors/index.js'
 import * as http from '@goscript/net/http/index.js'
+import * as io from '@goscript/io/index.js'
+
+class responseBody implements io.ReadCloser {
+  private reader: bytes.Reader
+
+  constructor(data: $.Bytes) {
+    this.reader = bytes.NewReader(Uint8Array.from(data ?? []))
+  }
+
+  public Read(p: $.Bytes): [number, $.GoError] {
+    return this.reader.Read(p)
+  }
+
+  public Close(): $.GoError {
+    return null
+  }
+}
 
 export class ResponseRecorder implements http.ResponseWriter {
   public Code = 200
-  public Body: $.Slice<number> = null
+  public Body = new bytes.Buffer()
   private headerMap = new http.Header()
+  private wroteHeader = false
 
   public Header(): http.Header {
     return this.headerMap
   }
 
   public Write(p: $.Slice<number>): [number, $.GoError] {
-    this.Body = $.append(this.Body, p)
-    return [$.len(p), null]
+    if (!this.wroteHeader) {
+      this.WriteHeader(http.StatusOK)
+    }
+    return this.Body.Write(p)
   }
 
   public WriteHeader(statusCode: number): void {
+    if (this.wroteHeader) {
+      return
+    }
+    this.wroteHeader = true
     this.Code = statusCode
   }
+
+  public Result(): http.Response {
+    return new http.Response({
+      Body: new responseBody(this.Body.Bytes()),
+      Header: this.headerMap,
+      StatusCode: this.Code,
+    })
+  }
 }
 
 export function NewRecorder(): ResponseRecorder {
   return new ResponseRecorder()
 }
+
+export function NewRequest(method: string, target: string, body: io.Reader | null): http.Request {
+  const [req, err] = http.NewRequest(method, target, body)
+  if (err != null || req == null) {
+    throw err ?? errors.New('net/http/httptest: NewRequest returned nil request')
+  }
+  return req
+}
+
+export class Server {
+  public URL: string
+  private handler: http.Handler | null
+
+  constructor(init?: Partial<Server> & { Handler?: http.Handler | null }) {
+    this.URL = init?.URL ?? 'http://127.0.0.1'
+    this.handler = init?.Handler ?? null
+  }
+
+  public Client(): http.Client {
+    return new http.Client({ Transport: new serverTransport(this) })
+  }
+
+  public Close(): void {}
+
+  public Config(): http.Server {
+    return new http.Server({ Handler: this.handler })
+  }
+
+  public ServeHTTP(w: http.ResponseWriter | null, r: http.Request | $.VarRef<http.Request> | null): void | Promise<void> {
+    return this.handler?.ServeHTTP(w, r)
+  }
+}
+
+class serverTransport implements http.RoundTripper {
+  constructor(private server: Server) {}
+
+  public RoundTrip(req: http.Request | $.VarRef<http.Request> | null): [http.Response | null, $.GoError] {
+    const request = $.pointerValue<http.Request | null>(req)
+    if (request == null) {
+      return [null, errors.New('net/http: nil Request')]
+    }
+    const recorder = NewRecorder()
+    const served = this.server.ServeHTTP(recorder, request)
+    if (served instanceof Promise) {
+      return [null, errors.New('net/http/httptest: async handlers are not supported by Client.Do')]
+    }
+    return [recorder.Result(), null]
+  }
+}
+
+export function NewServer(handler: http.Handler | null): Server {
+  return new Server({ Handler: handler })
+}
+
+export function NewUnstartedServer(handler: http.Handler | null): Server {
+  return new Server({ Handler: handler })
+}
+
+export function Server_Start(_s: Server | $.VarRef<Server> | null): $.GoError {
+  return errors.New('net/http/httptest: Server.Start is not implemented in GoScript')
+}