goscript 0.0.48 → 0.0.50

package/gs/reflect/function-types.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import { TypeOf } from './type.js'
+import { TypeOf, Kind_String } from './type.js'
 
 describe('Function Type Detection', () => {
   it('should detect regular function types', () => {
@@ -8,7 +8,7 @@ describe('Function Type Detection', () => {
     }
     const type = TypeOf(regularFunc)
     expect(type.String()).toMatch(/^func/)
-    expect(type.Kind().String()).toBe('func')
+    expect(Kind_String(type.Kind())).toBe('func')
   })
 
   it('should detect GoScript typed functions with __goTypeName', () => {
@@ -19,7 +19,7 @@ describe('Function Type Detection', () => {
     Object.assign(greetFunc, { __goTypeName: 'Greeter' })
     const greetType = TypeOf(greetFunc)
     expect(greetType.String()).toBe('func(string) string')
-    expect(greetType.Kind().String()).toBe('func')
+    expect(Kind_String(greetType.Kind())).toBe('func')
 
     // Test Adder function type
     const addFunc = function (a: number, b: number) {
@@ -28,7 +28,7 @@ describe('Function Type Detection', () => {
     Object.assign(addFunc, { __goTypeName: 'Adder' })
     const addType = TypeOf(addFunc)
     expect(addType.String()).toBe('func(int, int) int')
-    expect(addType.Kind().String()).toBe('func')
+    expect(Kind_String(addType.Kind())).toBe('func')
   })
 
   it('should detect functions with full __typeInfo metadata', () => {
@@ -49,7 +49,7 @@ describe('Function Type Detection', () => {
 
     const type = TypeOf(complexFunc)
     expect(type.String()).toBe('func(int, int) int')
-    expect(type.Kind().String()).toBe('func')
+    expect(Kind_String(type.Kind())).toBe('func')
   })
 
   it('should handle functions with multiple return types', () => {
@@ -70,7 +70,7 @@ describe('Function Type Detection', () => {
 
     const type = TypeOf(multiReturnFunc)
     expect(type.String()).toBe('func() (int, string)')
-    expect(type.Kind().String()).toBe('func')
+    expect(Kind_String(type.Kind())).toBe('func')
   })
 
   it('should handle functions with no parameters', () => {
@@ -88,7 +88,7 @@ describe('Function Type Detection', () => {
 
     const type = TypeOf(noParamFunc)
     expect(type.String()).toBe('func() int')
-    expect(type.Kind().String()).toBe('func')
+    expect(Kind_String(type.Kind())).toBe('func')
   })
 
   it('should handle functions with no return type', () => {
@@ -106,7 +106,7 @@ describe('Function Type Detection', () => {
 
     const type = TypeOf(voidFunc)
     expect(type.String()).toBe('func(int)')
-    expect(type.Kind().String()).toBe('func')
+    expect(Kind_String(type.Kind())).toBe('func')
   })
 
   it('should fallback to generic func for unknown typed functions', () => {
@@ -117,14 +117,14 @@ describe('Function Type Detection', () => {
 
     const type = TypeOf(unknownFunc)
     expect(type.String()).toBe('func')
-    expect(type.Kind().String()).toBe('func')
+    expect(Kind_String(type.Kind())).toBe('func')
   })
 
   it('should handle arrow functions', () => {
     const arrowFunc = (x: number) => x * 2
     const type = TypeOf(arrowFunc)
     expect(type.String()).toMatch(/^func/)
-    expect(type.Kind().String()).toBe('func')
+    expect(Kind_String(type.Kind())).toBe('func')
   })
 
   it('should detect functions that return values vs void functions', () => {

package/gs/reflect/index.ts

@@ -3,15 +3,19 @@ export {
   TypeOf,
   ValueOf,
   Value,
-  Kind,
+  Kind_String,
   ArrayOf,
   SliceOf,
   PointerTo,
   PtrTo,
   MapOf,
   ChanOf,
+  ChanDir_String,
+  RecvDir,
+  SendDir,
+  BothDir,
 } from './type'
-export type { Type } from './type'
+export type { Type, ChanDir, Kind } from './type'
 export { DeepEqual } from './deepequal'
 export {
   Zero,
@@ -28,10 +32,6 @@ export { Swapper } from './swapper'
 
 // Export new types and constants
 export {
-  ChanDir,
-  RecvDir,
-  SendDir,
-  BothDir,
   StructTag,
   ValueError,
   SelectDir,

package/gs/reflect/map.ts

@@ -1,4 +1,4 @@
-import { Type, Kind, Value } from './type.js'
+import { Type, Kind, Value, Map as MapKind } from './type.js'
 
 // Simple MapOf implementation using JavaScript Map
 export function MapOf(key: Type, elem: Type): Type {
@@ -17,7 +17,7 @@ class MapType implements Type {
   }
 
   public Kind(): Kind {
-    return new Kind(21) // Map kind
+    return MapKind // Map kind
   }
 
   public Size(): number {

package/gs/reflect/meta.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": [
+    "iter"
+  ]
+} 

package/gs/reflect/type.ts

@@ -1,4 +1,4 @@
-import { ReflectValue, ChanDir, StructField } from './types.js'
+import { ReflectValue, StructField } from './types.js'
 import { MapIter } from './map.js'
 
 // rtype is the common implementation of most values
@@ -10,18 +10,12 @@ export class rtype {
   }
 
   String(): string {
-    return this.kind.String()
+    return Kind_String(this.kind)
   }
 
   Pointers(): boolean {
-    // Return true for pointer-like types
-    const k = this.kind.valueOf()
-    return (
-      k === Ptr.valueOf() ||
-      k === Map.valueOf() ||
-      k === Slice.valueOf() ||
-      k === Interface.valueOf()
-    )
+    const k = this.kind
+    return k === Ptr || k === Map || k === Slice || k === Interface
   }
 }
 
@@ -42,15 +36,14 @@ export class flag {
     if (typeof _value === 'number') {
       this._value = _value
     } else {
-      this._value = _value.valueOf()
+      this._value = _value
     }
   }
 
   valueOf(): number {
-    return typeof this._value === 'number' ? this._value : this._value.valueOf()
+    return typeof this._value === 'number' ? this._value : this._value
   }
 
-  // Support arithmetic operations
   static from(value: number | Kind): flag {
     return new flag(value)
   }
@@ -80,86 +73,93 @@ export class bitVector {
 }
 
 // Kind represents the specific kind of type that a Type represents.
-export class Kind {
-  constructor(private _value: number) {}
-
-  valueOf(): number {
-    return this._value
-  }
-
-  toString(): string {
-    return this.String()
-  }
-
-  static from(value: number): Kind {
-    return new Kind(value)
-  }
+export type Kind = number
+
+// Kind_String returns the string representation of a Kind (wrapper function naming)
+export function Kind_String(k: Kind): string {
+  const kindNames = [
+    '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',
+    'unsafe.Pointer',
+  ]
+  if (k >= 0 && k < kindNames.length) {
+    return kindNames[k]
+  }
+  return 'invalid'
+}
 
-  public String(): string {
-    const kindNames = [
-      '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',
-      'unsafe.Pointer',
-    ]
-    if (this._value >= 0 && this._value < kindNames.length) {
-      return kindNames[this._value]
-    }
-    return 'invalid'
+// Channel direction constants and type
+export type ChanDir = number
+
+export const RecvDir: ChanDir = 1
+export const SendDir: ChanDir = 2
+export const BothDir: ChanDir = 3
+
+export function ChanDir_String(d: ChanDir): string {
+  switch (d) {
+    case RecvDir:
+      return 'RecvDir'
+    case SendDir:
+      return 'SendDir'
+    case BothDir:
+      return 'BothDir'
+    default:
+      return 'ChanDir(' + d + ')'
   }
 }
 
 // Kind constants
-export const Invalid = new Kind(0)
-export const Bool = new Kind(1)
-export const Int = new Kind(2)
-export const Int8 = new Kind(3)
-export const Int16 = new Kind(4)
-export const Int32 = new Kind(5)
-export const Int64 = new Kind(6)
-export const Uint = new Kind(7)
-export const Uint8 = new Kind(8)
-export const Uint16 = new Kind(9)
-export const Uint32 = new Kind(10)
-export const Uint64 = new Kind(11)
-export const Uintptr = new Kind(12)
-export const Float32 = new Kind(13)
-export const Float64 = new Kind(14)
-export const Complex64 = new Kind(15)
-export const Complex128 = new Kind(16)
-export const Array = new Kind(17)
-export const Chan = new Kind(18)
-export const Func = new Kind(19)
-export const Interface = new Kind(20)
-export const Map = new Kind(21)
-export const Ptr = new Kind(22)
-export const Slice = new Kind(23)
-export const String = new Kind(24)
-export const Struct = new Kind(25)
-export const UnsafePointer = new Kind(26)
+export const Invalid: Kind = 0
+export const Bool: Kind = 1
+export const Int: Kind = 2
+export const Int8: Kind = 3
+export const Int16: Kind = 4
+export const Int32: Kind = 5
+export const Int64: Kind = 6
+export const Uint: Kind = 7
+export const Uint8: Kind = 8
+export const Uint16: Kind = 9
+export const Uint32: Kind = 10
+export const Uint64: Kind = 11
+export const Uintptr: Kind = 12
+export const Float32: Kind = 13
+export const Float64: Kind = 14
+export const Complex64: Kind = 15
+export const Complex128: Kind = 16
+export const Array: Kind = 17
+export const Chan: Kind = 18
+export const Func: Kind = 19
+export const Interface: Kind = 20
+export const Map: Kind = 21
+export const Ptr: Kind = 22
+export const Slice: Kind = 23
+export const String: Kind = 24
+export const Struct: Kind = 25
+export const UnsafePointer: Kind = 26
 
 // Type is the representation of a Go type.
 export interface Type {
@@ -206,7 +206,7 @@ export class Value {
     }
     throw new Error(
       'reflect: call of reflect.Value.Int on ' +
-        this._type.Kind().String() +
+        Kind_String(this._type.Kind()) +
         ' Value',
     )
   }
@@ -217,7 +217,7 @@ export class Value {
     }
     throw new Error(
       'reflect: call of reflect.Value.Uint on ' +
-        this._type.Kind().String() +
+        Kind_String(this._type.Kind()) +
         ' Value',
     )
   }
@@ -228,7 +228,7 @@ export class Value {
     }
     throw new Error(
       'reflect: call of reflect.Value.Float on ' +
-        this._type.Kind().String() +
+        Kind_String(this._type.Kind()) +
         ' Value',
     )
   }
@@ -239,7 +239,7 @@ export class Value {
     }
     throw new Error(
       'reflect: call of reflect.Value.Bool on ' +
-        this._type.Kind().String() +
+        Kind_String(this._type.Kind()) +
         ' Value',
     )
   }
@@ -249,7 +249,7 @@ export class Value {
       return this._value
     }
     // Special case for bool values - display as <bool Value>
-    if (this._type.Kind().valueOf() === Bool.valueOf()) {
+    if (this._type.Kind() === Bool) {
       return '<bool Value>'
     }
     return this._type.String()
@@ -294,7 +294,7 @@ export class Value {
 
     throw new Error(
       'reflect: call of reflect.Value.Len on ' +
-        this._type.Kind().String() +
+        Kind_String(this._type.Kind()) +
         ' Value',
     )
   }
@@ -321,7 +321,7 @@ export class Value {
     }
     throw new Error(
       'reflect: call of reflect.Value.Index on ' +
-        this._type.Kind().String() +
+        Kind_String(this._type.Kind()) +
         ' Value',
     )
   }
@@ -332,7 +332,7 @@ export class Value {
     }
     throw new Error(
       'reflect: call of reflect.Value.Bytes on ' +
-        this._type.Kind().String() +
+        Kind_String(this._type.Kind()) +
         ' Value',
     )
   }
@@ -401,7 +401,7 @@ export class Value {
 
   // Send sends a value to a channel
   public Send(x: Value): void {
-    if (this._type.Kind().valueOf() !== Chan.valueOf()) {
+    if (this._type.Kind() !== Chan) {
       throw new Error('reflect: send on non-chan type')
     }
 
@@ -711,12 +711,12 @@ class ChannelType implements Type {
   public String(): string {
     // Format: chan T, <-chan T, or chan<- T
     const elem = this._elemType.String()
-    switch (this._dir.valueOf()) {
-      case 1: // RecvDir
+    switch (this._dir) {
+      case RecvDir:
         return `<-chan ${elem}`
-      case 2: // SendDir
+      case SendDir:
         return `chan<- ${elem}`
-      case 3: // BothDir
+      case BothDir:
       default:
         return `chan ${elem}`
     }
@@ -995,13 +995,13 @@ export function ChanOf(dir: ChanDir, t: Type): Type {
 
 // Additional functions from merged files
 export function canRangeFunc(t: Type): boolean {
-  const kind = t.Kind().valueOf()
-  return kind === 23 || kind === 17 || kind === 24 // slice, array, string
+  const kind = t.Kind()
+  return kind === Slice || kind === Array || kind === String
 }
 
 export function canRangeFunc2(t: Type): boolean {
-  const kind = t.Kind().valueOf()
-  return kind === 21 // map
+  const kind = t.Kind()
+  return kind === Map
 }
 
 export function funcLayout(

package/gs/reflect/types.ts

@@ -34,34 +34,8 @@ export type ReflectValue =
   | Float32Array
   | Float64Array
 
-// Channel direction constants and type
-export class ChanDir {
-  constructor(private _value: number) {}
-
-  valueOf(): number {
-    return this._value
-  }
-
-  toString(): string {
-    switch (this._value) {
-      case 1:
-        return 'RecvDir'
-      case 2:
-        return 'SendDir'
-      case 3:
-        return 'BothDir'
-      default:
-        return 'InvalidDir'
-    }
-  }
-}
-
-export const RecvDir = new ChanDir(1)
-export const SendDir = new ChanDir(2)
-export const BothDir = new ChanDir(3)
-
 // Import Type and Kind from the main type module
-import { Type, Kind, Value } from './type.js'
+import { Type, Kind, Value, Kind_String, ChanDir } from './type.js'
 
 // Struct field representation
 export class StructField {
@@ -205,7 +179,7 @@ export class ValueError extends Error {
 
   constructor(init: { Kind: Kind; Method: string }) {
     super(
-      `reflect: call of reflect.Value.${init.Method} on ${init.Kind.String()} Value`,
+      `reflect: call of reflect.Value.${init.Method} on ${Kind_String(init.Kind)} Value`,
     )
     this.Kind = init.Kind
     this.Method = init.Method

package/gs/reflect/value.ts

@@ -40,30 +40,30 @@ export { ValueOf } from './type'
 export function Zero(typ: Type): Value {
   let zeroValue: ReflectValue
 
-  switch (typ.Kind().valueOf()) {
-    case Bool.valueOf():
+  switch (typ.Kind()) {
+    case Bool:
       zeroValue = false
       break
-    case Int.valueOf():
-    case Int8.valueOf():
-    case Int16.valueOf():
-    case Int32.valueOf():
-    case Int64.valueOf():
-    case Uint.valueOf():
-    case Uint8.valueOf():
-    case Uint16.valueOf():
-    case Uint32.valueOf():
-    case Uint64.valueOf():
-    case Uintptr.valueOf():
-    case Float32.valueOf():
-    case Float64.valueOf():
+    case Int:
+    case Int8:
+    case Int16:
+    case Int32:
+    case Int64:
+    case Uint:
+    case Uint8:
+    case Uint16:
+    case Uint32:
+    case Uint64:
+    case Uintptr:
+    case Float32:
+    case Float64:
       zeroValue = 0
       break
-    case String.valueOf():
+    case String:
       zeroValue = ''
       break
-    case Slice.valueOf():
-    case Array.valueOf():
+    case Slice:
+    case Array:
       zeroValue = []
       break
     default:
@@ -116,7 +116,7 @@ function getArrayFromValue(value: Value): unknown[] | null {
 export function Indirect(v: Value): Value {
   // Check if this is a pointer type
   const type = v.Type()
-  if (type.Kind().valueOf() === Ptr.valueOf()) {
+  if (type.Kind() === Ptr) {
     // Ptr kind
     const elemType = type.Elem()
     if (elemType) {
@@ -141,7 +141,7 @@ 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().valueOf() !== Slice.valueOf()) {
+  if (typ.Kind() !== Slice) {
     throw new Error('reflect.MakeSlice of non-slice type')
   }
 
@@ -160,7 +160,7 @@ 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().valueOf() !== Map.valueOf()) {
+  if (typ.Kind() !== Map) {
     throw new Error('reflect.MakeMap of non-map type')
   }
 
@@ -170,7 +170,7 @@ export function MakeMap(typ: Type): Value {
 
 // Append appends the values x to a slice and returns the resulting slice.
 export function Append(s: Value, x: Value): Value {
-  if (s.Kind().valueOf() !== Slice.valueOf()) {
+  if (s.Kind() !== Slice) {
     throw new Error('reflect.Append of non-slice')
   }
 
@@ -187,7 +187,7 @@ export function Append(s: Value, x: Value): Value {
 
 // MakeChan returns a Value representing a new channel with the specified type.
 export function MakeChan(typ: Type, buffer: number): Value {
-  if (typ.Kind().valueOf() !== Chan.valueOf()) {
+  if (typ.Kind() !== Chan) {
     throw new Error('reflect.MakeChan of non-chan type')
   }
 

package/gs/reflect/visiblefields.ts

@@ -15,7 +15,7 @@ export function VisibleFields(t: Type): $.Slice<StructField> {
   if (t == null) {
     $.panic('reflect: VisibleFields(nil)')
   }
-  if (t!.Kind().valueOf() != 25) {
+  if (t!.Kind() != 25) {
     $.panic('reflect.VisibleFields of non-struct type ' + t!.String())
   }
   let w = new visibleFieldsWalker({
@@ -133,13 +133,13 @@ class visibleFieldsWalker {
         const f = field.clone()
         f.Index = $.append(null, w.index) as number[]
         if (f.Anonymous) {
-          if (f.Type && f.Type.Kind().valueOf() === Ptr.valueOf()) {
+          if (f.Type && f.Type.Kind() === Ptr) {
             const elemType = f.Type.Elem!()
             if (elemType) {
               f.Type = elemType
             }
           }
-          if (f.Type && f.Type.Kind().valueOf() === Struct.valueOf()) {
+          if (f.Type && f.Type.Kind() === Struct) {
             w.walk(f.Type)
           }
         } else {

package/gs/strconv/meta.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": [
+    "errors"
+  ]
+} 

package/gs/strings/meta.json

@@ -0,0 +1,9 @@
+{
+  "dependencies": [
+    "errors",
+    "io",
+    "iter",
+    "unicode",
+    "unicode/utf8"
+  ]
+} 

package/gs/sync/meta.json

@@ -0,0 +1,19 @@
+{
+  "dependencies": [
+    "unsafe"
+  ],
+  "asyncMethods": {
+    "Mutex.Lock": true,
+    "RWMutex.Lock": true,
+    "RWMutex.RLock": true,
+    "WaitGroup.Wait": true,
+    "Once.Do": true,
+    "Cond.Wait": true,
+    "Map.Delete": true,
+    "Map.Load": true,
+    "Map.LoadAndDelete": true,
+    "Map.LoadOrStore": true,
+    "Map.Range": true,
+    "Map.Store": true
+  }
+}