goscript 0.1.4 → 0.2.0

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

@@ -4,9 +4,43 @@ import * as $ from '@goscript/builtin/index.js'
 import * as bytes from '@goscript/bytes/index.js'
 import * as io from '@goscript/io/index.js'
 
-import { NewReader, NewWriter } from './index.js'
+import {
+  BestCompression,
+  BestSpeed,
+  DefaultCompression,
+  ErrChecksum,
+  ErrDictionary,
+  HuffmanOnly,
+  NewReader,
+  NewReaderDict,
+  NewWriter,
+  NewWriterLevel,
+  NewWriterLevelDict,
+  NoCompression,
+} from './index.js'
 
 describe('compress/zlib 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(
+      'zlib: invalid compression level: -3',
+    )
+    expect(NewWriterLevelDict(buf, BestCompression + 1, null)[1]?.Error()).toBe(
+      'zlib: invalid compression level: 10',
+    )
+  })
+
   test('round trips bytes through writer and reader', async () => {
     const input = $.stringToBytes('hello compressed world')
     const buf = $.markAsStructValue(new bytes.Buffer())
@@ -82,6 +116,33 @@ describe('compress/zlib override', () => {
     expect($.bytesToString(secondOut)).toBe('second stream')
   })
 
+  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)
+    expect(writerErr).toBeNull()
+    expect(writer!.Write($.stringToBytes('hello dictionary payload'))[1]).toBeNull()
+    expect(await writer!.Close()).toBeNull()
+
+    const [missingDictReader, missingDictErr] = NewReader(bytes.NewReader(compressed.Bytes()))
+    expect(missingDictReader).toBeNull()
+    expect(missingDictErr).toBe(ErrDictionary)
+
+    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'))
+    expect(wrongDictErr).toBe(ErrDictionary)
+
+    const corrupt = Uint8Array.from(compressed.Bytes())
+    corrupt[corrupt.length - 1] ^= 0xff
+    const [, corruptErr] = NewReaderDict(bytes.NewReader(corrupt), dict)
+    expect(corruptErr).toBe(ErrChecksum)
+  })
+
   test('reader reset accepts async generated readers', async () => {
     const compressed = $.markAsStructValue(new bytes.Buffer())
     const writer = NewWriter(compressed)

package/gs/compress/zlib/index.ts

@@ -10,10 +10,18 @@ type maybeAsyncWriter = {
   Write(p: $.Bytes): [number, $.GoError] | Promise<[number, $.GoError]>
 }
 
+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('zlib: invalid checksum')
 export let ErrDictionary = errors.New('zlib: invalid dictionary')
 export let ErrHeader = errors.New('zlib: invalid header')
 
+type nodeZlibError = Error & { code?: unknown }
+
 export function __goscript_set_ErrChecksum(value: $.GoError): void {
   ErrChecksum = value
 }
@@ -89,7 +97,11 @@ export class Writer {
   private chunks: Uint8Array[] = []
   private closed = false
 
-  constructor(private w: io.Writer | null) {}
+  constructor(
+    private w: io.Writer | null,
+    private dict: $.Bytes | null = null,
+    private level = DefaultCompression,
+  ) {}
 
   Write(p: $.Bytes): [number, $.GoError] {
     if (this.closed) {
@@ -108,7 +120,7 @@ export class Writer {
     if (this.w == null) {
       return errors.New('zlib: nil writer')
     }
-    const compressed = deflate(concat(this.chunks))
+    const compressed = deflate(concat(this.chunks), this.dict, this.level)
     const writer = $.pointerValue<maybeAsyncWriter>(this.w)
     const [, err] = await writer.Write(compressed)
     return err
@@ -131,17 +143,23 @@ export function NewWriter(w: io.Writer | null): Writer {
 
 export function NewWriterLevel(
   w: io.Writer | null,
-  _level: number,
+  level: number,
 ): [Writer | null, $.GoError] {
-  return [new Writer(w), null]
+  if (level < HuffmanOnly || level > BestCompression) {
+    return [null, errors.New(`zlib: invalid compression level: ${level}`)]
+  }
+  return [new Writer(w, null, level), null]
 }
 
 export function NewWriterLevelDict(
   w: io.Writer | null,
-  _level: number,
+  level: number,
   _dict: $.Bytes | null,
 ): [Writer | null, $.GoError] {
-  return [new Writer(w), null]
+  if (level < HuffmanOnly || level > BestCompression) {
+    return [null, errors.New(`zlib: invalid compression level: ${level}`)]
+  }
+  return [new Writer(w, _dict, level), null]
 }
 
 export function NewReader(
@@ -162,14 +180,25 @@ export function NewReaderDict(
   return [reader as any, null]
 }
 
-function deflate(data: Uint8Array): Uint8Array {
+function deflate(data: Uint8Array, dict: $.Bytes | null, level: number): Uint8Array {
   const zlib = nodeZlib()
-  return new Uint8Array(zlib.deflateSync(data))
+  const opts: Record<string, unknown> = {}
+  if (dict != null && $.len(dict) > 0) {
+    opts.dictionary = $.bytesToUint8Array(dict)
+  }
+  if (level === HuffmanOnly) {
+    opts.strategy = zlib.constants?.Z_HUFFMAN_ONLY
+    opts.level = DefaultCompression
+  } else {
+    opts.level = level
+  }
+  return new Uint8Array(zlib.deflateSync(data, opts))
 }
 
-function inflate(data: Uint8Array): Uint8Array {
+function inflate(data: Uint8Array, dict: $.Bytes | null): Uint8Array {
   const zlib = nodeZlib()
-  return new Uint8Array(zlib.inflateSync(data))
+  const opts = dict != null && $.len(dict) > 0 ? { dictionary: $.bytesToUint8Array(dict) } : undefined
+  return new Uint8Array(zlib.inflateSync(data, opts))
 }
 
 function nodeZlib(): any {
@@ -266,13 +295,21 @@ function recordCompressedBytes(
   }
   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 }
+    return { data: inflate(compressed, dict), err: null }
+  } catch (err) {
+    return { data: null, err: classifyInflateError(err) }
+  }
+}
+
+function classifyInflateError(err: unknown): $.GoError {
+  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')) {
+    return ErrChecksum
   }
+  return ErrHeader
 }
 
 function concat(chunks: Uint8Array[]): Uint8Array {

package/gs/compress/zlib/parity.json

@@ -0,0 +1,51 @@
+{
+  "schemaVersion": 1,
+  "strict": true,
+  "symbols": {
+    "BestCompression": {
+      "status": "real"
+    },
+    "BestSpeed": {
+      "status": "real"
+    },
+    "DefaultCompression": {
+      "status": "real"
+    },
+    "ErrChecksum": {
+      "status": "real"
+    },
+    "ErrDictionary": {
+      "status": "real"
+    },
+    "ErrHeader": {
+      "status": "real"
+    },
+    "HuffmanOnly": {
+      "status": "real"
+    },
+    "NewReader": {
+      "status": "real"
+    },
+    "NewReaderDict": {
+      "status": "real"
+    },
+    "NewWriter": {
+      "status": "real"
+    },
+    "NewWriterLevel": {
+      "status": "real"
+    },
+    "NewWriterLevelDict": {
+      "status": "real"
+    },
+    "NoCompression": {
+      "status": "real"
+    },
+    "Resetter": {
+      "status": "real"
+    },
+    "Writer": {
+      "status": "real"
+    }
+  }
+}

package/gs/encoding/json/index.test.ts

@@ -1,8 +1,34 @@
 import { describe, expect, it } from 'vitest'
 
 import * as $ from '@goscript/builtin/index.js'
+import * as bytes from '@goscript/bytes/index.js'
 
-import { Marshal, MarshalIndent, Unmarshal, type Unmarshaler } from './index.js'
+import {
+  Compact,
+  HTMLEscape,
+  Indent,
+  InvalidUTF8Error,
+  InvalidUnmarshalError,
+  MarshalerError,
+  Marshal,
+  MarshalIndent,
+  NewDecoder,
+  NewEncoder,
+  Number_Float64,
+  Number_Int64,
+  Number_String,
+  RawMessage_MarshalJSON,
+  RawMessage_UnmarshalJSON,
+  SyntaxError as JSONSyntaxError,
+  UnmarshalFieldError,
+  Unmarshal,
+  UnmarshalTypeError,
+  UnsupportedTypeError,
+  UnsupportedValueError,
+  Valid,
+  type Marshaler,
+  type Unmarshaler,
+} from './index.js'
 
 class Person {
   public _fields = {
@@ -16,37 +42,92 @@ class Person {
     new Person(),
     [],
     Person,
-    {
-      Name: {
+    [
+      {
+        name: 'Name',
+        key: 'Name',
         type: { kind: $.TypeKind.Basic, name: 'string' },
         tag: 'json:"name"',
       },
-      Age: { type: { kind: $.TypeKind.Basic, name: 'int' }, tag: 'json:"age"' },
-      Active: {
+      {
+        name: 'Age',
+        key: 'Age',
+        type: { kind: $.TypeKind.Basic, name: 'int' },
+        tag: 'json:"age"',
+      },
+      {
+        name: 'Active',
+        key: 'Active',
         type: { kind: $.TypeKind.Basic, name: 'bool' },
         tag: 'json:"active"',
       },
-    },
+    ],
+  )
+}
+
+class FieldAlias {
+  public _fields = {
+    Name: $.varRef(''),
+  }
+
+  static __typeInfo = $.registerStructType(
+    'test.FieldAlias',
+    new FieldAlias(),
+    [],
+    FieldAlias,
+    [
+      {
+        name: 'FullName',
+        key: 'Name',
+        type: { kind: $.TypeKind.Basic, name: 'string' },
+      },
+    ],
   )
 }
 
 describe('encoding/json override', () => {
   it('registers the Unmarshaler interface shape', () => {
+    class CustomMarshaler implements Marshaler {
+      MarshalJSON(): [$.Slice<number>, $.GoError] {
+        return [$.stringToBytes('{"ok":true}'), null]
+      }
+    }
+
     class CustomUnmarshaler implements Unmarshaler {
       UnmarshalJSON(_data: $.Slice<number>): $.GoError {
         return null
       }
     }
 
+    const [, marshalOK] = $.typeAssertTuple<Marshaler>(
+      new CustomMarshaler(),
+      'json.Marshaler',
+    )
     const [value, ok] = $.typeAssertTuple<Unmarshaler>(
       new CustomUnmarshaler(),
       'json.Unmarshaler',
     )
 
+    expect(marshalOK).toBe(true)
     expect(ok).toBe(true)
     expect(value.UnmarshalJSON($.stringToBytes('{}'))).toBeNull()
   })
 
+  it('exposes JSON error structs as Go errors', () => {
+    for (const err of [
+      new JSONSyntaxError(),
+      new InvalidUTF8Error({ S: 'bad' }),
+      new InvalidUnmarshalError(),
+      new MarshalerError({ Err: $.newError('bad marshal') }),
+      new UnmarshalFieldError({ Key: 'field' }),
+      new UnmarshalTypeError({ Value: 'string' }),
+      new UnsupportedTypeError(),
+      new UnsupportedValueError({ Str: 'NaN' }),
+    ]) {
+      expect(err.Error()).toBe(err.message)
+    }
+  })
+
   it('marshals struct fields through json tags', () => {
     const person = new Person()
     person._fields.Name.value = 'Alice'
@@ -61,6 +142,187 @@ describe('encoding/json override', () => {
     )
   })
 
+  it('uses descriptor names separately from storage keys', () => {
+    const alias = new FieldAlias()
+    alias._fields.Name.value = 'Ada'
+
+    const [data, err] = Marshal(alias)
+    expect(err).toBeNull()
+    expect($.bytesToString(data)).toBe('{"FullName":"Ada"}')
+
+    const target = $.varRef(new FieldAlias())
+    expect(
+      Unmarshal($.stringToBytes('{"FullName":"Grace"}'), target),
+    ).toBeNull()
+    expect(target.value._fields.Name.value).toBe('Grace')
+  })
+
+  it('rejects unsupported values and invalid unmarshal targets', () => {
+    const [nanData, nanErr] = Marshal(Number.NaN)
+    expect(nanData).toBeNull()
+    expect(nanErr).toBeInstanceOf(UnsupportedValueError)
+
+    const [htmlData, htmlErr] = Marshal(new Map([['text', '<tag>&']]))
+    expect(htmlErr).toBeNull()
+    expect($.bytesToString(htmlData)).toBe(
+      '{"text":"\\u003ctag\\u003e\\u0026"}',
+    )
+
+    expect(Unmarshal($.stringToBytes('{}'), null)).toBeInstanceOf(
+      InvalidUnmarshalError,
+    )
+    expect(Unmarshal($.stringToBytes('{}'), 1)).toBeInstanceOf(
+      InvalidUnmarshalError,
+    )
+  })
+
+  it('uses custom marshal and unmarshal hooks', () => {
+    class CustomJSON implements Marshaler, Unmarshaler {
+      public Text = ''
+
+      MarshalJSON(): [$.Slice<number>, $.GoError] {
+        return [$.stringToBytes('{"hook":true}'), null]
+      }
+
+      UnmarshalJSON(data: $.Slice<number>): $.GoError {
+        this.Text = $.bytesToString(data)
+        return null
+      }
+    }
+
+    class RawEnvelope {
+      public _fields = {
+        Raw: $.varRef($.stringToBytes('{"embedded":true}')),
+      }
+
+      static __typeInfo = $.registerStructType(
+        'test.RawEnvelope',
+        new RawEnvelope(),
+        [],
+        RawEnvelope,
+        [
+          {
+            name: 'Raw',
+            key: 'Raw',
+            type: 'json.RawMessage',
+            tag: 'json:"raw"',
+          },
+        ],
+      )
+    }
+
+    class Envelope {
+      public _fields = {
+        Person: $.varRef(new Person()),
+        Data: $.varRef(new Uint8Array(0)),
+        Raw: $.varRef(new Uint8Array(0)),
+        Hook: $.varRef(new CustomJSON()),
+      }
+
+      static __typeInfo = $.registerStructType(
+        'test.Envelope',
+        new Envelope(),
+        [],
+        Envelope,
+        [
+          {
+            name: 'Person',
+            key: 'Person',
+            type: { kind: $.TypeKind.Struct, name: 'test.Person' },
+            tag: 'json:"person"',
+          },
+          {
+            name: 'Data',
+            key: 'Data',
+            type: {
+              kind: $.TypeKind.Slice,
+              elemType: { kind: $.TypeKind.Basic, name: 'uint8' },
+            },
+            tag: 'json:"data"',
+          },
+          {
+            name: 'Raw',
+            key: 'Raw',
+            type: {
+              kind: $.TypeKind.Slice,
+              elemType: { kind: $.TypeKind.Basic, name: 'uint8' },
+              typeName: 'json.RawMessage',
+            },
+            tag: 'json:"raw"',
+          },
+          {
+            name: 'Hook',
+            key: 'Hook',
+            type: { kind: $.TypeKind.Struct, name: 'test.CustomJSON' },
+            tag: 'json:"hook"',
+          },
+        ],
+      )
+    }
+
+    const [data, err] = Marshal(new CustomJSON())
+    expect(err).toBeNull()
+    expect($.bytesToString(data)).toBe('{"hook":true}')
+
+    const [indented, indentErr] = MarshalIndent(new CustomJSON(), '', '  ')
+    expect(indentErr).toBeNull()
+    expect($.bytesToString(indented)).toBe('{\n  "hook": true\n}')
+
+    const target = $.varRef(new CustomJSON())
+    expect(Unmarshal($.stringToBytes('{"input":1}'), target)).toBeNull()
+    expect(target.value.Text).toBe('{"input":1}')
+
+    const raw = $.namedValueInterfaceValue<unknown>(
+      $.stringToBytes('{"raw":true}'),
+      'json.RawMessage',
+      { MarshalJSON: RawMessage_MarshalJSON },
+    )
+    const [rawData, rawErr] = Marshal(raw)
+    expect(rawErr).toBeNull()
+    expect($.bytesToString(rawData)).toBe('{"raw":true}')
+
+    const [byteData, byteErr] = Marshal($.stringToBytes('x'))
+    expect(byteErr).toBeNull()
+    expect($.bytesToString(byteData)).toBe('"eA=="')
+
+    const [rawEnvelopeData, rawEnvelopeErr] = Marshal(new RawEnvelope())
+    expect(rawEnvelopeErr).toBeNull()
+    expect($.bytesToString(rawEnvelopeData)).toBe('{"raw":{"embedded":true}}')
+
+    const rawEnvelopeTarget = $.varRef(new RawEnvelope())
+    expect(
+      Unmarshal($.stringToBytes('{"raw":{"next":1}}'), rawEnvelopeTarget),
+    ).toBeNull()
+    expect($.bytesToString(rawEnvelopeTarget.value._fields.Raw.value)).toBe(
+      '{"next":1}',
+    )
+
+    const byteTarget = $.varRef(new Uint8Array(0))
+    expect(Unmarshal($.stringToBytes('"eA=="'), byteTarget)).toBeNull()
+    expect($.bytesToString(byteTarget.value)).toBe('x')
+
+    const envelope = $.varRef(new Envelope())
+    expect(
+      Unmarshal(
+        $.stringToBytes(
+          '{"person":{"name":"Eve","age":31},"data":"eA==","raw":{"keep":true},"hook":{"nested":true}}',
+        ),
+        envelope,
+      ),
+    ).toBeNull()
+    expect(envelope.value._fields.Person.value._fields.Name.value).toBe('Eve')
+    expect(envelope.value._fields.Person.value._fields.Age.value).toBe(31)
+    expect($.bytesToString(envelope.value._fields.Data.value)).toBe('x')
+    expect($.bytesToString(envelope.value._fields.Raw.value)).toBe(
+      '{"keep":true}',
+    )
+    expect(envelope.value._fields.Hook.value.Text).toBe('{"nested":true}')
+
+    const [envelopeData, envelopeErr] = Marshal(envelope.value)
+    expect(envelopeErr).toBeNull()
+    expect($.bytesToString(envelopeData)).toContain('"raw":{"keep":true}')
+  })
+
   it('marshals indented JSON with a line prefix', () => {
     const person = new Person()
     person._fields.Name.value = 'Alice'
@@ -98,4 +360,96 @@ describe('encoding/json override', () => {
     expect(mapRef.value?.get('age')).toBe(22)
     expect(mapRef.value?.get('active')).toBe(true)
   })
+
+  it('encodes JSON to an io.Writer with newline, indentation, and HTML escaping', () => {
+    const chunks: string[] = []
+    const writer = {
+      Write(p: $.Bytes): [number, $.GoError] {
+        chunks.push($.bytesToString(p))
+        return [$.len(p), null]
+      },
+    }
+
+    const encoder = NewEncoder(writer)
+    expect(encoder.Encode(new Map([['text', '<tag>&']]))).toBeNull()
+    encoder.SetEscapeHTML(false)
+    encoder.SetIndent('', '  ')
+    expect(encoder.Encode(new Map([['text', '<tag>&']]))).toBeNull()
+
+    expect(chunks).toEqual([
+      '{"text":"\\u003ctag\\u003e\\u0026"}\n',
+      '{\n  "text": "<tag>&"\n}\n',
+    ])
+  })
+
+  it('validates, compacts, indents, and escapes JSON bytes', () => {
+    expect(Valid($.stringToBytes('{"ok":true}'))).toBe(true)
+    expect(Valid($.stringToBytes('{'))).toBe(false)
+
+    const compact = new bytes.Buffer()
+    expect(Compact(compact, $.stringToBytes('{ "ok" : true }'))).toBeNull()
+    expect(compact.String()).toBe('{"ok":true}')
+
+    const indented = new bytes.Buffer()
+    expect(
+      Indent(indented, $.stringToBytes('{"ok":true}'), '> ', '  '),
+    ).toBeNull()
+    expect(indented.String()).toBe('{\n>   "ok": true\n> }')
+
+    const escaped = new bytes.Buffer()
+    HTMLEscape(escaped, $.stringToBytes('"<tag>&"'))
+    expect(escaped.String()).toBe('"\\u003ctag\\u003e\\u0026"')
+  })
+
+  it('decodes from readers and exposes raw message and number helpers', () => {
+    const reader = bytes.NewBufferString('{"name":"Dana","age":28}')!
+    const decoder = NewDecoder(reader)
+    const target = $.varRef(new Person())
+
+    expect(decoder.Decode(target)).toBeNull()
+    expect(target.value._fields.Name.value).toBe('Dana')
+    expect(target.value._fields.Age.value).toBe(28)
+    expect(decoder.InputOffset()).toBeGreaterThan(0)
+
+    const raw = $.stringToBytes('{"raw":true}')
+    const [marshaled, marshalErr] = RawMessage_MarshalJSON(raw)
+    expect(marshalErr).toBeNull()
+    expect($.bytesToString(marshaled)).toBe('{"raw":true}')
+
+    const rawRef = $.varRef<$.Bytes>(null)
+    expect(
+      RawMessage_UnmarshalJSON(rawRef, $.stringToBytes('[1,2]')),
+    ).toBeNull()
+    expect($.bytesToString(rawRef.value)).toBe('[1,2]')
+
+    expect(Number_String('42')).toBe('42')
+    expect(Number_Int64('42')).toEqual([42, null])
+    expect(Number_Float64('3.5')).toEqual([3.5, null])
+    expect(Number.isNaN(Number_Float64('NaN')[0])).toBe(true)
+    expect(Number_Float64('-Inf')).toEqual([-Infinity, null])
+    expect(Number_Float64('1x')[1]?.Error()).toContain('invalid syntax')
+    expect(Number_Float64('1e999')[1]?.Error()).toContain('value out of range')
+    expect(Number_Int64('9223372036854775808')[1]?.Error()).toContain(
+      'value out of range',
+    )
+  })
+
+  it('applies decoder UseNumber and DisallowUnknownFields options', () => {
+    const numberReader = bytes.NewBufferString('{"n":12}')!
+    const numberDecoder = NewDecoder(numberReader)
+    numberDecoder.UseNumber()
+    const numberTarget = $.varRef<Map<string, unknown> | null>(null)
+
+    expect(numberDecoder.Decode(numberTarget)).toBeNull()
+    expect(numberTarget.value?.get('n')).toBe('12')
+
+    const strictReader = bytes.NewBufferString('{"name":"Ada","extra":true}')!
+    const strictDecoder = NewDecoder(strictReader)
+    strictDecoder.DisallowUnknownFields()
+    const strictTarget = $.varRef(new Person())
+
+    expect(strictDecoder.Decode(strictTarget)?.Error()).toBe(
+      'json: unknown field "extra"',
+    )
+  })
 })