goscript 0.1.3 → 0.2.0

package/gs/encoding/json/parity.json

@@ -0,0 +1,81 @@
+{
+  "schemaVersion": 1,
+  "strict": true,
+  "symbols": {
+    "Compact": {
+      "status": "real"
+    },
+    "Decoder": {
+      "status": "real"
+    },
+    "Delim": {
+      "status": "real"
+    },
+    "Encoder": {
+      "status": "real"
+    },
+    "HTMLEscape": {
+      "status": "real"
+    },
+    "Indent": {
+      "status": "real"
+    },
+    "InvalidUnmarshalError": {
+      "status": "real"
+    },
+    "InvalidUTF8Error": {
+      "status": "real"
+    },
+    "Marshal": {
+      "status": "real"
+    },
+    "Marshaler": {
+      "status": "real"
+    },
+    "MarshalerError": {
+      "status": "real"
+    },
+    "MarshalIndent": {
+      "status": "real"
+    },
+    "NewDecoder": {
+      "status": "real"
+    },
+    "NewEncoder": {
+      "status": "real"
+    },
+    "Number": {
+      "status": "real"
+    },
+    "RawMessage": {
+      "status": "real"
+    },
+    "SyntaxError": {
+      "status": "real"
+    },
+    "Token": {
+      "status": "real"
+    },
+    "Unmarshal": {
+      "status": "real"
+    },
+    "Unmarshaler": {
+      "status": "real"
+    },
+    "UnmarshalFieldError": {
+      "status": "real"
+    },
+    "UnmarshalTypeError": {
+      "status": "real"
+    },
+    "UnsupportedTypeError": {
+      "status": "real"
+    },
+    "UnsupportedValueError": {
+      "status": "real"
+    },
+    "Valid": {
+      "status": "real"
+    }
+  }
+}

package/gs/fmt/fmt.test.ts

@@ -58,6 +58,15 @@ describe('fmt basic value formatting', () => {
     expect(fmt.Sprintf('Type: %T', 3.14)).toBe('Type: float64')
     expect(fmt.Sprintf('Type: %T', 'hello')).toBe('Type: string')
     expect(fmt.Sprintf('Type: %T', true)).toBe('Type: bool')
+    expect(
+      fmt.Sprintf(
+        'Type: %T',
+        $.namedValueInterfaceValue(123, 'int', {}, {
+          kind: $.TypeKind.Basic,
+          name: 'int',
+        }),
+      ),
+    ).toBe('Type: int')
   })
 
   it('%d truncation behavior including negatives', () => {
@@ -115,6 +124,20 @@ describe('fmt basic value formatting', () => {
     // We prefer GoString() first
     expect(fmt.Sprintf('%v', goStringer)).toBe('<go stringer>')
   })
+
+  it('%w formats errors by Error method', () => {
+    const err = $.newError('root')
+    expect(fmt.Errorf('wrap: %w', err)?.Error()).toBe('wrap: root')
+  })
+
+  it('%s formats stringers by String method', () => {
+    const stringer = {
+      String() {
+        return 'string-value'
+      },
+    }
+    expect(fmt.Sprintf('value=%s', stringer)).toBe('value=string-value')
+  })
 })
 
 describe('fmt spacing rules', () => {
@@ -146,7 +169,7 @@ describe('fmt spacing rules', () => {
     expect(output).toBe('hi there 1 2\n')
   })
 
-  it('Fprint/Fprintln behave like Print/Println with writers', () => {
+  it('Fprint/Fprintln behave like Print/Println with writers', async () => {
     const chunks: Uint8Array[] = []
     const writer = {
       Write(b: Uint8Array): [number, any] {
@@ -155,14 +178,29 @@ describe('fmt spacing rules', () => {
       },
     }
 
-    let [n, err] = fmt.Fprint(writer, 1, 2, 'x', 3)
+    let [n, err] = await fmt.Fprint(writer, 1, 2, 'x', 3)
     expect(err).toBeNull()
     expect(n).toBe(5) // "1 2x3".length
     expect(new TextDecoder().decode(chunks[0])).toBe('1 2x3')
-    ;[, err] = fmt.Fprintln(writer, 'hi', 'there', 1, 2)
+    ;[, err] = await fmt.Fprintln(writer, 'hi', 'there', 1, 2)
     expect(err).toBeNull()
     expect(new TextDecoder().decode(chunks[1])).toBe('hi there 1 2\n')
   })
+
+  it('Fprintf awaits async writers', async () => {
+    const chunks: Uint8Array[] = []
+    const writer = {
+      async Write(b: Uint8Array): Promise<[number, any]> {
+        chunks.push(b)
+        return [b.length, null]
+      },
+    }
+
+    const [n, err] = await fmt.Fprintf(writer, 'n=%d s=%s', 7, 'ok')
+    expect(err).toBeNull()
+    expect(n).toBe(8)
+    expect(new TextDecoder().decode(chunks[0])).toBe('n=7 s=ok')
+  })
 })
 
 describe('fmt parseFormat basic cases', () => {

package/gs/fmt/fmt.ts

@@ -34,15 +34,20 @@ function formatValue(value: any, verb: string): string {
   switch (verb) {
     case 'v': // default format
       return defaultFormat(value)
+    case 'w': // wrapped error
+      return defaultFormat(value)
     case 'd': // decimal integer
       return String(Math.trunc(Number(value)))
     case 'f': // decimal point, no exponent
       return Number(value).toString()
     case 's': // string
-      return String(value)
+      if (typeof value === 'string') return value
+      if (value instanceof Uint8Array) return $.bytesToString(value)
+      return defaultFormat(value)
     case 't': // boolean
       return value ? 'true' : 'false'
     case 'T': // type (approximate Go names for primitives we need)
+      if (hasGoTypeName(value)) return value.__goType
       if (typeof value === 'number') {
         return Number.isInteger(value) ? 'int' : 'float64'
       }
@@ -85,6 +90,14 @@ function formatValue(value: any, verb: string): string {
   }
 }
 
+function hasGoTypeName(value: unknown): value is { __goType: string } {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    typeof (value as { __goType?: unknown }).__goType === 'string'
+  )
+}
+
 function defaultFormat(value: any): string {
   if (value === null || value === undefined) return '<nil>'
   if (typeof value === 'boolean') return value ? 'true' : 'false'
@@ -120,6 +133,9 @@ function defaultFormat(value: any): string {
         // Ignore error by continuing to next case.
       }
     }
+    if ('__goValue' in value) {
+      return defaultFormat((value as { __goValue: unknown }).__goValue)
+    }
     // Basic Map/Set rendering
     if (value instanceof Map) {
       const parts: string[] = []
@@ -357,8 +373,21 @@ export function Sprintln(...a: any[]): string {
   return a.map(defaultFormat).join(' ') + '\n'
 }
 
+async function writeToWriter(
+  w: any,
+  out: string,
+): Promise<[number, $.GoError | null]> {
+  if (w && w.Write) {
+    return await w.Write(new TextEncoder().encode(out))
+  }
+  return [0, $.newError('Writer does not implement Write method')]
+}
+
 // Fprint functions (write to Writer) - simplified implementation
-export function Fprint(w: any, ...a: any[]): [number, $.GoError | null] {
+export async function Fprint(
+  w: any,
+  ...a: any[]
+): Promise<[number, $.GoError | null]> {
   // Same spacing as Print
   let out = ''
   for (let i = 0; i < a.length; i++) {
@@ -369,32 +398,26 @@ export function Fprint(w: any, ...a: any[]): [number, $.GoError | null] {
     }
     out += defaultFormat(a[i])
   }
-  if (w && w.Write) {
-    return w.Write(new TextEncoder().encode(out))
-  }
-  return [0, $.newError('Writer does not implement Write method')]
+  return await writeToWriter(w, out)
 }
 
-export function Fprintf(
+export async function Fprintf(
   w: any,
   format: string,
   ...a: any[]
-): [number, $.GoError | null] {
+): Promise<[number, $.GoError | null]> {
   const result = parseFormat(format, a)
-  if (w && w.Write) {
-    return w.Write(new TextEncoder().encode(result))
-  }
-  return [0, $.newError('Writer does not implement Write method')]
+  return await writeToWriter(w, result)
 }
 
-export function Fprintln(w: any, ...a: any[]): [number, $.GoError | null] {
+export async function Fprintln(
+  w: any,
+  ...a: any[]
+): Promise<[number, $.GoError | null]> {
   // Same behavior as Println
   const body = a.map(defaultFormat).join(' ')
   const result = body + '\n'
-  if (w && w.Write) {
-    return w.Write(new TextEncoder().encode(result))
-  }
-  return [0, $.newError('Writer does not implement Write method')]
+  return await writeToWriter(w, result)
 }
 
 // Append functions (append to byte slice)

package/gs/fmt/meta.json

@@ -1,5 +1,10 @@
 {
+  "asyncFunctions": {
+    "Fprint": true,
+    "Fprintf": true,
+    "Fprintln": true
+  },
   "dependencies": [
     "errors"
   ]
-} 
+}

package/gs/github.com/aperturerobotics/protobuf-go-lite/index.test.ts

@@ -3,7 +3,17 @@ import { describe, expect, it } from 'vitest'
 import * as $ from '../../../builtin/index.js'
 import {
   AppendVarint,
+  CloneBytes,
+  CloneBytesMap,
+  CloneBytesSlice,
+  CloneMap,
   type CloneMessage,
+  ClonePtr,
+  CloneSlice,
+  type CloneVT,
+  CloneVTMap,
+  CloneVTSlice,
+  CloneVTValue,
   CompareEqualVT,
   ConsumeVarint,
   DecodeFixed32,
@@ -16,8 +26,55 @@ import {
   ErrIntOverflow,
   ErrInvalidLength,
   ErrUnexpectedEndOfGroup,
+  EqualBytes,
+  EqualBytesMap,
+  EqualBytesPresent,
+  EqualBytesSlice,
+  EqualMap,
+  EqualPtr,
+  EqualSlice,
+  EqualVTImplicit,
+  EqualVTMapImplicit,
+  EqualVTSliceImplicit,
+  type EqualVT,
   IsEqualVTSlice,
+  SizeBoolNonZero,
+  SizeBoolPacked,
+  SizeBoolPtr,
+  SizeBoolSlice,
+  SizeBoolValue,
+  SizeBytesNonEmpty,
+  SizeBytesPresent,
+  SizeBytesSlice,
+  SizeBytesValue,
+  SizeFixed32NonZero,
+  SizeFixed32Packed,
+  SizeFixed32Ptr,
+  SizeFixed32Slice,
+  SizeFixed32Value,
+  SizeFixed64NonZero,
+  SizeFixed64Packed,
+  SizeFixed64Ptr,
+  SizeFixed64Slice,
+  SizeFixed64Value,
+  SizeGroup,
+  SizeMessage,
   SizeOfVarint,
+  SizeOfZigzag,
+  SizeStringNonEmpty,
+  SizeStringPtr,
+  SizeStringSlice,
+  SizeStringValue,
+  SizeVarintNonZero,
+  SizeVarintPacked,
+  SizeVarintPtr,
+  SizeVarintSlice,
+  SizeVarintValue,
+  SizeZigzagNonZero,
+  SizeZigzagPacked,
+  SizeZigzagPtr,
+  SizeZigzagSlice,
+  SizeZigzagValue,
   Skip,
 } from './index.js'
 
@@ -29,6 +86,42 @@ class TestValue {
   }
 }
 
+class TestCloneValue
+  implements CloneVT<TestCloneValue>, EqualVT<TestCloneValue>
+{
+  constructor(private readonly cloneValue: string) {}
+
+  SizeVT(): number {
+    return 0
+  }
+
+  MarshalToSizedBufferVT(): [number, $.GoError] {
+    return [0, null]
+  }
+
+  MarshalVT(): [$.Slice<number>, $.GoError] {
+    return [null, null]
+  }
+
+  UnmarshalVT(): $.GoError {
+    return null
+  }
+
+  Reset(): void {}
+
+  CloneMessageVT(): CloneMessage | null {
+    return this.CloneVT()
+  }
+
+  CloneVT(): TestCloneValue {
+    return new TestCloneValue(this.cloneValue)
+  }
+
+  EqualVT(other: TestCloneValue): boolean {
+    return this.cloneValue === other.cloneValue
+  }
+}
+
 class TestCloneMessage implements CloneMessage {
   SizeVT(): number {
     return 0
@@ -78,6 +171,68 @@ describe('protobuf-go-lite EqualVT helpers', () => {
   })
 })
 
+describe('protobuf-go-lite static helper overrides', () => {
+  it('clones pointer, slice, map, bytes, and VT values', () => {
+    const ptr = $.varRef(7)
+    const clonedPtr = ClonePtr(ptr)
+    expect(clonedPtr).not.toBe(ptr)
+    expect(clonedPtr?.value).toBe(7)
+
+    const bytes = new Uint8Array([1, 2])
+    const clonedBytes = CloneBytes(bytes)
+    expect(clonedBytes).not.toBe(bytes)
+    expect(Array.from(clonedBytes ?? [])).toEqual([1, 2])
+
+    expect(CloneSlice([1, 2])).toEqual([1, 2])
+    expect(CloneMap(new Map([['a', 1]]))?.get('a')).toBe(1)
+
+    const bytesSlice = CloneBytesSlice([new Uint8Array([3])])
+    expect(bytesSlice?.[0]).not.toBe(bytes)
+    expect(Array.from(bytesSlice?.[0] ?? [])).toEqual([3])
+
+    const bytesMap = CloneBytesMap(new Map([['a', new Uint8Array([4])]]))
+    expect(Array.from(bytesMap?.get('a') ?? [])).toEqual([4])
+
+    const msg = new TestCloneValue('x')
+    expect(CloneVTValue(msg)).not.toBe(msg)
+    expect(CloneVTSlice([msg])?.[0]).not.toBe(msg)
+    expect(CloneVTMap(new Map([['a', msg]]))?.get('a')).not.toBe(msg)
+  })
+
+  it('compares pointer, slice, map, bytes, and implicit VT values', () => {
+    expect(EqualPtr($.varRef(1), $.varRef(1))).toBe(true)
+    expect(EqualPtr($.varRef(1), $.varRef(2))).toBe(false)
+    expect(EqualBytes(new Uint8Array([1]), [1])).toBe(true)
+    expect(EqualBytesPresent(null, new Uint8Array())).toBe(false)
+    expect(EqualSlice([1, 2], [1, 2])).toBe(true)
+    expect(EqualMap(new Map([['a', 1]]), new Map([['a', 1]]))).toBe(true)
+    expect(EqualBytesSlice([new Uint8Array([1])], [[1]])).toBe(true)
+    expect(
+      EqualBytesMap(
+        new Map([['a', new Uint8Array([1])]]),
+        new Map([['a', [1]]]),
+      ),
+    ).toBe(true)
+
+    const empty = () => new TestCloneValue('')
+    expect(EqualVTImplicit(null, new TestCloneValue(''), empty)).toBe(true)
+    expect(
+      EqualVTSliceImplicit(
+        [null, new TestCloneValue('x')],
+        [new TestCloneValue(''), new TestCloneValue('x')],
+        empty,
+      ),
+    ).toBe(true)
+    expect(
+      EqualVTMapImplicit(
+        new Map([['a', null]]),
+        new Map([['a', new TestCloneValue('')]]),
+        empty,
+      ),
+    ).toBe(true)
+  })
+})
+
 describe('protobuf-go-lite runtime interfaces', () => {
   it('registers CloneMessage metadata for Go type assertions', () => {
     const [value, ok] = $.typeAssertTuple<CloneMessage | null>(
@@ -105,9 +260,13 @@ describe('protobuf-go-lite wire helpers', () => {
     expect(DecodeVarintUint32(buf, offset)).toEqual([300, 4, null])
     expect(Array.from(AppendVarint([], 300) as number[])).toEqual([0xac, 0x02])
     expect(SizeOfVarint(0xffffffffffffffffn)).toBe(10)
-    expect(Array.from(AppendVarint([], 0xffffffffffffffffn) as number[])).toEqual([
-      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01,
-    ])
+    expect(SizeOfZigzag(-1)).toBe(1)
+    expect(SizeOfZigzag(1)).toBe(1)
+    expect(SizeOfZigzag(-64)).toBe(1)
+    expect(SizeOfZigzag(-65)).toBe(2)
+    expect(
+      Array.from(AppendVarint([], 0xffffffffffffffffn) as number[]),
+    ).toEqual([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01])
     expect(ConsumeVarint(AppendVarint([], 0xffffffffffffffffn))).toEqual([
       0xffffffffffffffffn,
       10,
@@ -147,4 +306,53 @@ describe('protobuf-go-lite wire helpers', () => {
     const [, eof] = Skip(new Uint8Array([0x08, 0x80]))
     expect(eof?.Error()).toBe('unexpected EOF')
   })
+
+  it('reports helper-backed protobuf sizes', () => {
+    expect(SizeVarintValue(1, 300)).toBe(3)
+    expect(SizeVarintNonZero(1, 0)).toBe(0)
+    expect(SizeVarintNonZero(1, 300)).toBe(3)
+    expect(SizeVarintPtr(1, null)).toBe(0)
+    expect(SizeVarintPtr(1, $.varRef(300))).toBe(3)
+    expect(SizeVarintSlice(1, [1, 300])).toBe(5)
+    expect(SizeVarintPacked(1, [1, 300])).toBe(5)
+
+    expect(SizeZigzagValue(1, -65)).toBe(3)
+    expect(SizeZigzagNonZero(1, 0)).toBe(0)
+    expect(SizeZigzagPtr(1, $.varRef(-1))).toBe(2)
+    expect(SizeZigzagSlice(1, [-1, -65])).toBe(5)
+    expect(SizeZigzagPacked(1, [-1, -65])).toBe(5)
+
+    expect(SizeFixed32Value(1)).toBe(5)
+    expect(SizeFixed32NonZero(1, 0)).toBe(0)
+    expect(SizeFixed32Ptr(1, $.varRef(1))).toBe(5)
+    expect(SizeFixed32Slice(1, [1, 2])).toBe(10)
+    expect(SizeFixed32Packed(1, [1, 2])).toBe(10)
+
+    expect(SizeFixed64Value(1)).toBe(9)
+    expect(SizeFixed64NonZero(1, 0)).toBe(0)
+    expect(SizeFixed64Ptr(1, $.varRef(1))).toBe(9)
+    expect(SizeFixed64Slice(1, [1, 2])).toBe(18)
+    expect(SizeFixed64Packed(1, [1, 2])).toBe(18)
+
+    expect(SizeBoolValue(1)).toBe(2)
+    expect(SizeBoolNonZero(1, false)).toBe(0)
+    expect(SizeBoolPtr(1, $.varRef(false))).toBe(2)
+    expect(SizeBoolSlice(1, [true, false])).toBe(4)
+    expect(SizeBoolPacked(1, [true, false])).toBe(4)
+
+    expect(SizeStringValue(1, 'abc')).toBe(5)
+    expect(SizeStringNonEmpty(1, '')).toBe(0)
+    expect(SizeStringPtr(1, $.varRef('abc'))).toBe(5)
+    expect(SizeStringSlice(1, ['a', 'bc'])).toBe(7)
+
+    expect(SizeBytesValue(1, 3)).toBe(5)
+    expect(SizeBytesNonEmpty(1, new Uint8Array())).toBe(0)
+    expect(SizeBytesPresent(1, new Uint8Array())).toBe(2)
+    expect(
+      SizeBytesSlice(1, [new Uint8Array([1]), new Uint8Array([2, 3])]),
+    ).toBe(7)
+
+    expect(SizeMessage(1, 3)).toBe(5)
+    expect(SizeGroup(1, 3)).toBe(5)
+  })
 })