goscript 0.1.0 → 0.1.2

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

@@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest'
 
 import * as $ from '@goscript/builtin/index.js'
 
-import { Marshal, Unmarshal } from './index.js'
+import { Marshal, MarshalIndent, Unmarshal, type Unmarshaler } from './index.js'
 
 class Person {
   public _fields = {
@@ -17,14 +17,36 @@ class Person {
     [],
     Person,
     {
-      Name: { type: { kind: $.TypeKind.Basic, name: 'string' }, tag: 'json:"name"' },
+      Name: {
+        type: { kind: $.TypeKind.Basic, name: 'string' },
+        tag: 'json:"name"',
+      },
       Age: { type: { kind: $.TypeKind.Basic, name: 'int' }, tag: 'json:"age"' },
-      Active: { type: { kind: $.TypeKind.Basic, name: 'bool' }, tag: 'json:"active"' },
+      Active: {
+        type: { kind: $.TypeKind.Basic, name: 'bool' },
+        tag: 'json:"active"',
+      },
     },
   )
 }
 
 describe('encoding/json override', () => {
+  it('registers the Unmarshaler interface shape', () => {
+    class CustomUnmarshaler implements Unmarshaler {
+      UnmarshalJSON(_data: $.Slice<number>): $.GoError {
+        return null
+      }
+    }
+
+    const [value, ok] = $.typeAssertTuple<Unmarshaler>(
+      new CustomUnmarshaler(),
+      'json.Unmarshaler',
+    )
+
+    expect(ok).toBe(true)
+    expect(value.UnmarshalJSON($.stringToBytes('{}'))).toBeNull()
+  })
+
   it('marshals struct fields through json tags', () => {
     const person = new Person()
     person._fields.Name.value = 'Alice'
@@ -39,6 +61,20 @@ describe('encoding/json override', () => {
     )
   })
 
+  it('marshals indented JSON with a line prefix', () => {
+    const person = new Person()
+    person._fields.Name.value = 'Alice'
+    person._fields.Age.value = 30
+    person._fields.Active.value = true
+
+    const [data, err] = MarshalIndent(person, '> ', '  ')
+
+    expect(err).toBeNull()
+    expect($.bytesToString(data)).toBe(
+      '{\n>   "name": "Alice",\n>   "age": 30,\n>   "active": true\n> }',
+    )
+  })
+
   it('unmarshals into struct and map pointers', () => {
     const person = $.varRef(new Person())
     const personErr = Unmarshal(

package/gs/encoding/json/index.ts

@@ -1,5 +1,25 @@
 import * as $ from '@goscript/builtin/index.js'
 
+export interface Unmarshaler {
+  UnmarshalJSON(data: $.Slice<number>): $.GoError
+}
+
+$.registerInterfaceType('json.Unmarshaler', null, [
+  {
+    name: 'UnmarshalJSON',
+    args: [
+      {
+        name: 'data',
+        type: {
+          kind: $.TypeKind.Slice,
+          elemType: { kind: $.TypeKind.Basic, name: 'uint8' },
+        },
+      },
+    ],
+    returns: [{ type: 'GoError' }],
+  },
+])
+
 export function Marshal(v: unknown): [$.Slice<number>, $.GoError] {
   try {
     return [$.stringToBytes(JSON.stringify(marshalValue(v))), null]
@@ -8,6 +28,30 @@ export function Marshal(v: unknown): [$.Slice<number>, $.GoError] {
   }
 }
 
+export function MarshalIndent(
+  v: unknown,
+  prefix: string,
+  indent: string,
+): [$.Slice<number>, $.GoError] {
+  try {
+    const text = JSON.stringify(marshalValue(v), null, indent)
+    if (prefix === '') {
+      return [$.stringToBytes(text), null]
+    }
+    return [
+      $.stringToBytes(
+        text
+          .split('\n')
+          .map((line, idx) => (idx === 0 ? line : prefix + line))
+          .join('\n'),
+      ),
+      null,
+    ]
+  } catch (err) {
+    return [null, goError(err)]
+  }
+}
+
 export function Unmarshal(data: $.Slice<number>, v: unknown): $.GoError {
   try {
     assignDecodedValue(v, JSON.parse($.bytesToString(data)))
@@ -123,9 +167,7 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
   )
 }
 
-function structFieldMetadata(
-  value: unknown,
-): Record<string, { tag?: string }> {
+function structFieldMetadata(value: unknown): Record<string, { tag?: string }> {
   if (value === null || typeof value !== 'object') {
     return {}
   }

package/gs/errors/errors.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import { AsType, Errorf, Is, Join, Wrap, Wrapf } from './errors.js'
+
+class DNSError {
+  public readonly IsNotFound = true
+
+  public Error(): string {
+    return 'dns'
+  }
+}
+
+class Wrapper {
+  constructor(private readonly err: $.GoError) {}
+
+  public Error(): string {
+    return 'wrapped'
+  }
+
+  public Unwrap(): $.GoError {
+    return this.err
+  }
+}
+
+const dnsTypeArgs: $.GenericTypeArgs = {
+  E: {
+    type: { kind: $.TypeKind.Pointer, elemType: 'net.DNSError' },
+    zero: () => null,
+  },
+}
+
+describe('errors.AsType', () => {
+  it('returns a directly matching error', () => {
+    const dns = $.interfaceValue<$.GoError>(new DNSError(), '*net.DNSError')
+
+    const [matched, ok] = AsType(dnsTypeArgs, dns)
+
+    expect(ok).toBe(true)
+    expect(matched).toBe(dns)
+  })
+
+  it('walks wrapped errors depth first', () => {
+    const dns = $.interfaceValue<$.GoError>(new DNSError(), '*net.DNSError')
+    const wrapped = $.interfaceValue<$.GoError>(
+      new Wrapper(dns),
+      '*main.Wrapper',
+    )
+
+    const [matched, ok] = AsType(dnsTypeArgs, Join(null, wrapped))
+
+    expect(ok).toBe(true)
+    expect(matched).toBe(dns)
+  })
+
+  it('returns zero when no error matches', () => {
+    const [matched, ok] = AsType(dnsTypeArgs, $.newError('plain'))
+
+    expect(ok).toBe(false)
+    expect(matched).toBe(null)
+  })
+})
+
+describe('errors github.com/pkg/errors compatibility helpers', () => {
+  it('formats new errors', () => {
+    expect(Errorf('bad %s: %d', 'value', 42)?.Error()).toBe('bad value: 42')
+  })
+
+  it('wraps and unwraps errors', () => {
+    const base = $.newError('root')
+    const wrapped = Wrap(base, 'context')
+
+    expect(wrapped?.Error()).toBe('context: root')
+    expect(Is(wrapped, base)).toBe(true)
+  })
+
+  it('wraps formatted context and preserves nil', () => {
+    const base = $.newError('root')
+
+    expect(Wrapf(base, 'context %d', 7)?.Error()).toBe('context 7: root')
+    expect(Wrap(null, 'context')).toBe(null)
+    expect(Wrapf(null, 'context %d', 7)).toBe(null)
+  })
+})

package/gs/errors/errors.ts

@@ -6,6 +6,57 @@ export function New(text: string): $.GoError {
   return $.newError(text)
 }
 
+export function Errorf(format: string, ...args: any[]): $.GoError {
+  return New(formatText(format, args))
+}
+
+export function Wrap(err: $.GoError, message: string): $.GoError {
+  if (err === null) {
+    return null
+  }
+  return wrapError(err, message)
+}
+
+export function Wrapf(
+  err: $.GoError,
+  format: string,
+  ...args: any[]
+): $.GoError {
+  if (err === null) {
+    return null
+  }
+  return wrapError(err, formatText(format, args))
+}
+
+function wrapError(err: Exclude<$.GoError, null>, message: string): $.GoError {
+  const wrapped = $.newError(`${message}: ${err.Error()}`)
+  ;(wrapped as any).Unwrap = function (): $.GoError {
+    return err
+  }
+  return wrapped
+}
+
+function formatText(format: string, args: any[]): string {
+  let argIndex = 0
+  return format.replace(/%[sdqv%]/g, (match) => {
+    if (match === '%%') {
+      return '%'
+    }
+    if (argIndex >= args.length) {
+      return match
+    }
+    const arg = args[argIndex++]
+    switch (match) {
+      case '%d':
+        return String(Number(arg))
+      case '%q':
+        return JSON.stringify(String(arg))
+      default:
+        return String(arg)
+    }
+  })
+}
+
 // ErrUnsupported indicates that a requested operation cannot be performed,
 // because it is unsupported. For example, a call to os.Link when using a
 // file system that does not support hard links.
@@ -140,10 +191,7 @@ export function As(err: $.GoError, target: any): boolean {
     throw new Error('errors: target cannot be nil')
   }
 
-  // Check if err matches target type
-  if (err.constructor === target.constructor) {
-    // Copy properties from err to target
-    Object.assign(target, err)
+  if (assignAsTarget(err, target)) {
     return true
   }
 
@@ -179,6 +227,86 @@ export function As(err: $.GoError, target: any): boolean {
   return false
 }
 
+function assignAsTarget(err: Exclude<$.GoError, null>, target: any): boolean {
+  const targetType = asTargetType(target)
+  if (targetType !== undefined) {
+    const [matched, ok] = $.typeAssertTuple<any>(err, targetType)
+    if (!ok) {
+      return false
+    }
+    if ($.isVarRef(target)) {
+      target.value = matched
+      return true
+    }
+    Object.assign(target, matched)
+    return true
+  }
+
+  if (err.constructor === target.constructor) {
+    Object.assign(target, err)
+    return true
+  }
+  return false
+}
+
+function asTargetType(target: any): string | undefined {
+  const goType = target?.__goType
+  if (typeof goType !== 'string' || !goType.startsWith('*')) {
+    return undefined
+  }
+  return goType.slice(1)
+}
+
+// AsType finds the first error in err's tree that matches the generic error
+// type E, returning the matching error and true. Otherwise it returns E's zero
+// value and false.
+export function AsType(
+  typeArgs: $.GenericTypeArgs | undefined,
+  err: $.GoError,
+): [any, boolean] {
+  const descriptor = typeArgs?.E
+  const zero = (): any => descriptor?.zero?.() ?? null
+  if (err === null || descriptor?.type === undefined) {
+    return [zero(), false]
+  }
+  return asType(err, descriptor.type, zero)
+}
+
+function asType(
+  err: $.GoError,
+  typeInfo: $.TypeInfo | string,
+  zero: () => any,
+): [any, boolean] {
+  if (err === null) {
+    return [zero(), false]
+  }
+
+  const [asserted, ok] = $.typeAssertTuple<any>(err, typeInfo)
+  if (ok) {
+    return [asserted, true]
+  }
+
+  if (typeof (err as any).Unwrap === 'function') {
+    const result = (err as any).Unwrap()
+    if (Array.isArray(result)) {
+      for (const wrappedErr of result) {
+        if (wrappedErr && typeof wrappedErr.Error === 'function') {
+          const [matched, matchedOK] = asType(wrappedErr, typeInfo, zero)
+          if (matchedOK) {
+            return [matched, true]
+          }
+        }
+      }
+      return [zero(), false]
+    }
+    if (result && typeof result.Error === 'function') {
+      return asType(result, typeInfo, zero)
+    }
+  }
+
+  return [zero(), false]
+}
+
 // Join returns an error that wraps the given errors.
 // Any nil error values are discarded.
 // Join returns nil if every value in errs is nil.

package/gs/fmt/fmt.test.ts

@@ -36,7 +36,9 @@ function captureStdout(run: () => void): string {
           length?: number,
           _position?: number | null,
         ) => {
-          buf += new TextDecoder().decode(chunk.subarray(0, length ?? chunk.length))
+          buf += new TextDecoder().decode(
+            chunk.subarray(0, length ?? chunk.length),
+          )
           return length ?? chunk.length
         },
       ),

package/gs/fmt/fmt.ts

@@ -22,7 +22,7 @@ export interface State {
   Flag(c: number): boolean
   Precision(): [number, boolean]
   Width(): [number, boolean]
-  Write(b: Uint8Array): [number, $.GoError | null]
+  Write(b: $.Bytes): [number, $.GoError | null]
 }
 
 // Simple printf-style formatting implementation
@@ -199,7 +199,11 @@ function parseFormat(format: string, args: any[]): string {
           const verb = format[j]
 
           if (argIndex < args.length) {
-            let formatted = formatValue(args[argIndex], verb)
+            const arg = args[argIndex]
+            let formatted = formatWithState(arg, verb, flags, width, precision)
+            if (formatted === null) {
+              formatted = formatValue(arg, verb)
+            }
 
             // Apply width and precision formatting
             if (width && !precision) {
@@ -217,7 +221,7 @@ function parseFormat(format: string, args: any[]): string {
               (verb === 'f' || verb === 'e' || verb === 'g')
             ) {
               const p = parseInt(precision)
-              const num = Number(args[argIndex])
+              const num = Number(arg)
               if (verb === 'f') {
                 formatted = num.toFixed(p)
               } else if (verb === 'e') {
@@ -257,6 +261,39 @@ function parseFormat(format: string, args: any[]): string {
   return result
 }
 
+function formatWithState(
+  value: any,
+  verb: string,
+  flags: string,
+  width: string,
+  precision: string,
+): string | null {
+  if (!value || typeof value.Format !== 'function') {
+    return null
+  }
+
+  let out = ''
+  const state: State = {
+    Flag(c: number): boolean {
+      return flags.includes(String.fromCharCode(c))
+    },
+    Precision(): [number, boolean] {
+      return precision === '' ? [0, false] : [parseInt(precision), true]
+    },
+    Width(): [number, boolean] {
+      return width === '' ? [0, false] : [parseInt(width), true]
+    },
+    Write(b: $.Bytes): [number, $.GoError | null] {
+      const text = $.bytesToString(b)
+      out += text
+      return [text.length, null]
+    },
+  }
+
+  value.Format(state, verb.codePointAt(0) ?? 0)
+  return out
+}
+
 // Global stdout simulation for Print functions
 let stdout = {
   write: (data: string) => {
@@ -361,34 +398,33 @@ export function Fprintln(w: any, ...a: any[]): [number, $.GoError | null] {
 }
 
 // Append functions (append to byte slice)
-export function Append(b: Uint8Array, ...a: any[]): Uint8Array {
+export function Append(b: $.Bytes, ...a: any[]): $.Bytes {
   const result = a.map(defaultFormat).join(' ')
   const encoded = new TextEncoder().encode(result)
-  const newArray = new Uint8Array(b.length + encoded.length)
-  newArray.set(b)
-  newArray.set(encoded, b.length)
+  const base = $.bytesToUint8Array(b)
+  const newArray = new Uint8Array(base.length + encoded.length)
+  newArray.set(base)
+  newArray.set(encoded, base.length)
   return newArray
 }
 
-export function Appendf(
-  b: Uint8Array,
-  format: string,
-  ...a: any[]
-): Uint8Array {
+export function Appendf(b: $.Bytes, format: string, ...a: any[]): $.Bytes {
   const result = parseFormat(format, a)
   const encoded = new TextEncoder().encode(result)
-  const newArray = new Uint8Array(b.length + encoded.length)
-  newArray.set(b)
-  newArray.set(encoded, b.length)
+  const base = $.bytesToUint8Array(b)
+  const newArray = new Uint8Array(base.length + encoded.length)
+  newArray.set(base)
+  newArray.set(encoded, base.length)
   return newArray
 }
 
-export function Appendln(b: Uint8Array, ...a: any[]): Uint8Array {
+export function Appendln(b: $.Bytes, ...a: any[]): $.Bytes {
   const result = a.map(defaultFormat).join(' ') + '\n'
   const encoded = new TextEncoder().encode(result)
-  const newArray = new Uint8Array(b.length + encoded.length)
-  newArray.set(b)
-  newArray.set(encoded, b.length)
+  const base = $.bytesToUint8Array(b)
+  const newArray = new Uint8Array(base.length + encoded.length)
+  newArray.set(base)
+  newArray.set(encoded, base.length)
   return newArray
 }
 

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

@@ -1,6 +1,25 @@
 import { describe, expect, it } from 'vitest'
 
-import { CompareEqualVT } from './index.js'
+import * as $ from '../../../builtin/index.js'
+import {
+  AppendVarint,
+  type CloneMessage,
+  CompareEqualVT,
+  ConsumeVarint,
+  DecodeFixed32,
+  DecodeFixed64,
+  DecodeVarint,
+  DecodeVarintInt32,
+  DecodeVarintInt64,
+  DecodeVarintUint32,
+  EncodeVarint,
+  ErrIntOverflow,
+  ErrInvalidLength,
+  ErrUnexpectedEndOfGroup,
+  IsEqualVTSlice,
+  SizeOfVarint,
+  Skip,
+} from './index.js'
 
 class TestValue {
   constructor(private readonly value: string) {}
@@ -10,6 +29,30 @@ class TestValue {
   }
 }
 
+class TestCloneMessage implements CloneMessage {
+  SizeVT(): number {
+    return 0
+  }
+
+  MarshalToSizedBufferVT(): [$.Slice<number>, $.GoError] {
+    return [null, null]
+  }
+
+  MarshalVT(): [$.Slice<number>, $.GoError] {
+    return [null, null]
+  }
+
+  UnmarshalVT(): $.GoError {
+    return null
+  }
+
+  Reset(): void {}
+
+  CloneMessageVT(): CloneMessage | null {
+    return new TestCloneMessage()
+  }
+}
+
 describe('protobuf-go-lite EqualVT helpers', () => {
   it('accepts compiler-emitted runtime type arguments', () => {
     const equal = CompareEqualVT<TestValue>({
@@ -20,4 +63,88 @@ describe('protobuf-go-lite EqualVT helpers', () => {
     expect(equal(new TestValue('a'), new TestValue('b'))).toBe(false)
     expect(equal(null, null)).toBe(true)
   })
+
+  it('accepts nullable generated message slices', () => {
+    const left: $.Slice<TestValue | $.VarRef<TestValue> | null> = [
+      $.varRef(new TestValue('x')),
+      null,
+    ]
+    const right: $.Slice<TestValue | $.VarRef<TestValue> | null> = [
+      new TestValue('x'),
+      null,
+    ]
+
+    expect(IsEqualVTSlice(left, right)).toBe(true)
+  })
+})
+
+describe('protobuf-go-lite runtime interfaces', () => {
+  it('registers CloneMessage metadata for Go type assertions', () => {
+    const [value, ok] = $.typeAssertTuple<CloneMessage | null>(
+      new TestCloneMessage(),
+      'protobuf_go_lite.CloneMessage',
+    )
+
+    expect(ok).toBe(true)
+    expect(value?.CloneMessageVT()).toBeInstanceOf(TestCloneMessage)
+  })
+})
+
+describe('protobuf-go-lite wire helpers', () => {
+  it('encodes and decodes varints', () => {
+    const buf = new Uint8Array(4)
+
+    const offset = EncodeVarint(buf, 4, 300)
+
+    expect(offset).toBe(2)
+    expect(Array.from(buf.slice(offset))).toEqual([0xac, 0x02])
+    expect(SizeOfVarint(300)).toBe(2)
+    expect(DecodeVarint(buf, offset)).toEqual([300, 4, null])
+    expect(DecodeVarintInt32(buf, offset)).toEqual([300, 4, null])
+    expect(DecodeVarintInt64(buf, offset)).toEqual([300, 4, null])
+    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(ConsumeVarint(AppendVarint([], 0xffffffffffffffffn))).toEqual([
+      0xffffffffffffffffn,
+      10,
+    ])
+  })
+
+  it('decodes fixed64 values', () => {
+    expect(DecodeFixed32(new Uint8Array([0x44, 0x33, 0x22, 0x11]), 0)).toEqual([
+      0x11223344,
+      4,
+      null,
+    ])
+
+    expect(
+      DecodeFixed64(
+        new Uint8Array([0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11]),
+        0,
+      ),
+    ).toEqual([0x1122334455667800, 8, null])
+
+    const [, , err] = DecodeFixed64(new Uint8Array([1, 2, 3]), 0)
+    expect(err?.Error()).toBe('unexpected EOF')
+  })
+
+  it('skips protobuf records', () => {
+    expect(Skip(new Uint8Array([0x08, 0x96, 0x01]))).toEqual([3, null])
+    expect(Skip(new Uint8Array([0x12, 0x03, 0x61, 0x62, 0x63]))).toEqual([
+      5,
+      null,
+    ])
+    expect(Skip(new Uint8Array([0x0c]))).toEqual([0, ErrUnexpectedEndOfGroup])
+  })
+
+  it('reports protobuf wire errors as Go errors', () => {
+    expect(ErrInvalidLength?.Error()).toContain('negative length')
+    expect(ErrIntOverflow?.Error()).toContain('integer overflow')
+    const [, eof] = Skip(new Uint8Array([0x08, 0x80]))
+    expect(eof?.Error()).toBe('unexpected EOF')
+  })
 })