goscript 0.0.36 → 0.0.38

package/gs/reflect/types.ts

@@ -0,0 +1,214 @@
+// Common types used throughout the reflect module
+
+// Basic Go types that need TypeScript equivalents
+export type uintptr = number
+
+// Define a proper type-safe Pointer type
+export interface UnsafePointer {
+  readonly __unsafePointerBrand: unique symbol
+  value: unknown
+}
+
+export type Pointer = UnsafePointer | null
+
+// Define the possible JavaScript values that can be reflected
+export type ReflectValue =
+  | null
+  | undefined
+  | boolean
+  | number
+  | bigint
+  | string
+  | symbol
+  | Function //eslint-disable-line @typescript-eslint/no-unsafe-function-type
+  | object
+  | unknown[]
+  | Map<unknown, unknown>
+  | Set<unknown>
+  | Uint8Array
+  | Int8Array
+  | Uint16Array
+  | Int16Array
+  | Uint32Array
+  | Int32Array
+  | 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'
+
+// Struct field representation
+export class StructField {
+  public Name: string = ''
+  public Type!: Type
+  public Tag?: StructTag
+  public Offset?: uintptr
+  public Index?: number[]
+  public Anonymous?: boolean
+
+  constructor(init?: Partial<StructField>) {
+    if (init) {
+      Object.assign(this, init)
+    }
+  }
+
+  public clone(): StructField {
+    return new StructField({
+      Name: this.Name,
+      Type: this.Type,
+      Tag: this.Tag,
+      Offset: this.Offset,
+      Index: this.Index ? [...this.Index] : undefined,
+      Anonymous: this.Anonymous,
+    })
+  }
+}
+
+// Struct tag type
+export class StructTag {
+  constructor(private _value: string) {}
+
+  toString(): string {
+    return this._value
+  }
+
+  Get(key: string): string {
+    // Simple tag parsing - in a real implementation this would be more sophisticated
+    const parts = this._value.split(' ')
+    for (const part of parts) {
+      if (part.startsWith(key + ':')) {
+        const value = part.substring(key.length + 1)
+        if (value.startsWith('"') && value.endsWith('"')) {
+          return value.slice(1, -1)
+        }
+        return value
+      }
+    }
+    return ''
+  }
+}
+
+// Method representation
+export interface Method {
+  Name: string
+  Type: Type
+  Func: Function //eslint-disable-line @typescript-eslint/no-unsafe-function-type
+  Index: number
+}
+
+// Channel type for reflection
+export interface Channel<T = unknown> {
+  readonly __channelBrand: unique symbol
+  direction: ChanDir
+  elementType: Type
+  buffer: T[]
+  closed: boolean
+}
+
+// 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
+}
+
+// Select direction constants
+export class SelectDir {
+  constructor(private _value: number) {}
+
+  valueOf(): number {
+    return this._value
+  }
+}
+
+export const SelectSend = new SelectDir(1)
+export const SelectRecv = new SelectDir(2)
+export const SelectDefault = new SelectDir(3)
+
+// Slice header (internal representation)
+export interface SliceHeader {
+  Data: uintptr
+  Len: number
+  Cap: number
+}
+
+// String header (internal representation)
+export interface StringHeader {
+  Data: uintptr
+  Len: number
+}
+
+// Map iterator with proper typing
+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
+  Next(): boolean
+  Reset(m: Map<K, V>): void
+}
+
+// Bit vector for tracking pointers
+export class bitVector {
+  private bits: number[] = []
+
+  Set(index: number): void {
+    const wordIndex = Math.floor(index / 32)
+    const bitIndex = index % 32
+    while (this.bits.length <= wordIndex) {
+      this.bits.push(0)
+    }
+    this.bits[wordIndex] |= 1 << bitIndex
+  }
+
+  Get(index: number): boolean {
+    const wordIndex = Math.floor(index / 32)
+    const bitIndex = index % 32
+    if (wordIndex >= this.bits.length) {
+      return false
+    }
+    return (this.bits[wordIndex] & (1 << bitIndex)) !== 0
+  }
+}
+
+// Value error type
+export class ValueError extends Error {
+  public Kind: Kind
+  public Method: string
+
+  constructor(init: { Kind: Kind; Method: string }) {
+    super(
+      `reflect: call of reflect.Value.${init.Method} on ${init.Kind.String()} Value`,
+    )
+    this.Kind = init.Kind
+    this.Method = init.Method
+    this.name = 'ValueError'
+  }
+}

package/gs/reflect/value.ts

@@ -0,0 +1,264 @@
+import {
+  Array,
+  Bool,
+  Float32,
+  Float64,
+  Int,
+  Int16,
+  Int32,
+  Int64,
+  Int8,
+  Map,
+  PointerTo,
+  Ptr,
+  Slice,
+  String,
+  Type,
+  Uint,
+  Uint16,
+  Uint32,
+  Uint64,
+  Uint8,
+  Uintptr,
+  Value,
+  Chan,
+  BasicType,
+  Invalid,
+} from './type.js'
+import { ReflectValue, SelectCase, SelectRecv, SelectDefault } from './types.js'
+import * as $ from '@goscript/builtin/builtin.js'
+
+// Re-export ValueOf from type.ts for compatibility
+export { ValueOf } from './type'
+
+// Zero returns a Value representing the zero value for the specified type.
+export function Zero(typ: Type): Value {
+  let zeroValue: ReflectValue
+
+  switch (typ.Kind().valueOf()) {
+    case Bool.valueOf():
+      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():
+      zeroValue = 0
+      break
+    case String.valueOf():
+      zeroValue = ''
+      break
+    case Slice.valueOf():
+    case Array.valueOf():
+      zeroValue = []
+      break
+    default:
+      zeroValue = null
+      break
+  }
+
+  return new Value(zeroValue, typ)
+}
+
+// Copy copies the contents of src to dst until either dst has been filled
+// or src has been exhausted. It returns the number of elements copied.
+export function Copy(dst: Value, src: Value): number {
+  // Extract the underlying arrays from the Value objects
+  const dstArray = getArrayFromValue(dst)
+  const srcArray = getArrayFromValue(src)
+
+  if (!dstArray || !srcArray) {
+    return 0
+  }
+
+  const count = Math.min(dstArray.length, srcArray.length)
+  for (let i = 0; i < count; i++) {
+    dstArray[i] = srcArray[i]
+  }
+  return count
+}
+
+// Helper function to extract the underlying array from a Value
+function getArrayFromValue(value: Value): unknown[] | null {
+  const val = (value as unknown as { value: ReflectValue }).value
+
+  // Check for GoScript slice objects created by $.arrayToSlice
+  if (val && typeof val === 'object' && '__meta__' in val) {
+    const meta = (val as { __meta__?: { backing?: unknown[] } }).__meta__
+    if (meta && meta.backing && globalThis.Array.isArray(meta.backing)) {
+      return meta.backing
+    }
+  }
+
+  // Check for regular JavaScript arrays
+  if (globalThis.Array.isArray(val)) {
+    return val
+  }
+
+  return null
+}
+
+// Indirect returns the value that v points to.
+export function Indirect(v: Value): Value {
+  // Check if this is a pointer type
+  const type = v.Type()
+  if (type.Kind().valueOf() === Ptr.valueOf()) {
+    // Ptr kind
+    const elemType = type.Elem()
+    if (elemType) {
+      // Return a new Value with the same underlying value but the element type
+      return new Value(
+        (v as unknown as { value: ReflectValue }).value,
+        elemType,
+      )
+    }
+  }
+  // For non-pointer types, just return the value as-is
+  return v
+}
+
+// New returns a Value representing a pointer to a new zero value for the specified type.
+export function New(typ: Type): Value {
+  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
+  return new Value(null, ptrType) // null represents the pointer 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()) {
+    throw new Error('reflect.MakeSlice of non-slice type')
+  }
+
+  // Create a slice with the specified length, filled with zero values
+  const elemType = typ.Elem()
+  if (!elemType) {
+    throw new Error('slice type missing element type')
+  }
+
+  const zeroValue = Zero(elemType)
+  const zeroVal = (zeroValue as unknown as { value: ReflectValue }).value
+  const array = new globalThis.Array(len).fill(zeroVal)
+
+  return new Value(array, typ)
+}
+
+// MakeMap returns a Value representing a new map with the specified type.
+export function MakeMap(typ: Type): Value {
+  if (typ.Kind().valueOf() !== Map.valueOf()) {
+    throw new Error('reflect.MakeMap of non-map type')
+  }
+
+  const map = new globalThis.Map()
+  return new Value(map, typ)
+}
+
+// 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()) {
+    throw new Error('reflect.Append of non-slice')
+  }
+
+  const array = getArrayFromValue(s)
+  if (!array) {
+    throw new Error('cannot get array from slice value')
+  }
+
+  const newValue = (x as unknown as { value: ReflectValue }).value
+  const newArray = [...array, newValue]
+
+  return new Value(newArray, s.Type())
+}
+
+// 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()) {
+    throw new Error('reflect.MakeChan of non-chan type')
+  }
+
+  const elemType = typ.Elem()
+  if (!elemType) {
+    throw new Error('channel type missing element type')
+  }
+
+  // Get the zero value for the channel element type
+  const zeroValue = Zero(elemType)
+  const zeroVal = (zeroValue as unknown as { value: ReflectValue }).value
+
+  // Create a channel using the builtin makeChannel function
+  const channel = $.makeChannel(buffer, zeroVal)
+  return new Value(channel, typ)
+}
+
+// Select executes a select operation on the provided cases.
+// It returns the index of the chosen case, the received value (if applicable), and whether the receive was successful.
+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
+    }
+  }
+
+  // Check for ready channels (channels with queued values)
+  for (let i = 0; i < selectCases.length; i++) {
+    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
+
+      // Check if there are queued values to receive
+      if (
+        channelObj &&
+        channelObj._sendQueue &&
+        channelObj._sendQueue.length > 0
+      ) {
+        const receivedValue = channelObj._sendQueue.shift() // Remove from queue
+        const elemType = channelValue.Type().Elem()
+        if (elemType) {
+          const recvVal = new Value(receivedValue, elemType)
+          return [i, recvVal, true]
+        }
+      }
+    }
+  }
+
+  // Look for default case if no channels are ready
+  for (let i = 0; i < selectCases.length; i++) {
+    const selectCase = selectCases[i]
+    if (selectCase.Dir.valueOf() === SelectDefault.valueOf()) {
+      // Default case is immediately available
+      return [i, new Value(null, new BasicType(Invalid, 'invalid')), false]
+    }
+  }
+
+  // If no channels are ready and no default case, return first case as fallback
+  if (selectCases.length > 0) {
+    const firstCase = selectCases[0]
+    if (firstCase.Dir.valueOf() === SelectRecv.valueOf() && firstCase.Chan) {
+      // Simulate receiving a zero value
+      const elemType = firstCase.Chan.Type().Elem()
+      if (elemType) {
+        const zeroVal = Zero(elemType)
+        return [0, zeroVal, true]
+      }
+    }
+    return [0, new Value(null, new BasicType(Invalid, 'invalid')), false]
+  }
+
+  // Fallback
+  return [0, new Value(null, new BasicType(Invalid, 'invalid')), false]
+}

package/gs/reflect/visiblefields.ts

@@ -0,0 +1,173 @@
+import * as $ from '@goscript/builtin/builtin.js'
+import { Type } from './type.js'
+import { StructField } from './types.js'
+
+// VisibleFields returns all the visible fields in t, which must be a
+// struct type. A field is defined as visible if it's accessible
+// directly with a FieldByName call. The returned fields include fields
+// inside anonymous struct members and unexported fields. They follow
+// the same order found in the struct, with anonymous fields followed
+// immediately by their promoted fields.
+//
+// For each element e of the returned slice, the corresponding field
+// can be retrieved from a value v of type t by calling v.FieldByIndex(e.Index).
+export function VisibleFields(t: Type): $.Slice<StructField> {
+  if (t == null) {
+    $.panic('reflect: VisibleFields(nil)')
+  }
+  if (t!.Kind().valueOf() != 25) {
+    $.panic('reflect.VisibleFields of non-struct type ' + t!.String())
+  }
+  let w = new visibleFieldsWalker({
+    byName: $.makeMap<string, number>(),
+    fields: $.makeSlice<StructField>(0, t!.NumField!()),
+    index: $.makeSlice<number>(0, 2, 'number'),
+    visiting: $.makeMap<Type, boolean>(),
+  })
+  w.walk(t)
+  // Remove all the fields that have been hidden.
+  // Use an in-place removal that avoids copying in
+  // the common case that there are no hidden fields.
+  let j = 0
+
+  // A field has been removed. We need to shuffle
+  // all the subsequent elements up.
+  for (let i = 0; i < $.len(w.fields); i++) {
+    {
+      let f = w.fields![i]
+      if (f!.Name == '') {
+        continue
+      }
+
+      // A field has been removed. We need to shuffle
+      // all the subsequent elements up.
+      if (i != j) {
+        // A field has been removed. We need to shuffle
+        // all the subsequent elements up.
+        w.fields![j] = f!.clone()
+      }
+      j++
+    }
+  }
+  return $.goSlice(w.fields, undefined, j)
+}
+
+class visibleFieldsWalker {
+  public get byName(): Map<string, number> {
+    return this._fields.byName.value
+  }
+  public set byName(value: Map<string, number>) {
+    this._fields.byName.value = value
+  }
+
+  public get visiting(): Map<Type, boolean> {
+    return this._fields.visiting.value
+  }
+  public set visiting(value: Map<Type, boolean>) {
+    this._fields.visiting.value = value
+  }
+
+  public get fields(): $.Slice<StructField> {
+    return this._fields.fields.value
+  }
+  public set fields(value: $.Slice<StructField>) {
+    this._fields.fields.value = value
+  }
+
+  public get index(): $.Slice<number> {
+    return this._fields.index.value
+  }
+  public set index(value: $.Slice<number>) {
+    this._fields.index.value = value
+  }
+
+  public _fields: {
+    byName: $.VarRef<Map<string, number>>
+    visiting: $.VarRef<Map<Type, boolean>>
+    fields: $.VarRef<$.Slice<StructField>>
+    index: $.VarRef<$.Slice<number>>
+  }
+
+  constructor(
+    init?: Partial<{
+      byName?: Map<string, number>
+      fields?: $.Slice<StructField>
+      index?: $.Slice<number>
+      visiting?: Map<Type, boolean>
+    }>,
+  ) {
+    this._fields = {
+      byName: $.varRef(init?.byName ?? $.makeMap<string, number>()),
+      visiting: $.varRef(init?.visiting ?? $.makeMap<Type, boolean>()),
+      fields: $.varRef(init?.fields ?? $.makeSlice<StructField>(0, 0)),
+      index: $.varRef(init?.index ?? $.makeSlice<number>(0, 2, 'number')),
+    }
+  }
+
+  public clone(): visibleFieldsWalker {
+    const cloned = new visibleFieldsWalker()
+    cloned._fields = {
+      byName: $.varRef(this._fields.byName.value),
+      visiting: $.varRef(this._fields.visiting.value),
+      fields: $.varRef(this._fields.fields.value),
+      index: $.varRef(this._fields.index.value),
+    }
+    return cloned
+  }
+
+  // walk walks all the fields in the struct type t, visiting
+  // fields in index preorder and appending them to w.fields
+  // (this maintains the required ordering).
+  // Fields that have been overridden have their
+  // Name field cleared.
+  public walk(t: Type): void {
+    const w = this
+    if ($.mapGet(w.visiting, t, false)[0]) {
+      return
+    }
+    $.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 (f.Type!.Kind().valueOf() == 25) {
+          w.walk(f.Type)
+        }
+      } else {
+        w.fields = $.append(w.fields, f)
+      }
+    }
+    $.deleteMapEntry(w.visiting, t)
+  }
+
+  // Register this type with the runtime type system
+  static __typeInfo = $.registerStructType(
+    'visibleFieldsWalker',
+    new visibleFieldsWalker(),
+    [{ name: 'walk', args: [{ name: 't', type: 'Type' }], returns: [] }],
+    visibleFieldsWalker,
+    {
+      byName: {
+        kind: $.TypeKind.Map,
+        keyType: { kind: $.TypeKind.Basic, name: 'string' },
+        elemType: { kind: $.TypeKind.Basic, name: 'number' },
+      },
+      visiting: {
+        kind: $.TypeKind.Map,
+        keyType: 'Type',
+        elemType: { kind: $.TypeKind.Basic, name: 'boolean' },
+      },
+      fields: { kind: $.TypeKind.Slice, elemType: 'StructField' },
+      index: {
+        kind: $.TypeKind.Slice,
+        elemType: { kind: $.TypeKind.Basic, name: 'number' },
+      },
+    },
+  )
+}

package/gs/strconv/index.ts

@@ -1,6 +1,39 @@
-export { AppendBool, FormatBool, ParseBool } from "./atob.gs.js"
-export { ParseFloat } from "./atof.gs.js"
-export { Atoi, ErrRange, ErrSyntax, IntSize, NumError, ParseInt, ParseUint } from "./atoi.gs.js"
-export { AppendFloat, FormatFloat } from "./ftoa.gs.js"
-export { AppendInt, AppendUint, FormatInt, FormatUint, Itoa } from "./itoa.gs.js"
-export { AppendQuote, AppendQuoteRune, AppendQuoteRuneToASCII, AppendQuoteRuneToGraphic, AppendQuoteToASCII, AppendQuoteToGraphic, CanBackquote, IsGraphic, IsPrint, Quote, QuoteRune, QuoteRuneToASCII, QuoteRuneToGraphic, QuoteToASCII, QuoteToGraphic, QuotedPrefix, Unquote, UnquoteChar } from "./quote.gs.js"
+export { AppendBool, FormatBool, ParseBool } from './atob.gs.js'
+export { ParseFloat } from './atof.gs.js'
+export {
+  Atoi,
+  ErrRange,
+  ErrSyntax,
+  IntSize,
+  NumError,
+  ParseInt,
+  ParseUint,
+} from './atoi.gs.js'
+export { AppendFloat, FormatFloat } from './ftoa.gs.js'
+export {
+  AppendInt,
+  AppendUint,
+  FormatInt,
+  FormatUint,
+  Itoa,
+} from './itoa.gs.js'
+export {
+  AppendQuote,
+  AppendQuoteRune,
+  AppendQuoteRuneToASCII,
+  AppendQuoteRuneToGraphic,
+  AppendQuoteToASCII,
+  AppendQuoteToGraphic,
+  CanBackquote,
+  IsGraphic,
+  IsPrint,
+  Quote,
+  QuoteRune,
+  QuoteRuneToASCII,
+  QuoteRuneToGraphic,
+  QuoteToASCII,
+  QuoteToGraphic,
+  QuotedPrefix,
+  Unquote,
+  UnquoteChar,
+} from './quote.gs.js'

package/gs/strings/index.ts

@@ -2,5 +2,11 @@ export * from './builder.js'
 export * from './strings.js'
 export * from './reader.js'
 export { Replacer, NewReplacer } from './replace.js'
-export { Lines, FieldsSeq, FieldsFuncSeq, SplitSeq, SplitAfterSeq } from './iter.js'
+export {
+  Lines,
+  FieldsSeq,
+  FieldsFuncSeq,
+  SplitSeq,
+  SplitAfterSeq,
+} from './iter.js'
 // Clone and Compare are already exported from strings.js, so we don't re-export them