goscript 0.2.3 → 0.2.4

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

@@ -44,7 +44,7 @@ describe('embed.FS', () => {
       'config-set.bin',
     ])
 
-    const [assetInfo, statErr] = Stat(fsys, 'assets')
+    const [assetInfo, statErr] = await Stat(fsys, 'assets')
     expect(statErr).toBeNull()
     expect(assetInfo!.IsDir()).toBe(true)
 

package/gs/io/fs/glob.ts

@@ -96,7 +96,7 @@ export async function globWithLimit(
     }
     if (!hasMeta(pattern)) {
       {
-        const [, statErr] = Stat(fsys, pattern)
+        const [, statErr] = await Stat(fsys, pattern)
         if (statErr != null) {
           return [null, null]
         }

package/gs/io/fs/meta.json

@@ -1,7 +1,10 @@
 {
   "asyncFunctions": {
     "Glob": true,
+    "Lstat": true,
     "ReadDir": true,
+    "Stat": true,
+    "Sub": true,
     "WalkDir": true
   }
 }

package/gs/io/fs/readlink.test.ts

@@ -35,8 +35,8 @@ describe('io/fs ReadLink', () => {
     expect(err?.Error()).toBe('readlink link: invalid argument')
   })
 
-  it('uses Lstat from ReadLinkFS implementations', () => {
-    const [, err] = Lstat(new linkFS(), 'link')
+  it('uses Lstat from ReadLinkFS implementations', async () => {
+    const [, err] = await Lstat(new linkFS(), 'link')
 
     expect(err).toBe(ErrInvalid)
   })

package/gs/io/fs/readlink.ts

@@ -60,10 +60,13 @@ export function ReadLink(fsys: FS, name: string): [string, $.GoError] {
   return sym!.ReadLink(name)
 }
 
-export function Lstat(fsys: FS, name: string): [FileInfo, $.GoError] {
+export async function Lstat(
+  fsys: FS,
+  name: string,
+): Promise<[FileInfo, $.GoError]> {
   const { value: sym, ok } = $.typeAssert<ReadLinkFS>(fsys, 'ReadLinkFS')
   if (!ok) {
-    return Stat(fsys, name)
+    return await Stat(fsys, name)
   }
   return sym!.Lstat(name)
 }

package/gs/io/fs/stat.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
+
+import { File, FileInfo, Stat } from './index.js'
+
+function fileInfo(name: string, isDir = false): FileInfo {
+  return {
+    IsDir(): boolean {
+      return isDir
+    },
+    ModTime(): any {
+      return null
+    },
+    Mode(): number {
+      return isDir ? 0o040000 : 0
+    },
+    Name(): string {
+      return name
+    },
+    Size(): number {
+      return 0
+    },
+    Sys(): null {
+      return null
+    },
+  }
+}
+
+describe('io/fs Stat override', () => {
+  it('awaits async StatFS implementations', async () => {
+    const info = fileInfo('pkg', true)
+
+    const [got, err] = await Stat(
+      {
+        async Stat(_name: string): Promise<[FileInfo, $.GoError]> {
+          return [info, null]
+        },
+        Open(_name: string): [File, $.GoError] {
+          throw new Error('StatFS path should not open')
+        },
+      },
+      'pkg',
+    )
+
+    expect(err).toBeNull()
+    expect(got).toBe(info)
+  })
+
+  it('awaits async Open, File.Stat, and Close fallback implementations', async () => {
+    const info = fileInfo('file.txt')
+    let closed = false
+    const file: File = {
+      async Close(): Promise<$.GoError> {
+        closed = true
+        return null
+      },
+      Read(_p0: Uint8Array): [number, $.GoError] {
+        return [0, null]
+      },
+      async Stat(): Promise<[FileInfo, $.GoError]> {
+        expect(closed).toBe(false)
+        return [info, null]
+      },
+    } as unknown as File
+
+    const [got, err] = await Stat(
+      {
+        async Open(_name: string): Promise<[File, $.GoError]> {
+          return [file, null]
+        },
+      } as any,
+      'file.txt',
+    )
+
+    expect(err).toBeNull()
+    expect(got).toBe(info)
+    expect(closed).toBe(true)
+  })
+})

package/gs/io/fs/stat.ts

@@ -1,14 +1,25 @@
 import * as $ from '@goscript/builtin/index.js'
-import { FS, FileInfo } from './fs.js'
+import { FS, File, FileInfo } from './fs.js'
+
+type maybePromise<T> = T | Promise<T>
 
 export type StatFS =
   | null
   | ({
       // Stat returns a FileInfo describing the file.
       // If there is an error, it should be of type *PathError.
-      Stat(name: string): [FileInfo, $.GoError]
+      Stat(name: string): maybePromise<[FileInfo, $.GoError]>
     } & FS)
 
+type asyncFS = null | {
+  Open(name: string): maybePromise<[File, $.GoError]>
+}
+
+type asyncFile = null | {
+  Close(): maybePromise<$.GoError>
+  Stat(): maybePromise<[FileInfo, $.GoError]>
+}
+
 $.registerInterfaceType(
   'StatFS',
   null, // Zero value for interface is null
@@ -42,21 +53,24 @@ $.registerInterfaceType(
 //
 // If fs implements [StatFS], Stat calls fs.Stat.
 // Otherwise, Stat opens the [File] to stat it.
-export function Stat(fsys: FS, name: string): [FileInfo, $.GoError] {
-  using __defer = new $.DisposableStack()
+export async function Stat(
+  fsys: FS,
+  name: string,
+): Promise<[FileInfo, $.GoError]> {
   {
     let { value: fsysTyped, ok: ok } = $.typeAssert<StatFS>(fsys, 'StatFS')
     if (ok) {
-      return fsysTyped!.Stat(name)
+      return await fsysTyped!.Stat(name)
     }
   }
 
-  let [file, err] = fsys!.Open(name)
+  let [file, err] = await (fsys as asyncFS)!.Open(name)
   if (err != null) {
     return [null, err]
   }
-  __defer.defer(() => {
-    file!.Close()
-  })
-  return file!.Stat()
+  try {
+    return await (file as asyncFile)!.Stat()
+  } finally {
+    await (file as asyncFile)!.Close()
+  }
 }

package/gs/io/fs/sub.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
+
+import { File, FileInfo, Sub, Stat } from './index.js'
+
+function fileInfo(name: string, isDir = false): FileInfo {
+  return {
+    IsDir(): boolean {
+      return isDir
+    },
+    ModTime(): any {
+      return null
+    },
+    Mode(): number {
+      return isDir ? 0o040000 : 0
+    },
+    Name(): string {
+      return name
+    },
+    Size(): number {
+      return 0
+    },
+    Sys(): null {
+      return null
+    },
+  }
+}
+
+describe('io/fs Sub override', () => {
+  it('preserves the backing filesystem and directory in fallback subFS', async () => {
+    const opened: string[] = []
+    const dirInfo = fileInfo('pkg', true)
+    const file: File = {
+      async Close(): Promise<$.GoError> {
+        return null
+      },
+      Read(_p0: Uint8Array): [number, $.GoError] {
+        return [0, null]
+      },
+      async Stat(): Promise<[FileInfo, $.GoError]> {
+        return [dirInfo, null]
+      },
+    } as unknown as File
+
+    const [sub, subErr] = await Sub(
+      {
+        async Open(name: string): Promise<[File, $.GoError]> {
+          opened.push(name)
+          return [file, null]
+        },
+      } as any,
+      'pkg',
+    )
+    expect(subErr).toBeNull()
+
+    const [got, statErr] = await Stat(sub, '.')
+    expect(statErr).toBeNull()
+    expect(got).toBe(dirInfo)
+    expect(opened).toEqual(['pkg'])
+  })
+
+  it('joins nested fallback subFS directories', async () => {
+    const opened: string[] = []
+    const fileInfoValue = fileInfo('index.js')
+    const file: File = {
+      async Close(): Promise<$.GoError> {
+        return null
+      },
+      Read(_p0: Uint8Array): [number, $.GoError] {
+        return [0, null]
+      },
+      async Stat(): Promise<[FileInfo, $.GoError]> {
+        return [fileInfoValue, null]
+      },
+    } as unknown as File
+
+    const backingFS = {
+      async Open(name: string): Promise<[File, $.GoError]> {
+        opened.push(name)
+        return [file, null]
+      },
+    } as any
+    const [pkgFS, pkgErr] = await Sub(backingFS, '@scope')
+    expect(pkgErr).toBeNull()
+    const [clientFS, clientErr] = await Sub(pkgFS, 'client')
+    expect(clientErr).toBeNull()
+
+    const [got, statErr] = await Stat(clientFS, 'index.js')
+    expect(statErr).toBeNull()
+    expect(got).toBe(fileInfoValue)
+    expect(opened).toEqual(['@scope/client/index.js'])
+  })
+})

package/gs/io/fs/sub.ts

@@ -12,7 +12,7 @@ export type SubFS =
   | null
   | ({
       // Sub returns an FS corresponding to the subtree rooted at dir.
-      Sub(dir: string): [FS, $.GoError]
+      Sub(dir: string): [FS, $.GoError] | Promise<[FS, $.GoError]>
     } & FS)
 
 $.registerInterfaceType(
@@ -56,7 +56,7 @@ $.registerInterfaceType(
 // does not check for symbolic links inside "/prefix" that point to
 // other directories. That is, [os.DirFS] is not a general substitute for a
 // chroot-style security mechanism, and Sub does not change that fact.
-export function Sub(fsys: FS, dir: string): [FS, $.GoError] {
+export async function Sub(fsys: FS, dir: string): Promise<[FS, $.GoError]> {
   if (!ValidPath(dir)) {
     return [null, new PathError({ Err: ErrInvalid, Op: 'sub', Path: dir })]
   }
@@ -66,10 +66,10 @@ export function Sub(fsys: FS, dir: string): [FS, $.GoError] {
   {
     let { value: fsysTyped, ok: ok } = $.typeAssert<SubFS>(fsys, 'SubFS')
     if (ok) {
-      return fsysTyped!.Sub(dir)
+      return await fsysTyped!.Sub(dir)
     }
   }
-  return [new subFS({}), null]
+  return [new subFS({ fsys, dir }) as unknown as FS, null]
 }
 
 class subFS {
@@ -153,14 +153,14 @@ class subFS {
     return err
   }
 
-  public Open(name: string): [File, $.GoError] {
+  public async Open(name: string): Promise<[File, $.GoError]> {
     const f = this
     let [full, err] = f!.fullName('open', name)
     if (err != null) {
       return [null, err]
     }
     let file: File
-    ;[file, err] = f!.fsys!.Open(full)
+    ;[file, err] = await (f!.fsys as any)!.Open(full)
     return [file, f!.fixErr(err)]
   }
 
@@ -225,13 +225,13 @@ class subFS {
   public Sub(dir: string): [FS, $.GoError] {
     const f = this
     if (dir == '.') {
-      return [f, null]
+      return [f as unknown as FS, null]
     }
-    let [_full, err] = f!.fullName('sub', dir)
+    let [full, err] = f!.fullName('sub', dir)
     if (err != null) {
       return [null, err]
     }
-    return [new subFS({}), null]
+    return [new subFS({ fsys: f.fsys, dir: full }) as unknown as FS, null]
   }
 
   // Register this type with the runtime type system