goscript 0.0.38 → 0.0.40

package/gs/reflect/map.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest'
+import { MapIter } from './map.js'
+
+describe('MapIter', () => {
+  it('should iterate over map entries with proper typing', () => {
+    const map = new Map<string, number>()
+    map.set('one', 1)
+    map.set('two', 2)
+    map.set('three', 3)
+
+    const iter = new MapIter<string, number>(map)
+
+    expect(iter.current?.done === false).toBe(true)
+    expect(iter.Key()).toBe('one')
+    expect(iter.Value()).toBe(1)
+
+    expect(iter.Next()).toBe(true)
+    expect(iter.current?.done === false).toBe(true)
+    expect(typeof iter.Key()).toBe('string')
+    expect(typeof iter.Value()).toBe('number')
+
+    const newMap = new Map<string, number>()
+    newMap.set('reset', 100)
+    iter.Reset(newMap)
+
+    expect(iter.current?.done === false).toBe(true)
+    expect(iter.Key()).toBe('reset')
+    expect(iter.Value()).toBe(100)
+  })
+})

package/gs/reflect/map.ts

@@ -37,35 +37,39 @@ class MapType implements Type {
   }
 }
 
-// Simple map iterator using JavaScript Map
-export class MapIter {
-  private iterator: Iterator<[any, any]>
-  private currentEntry: IteratorResult<[any, any]> | null = null
-
-  constructor(private map: Map<any, any>) {
+/**
+ * MapIter provides an iterator interface for Go maps.
+ * It wraps a JavaScript Map iterator and provides methods to iterate over key-value pairs.
+ * @template K - The type of keys in the map
+ * @template V - The type of values in the map
+ */
+export class MapIter<K = unknown, V = unknown> {
+  public iterator: Iterator<[K, V]>
+  public current: IteratorResult<[K, V]> | null = null
+
+  constructor(public map: Map<K, V>) {
     this.iterator = map.entries()
     this.Next()
   }
 
   public Next(): boolean {
-    this.currentEntry = this.iterator.next()
-    return !this.currentEntry.done
+    this.current = this.iterator.next()
+    return !this.current.done
   }
 
-  public Key(): any {
-    return this.currentEntry?.value?.[0]
+  public Key(): K | null {
+    return this.current?.value?.[0] ?? null
   }
 
-  public Value(): any {
-    return this.currentEntry?.value?.[1]
+  public Value(): V | null {
+    return this.current?.value?.[1] ?? null
   }
 
-  public Reset(m: any): void {
-    if (m instanceof Map) {
-      this.map = m
-      this.iterator = m.entries()
-      this.Next()
-    }
+  public Reset(m: Map<K, V>): void {
+    this.map = m
+    this.iterator = m.entries()
+    this.current = null
+    this.Next()
   }
 }
 

package/gs/reflect/metadata.go

@@ -0,0 +1,7 @@
+package reflect
+
+// GsDependencies lists the import paths that this gs/ package requires
+// These dependencies will be automatically copied when this package is included
+var GsDependencies = []string{
+	"iter",
+}

package/gs/reflect/type.ts

@@ -1,4 +1,5 @@
-import { ReflectValue, ChanDir } from './types.js'
+import { ReflectValue, ChanDir, StructField } from './types.js'
+import { MapIter } from './map.js'
 
 // rtype is the common implementation of most values
 export class rtype {
@@ -181,7 +182,7 @@ export interface Type {
   PkgPath?(): string
 
   // Field returns a struct type's i'th field.
-  Field?(i: number): any
+  Field?(i: number): StructField | null
 
   // common returns the common type implementation.
   common?(): rtype
@@ -351,15 +352,15 @@ export class Value {
   }
 
   // Additional methods needed by various parts of the codebase
-  public UnsafePointer(): any {
+  public UnsafePointer(): unknown {
     return this._value
   }
 
-  public pointer(): any {
+  public pointer(): unknown {
     return this._value
   }
 
-  public get ptr(): any {
+  public get ptr(): unknown {
     return this._value
   }
 
@@ -383,7 +384,7 @@ export class Value {
     return 0
   }
 
-  public MapRange(): any {
+  public MapRange(): MapIter<unknown, unknown> | null {
     // Placeholder for map iteration
     return null
   }
@@ -393,9 +394,9 @@ export class Value {
     return new Value(null, new BasicType(Invalid, 'invalid'))
   }
 
-  public Complex(): any {
+  public Complex(): number | { real: number; imag: number } | null {
     // Placeholder for complex number support
-    return this._value
+    return this._value as number | { real: number; imag: number } | null
   }
 
   // Send sends a value to a channel
@@ -459,7 +460,7 @@ export class BasicType implements Type {
     return ''
   }
 
-  public Field?(_i: number): any {
+  public Field?(_i: number): StructField | null {
     return null
   }
 
@@ -532,7 +533,7 @@ class ArrayType implements Type {
     return ''
   }
 
-  public Field?(_i: number): any {
+  public Field?(_i: number): StructField | null {
     return null
   }
 
@@ -569,7 +570,7 @@ class PointerType implements Type {
     return ''
   }
 
-  public Field?(_i: number): any {
+  public Field?(_i: number): StructField | null {
     return null
   }
 
@@ -606,7 +607,7 @@ class FunctionType implements Type {
     return ''
   }
 
-  public Field?(_i: number): any {
+  public Field?(_i: number): StructField | null {
     return null
   }
 
@@ -650,7 +651,7 @@ class MapType implements Type {
     return ''
   }
 
-  public Field?(_i: number): any {
+  public Field?(_i: number): StructField | null {
     return null
   }
 
@@ -780,7 +781,7 @@ function getTypeOf(value: ReflectValue): Type {
       if (funcWithMeta.__typeInfo) {
         const typeInfo = funcWithMeta.__typeInfo
         if (
-          typeInfo.kind === 'function' &&
+          (typeInfo.kind === 'function' || typeInfo.kind === 'Function') &&
           typeInfo.params &&
           typeInfo.results
         ) {
@@ -1003,7 +1004,10 @@ export function canRangeFunc2(t: Type): boolean {
   return kind === 21 // map
 }
 
-export function funcLayout(_t: Type, _rcvr: Type | null): any {
+export function funcLayout(
+  _t: Type,
+  _rcvr: Type | null,
+): { Type: Type | null; InCount: number; OutCount: number } {
   return {
     Type: null,
     InCount: 0,

package/gs/reflect/value.ts

@@ -28,6 +28,11 @@ import {
 import { ReflectValue, SelectCase, SelectRecv, SelectDefault } from './types.js'
 import * as $ from '@goscript/builtin/builtin.js'
 
+interface ChannelObject {
+  _sendQueue?: unknown[]
+  send?: (value: unknown) => void
+}
+
 // Re-export ValueOf from type.ts for compatibility
 export { ValueOf } from './type'
 
@@ -205,11 +210,19 @@ export function MakeChan(typ: Type, buffer: number): Value {
 export function Select(cases: $.Slice<SelectCase>): [number, Value, boolean] {
   // Extract the backing array from the GoScript slice
   let selectCases: SelectCase[] = []
-  if (cases && typeof cases === 'object' && '__meta__' in cases) {
-    // This is a GoScript slice, extract the backing array
-    const meta = (cases as { __meta__?: { backing?: SelectCase[] } }).__meta__
-    if (meta && meta.backing) {
-      selectCases = meta.backing
+  
+  if (cases && typeof cases === 'object') {
+    if ('__meta__' in cases) {
+      // This is a GoScript SliceProxy, extract the backing array
+      const meta = (cases as { __meta__?: { backing?: SelectCase[], offset?: number, length?: number } }).__meta__
+      if (meta && meta.backing) {
+        const offset = meta.offset ?? 0
+        const length = meta.length ?? meta.backing.length
+        selectCases = meta.backing.slice(offset, offset + length)
+      }
+    } else if (globalThis.Array.isArray(cases)) {
+      // This is a plain array (optimized case where offset=0 and length=capacity)
+      selectCases = cases as SelectCase[]
     }
   }
 
@@ -218,7 +231,8 @@ export function Select(cases: $.Slice<SelectCase>): [number, Value, boolean] {
     const selectCase = selectCases[i]
     if (selectCase.Dir.valueOf() === SelectRecv.valueOf() && selectCase.Chan) {
       const channelValue = selectCase.Chan
-      const channelObj = (channelValue as unknown as { value: any }).value
+      const channelObj = (channelValue as unknown as { value: unknown })
+        .value as ChannelObject
 
       // Check if there are queued values to receive
       if (
@@ -226,7 +240,7 @@ export function Select(cases: $.Slice<SelectCase>): [number, Value, boolean] {
         channelObj._sendQueue &&
         channelObj._sendQueue.length > 0
       ) {
-        const receivedValue = channelObj._sendQueue.shift() // Remove from queue
+        const receivedValue = channelObj._sendQueue.shift() as ReflectValue // Remove from queue
         const elemType = channelValue.Type().Elem()
         if (elemType) {
           const recvVal = new Value(receivedValue, elemType)

package/gs/reflect/visiblefields.ts

@@ -1,5 +1,5 @@
 import * as $ from '@goscript/builtin/builtin.js'
-import { Type } from './type.js'
+import { Type, Ptr, Struct } from './type.js'
 import { StructField } from './types.js'
 
 // VisibleFields returns all the visible fields in t, which must be a
@@ -127,20 +127,24 @@ class visibleFieldsWalker {
     }
     $.mapSet(w.visiting, t, true)
     for (let i = 0; i < t!.NumField!(); i++) {
-      let f = t!.Field!(i).clone()
-      f.Index = $.append(null, w.index) as number[]
-      if (f.Anonymous) {
-        if (f.Type!.Kind().valueOf() == 22) {
-          const elemType = f.Type!.Elem!()
-          if (elemType) {
-            f.Type = elemType
+      if (!t!.Field) continue
+      const field = t!.Field(i)
+      if (field) {
+        const f = field.clone()
+        f.Index = $.append(null, w.index) as number[]
+        if (f.Anonymous) {
+          if (f.Type && f.Type.Kind().valueOf() === Ptr.valueOf()) {
+            const elemType = f.Type.Elem!()
+            if (elemType) {
+              f.Type = elemType
+            }
           }
+          if (f.Type && f.Type.Kind().valueOf() === Struct.valueOf()) {
+            w.walk(f.Type)
+          }
+        } else {
+          w.fields = $.append(w.fields, f)
         }
-        if (f.Type!.Kind().valueOf() == 25) {
-          w.walk(f.Type)
-        }
-      } else {
-        w.fields = $.append(w.fields, f)
       }
     }
     $.deleteMapEntry(w.visiting, t)

package/gs/sort/godoc.txt

@@ -0,0 +1,27 @@
+package sort // import "sort"
+
+Package sort provides primitives for sorting slices and user-defined
+collections.
+
+func Find(n int, cmp func(int) int) (i int, found bool)
+func Float64s(x []float64)
+func Float64sAreSorted(x []float64) bool
+func Ints(x []int)
+func IntsAreSorted(x []int) bool
+func IsSorted(data Interface) bool
+func Search(n int, f func(int) bool) int
+func SearchFloat64s(a []float64, x float64) int
+func SearchInts(a []int, x int) int
+func SearchStrings(a []string, x string) int
+func Slice(x any, less func(i, j int) bool)
+func SliceIsSorted(x any, less func(i, j int) bool) bool
+func SliceStable(x any, less func(i, j int) bool)
+func Sort(data Interface)
+func Stable(data Interface)
+func Strings(x []string)
+func StringsAreSorted(x []string) bool
+type Float64Slice []float64
+type IntSlice []int
+type Interface interface{ ... }
+    func Reverse(data Interface) Interface
+type StringSlice []string

package/gs/sort/index.ts

@@ -0,0 +1,24 @@
+export {
+  Find,
+  Search,
+  SearchFloat64s,
+  SearchInts,
+  SearchStrings,
+} from './search.gs'
+export { Slice, SliceIsSorted, SliceStable } from './slice.gs'
+export {
+  Float64Slice,
+  Float64s,
+  Float64sAreSorted,
+  IntSlice,
+  Ints,
+  IntsAreSorted,
+  IsSorted,
+  Reverse,
+  Sort,
+  Stable,
+  StringSlice,
+  Strings,
+  StringsAreSorted,
+} from './sort.gs'
+export type { Interface } from './sort.gs'

package/gs/sort/search.gs.ts

@@ -0,0 +1,128 @@
+import * as $ from "@goscript/builtin/builtin.js";
+
+// Search uses binary search to find and return the smallest index i
+// in [0, n) at which f(i) is true, assuming that on the range [0, n),
+// f(i) == true implies f(i+1) == true. That is, Search requires that
+// f is false for some (possibly empty) prefix of the input range [0, n)
+// and then true for the (possibly empty) remainder; Search returns
+// the first true index. If there is no such index, Search returns n.
+// (Note that the "not found" return value is not -1 as in, for instance,
+// strings.Index.)
+// Search calls f(i) only for i in the range [0, n).
+//
+// A common use of Search is to find the index i for a value x in
+// a sorted, indexable data structure such as an array or slice.
+// In this case, the argument f, typically a closure, captures the value
+// to be searched for, and how the data structure is indexed and
+// ordered.
+//
+// For instance, given a slice data sorted in ascending order,
+// the call Search(len(data), func(i int) bool { return data[i] >= 23 })
+// returns the smallest index i such that data[i] >= 23. If the caller
+// wants to find whether 23 is in the slice, it must test data[i] == 23
+// separately.
+//
+// Searching data sorted in descending order would use the <=
+// operator instead of the >= operator.
+//
+// To complete the example above, the following code tries to find the value
+// x in an integer slice data sorted in ascending order:
+//
+//	x := 23
+//	i := sort.Search(len(data), func(i int) bool { return data[i] >= x })
+//	if i < len(data) && data[i] == x {
+//		// x is present at data[i]
+//	} else {
+//		// x is not present in data,
+//		// but i is the index where it would be inserted.
+//	}
+//
+// As a more whimsical example, this program guesses your number:
+//
+//	func GuessingGame() {
+//		var s string
+//		fmt.Printf("Pick an integer from 0 to 100.\n")
+//		answer := sort.Search(100, func(i int) bool {
+//			fmt.Printf("Is your number <= %d? ", i)
+//			fmt.Scanf("%s", &s)
+//			return s != "" && s[0] == 'y'
+//		})
+//		fmt.Printf("Your number is %d.\n", answer)
+//	}
+export function Search(n: number, f: (i: number) => boolean): number {
+	let left = 0
+	let right = n
+	while (left < right) {
+		const mid = Math.floor((left + right) / 2)
+		if (f(mid)) {
+			right = mid
+		} else {
+			left = mid + 1
+		}
+	}
+	return left
+}
+
+// Find uses binary search to find and return the smallest index i in [0, n)
+// at which cmp(i) <= 0. If there is no such index i, Find returns i = n.
+// The found result is true if i < n and cmp(i) == 0.
+// Find calls cmp(i) only for i in the range [0, n).
+//
+// To permit binary search, Find requires that cmp(i) > 0 for a leading
+// prefix of the range, cmp(i) == 0 in the middle, and cmp(i) < 0 for
+// the final suffix of the range. (Each subrange could be empty.)
+// The usual way to establish this condition is to interpret cmp(i)
+// as a comparison of a desired target value t against entry i in an
+// underlying indexed data structure x, returning <0, 0, and >0
+// when t < x[i], t == x[i], and t > x[i], respectively.
+//
+// For example, to look for a particular string in a sorted, random-access
+// list of strings:
+//
+//	i, found := sort.Find(x.Len(), func(i int) int {
+//	    return strings.Compare(target, x.At(i))
+//	})
+//	if found {
+//	    fmt.Printf("found %s at entry %d\n", target, i)
+//	} else {
+//	    fmt.Printf("%s not found, would insert at %d", target, i)
+//	}
+export function Find(n: number, cmp: (i: number) => number): [number, boolean] {
+	let left = 0
+	let right = n
+	while (left < right) {
+		const mid = Math.floor((left + right) / 2)
+		if (cmp(mid) <= 0) {
+			right = mid
+		} else {
+			left = mid + 1
+		}
+	}
+	const found = left < n && cmp(left) === 0
+	return [left, found]
+}
+
+// SearchInts searches for x in a sorted slice of ints and returns the index
+// as specified by Search. The return value is the index to insert x if x is
+// not present (it could be len(a)).
+// The slice must be sorted in ascending order.
+export function SearchInts(a: $.Slice<number>, x: number): number {
+	return Search($.len(a), (i: number) => ($.index(a, i) as number) >= x)
+}
+
+// SearchFloat64s searches for x in a sorted slice of float64s and returns the index
+// as specified by Search. The return value is the index to insert x if x is not
+// present (it could be len(a)).
+// The slice must be sorted in ascending order.
+export function SearchFloat64s(a: $.Slice<number>, x: number): number {
+	return Search($.len(a), (i: number) => ($.index(a, i) as number) >= x)
+}
+
+// SearchStrings searches for x in a sorted slice of strings and returns the index
+// as specified by Search. The return value is the index to insert x if x is not
+// present (it could be len(a)).
+// The slice must be sorted in ascending order.
+export function SearchStrings(a: $.Slice<string>, x: string): number {
+	return Search($.len(a), (i: number) => ($.index(a, i) as string) >= x)
+}
+

package/gs/sort/slice.gs.ts

@@ -0,0 +1,59 @@
+import * as $ from "../builtin/builtin.js";
+
+// Helper type for slice metadata
+interface SliceMetadata<T> {
+  backing: T[]
+  offset: number
+  length: number
+  capacity: number
+}
+
+// Helper function to swap elements in a slice
+function swapInSlice<T>(slice: $.Slice<T>, i: number, j: number): void {
+  if (!slice) return
+  
+  const temp = $.index(slice, i)
+  if (Array.isArray(slice)) {
+    const val_j = $.index(slice, j)
+    const val_i = temp
+    slice[i] = val_j as T
+    slice[j] = val_i as T
+  } else if (typeof slice === 'object' && '__meta__' in slice) {
+    const meta = (slice as any).__meta__ as SliceMetadata<T>
+    const backing = meta.backing
+    backing[meta.offset + i] = $.index(slice, j) as T
+    backing[meta.offset + j] = temp as T
+  }
+}
+
+// Slice sorts the slice x given the provided less function
+export function Slice(x: $.Slice<any>, less: (i: number, j: number) => boolean): void {
+  if (!x) return
+  
+  // Simple insertion sort using the provided less function
+  const n = $.len(x)
+  for (let i = 1; i < n; i++) {
+    for (let j = i; j > 0 && less(j, j - 1); j--) {
+      swapInSlice(x, j, j - 1)
+    }
+  }
+}
+
+// SliceIsSorted reports whether the slice x is sorted according to the provided less function
+export function SliceIsSorted(x: $.Slice<any>, less: (i: number, j: number) => boolean): boolean {
+  if (!x) return true
+  
+  const n = $.len(x)
+  for (let i = n - 1; i > 0; i--) {
+    if (less(i, i - 1)) {
+      return false
+    }
+  }
+  return true
+}
+
+// SliceStable sorts the slice x while keeping the original order of equal elements
+export function SliceStable(x: $.Slice<any>, less: (i: number, j: number) => boolean): void {
+  // For simplicity, use the same sort - can be improved later
+  Slice(x, less)
+}