goscript 0.0.28 → 0.0.29

package/gs/time/time.ts

@@ -3,16 +3,309 @@ export class Time {
   private _date: globalThis.Date
   private _nsec: number // nanoseconds within the second
   private _monotonic?: number // high-resolution monotonic timestamp in nanoseconds
+  private _location: Location // timezone location
 
-  constructor(date: globalThis.Date, nsec: number = 0, monotonic?: number) {
+  constructor(date: globalThis.Date, nsec: number = 0, monotonic?: number, location?: Location) {
     this._date = new globalThis.Date(date.getTime())
     this._nsec = nsec
     this._monotonic = monotonic
+    this._location = location || UTC
   }
 
   // clone returns a copy of this Time instance
   public clone(): Time {
-    return new Time(this._date, this._nsec, this._monotonic)
+    return new Time(this._date, this._nsec, this._monotonic, this._location)
+  }
+
+  // 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:
+    // "Mon Jan 2 15:04:05 MST 2006" (Unix time 1136239445)
+    
+    // Calculate the time in the timezone of this Time object
+    let year: number, month0: number, dayOfMonth: number, dayOfWeek: number
+    let hour24: number, minute: number, second: number
+    
+    if (this._location.offsetSeconds !== undefined) {
+      // For fixed timezone locations, adjust the UTC time by the offset
+      const offsetMs = this._location.offsetSeconds * 1000
+      const adjustedTime = new globalThis.Date(this._date.getTime() + offsetMs)
+      
+      year = adjustedTime.getUTCFullYear()
+      month0 = adjustedTime.getUTCMonth() // 0-11 for array indexing
+      dayOfMonth = adjustedTime.getUTCDate() // 1-31
+      dayOfWeek = adjustedTime.getUTCDay() // 0 (Sun) - 6 (Sat)
+      hour24 = adjustedTime.getUTCHours() // 0-23
+      minute = adjustedTime.getUTCMinutes() // 0-59
+      second = adjustedTime.getUTCSeconds() // 0-59
+    } else {
+      // For local time, use the local timezone methods
+      year = this._date.getFullYear()
+      month0 = this._date.getMonth() // 0-11 for array indexing
+      dayOfMonth = this._date.getDate() // 1-31
+      dayOfWeek = this._date.getDay() // 0 (Sun) - 6 (Sat)
+      hour24 = this._date.getHours() // 0-23
+      minute = this._date.getMinutes() // 0-59
+      second = this._date.getSeconds() // 0-59
+    }
+    
+    const nsec = this._nsec // Nanoseconds (0-999,999,999)
+
+    const shortMonthNames = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+    const longMonthNames = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]
+    const shortDayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
+    const longDayNames = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]
+
+    const hour12 = hour24 % 12 || 12 // 12 for 0h and 12h
+    const ampmUpper = hour24 < 12 ? 'AM' : 'PM'
+    const ampmLower = ampmUpper.toLowerCase()
+
+    // Timezone offset calculation - use the location's offset if available
+    let tzOffsetSeconds = 0
+    let tzName = this._location.name
+    let isUTC = false
+    
+    if (this._location.offsetSeconds !== undefined) {
+      // Use the fixed offset from the location
+      tzOffsetSeconds = this._location.offsetSeconds
+      isUTC = tzOffsetSeconds === 0 && this._location.name === "UTC"
+    } else {
+      // Fall back to JavaScript's timezone offset (for local time)
+      const tzOffsetMinutesJS = this._date.getTimezoneOffset()
+      tzOffsetSeconds = -tzOffsetMinutesJS * 60 // Convert to seconds, negate because JS offset is opposite
+      isUTC = tzOffsetSeconds === 0
+    }
+    
+    let tzSign = '+'
+    if (tzOffsetSeconds < 0) {
+      tzSign = '-'
+    }
+    const absTzOffsetSeconds = Math.abs(tzOffsetSeconds)
+    const tzOffsetHours = Math.floor(absTzOffsetSeconds / 3600)
+    const tzOffsetMins = Math.floor((absTzOffsetSeconds % 3600) / 60)
+    
+    // Helper function to format fractional seconds
+    const formatFracSeconds = (n: number, trimZeros: boolean): string => {
+      if (n === 0 && trimZeros) return ''
+      let str = n.toString().padStart(9, '0')
+      if (trimZeros) {
+        str = str.replace(/0+$/, '')
+      }
+      return str.length > 0 ? '.' + str : ''
+    }
+
+    let result = ''
+    let i = 0
+    
+    // Process layout character by character, matching Go's nextStdChunk logic
+    while (i < layout.length) {
+      let matched = false
+      
+      // Check for multi-character patterns first (longest matches first)
+      const remaining = layout.slice(i)
+      
+      // Fractional seconds with comma/period
+      if (remaining.match(/^[.,]999999999/)) {
+        result += formatFracSeconds(nsec, true).replace('.', remaining[0])
+        i += 10
+        matched = true
+      } else if (remaining.match(/^[.,]999999/)) {
+        const microseconds = Math.floor(nsec / 1000)
+        let str = microseconds.toString().padStart(6, '0')
+        str = str.replace(/0+$/, '') // trim trailing zeros
+        result += str.length > 0 ? remaining[0] + str : ''
+        i += 7
+        matched = true
+      } else if (remaining.match(/^[.,]999/)) {
+        const milliseconds = Math.floor(nsec / 1000000)
+        let str = milliseconds.toString().padStart(3, '0')
+        str = str.replace(/0+$/, '') // trim trailing zeros
+        result += str.length > 0 ? remaining[0] + str : ''
+        i += 4
+        matched = true
+      } else if (remaining.match(/^[.,]000000000/)) {
+        result += remaining[0] + nsec.toString().padStart(9, '0')
+        i += 10
+        matched = true
+      } else if (remaining.match(/^[.,]000000/)) {
+        result += remaining[0] + Math.floor(nsec / 1000).toString().padStart(6, '0')
+        i += 7
+        matched = true
+      } else if (remaining.match(/^[.,]000/)) {
+        result += remaining[0] + Math.floor(nsec / 1000000).toString().padStart(3, '0')
+        i += 4
+        matched = true
+      }
+      // Full month/day names
+      else if (remaining.startsWith('January')) {
+        result += longMonthNames[month0]
+        i += 7
+        matched = true
+      } else if (remaining.startsWith('Monday')) {
+        result += longDayNames[dayOfWeek]
+        i += 6
+        matched = true
+      }
+      // Year patterns
+      else if (remaining.startsWith('2006')) {
+        result += year.toString()
+        i += 4
+        matched = true
+      }
+      // Timezone patterns (order matters - longer patterns first)
+      else if (remaining.startsWith('Z070000')) {
+        if (isUTC) {
+          result += 'Z'
+        } else {
+          result += `${tzSign}${tzOffsetHours.toString().padStart(2, '0')}${tzOffsetMins.toString().padStart(2, '0')}00`
+        }
+        i += 7
+        matched = true
+      } else if (remaining.startsWith('Z07:00:00')) {
+        if (isUTC) {
+          result += 'Z'
+        } else {
+          result += `${tzSign}${tzOffsetHours.toString().padStart(2, '0')}:${tzOffsetMins.toString().padStart(2, '0')}:00`
+        }
+        i += 9
+        matched = true
+      } else if (remaining.startsWith('Z0700')) {
+        if (isUTC) {
+          result += 'Z'
+        } else {
+          result += `${tzSign}${tzOffsetHours.toString().padStart(2, '0')}${tzOffsetMins.toString().padStart(2, '0')}`
+        }
+        i += 5
+        matched = true
+      } else if (remaining.startsWith('Z07:00')) {
+        if (isUTC) {
+          result += 'Z'
+        } else {
+          result += `${tzSign}${tzOffsetHours.toString().padStart(2, '0')}:${tzOffsetMins.toString().padStart(2, '0')}`
+        }
+        i += 6
+        matched = true
+      } else if (remaining.startsWith('Z07')) {
+        if (isUTC) {
+          result += 'Z'
+        } else {
+          result += `${tzSign}${tzOffsetHours.toString().padStart(2, '0')}`
+        }
+        i += 3
+        matched = true
+      } else if (remaining.startsWith('-070000')) {
+        result += `${tzSign}${tzOffsetHours.toString().padStart(2, '0')}${tzOffsetMins.toString().padStart(2, '0')}00`
+        i += 7
+        matched = true
+      } else if (remaining.startsWith('-07:00:00')) {
+        result += `${tzSign}${tzOffsetHours.toString().padStart(2, '0')}:${tzOffsetMins.toString().padStart(2, '0')}:00`
+        i += 9
+        matched = true
+      } else if (remaining.startsWith('-0700')) {
+        result += `${tzSign}${tzOffsetHours.toString().padStart(2, '0')}${tzOffsetMins.toString().padStart(2, '0')}`
+        i += 5
+        matched = true
+      } else if (remaining.startsWith('-07:00')) {
+        result += `${tzSign}${tzOffsetHours.toString().padStart(2, '0')}:${tzOffsetMins.toString().padStart(2, '0')}`
+        i += 6
+        matched = true
+      } else if (remaining.startsWith('-07')) {
+        result += `${tzSign}${tzOffsetHours.toString().padStart(2, '0')}`
+        i += 3
+        matched = true
+      }
+      // Hour patterns
+      else if (remaining.startsWith('15')) {
+        result += hour24.toString().padStart(2, '0')
+        i += 2
+        matched = true
+      }
+      // Month patterns
+      else if (remaining.startsWith('Jan')) {
+        result += shortMonthNames[month0]
+        i += 3
+        matched = true
+      }
+      // Day patterns
+      else if (remaining.startsWith('Mon')) {
+        result += shortDayNames[dayOfWeek]
+        i += 3
+        matched = true
+      } else if (remaining.startsWith('MST')) {
+        // Use the actual timezone name instead of literal "MST"
+        result += tzName
+        i += 3
+        matched = true
+      }
+      // AM/PM patterns
+      else if (remaining.startsWith('PM')) {
+        result += ampmUpper
+        i += 2
+        matched = true
+      } else if (remaining.startsWith('pm')) {
+        result += ampmLower
+        i += 2
+        matched = true
+      }
+      // Two-digit patterns
+      else if (remaining.startsWith('06')) {
+        result += (year % 100).toString().padStart(2, '0')
+        i += 2
+        matched = true
+      } else if (remaining.startsWith('_2')) {
+        result += dayOfMonth < 10 ? ' ' + dayOfMonth.toString() : dayOfMonth.toString()
+        i += 2
+        matched = true
+      } else if (remaining.startsWith('03')) {
+        result += hour12.toString().padStart(2, '0')
+        i += 2
+        matched = true
+      } else if (remaining.startsWith('01')) {
+        result += (month0 + 1).toString().padStart(2, '0')
+        i += 2
+        matched = true
+      } else if (remaining.startsWith('02')) {
+        result += dayOfMonth.toString().padStart(2, '0')
+        i += 2
+        matched = true
+      } else if (remaining.startsWith('04')) {
+        result += minute.toString().padStart(2, '0')
+        i += 2
+        matched = true
+      } else if (remaining.startsWith('05')) {
+        result += second.toString().padStart(2, '0')
+        i += 2
+        matched = true
+      }
+      // Single digit patterns (must come after two-digit patterns)
+      else if (layout[i] === '3' && (i === 0 || !'0123456789'.includes(layout[i-1]))) {
+        result += hour12.toString()
+        i += 1
+        matched = true
+      } else if (layout[i] === '2' && (i === 0 || !'0123456789'.includes(layout[i-1]))) {
+        result += dayOfMonth.toString()
+        i += 1
+        matched = true
+      } else if (layout[i] === '1' && (i === 0 || !'0123456789'.includes(layout[i-1]))) {
+        result += (month0 + 1).toString()
+        i += 1
+        matched = true
+      }
+      // Special Z handling for standalone Z
+      else if (layout[i] === 'Z' && !remaining.startsWith('Z0')) {
+        result += 'Z'
+        i += 1
+        matched = true
+      }
+      
+      // If no pattern matched, copy the character literally
+      if (!matched) {
+        result += layout[i]
+        i += 1
+      }
+    }
+
+    return result
   }
 
   // Sub returns the duration t-u
@@ -40,7 +333,7 @@ export class Time {
     const newNsec = this._nsec + (durationNs % 1000000)
     const newMonotonic =
       this._monotonic !== undefined ? this._monotonic + durationNs : undefined
-    return new Time(newDate, newNsec, newMonotonic)
+    return new Time(newDate, newNsec, newMonotonic, this._location)
   }
 
   // Equal reports whether t and u represent the same time instant
@@ -79,7 +372,7 @@ export class Time {
   public Round(d: Duration): Time {
     // Implementation would round to nearest duration
     // For now, simplified version that strips monotonic reading
-    return new Time(this._date, this._nsec)
+    return new Time(this._date, this._nsec, undefined, this._location)
   }
 
   // Truncate returns the result of rounding t down to a multiple of d
@@ -87,7 +380,7 @@ export class Time {
   public Truncate(d: Duration): Time {
     // Implementation would truncate to duration
     // For now, simplified version that strips monotonic reading
-    return new Time(this._date, this._nsec)
+    return new Time(this._date, this._nsec, undefined, this._location)
   }
 
   // String returns the time formatted as a string
@@ -156,14 +449,20 @@ export function multiplyDuration(
 // Location represents a time zone
 export class Location {
   private _name: string
+  private _offsetSeconds?: number
 
-  constructor(name: string) {
+  constructor(name: string, offsetSeconds?: number) {
     this._name = name
+    this._offsetSeconds = offsetSeconds
   }
 
   public get name(): string {
     return this._name
   }
+
+  public get offsetSeconds(): number | undefined {
+    return this._offsetSeconds
+  }
 }
 
 // Month represents a month of the year
@@ -212,9 +511,10 @@ export function Date(
   loc: Location,
 ): Time {
   let date: globalThis.Date
-  if (loc.name === 'UTC') {
-    // Use Date.UTC for proper UTC handling
-    const utcTime = globalThis.Date.UTC(
+  
+  if (loc.offsetSeconds !== undefined) {
+    // For fixed timezone locations, create the date in the local timezone and then convert to UTC
+    const localTime = globalThis.Date.UTC(
       year,
       month - 1,
       day,
@@ -223,7 +523,9 @@ export function Date(
       sec,
       Math.floor(nsec / 1000000),
     )
-    date = new globalThis.Date(utcTime)
+    // Subtract the offset to convert local time to UTC
+    // (if offset is -7*3600 for PDT, local time - (-7*3600) = local time + 7*3600 = UTC)
+    date = new globalThis.Date(localTime - loc.offsetSeconds * 1000)
   } else {
     // For local time or other timezones, use regular Date constructor
     date = new globalThis.Date(
@@ -236,11 +538,16 @@ export function Date(
       Math.floor(nsec / 1000000),
     )
   }
-  return new Time(date, nsec % 1000000) // No monotonic reading
+  return new Time(date, nsec % 1000000000, undefined, loc) // No monotonic reading
 }
 
 // Common locations
-export const UTC = new Location('UTC')
+export const UTC = new Location('UTC', 0)
+
+// FixedZone returns a Location that always uses the given zone name and offset (seconds east of UTC)
+export function FixedZone(name: string, offset: number): Location {
+  return new Location(name, offset)
+}
 
 // Common durations (matching Go's time package constants)
 export const Nanosecond = new Duration(1)
@@ -270,3 +577,9 @@ export async function Sleep(d: Duration): Promise<void> {
 
 // Export month constants
 export const May = Month.May
+
+// 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 Kitchen = "3:04PM"

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "goscript",
   "description": "Go to TypeScript transpiler",
-  "version": "0.0.28",
+  "version": "0.0.29",
   "author": {
     "name": "Aperture Robotics LLC.",
     "email": "support@aperture.us",

package/gs/time/godoc.md

@@ -1,116 +0,0 @@
-package time // import "time"
-
-Package time provides functionality for measuring and displaying time.
-
-The calendrical calculations always assume a Gregorian calendar, with no leap
-seconds.
-
-# Monotonic Clocks
-
-Operating systems provide both a “wall clock,” which is subject to changes
-for clock synchronization, and a “monotonic clock,” which is not. The general
-rule is that the wall clock is for telling time and the monotonic clock is for
-measuring time. Rather than split the API, in this package the Time returned by
-time.Now contains both a wall clock reading and a monotonic clock reading; later
-time-telling operations use the wall clock reading, but later time-measuring
-operations, specifically comparisons and subtractions, use the monotonic clock
-reading.
-
-For example, this code always computes a positive elapsed time of approximately
-20 milliseconds, even if the wall clock is changed during the operation being
-timed:
-
-    start := time.Now()
-    ... operation that takes 20 milliseconds ...
-    t := time.Now()
-    elapsed := t.Sub(start)
-
-Other idioms, such as time.Since(start), time.Until(deadline), and
-time.Now().Before(deadline), are similarly robust against wall clock resets.
-
-The rest of this section gives the precise details of how operations use
-monotonic clocks, but understanding those details is not required to use this
-package.
-
-The Time returned by time.Now contains a monotonic clock reading. If Time t
-has a monotonic clock reading, t.Add adds the same duration to both the wall
-clock and monotonic clock readings to compute the result. Because t.AddDate(y,
-m, d), t.Round(d), and t.Truncate(d) are wall time computations, they always
-strip any monotonic clock reading from their results. Because t.In, t.Local,
-and t.UTC are used for their effect on the interpretation of the wall time,
-they also strip any monotonic clock reading from their results. The canonical
-way to strip a monotonic clock reading is to use t = t.Round(0).
-
-If Times t and u both contain monotonic clock readings, the operations
-t.After(u), t.Before(u), t.Equal(u), t.Compare(u), and t.Sub(u) are carried out
-using the monotonic clock readings alone, ignoring the wall clock readings.
-If either t or u contains no monotonic clock reading, these operations fall back
-to using the wall clock readings.
-
-On some systems the monotonic clock will stop if the computer goes to sleep.
-On such a system, t.Sub(u) may not accurately reflect the actual time that
-passed between t and u. The same applies to other functions and methods that
-subtract times, such as Since, Until, Time.Before, Time.After, Time.Add,
-Time.Equal and Time.Compare. In some cases, you may need to strip the monotonic
-clock to get accurate results.
-
-Because the monotonic clock reading has no meaning outside the current process,
-the serialized forms generated by t.GobEncode, t.MarshalBinary, t.MarshalJSON,
-and t.MarshalText omit the monotonic clock reading, and t.Format provides
-no format for it. Similarly, the constructors time.Date, time.Parse,
-time.ParseInLocation, and time.Unix, as well as the unmarshalers t.GobDecode,
-t.UnmarshalBinary. t.UnmarshalJSON, and t.UnmarshalText always create times with
-no monotonic clock reading.
-
-The monotonic clock reading exists only in Time values. It is not a part of
-Duration values or the Unix times returned by t.Unix and friends.
-
-Note that the Go == operator compares not just the time instant but also the
-Location and the monotonic clock reading. See the documentation for the Time
-type for a discussion of equality testing for Time values.
-
-For debugging, the result of t.String does include the monotonic clock
-reading if present. If t != u because of different monotonic clock readings,
-that difference will be visible when printing t.String() and u.String().
-
-# Timer Resolution
-
-Timer resolution varies depending on the Go runtime, the operating system
-and the underlying hardware. On Unix, the resolution is ~1ms. On Windows
-version 1803 and newer, the resolution is ~0.5ms. On older Windows versions,
-the default resolution is ~16ms, but a higher resolution may be requested using
-golang.org/x/sys/windows.TimeBeginPeriod.
-
-const Layout = "01/02 03:04:05PM '06 -0700" ...
-const Nanosecond Duration = 1 ...
-func After(d Duration) <-chan Time
-func Sleep(d Duration)
-func Tick(d Duration) <-chan Time
-type Duration int64
-    func ParseDuration(s string) (Duration, error)
-    func Since(t Time) Duration
-    func Until(t Time) Duration
-type Location struct{ ... }
-    var Local *Location = &localLoc
-    var UTC *Location = &utcLoc
-    func FixedZone(name string, offset int) *Location
-    func LoadLocation(name string) (*Location, error)
-    func LoadLocationFromTZData(name string, data []byte) (*Location, error)
-type Month int
-    const January Month = 1 + iota ...
-type ParseError struct{ ... }
-type Ticker struct{ ... }
-    func NewTicker(d Duration) *Ticker
-type Time struct{ ... }
-    func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time
-    func Now() Time
-    func Parse(layout, value string) (Time, error)
-    func ParseInLocation(layout, value string, loc *Location) (Time, error)
-    func Unix(sec int64, nsec int64) Time
-    func UnixMicro(usec int64) Time
-    func UnixMilli(msec int64) Time
-type Timer struct{ ... }
-    func AfterFunc(d Duration, f func()) *Timer
-    func NewTimer(d Duration) *Timer
-type Weekday int
-    const Sunday Weekday = iota ...