goscript 0.0.84 → 0.1.1

package/gs/builtin/type.ts

@@ -44,6 +44,7 @@ export interface MethodSignature {
  */
 export interface StructFieldInfo {
   type: TypeInfo | string // The field's type
+  name?: string // The Go field name when it differs from the TypeScript key.
   tag?: string // The struct field tag (e.g., `json:"name,omitempty"`)
 }
 
@@ -233,6 +234,13 @@ export const registerStructType = (
   return typeInfo
 }
 
+function resolveZeroValue<T>(zeroValue: any): T {
+  if (typeof zeroValue === 'function') {
+    return zeroValue() as T
+  }
+  return zeroValue as T
+}
+
 /**
  * Registers an interface type with the runtime type system.
  *
@@ -500,10 +508,9 @@ function matchesStructType(value: any, info: TypeInfo): boolean {
 
     if (fieldsExist && sameFieldCount && allFieldsInStruct) {
       return Object.entries(info.fields).every(([fieldName, fieldType]) => {
-        return matchesType(
-          value[fieldName],
-          normalizeTypeInfo(fieldType as TypeInfo | string),
-        )
+        const fieldTypeInfo =
+          isStructFieldInfo(fieldType) ? fieldType.type : fieldType
+        return matchesType(value[fieldName], normalizeTypeInfo(fieldTypeInfo))
       })
     }
 
@@ -664,9 +671,15 @@ function matchesMapType(value: any, info: TypeInfo): boolean {
  */
 function matchesArrayOrSliceType(value: any, info: TypeInfo): boolean {
   // For slices and arrays, check if the value is an array and sample element types
-  if (!Array.isArray(value)) return false
   if (!isArrayTypeInfo(info) && !isSliceTypeInfo(info)) return false
 
+  if (value instanceof Uint8Array) {
+    if (isArrayTypeInfo(info) && value.length !== info.length) return false
+    return isNumberElementType(info.elemType)
+  }
+
+  if (!Array.isArray(value)) return false
+
   if (info.elemType) {
     const arr = value as any[]
     if (arr.length === 0) return true // Empty array matches any array type
@@ -687,6 +700,21 @@ function matchesArrayOrSliceType(value: any, info: TypeInfo): boolean {
   return true
 }
 
+function isNumberElementType(typeInfo: string | TypeInfo | undefined): boolean {
+  if (typeInfo === undefined) return true
+  const info = normalizeTypeInfo(typeInfo)
+  return (
+    info.kind === TypeKind.Basic &&
+    (info.name === undefined ||
+      info.name === 'number' ||
+      info.name === 'int' ||
+      info.name === 'uint' ||
+      info.name === 'uint8' ||
+      info.name === 'byte' ||
+      info.name === 'float64')
+  )
+}
+
 // Symbol used to mark struct instances that represent values (not pointers)
 const STRUCT_VALUE_MARKER = Symbol('structValue')
 
@@ -698,6 +726,20 @@ export function markAsStructValue<T>(value: T): T {
   return value
 }
 
+export function cloneStructValue<T>(value: T): T {
+  const cloneable = value as T & {
+    __goscriptClone?: () => T
+    clone?: () => T
+  }
+  if (typeof cloneable.__goscriptClone === 'function') {
+    return cloneable.__goscriptClone()
+  }
+  if (typeof cloneable.clone === 'function') {
+    return cloneable.clone()
+  }
+  throw new Error('runtime error: value is not cloneable')
+}
+
 // Check if a struct instance is marked as a value
 function isMarkedAsStructValue(value: any): boolean {
   return (
@@ -726,6 +768,10 @@ function matchesPointerType(value: any, info: TypeInfo): boolean {
 
   if (!isPointerTypeInfo(info)) return false
 
+  if (typeof value.__goType === 'string') {
+    return compareTypeStringWithTypeInfo(value.__goType, info)
+  }
+
   if (!info.elemType) return false
 
   let elem = info.elemType
@@ -851,6 +897,13 @@ function matchesType(value: any, info: TypeInfo): boolean {
   if (value === null || value === undefined) {
     return false
   }
+  if (
+    typeof value === 'object' &&
+    typeof value.__goType === 'string' &&
+    value.__goType === info.name
+  ) {
+    return true
+  }
 
   switch (info.kind) {
     case TypeKind.Basic:
@@ -1008,6 +1061,12 @@ export function typeAssert<T>(
 
   // Handle typed nil pointers (created by typedNil() for conversions like (*T)(nil))
   if (typeof value === 'object' && value !== null && value.__isTypedNil) {
+    if (
+      isInterfaceTypeInfo(normalizedType) &&
+      matchesInterfaceType(value, normalizedType)
+    ) {
+      return { value: value as T, ok: true }
+    }
     // For typed nils, we need to compare the stored type with the expected type
     if (isPointerTypeInfo(normalizedType)) {
       // Parse the stored type string and compare with expected type
@@ -1023,6 +1082,17 @@ export function typeAssert<T>(
   if (isPointerTypeInfo(normalizedType) && value === null) {
     return { value: null as unknown as T, ok: false }
   }
+  if (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof value.__goType === 'string' &&
+    value.__goType === normalizedType.name
+  ) {
+    if ('__goValue' in value) {
+      return { value: value.__goValue as T, ok: true }
+    }
+    return { value: value as T, ok: true }
+  }
 
   // Removed struct matching logic - struct types should use nominal matching
   // via matchesStructType in matchesType, not structural matching here
@@ -1034,9 +1104,9 @@ export function typeAssert<T>(
   ) {
     if (normalizedType.keyType || normalizedType.elemType) {
       const entries =
-        value instanceof Map
-          ? Array.from(value.entries())
-          : Object.entries(value)
+        value instanceof Map ?
+          Array.from(value.entries())
+        : Object.entries(value)
 
       if (entries.length === 0) {
         return { value: value as T, ok: true }
@@ -1074,17 +1144,6 @@ export function typeAssert<T>(
 
   const matches = matchesType(value, normalizedType)
   if (matches) {
-    // Special handling for pointer type assertions:
-    // If the value is a VarRef and we're asserting to a pointer type,
-    // return the inner value (value.value), not the VarRef object itself
-    if (
-      isPointerTypeInfo(normalizedType) &&
-      typeof value === 'object' &&
-      value !== null &&
-      'value' in value
-    ) {
-      return { value: value.value as T, ok: true }
-    }
     return { value: value as T, ok: true }
   }
 
@@ -1093,10 +1152,10 @@ export function typeAssert<T>(
   if (typeof typeInfo === 'string') {
     const registeredType = typeRegistry.get(typeInfo)
     if (registeredType && registeredType.zeroValue !== undefined) {
-      return { value: registeredType.zeroValue as T, ok: false }
+      return { value: resolveZeroValue<T>(registeredType.zeroValue), ok: false }
     }
   } else if (normalizedType.zeroValue !== undefined) {
-    return { value: normalizedType.zeroValue as T, ok: false }
+    return { value: resolveZeroValue<T>(normalizedType.zeroValue), ok: false }
   }
 
   return { value: null as unknown as T, ok: false }
@@ -1160,7 +1219,7 @@ export function is(value: any, typeInfo: string | TypeInfo): boolean {
  */
 export interface TypeSwitchCase {
   types: (string | TypeInfo)[] // Array of types for this case (e.g., case int, string:)
-  body: (value?: any) => void // Function representing the case body. 'value' is the asserted value if applicable.
+  body: (value?: any) => any // Function representing the case body. 'value' is the asserted value if applicable.
 }
 
 /**
@@ -1174,16 +1233,15 @@ export interface TypeSwitchCase {
 export function typeSwitch(
   value: any,
   cases: TypeSwitchCase[],
-  defaultCase?: () => void,
-): void {
+  defaultCase?: () => any,
+): any {
   for (const caseObj of cases) {
     // For cases with multiple types (case T1, T2:), use $.is
     if (caseObj.types.length > 1) {
       const matchesAny = caseObj.types.some((typeInfo) => is(value, typeInfo))
       if (matchesAny) {
         // For multi-type cases, the case variable (if any) gets the original value
-        caseObj.body(value)
-        return // Found a match, exit switch
+        return caseObj.body(value)
       }
     } else if (caseObj.types.length === 1) {
       // For single-type cases (case T:), use $.typeAssert to get the typed value and ok status
@@ -1191,9 +1249,7 @@ export function typeSwitch(
       const { value: assertedValue, ok } = typeAssert(value, typeInfo)
       if (ok) {
         // Pass the asserted value to the case body function
-        caseObj.body(assertedValue)
-
-        return // Found a match, exit switch
+        return caseObj.body(assertedValue)
       }
     }
     // Note: Cases with 0 types are not valid in Go type switches
@@ -1201,7 +1257,7 @@ export function typeSwitch(
 
   // If no case matched and a default case exists, execute it
   if (defaultCase) {
-    defaultCase()
+    return defaultCase()
   }
 }
 
@@ -1219,3 +1275,105 @@ export function typedNil(typeName: string): any {
     __isTypedNil: true,
   })
 }
+
+export function interfaceValue<T>(value: unknown, typeName: string): T {
+  if (value !== null && value !== undefined) {
+    if (typeof value === 'object') {
+      Object.defineProperty(value, '__goType', {
+        value: typeName,
+        writable: true,
+        configurable: true,
+      })
+    }
+    return value as T
+  }
+
+  const nilValue = typedNil(typeName)
+  if (!typeName.startsWith('*')) {
+    return nilValue as T
+  }
+
+  const dynamicType = typeRegistry.get(typeName.slice(1))
+  if (!dynamicType || !isStructTypeInfo(dynamicType) || !dynamicType.ctor) {
+    return nilValue as T
+  }
+
+  const prototype = dynamicType.ctor.prototype as Record<string, unknown>
+  for (const method of dynamicType.methods) {
+    const implementation = prototype[method.name]
+    if (typeof implementation !== 'function') {
+      continue
+    }
+    Object.defineProperty(nilValue, method.name, {
+      value: (...args: unknown[]) => implementation.call(null, ...args),
+      enumerable: true,
+    })
+  }
+  return nilValue as T
+}
+
+export function namedValueInterfaceValue<T>(
+  value: unknown,
+  typeName: string,
+  methods: Record<string, (receiver: any, ...args: any[]) => any>,
+): T {
+  const boxed: any = {
+    __goType: typeName,
+    __goValue: value,
+    valueOf: () => value,
+    toString: () => String(value),
+    [Symbol.toPrimitive]: () => value as any,
+  }
+  for (const [name, method] of Object.entries(methods)) {
+    boxed[name] = (...args: any[]) => method(value, ...args)
+  }
+  return boxed as T
+}
+
+export function namedFunction<T>(fn: T, typeName: string): T {
+  if (typeof fn !== 'function') {
+    return fn
+  }
+  return Object.assign(fn, { __goTypeName: typeName })
+}
+
+export function functionValue<T extends (...args: any[]) => any>(
+  fn: T,
+  typeInfo: FunctionTypeInfo,
+): T {
+  return Object.assign(fn, { __typeInfo: typeInfo })
+}
+
+export interface GenericTypeDescriptor<T = any> {
+  type?: TypeInfo | string
+  zero?: () => T
+  methods?: Record<string, (receiver: T, ...args: any[]) => any>
+}
+
+export type GenericTypeArgs = Record<string, GenericTypeDescriptor>
+
+export function genericZero<T>(
+  typeArgs: GenericTypeArgs | undefined,
+  name: string,
+  fallback: T,
+): T {
+  const zero = typeArgs?.[name]?.zero
+  if (zero) {
+    return zero() as T
+  }
+  return fallback
+}
+
+export function callGenericMethod<T>(
+  typeArgs: GenericTypeArgs | undefined,
+  name: string,
+  method: string,
+  receiver: T,
+  ...args: any[]
+): any {
+  const fn = typeArgs?.[name]?.methods?.[method]
+  if (fn) {
+    return fn(receiver, ...args)
+  }
+  return (receiver as any)[method](...args)
+}

package/gs/builtin/varRef.ts

@@ -5,7 +5,12 @@
  *   var myVariable int // variable referenced
  *   myOtherVar := &myVariable
  */
-export type VarRef<T> = { value: T; __isVarRef?: true }
+export type VarRef<T> = {
+  value: T
+  __isVarRef?: true
+  __goType?: string
+  __goAddress?: () => number
+}
 
 /** Wrap a non-null T in a variable reference. */
 export function varRef<T>(v: T): VarRef<T> {
@@ -15,6 +20,22 @@ export function varRef<T>(v: T): VarRef<T> {
   return { value: v, __isVarRef: true }
 }
 
+/** Create a variable reference to an object field. */
+export function fieldRef<T extends object, K extends keyof T>(
+  target: T,
+  key: K,
+): VarRef<T[K]> {
+  return {
+    get value(): T[K] {
+      return target[key]
+    },
+    set value(value: T[K]) {
+      target[key] = value
+    },
+    __isVarRef: true,
+  }
+}
+
 /** Check if a value is a VarRef (pointer) */
 export function isVarRef(v: unknown): v is VarRef<unknown> {
   return v !== null && typeof v === 'object' && (v as any).__isVarRef === true
@@ -29,3 +50,19 @@ export function unref<T>(b: VarRef<T>): T {
   }
   return b.value
 }
+
+export function unsupportedPointerRef<T>(_value: unknown): VarRef<T> {
+  return {
+    get value(): T {
+      throw new Error(
+        'unsafe pointer dereference is not supported in JavaScript/TypeScript',
+      )
+    },
+    set value(_value: T) {
+      throw new Error(
+        'unsafe pointer dereference is not supported in JavaScript/TypeScript',
+      )
+    },
+    __isVarRef: true,
+  }
+}

package/gs/bytes/buffer.gs.ts

@@ -269,28 +269,30 @@ export class Buffer {
 	// error except io.EOF encountered during the read is also returned. If the
 	// buffer becomes too large, ReadFrom will panic with [ErrTooLarge].
 	public ReadFrom(r: io.Reader): [number, $.GoError] {
-		const b = this
-		b.lastRead = 0
-		let n = 0
-		for (; ; ) {
-			let i = b.grow(512)
-			b.buf = $.goSlice(b.buf, undefined, i)
-			let [m, e] = r!.Read($.bytesToUint8Array($.goSlice(b.buf, i, $.cap(b.buf))))
-			if (m < 0) {
-				$.panic(errNegativeRead)
-			}
+		return (async (): Promise<[number, $.GoError]> => {
+			const b = this
+			b.lastRead = 0
+			let n = 0
+			for (; ; ) {
+				let i = b.grow(512)
+				b.buf = $.goSlice(b.buf, undefined, i)
+				let [m, e] = await (r!.Read($.bytesToUint8Array($.goSlice(b.buf, i, $.cap(b.buf)))) as any)
+				if (m < 0) {
+					$.panic(errNegativeRead)
+				}
 
-			b.buf = $.goSlice(b.buf, undefined, i + m)
-			n += (m as number)
+				b.buf = $.goSlice(b.buf, undefined, i + m)
+				n += (m as number)
 
-			// e is EOF, so return nil explicitly
-			if (e == io.EOF) {
-				return [n, null]
-			}
-			if (e != null) {
-				return [n, e]
+				// e is EOF, so return nil explicitly
+				if (e == io.EOF) {
+					return [n, null]
+				}
+				if (e != null) {
+					return [n, e]
+				}
 			}
-		}
+		})() as any
 	}
 
 	// WriteTo writes data to w until the buffer is drained or an error occurs.
@@ -298,30 +300,32 @@ export class Buffer {
 	// int, but it is int64 to match the [io.WriterTo] interface. Any error
 	// encountered during the write is also returned.
 	public WriteTo(w: io.Writer): [number, $.GoError] {
-		const b = this
-		b.lastRead = 0
-		let n = 0
-		{
-			let nBytes = b.Len()
-			if (nBytes > 0) {
-				let [m, e] = w!.Write($.bytesToUint8Array($.goSlice(b.buf, b.off, undefined)))
-				if (m > nBytes) {
-					$.panic("bytes.Buffer.WriteTo: invalid Write count")
-				}
-				b.off += m
-				n = (m as number)
-				if (e != null) {
-					return [n, e]
-				}
-				// all bytes should have been written, by definition of
-				// Write method in io.Writer
-				if (m != nBytes) {
-					return [n, io.ErrShortWrite]
+		return (async (): Promise<[number, $.GoError]> => {
+			const b = this
+			b.lastRead = 0
+			let n = 0
+			{
+				let nBytes = b.Len()
+				if (nBytes > 0) {
+					let [m, e] = await (w!.Write($.bytesToUint8Array($.goSlice(b.buf, b.off, undefined))) as any)
+					if (m > nBytes) {
+						$.panic("bytes.Buffer.WriteTo: invalid Write count")
+					}
+					b.off += m
+					n = (m as number)
+					if (e != null) {
+						return [n, e]
+					}
+					// all bytes should have been written, by definition of
+					// Write method in io.Writer
+					if (m != nBytes) {
+						return [n, io.ErrShortWrite]
+					}
 				}
 			}
-		}
-		b.Reset()
-		return [n, null]
+			b.Reset()
+			return [n, null]
+		})() as any
 	}
 
 	// WriteByte appends the byte c to the buffer, growing the buffer as needed.
@@ -373,7 +377,7 @@ export class Buffer {
 			}
 			return [0, io.EOF]
 		}
-		const n = $.copy($.bytesToUint8Array(p), $.bytesToUint8Array($.goSlice(b.buf, b.off, undefined)))
+		const n = $.copy(p, $.goSlice(b.buf, b.off, undefined))
 		b.off += n
 		if (n > 0) {
 			b.lastRead = -1
@@ -603,8 +607,8 @@ export function growSlice(b: $.Bytes, n: number): $.Bytes {
 		// we could rely purely on append to determine the growth rate.
 		c = 2 * $.cap(b)
 	}
-	let b2 = $.append<number>(null, new Uint8Array(c))
-	let i = $.copy($.bytesToUint8Array(b2), $.bytesToUint8Array(b))
+	let b2 = $.makeSlice<number>(c, c, 'byte')
+	let i = $.copy(b2, b)
 	return $.goSlice(b2, undefined, i)
 }
 

package/gs/bytes/meta.json

@@ -1,10 +1,15 @@
 {
   "dependencies": [
     "errors",
-    "io", 
+    "io",
     "iter",
     "unicode",
     "unicode/utf8",
     "unsafe"
-  ]
-} 
+  ],
+  "asyncMethods": {
+    "Buffer.ReadFrom": true,
+    "Buffer.WriteTo": true,
+    "Reader.WriteTo": true
+  }
+}

package/gs/bytes/reader.gs.ts

@@ -80,7 +80,7 @@ export class Reader {
 			return [0, io.EOF]
 		}
 		r.prevRune = -1
-		const n = $.copy($.bytesToUint8Array(b), $.bytesToUint8Array($.goSlice(r.s, r.i, undefined)))
+		const n = $.copy(b, $.goSlice(r.s, r.i, undefined))
 		r.i += (n as number)
 		return [n, null]
 	}
@@ -94,7 +94,7 @@ export class Reader {
 		if (off >= ($.len(r.s) as number)) {
 			return [0, io.EOF]
 		}
-		const n = $.copy($.bytesToUint8Array(b), $.bytesToUint8Array($.goSlice(r.s, off, undefined)))
+		const n = $.copy(b, $.goSlice(r.s, off, undefined))
 		let err: $.GoError = null
 		if (n < $.len(b)) {
 			err = io.EOF
@@ -187,22 +187,24 @@ export class Reader {
 
 	// WriteTo implements the [io.WriterTo] interface.
 	public WriteTo(w: io.Writer): [number, $.GoError] {
-		const r = this
-		r.prevRune = -1
-		if (r.i >= ($.len(r.s) as number)) {
-			return [0, null]
-		}
-		const b = $.goSlice(r.s, r.i, undefined)
-		const [m, err] = w!.Write($.bytesToUint8Array(b))
-		if (m > $.len(b)) {
-			$.panic("bytes.Reader.WriteTo: invalid Write count")
-		}
-		r.i += (m as number)
-		const n = (m as number)
-		if (m != $.len(b) && err == null) {
-			return [n, io.ErrShortWrite]
-		}
-		return [n, err]
+		return (async (): Promise<[number, $.GoError]> => {
+			const r = this
+			r.prevRune = -1
+			if (r.i >= ($.len(r.s) as number)) {
+				return [0, null]
+			}
+			const b = $.goSlice(r.s, r.i, undefined)
+			const [m, err] = await (w!.Write($.bytesToUint8Array(b)) as any)
+			if (m > $.len(b)) {
+				$.panic("bytes.Reader.WriteTo: invalid Write count")
+			}
+			r.i += (m as number)
+			const n = (m as number)
+			if (m != $.len(b) && err == null) {
+				return [n, io.ErrShortWrite]
+			}
+			return [n, err]
+		})() as any
 	}
 
 	// Reset resets the [Reader] to be reading from b.
@@ -227,4 +229,3 @@ export class Reader {
 export function NewReader(b: $.Bytes): Reader {
 	return new Reader({s: $.normalizeBytes(b), i: 0, prevRune: -1})
 }
-

package/gs/context/context.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest'
+
+import { AfterFunc, WithCancel, Background } from './index.js'
+
+async function nextMicrotask(): Promise<void> {
+  await new Promise<void>((resolve) => queueMicrotask(resolve))
+}
+
+describe('context override', () => {
+  it('runs AfterFunc after cancellation', async () => {
+    const [ctx, cancel] = WithCancel(Background())
+    let called = false
+
+    const stop = AfterFunc(ctx, () => {
+      called = true
+    })
+
+    cancel?.()
+    await nextMicrotask()
+    await nextMicrotask()
+
+    expect(called).toBe(true)
+    expect(stop()).toBe(false)
+  })
+
+  it('stops AfterFunc before cancellation', async () => {
+    const [ctx, cancel] = WithCancel(Background())
+    let called = false
+
+    const stop = AfterFunc(ctx, () => {
+      called = true
+    })
+
+    expect(stop()).toBe(true)
+    cancel?.()
+    await nextMicrotask()
+    await nextMicrotask()
+
+    expect(called).toBe(false)
+  })
+})