goscript 0.1.1 → 0.1.3

package/gs/syscall/fs.ts

@@ -242,16 +242,16 @@ export function SetsockoptInt(
   return null
 }
 
-export function readv(_fd: number, _iovecs: $.Slice<Iovec> | null): [
-  number,
-  $.GoError,
-] {
+export function readv(
+  _fd: number,
+  _iovecs: $.Slice<Iovec> | null,
+): [number, $.GoError] {
   return [0, ENOSYS]
 }
 
-export function writev(_fd: number, _iovecs: $.Slice<Iovec> | null): [
-  number,
-  $.GoError,
-] {
+export function writev(
+  _fd: number,
+  _iovecs: $.Slice<Iovec> | null,
+): [number, $.GoError] {
   return [0, ENOSYS]
 }

package/gs/syscall/js/index.ts

@@ -105,14 +105,21 @@ export class Value {
         `syscall/js: Value.Call: property ${m} is not a function, got ${Type_String(ValueOf(fn).Type())}`,
       )
     }
-    return new Value({ raw: fn.apply(this._raw, args.map((arg) => ValueOf(arg)._raw)) })
+    return new Value({
+      raw: fn.apply(
+        this._raw,
+        args.map((arg) => ValueOf(arg)._raw),
+      ),
+    })
   }
 
   public Invoke(...args: unknown[]): Value {
     if (typeof this._raw !== 'function') {
       $.panic(new ValueError({ Method: 'Value.Invoke', Type: this.Type() }))
     }
-    return new Value({ raw: this._raw(...args.map((arg) => ValueOf(arg)._raw)) })
+    return new Value({
+      raw: this._raw(...args.map((arg) => ValueOf(arg)._raw)),
+    })
   }
 
   public New(...args: unknown[]): Value {
@@ -120,7 +127,10 @@ export class Value {
       $.panic(new ValueError({ Method: 'Value.Invoke', Type: this.Type() }))
     }
     return new Value({
-      raw: Reflect.construct(this._raw, args.map((arg) => ValueOf(arg)._raw)),
+      raw: Reflect.construct(
+        this._raw,
+        args.map((arg) => ValueOf(arg)._raw),
+      ),
     })
   }
 
@@ -224,21 +234,27 @@ export class Func {
   public Value: Value
   private _released = false
 
-  constructor(init?: Partial<Func> & { fn?: (this$: Value, args: $.Slice<Value>) => unknown }) {
+  constructor(
+    init?: Partial<Func> & {
+      fn?: (this$: Value, args: $.Slice<Value>) => unknown
+    },
+  ) {
     const fn = init?.fn
-    this.Value = init?.Value?.clone() ?? new Value({
-      raw: function (this: unknown, ...args: unknown[]) {
-        if (fn === undefined) {
-          return undefined
-        }
-        return ValueOf(
-          fn(
-            new Value({ raw: this }),
-            args.map((arg) => new Value({ raw: arg })) as $.Slice<Value>,
-          ),
-        )._raw
-      },
-    })
+    this.Value =
+      init?.Value?.clone() ??
+      new Value({
+        raw: function (this: unknown, ...args: unknown[]) {
+          if (fn === undefined) {
+            return undefined
+          }
+          return ValueOf(
+            fn(
+              new Value({ raw: this }),
+              args.map((arg) => new Value({ raw: arg })) as $.Slice<Value>,
+            ),
+          )._raw
+        },
+      })
   }
 
   public clone(): Func {
@@ -352,7 +368,11 @@ export function ValueOf(x: unknown): Value {
   if (x === null || x === undefined) {
     return Null()
   }
-  if (typeof x === 'boolean' || typeof x === 'number' || typeof x === 'string') {
+  if (
+    typeof x === 'boolean' ||
+    typeof x === 'number' ||
+    typeof x === 'string'
+  ) {
     return new Value({ raw: x })
   }
   if (typeof x === 'bigint') {
@@ -423,7 +443,8 @@ export function CopyBytesToGo(dst: $.Bytes | null, src: Value): number {
 
 export function CopyBytesToJS(dst: Value, src: $.Bytes | null): number {
   const target = dstRawBytes(dst)
-  const bytes = src instanceof Uint8Array ? src : Uint8Array.from($.asArray(src))
+  const bytes =
+    src instanceof Uint8Array ? src : Uint8Array.from($.asArray(src))
   const n = Math.min(target.length, bytes.length)
   target.set(bytes.subarray(0, n), 0)
   return n
@@ -432,9 +453,13 @@ export function CopyBytesToJS(dst: Value, src: $.Bytes | null): number {
 function sourceBytes(src: Value): Uint8Array {
   const raw = srcRaw(src)
   if (raw instanceof Uint8Array || raw instanceof Uint8ClampedArray) {
-    return raw instanceof Uint8Array ? raw : new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength)
+    return raw instanceof Uint8Array ? raw : (
+        new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength)
+      )
   }
-  $.panic('syscall/js: CopyBytesToGo: expected src to be a Uint8Array or Uint8ClampedArray')
+  $.panic(
+    'syscall/js: CopyBytesToGo: expected src to be a Uint8Array or Uint8ClampedArray',
+  )
 }
 
 function dstRawBytes(dst: Value): Uint8Array | Uint8ClampedArray {
@@ -442,7 +467,9 @@ function dstRawBytes(dst: Value): Uint8Array | Uint8ClampedArray {
   if (raw instanceof Uint8Array || raw instanceof Uint8ClampedArray) {
     return raw
   }
-  $.panic('syscall/js: CopyBytesToJS: expected dst to be a Uint8Array or Uint8ClampedArray')
+  $.panic(
+    'syscall/js: CopyBytesToJS: expected dst to be a Uint8Array or Uint8ClampedArray',
+  )
 }
 
 function srcRaw(value: Value): unknown {

package/gs/syscall/net.test.ts

@@ -1,13 +1,25 @@
 import { describe, expect, test } from 'vitest'
 
+import * as $ from '@goscript/builtin/index.js'
+
 import {
   Bind,
   Close,
   CloseOnExec,
   Connect,
   Dup,
+  EADDRNOTAVAIL,
+  EAGAIN,
+  EINTR,
+  EMFILE,
   ENOSYS,
+  ENFILE,
   ENOTSUP,
+  ETIMEDOUT,
+  Errno_Error,
+  Errno_Is,
+  Errno_Temporary,
+  Errno_Timeout,
   GetsockoptInt,
   Iovec,
   IPPROTO_IPV6,
@@ -36,6 +48,7 @@ import {
   readv,
   writev,
 } from './index.js'
+import type { Errno } from './index.js'
 
 describe('syscall network stubs', () => {
   test('exports network constants used by generated net', () => {
@@ -47,6 +60,19 @@ describe('syscall network stubs', () => {
     expect(ENOTSUP.Error()).toBe('operation not supported')
   })
 
+  test('models Errno numeric zero values and named primitive methods', () => {
+    const errno: $.VarRef<Errno> = $.varRef(0)
+
+    expect(Errno_Error(errno.value)).toBe('errno 0')
+    expect(Errno_Is(EADDRNOTAVAIL, EADDRNOTAVAIL)).toBe(true)
+    expect(Errno_Temporary(EINTR)).toBe(true)
+    expect(Errno_Temporary(EMFILE)).toBe(true)
+    expect(Errno_Temporary(ENFILE)).toBe(true)
+    expect(Errno_Timeout(EAGAIN)).toBe(true)
+    expect(Errno_Timeout(ETIMEDOUT)).toBe(true)
+    expect(Errno_Timeout(EADDRNOTAVAIL)).toBe(false)
+  })
+
   test('reports unsupported socket operations as syscall errors', () => {
     expect(Socket(0, 0, 0)).toEqual([-1, ENOSYS])
     expect(Connect(-1, null)).toBe(ENOSYS)

package/gs/syscall/types.ts

@@ -3,10 +3,15 @@ import * as $ from '@goscript/builtin/index.js'
 // Essential type aliases
 export type uintptr = number
 
-// Errno type for syscall errors
-export interface Errno {
+// Errno is a named numeric Go type. Constants use object values so they can
+// satisfy error interfaces, while generated zero values may still be numbers.
+export type Errno = number | ErrnoObject
+
+export interface ErrnoObject {
   Error(): string
   Is(target: $.GoError): boolean
+  Temporary?(): boolean
+  Timeout?(): boolean
   Errno(): number
 }
 

package/gs/testing/testing.test.ts

@@ -87,4 +87,60 @@ describe('testing.T', () => {
     expect(observed).toBe(true)
     expect(Short()).toBe(false)
   })
+
+  it('accepts parallel tests in the sequential runner', () => {
+    const t = new T('root')
+
+    t.Parallel()
+
+    expect(t.Failed()).toBe(false)
+  })
+
+  it('accepts nil cleanup values and fails when cleanup runs', async () => {
+    const t = new T('root')
+
+    t.Cleanup(null)
+
+    await expect(t.runCleanups()).rejects.toThrow('testing: nil cleanup function')
+  })
+
+  it('returns a non-nil context', () => {
+    const t = new T('root')
+
+    expect(t.Context()).not.toBeNull()
+  })
+
+  it('formats common testing printf verbs', () => {
+    const t = new T('root')
+    const messages: string[] = []
+    const originalLog = console.log
+    console.log = (message?: unknown) => {
+      messages.push(String(message))
+    }
+    try {
+      t.Logf('quoted=%q value=%#v plus=%+v number=%d string=%s plain=%v', 'key', 7, { ok: true }, 3, 'ok', true)
+      t.flushLogs()
+    } finally {
+      console.log = originalLog
+    }
+
+    expect(messages).toEqual(['    quoted="key" value=7 plus=[object Object] number=3 string=ok plain=true'])
+  })
+
+  it('formats Go-style error objects with Error methods', () => {
+    const t = new T('root')
+    const messages: string[] = []
+    const originalLog = console.log
+    console.log = (message?: unknown) => {
+      messages.push(String(message))
+    }
+    try {
+      t.Logf('err=%v', { Error: () => 'host path missing' })
+      t.flushLogs()
+    } finally {
+      console.log = originalLog
+    }
+
+    expect(messages).toEqual(['    err=host path missing'])
+  })
 })

package/gs/testing/testing.ts

@@ -2,6 +2,8 @@ import { mkdirSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 
+import * as context from '@goscript/context/index.js'
+
 export type TestFunc = (t: T) => void | Promise<void>
 export type TB = T | B | F
 
@@ -111,8 +113,13 @@ export class T {
 
   public Helper(): void {}
 
-  public Cleanup(fn: () => void | Promise<void>): void {
-    this.cleanups.push(fn)
+  public Cleanup(fn: (() => void | Promise<void>) | null): void {
+    this.cleanups.push(() => {
+      if (fn == null) {
+        throw new Error('testing: nil cleanup function')
+      }
+      return fn()
+    })
   }
 
   public async Run(name: string, fn: TestFunc): Promise<boolean> {
@@ -158,11 +165,7 @@ export class T {
     return path
   }
 
-  public Parallel(): never {
-    throw new TestControl(
-      'fatal',
-      'testing.T.Parallel is not supported by GoScript test',
-    )
+  public Parallel(): void {
   }
 
   public Setenv(key: string, value: string): void {
@@ -204,8 +207,8 @@ export class T {
 
   public Attr(_key: string, _value: string): void {}
 
-  public Context(): null {
-    return null
+  public Context(): context.Context {
+    return context.Background()
   }
 
   public Output(): null {
@@ -368,13 +371,27 @@ export async function runTests(
 
 function formatMessage(format: string, args: unknown[]): string {
   let index = 0
-  return format.replace(/%[vds]/g, () => formatValue(args[index++]))
+  return format.replace(/%#v|%\+v|%q|%[vds]/g, (verb) => {
+    const value = args[index++]
+    if (verb === '%q') {
+      return JSON.stringify(String(value))
+    }
+    return formatValue(value)
+  })
 }
 
 function formatValue(value: unknown): string {
   if (value instanceof Error) {
     return value.message
   }
+  if (
+    value !== null &&
+    typeof value === 'object' &&
+    'Error' in value &&
+    typeof value.Error === 'function'
+  ) {
+    return String(value.Error())
+  }
   if (value === null) {
     return '<nil>'
   }

package/gs/time/meta.json

@@ -1,6 +1,6 @@
 {
   "dependencies": [],
-  "asyncMethods": {
+  "asyncFunctions": {
     "Sleep": true
   }
-} 
+}

package/gs/time/time.test.ts

@@ -35,6 +35,10 @@ describe('time.Duration_String', () => {
     expect(Duration_String(1500 * Millisecond)).toBe('1.5s')
     expect(Duration_String(-1500 * Millisecond)).toBe('-1.5s')
     expect(Duration_String(2 * Second)).toBe('2s')
+    expect(Duration_String(9 * Millisecond)).toBe('9ms')
+    expect(Duration_String(1500 * Microsecond)).toBe('1.5ms')
+    expect(Duration_String(1500)).toBe('1.5\u00b5s')
+    expect(Duration_String(12)).toBe('12ns')
   })
 })
 

package/gs/time/time.ts

@@ -703,7 +703,10 @@ export function Duration_Nanoseconds(receiver: Duration): number {
   return durationNumber(receiver)
 }
 
-export function Duration_Round(receiver: Duration, multiple: Duration): Duration {
+export function Duration_Round(
+  receiver: Duration,
+  multiple: Duration,
+): Duration {
   const value = durationNumber(receiver)
   const unit = durationNumber(multiple)
   if (unit <= 0) {
@@ -740,6 +743,9 @@ export function Duration_String(receiver: Duration): string {
   }
   const sign = value < 0 ? '-' : ''
   let remaining = Math.abs(value)
+  if (remaining < Second) {
+    return sign + formatSubsecond(remaining)
+  }
   const hours = Math.floor(remaining / Hour)
   remaining -= hours * Hour
   const minutes = Math.floor(remaining / Minute)
@@ -767,7 +773,11 @@ export function Duration_format(
   const text = Duration_String(receiver)
   const bytes = Array.from(new TextEncoder().encode(text))
   const start = Math.max(0, buf.value.length - bytes.length)
-  for (let idx = 0; idx < bytes.length && start + idx < buf.value.length; idx++) {
+  for (
+    let idx = 0;
+    idx < bytes.length && start + idx < buf.value.length;
+    idx++
+  ) {
     buf.value[start + idx] = bytes[idx]!
   }
   return start
@@ -781,6 +791,27 @@ function formatSeconds(seconds: number, nanos: number): string {
   return `${seconds}.${fraction}s`
 }
 
+function formatSubsecond(nanos: number): string {
+  if (nanos >= Millisecond) {
+    return formatUnit(nanos, Millisecond, 'ms')
+  }
+  if (nanos >= Microsecond) {
+    return formatUnit(nanos, Microsecond, '\u00b5s')
+  }
+  return `${nanos}ns`
+}
+
+function formatUnit(nanos: number, unit: number, suffix: string): string {
+  const whole = Math.floor(nanos / unit)
+  const rem = nanos % unit
+  if (rem === 0) {
+    return `${whole}${suffix}`
+  }
+  const scale = Math.log10(unit)
+  const fraction = String(rem).padStart(scale, '0').replace(/0+$/, '')
+  return `${whole}.${fraction}${suffix}`
+}
+
 // Location represents a time zone
 export class Location {
   private _name: string

package/gs/unicode/unicode.test.ts

@@ -2,13 +2,24 @@ import { describe, expect, it } from 'vitest'
 
 import * as $ from '@goscript/builtin/index.js'
 
-import { CategoryAliases, Cn, Is, Range16, Range32, RangeTable } from './unicode.js'
+import {
+  CategoryAliases,
+  Cn,
+  Is,
+  Range16,
+  Range32,
+  RangeTable,
+} from './unicode.js'
 
 describe('unicode overrides', () => {
   it('accepts generated struct-literal constructor shapes', () => {
     const table = new RangeTable({
-      R16: $.arrayToSlice<Range16>([new Range16({ Lo: 0x41, Hi: 0x5a, Stride: 1 })]),
-      R32: $.arrayToSlice<Range32>([new Range32({ Lo: 0x10000, Hi: 0x10002, Stride: 1 })]),
+      R16: $.arrayToSlice<Range16>([
+        new Range16({ Lo: 0x41, Hi: 0x5a, Stride: 1 }),
+      ]),
+      R32: $.arrayToSlice<Range32>([
+        new Range32({ Lo: 0x10000, Hi: 0x10002, Stride: 1 }),
+      ]),
       LatinOffset: 1,
     })
 

package/gs/unicode/unicode.ts

@@ -92,11 +92,7 @@ export class RangeTable {
   public LatinOffset: number
 
   constructor(init?: RangeTableInit)
-  constructor(
-    r16?: Slice<Range16>,
-    r32?: Slice<Range32>,
-    latinOffset?: number,
-  )
+  constructor(r16?: Slice<Range16>, r32?: Slice<Range32>, latinOffset?: number)
   constructor(
     r16OrInit: Slice<Range16> | RangeTableInit = [],
     r32: Slice<Range32> = [],

package/gs/unique/index.ts

@@ -73,11 +73,18 @@ function normalize(
   if (value instanceof Map) {
     return {
       $map: [...value.entries()]
-        .map(([key, entry]) => [normalize(key, seen, nextID), normalize(entry, seen, nextID)])
+        .map(([key, entry]) => [
+          normalize(key, seen, nextID),
+          normalize(entry, seen, nextID),
+        ])
         .sort(([a], [b]) => JSON.stringify(a).localeCompare(JSON.stringify(b))),
     }
   }
-  if ('_fields' in value && value._fields && typeof value._fields === 'object') {
+  if (
+    '_fields' in value &&
+    value._fields &&
+    typeof value._fields === 'object'
+  ) {
     return {
       $type: value.constructor.name,
       $fields: normalize(value._fields, seen, nextID),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "goscript",
   "description": "Go to TypeScript transpiler",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "author": {
     "name": "Aperture Robotics LLC.",
     "email": "support@aperture.us",
@@ -104,9 +104,9 @@
     "eslint": "^10.2.0",
     "eslint-config-prettier": "^10.0.2",
     "husky": "^9.1.7",
-    "lint-staged": "^16.4.0",
+    "lint-staged": "^17.0.0",
     "prettier": "^3.8.1",
-    "starpc": "0.49.9",
+    "starpc": "0.49.15",
     "typescript": "^6.0.0",
     "typescript-eslint": "^8.58.0",
     "vitest": "^4.1.2"