goscript 0.0.84 → 0.1.0

package/gs/os/types_js.gs.ts

@@ -8,8 +8,8 @@ import * as syscall from "@goscript/syscall/index.js"
 import {
 	DenoFileLike,
 	DenoStream,
+	getHostRuntime,
 	HostUnsupportedError,
-	hostRuntime,
 	NodeFSModule,
 	resetHostRuntimeForTests,
 } from "@goscript/builtin/hostio.js"
@@ -33,23 +33,23 @@ export function newHostError(err: unknown): $.GoError {
 }
 
 export function getNodeFS(): NodeFSModule | null {
-	return hostRuntime.nodeFS
+	return getHostRuntime().nodeFS
 }
 
 export function getDeno(): any | null {
-	return hostRuntime.deno
+	return getHostRuntime().deno
 }
 
 export function getPlatform(): string {
-	return hostRuntime.platform
+	return getHostRuntime().platform
 }
 
 export function getEnv(name: string): string {
-	return hostRuntime.getEnv(name)
+	return getHostRuntime().getEnv(name)
 }
 
 export function getDenoStream(fd: number): DenoStream | null {
-	return hostRuntime.getStdioHandle(fd)
+	return getHostRuntime().getStdioHandle(fd)
 }
 
 function readFD(fd: number, b: Uint8Array): [number, $.GoError] {
@@ -58,7 +58,7 @@ function readFD(fd: number, b: Uint8Array): [number, $.GoError] {
 	}
 
 	try {
-		const n = hostRuntime.readFD(fd, b)
+		const n = getHostRuntime().readFD(fd, b)
 		if (n === null || n === 0) {
 			return [0, io.EOF]
 		}
@@ -77,7 +77,7 @@ function writeFD(fd: number, b: Uint8Array): [number, $.GoError] {
 	}
 
 	try {
-		return [hostRuntime.writeFD(fd, b), null]
+		return [getHostRuntime().writeFD(fd, b), null]
 	} catch (err) {
 		if (err instanceof HostUnsupportedError) {
 			return [0, ErrUnimplemented]
@@ -192,7 +192,7 @@ export function createFileInfo(name: string, stat: HostStatLike): fs.FileInfo {
 export function createHostFile(name: string, fd: number = -1, handle: DenoFileLike | null = null): File {
 	return new File({
 		fd,
-		file: new file({ handle: handle ?? hostRuntime.getStdioHandle(fd), path: name }),
+		file: new file({ handle: handle ?? getHostRuntime().getStdioHandle(fd), path: name }),
 		name,
 	})
 }

package/gs/reflect/index.ts

@@ -47,7 +47,6 @@ export {
 } from './types.js'
 export type {
   uintptr,
-  Pointer,
   Method,
   SelectDir,
   SliceHeader,
@@ -80,6 +79,7 @@ export {
   Interface,
   Map,
   Ptr,
+  Pointer,
   Slice,
   String,
   Struct,

package/gs/reflect/type.ts

@@ -167,6 +167,7 @@ export const Func: Kind = 19
 export const Interface: Kind = 20
 export const Map: Kind = 21
 export const Ptr: Kind = 22
+export const Pointer: Kind = Ptr
 export const Slice: Kind = 23
 export const String: Kind = 24
 export const Struct: Kind = 25
@@ -1945,22 +1946,7 @@ function getTypeOf(value: ReflectValue): Type {
           typeInfo.params &&
           typeInfo.results
         ) {
-          // Build proper function signature from type info
-          const paramTypes = typeInfo.params
-            .map((p: any) => (typeof p === 'string' ? p : p.name || 'any'))
-            .join(', ')
-          const resultTypes = typeInfo.results.map((r: any) =>
-            typeof r === 'string' ? r : r.name || 'any',
-          )
-
-          let signature = `func(${paramTypes})`
-          if (resultTypes.length === 1) {
-            signature += ` ${resultTypes[0]}`
-          } else if (resultTypes.length > 1) {
-            signature += ` (${resultTypes.join(', ')})`
-          }
-
-          return new FunctionType(signature)
+          return functionTypeFromInfo(typeInfo)
         }
       }
 
@@ -2180,10 +2166,113 @@ export function ChanOf(dir: ChanDir, t: Type): Type {
   return new ChannelType(t, dir)
 }
 
-export function TypeFor(): Type {
+export function TypeFor(typeArgs?: $.GenericTypeArgs): Type {
+  const descriptor = typeArgs?.T
+  if (descriptor?.type) {
+    return typeFromTypeInfo(descriptor.type)
+  }
+  if (descriptor?.methods) {
+    const methods = Object.keys(descriptor.methods)
+    if (methods.length !== 0) {
+      return new InterfaceType(
+        `interface { ${methods.map((method) => method + '()').join('; ')} }`,
+      )
+    }
+  }
+  if (descriptor?.zero) {
+    return getTypeOf(descriptor.zero())
+  }
   return new InterfaceType('interface{}')
 }
 
+function typeFromTypeInfo(info: $.TypeInfo | string): Type {
+  if (typeof info === 'string') {
+    const registered = builtinGetTypeByName(info)
+    if (registered) {
+      return typeFromTypeInfo(registered)
+    }
+    return StructType.createTypeFromFieldInfo(info)
+  }
+  switch (info.kind) {
+    case $.TypeKind.Array:
+      return new ArrayType(
+        typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }),
+        info.length,
+      )
+    case $.TypeKind.Channel:
+      return new ChannelType(
+        typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }),
+        chanDirFromTypeInfo(info.direction),
+      )
+    case $.TypeKind.Function:
+      return functionTypeFromInfo(info)
+    case $.TypeKind.Interface:
+      return interfaceTypeFromInfo(info)
+    case $.TypeKind.Map:
+      return new MapType(
+        typeFromTypeInfo(info.keyType ?? { kind: $.TypeKind.Basic, name: 'unknown' }),
+        typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }),
+      )
+    case $.TypeKind.Pointer:
+      return new PointerType(
+        typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }),
+      )
+    default:
+      return StructType.createTypeFromFieldInfo(info)
+  }
+}
+
+function functionTypeFromInfo(info: $.FunctionTypeInfo): Type {
+  if (info.name) {
+    return new FunctionType(info.name)
+  }
+  const params = info.params ?? []
+  const paramTypes = params.map((param, index) => {
+    const typeName = functionSignatureTypeName(param)
+    if (!info.isVariadic || index !== params.length - 1) {
+      return typeName
+    }
+    if (typeName.startsWith('[]')) {
+      return '...' + typeName.slice(2)
+    }
+    return '...' + typeName
+  })
+  const resultTypes = (info.results ?? []).map(functionSignatureTypeName)
+  let signature = `func(${paramTypes.join(', ')})`
+  if (resultTypes.length === 1) {
+    signature += ` ${resultTypes[0]}`
+  }
+  if (resultTypes.length > 1) {
+    signature += ` (${resultTypes.join(', ')})`
+  }
+  return new FunctionType(signature)
+}
+
+function functionSignatureTypeName(info: $.TypeInfo | string): string {
+  return typeFromTypeInfo(info).String()
+}
+
+function interfaceTypeFromInfo(info: $.InterfaceTypeInfo): Type {
+  if (info.methods.length === 0) {
+    return new InterfaceType('interface{}', info.name)
+  }
+  return new InterfaceType(
+    `interface { ${info.methods.map((method) => method.name + '()').join('; ')} }`,
+    info.name,
+  )
+}
+
+function chanDirFromTypeInfo(direction?: 'send' | 'receive' | 'both'): ChanDir {
+  switch (direction) {
+    case 'send':
+      return SendDir
+    case 'receive':
+      return RecvDir
+    default:
+      return BothDir
+  }
+}
+
 /**
  * getInterfaceTypeByName looks up a registered interface type by name
  * and returns a Type for it. Returns an interface{} type if not found.

package/gs/reflect/typefor.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect } from 'vitest'
+import {
+  TypeKind,
+  registerInterfaceType,
+  registerStructType,
+} from '../builtin/index.js'
+import { Int, Struct, TypeFor } from './type.js'
+
+describe('TypeFor', () => {
+  it('uses generic runtime type descriptors', () => {
+    const intType = TypeFor({
+      T: {
+        type: { kind: TypeKind.Basic, name: 'int' },
+        zero: () => 0,
+      },
+    })
+
+    expect(intType.String()).toBe('int')
+    expect(intType.Kind()).toBe(Int)
+  })
+
+  it('formats literal interface methods from type metadata', () => {
+    const ifaceType = TypeFor({
+      T: {
+        type: {
+          kind: TypeKind.Interface,
+          methods: [{ name: 'SomeMethod', args: [], returns: [] }],
+        },
+        zero: () => null,
+      },
+    })
+
+    expect(ifaceType.String()).toBe('interface { SomeMethod() }')
+  })
+
+  it('formats unnamed function signatures from type metadata', () => {
+    const fnType = TypeFor({
+      T: {
+        type: {
+          kind: TypeKind.Function,
+          params: [{ kind: TypeKind.Basic, name: 'int' }],
+          results: [{ kind: TypeKind.Basic, name: 'string' }],
+        },
+        zero: () => null,
+      },
+    })
+
+    expect(fnType.String()).toBe('func(int) string')
+  })
+
+  it('resolves registered type names from descriptors', () => {
+    class RegisteredStruct {}
+    registerStructType(
+      'main.RegisteredStruct',
+      new RegisteredStruct(),
+      [],
+      RegisteredStruct,
+      {},
+    )
+    registerInterfaceType('main.RegisteredInterface', null, [
+      { name: 'SomeMethod', args: [], returns: [] },
+    ])
+
+    const structType = TypeFor({
+      T: { type: 'main.RegisteredStruct', zero: () => new RegisteredStruct() },
+    })
+    const ifaceType = TypeFor({
+      T: { type: 'main.RegisteredInterface', zero: () => null },
+    })
+
+    expect(structType.String()).toBe('main.RegisteredStruct')
+    expect(structType.Kind()).toBe(Struct)
+    expect(ifaceType.String()).toBe('interface { SomeMethod() }')
+  })
+})

package/gs/sync/sync.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest'
+
+import { WaitGroup } from './sync.js'
+
+describe('sync.WaitGroup', () => {
+  it('Go tracks scheduled work and unblocks Wait after completion', async () => {
+    const wg = new WaitGroup()
+    const events: string[] = []
+
+    wg.Go(async () => {
+      events.push('worker start')
+      await Promise.resolve()
+      events.push('worker done')
+    })
+
+    const wait = wg.Wait().then(() => {
+      events.push('wait done')
+    })
+
+    expect(events).toEqual([])
+    await wait
+    expect(events).toEqual(['worker start', 'worker done', 'wait done'])
+  })
+})

package/gs/sync/sync.ts

@@ -193,6 +193,18 @@ export class WaitGroup {
     this.Add(-1)
   }
 
+  // Go calls f in a new goroutine and adds that task to the WaitGroup.
+  public Go(f: () => void | Promise<void>): void {
+    this.Add(1)
+    queueMicrotask(async () => {
+      try {
+        await f()
+      } finally {
+        this.Done()
+      }
+    })
+  }
+
   // Wait blocks until the WaitGroup counter is zero
   public async Wait(): Promise<void> {
     if (this._counter === 0) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "goscript",
   "description": "Go to TypeScript transpiler",
-  "version": "0.0.84",
+  "version": "0.1.0",
   "author": {
     "name": "Aperture Robotics LLC.",
     "email": "support@aperture.us",
@@ -42,27 +42,27 @@
     }
   },
   "scripts": {
-    "build": "npm run build:updategover && tsc -p tsconfig.build.json",
-    "build:updategover": "node -e \"const fs = require('fs'); const { execSync } = require('child_process'); const goVersion = execSync('go mod edit -json', { encoding: 'utf8' }); const goData = JSON.parse(goVersion); const version = goData.Go; const runtimePath = 'gs/runtime/runtime.ts'; const content = fs.readFileSync(runtimePath, 'utf8'); const updatedContent = content.replace(/export const GOVERSION = 'go[^']*'/, \\`export const GOVERSION = 'go\\${version}'\\`); fs.writeFileSync(runtimePath, updatedContent);\"",
-    "prepublishOnly": "npm run build",
+    "build": "bun run build:updategover && tsgo -p tsconfig.build.json",
+    "build:updategover": "bun run scripts/update-go-version.ts",
+    "prepublishOnly": "bun run build",
     "example": "cd ./example/simple && bash run.bash",
-    "test": "npm run test:go && npm run test:js",
+    "test": "bun run test:go && bun run test:js",
     "test:go": "go test ./...",
-    "test:js": "npm run typecheck && vitest run",
+    "test:js": "bun run typecheck && vitest run",
     "test:browser": "bun run scripts/generate-browser-tests.ts && vitest run --config vitest.browser.config.ts",
     "test:browser:ui": "bun run scripts/generate-browser-tests.ts && vitest --config vitest.browser.config.ts --ui",
     "typecheck": "tsgo --noEmit -p tsconfig.build.json",
-    "format": "npm run format:go && npm run format:js && npm run format:config",
+    "format": "bun run format:go && bun run format:js && bun run format:config",
     "format:config": "prettier --write tsconfig.json package.json",
     "format:go": "gofumpt -w .",
     "format:js": "prettier --write './{src,gs,example}/**/(*.ts|*.tsx|*.html|*.css|*.scss)'",
-    "release": "npm run release:version && npm run release:commit",
-    "release:minor": "npm run release:version:minor && npm run release:commit",
-    "release:version": "npm version patch -m \"release: v%s\" --no-git-tag-version",
-    "release:version:minor": "npm version minor -m \"release: v%s\" --no-git-tag-version",
-    "release:commit": "git reset && git add package.json && git commit -s -m \"release: v$(node -p \"require('./package.json').version\")\" && git tag v$(node -p \"require('./package.json').version\")",
+    "release": "bun run release:version && bun run release:commit",
+    "release:minor": "bun run release:version:minor && bun run release:commit",
+    "release:version": "bun run scripts/bump-version.ts patch",
+    "release:version:minor": "bun run scripts/bump-version.ts minor",
+    "release:commit": "git reset && git add package.json && git commit -s -m \"release: v$(bun -p \"require('./package.json').version\")\" && git tag v$(bun -p \"require('./package.json').version\")",
     "release:publish": "git push && git push --tags",
-    "lint": "npm run lint:go && npm run lint:js",
+    "lint": "bun run lint:go && bun run lint:js",
     "lint:go": "golangci-lint run .",
     "lint:js": "eslint -c eslint.config.mjs ./",
     "lint:js:fix": "eslint -c eslint.config.mjs ./ --fix",