goscript 0.1.2 → 0.1.4

package/gs/bytes/bytes.gs.ts

@@ -8,6 +8,9 @@ import * as utf8 from "@goscript/unicode/utf8/index.js"
 // for linkname
 import * as _ from "@goscript/unsafe/index.js"
 
+type SyncCallbackResult<T> = T | globalThis.Promise<T>
+type PredicateCallback = ((r: number) => SyncCallbackResult<boolean>) | null
+
 // Equal reports whether a and b
 // are the same length and contain the same bytes.
 // A nil argument is equivalent to an empty slice.
@@ -90,7 +93,7 @@ export function ContainsRune(b: $.Bytes, r: number): boolean {
 }
 
 // ContainsFunc reports whether any of the UTF-8-encoded code points r within b satisfy f(r).
-export function ContainsFunc(b: $.Bytes, f: ((p0: number) => boolean) | null): boolean {
+export function ContainsFunc(b: $.Bytes, f: PredicateCallback): boolean {
 	return IndexFunc(b, f) >= 0
 }
 
@@ -794,21 +797,21 @@ export function TrimSuffix(s: $.Bytes, suffix: $.Bytes): $.Bytes {
 // IndexFunc interprets s as a sequence of UTF-8-encoded code points.
 // It returns the byte index in s of the first Unicode
 // code point satisfying f(c), or -1 if none do.
-export function IndexFunc(s: $.Bytes, f: ((r: number) => boolean) | null): number {
+export function IndexFunc(s: $.Bytes, f: PredicateCallback): number {
 	return indexFunc(s, f, true)
 }
 
 // LastIndexFunc interprets s as a sequence of UTF-8-encoded code points.
 // It returns the byte index in s of the last Unicode
 // code point satisfying f(c), or -1 if none do.
-export function LastIndexFunc(s: $.Bytes, f: ((r: number) => boolean) | null): number {
+export function LastIndexFunc(s: $.Bytes, f: PredicateCallback): number {
 	return lastIndexFunc(s, f, true)
 }
 
 // indexFunc is the same as IndexFunc except that if
 // truth==false, the sense of the predicate function is
 // inverted.
-export function indexFunc(s: $.Bytes, f: ((r: number) => boolean) | null, truth: boolean): number {
+export function indexFunc(s: $.Bytes, f: PredicateCallback, truth: boolean): number {
 	if (s === null || f === null) {
 		return -1
 	}
@@ -817,12 +820,12 @@ export function indexFunc(s: $.Bytes, f: ((r: number) => boolean) | null, truth:
 		const [r, size] = utf8.DecodeRune($.goSlice(s, i, undefined))
 		if (size <= 0) {
 			// Invalid UTF-8
-			if (f(utf8.RuneError) === truth) {
+			if (syncBoolean(f(utf8.RuneError)) === truth) {
 				return i
 			}
 			i++
 		} else {
-			if (f(r) === truth) {
+			if (syncBoolean(f(r)) === truth) {
 				return i
 			}
 			i += size
@@ -835,7 +838,7 @@ export function indexFunc(s: $.Bytes, f: ((r: number) => boolean) | null, truth:
 // lastIndexFunc is the same as LastIndexFunc except that if
 // truth==false, the sense of the predicate function is
 // inverted.
-export function lastIndexFunc(s: $.Bytes, f: ((r: number) => boolean) | null, truth: boolean): number {
+export function lastIndexFunc(s: $.Bytes, f: PredicateCallback, truth: boolean): number {
 	if (s === null || f === null) {
 		return -1
 	}
@@ -846,12 +849,12 @@ export function lastIndexFunc(s: $.Bytes, f: ((r: number) => boolean) | null, tr
 		const [r, size] = utf8.DecodeRune($.goSlice(s, i, undefined))
 		if (size <= 0) {
 			// Invalid UTF-8
-			if (f(utf8.RuneError) === truth) {
+			if (syncBoolean(f(utf8.RuneError)) === truth) {
 				lastIndex = i
 			}
 			i++
 		} else {
-			if (f(r) === truth) {
+			if (syncBoolean(f(r)) === truth) {
 				lastIndex = i
 			}
 			i += size
@@ -861,6 +864,13 @@ export function lastIndexFunc(s: $.Bytes, f: ((r: number) => boolean) | null, tr
 	return lastIndex
 }
 
+function syncBoolean(value: SyncCallbackResult<boolean>): boolean {
+	if (value instanceof Promise) {
+		throw new Error("bytes: asynchronous callback result is not supported")
+	}
+	return value
+}
+
 class asciiSet {
 	constructor(public _value: number[]) {}
 
@@ -1285,4 +1295,3 @@ export function CutSuffix(s: $.Bytes, suffix: $.Bytes): [$.Bytes, boolean] {
 	}
 	return [$.goSlice(s, undefined, $.len(s) - $.len(suffix)), true]
 }
-

package/gs/bytes/bytes.test.ts

@@ -0,0 +1,17 @@
+import * as $ from "@goscript/builtin/index.js"
+import { IndexFunc } from "./index.js"
+import { describe, expect, test } from "vitest"
+
+describe("bytes", () => {
+	test("IndexFunc accepts generated async-shaped callbacks", () => {
+		const predicate: (r: number) => boolean | Promise<boolean> = (r) => r === 0x62
+
+		expect(IndexFunc($.stringToBytes("abc"), predicate)).toBe(1)
+	})
+
+	test("IndexFunc rejects actual async callback results", () => {
+		expect(() => IndexFunc($.stringToBytes("abc"), async (r) => r === 0x62)).toThrow(
+			"bytes: asynchronous callback result is not supported",
+		)
+	})
+})

package/gs/compress/zlib/index.test.ts

@@ -25,4 +25,101 @@ describe('compress/zlib override', () => {
     expect(readErr).toBeNull()
     expect($.bytesToString(out)).toBe('hello compressed world')
   })
+
+  test('reader implements resettable zlib reader contract', async () => {
+    const first = $.markAsStructValue(new bytes.Buffer())
+    const firstWriter = NewWriter(first)
+    expect(firstWriter.Write($.stringToBytes('first stream'))[1]).toBeNull()
+    expect(await firstWriter.Close()).toBeNull()
+
+    const second = $.markAsStructValue(new bytes.Buffer())
+    const secondWriter = NewWriter(second)
+    expect(secondWriter.Write($.stringToBytes('second stream'))[1]).toBeNull()
+    expect(await secondWriter.Close()).toBeNull()
+
+    const readerInterface = $.registerInterfaceType(
+      'compress/zlib.testReader',
+      null,
+      [
+        { name: 'Close', args: [], returns: [{ type: 'error' }] },
+        {
+          name: 'Read',
+          args: [
+            {
+              name: 'p',
+              type: {
+                kind: $.TypeKind.Slice,
+                elemType: { kind: $.TypeKind.Basic, name: 'uint8' },
+              },
+            },
+          ],
+          returns: [{ type: 'int' }, { type: 'error' }],
+        },
+        {
+          name: 'Reset',
+          args: [{ type: 'io.Reader' }, { type: '[]byte' }],
+          returns: [{ type: 'error' }],
+        },
+      ],
+    )
+
+    const [reader, readerErr] = NewReader(bytes.NewReader(first.Bytes()))
+    expect(readerErr).toBeNull()
+    const [zlibReader, ok] = $.typeAssertTuple<
+      io.ReadCloser & {
+        Reset(r: io.Reader | null, dict: $.Bytes | null): $.GoError
+      }
+    >(reader, readerInterface)
+    expect(ok).toBe(true)
+
+    const [firstOut, firstReadErr] = await io.ReadAll(zlibReader)
+    expect(firstReadErr).toBeNull()
+    expect($.bytesToString(firstOut)).toBe('first stream')
+
+    expect(zlibReader.Reset(bytes.NewReader(second.Bytes()), null)).toBeNull()
+    const [secondOut, secondReadErr] = await io.ReadAll(zlibReader)
+    expect(secondReadErr).toBeNull()
+    expect($.bytesToString(secondOut)).toBe('second stream')
+  })
+
+  test('reader reset accepts async generated readers', async () => {
+    const compressed = $.markAsStructValue(new bytes.Buffer())
+    const writer = NewWriter(compressed)
+    expect(writer.Write($.stringToBytes('async source stream'))[1]).toBeNull()
+    expect(await writer.Close()).toBeNull()
+
+    const source = bytes.NewReader(compressed.Bytes())
+    const asyncReader = {
+      async Read(p: $.Bytes): Promise<[number, $.GoError]> {
+        await Promise.resolve()
+        return source.Read(p)
+      },
+    }
+
+    const [reader, readerErr] = NewReader(asyncReader as io.Reader)
+    expect(readerErr).toBeNull()
+    const [out, readErr] = await io.ReadAll(reader!)
+    expect(readErr).toBeNull()
+    expect($.bytesToString(out)).toBe('async source stream')
+  })
+
+  test('Close awaits pointer-wrapped generated writers', async () => {
+    const chunks: number[] = []
+    const sink = {
+      async Write(p: $.Bytes): Promise<[number, $.GoError]> {
+        await Promise.resolve()
+        chunks.push(...Array.from(p ?? []))
+        return [$.len(p), null]
+      },
+    }
+    const writer = NewWriter(
+      $.interfaceValue($.varRef(sink), '*zlib.asyncWriter'),
+    )
+
+    const [written, writeErr] = writer.Write($.stringToBytes('async zlib sink'))
+    expect(writeErr).toBeNull()
+    expect(written).toBe('async zlib sink'.length)
+    expect(await writer.Close()).toBeNull()
+    expect(chunks.length).toBeGreaterThan(0)
+  })
 })

package/gs/compress/zlib/index.ts

@@ -3,7 +3,11 @@ import * as errors from '@goscript/errors/index.js'
 import * as io from '@goscript/io/index.js'
 
 export type Resetter = {
-  Reset(r: io.Reader | null, dict: $.Bytes | null): Promise<$.GoError>
+  Reset(r: io.Reader | null, dict: $.Bytes | null): $.GoError
+}
+
+type maybeAsyncWriter = {
+  Write(p: $.Bytes): [number, $.GoError] | Promise<[number, $.GoError]>
 }
 
 export let ErrChecksum = errors.New('zlib: invalid checksum')
@@ -22,12 +26,30 @@ export function __goscript_set_ErrHeader(value: $.GoError): void {
   ErrHeader = value
 }
 
-class zlibReader implements io.ReadCloser {
+class zlibReader implements Resetter {
+  private data: Uint8Array = new Uint8Array(0)
   private offset = 0
+  private pending:
+    | Promise<{ data: Uint8Array | null; err: $.GoError }>
+    | null = null
 
-  constructor(private data: Uint8Array) {}
+  constructor(data?: Uint8Array) {
+    if (data != null) {
+      this.data = data
+    }
+  }
 
-  Read(p: $.Bytes): [number, $.GoError] {
+  async Read(p: $.Bytes): Promise<[number, $.GoError]> {
+    const pending = this.pending
+    if (pending != null) {
+      this.pending = null
+      const result = await pending
+      if (result.err != null) {
+        return [0, result.err]
+      }
+      this.data = result.data ?? new Uint8Array(0)
+      this.offset = 0
+    }
     if (this.offset >= this.data.length) {
       return [0, io.EOF]
     }
@@ -41,6 +63,26 @@ class zlibReader implements io.ReadCloser {
   Close(): $.GoError {
     return null
   }
+
+  Reset(r: io.Reader | null, dict: $.Bytes | null): $.GoError {
+    if (r == null) {
+      return errors.New('zlib: nil reader')
+    }
+    const result = readInflated(r, dict)
+    if (result instanceof Promise) {
+      this.data = new Uint8Array(0)
+      this.offset = 0
+      this.pending = result
+      return null
+    }
+    if (result.err != null) {
+      return result.err
+    }
+    this.data = result.data ?? new Uint8Array(0)
+    this.offset = 0
+    this.pending = null
+    return null
+  }
 }
 
 export class Writer {
@@ -58,7 +100,7 @@ export class Writer {
     return [data.length, null]
   }
 
-  Close(): $.GoError {
+  async Close(): Promise<$.GoError> {
     if (this.closed) {
       return null
     }
@@ -67,7 +109,8 @@ export class Writer {
       return errors.New('zlib: nil writer')
     }
     const compressed = deflate(concat(this.chunks))
-    const [, err] = this.w.Write(compressed)
+    const writer = $.pointerValue<maybeAsyncWriter>(this.w)
+    const [, err] = await writer.Write(compressed)
     return err
   }
 
@@ -109,21 +152,14 @@ export function NewReader(
 
 export function NewReaderDict(
   r: io.Reader | null,
-  _dict: $.Bytes | null,
+  dict: $.Bytes | null,
 ): [io.ReadCloser | null, $.GoError] {
-  if (r == null) {
-    return [null, errors.New('zlib: nil reader')]
-  }
-  const [data, readErr] = readAll(r)
-  if (readErr != null) {
-    return [null, readErr]
-  }
-  try {
-    const out = inflate($.bytesToUint8Array(data))
-    return [new zlibReader(out), null]
-  } catch {
-    return [null, ErrHeader]
+  const reader = new zlibReader()
+  const err = reader.Reset(r, dict)
+  if (err != null) {
+    return [null, err]
   }
+  return [reader as any, null]
 }
 
 function deflate(data: Uint8Array): Uint8Array {
@@ -168,20 +204,74 @@ function nodeZlib(): any {
   throw new Error('compress/zlib: node zlib module unavailable')
 }
 
-function readAll(r: io.Reader): [Uint8Array, $.GoError] {
-  const chunks: Uint8Array[] = []
-  const buf = $.makeSlice<number>(32 * 1024, undefined, 'byte')
+function readInflated(
+  r: io.Reader,
+  dict: $.Bytes | null,
+):
+  | { data: Uint8Array | null; err: $.GoError }
+  | Promise<{ data: Uint8Array | null; err: $.GoError }> {
+  const chunks: number[] = []
+  const buf = $.makeSlice<number>(1, undefined, 'byte')
+  while (true) {
+    const read = r.Read(buf)
+    if (read instanceof Promise) {
+      return readInflatedAsync(read, r, buf, chunks, dict)
+    }
+    const [n, err] = read
+    const result = recordCompressedBytes(chunks, buf, n, dict)
+    if (result.err == null && result.data != null) {
+      return result
+    }
+    if (err != null) {
+      if (err === io.EOF) {
+        return result
+      }
+      return { data: null, err }
+    }
+  }
+}
+
+async function readInflatedAsync(
+  first: Promise<[number, $.GoError]>,
+  r: io.Reader,
+  buf: $.Bytes,
+  chunks: number[],
+  dict: $.Bytes | null,
+): Promise<{ data: Uint8Array | null; err: $.GoError }> {
+  let read = await first
   while (true) {
-    const [n, err] = r.Read(buf)
-    if (n > 0) {
-      chunks.push($.bytesToUint8Array($.goSlice(buf, 0, n)).slice())
+    const [n, err] = read
+    const result = recordCompressedBytes(chunks, buf, n, dict)
+    if (result.err == null && result.data != null) {
+      return result
     }
     if (err != null) {
       if (err === io.EOF) {
-        return [concat(chunks), null]
+        return result
       }
-      return [new Uint8Array(0), err]
+      return { data: null, err }
+    }
+    read = await r.Read(buf)
+  }
+}
+
+function recordCompressedBytes(
+  chunks: number[],
+  buf: $.Bytes,
+  n: number,
+  dict: $.Bytes | null,
+): { data: Uint8Array | null; err: $.GoError } {
+  if (n > 0) {
+    chunks.push(...$.bytesToUint8Array($.goSlice(buf, 0, n)))
+  }
+  const compressed = new Uint8Array(chunks)
+  try {
+    return { data: inflate(compressed), err: null }
+  } catch {
+    if (dict != null && $.len(dict) > 0) {
+      return { data: null, err: ErrDictionary }
     }
+    return { data: null, err: ErrHeader }
   }
 }
 

package/gs/compress/zlib/meta.json

@@ -1,3 +1,6 @@
 {
-  "dependencies": []
+  "dependencies": [],
+  "asyncMethods": {
+    "Writer.Close": true
+  }
 }

package/gs/context/context.test.ts

@@ -8,6 +8,10 @@ async function nextMicrotask(): Promise<void> {
   await new Promise<void>((resolve) => queueMicrotask(resolve))
 }
 
+async function nextTask(): Promise<void> {
+  await new Promise<void>((resolve) => setTimeout(resolve, 0))
+}
+
 describe('context override', () => {
   it('matches generated struct keys by Go comparable value', () => {
     class Key {
@@ -39,7 +43,7 @@ describe('context override', () => {
 
     cancel?.()
     await nextMicrotask()
-    await nextMicrotask()
+    await nextTask()
 
     expect(called).toBe(true)
     expect(stop()).toBe(false)

package/gs/crypto/sha1/index.test.ts

@@ -0,0 +1,45 @@
+import { createHash } from 'node:crypto'
+import { describe, expect, it } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
+
+import { New, Size, Sum } from './index.js'
+
+describe('crypto/sha1 override', () => {
+  it('matches Node digest', async () => {
+    const data = new TextEncoder().encode('goscript sha1')
+
+    expect(toHex(await Sum(data))).toBe(nodeHash(data))
+  })
+
+  it('supports incremental hash.Hash use', async () => {
+    const h = New()
+    h.Write(new TextEncoder().encode('go'))
+    h.Write(new TextEncoder().encode('script'))
+
+    expect(toHex(await h.Sum(null))).toBe(
+      nodeHash(new TextEncoder().encode('goscript')),
+    )
+  })
+
+  it('appends into spare byte-slice backing', async () => {
+    const h = New()
+    h.Write(new TextEncoder().encode('abc'))
+
+    const backing = $.makeSlice<number>(Size, undefined, 'byte')
+    const out = await h.Sum($.goSlice(backing, 0, 0))
+    expect(out.length).toBe(Size)
+    expect(backing[0]).toBe(out[0])
+    expect(backing[Size - 1]).toBe(out[Size - 1])
+    expect(toHex($.bytesToUint8Array(backing))).toBe(
+      nodeHash(new TextEncoder().encode('abc')),
+    )
+  })
+})
+
+function nodeHash(data: Uint8Array): string {
+  return createHash('sha1').update(data).digest('hex')
+}
+
+function toHex(value: Uint8Array): string {
+  return Buffer.from(value).toString('hex')
+}

package/gs/crypto/sha1/index.ts

@@ -0,0 +1,127 @@
+import * as $ from '@goscript/builtin/index.js'
+import {
+  getHostRuntime,
+  type NodeCryptoHash,
+} from '@goscript/builtin/hostio.js'
+
+export const Size = 20
+export const BlockSize = 64
+
+class Sha1Error {
+  constructor(private readonly message: string) {}
+
+  Error(): string {
+    return this.message
+  }
+}
+
+class Digest {
+  private chunks: Uint8Array[] = []
+  private dataLength = 0
+  private hash: NodeCryptoHash | null
+  private canCopyHash: boolean
+
+  constructor() {
+    this.hash = createNodeHash()
+    this.canCopyHash = typeof this.hash?.copy === 'function'
+  }
+
+  Write(p: $.Bytes): [number, $.GoError] {
+    const bytes = $.bytesToUint8Array(p)
+    this.hash?.update(bytes)
+    if (!this.canCopyHash) {
+      this.chunks.push(bytes.slice())
+      this.dataLength += bytes.length
+    }
+    return [bytes.length, null]
+  }
+
+  async Sum(b: $.Bytes): Promise<$.Bytes> {
+    const digest =
+      this.canCopyHash ?
+        new Uint8Array(this.hash!.copy!().digest())
+      : await sum(this.snapshotBytes())
+    return appendDigest(b, digest)
+  }
+
+  Reset(): void {
+    this.chunks = []
+    this.dataLength = 0
+    this.hash = createNodeHash()
+    this.canCopyHash = typeof this.hash?.copy === 'function'
+  }
+
+  Size(): number {
+    return Size
+  }
+
+  BlockSize(): number {
+    return BlockSize
+  }
+
+  private snapshotBytes(): Uint8Array {
+    return concatChunks(this.chunks, this.dataLength)
+  }
+}
+
+export function New(): any {
+  return new Digest()
+}
+
+export async function Sum(data: $.Bytes): Promise<Uint8Array> {
+  return sum(data)
+}
+
+async function sum(data: $.Bytes): Promise<Uint8Array> {
+  const hash = createNodeHash()
+  if (hash != null) {
+    return new Uint8Array(hash.update($.bytesToUint8Array(data)).digest())
+  }
+
+  const subtle = subtleCrypto()
+  if (subtle == null) {
+    throw new Error(
+      new Sha1Error('crypto/sha1: WebCrypto digest is unavailable').Error(),
+    )
+  }
+
+  const digest = await subtle.digest(
+    'SHA-1',
+    $.bytesToUint8Array(data) as unknown as BufferSource,
+  )
+  return new Uint8Array(digest)
+}
+
+function appendDigest(prefix: $.Bytes, digest: Uint8Array): $.Bytes {
+  return $.append(prefix as any, ...digest) as $.Bytes
+}
+
+function createNodeHash(): NodeCryptoHash | null {
+  const nodeCrypto = getHostRuntime().nodeCrypto
+  if (!nodeCrypto?.createHash) {
+    return null
+  }
+  try {
+    return nodeCrypto.createHash('sha1')
+  } catch {
+    return null
+  }
+}
+
+function concatChunks(chunks: Uint8Array[], length: number): Uint8Array {
+  const out = new Uint8Array(length)
+  let offset = 0
+  for (const chunk of chunks) {
+    out.set(chunk, offset)
+    offset += chunk.length
+  }
+  return out
+}
+
+function subtleCrypto(): SubtleCrypto | null {
+  const crypto = globalThis.crypto
+  if (crypto?.subtle && typeof crypto.subtle.digest === 'function') {
+    return crypto.subtle
+  }
+  return null
+}

package/gs/crypto/sha1/meta.json

@@ -0,0 +1,8 @@
+{
+  "asyncFunctions": {
+    "Sum": true
+  },
+  "asyncMethods": {
+    "Digest.Sum": true
+  }
+}

package/gs/crypto/sha256/index.test.ts

@@ -25,11 +25,23 @@ describe('crypto/sha256 override', () => {
     )
   })
 
+  test('streaming digest appends into spare byte-slice backing', async () => {
+    const digest = New()
+    expect(digest.Write($.stringToBytes('abc'))).toEqual([3, null])
+
+    const backing = $.makeSlice<number>(Size, undefined, 'byte')
+    const out = await digest.Sum($.goSlice(backing, 0, 0))
+    expect(out.length).toBe(Size)
+    expect(Array.from($.bytesToUint8Array(backing))).toEqual(
+      Array.from(await Sum256($.stringToBytes('abc'))),
+    )
+  })
+
   test('sums SHA-224 with host crypto', async () => {
     const sum = await Sum224($.stringToBytes('abc'))
     expect(Array.from(sum)).toEqual([
-      35, 9, 125, 34, 52, 5, 216, 34, 134, 66, 164, 119, 189, 162, 85, 179,
-      42, 173, 188, 228, 189, 160, 179, 247, 227, 108, 157, 167,
+      35, 9, 125, 34, 52, 5, 216, 34, 134, 66, 164, 119, 189, 162, 85, 179, 42,
+      173, 188, 228, 189, 160, 179, 247, 227, 108, 157, 167,
     ])
   })
 

package/gs/crypto/sha256/index.ts

@@ -44,7 +44,7 @@ class Digest {
       this.canCopyHash ?
         new Uint8Array(this.hash!.copy!().digest())
       : await sum(this.algorithm, this.snapshotBytes())
-    return appendDigest($.bytesToUint8Array(b), digest)
+    return appendDigest(b, digest)
   }
 
   Reset(): void {
@@ -112,11 +112,8 @@ async function sum(
   return new Uint8Array(digest)
 }
 
-function appendDigest(prefix: Uint8Array, digest: Uint8Array): Uint8Array {
-  const out = new Uint8Array(prefix.length + digest.length)
-  out.set(prefix)
-  out.set(digest, prefix.length)
-  return out
+function appendDigest(prefix: $.Bytes, digest: Uint8Array): $.Bytes {
+  return $.append(prefix as any, ...digest) as $.Bytes
 }
 
 function createNodeHash(algorithm: ShaAlgorithm): NodeCryptoHash | null {