goscript 0.1.3 → 0.1.4

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/crypto/sha1/index.test.ts

@@ -1,7 +1,8 @@
 import { createHash } from 'node:crypto'
 import { describe, expect, it } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
 
-import { New, Sum } from './index.js'
+import { New, Size, Sum } from './index.js'
 
 describe('crypto/sha1 override', () => {
   it('matches Node digest', async () => {
@@ -15,7 +16,23 @@ describe('crypto/sha1 override', () => {
     h.Write(new TextEncoder().encode('go'))
     h.Write(new TextEncoder().encode('script'))
 
-    expect(toHex(await h.Sum(null))).toBe(nodeHash(new TextEncoder().encode('goscript')))
+    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')),
+    )
   })
 })
 

package/gs/crypto/sha1/index.ts

@@ -41,7 +41,7 @@ class Digest {
       this.canCopyHash ?
         new Uint8Array(this.hash!.copy!().digest())
       : await sum(this.snapshotBytes())
-    return appendDigest($.bytesToUint8Array(b), digest)
+    return appendDigest(b, digest)
   }
 
   Reset(): void {
@@ -92,11 +92,8 @@ async function sum(data: $.Bytes): Promise<Uint8Array> {
   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(): NodeCryptoHash | null {

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 {

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

@@ -1,7 +1,8 @@
 import { createHash } from 'node:crypto'
 import { describe, expect, it } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
 
-import { New, Sum384, Sum512, Sum512_224, Sum512_256 } from './index.js'
+import { New, Size, Sum384, Sum512, Sum512_224, Sum512_256 } from './index.js'
 
 describe('crypto/sha512 override', () => {
   it('matches Node digests', async () => {
@@ -18,7 +19,21 @@ describe('crypto/sha512 override', () => {
     h.Write(new TextEncoder().encode('go'))
     h.Write(new TextEncoder().encode('script'))
 
-    expect(toHex(await h.Sum(null))).toBe(nodeHash('sha512', new TextEncoder().encode('goscript')))
+    expect(toHex(await h.Sum(null))).toBe(
+      nodeHash('sha512', 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(toHex($.bytesToUint8Array(backing))).toBe(
+      nodeHash('sha512', new TextEncoder().encode('abc')),
+    )
   })
 })
 

package/gs/crypto/sha512/index.ts

@@ -38,7 +38,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 {
@@ -123,11 +123,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 {

package/gs/embed/index.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it } from 'vitest'
+
+import { cloneStructValue, markAsStructValue } from '@goscript/builtin/index.js'
+import { EOF } from '@goscript/io/index.js'
+import { ReadDir, ReadFile, Stat } from '@goscript/io/fs/index.js'
+
+import { FS } from './index.js'
+
+describe('embed.FS', () => {
+  it('clones embedded files as Go struct values', () => {
+    const original = markAsStructValue(
+      new FS(new Map([['config-set.bin', new Uint8Array([1, 2, 3])]])),
+    )
+
+    const cloned = cloneStructValue(original)
+    const [data, err] = cloned.ReadFile('config-set.bin')
+
+    expect(err).toBeNull()
+    expect(Array.from(data)).toEqual([1, 2, 3])
+  })
+
+  it('supports io/fs read, stat, and directory APIs', () => {
+    const fsys = markAsStructValue(
+      new FS(
+        new Map([
+          ['config-set.bin', new Uint8Array([1, 2, 3])],
+          ['assets/config.json', new Uint8Array([4])],
+        ]),
+      ),
+    )
+
+    const [data, readErr] = ReadFile(fsys, 'config-set.bin')
+    expect(readErr).toBeNull()
+    expect(Array.from(data)).toEqual([1, 2, 3])
+    data[0] = 9
+    const [dataAgain, readAgainErr] = ReadFile(fsys, 'config-set.bin')
+    expect(readAgainErr).toBeNull()
+    expect(Array.from(dataAgain)).toEqual([1, 2, 3])
+
+    const [rootEntries, rootErr] = ReadDir(fsys, '.')
+    expect(rootErr).toBeNull()
+    expect(rootEntries!.map((entry) => entry!.Name())).toEqual([
+      'assets',
+      'config-set.bin',
+    ])
+
+    const [assetInfo, statErr] = Stat(fsys, 'assets')
+    expect(statErr).toBeNull()
+    expect(assetInfo!.IsDir()).toBe(true)
+
+    const [assetEntries, assetErr] = ReadDir(fsys, 'assets')
+    expect(assetErr).toBeNull()
+    expect(assetEntries!.map((entry) => entry!.Name())).toEqual(['config.json'])
+  })
+
+  it('supports Open file reads and directory iteration', () => {
+    const fsys = markAsStructValue(
+      new FS(
+        new Map([
+          ['config-set.bin', new Uint8Array([1, 2, 3])],
+          ['assets/config.json', new Uint8Array([4])],
+        ]),
+      ),
+    )
+
+    const [file, openErr] = fsys.Open('config-set.bin')
+    expect(openErr).toBeNull()
+    const buffer = new Uint8Array(2)
+    const [firstRead, firstErr] = file!.Read(buffer)
+    expect(firstErr).toBeNull()
+    expect(firstRead).toBe(2)
+    expect(Array.from(buffer)).toEqual([1, 2])
+    const [secondRead, secondErr] = file!.Read(buffer)
+    expect(secondErr).toBeNull()
+    expect(secondRead).toBe(1)
+    expect(Array.from(buffer)).toEqual([3, 2])
+    const [eofRead, eofErr] = file!.Read(buffer)
+    expect(eofRead).toBe(0)
+    expect(eofErr).toBe(EOF)
+
+    const [dir, dirOpenErr] = fsys.Open('.')
+    expect(dirOpenErr).toBeNull()
+    const [entries, readDirErr] = dir!.ReadDir(1)
+    expect(readDirErr).toBeNull()
+    expect(entries!.map((entry) => entry!.Name())).toEqual(['assets'])
+  })
+})