goscript 0.1.0 → 0.1.2

package/gs/time/time.ts

@@ -1,3 +1,4 @@
+import * as $ from '../builtin/index.js'
 import { makeChannel, ChannelRef, makeChannelRef } from '../builtin/channel.js'
 
 // Time represents a time instant with nanosecond precision
@@ -132,11 +133,40 @@ export class Time {
     return this._nsec
   }
 
+  public Date(): [number, Month, number] {
+    return [this.Year(), this.Month(), this.Day()]
+  }
+
+  public Clock(): [number, number, number] {
+    return [this.Hour(), this.Minute(), this.Second()]
+  }
+
+  public Zone(): [string, number] {
+    if (this._location.offsetSeconds !== undefined) {
+      return [this._location.name, this._location.offsetSeconds]
+    }
+    const offset = -this._date.getTimezoneOffset() * 60
+    return [this._location.name, offset]
+  }
+
   // Location returns the time zone information associated with t
   public Location(): Location {
     return this._location
   }
 
+  // UTC returns t with the location set to UTC.
+  public UTC(): Time {
+    return Time.create(this._date, this._nsec, undefined, UTC)
+  }
+
+  // In returns a copy of t representing the same instant in loc.
+  public In(loc: Location | $.VarRef<Location> | null): Time {
+    if (loc === null) {
+      throw new Error('time: missing Location in call to Time.In')
+    }
+    return Time.create(this._date, this._nsec, undefined, $.pointerValue(loc))
+  }
+
   // Format returns a textual representation of the time value formatted according to the layout
   public Format(layout: string): string {
     // Implementation of Go's time formatting based on reference time:
@@ -498,7 +528,7 @@ export class Time {
   // Add adds the duration d to t, returning the sum
   // Preserves monotonic reading if present
   public Add(d: Duration): Time {
-    const durationNs = d
+    const durationNs = durationNumber(d)
     const newDate = new globalThis.Date(
       this._date.getTime() + Math.floor(durationNs / 1000000),
     )
@@ -508,6 +538,33 @@ export class Time {
     return Time.create(newDate, newNsec, newMonotonic, this._location)
   }
 
+  public AddDate(years: number, months: number, days: number): Time {
+    if (this._location.offsetSeconds !== undefined) {
+      const offsetMs = this._location.offsetSeconds * 1000
+      const local = new globalThis.Date(this._date.getTime() + offsetMs)
+      const shifted = globalThis.Date.UTC(
+        local.getUTCFullYear() + years,
+        local.getUTCMonth() + months,
+        local.getUTCDate() + days,
+        local.getUTCHours(),
+        local.getUTCMinutes(),
+        local.getUTCSeconds(),
+        local.getUTCMilliseconds(),
+      )
+      return Time.create(
+        new globalThis.Date(shifted - offsetMs),
+        this._nsec,
+        undefined,
+        this._location,
+      )
+    }
+    const shifted = new globalThis.Date(this._date.getTime())
+    shifted.setFullYear(shifted.getFullYear() + years)
+    shifted.setMonth(shifted.getMonth() + months)
+    shifted.setDate(shifted.getDate() + days)
+    return Time.create(shifted, this._nsec, undefined, this._location)
+  }
+
   // Equal reports whether t and u represent the same time instant
   // Uses monotonic clock if both times have it
   public Equal(u: Time): boolean {
@@ -517,6 +574,10 @@ export class Time {
     return this._date.getTime() === u._date.getTime() && this._nsec === u._nsec
   }
 
+  public IsZero(): boolean {
+    return this.Equal(new Time())
+  }
+
   // Before reports whether the time instant t is before u
   // Uses monotonic clock if both times have it
   public Before(u: Time): boolean {
@@ -579,6 +640,25 @@ export class Time {
 // Duration represents a span of time (nanoseconds)
 export type Duration = number
 
+const maxDuration = Number(9223372036854775807n)
+const minDuration = Number(-9223372036854775808n)
+const maxTimerDelayMilliseconds = 0x7fffffff
+
+function durationNumber(d: Duration): number {
+  return Number(d)
+}
+
+function timeoutMilliseconds(d: Duration): number {
+  const ms = durationNumber(d) / 1000000
+  if (!Number.isFinite(ms) || ms > maxTimerDelayMilliseconds) {
+    return maxTimerDelayMilliseconds
+  }
+  if (ms <= 0) {
+    return 0
+  }
+  return ms
+}
+
 // Duration comparison function
 export function Duration_lt(receiver: Duration, other: Duration): boolean {
   return receiver < other
@@ -589,7 +669,147 @@ export function Duration_multiply(
   receiver: Duration,
   multiplier: number,
 ): Duration {
-  return receiver * multiplier
+  return durationNumber(receiver) * multiplier
+}
+
+export function Duration_Abs(receiver: Duration): Duration {
+  const value = durationNumber(receiver)
+  if (value >= 0) {
+    return value
+  }
+  if (value === minDuration) {
+    return maxDuration
+  }
+  return -value
+}
+
+export function Duration_Hours(receiver: Duration): number {
+  return durationNumber(receiver) / Hour
+}
+
+export function Duration_Microseconds(receiver: Duration): number {
+  return Math.trunc(durationNumber(receiver) / Microsecond)
+}
+
+export function Duration_Milliseconds(receiver: Duration): number {
+  return Math.trunc(durationNumber(receiver) / Millisecond)
+}
+
+export function Duration_Minutes(receiver: Duration): number {
+  return durationNumber(receiver) / Minute
+}
+
+export function Duration_Nanoseconds(receiver: Duration): number {
+  return durationNumber(receiver)
+}
+
+export function Duration_Round(
+  receiver: Duration,
+  multiple: Duration,
+): Duration {
+  const value = durationNumber(receiver)
+  const unit = durationNumber(multiple)
+  if (unit <= 0) {
+    return value
+  }
+  const rounded =
+    value >= 0 ?
+      Math.floor(value / unit + 0.5) * unit
+    : Math.ceil(value / unit - 0.5) * unit
+  return Math.max(minDuration, Math.min(maxDuration, rounded))
+}
+
+// Duration_Seconds returns the duration as a floating point number of seconds.
+export function Duration_Seconds(receiver: Duration): number {
+  return durationNumber(receiver) / Second
+}
+
+export function Duration_Truncate(
+  receiver: Duration,
+  multiple: Duration,
+): Duration {
+  const value = durationNumber(receiver)
+  const unit = durationNumber(multiple)
+  if (unit <= 0) {
+    return value
+  }
+  return value - (value % unit)
+}
+
+export function Duration_String(receiver: Duration): string {
+  const value = durationNumber(receiver)
+  if (value === 0) {
+    return '0s'
+  }
+  const sign = value < 0 ? '-' : ''
+  let remaining = Math.abs(value)
+  if (remaining < Second) {
+    return sign + formatSubsecond(remaining)
+  }
+  const hours = Math.floor(remaining / Hour)
+  remaining -= hours * Hour
+  const minutes = Math.floor(remaining / Minute)
+  remaining -= minutes * Minute
+  const seconds = Math.floor(remaining / Second)
+  remaining -= seconds * Second
+
+  let out = sign
+  if (hours !== 0) {
+    out += `${hours}h`
+  }
+  if (minutes !== 0) {
+    out += `${minutes}m`
+  }
+  if (seconds !== 0 || remaining !== 0) {
+    out += formatSeconds(seconds, remaining)
+  }
+  return out
+}
+
+export function Duration_format(
+  receiver: Duration,
+  buf: $.VarRef<number[]>,
+): number {
+  const text = Duration_String(receiver)
+  const bytes = Array.from(new TextEncoder().encode(text))
+  const start = Math.max(0, buf.value.length - bytes.length)
+  for (
+    let idx = 0;
+    idx < bytes.length && start + idx < buf.value.length;
+    idx++
+  ) {
+    buf.value[start + idx] = bytes[idx]!
+  }
+  return start
+}
+
+function formatSeconds(seconds: number, nanos: number): string {
+  if (nanos === 0) {
+    return `${seconds}s`
+  }
+  const fraction = String(nanos).padStart(9, '0').replace(/0+$/, '')
+  return `${seconds}.${fraction}s`
+}
+
+function formatSubsecond(nanos: number): string {
+  if (nanos >= Millisecond) {
+    return formatUnit(nanos, Millisecond, 'ms')
+  }
+  if (nanos >= Microsecond) {
+    return formatUnit(nanos, Microsecond, '\u00b5s')
+  }
+  return `${nanos}ns`
+}
+
+function formatUnit(nanos: number, unit: number, suffix: string): string {
+  const whole = Math.floor(nanos / unit)
+  const rem = nanos % unit
+  if (rem === 0) {
+    return `${whole}${suffix}`
+  }
+  const scale = Math.log10(unit)
+  const fraction = String(rem).padStart(scale, '0').replace(/0+$/, '')
+  return `${whole}.${fraction}${suffix}`
 }
 
 // Location represents a time zone
@@ -692,17 +912,13 @@ export class Timer {
   private _timeout: NodeJS.Timeout | number
   private _duration: Duration
   private _callback?: () => void
+  private _channel = makeChannel(1, new Time(), 'both')
+  public C: ChannelRef<Time> = makeChannelRef(this._channel, 'receive')
 
   constructor(duration: Duration, callback?: () => void) {
     this._duration = duration
     this._callback = callback
-    const ms = duration / 1000000 // Convert nanoseconds to milliseconds
-
-    if (callback) {
-      this._timeout = setTimeout(callback, ms)
-    } else {
-      this._timeout = setTimeout(() => {}, ms)
-    }
+    this._timeout = this.start(duration)
   }
 
   // Stop prevents the Timer from firing
@@ -718,13 +934,19 @@ export class Timer {
   // Reset changes the timer to expire after duration d
   public Reset(d: Duration): boolean {
     this.Stop()
-    const ms = d / 1000000
+    this._duration = d
+    this._timeout = this.start(d)
+    return true
+  }
+
+  private start(d: Duration): NodeJS.Timeout | number {
+    const ms = timeoutMilliseconds(d)
     if (this._callback) {
-      this._timeout = setTimeout(this._callback, ms)
-    } else {
-      this._timeout = setTimeout(() => {}, ms)
+      return setTimeout(this._callback, ms)
     }
-    return true
+    return setTimeout(() => {
+      this._channel.send(Now()).catch(() => {})
+    }, ms)
   }
 }
 
@@ -733,11 +955,12 @@ export class Ticker {
   private _interval: NodeJS.Timeout | number
   private _duration: Duration
   private _stopped: boolean = false
+  private _channel = makeChannel(1, new Time(), 'both')
+  public C: ChannelRef<Time> = makeChannelRef(this._channel, 'receive')
 
   constructor(duration: Duration) {
     this._duration = duration
-    const ms = duration / 1000000 // Convert nanoseconds to milliseconds
-    this._interval = setInterval(() => {}, ms)
+    this._interval = this.start(duration)
   }
 
   // Stop turns off a ticker
@@ -755,20 +978,22 @@ export class Ticker {
     this.Stop()
     this._stopped = false
     this._duration = d
-    const ms = d / 1000000
-    this._interval = setInterval(() => {}, ms)
+    this._interval = this.start(d)
   }
 
   // Channel returns an async iterator that yields time values
   public async *Channel(): AsyncIterableIterator<Time> {
-    const ms = this._duration / 1000000
     while (!this._stopped) {
-      await new Promise((resolve) => setTimeout(resolve, ms))
-      if (!this._stopped) {
-        yield Now()
-      }
+      yield await this.C.receive()
     }
   }
+
+  private start(d: Duration): NodeJS.Timeout | number {
+    const ms = timeoutMilliseconds(d)
+    return setInterval(() => {
+      this._channel.send(Now()).catch(() => {})
+    }, ms)
+  }
 }
 
 // Now returns the current local time with monotonic clock reading
@@ -861,17 +1086,29 @@ export function Until(t: Time): Duration {
 
 // Sleep pauses the current execution for at least the duration d
 export async function Sleep(d: Duration): Promise<void> {
-  const ms = d / 1000000 // Convert nanoseconds to milliseconds
+  const ms = timeoutMilliseconds(d)
   return new Promise((resolve) => setTimeout(resolve, ms))
 }
 
 // Export month constants
+export const January = Month.January
+export const February = Month.February
+export const March = Month.March
+export const April = Month.April
 export const May = Month.May
+export const June = Month.June
+export const July = Month.July
+export const August = Month.August
+export const September = Month.September
+export const October = Month.October
+export const November = Month.November
+export const December = Month.December
 
 // Time layout constants (matching Go's time package)
 export const DateTime = '2006-01-02 15:04:05'
 export const Layout = "01/02 03:04:05PM '06 -0700"
 export const RFC3339 = '2006-01-02T15:04:05Z07:00'
+export const RFC3339Nano = '2006-01-02T15:04:05.999999999Z07:00'
 export const Kitchen = '3:04PM'
 
 // Unix returns the local Time corresponding to the given Unix time,
@@ -907,12 +1144,12 @@ export function UnixNano(nsec: number): Time {
 // ParseDuration parses a duration string
 // A duration string is a possibly signed sequence of decimal numbers,
 // each with optional fraction and a unit suffix
-export function ParseDuration(s: string): Duration {
+export function ParseDuration(s: string): [Duration, $.GoError] {
   const regex = /^([+-]?)(\d+(?:\.\d+)?)(ns|us|µs|ms|s|m|h)$/
   const match = s.match(regex)
 
   if (!match) {
-    throw new Error(`time: invalid duration "${s}"`)
+    return [0, $.newError(`time: invalid duration "${s}"`)]
   }
 
   const [, sign, valueStr, unit] = match
@@ -941,14 +1178,14 @@ export function ParseDuration(s: string): Duration {
       nanoseconds = value * 3600000000000
       break
     default:
-      throw new Error(`time: unknown unit "${unit}" in duration "${s}"`)
+      return [0, $.newError(`time: unknown unit "${unit}" in duration "${s}"`)]
   }
 
-  return nanoseconds
+  return [nanoseconds, null]
 }
 
 // Parse parses a formatted string and returns the time value it represents
-export function Parse(layout: string, value: string): Time {
+export function Parse(layout: string, value: string): [Time, $.GoError] {
   return ParseInLocation(layout, value, UTC)
 }
 
@@ -957,7 +1194,7 @@ export function ParseInLocation(
   layout: string,
   value: string,
   loc: Location,
-): Time {
+): [Time, $.GoError] {
   // This is a simplified implementation
   // A full implementation would need to parse according to the layout format
 
@@ -965,48 +1202,63 @@ export function ParseInLocation(
   if (layout === RFC3339 || layout === '2006-01-02T15:04:05Z07:00') {
     const date = new globalThis.Date(value)
     if (isNaN(date.getTime())) {
-      throw new ParseError(
-        layout,
-        value,
-        '',
-        '',
-        `parsing time "${value}" as "${layout}": cannot parse`,
-      )
+      return [
+        new Time(),
+        $.toGoError(
+          new ParseError(
+            layout,
+            value,
+            '',
+            '',
+            `parsing time "${value}" as "${layout}": cannot parse`,
+          ),
+        ),
+      ]
     }
-    return Time.create(date, 0, undefined, loc)
+    return [Time.create(date, 0, undefined, loc), null]
   }
 
   if (layout === DateTime || layout === '2006-01-02 15:04:05') {
     const date = new globalThis.Date(value)
     if (isNaN(date.getTime())) {
-      throw new ParseError(
-        layout,
-        value,
-        '',
-        '',
-        `parsing time "${value}" as "${layout}": cannot parse`,
-      )
+      return [
+        new Time(),
+        $.toGoError(
+          new ParseError(
+            layout,
+            value,
+            '',
+            '',
+            `parsing time "${value}" as "${layout}": cannot parse`,
+          ),
+        ),
+      ]
     }
-    return Time.create(date, 0, undefined, loc)
+    return [Time.create(date, 0, undefined, loc), null]
   }
 
   // Fallback to standard Date parsing
   const date = new globalThis.Date(value)
   if (isNaN(date.getTime())) {
-    throw new ParseError(
-      layout,
-      value,
-      '',
-      '',
-      `parsing time "${value}" as "${layout}": cannot parse`,
-    )
+    return [
+      new Time(),
+      $.toGoError(
+        new ParseError(
+          layout,
+          value,
+          '',
+          '',
+          `parsing time "${value}" as "${layout}": cannot parse`,
+        ),
+      ),
+    ]
   }
-  return Time.create(date, 0, undefined, loc)
+  return [Time.create(date, 0, undefined, loc), null]
 }
 
 // After waits for the duration to elapse and then sends the current time on the returned channel
 export function After(d: Duration): ChannelRef<Time> {
-  const ms = d / 1000000 // Convert nanoseconds to milliseconds
+  const ms = timeoutMilliseconds(d)
 
   // Create a buffered channel with capacity 1
   const channel = makeChannel(1, new Time(), 'both')
@@ -1035,8 +1287,8 @@ export function NewTicker(d: Duration): Ticker {
 }
 
 // Tick is a convenience wrapper for NewTicker providing access to the ticking channel only
-export function Tick(d: Duration): AsyncIterableIterator<Time> {
-  return new Ticker(d).Channel()
+export function Tick(d: Duration): ChannelRef<Time> {
+  return new Ticker(d).C
 }
 
 // LoadLocation returns the Location with the given name

package/gs/unicode/unicode.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import {
+  CategoryAliases,
+  Cn,
+  Is,
+  Range16,
+  Range32,
+  RangeTable,
+} from './unicode.js'
+
+describe('unicode overrides', () => {
+  it('accepts generated struct-literal constructor shapes', () => {
+    const table = new RangeTable({
+      R16: $.arrayToSlice<Range16>([
+        new Range16({ Lo: 0x41, Hi: 0x5a, Stride: 1 }),
+      ]),
+      R32: $.arrayToSlice<Range32>([
+        new Range32({ Lo: 0x10000, Hi: 0x10002, Stride: 1 }),
+      ]),
+      LatinOffset: 1,
+    })
+
+    expect(table.LatinOffset).toBe(1)
+    expect(Is(table, 0x41)).toBe(true)
+    expect(Is(table, 0x10001)).toBe(true)
+    expect(Is(table, 0x61)).toBe(false)
+  })
+
+  it('exports category aliases used by regexp/syntax', () => {
+    expect(CategoryAliases.get('digit')).toBe('Nd')
+    expect(Cn).toBeInstanceOf(RangeTable)
+  })
+})