goscript 0.1.3 → 0.2.0

package/gs/io/io.ts

@@ -68,71 +68,116 @@ export interface ReadCloser extends Reader, Closer {}
 export interface WriteCloser extends Writer, Closer {}
 export interface ReadWriteCloser extends Reader, Writer, Closer {}
 export interface ReadSeeker extends Reader, Seeker {}
+export interface ReadSeekCloser extends Reader, Seeker, Closer {}
 export interface WriteSeeker extends Writer, Seeker {}
 export interface ReadWriteSeeker extends Reader, Writer, Seeker {}
 
 class pipeState {
-  private chunks: Uint8Array[] = []
-  private readOffset = 0
   private readerClosed = false
   private writerClosed = false
   private readerErr: $.GoError = null
   private writerErr: $.GoError = null
-
-  Read(p: $.Bytes): [number, $.GoError] {
-    if (this.readerClosed) {
-      return [0, this.readerErr ?? ErrClosedPipe]
-    }
-    if ($.len(p) === 0) {
-      return [0, null]
-    }
-    if (this.chunks.length === 0) {
+  private pendingReads: Array<{
+    data: $.Bytes
+    resolve: (result: [number, $.GoError]) => void
+  }> = []
+  private pendingWrites: Array<{
+    data: Uint8Array
+    offset: number
+    resolve: (result: [number, $.GoError]) => void
+  }> = []
+
+  Read(p: $.Bytes): Promise<[number, $.GoError]> {
+    return (async (): Promise<[number, $.GoError]> => {
+      if (this.readerClosed) {
+        return [0, this.readerErr ?? ErrClosedPipe]
+      }
+      if ($.len(p) === 0) {
+        return [0, null]
+      }
+      if (this.pendingWrites.length > 0) {
+        return this.consumeNextWrite(p)
+      }
       if (this.writerClosed) {
         return [0, this.writerErr ?? EOF]
       }
-      return [0, EOF]
-    }
-
-    let copied = 0
-    while (copied < $.len(p) && this.chunks.length > 0) {
-      const chunk = this.chunks[0]
-      const available = chunk.length - this.readOffset
-      const want = Math.min($.len(p) - copied, available)
-      const target = $.goSlice(p, copied, copied + want)
-      $.copy(target, chunk.subarray(this.readOffset, this.readOffset + want))
-      copied += want
-      this.readOffset += want
-      if (this.readOffset === chunk.length) {
-        this.chunks.shift()
-        this.readOffset = 0
-      }
-    }
-    return [copied, null]
+      return await new Promise<[number, $.GoError]>((resolve) => {
+        this.pendingReads.push({ data: p, resolve })
+      })
+    })()
   }
 
-  Write(p: $.Bytes): [number, $.GoError] {
-    if (this.writerClosed || this.readerClosed) {
-      return [0, this.readerErr ?? ErrClosedPipe]
-    }
-    const data = new Uint8Array($.len(p))
-    $.copy(data, p)
-    this.chunks.push(data)
-    return [$.len(p), null]
+  Write(p: $.Bytes): Promise<[number, $.GoError]> {
+    return (async (): Promise<[number, $.GoError]> => {
+      if (this.writerClosed || this.readerClosed) {
+        return [0, this.readerErr ?? ErrClosedPipe]
+      }
+      if ($.len(p) === 0) {
+        return [0, null]
+      }
+      const data = new Uint8Array($.len(p))
+      $.copy(data, p)
+      return await new Promise<[number, $.GoError]>((resolve) => {
+        this.pendingWrites.push({ data, offset: 0, resolve })
+        this.drain()
+      })
+    })()
   }
 
   CloseReader(err: $.GoError): $.GoError {
     this.readerClosed = true
     this.readerErr = err
-    this.chunks = []
-    this.readOffset = 0
+    this.resolvePendingReads(ErrClosedPipe)
+    this.resolvePendingWrites(ErrClosedPipe)
     return null
   }
 
   CloseWriter(err: $.GoError): $.GoError {
     this.writerClosed = true
     this.writerErr = err
+    if (this.pendingWrites.length === 0) {
+      this.resolvePendingReads(err ?? EOF)
+    }
     return null
   }
+
+  private drain(): void {
+    while (this.pendingWrites.length > 0 && this.pendingReads.length > 0) {
+      if (this.readerClosed) {
+        this.resolvePendingWrites(this.readerErr ?? ErrClosedPipe)
+        return
+      }
+      const pending = this.pendingReads.shift()!
+      pending.resolve(this.consumeNextWrite(pending.data))
+    }
+  }
+
+  private consumeNextWrite(p: $.Bytes): [number, $.GoError] {
+    const pending = this.pendingWrites[0]
+    const n = Math.min($.len(p), pending.data.length - pending.offset)
+    $.copy(p, pending.data.subarray(pending.offset, pending.offset + n))
+    pending.offset += n
+    if (pending.offset === pending.data.length) {
+      this.pendingWrites.shift()
+      pending.resolve([pending.data.length, null])
+      if (this.writerClosed && this.pendingWrites.length === 0) {
+        this.resolvePendingReads(this.writerErr ?? EOF)
+      }
+    }
+    return [n, null]
+  }
+
+  private resolvePendingReads(err: $.GoError): void {
+    while (this.pendingReads.length > 0) {
+      this.pendingReads.shift()!.resolve([0, err])
+    }
+  }
+
+  private resolvePendingWrites(err: $.GoError): void {
+    while (this.pendingWrites.length > 0) {
+      this.pendingWrites.shift()!.resolve([0, err])
+    }
+  }
 }
 
 // PipeReader is the read half of a pipe.
@@ -140,7 +185,7 @@ export class PipeReader implements Reader, Closer {
   constructor(private pipe: pipeState) {}
 
   Read(data: $.Bytes): [number, $.GoError] {
-    return this.pipe.Read(data)
+    return this.pipe.Read(data) as any
   }
 
   Close(): $.GoError {
@@ -157,7 +202,7 @@ export class PipeWriter implements Writer, Closer {
   constructor(private pipe: pipeState) {}
 
   Write(data: $.Bytes): [number, $.GoError] {
-    return this.pipe.Write(data)
+    return this.pipe.Write(data) as any
   }
 
   Close(): $.GoError {
@@ -235,15 +280,18 @@ class DiscardWriter implements Writer {
 export const Discard: Writer | null = new DiscardWriter()
 
 // WriteString writes the contents of the string s to w, which accepts a slice of bytes
-export function WriteString(w: Writer, s: string): [number, $.GoError] {
+export async function WriteString(
+  w: Writer,
+  s: string,
+): Promise<[number, $.GoError]> {
   // Check if w implements StringWriter interface
   if ('WriteString' in w && typeof (w as any).WriteString === 'function') {
-    return (w as StringWriter).WriteString(s)
+    return await ((w as StringWriter).WriteString(s) as any)
   }
 
   // Convert string to bytes and write
   const bytes = new TextEncoder().encode(s)
-  return w.Write(bytes)
+  return await (w.Write(bytes) as any)
 }
 
 // LimitedReader reads from R but limits the amount of data returned to just N bytes
@@ -251,7 +299,10 @@ export class LimitedReader implements Reader {
   public R: Reader | null
   public N: number
 
-  constructor(r?: Reader | { R?: Reader | null; N?: number } | null, n?: number) {
+  constructor(
+    r?: Reader | { R?: Reader | null; N?: number } | null,
+    n?: number,
+  ) {
     if (r != null && typeof (r as { Read?: unknown }).Read !== 'function') {
       const init = r as { R?: Reader | null; N?: number }
       this.R = init.R ?? null
@@ -605,7 +656,15 @@ export async function ReadAll(r: Reader): Promise<[$.Bytes, $.GoError]> {
 }
 
 // NopCloser returns a ReadCloser with a no-op Close method wrapping the provided Reader r
-export function NopCloser(r: Reader): ReadCloser {
+export function NopCloser(r: Reader | null): ReadCloser {
+  if (r == null) {
+    return {
+      Read: () => {
+        throw new Error('nil Reader')
+      },
+      Close: () => null,
+    }
+  }
   return {
     Read: r.Read.bind(r),
     Close: () => null,
@@ -655,22 +714,22 @@ class multiReader implements Reader {
 
 // MultiWriter creates a writer that duplicates its writes to all the provided writers
 export function MultiWriter(...writers: (Writer | null)[]): Writer {
-  return new multiWriter(writers.slice())
+  return new multiWriter(writers.slice()) as any
 }
 
-class multiWriter implements Writer {
+class multiWriter {
   private writers: (Writer | null)[]
 
   constructor(writers: (Writer | null)[]) {
     this.writers = writers
   }
 
-  Write(p: $.Bytes): [number, $.GoError] {
+  async Write(p: $.Bytes): Promise<[number, $.GoError]> {
     for (const w of this.writers) {
       if (w == null) {
         throw new Error('io.MultiWriter: nil writer')
       }
-      const [n, err] = w.Write(p)
+      const [n, err] = await w.Write(p)
       if (err !== null) {
         return [n, err]
       }
@@ -697,15 +756,19 @@ class teeReader implements Reader {
   }
 
   Read(p: $.Bytes): [number, $.GoError] {
+    return this.read(p) as any
+  }
+
+  private async read(p: $.Bytes): Promise<[number, $.GoError]> {
     if (this.r == null) {
       throw new Error('io.TeeReader: nil reader')
     }
-    const [n, err] = this.r.Read(p)
+    const [n, err] = await this.r.Read(p)
     if (n > 0) {
       if (this.w == null) {
         throw new Error('io.TeeReader: nil writer')
       }
-      const [nw, ew] = this.w.Write($.goSlice(p, 0, n))
+      const [nw, ew] = await this.w.Write($.goSlice(p, 0, n))
       if (ew !== null) {
         return [n, ew]
       }

package/gs/io/meta.json

@@ -12,6 +12,12 @@
     "CopyN": true,
     "ReadAtLeast": true,
     "ReadFull": true,
-    "ReadAll": true
+    "ReadAll": true,
+    "WriteString": true
+  },
+  "asyncMethods": {
+    "PipeReader.Read": true,
+    "PipeWriter.Write": true,
+    "TeeReader.Read": true
   }
 }

package/gs/io/parity.json

@@ -0,0 +1,162 @@
+{
+  "schemaVersion": 1,
+  "strict": true,
+  "symbols": {
+    "ByteReader": {
+      "status": "real"
+    },
+    "ByteScanner": {
+      "status": "real"
+    },
+    "ByteWriter": {
+      "status": "real"
+    },
+    "Closer": {
+      "status": "real"
+    },
+    "Copy": {
+      "status": "real"
+    },
+    "CopyBuffer": {
+      "status": "real"
+    },
+    "CopyN": {
+      "status": "real"
+    },
+    "Discard": {
+      "status": "real"
+    },
+    "EOF": {
+      "status": "real"
+    },
+    "ErrClosedPipe": {
+      "status": "real"
+    },
+    "ErrNoProgress": {
+      "status": "real"
+    },
+    "ErrShortBuffer": {
+      "status": "real"
+    },
+    "ErrShortWrite": {
+      "status": "real"
+    },
+    "ErrUnexpectedEOF": {
+      "status": "real"
+    },
+    "LimitedReader": {
+      "status": "real"
+    },
+    "LimitReader": {
+      "status": "real"
+    },
+    "MultiReader": {
+      "status": "real"
+    },
+    "MultiWriter": {
+      "status": "real"
+    },
+    "NewOffsetWriter": {
+      "status": "real"
+    },
+    "NewSectionReader": {
+      "status": "real"
+    },
+    "NopCloser": {
+      "status": "real"
+    },
+    "OffsetWriter": {
+      "status": "real"
+    },
+    "Pipe": {
+      "status": "real"
+    },
+    "PipeReader": {
+      "status": "real"
+    },
+    "PipeWriter": {
+      "status": "real"
+    },
+    "ReadAll": {
+      "status": "real"
+    },
+    "ReadAtLeast": {
+      "status": "real"
+    },
+    "ReadCloser": {
+      "status": "real"
+    },
+    "Reader": {
+      "status": "real"
+    },
+    "ReaderAt": {
+      "status": "real"
+    },
+    "ReaderFrom": {
+      "status": "real"
+    },
+    "ReadFull": {
+      "status": "real"
+    },
+    "ReadSeekCloser": {
+      "status": "real"
+    },
+    "ReadSeeker": {
+      "status": "real"
+    },
+    "ReadWriteCloser": {
+      "status": "real"
+    },
+    "ReadWriter": {
+      "status": "real"
+    },
+    "ReadWriteSeeker": {
+      "status": "real"
+    },
+    "RuneReader": {
+      "status": "real"
+    },
+    "RuneScanner": {
+      "status": "real"
+    },
+    "SectionReader": {
+      "status": "real"
+    },
+    "SeekCurrent": {
+      "status": "real"
+    },
+    "SeekEnd": {
+      "status": "real"
+    },
+    "Seeker": {
+      "status": "real"
+    },
+    "SeekStart": {
+      "status": "real"
+    },
+    "StringWriter": {
+      "status": "real"
+    },
+    "TeeReader": {
+      "status": "real"
+    },
+    "WriteCloser": {
+      "status": "real"
+    },
+    "Writer": {
+      "status": "real"
+    },
+    "WriterAt": {
+      "status": "real"
+    },
+    "WriterTo": {
+      "status": "real"
+    },
+    "WriteSeeker": {
+      "status": "real"
+    },
+    "WriteString": {
+      "status": "real"
+    }
+  }
+}

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

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 
-import { Mul64 } from './index.js'
+import { Mul64, Rem, Rem32, Rem64, RotateLeft16, RotateLeft32, RotateLeft64, RotateLeft8 } from './index.js'
 
 describe('math/bits override', () => {
   it('returns the full 128-bit product from Mul64', () => {
@@ -17,4 +17,17 @@ describe('math/bits override', () => {
       0xffc0000000000001n,
     ])
   })
+
+  it('returns remainders from double-word division helpers', () => {
+    expect(Rem32(1, 0, 3)).toBe(1)
+    expect(Rem(1n, 0n, 3n)).toBe(1n)
+    expect(Rem64(1n, 0n, 3n)).toBe(1n)
+  })
+
+  it('rotates right for negative counts', () => {
+    expect(RotateLeft8(1, -1)).toBe(0x80)
+    expect(RotateLeft16(1, -1)).toBe(0x8000)
+    expect(RotateLeft32(1, -1)).toBe(0x80000000)
+    expect(RotateLeft64(1n, -1)).toBe(0x8000000000000000n)
+  })
 })