goscript 0.2.2 → 0.2.4

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

@@ -0,0 +1,86 @@
+import { describe, expect, test } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+import * as bytes from '@goscript/bytes/index.js'
+import * as io from '@goscript/io/index.js'
+
+import {
+  BestCompression,
+  BestSpeed,
+  DefaultCompression,
+  ErrHeader,
+  HuffmanOnly,
+  NewReader,
+  NewWriter,
+  NewWriterLevel,
+  NoCompression,
+} from './index.js'
+
+describe('compress/gzip override', () => {
+  test('exports flate compression level constants', () => {
+    expect(NoCompression).toBe(0)
+    expect(BestSpeed).toBe(1)
+    expect(BestCompression).toBe(9)
+    expect(DefaultCompression).toBe(-1)
+    expect(HuffmanOnly).toBe(-2)
+  })
+
+  test('rejects invalid compression levels', () => {
+    const buf = $.markAsStructValue(new bytes.Buffer())
+
+    expect(NewWriterLevel(buf, HuffmanOnly)[1]).toBeNull()
+    expect(NewWriterLevel(buf, BestCompression)[1]).toBeNull()
+    expect(NewWriterLevel(buf, HuffmanOnly - 1)[1]?.Error()).toBe(
+      'gzip: invalid compression level: -3',
+    )
+    expect(NewWriterLevel(buf, BestCompression + 1)[1]?.Error()).toBe(
+      'gzip: invalid compression level: 10',
+    )
+  })
+
+  test('round trips bytes through writer and reader', async () => {
+    const input = $.stringToBytes('hello gzip world')
+    const buf = $.markAsStructValue(new bytes.Buffer())
+    const writer = NewWriter(buf)
+
+    const [written, writeErr] = writer.Write(input)
+    expect(writeErr).toBeNull()
+    expect(written).toBe(input.length)
+    expect(await writer.Close()).toBeNull()
+
+    const [reader, readerErr] = NewReader(bytes.NewReader(buf.Bytes()))
+    expect(readerErr).toBeNull()
+    expect(reader).not.toBeNull()
+
+    const [out, readErr] = await io.ReadAll(reader!)
+    expect(readErr).toBeNull()
+    expect($.bytesToString(out)).toBe('hello gzip world')
+  })
+
+  test('reader reset accepts async generated readers', async () => {
+    const compressed = $.markAsStructValue(new bytes.Buffer())
+    const writer = NewWriter(compressed)
+    expect(writer.Write($.stringToBytes('async gzip source'))[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 gzip source')
+  })
+
+  test('invalid gzip bytes return ErrHeader', () => {
+    const [reader, err] = NewReader(bytes.NewReader($.stringToBytes('plain')))
+    expect(reader).toBeNull()
+    expect(err).toBe(ErrHeader)
+  })
+})

package/gs/compress/gzip/index.ts

@@ -0,0 +1,297 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as errors from '@goscript/errors/index.js'
+import * as io from '@goscript/io/index.js'
+
+type maybeAsyncWriter = {
+  Write(p: $.Bytes): [number, $.GoError] | Promise<[number, $.GoError]>
+}
+
+type compressionRuntime = {
+  gzipSync?: (data: Uint8Array, opts?: Record<string, unknown>) => Uint8Array
+  gunzipSync?: (data: Uint8Array) => Uint8Array
+}
+
+export const NoCompression = 0
+export const BestSpeed = 1
+export const BestCompression = 9
+export const DefaultCompression = -1
+export const HuffmanOnly = -2
+
+export let ErrChecksum = errors.New('gzip: invalid checksum')
+export let ErrHeader = errors.New('gzip: invalid header')
+
+export function __goscript_set_ErrChecksum(value: $.GoError): void {
+  ErrChecksum = value
+}
+
+export function __goscript_set_ErrHeader(value: $.GoError): void {
+  ErrHeader = value
+}
+
+export class Header {
+  Comment = ''
+  Extra: $.Bytes = null
+  ModTime: any = null
+  Name = ''
+  OS = 255
+}
+
+export class Reader {
+  private data: Uint8Array = new Uint8Array(0)
+  private offset = 0
+  private pending: Promise<{ data: Uint8Array | null; err: $.GoError }> | null =
+    null
+
+  constructor(r?: io.Reader | null) {
+    if (r != null) {
+      this.Reset(r)
+    }
+  }
+
+  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]
+    }
+    const out = $.bytesToUint8Array(p)
+    const n = Math.min(out.length, this.data.length - this.offset)
+    out.set(this.data.subarray(this.offset, this.offset + n))
+    this.offset += n
+    return [n, null]
+  }
+
+  Close(): $.GoError {
+    return null
+  }
+
+  Reset(r: io.Reader | null): $.GoError {
+    if (r == null) {
+      return errors.New('gzip: nil reader')
+    }
+    const result = readGunzipped(r)
+    this.data = new Uint8Array(0)
+    this.offset = 0
+    if (result instanceof Promise) {
+      this.pending = result
+      return null
+    }
+    this.pending = null
+    if (result.err != null) {
+      return result.err
+    }
+    this.data = result.data ?? new Uint8Array(0)
+    return null
+  }
+}
+
+export class Writer {
+  private chunks: Uint8Array[] = []
+  private closed = false
+
+  constructor(
+    private w: io.Writer | null,
+    private level = DefaultCompression,
+  ) {}
+
+  Write(p: $.Bytes): [number, $.GoError] {
+    if (this.closed) {
+      return [0, errors.New('gzip: writer closed')]
+    }
+    const data = $.bytesToUint8Array(p)
+    this.chunks.push(data.slice())
+    return [data.length, null]
+  }
+
+  async Close(): Promise<$.GoError> {
+    if (this.closed) {
+      return null
+    }
+    this.closed = true
+    if (this.w == null) {
+      return errors.New('gzip: nil writer')
+    }
+    const compressed = await gzipBytes(concat(this.chunks), this.level)
+    const writer = $.pointerValue<maybeAsyncWriter>(this.w)
+    const [, err] = await writer.Write(compressed)
+    return err
+  }
+
+  Flush(): $.GoError {
+    return null
+  }
+
+  Reset(w: io.Writer | null): void {
+    this.w = w
+    this.chunks = []
+    this.closed = false
+  }
+}
+
+export function NewReader(
+  r: io.Reader | null,
+): [io.ReadCloser | null, $.GoError] {
+  const reader = new Reader()
+  const err = reader.Reset(r)
+  if (err != null) {
+    return [null, err]
+  }
+  return [reader as any, null]
+}
+
+export function NewWriter(w: io.Writer | null): Writer {
+  return new Writer(w)
+}
+
+export function NewWriterLevel(
+  w: io.Writer | null,
+  level: number,
+): [Writer | null, $.GoError] {
+  if (level < HuffmanOnly || level > BestCompression) {
+    return [null, errors.New(`gzip: invalid compression level: ${level}`)]
+  }
+  return [new Writer(w, level), null]
+}
+
+async function gzipBytes(data: Uint8Array, level: number): Promise<Uint8Array> {
+  const runtime = nodeCompressionRuntime()
+  if (runtime?.gzipSync != null) {
+    return runtime.gzipSync(data, { level })
+  }
+
+  const CompressionStreamCtor = (globalThis as any).CompressionStream
+  if (typeof CompressionStreamCtor !== 'function') {
+    throw new Error('compress/gzip: CompressionStream unavailable')
+  }
+  return streamTransform(data, new CompressionStreamCtor('gzip'))
+}
+
+function gunzipBytes(
+  data: Uint8Array,
+): Uint8Array | Promise<Uint8Array> {
+  const runtime = nodeCompressionRuntime()
+  if (runtime?.gunzipSync != null) {
+    return runtime.gunzipSync(data)
+  }
+
+  const DecompressionStreamCtor = (globalThis as any).DecompressionStream
+  if (typeof DecompressionStreamCtor !== 'function') {
+    throw new Error('compress/gzip: DecompressionStream unavailable')
+  }
+  return streamTransform(data, new DecompressionStreamCtor('gzip'))
+}
+
+async function streamTransform(
+  data: Uint8Array,
+  stream: ReadableWritablePair<Uint8Array, Uint8Array>,
+): Promise<Uint8Array> {
+  const body = new ArrayBuffer(data.length)
+  new Uint8Array(body).set(data)
+  const response = new Response(
+    new Blob([body]).stream().pipeThrough(stream as any),
+  )
+  return new Uint8Array(await response.arrayBuffer())
+}
+
+function readGunzipped(
+  r: io.Reader,
+):
+  | { data: Uint8Array | null; err: $.GoError }
+  | Promise<{ data: Uint8Array | null; err: $.GoError }> {
+  const chunks: Uint8Array[] = []
+  const buf = $.makeSlice<number>(1, undefined, 'byte')
+  while (true) {
+    const read = r.Read(buf)
+    if (read instanceof Promise) {
+      return readGunzippedAsync(read, r, buf, chunks)
+    }
+    const [n, err] = read
+    recordChunk(chunks, buf, n)
+    if (err != null) {
+      if (err === io.EOF) {
+        return inflateRecorded(chunks)
+      }
+      return { data: null, err }
+    }
+  }
+}
+
+async function readGunzippedAsync(
+  read: Promise<[number, $.GoError]>,
+  r: io.Reader,
+  buf: $.Bytes,
+  chunks: Uint8Array[],
+): Promise<{ data: Uint8Array | null; err: $.GoError }> {
+  while (true) {
+    const [n, err] = await read
+    recordChunk(chunks, buf, n)
+    if (err != null) {
+      if (err === io.EOF) {
+        return inflateRecorded(chunks)
+      }
+      return { data: null, err }
+    }
+    read = r.Read(buf) as any
+  }
+}
+
+function recordChunk(chunks: Uint8Array[], buf: $.Bytes, n: number): void {
+  if (n > 0) {
+    chunks.push($.bytesToUint8Array($.goSlice(buf, 0, n)).slice())
+  }
+}
+
+function inflateRecorded(
+  chunks: Uint8Array[],
+): { data: Uint8Array | null; err: $.GoError } | Promise<{
+  data: Uint8Array | null
+  err: $.GoError
+}> {
+  try {
+    const inflated = gunzipBytes(concat(chunks))
+    if (inflated instanceof Promise) {
+      return inflated
+        .then((data) => ({ data, err: null }))
+        .catch(() => ({ data: null, err: ErrHeader }))
+    }
+    return { data: inflated, err: null }
+  } catch {
+    return { data: null, err: ErrHeader }
+  }
+}
+
+function concat(chunks: Uint8Array[]): Uint8Array {
+  let length = 0
+  for (const chunk of chunks) {
+    length += chunk.length
+  }
+  const out = new Uint8Array(length)
+  let offset = 0
+  for (const chunk of chunks) {
+    out.set(chunk, offset)
+    offset += chunk.length
+  }
+  return out
+}
+
+function nodeCompressionRuntime(): compressionRuntime | null {
+  const processObj = (globalThis as any).process
+  if (processObj && typeof processObj.getBuiltinModule === 'function') {
+    const mod = processObj.getBuiltinModule('zlib')
+    if (mod && typeof mod.gzipSync === 'function') {
+      return {
+        gzipSync: (data, opts) => new Uint8Array(mod.gzipSync(data, opts)),
+        gunzipSync: (data) => new Uint8Array(mod.gunzipSync(data)),
+      }
+    }
+  }
+  return null
+}

package/gs/compress/gzip/meta.json

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

package/gs/compress/gzip/parity.json

@@ -0,0 +1,45 @@
+{
+  "schemaVersion": 1,
+  "strict": true,
+  "symbols": {
+    "BestCompression": {
+      "status": "real"
+    },
+    "BestSpeed": {
+      "status": "real"
+    },
+    "DefaultCompression": {
+      "status": "real"
+    },
+    "ErrChecksum": {
+      "status": "real"
+    },
+    "ErrHeader": {
+      "status": "real"
+    },
+    "Header": {
+      "status": "real"
+    },
+    "HuffmanOnly": {
+      "status": "real"
+    },
+    "NewReader": {
+      "status": "real"
+    },
+    "NewWriter": {
+      "status": "real"
+    },
+    "NewWriterLevel": {
+      "status": "real"
+    },
+    "NoCompression": {
+      "status": "real"
+    },
+    "Reader": {
+      "status": "real"
+    },
+    "Writer": {
+      "status": "real"
+    }
+  }
+}

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

@@ -119,22 +119,36 @@ describe('compress/zlib override', () => {
   test('writer and reader honor preset dictionaries', async () => {
     const dict = $.stringToBytes('hello dictionary')
     const compressed = $.markAsStructValue(new bytes.Buffer())
-    const [writer, writerErr] = NewWriterLevelDict(compressed, DefaultCompression, dict)
+    const [writer, writerErr] = NewWriterLevelDict(
+      compressed,
+      DefaultCompression,
+      dict,
+    )
     expect(writerErr).toBeNull()
-    expect(writer!.Write($.stringToBytes('hello dictionary payload'))[1]).toBeNull()
+    expect(
+      writer!.Write($.stringToBytes('hello dictionary payload'))[1],
+    ).toBeNull()
     expect(await writer!.Close()).toBeNull()
 
-    const [missingDictReader, missingDictErr] = NewReader(bytes.NewReader(compressed.Bytes()))
+    const [missingDictReader, missingDictErr] = NewReader(
+      bytes.NewReader(compressed.Bytes()),
+    )
     expect(missingDictReader).toBeNull()
     expect(missingDictErr).toBe(ErrDictionary)
 
-    const [reader, readerErr] = NewReaderDict(bytes.NewReader(compressed.Bytes()), dict)
+    const [reader, readerErr] = NewReaderDict(
+      bytes.NewReader(compressed.Bytes()),
+      dict,
+    )
     expect(readerErr).toBeNull()
     const [out, readErr] = await io.ReadAll(reader!)
     expect(readErr).toBeNull()
     expect($.bytesToString(out)).toBe('hello dictionary payload')
 
-    const [, wrongDictErr] = NewReaderDict(bytes.NewReader(compressed.Bytes()), $.stringToBytes('wrong dictionary'))
+    const [, wrongDictErr] = NewReaderDict(
+      bytes.NewReader(compressed.Bytes()),
+      $.stringToBytes('wrong dictionary'),
+    )
     expect(wrongDictErr).toBe(ErrDictionary)
 
     const corrupt = Uint8Array.from(compressed.Bytes())

package/gs/compress/zlib/index.ts

@@ -37,9 +37,8 @@ export function __goscript_set_ErrHeader(value: $.GoError): void {
 class zlibReader implements Resetter {
   private data: Uint8Array = new Uint8Array(0)
   private offset = 0
-  private pending:
-    | Promise<{ data: Uint8Array | null; err: $.GoError }>
-    | null = null
+  private pending: Promise<{ data: Uint8Array | null; err: $.GoError }> | null =
+    null
 
   constructor(data?: Uint8Array) {
     if (data != null) {
@@ -180,7 +179,11 @@ export function NewReaderDict(
   return [reader as any, null]
 }
 
-function deflate(data: Uint8Array, dict: $.Bytes | null, level: number): Uint8Array {
+function deflate(
+  data: Uint8Array,
+  dict: $.Bytes | null,
+  level: number,
+): Uint8Array {
   const zlib = nodeZlib()
   const opts: Record<string, unknown> = {}
   if (dict != null && $.len(dict) > 0) {
@@ -197,7 +200,10 @@ function deflate(data: Uint8Array, dict: $.Bytes | null, level: number): Uint8Ar
 
 function inflate(data: Uint8Array, dict: $.Bytes | null): Uint8Array {
   const zlib = nodeZlib()
-  const opts = dict != null && $.len(dict) > 0 ? { dictionary: $.bytesToUint8Array(dict) } : undefined
+  const opts =
+    dict != null && $.len(dict) > 0 ?
+      { dictionary: $.bytesToUint8Array(dict) }
+    : undefined
   return new Uint8Array(zlib.inflateSync(data, opts))
 }
 
@@ -302,11 +308,14 @@ function recordCompressedBytes(
 }
 
 function classifyInflateError(err: unknown): $.GoError {
-  const zerr = err instanceof Error ? err as nodeZlibError : null
+  const zerr = err instanceof Error ? (err as nodeZlibError) : null
   if (zerr?.code === 'Z_NEED_DICT') {
     return ErrDictionary
   }
-  if (zerr?.code === 'Z_DATA_ERROR' && zerr.message.includes('incorrect data check')) {
+  if (
+    zerr?.code === 'Z_DATA_ERROR' &&
+    zerr.message.includes('incorrect data check')
+  ) {
     return ErrChecksum
   }
   return ErrHeader

package/gs/context/context.test.ts

@@ -29,7 +29,9 @@ describe('context override', () => {
     )
 
     expect(
-      ctx.Value($.interfaceValue($.markAsStructValue(new Key()), 'example.key')),
+      ctx.Value(
+        $.interfaceValue($.markAsStructValue(new Key()), 'example.key'),
+      ),
     ).toBe('stored')
   })
 

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

@@ -35,9 +35,13 @@ describe('crypto/ecdh override', () => {
 })
 
 function hex(value: string): Uint8Array {
-  return new Uint8Array(value.match(/../g)!.map((byte) => Number.parseInt(byte, 16)))
+  return new Uint8Array(
+    value.match(/../g)!.map((byte) => Number.parseInt(byte, 16)),
+  )
 }
 
 function toHex(value: Uint8Array | null): string {
-  return Array.from(value ?? [], (byte) => byte.toString(16).padStart(2, '0')).join('')
+  return Array.from(value ?? [], (byte) =>
+    byte.toString(16).padStart(2, '0'),
+  ).join('')
 }

package/gs/crypto/ecdh/index.ts

@@ -29,7 +29,9 @@ export class PublicKey {
 
   public Equal(x: PublicKey | $.VarRef<PublicKey> | null): boolean {
     const other = $.pointerValueOrNil(x)
-    return other instanceof PublicKey && bytesEqual(this.publicKey, other.publicKey)
+    return (
+      other instanceof PublicKey && bytesEqual(this.publicKey, other.publicKey)
+    )
   }
 }
 
@@ -54,17 +56,27 @@ export class PrivateKey {
     return this.curve
   }
 
-  public ECDH(remote: PublicKey | $.VarRef<PublicKey> | null): [$.Bytes, $.GoError] {
+  public ECDH(
+    remote: PublicKey | $.VarRef<PublicKey> | null,
+  ): [$.Bytes, $.GoError] {
     const remoteKey = $.pointerValueOrNil(remote)
     if (remoteKey == null || remoteKey.curve !== this.curve) {
-      return [null, $.newError('crypto/ecdh: private key and public key curves do not match')]
+      return [
+        null,
+        $.newError(
+          'crypto/ecdh: private key and public key curves do not match',
+        ),
+      ]
     }
     return this.curve.ecdh(this, remoteKey)
   }
 
   public Equal(x: PrivateKey | $.VarRef<PrivateKey> | null): boolean {
     const other = $.pointerValueOrNil(x)
-    return other instanceof PrivateKey && bytesEqual(this.privateKey, other.privateKey)
+    return (
+      other instanceof PrivateKey &&
+      bytesEqual(this.privateKey, other.privateKey)
+    )
   }
 
   public Public(): PublicKey {
@@ -80,7 +92,9 @@ export class x25519Curve {
   public GenerateKey(r: io.Reader | null): [PrivateKey | null, $.GoError] {
     const key = new Uint8Array(x25519PrivateKeySize)
     if (r != null) {
-      throw new Error('crypto/ecdh: custom random readers are not implemented in GoScript')
+      throw new Error(
+        'crypto/ecdh: custom random readers are not implemented in GoScript',
+      )
     }
     globalThis.crypto.getRandomValues(key)
     return this.NewPrivateKey(key)
@@ -113,10 +127,18 @@ export class x25519Curve {
     return 'X25519'
   }
 
-  public ecdh(local: PrivateKey | null, remote: PublicKey | null): [$.Bytes, $.GoError] {
+  public ecdh(
+    local: PrivateKey | null,
+    remote: PublicKey | null,
+  ): [$.Bytes, $.GoError] {
     const out = scalarMult(local?.privateKey ?? null, remote?.publicKey ?? null)
     if (isZero(out)) {
-      return [null, $.newError('crypto/ecdh: bad X25519 remote ECDH input: low order point')]
+      return [
+        null,
+        $.newError(
+          'crypto/ecdh: bad X25519 remote ECDH input: low order point',
+        ),
+      ]
     }
     return [out, null]
   }
@@ -132,23 +154,38 @@ export class unsupportedCurve {
   constructor(private readonly name: string) {}
 
   public GenerateKey(_r: io.Reader | null): [PrivateKey | null, $.GoError] {
-    return [null, $.newError(`crypto/ecdh: ${this.name} is not implemented in GoScript`)]
+    return [
+      null,
+      $.newError(`crypto/ecdh: ${this.name} is not implemented in GoScript`),
+    ]
   }
 
   public NewPrivateKey(_key: $.Bytes): [PrivateKey | null, $.GoError] {
-    return [null, $.newError(`crypto/ecdh: ${this.name} is not implemented in GoScript`)]
+    return [
+      null,
+      $.newError(`crypto/ecdh: ${this.name} is not implemented in GoScript`),
+    ]
   }
 
   public NewPublicKey(_key: $.Bytes): [PublicKey | null, $.GoError] {
-    return [null, $.newError(`crypto/ecdh: ${this.name} is not implemented in GoScript`)]
+    return [
+      null,
+      $.newError(`crypto/ecdh: ${this.name} is not implemented in GoScript`),
+    ]
   }
 
   public String(): string {
     return this.name
   }
 
-  public ecdh(_local: PrivateKey | null, _remote: PublicKey | null): [$.Bytes, $.GoError] {
-    return [null, $.newError(`crypto/ecdh: ${this.name} is not implemented in GoScript`)]
+  public ecdh(
+    _local: PrivateKey | null,
+    _remote: PublicKey | null,
+  ): [$.Bytes, $.GoError] {
+    return [
+      null,
+      $.newError(`crypto/ecdh: ${this.name} is not implemented in GoScript`),
+    ]
   }
 }