goscript 0.0.61 → 0.0.62

package/gs/reflect/types.ts

@@ -41,10 +41,10 @@ import { Type, Kind, Value, Kind_String, ChanDir } from './type.js'
 export class StructField {
   public Name: string = ''
   public Type!: Type
-  public Tag?: StructTag
-  public Offset?: uintptr
-  public Index?: number[]
-  public Anonymous?: boolean
+  public Tag: StructTag = new StructTag('')
+  public Offset: uintptr = 0
+  public Index: number[] = []
+  public Anonymous: boolean = false
 
   constructor(init?: Partial<StructField>) {
     if (init) {
@@ -58,10 +58,14 @@ export class StructField {
       Type: this.Type,
       Tag: this.Tag,
       Offset: this.Offset,
-      Index: this.Index ? [...this.Index] : undefined,
+      Index: [...this.Index],
       Anonymous: this.Anonymous,
     })
   }
+
+  public IsExported(): boolean {
+    return this.Name !== '' && this.Name[0] !== '_'
+  }
 }
 
 // Struct tag type
@@ -88,6 +92,14 @@ export class StructTag {
   }
 }
 
+// Wrapper function for GoScript naming convention
+export function StructTag_Get(tag: StructTag | undefined, key: string): string {
+  if (!tag) {
+    return ''
+  }
+  return tag.Get(key)
+}
+
 // Method representation
 export interface Method {
   Name: string
@@ -106,24 +118,24 @@ export interface Channel<T = unknown> {
 }
 
 // Select case for channel operations
-export interface SelectCase {
-  Dir: SelectDir
-  Chan?: Value // Value representing a channel - optional since default cases don't need it
-  Send?: Value // Value to send (if Dir is SendDir) - optional since only needed for send cases
-}
+export class SelectCase {
+  public Dir!: SelectDir
+  public Chan?: Value // Value representing a channel - optional since default cases don't need it
+  public Send?: Value // Value to send (if Dir is SendDir) - optional since only needed for send cases
 
-// Select direction constants
-export class SelectDir {
-  constructor(private _value: number) {}
-
-  valueOf(): number {
-    return this._value
+  constructor(init?: Partial<SelectCase>) {
+    if (init) {
+      Object.assign(this, init)
+    }
   }
 }
 
-export const SelectSend = new SelectDir(1)
-export const SelectRecv = new SelectDir(2)
-export const SelectDefault = new SelectDir(3)
+// Select direction constants - SelectDir is just an int in Go
+export type SelectDir = number
+
+export const SelectSend: SelectDir = 1
+export const SelectRecv: SelectDir = 2
+export const SelectDefault: SelectDir = 3
 
 // Slice header (internal representation)
 export interface SliceHeader {
@@ -139,12 +151,13 @@ export interface StringHeader {
 }
 
 // Map iterator with proper typing
+// Key() and Value() return reflect.Value to match Go's reflect.MapIter
 export interface MapIter<K = unknown, V = unknown> {
   map: Map<K, V>
   iterator: Iterator<[K, V]>
   current: IteratorResult<[K, V]> | null
-  Key(): K | null
-  Value(): V | null
+  Key(): Value
+  Value(): Value
   Next(): boolean
   Reset(m: Map<K, V>): void
 }

package/gs/reflect/value.ts

@@ -34,7 +34,10 @@ interface ChannelObject {
 }
 
 // Zero returns a Value representing the zero value for the specified type.
-export function Zero(typ: Type): Value {
+export function Zero(typ: Type | null): Value {
+  if (typ === null) {
+    return new Value() // Return invalid value for null type
+  }
   let zeroValue: ReflectValue
 
   switch (typ.Kind()) {
@@ -129,7 +132,10 @@ export function Indirect(v: Value): Value {
 }
 
 // New returns a Value representing a pointer to a new zero value for the specified type.
-export function New(typ: Type): Value {
+export function New(typ: Type | null): Value {
+  if (typ === null) {
+    return new Value() // Return invalid value for null type
+  }
   const ptrType = PointerTo(typ)
   // For the pointer value, we'll use the zero value but with pointer type
   // In a real implementation, this would be a pointer to the zero value
@@ -137,8 +143,8 @@ export function New(typ: Type): Value {
 }
 
 // MakeSlice returns a Value representing a new slice with the specified type, length, and capacity.
-export function MakeSlice(typ: Type, len: number, _cap: number): Value {
-  if (typ.Kind() !== Slice) {
+export function MakeSlice(typ: Type | null, len: number, _cap: number): Value {
+  if (typ === null || typ.Kind() !== Slice) {
     throw new Error('reflect.MakeSlice of non-slice type')
   }
 
@@ -156,8 +162,8 @@ export function MakeSlice(typ: Type, len: number, _cap: number): Value {
 }
 
 // MakeMap returns a Value representing a new map with the specified type.
-export function MakeMap(typ: Type): Value {
-  if (typ.Kind() !== Map) {
+export function MakeMap(typ: Type | null): Value {
+  if (typ === null || typ.Kind() !== Map) {
     throw new Error('reflect.MakeMap of non-map type')
   }
 

package/gs/slices/slices.ts

@@ -1,5 +1,45 @@
 // TypeScript implementation of Go's slices package
 import * as $ from '@goscript/builtin/index.js'
+import * as cmp from '../cmp/index.js'
+
+/**
+ * Compare compares the elements of s1 and s2 using cmp.Compare.
+ * The elements are compared sequentially, starting at index 0,
+ * until one element is not equal to the other.
+ * The result of comparing the first non-matching elements is returned.
+ * If both slices are equal until one of them ends, the shorter slice is
+ * considered less than the longer one.
+ * The result is 0 if s1 == s2, -1 if s1 < s2, and +1 if s1 > s2.
+ * @param s1 First slice
+ * @param s2 Second slice
+ * @returns -1, 0, or 1
+ */
+export function Compare<T extends string | number>(
+  s1: $.Slice<T>,
+  s2: $.Slice<T>,
+): number {
+  const len1 = $.len(s1)
+  const len2 = $.len(s2)
+  const minLen = len1 < len2 ? len1 : len2
+
+  for (let i = 0; i < minLen; i++) {
+    const v1 = (s1 as any)[i] as T
+    const v2 = (s2 as any)[i] as T
+    const result = cmp.Compare(v1, v2)
+    if (result !== 0) {
+      return result
+    }
+  }
+
+  // All elements are equal up to minLen, compare lengths
+  if (len1 < len2) {
+    return -1
+  }
+  if (len1 > len2) {
+    return 1
+  }
+  return 0
+}
 
 /**
  * All returns an iterator over index-value pairs in the slice.
@@ -99,6 +139,21 @@ export function Grow<T>(s: $.Slice<T>, n: number): $.Slice<T> {
   return newSlice
 }
 
+/**
+ * SortFunc sorts the slice using the provided comparison function.
+ * The comparison function should return a negative number if a < b, zero if a == b, or a positive number if a > b.
+ * This is equivalent to Go's slices.SortFunc function.
+ * @param s The slice to sort in place
+ * @param cmp Comparison function
+ */
+export function SortFunc<T>(s: $.Slice<T>, cmp: (a: T, b: T) => number): void {
+  if (s === null || s === undefined) {
+    return
+  }
+  const arr = s as any as T[]
+  arr.sort(cmp)
+}
+
 /**
  * BinarySearchFunc works like BinarySearch, but uses a custom comparison function.
  * The slice must be sorted in increasing order, where "increasing" is defined by cmp.

package/gs/sync/atomic/type.gs.ts

@@ -106,15 +106,24 @@ export class Pointer<T> {
 	}
 
 	// Store atomically stores val into x.
-	public Store(val: T): void {
-		const x = this
-		const varRef = $.varRef(val)
-		StorePointer(x._fields.v, unsafe.Pointer(varRef))
+	// In Go, this takes *T which can be nil, so we accept T | null
+	public Store(val: T | null): void {
+		const x = this
+		if (val === null) {
+			StorePointer(x._fields.v, null)
+		} else {
+			const varRef = $.varRef(val)
+			StorePointer(x._fields.v, unsafe.Pointer(varRef))
+		}
 	}
 
 	// Swap atomically stores new into x and returns the previous value.
-	public Swap(_new: T): $.VarRef<T> | null {
+	// In Go, this takes *T which can be nil, so we accept T | null
+	public Swap(_new: T | null): $.VarRef<T> | null {
 		const x = this
+		if (_new === null) {
+			return SwapPointer(x._fields.v, null) as $.VarRef<T> | null
+		}
 		const varRef = $.varRef(_new)
 		return SwapPointer(x._fields.v, unsafe.Pointer(varRef)) as $.VarRef<T> | null
 	}

package/gs/unicode/utf8/utf8.ts

@@ -15,12 +15,13 @@ export const MaxRune = 0x10ffff
 export const UTFMax = 4
 
 // AppendRune appends the UTF-8 encoding of r to the end of p and returns the extended buffer.
-export function AppendRune(p: Uint8Array, r: number): Uint8Array {
+export function AppendRune(p: $.Bytes, r: number): Uint8Array {
+  const bytes = $.normalizeBytes(p)
   const temp = new Uint8Array(UTFMax)
   const n = EncodeRune(temp, r)
-  const result = new Uint8Array(p.length + n)
-  result.set(p)
-  result.set(temp.slice(0, n), p.length)
+  const result = new Uint8Array(bytes.length + n)
+  result.set(bytes)
+  result.set(temp.slice(0, n), bytes.length)
   return result
 }
 
@@ -90,18 +91,21 @@ export function DecodeRune(p: $.Bytes): [number, number] {
 }
 
 // DecodeRuneInString is like DecodeRune but its input is a string.
-export function DecodeRuneInString(s: string): [number, number] {
-  if (s.length === 0) {
+// Also accepts Bytes for Go's []byte to string conversion pattern.
+export function DecodeRuneInString(s: string | $.Bytes): [number, number] {
+  // Convert Bytes to string if necessary
+  const str = typeof s === 'string' ? s : $.bytesToString(s)
+  if (str.length === 0) {
     return [RuneError, 0]
   }
 
-  const c = s.charCodeAt(0)
+  const c = str.charCodeAt(0)
   if (c < RuneSelf) {
     return [c, 1]
   }
 
   // Use JavaScript's built-in Unicode handling
-  const codePoint = s.codePointAt(0) || RuneError
+  const codePoint = str.codePointAt(0) || RuneError
   const char = String.fromCodePoint(codePoint)
   const encoder = new TextEncoder()
   const encoded = encoder.encode(char)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "goscript",
   "description": "Go to TypeScript transpiler",
-  "version": "0.0.61",
+  "version": "0.0.62",
   "author": {
     "name": "Aperture Robotics LLC.",
     "email": "support@aperture.us",
@@ -58,7 +58,7 @@
     "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$npm_package_version\" && git tag v$npm_package_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:publish": "git push && git push --tags && npm run build && npm publish",
     "lint": "npm run lint:go && npm run lint:js",
     "lint:go": "golangci-lint run .",
@@ -85,19 +85,19 @@
   },
   "devDependencies": {
     "@aptre/protobuf-es-lite": "^0.5.2",
-    "@eslint/js": "^9.31.0",
-    "@types/node": "^24.0.13",
-    "@typescript-eslint/eslint-plugin": "^8.36.0",
-    "@typescript-eslint/parser": "^8.36.0",
-    "@typescript/native-preview": "^7.0.0-dev.20250711.1",
-    "eslint": "^9.31.0",
+    "@eslint/js": "^9.39.2",
+    "@types/node": "^25.0.3",
+    "@typescript-eslint/eslint-plugin": "^8.50.1",
+    "@typescript-eslint/parser": "^8.50.1",
+    "@typescript/native-preview": "^7.0.0-dev.20251226.1",
+    "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.0.2",
     "husky": "^9.1.7",
-    "lint-staged": "^16.0.0",
-    "prettier": "^3.6.2",
-    "tsx": "^4.0.0",
+    "lint-staged": "^16.2.7",
+    "prettier": "^3.7.4",
+    "tsx": "^4.21.0",
     "typescript": "^5.8.3",
-    "typescript-eslint": "^8.36.0",
-    "vitest": "^4.0.0"
+    "typescript-eslint": "^8.50.1",
+    "vitest": "^4.0.16"
   }
 }