goscript 0.0.37 → 0.0.39

package/gs/reflect/index.ts

@@ -0,0 +1,83 @@
+// Export the main reflect functions organized like Go stdlib
+export {
+  TypeOf,
+  ValueOf,
+  Value,
+  Kind,
+  ArrayOf,
+  SliceOf,
+  PointerTo,
+  PtrTo,
+  MapOf,
+  ChanOf,
+} from './type'
+export type { Type } from './type'
+export { DeepEqual } from './deepequal'
+export {
+  Zero,
+  Copy,
+  Indirect,
+  New,
+  MakeSlice,
+  MakeMap,
+  Append,
+  MakeChan,
+  Select,
+} from './value'
+export { Swapper } from './swapper'
+
+// Export new types and constants
+export {
+  ChanDir,
+  RecvDir,
+  SendDir,
+  BothDir,
+  StructTag,
+  ValueError,
+  SelectDir,
+  SelectSend,
+  SelectRecv,
+  SelectDefault,
+  bitVector,
+} from './types'
+export type {
+  uintptr,
+  Pointer,
+  StructField,
+  Method,
+  SelectCase,
+  SliceHeader,
+  StringHeader,
+  MapIter,
+} from './types'
+
+// Export kind constants
+export {
+  Invalid,
+  Bool,
+  Int,
+  Int8,
+  Int16,
+  Int32,
+  Int64,
+  Uint,
+  Uint8,
+  Uint16,
+  Uint32,
+  Uint64,
+  Uintptr,
+  Float32,
+  Float64,
+  Complex64,
+  Complex128,
+  Array,
+  Chan,
+  Func,
+  Interface,
+  Map,
+  Ptr,
+  Slice,
+  String,
+  Struct,
+  UnsafePointer,
+} from './type'

package/gs/reflect/iter.ts

@@ -0,0 +1,44 @@
+import { Type, Value } from './type.js'
+import { uintptr } from './types.js'
+import { ValueOf } from './value.js'
+
+import * as iter from '@goscript/iter/index.js'
+
+export function rangeNum<
+  T extends
+    | number
+    | number
+    | number
+    | number
+    | number
+    | number
+    | number
+    | number
+    | number
+    | number
+    | uintptr,
+  N extends number | number,
+>(num: N, t: Type): iter.Seq<Value> {
+  // cannot use range T(v) because no core type.
+
+  // if the iteration value type is define by
+  // type T built-in type.
+  return (_yield: ((v: Value) => boolean) | null): void => {
+    let convert = t!.PkgPath!() != ''
+    // cannot use range T(v) because no core type.
+
+    // if the iteration value type is define by
+    // type T built-in type.
+    for (let i = 0 as unknown as T; i < (num as unknown as T); i++) {
+      let tmp = ValueOf(i).clone()
+      // if the iteration value type is define by
+      // type T built-in type.
+      if (convert) {
+        tmp = tmp.Convert(t).clone()
+      }
+      if (!_yield!(tmp)) {
+        return
+      }
+    }
+  }
+}

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

@@ -0,0 +1,85 @@
+import { Type, Kind, Value } from './type.js'
+
+// Simple MapOf implementation using JavaScript Map
+export function MapOf(key: Type, elem: Type): Type {
+  return new MapType(key, elem)
+}
+
+// Simple map type implementation
+class MapType implements Type {
+  constructor(
+    private _keyType: Type,
+    private _elemType: Type,
+  ) {}
+
+  public String(): string {
+    return `map[${this._keyType.String()}]${this._elemType.String()}`
+  }
+
+  public Kind(): Kind {
+    return new Kind(21) // Map kind
+  }
+
+  public Size(): number {
+    return 8 // pointer size
+  }
+
+  public Elem(): Type | null {
+    return this._elemType
+  }
+
+  public Key(): Type | null {
+    return this._keyType
+  }
+
+  public NumField(): number {
+    return 0
+  }
+}
+
+/**
+ * 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.current = this.iterator.next()
+    return !this.current.done
+  }
+
+  public Key(): K | null {
+    return this.current?.value?.[0] ?? null
+  }
+
+  public Value(): V | null {
+    return this.current?.value?.[1] ?? null
+  }
+
+  public Reset(m: Map<K, V>): void {
+    this.map = m
+    this.iterator = m.entries()
+    this.current = null
+    this.Next()
+  }
+}
+
+// Helper functions for map operations
+export function MakeMap(typ: Type): Value {
+  const map = new Map()
+  return new Value(map, typ)
+}
+
+export function MakeMapWithSize(typ: Type, _n: number): Value {
+  // JavaScript Map doesn't have initial size, so we ignore n
+  return MakeMap(typ)
+}

package/gs/reflect/swapper.ts

@@ -0,0 +1,52 @@
+import { ReflectValue } from './types'
+
+// Swapper returns a function that swaps the elements in the provided slice.
+// Swapper panics if the provided interface is not a slice.
+export function Swapper(slice: ReflectValue): (i: number, j: number) => void {
+  let actualArray: unknown[] | null = null
+
+  // Try to extract the underlying array
+  if (Array.isArray(slice)) {
+    actualArray = slice
+  } else if (slice && typeof slice === 'object' && '__meta__' in slice) {
+    // GoScript slice object
+    const meta = (slice as { __meta__?: { backing?: unknown[] } }).__meta__
+    if (meta && meta.backing && Array.isArray(meta.backing)) {
+      actualArray = meta.backing
+    }
+  }
+
+  if (!actualArray) {
+    // Return a no-op function if we can't extract an array
+    return () => {}
+  }
+
+  // Fast path for slices of size 0 and 1. Nothing to swap.
+  switch (actualArray.length) {
+    case 0:
+      return (_i: number, _j: number): void => {
+        throw new Error('reflect: slice index out of range')
+      }
+    case 1:
+      return (i: number, j: number): void => {
+        if (i !== 0 || j !== 0) {
+          throw new Error('reflect: slice index out of range')
+        }
+      }
+  }
+
+  // Return the swapper function
+  return (i: number, j: number) => {
+    if (
+      actualArray &&
+      i >= 0 &&
+      j >= 0 &&
+      i < actualArray.length &&
+      j < actualArray.length
+    ) {
+      const temp = actualArray[i]
+      actualArray[i] = actualArray[j]
+      actualArray[j] = temp
+    }
+  }
+}