goscript 0.0.84 → 0.1.1

package/gs/context/context.ts

@@ -1,17 +1,18 @@
 import * as $ from '@goscript/builtin/index.js'
+import * as time from '@goscript/time/index.js'
 
 export const Canceled = $.newError('context canceled')
 
 export const DeadlineExceeded = $.newError('context deadline exceeded')
 
 // Function types
-export type CancelFunc = () => void
+export type CancelFunc = (() => void) | null
 export type CancelCauseFunc = (cause: $.GoError) => void
 
 // Context interface matching Go's context.Context
 export type Context = null | {
   // Deadline returns the time when work done on behalf of this context should be canceled
-  Deadline(): [Date | null, boolean]
+  Deadline(): [time.Time, boolean]
 
   // Done returns a channel that's closed when work done on behalf of this context should be canceled
   Done(): $.Channel<{}>
@@ -28,7 +29,7 @@ export type ContextNonNil = Exclude<Context, null>
 
 // Base implementation for all contexts
 abstract class baseContext implements ContextNonNil {
-  abstract Deadline(): [Date | null, boolean]
+  abstract Deadline(): [time.Time, boolean]
   abstract Done(): $.Channel<{}>
   abstract Err(): $.GoError
   abstract Value(key: any): any
@@ -42,8 +43,8 @@ class backgroundContext extends baseContext {
     return backgroundContext.neverClosedChannel
   }
 
-  Deadline(): [Date | null, boolean] {
-    return [null, false]
+  Deadline(): [time.Time, boolean] {
+    return [new time.Time(), false]
   }
 
   Done(): $.Channel<{}> {
@@ -73,7 +74,7 @@ class valueContext extends baseContext {
     return this.parent
   }
 
-  Deadline(): [Date | null, boolean] {
+  Deadline(): [time.Time, boolean] {
     return this.parent.Deadline()
   }
 
@@ -109,7 +110,7 @@ class cancelContext extends baseContext {
     this.doneChannel = $.makeChannel<{}>(0, {}, 'both')
   }
 
-  Deadline(): [Date | null, boolean] {
+  Deadline(): [time.Time, boolean] {
     return this.parent.Deadline()
   }
 
@@ -195,21 +196,20 @@ class cancelContext extends baseContext {
 
 // Timer context with deadline
 class timerContext extends cancelContext {
-  private deadline: Date
+  private deadline: time.Time
   private timer: any
 
-  constructor(parent: ContextNonNil, deadline: Date) {
+  constructor(parent: ContextNonNil, deadline: time.Time) {
     super(parent)
-    this.deadline = deadline
+    this.deadline = deadline.clone()
   }
 
-  Deadline(): [Date | null, boolean] {
-    return [this.deadline, true]
+  Deadline(): [time.Time, boolean] {
+    return [this.deadline.clone(), true]
   }
 
   startTimer(): void {
-    const now = Date.now()
-    const duration = this.deadline.getTime() - now
+    const duration = this.deadline.Sub(time.Now()) / 1000000
 
     if (duration <= 0) {
       // Already expired
@@ -237,8 +237,8 @@ class withoutCancelContext extends baseContext {
     super()
   }
 
-  Deadline(): [Date | null, boolean] {
-    return [null, false]
+  Deadline(): [time.Time, boolean] {
+    return [new time.Time(), false]
   }
 
   Done(): $.Channel<{}> {
@@ -305,7 +305,7 @@ export function WithCancelCause(
 // WithDeadline returns a copy of parent with the deadline adjusted to be no later than d
 export function WithDeadline(
   parent: Context,
-  d: Date,
+  d: time.Time,
 ): [ContextNonNil, CancelFunc] {
   return WithDeadlineCause(parent, d, null)
 }
@@ -313,7 +313,7 @@ export function WithDeadline(
 // WithDeadlineCause is like WithDeadline but also sets the cause
 export function WithDeadlineCause(
   parent: Context,
-  d: Date,
+  d: time.Time,
   cause: $.GoError,
 ): [ContextNonNil, CancelFunc] {
   if (parent === null) {
@@ -321,7 +321,7 @@ export function WithDeadlineCause(
   }
   // Check if parent deadline is already earlier
   const [parentDeadline, ok] = parent.Deadline()
-  if (ok && parentDeadline && parentDeadline <= d) {
+  if (ok && (parentDeadline.Before(d) || parentDeadline.Equal(d))) {
     // Parent deadline is already sooner
     return WithCancel(parent)
   }
@@ -343,7 +343,7 @@ export function WithTimeout(
   parent: Context,
   timeout: number,
 ): [ContextNonNil, CancelFunc] {
-  return WithDeadline(parent, new Date(Date.now() + timeout / 1000000))
+  return WithDeadline(parent, time.Now().Add(timeout))
 }
 
 // WithTimeoutCause is like WithTimeout but also sets the cause
@@ -352,11 +352,7 @@ export function WithTimeoutCause(
   timeout: number,
   cause: $.GoError,
 ): [ContextNonNil, CancelFunc] {
-  return WithDeadlineCause(
-    parent,
-    new Date(Date.now() + timeout / 1000000),
-    cause,
-  )
+  return WithDeadlineCause(parent, time.Now().Add(timeout), cause)
 }
 
 // WithValue returns a copy of parent with the value associated with key
@@ -409,7 +405,7 @@ export function AfterFunc(ctx: Context, f: () => void): () => boolean {
     if (!stopped) {
       done = true
       // Run in next tick to simulate goroutine
-      setImmediate(f)
+      queueMicrotask(f)
     }
   })()
 

package/gs/crypto/internal/fips140deps/byteorder/index.ts

@@ -0,0 +1 @@
+export * from '@goscript/internal/byteorder/index.js'

package/gs/crypto/internal/fips140deps/godebug/index.ts

@@ -0,0 +1 @@
+export { New, Setting, Value } from '@goscript/internal/godebug/index.js'

package/gs/crypto/rand/index.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import { Read, Reader, Text } from './index.js'
+
+describe('crypto/rand override', () => {
+  it('fills byte slices from Web Crypto', () => {
+    const buf = new Uint8Array(32)
+    const [n, err] = Read(buf)
+
+    expect(err).toBeNull()
+    expect(n).toBe(32)
+    expect(buf.some((b) => b !== 0)).toBe(true)
+  })
+
+  it('exposes Reader as an io.Reader-compatible source', () => {
+    const buf = $.makeSlice<number>(12, 12, 'byte')
+    const [n, err] = Reader.Read(buf)
+
+    expect(err).toBeNull()
+    expect(n).toBe(12)
+    expect(Array.from(buf ?? []).some((b) => b !== 0)).toBe(true)
+  })
+
+  it('generates base32 text tokens', () => {
+    const token = Text()
+
+    expect(token).toHaveLength(26)
+    expect(token).toMatch(/^[A-Z2-7]+$/)
+  })
+})

package/gs/crypto/rand/index.ts

@@ -0,0 +1,90 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as io from '@goscript/io/index.js'
+
+const base32alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'
+const maxGetRandomValuesBytes = 65536
+
+class RandError {
+  constructor(private readonly message: string) {}
+
+  Error(): string {
+    return this.message
+  }
+}
+
+class WebCryptoReader implements io.Reader {
+  Read(p: $.Bytes): [number, $.GoError] {
+    const err = fillSecureBytes(p)
+    if (err != null) {
+      return [0, err]
+    }
+    return [$.len(p), null]
+  }
+}
+
+export let Reader: io.Reader = new WebCryptoReader()
+
+export function Read(b: $.Bytes): [number, $.GoError] {
+  const [n, err] = Reader.Read(b)
+  if (err != null) {
+    return [n, err]
+  }
+  if (n !== $.len(b)) {
+    return [n, io.ErrUnexpectedEOF]
+  }
+  return [n, null]
+}
+
+export function Text(): string {
+  const src = new Uint8Array(26)
+  const [, err] = Read(src)
+  if (err != null) {
+    throw new Error(err.Error())
+  }
+
+  let out = ''
+  for (const b of src) {
+    out += base32alphabet[b % 32]
+  }
+  return out
+}
+
+function fillSecureBytes(dst: $.Bytes): $.GoError {
+  const length = $.len(dst)
+  if (length === 0) {
+    return null
+  }
+
+  const crypto = secureCrypto()
+  if (crypto == null) {
+    return new RandError('crypto/rand: Web Crypto getRandomValues is unavailable')
+  }
+
+  if (dst instanceof Uint8Array) {
+    fillUint8Array(crypto, dst)
+    return null
+  }
+
+  const tmp = new Uint8Array(length)
+  fillUint8Array(crypto, tmp)
+  $.copy(dst, tmp)
+  return null
+}
+
+function fillUint8Array(crypto: Crypto, dst: Uint8Array): void {
+  for (let offset = 0; offset < dst.length; offset += maxGetRandomValuesBytes) {
+    const chunk = dst.subarray(
+      offset,
+      Math.min(offset + maxGetRandomValuesBytes, dst.length),
+    ) as Uint8Array<ArrayBuffer>
+    crypto.getRandomValues(chunk)
+  }
+}
+
+function secureCrypto(): Crypto | null {
+  const crypto = globalThis.crypto
+  if (crypto && typeof crypto.getRandomValues === 'function') {
+    return crypto
+  }
+  return null
+}

package/gs/crypto/rand/meta.json

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

package/gs/embed/index.ts

@@ -0,0 +1,20 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as fs from '@goscript/io/fs/index.js'
+
+export class FS {
+  Open(name: string): [fs.File, $.GoError] {
+    return [null, pathError('open', name)]
+  }
+
+  ReadDir(name: string): [$.Slice<fs.DirEntry>, $.GoError] {
+    return [null, pathError('read', name)]
+  }
+
+  ReadFile(name: string): [Uint8Array, $.GoError] {
+    return [new Uint8Array(0), pathError('read', name)]
+  }
+}
+
+function pathError(op: string, name: string): $.GoError {
+  return new fs.PathError({ Op: op, Path: name, Err: fs.ErrNotExist })
+}

package/gs/embed/meta.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": [
+    "io/fs"
+  ]
+}

package/gs/encoding/json/index.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import { Marshal, MarshalIndent, Unmarshal } from './index.js'
+
+class Person {
+  public _fields = {
+    Name: $.varRef(''),
+    Age: $.varRef(0),
+    Active: $.varRef(false),
+  }
+
+  static __typeInfo = $.registerStructType(
+    'test.Person',
+    new Person(),
+    [],
+    Person,
+    {
+      Name: { type: { kind: $.TypeKind.Basic, name: 'string' }, tag: 'json:"name"' },
+      Age: { type: { kind: $.TypeKind.Basic, name: 'int' }, tag: 'json:"age"' },
+      Active: { type: { kind: $.TypeKind.Basic, name: 'bool' }, tag: 'json:"active"' },
+    },
+  )
+}
+
+describe('encoding/json override', () => {
+  it('marshals struct fields through json tags', () => {
+    const person = new Person()
+    person._fields.Name.value = 'Alice'
+    person._fields.Age.value = 30
+    person._fields.Active.value = true
+
+    const [data, err] = Marshal(person)
+
+    expect(err).toBeNull()
+    expect($.bytesToString(data)).toBe(
+      '{"name":"Alice","age":30,"active":true}',
+    )
+  })
+
+  it('marshals indented JSON with a line prefix', () => {
+    const person = new Person()
+    person._fields.Name.value = 'Alice'
+    person._fields.Age.value = 30
+    person._fields.Active.value = true
+
+    const [data, err] = MarshalIndent(person, '> ', '  ')
+
+    expect(err).toBeNull()
+    expect($.bytesToString(data)).toBe(
+      '{\n>   "name": "Alice",\n>   "age": 30,\n>   "active": true\n> }',
+    )
+  })
+
+  it('unmarshals into struct and map pointers', () => {
+    const person = $.varRef(new Person())
+    const personErr = Unmarshal(
+      $.stringToBytes('{"name":"Bob","age":25,"active":false}'),
+      person,
+    )
+
+    expect(personErr).toBeNull()
+    expect(person.value._fields.Name.value).toBe('Bob')
+    expect(person.value._fields.Age.value).toBe(25)
+    expect(person.value._fields.Active.value).toBe(false)
+
+    const mapRef: $.VarRef<Map<string, unknown> | null> = $.varRef(null)
+    const mapErr = Unmarshal(
+      $.stringToBytes('{"name":"Carol","age":22,"active":true}'),
+      mapRef,
+    )
+
+    expect(mapErr).toBeNull()
+    expect(mapRef.value?.get('name')).toBe('Carol')
+    expect(mapRef.value?.get('age')).toBe(22)
+    expect(mapRef.value?.get('active')).toBe(true)
+  })
+})

package/gs/encoding/json/index.ts

@@ -0,0 +1,210 @@
+import * as $ from '@goscript/builtin/index.js'
+
+export function Marshal(v: unknown): [$.Slice<number>, $.GoError] {
+  try {
+    return [$.stringToBytes(JSON.stringify(marshalValue(v))), null]
+  } catch (err) {
+    return [null, goError(err)]
+  }
+}
+
+export function MarshalIndent(
+  v: unknown,
+  prefix: string,
+  indent: string,
+): [$.Slice<number>, $.GoError] {
+  try {
+    const text = JSON.stringify(marshalValue(v), null, indent)
+    if (prefix === '') {
+      return [$.stringToBytes(text), null]
+    }
+    return [
+      $.stringToBytes(
+        text
+          .split('\n')
+          .map((line, idx) => (idx === 0 ? line : prefix + line))
+          .join('\n'),
+      ),
+      null,
+    ]
+  } catch (err) {
+    return [null, goError(err)]
+  }
+}
+
+export function Unmarshal(data: $.Slice<number>, v: unknown): $.GoError {
+  try {
+    assignDecodedValue(v, JSON.parse($.bytesToString(data)))
+    return null
+  } catch (err) {
+    return goError(err)
+  }
+}
+
+function marshalValue(v: unknown): unknown {
+  if ($.isVarRef(v)) {
+    return marshalValue(v.value)
+  }
+  if (v === null || v === undefined) {
+    return null
+  }
+  if (typeof v !== 'object') {
+    return v
+  }
+  if (v instanceof Uint8Array) {
+    return Array.from(v).map(marshalValue)
+  }
+  if (Array.isArray(v)) {
+    return v.map(marshalValue)
+  }
+  if (v instanceof Map) {
+    const out: Record<string, unknown> = {}
+    for (const [key, value] of v.entries()) {
+      out[String(key)] = marshalValue(value)
+    }
+    return out
+  }
+  if (!isStructValue(v)) {
+    return v
+  }
+
+  const out: Record<string, unknown> = {}
+  const typeFields = structFieldMetadata(v)
+  for (const [fieldName, ref] of Object.entries(v._fields)) {
+    const jsonName = jsonFieldName(fieldName, typeFields[fieldName]?.tag)
+    if (jsonName === '') {
+      continue
+    }
+    out[jsonName] = marshalValue(ref.value)
+  }
+  return out
+}
+
+function assignDecodedValue(target: unknown, decoded: unknown): void {
+  if ($.isVarRef(target)) {
+    if (isStructValue(target.value) && isPlainObject(decoded)) {
+      assignStructFields(target.value, decoded)
+      return
+    }
+    if (isPlainObject(decoded)) {
+      target.value = objectToMap(decoded)
+      return
+    }
+    target.value = decoded
+    return
+  }
+  if (isStructValue(target) && isPlainObject(decoded)) {
+    assignStructFields(target, decoded)
+  }
+}
+
+function assignStructFields(
+  target: { _fields: Record<string, $.VarRef<unknown>> },
+  decoded: Record<string, unknown>,
+): void {
+  const typeFields = structFieldMetadata(target)
+  for (const [fieldName, ref] of Object.entries(target._fields)) {
+    const jsonName = jsonFieldName(fieldName, typeFields[fieldName]?.tag)
+    if (
+      jsonName !== '' &&
+      Object.prototype.hasOwnProperty.call(decoded, jsonName)
+    ) {
+      ref.value = decoded[jsonName]
+    }
+  }
+}
+
+function objectToMap(decoded: Record<string, unknown>): Map<string, unknown> {
+  const out = new Map<string, unknown>()
+  for (const [key, value] of Object.entries(decoded)) {
+    out.set(key, isPlainObject(value) ? objectToMap(value) : value)
+  }
+  return out
+}
+
+function isStructValue(
+  value: unknown,
+): value is { _fields: Record<string, $.VarRef<unknown>> } {
+  if (value === null || typeof value !== 'object') {
+    return false
+  }
+  const fields = Reflect.get(value, '_fields')
+  return (
+    fields !== null &&
+    fields !== undefined &&
+    typeof fields === 'object' &&
+    !Array.isArray(fields)
+  )
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    !(value instanceof Uint8Array) &&
+    !(value instanceof Map)
+  )
+}
+
+function structFieldMetadata(
+  value: unknown,
+): Record<string, { tag?: string }> {
+  if (value === null || typeof value !== 'object') {
+    return {}
+  }
+  const ctor = Reflect.get(value, 'constructor')
+  if (
+    ctor === null ||
+    ctor === undefined ||
+    (typeof ctor !== 'object' && typeof ctor !== 'function')
+  ) {
+    return {}
+  }
+  const typeInfo = Reflect.get(ctor, '__typeInfo')
+  if (
+    typeInfo === null ||
+    typeInfo === undefined ||
+    typeof typeInfo !== 'object'
+  ) {
+    return {}
+  }
+  const fields = Reflect.get(typeInfo, 'fields')
+  if (isPlainObject(fields)) {
+    const out: Record<string, { tag?: string }> = {}
+    for (const [name, field] of Object.entries(fields)) {
+      if (!isPlainObject(field)) {
+        continue
+      }
+      const tag = field.tag
+      out[name] = typeof tag === 'string' ? { tag } : {}
+    }
+    return out
+  }
+  return {}
+}
+
+function goError(err: unknown): $.GoError {
+  if (err instanceof Error) {
+    return $.toGoError(err)
+  }
+  return $.newError(String(err))
+}
+
+function jsonFieldName(fieldName: string, tag: string | undefined): string {
+  if (tag === undefined || !tag.startsWith('json:"')) {
+    return fieldName
+  }
+  const end = tag.indexOf('"', 'json:"'.length)
+  if (end < 0) {
+    return fieldName
+  }
+  const name = tag.slice('json:"'.length, end).split(',')[0]
+  if (name === '-') {
+    return ''
+  }
+  if (name === '') {
+    return fieldName
+  }
+  return name
+}

package/gs/errors/errors.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import { AsType, Errorf, Is, Join, Wrap, Wrapf } from './errors.js'
+
+class DNSError {
+  public readonly IsNotFound = true
+
+  public Error(): string {
+    return 'dns'
+  }
+}
+
+class Wrapper {
+  constructor(private readonly err: $.GoError) {}
+
+  public Error(): string {
+    return 'wrapped'
+  }
+
+  public Unwrap(): $.GoError {
+    return this.err
+  }
+}
+
+const dnsTypeArgs: $.GenericTypeArgs = {
+  E: {
+    type: { kind: $.TypeKind.Pointer, elemType: 'net.DNSError' },
+    zero: () => null,
+  },
+}
+
+describe('errors.AsType', () => {
+  it('returns a directly matching error', () => {
+    const dns = $.interfaceValue<$.GoError>(new DNSError(), '*net.DNSError')
+
+    const [matched, ok] = AsType(dnsTypeArgs, dns)
+
+    expect(ok).toBe(true)
+    expect(matched).toBe(dns)
+  })
+
+  it('walks wrapped errors depth first', () => {
+    const dns = $.interfaceValue<$.GoError>(new DNSError(), '*net.DNSError')
+    const wrapped = $.interfaceValue<$.GoError>(new Wrapper(dns), '*main.Wrapper')
+
+    const [matched, ok] = AsType(dnsTypeArgs, Join(null, wrapped))
+
+    expect(ok).toBe(true)
+    expect(matched).toBe(dns)
+  })
+
+  it('returns zero when no error matches', () => {
+    const [matched, ok] = AsType(dnsTypeArgs, $.newError('plain'))
+
+    expect(ok).toBe(false)
+    expect(matched).toBe(null)
+  })
+})
+
+describe('errors github.com/pkg/errors compatibility helpers', () => {
+  it('formats new errors', () => {
+    expect(Errorf('bad %s: %d', 'value', 42)?.Error()).toBe('bad value: 42')
+  })
+
+  it('wraps and unwraps errors', () => {
+    const base = $.newError('root')
+    const wrapped = Wrap(base, 'context')
+
+    expect(wrapped?.Error()).toBe('context: root')
+    expect(Is(wrapped, base)).toBe(true)
+  })
+
+  it('wraps formatted context and preserves nil', () => {
+    const base = $.newError('root')
+
+    expect(Wrapf(base, 'context %d', 7)?.Error()).toBe('context 7: root')
+    expect(Wrap(null, 'context')).toBe(null)
+    expect(Wrapf(null, 'context %d', 7)).toBe(null)
+  })
+})