goscript 0.1.0 → 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/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

@@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest'
 
 import * as $ from '@goscript/builtin/index.js'
 
-import { Marshal, Unmarshal } from './index.js'
+import { Marshal, MarshalIndent, Unmarshal } from './index.js'
 
 class Person {
   public _fields = {
@@ -39,6 +39,20 @@ describe('encoding/json override', () => {
     )
   })
 
+  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(

package/gs/encoding/json/index.ts

@@ -8,6 +8,30 @@ export function Marshal(v: unknown): [$.Slice<number>, $.GoError] {
   }
 }
 
+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)))

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)
+  })
+})

package/gs/errors/errors.ts

@@ -6,6 +6,57 @@ export function New(text: string): $.GoError {
   return $.newError(text)
 }
 
+export function Errorf(format: string, ...args: any[]): $.GoError {
+  return New(formatText(format, args))
+}
+
+export function Wrap(err: $.GoError, message: string): $.GoError {
+  if (err === null) {
+    return null
+  }
+  return wrapError(err, message)
+}
+
+export function Wrapf(
+  err: $.GoError,
+  format: string,
+  ...args: any[]
+): $.GoError {
+  if (err === null) {
+    return null
+  }
+  return wrapError(err, formatText(format, args))
+}
+
+function wrapError(err: Exclude<$.GoError, null>, message: string): $.GoError {
+  const wrapped = $.newError(`${message}: ${err.Error()}`)
+  ;(wrapped as any).Unwrap = function (): $.GoError {
+    return err
+  }
+  return wrapped
+}
+
+function formatText(format: string, args: any[]): string {
+  let argIndex = 0
+  return format.replace(/%[sdqv%]/g, (match) => {
+    if (match === '%%') {
+      return '%'
+    }
+    if (argIndex >= args.length) {
+      return match
+    }
+    const arg = args[argIndex++]
+    switch (match) {
+      case '%d':
+        return String(Number(arg))
+      case '%q':
+        return JSON.stringify(String(arg))
+      default:
+        return String(arg)
+    }
+  })
+}
+
 // ErrUnsupported indicates that a requested operation cannot be performed,
 // because it is unsupported. For example, a call to os.Link when using a
 // file system that does not support hard links.
@@ -179,6 +230,59 @@ export function As(err: $.GoError, target: any): boolean {
   return false
 }
 
+// AsType finds the first error in err's tree that matches the generic error
+// type E, returning the matching error and true. Otherwise it returns E's zero
+// value and false.
+export function AsType(
+  typeArgs: $.GenericTypeArgs | undefined,
+  err: $.GoError,
+): [any, boolean] {
+  const descriptor = typeArgs?.E
+  const zero = (): any => descriptor?.zero?.() ?? null
+  if (err === null || descriptor?.type === undefined) {
+    return [zero(), false]
+  }
+  return asType(err, descriptor.type, zero)
+}
+
+function asType(
+  err: $.GoError,
+  typeInfo: $.TypeInfo | string,
+  zero: () => any,
+): [any, boolean] {
+  if (err === null) {
+    return [zero(), false]
+  }
+
+  const [asserted, ok] = $.typeAssertTuple<any>(err, typeInfo)
+  if (ok) {
+    return [asserted, true]
+  }
+
+  if (typeof (err as any).Unwrap === 'function') {
+    const result = (err as any).Unwrap()
+    if (Array.isArray(result)) {
+      for (const wrappedErr of result) {
+        if (
+          wrappedErr &&
+          typeof wrappedErr.Error === 'function'
+        ) {
+          const [matched, matchedOK] = asType(wrappedErr, typeInfo, zero)
+          if (matchedOK) {
+            return [matched, true]
+          }
+        }
+      }
+      return [zero(), false]
+    }
+    if (result && typeof result.Error === 'function') {
+      return asType(result, typeInfo, zero)
+    }
+  }
+
+  return [zero(), false]
+}
+
 // Join returns an error that wraps the given errors.
 // Any nil error values are discarded.
 // Join returns nil if every value in errs is nil.

package/gs/fmt/fmt.ts

@@ -22,7 +22,7 @@ export interface State {
   Flag(c: number): boolean
   Precision(): [number, boolean]
   Width(): [number, boolean]
-  Write(b: Uint8Array): [number, $.GoError | null]
+  Write(b: $.Bytes): [number, $.GoError | null]
 }
 
 // Simple printf-style formatting implementation
@@ -199,7 +199,11 @@ function parseFormat(format: string, args: any[]): string {
           const verb = format[j]
 
           if (argIndex < args.length) {
-            let formatted = formatValue(args[argIndex], verb)
+            const arg = args[argIndex]
+            let formatted = formatWithState(arg, verb, flags, width, precision)
+            if (formatted === null) {
+              formatted = formatValue(arg, verb)
+            }
 
             // Apply width and precision formatting
             if (width && !precision) {
@@ -217,7 +221,7 @@ function parseFormat(format: string, args: any[]): string {
               (verb === 'f' || verb === 'e' || verb === 'g')
             ) {
               const p = parseInt(precision)
-              const num = Number(args[argIndex])
+              const num = Number(arg)
               if (verb === 'f') {
                 formatted = num.toFixed(p)
               } else if (verb === 'e') {
@@ -257,6 +261,39 @@ function parseFormat(format: string, args: any[]): string {
   return result
 }
 
+function formatWithState(
+  value: any,
+  verb: string,
+  flags: string,
+  width: string,
+  precision: string,
+): string | null {
+  if (!value || typeof value.Format !== 'function') {
+    return null
+  }
+
+  let out = ''
+  const state: State = {
+    Flag(c: number): boolean {
+      return flags.includes(String.fromCharCode(c))
+    },
+    Precision(): [number, boolean] {
+      return precision === '' ? [0, false] : [parseInt(precision), true]
+    },
+    Width(): [number, boolean] {
+      return width === '' ? [0, false] : [parseInt(width), true]
+    },
+    Write(b: $.Bytes): [number, $.GoError | null] {
+      const text = $.bytesToString(b)
+      out += text
+      return [text.length, null]
+    },
+  }
+
+  value.Format(state, verb.codePointAt(0) ?? 0)
+  return out
+}
+
 // Global stdout simulation for Print functions
 let stdout = {
   write: (data: string) => {
@@ -361,34 +398,37 @@ export function Fprintln(w: any, ...a: any[]): [number, $.GoError | null] {
 }
 
 // Append functions (append to byte slice)
-export function Append(b: Uint8Array, ...a: any[]): Uint8Array {
+export function Append(b: $.Bytes, ...a: any[]): $.Bytes {
   const result = a.map(defaultFormat).join(' ')
   const encoded = new TextEncoder().encode(result)
-  const newArray = new Uint8Array(b.length + encoded.length)
-  newArray.set(b)
-  newArray.set(encoded, b.length)
+  const base = $.bytesToUint8Array(b)
+  const newArray = new Uint8Array(base.length + encoded.length)
+  newArray.set(base)
+  newArray.set(encoded, base.length)
   return newArray
 }
 
 export function Appendf(
-  b: Uint8Array,
+  b: $.Bytes,
   format: string,
   ...a: any[]
-): Uint8Array {
+): $.Bytes {
   const result = parseFormat(format, a)
   const encoded = new TextEncoder().encode(result)
-  const newArray = new Uint8Array(b.length + encoded.length)
-  newArray.set(b)
-  newArray.set(encoded, b.length)
+  const base = $.bytesToUint8Array(b)
+  const newArray = new Uint8Array(base.length + encoded.length)
+  newArray.set(base)
+  newArray.set(encoded, base.length)
   return newArray
 }
 
-export function Appendln(b: Uint8Array, ...a: any[]): Uint8Array {
+export function Appendln(b: $.Bytes, ...a: any[]): $.Bytes {
   const result = a.map(defaultFormat).join(' ') + '\n'
   const encoded = new TextEncoder().encode(result)
-  const newArray = new Uint8Array(b.length + encoded.length)
-  newArray.set(b)
-  newArray.set(encoded, b.length)
+  const base = $.bytesToUint8Array(b)
+  const newArray = new Uint8Array(base.length + encoded.length)
+  newArray.set(base)
+  newArray.set(encoded, base.length)
   return newArray
 }
 

package/gs/github.com/aperturerobotics/protobuf-go-lite/index.test.ts

@@ -1,6 +1,21 @@
 import { describe, expect, it } from 'vitest'
 
-import { CompareEqualVT } from './index.js'
+import {
+  AppendVarint,
+  CompareEqualVT,
+  DecodeFixed32,
+  DecodeFixed64,
+  DecodeVarint,
+  DecodeVarintInt32,
+  DecodeVarintInt64,
+  DecodeVarintUint32,
+  EncodeVarint,
+  ErrIntOverflow,
+  ErrInvalidLength,
+  ErrUnexpectedEndOfGroup,
+  SizeOfVarint,
+  Skip,
+} from './index.js'
 
 class TestValue {
   constructor(private readonly value: string) {}
@@ -21,3 +36,60 @@ describe('protobuf-go-lite EqualVT helpers', () => {
     expect(equal(null, null)).toBe(true)
   })
 })
+
+describe('protobuf-go-lite wire helpers', () => {
+  it('encodes and decodes varints', () => {
+    const buf = new Uint8Array(4)
+
+    const offset = EncodeVarint(buf, 4, 300)
+
+    expect(offset).toBe(2)
+    expect(Array.from(buf.slice(offset))).toEqual([0xac, 0x02])
+    expect(SizeOfVarint(300)).toBe(2)
+    expect(DecodeVarint(buf, offset)).toEqual([300, 4, null])
+    expect(DecodeVarintInt32(buf, offset)).toEqual([300, 4, null])
+    expect(DecodeVarintInt64(buf, offset)).toEqual([300, 4, null])
+    expect(DecodeVarintUint32(buf, offset)).toEqual([300, 4, null])
+    expect(Array.from(AppendVarint([], 300) as number[])).toEqual([
+      0xac,
+      0x02,
+    ])
+  })
+
+  it('decodes fixed64 values', () => {
+    expect(DecodeFixed32(new Uint8Array([0x44, 0x33, 0x22, 0x11]), 0)).toEqual([
+      0x11223344,
+      4,
+      null,
+    ])
+
+    expect(
+      DecodeFixed64(
+        new Uint8Array([0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11]),
+        0,
+      ),
+    ).toEqual([0x1122334455667800, 8, null])
+
+    const [, , err] = DecodeFixed64(new Uint8Array([1, 2, 3]), 0)
+    expect(err?.Error()).toBe('unexpected EOF')
+  })
+
+  it('skips protobuf records', () => {
+    expect(Skip(new Uint8Array([0x08, 0x96, 0x01]))).toEqual([3, null])
+    expect(Skip(new Uint8Array([0x12, 0x03, 0x61, 0x62, 0x63]))).toEqual([
+      5,
+      null,
+    ])
+    expect(Skip(new Uint8Array([0x0c]))).toEqual([
+      0,
+      ErrUnexpectedEndOfGroup,
+    ])
+  })
+
+  it('reports protobuf wire errors as Go errors', () => {
+    expect(ErrInvalidLength?.Error()).toContain('negative length')
+    expect(ErrIntOverflow?.Error()).toContain('integer overflow')
+    const [, eof] = Skip(new Uint8Array([0x08, 0x80]))
+    expect(eof?.Error()).toBe('unexpected EOF')
+  })
+})