firefly-compiler 0.5.49 → 0.5.51

package/experimental/date/Date.ff

@@ -0,0 +1,604 @@
+// Temporal.ZonedDateTime but with consistent equals/compare
+newtype Date(jsValue: JsValue)
+
+data DateGap(
+    years: Int = 0
+    months: Int = 0
+    weeks: Int = 0
+    days: Int = 0
+    hours: Int = 0
+    minutes: Int = 0
+    seconds: Int = 0
+    milliseconds: Int = 0
+    microseconds: Int = 0
+    nanoseconds: Int = 0
+)
+
+new(
+    timeZoneId: String
+    year: Int
+    month: Int
+    day: Int
+    hour: Int = 0
+    minute: Int = 0
+    second: Int = 0
+    millisecond: Int = 0
+    microsecond: Int = 0
+    nanosecond: Int = 0
+    calendarId: String = "iso8601"
+    offset: Option[String] = None
+    earlier: Bool = True
+    later: Bool = True
+): Date {
+    Date(Js->Temporal->ZonedDateTime->from(Js->(
+        timeZone = timeZoneId
+        year = year
+        month = month
+        day = day
+        hour = hour
+        minute = minute
+        second = second
+        millisecond = millisecond
+        microsecond = microsecond
+        nanosecond = nanosecond
+        calendar = calendarId
+        offset = offset.map {_!}.else {Js.undefined()}
+    ), internalDisambiguation(earlier, later)))
+}
+
+newEra(
+    calendarId: String
+    timeZoneId: String
+    era: String
+    eraYear: Int
+    month: Int
+    day: Int
+    hour: Int = 0
+    minute: Int = 0
+    second: Int = 0
+    millisecond: Int = 0
+    microsecond: Int = 0
+    nanosecond: Int = 0
+    offset: Option[String] = None
+    earlier: Bool = True
+    later: Bool = True
+): Date {
+    Date(Js->Temporal->ZonedDateTime->from(Js->(
+        timeZone = timeZoneId
+        era = era
+        eraYear = eraYear
+        month = month
+        day = day
+        hour = hour
+        minute = minute
+        second = second
+        millisecond = millisecond
+        microsecond = microsecond
+        nanosecond = nanosecond
+        calendar = calendarId
+        offset = offset.map {_!}.else {Js.undefined()}
+    ), internalDisambiguation(earlier, later)))
+}
+
+newEpochMilliseconds(timeZoneId: String, epochMilliseconds: Int, calendarId: String = "iso8601"): Date {
+    let zoned = Js->Temporal->Instant->fromEpochMilliseconds(epochMilliseconds)->toZonedDateTimeISO(timeZoneId)
+    if(calendarId != "iso8601") {Date(zoned->withCalendar(calendarId))} else {Date(zoned)}
+}
+
+newRfc9557(rfc9557: String): Date {
+    Date(Js->Temporal->ZonedDateTime->from(rfc9557))
+}
+
+gap(iso8601: String): DateGap {
+    let duration = Js->Temporal->Duration->from(iso8601)
+    DateGap(
+        years = duration->years?
+        months = duration->months?
+        weeks = duration->weeks?
+        days = duration->days?
+        hours = duration->hours?
+        minutes = duration->minutes?
+        seconds = duration->seconds?
+        milliseconds = duration->milliseconds?
+        microseconds = duration->microseconds?
+        nanoseconds = duration->nanoseconds?
+    )
+}
+
+instance Date: Equal {
+    equals(x: Date, y: Date): Bool {
+        x.jsValue->equals(y.jsValue)?
+    }    
+}
+
+instance Date: Order {
+    compare(x: Date, y: Date): Ordering {
+        let instant: Int = Js->Temporal->ZonedDateTime->compare(x.jsValue, y.jsValue)?
+        if(instant != 0) {Ordering.fromInt(instant)} else:
+        let timeZone = Ordering.compare(x.timeZoneId(), y.timeZoneId())
+        if(timeZone != OrderingSame) {timeZone} else:
+        Ordering.compare(x.calendarId(), y.calendarId())
+    }
+}
+
+instance Date: HasAnyTag {
+    anyTag(): AnyTag[Date] {
+        Any.internalAnyTag("ff:core/Date.Date[]")
+    }
+}
+
+instance Date: Show {
+    show(value: Date): String {
+        value.toRfc9557()
+    }
+}
+
+instance Date: Serializable {
+    
+    serializeUsing(serialization: Serialization, value: Date): Unit {
+        Serializable.serializeUsing(serialization, value.toRfc9557())
+    }
+    
+    deserializeUsing(serialization: Serialization): Date {
+        newRfc9557(Serializable.deserializeUsing(serialization))
+    }
+    
+}
+
+extend self: Date {
+    
+    timeZoneId(): String {
+        self.jsValue->timeZoneId?
+    }
+    
+    calendarId(): String {
+        self.jsValue->calendarId?
+    }
+    
+    day(): Int {
+        self.jsValue->day?
+    }
+    
+    dayOfWeek(): Int {
+        self.jsValue->dayOfWeek?
+    }
+    
+    dayOfYear(): Int {
+        self.jsValue->dayOfYear?
+    }
+    
+    daysInWeek(): Int {
+        self.jsValue->daysInWeek?
+    }
+    
+    daysInMonth(): Int {
+        self.jsValue->daysInMonth?
+    }
+    
+    daysInYear(): Int {
+        self.jsValue->daysInYear?
+    }
+    
+    epochMilliseconds(): Int {
+        self.jsValue->epochMilliseconds?
+    }
+    
+    era(): Option[String] {
+        let era = self.jsValue->era
+        if(!era.isNullOrUndefined()) {era?}
+    }
+    
+    eraYear(): Option[Int] {
+        let eraYear = self.jsValue->eraYear
+        if(!eraYear.isNullOrUndefined()) {eraYear?}
+    }
+    
+    hour(): Int {
+        self.jsValue->hour?
+    }
+    
+    hoursInDay(): Int {
+        self.jsValue->hoursInDay?
+    }
+
+    inLeapYear(): Bool {
+        self.jsValue->inLeapYear?
+    }
+
+    microsecond(): Int {
+        self.jsValue->microsecond?
+    }
+
+    millisecond(): Int {
+        self.jsValue->millisecond?
+    }
+
+    minute(): Int {
+        self.jsValue->minute?
+    }
+
+    month(): Int {
+        self.jsValue->month?
+    }
+
+    monthCode(): String {
+        self.jsValue->monthCode?
+    }
+
+    monthsInYear(): Int {
+        self.jsValue->monthsInYear?
+    }
+
+    nanosecond(): Int {
+        self.jsValue->nanosecond?
+    }
+
+    offset(): String {
+        self.jsValue->offset?
+    }
+
+    offsetNanoseconds(): Int {
+        self.jsValue->offsetNanoseconds?
+    }
+
+    second(): Int {
+        self.jsValue->second?
+    }
+
+    weekOfYear(): Int {
+        self.jsValue->weekOfYear?
+    }
+
+    year(): Int {
+        self.jsValue->year?
+    }
+
+    yearOfWeek(): Int {
+        self.jsValue->yearOfWeek?
+    }
+    
+    nextTimeZoneTransition(): Date {
+        Date(self.jsValue->getTimeZoneTransition("next"))
+    }
+    
+    previousTimeZoneTransition(): Date {
+        Date(self.jsValue->getTimeZoneTransition("previous"))
+    }
+    
+    startOfYear(): Date {
+        Date(self.jsValue->with(Js->(year = self.year(), month = 1, day = 1))->startOfDay())
+    }
+
+    startOfMonth(): Date {
+        Date(self.jsValue->with(Js->(year = self.year(), month = self.month(), day = 1))->startOfDay())
+    }
+    
+    startOfWeek(firstDayOfWeek: Int = 1): Date {
+        let offset = ((self.dayOfWeek() - firstDayOfWeek) + self.daysInWeek()) % self.daysInWeek()
+        Date(self.jsValue->subtract(Js->(day = offset))->startOfDay())
+    }
+    
+    startOfDay(): Date {
+        Date(self.jsValue->startOfDay())
+    }
+
+    startOfHour(): Date {
+        Date(self.jsValue->round(Js->(smallestUnit = "hour", roundingMode = "floor")))
+    }
+    
+    startOfMinute(): Date {
+        Date(self.jsValue->round(Js->(smallestUnit = "minute", roundingMode = "floor")))
+    }
+    
+    startOfSecond(): Date {
+        Date(self.jsValue->round(Js->(smallestUnit = "second", roundingMode = "floor")))
+    }
+    
+    startOfMillisecond(): Date {
+        Date(self.jsValue->round(Js->(smallestUnit = "millisecond", roundingMode = "floor")))
+    }
+    
+    startOfMicrosecond(): Date {
+        Date(self.jsValue->round(Js->(smallestUnit = "microsecond", roundingMode = "floor")))
+    }
+    
+    toRfc9557(
+        smallestUnit: Option[String] = None
+        fractionalSecondDigits: Option[Int] = None
+        roundingMode: String = "trunc"
+        timeZoneName: String = "auto"
+        offset: String = "auto"
+        calendarName: String = "auto"
+    ): String {
+        self.jsValue->toString(Js->(
+            calendarName = calendarName
+            fractionalSecondDigits = fractionalSecondDigits.map {_!}.else {"auto"!}
+            roundingMode = roundingMode
+            smallestUnit = smallestUnit.map {_!}.else {Js.undefined()}
+            timeZoneName = timeZoneName
+            offset = offset
+        ))?
+    }
+    
+    withCalendar(calendarId: String): Date {
+        Date(self.jsValue->withCalendar(calendarId))
+    }
+    
+    withTimeZone(timeZoneId: String): Date {
+        Date(self.jsValue->withTimeZone(timeZoneId))
+    }
+    
+    withEra(era: String, eraYear: Int, earlier: Bool = True, later: Bool = True): Date {
+        Date(self.jsValue->with(Js->(era = era, eraYear = eraYear), internalDisambiguation(earlier, later)))
+    }
+    
+    with(
+        year: Option[Int] = None
+        month: Option[Int] = None
+        week: Option[Int] = None
+        day: Option[Int] = None
+        hour: Option[Int] = None
+        minute: Option[Int] = None
+        second: Option[Int] = None
+        millisecond: Option[Int] = None
+        microsecond: Option[Int] = None
+        nanosecond: Option[Int] = None
+        offset: Option[String] = None
+        earlier: Bool = True
+        later: Bool = True
+    ): Date {
+        Date(self.jsValue->with(Js->(
+            year = year.map {_!}.else {Js.undefined()} 
+            month = month.map {_!}.else {Js.undefined()} 
+            week = week.map {_!}.else {Js.undefined()} 
+            day = day.map {_!}.else {Js.undefined()} 
+            hour = hour.map {_!}.else {Js.undefined()} 
+            minute = minute.map {_!}.else {Js.undefined()} 
+            second = second.map {_!}.else {Js.undefined()} 
+            millisecond = millisecond.map {_!}.else {Js.undefined()} 
+            microsecond = microsecond.map {_!}.else {Js.undefined()} 
+            nanosecond = nanosecond.map {_!}.else {Js.undefined()}
+            offset = offset.map {_!}.else {Js.undefined()}
+        ), internalDisambiguation(earlier, later)))
+    }
+    
+    add(
+        years: Int = 0
+        months: Int = 0
+        weeks: Int = 0
+        days: Int = 0
+        hours: Int = 0
+        minutes: Int = 0
+        seconds: Int = 0
+        milliseconds: Int = 0
+        microseconds: Int = 0
+        nanoseconds: Int = 0
+    ): Date {
+        Date(self.jsValue->add(Js->(
+            years = years
+            months = months
+            weeks = weeks
+            days = days
+            hours = hours
+            minutes = minutes
+            seconds = seconds
+            milliseconds = milliseconds
+            microseconds = microseconds
+            nanoseconds = nanoseconds
+        )))
+    }
+    
+    subtract(
+        years: Int = 0
+        months: Int = 0
+        weeks: Int = 0
+        days: Int = 0
+        hours: Int = 0
+        minutes: Int = 0
+        seconds: Int = 0
+        milliseconds: Int = 0
+        microseconds: Int = 0
+        nanoseconds: Int = 0
+    ): Date {
+        Date(self.jsValue->subtract(Js->(
+            years = years
+            months = months
+            weeks = weeks
+            days = days
+            hours = hours
+            minutes = minutes
+            seconds = seconds
+            milliseconds = milliseconds
+            microseconds = microseconds
+            nanoseconds = nanoseconds
+        )))
+    }
+    
+    addGap(gap: DateGap): Date {
+        Date(self.jsValue->add(Js->(
+            years = gap.years
+            months = gap.months
+            weeks = gap.weeks
+            days = gap.days
+            hours = gap.hours
+            minutes = gap.minutes
+            seconds = gap.seconds
+            milliseconds = gap.milliseconds
+            microseconds = gap.microseconds
+            nanoseconds = gap.nanoseconds
+        )))
+    }
+    
+    subtractGap(gap: DateGap): Date {
+        Date(self.jsValue->add(Js->(
+            years = gap.years
+            months = gap.months
+            weeks = gap.weeks
+            days = gap.days
+            hours = gap.hours
+            minutes = gap.minutes
+            seconds = gap.seconds
+            milliseconds = gap.milliseconds
+            microseconds = gap.microseconds
+            nanoseconds = gap.nanoseconds
+        )))
+    }
+    
+    since(that: Date): DateGap {
+        let duration = self.jsValue->since(that.jsValue)
+        DateGap(
+            years = duration->years?
+            months = duration->months?
+            weeks = duration->weeks?
+            days = duration->days?
+            hours = duration->hours?
+            minutes = duration->minutes?
+            seconds = duration->seconds?
+            milliseconds = duration->milliseconds?
+            microseconds = duration->microseconds?
+            nanoseconds = duration->nanoseconds?
+        )
+    }
+    
+    until(that: Date): DateGap {
+        let duration = self.jsValue->until(that.jsValue)
+        DateGap(
+            years = duration->years?
+            months = duration->months?
+            weeks = duration->weeks?
+            days = duration->days?
+            hours = duration->hours?
+            minutes = duration->minutes?
+            seconds = duration->seconds?
+            milliseconds = duration->milliseconds?
+            microseconds = duration->microseconds?
+            nanoseconds = duration->nanoseconds?
+        )
+    }
+    
+    yearsSince(that: Date): Float {
+        let duration = self.jsValue->since(that.jsValue)
+        duration->total(Js->(unit = "years", relativeTo = that.jsValue))?
+    }
+    
+    monthsSince(that: Date): Float {
+        let duration = self.jsValue->since(that.jsValue)
+        duration->total(Js->(unit = "months", relativeTo = that.jsValue))?
+    }
+    
+    weeksSince(that: Date): Float {
+        let duration = self.jsValue->since(that.jsValue)
+        duration->total(Js->(unit = "weeks", relativeTo = that.jsValue))?
+    }
+    
+    daysSince(that: Date): Float {
+        let duration = self.jsValue->since(that.jsValue)
+        duration->total(Js->(unit = "days", relativeTo = that.jsValue))?
+    }
+    
+    hoursSince(that: Date): Float {
+        let duration = self.jsValue->since(that.jsValue)
+        duration->total(Js->(unit = "hours", relativeTo = that.jsValue))?
+    }
+    
+    minutesSince(that: Date): Float {
+        let duration = self.jsValue->since(that.jsValue)
+        duration->total(Js->(unit = "minutes", relativeTo = that.jsValue))?
+    }
+    
+    secondsSince(that: Date): Float {
+        let duration = self.jsValue->since(that.jsValue)
+        duration->total(Js->(unit = "seconds", relativeTo = that.jsValue))?
+    }
+    
+    millisecondsSince(that: Date): Float {
+        let duration = self.jsValue->since(that.jsValue)
+        duration->total(Js->(unit = "milliseconds", relativeTo = that.jsValue))?
+    }
+    
+    microsecondsSince(that: Date): Float {
+        let duration = self.jsValue->since(that.jsValue)
+        duration->total(Js->(unit = "microseconds", relativeTo = that.jsValue))?
+    }
+    
+    nanosecondsSince(that: Date): Float {
+        let duration = self.jsValue->since(that.jsValue)
+        duration->total(Js->(unit = "nanoseconds", relativeTo = that.jsValue))?
+    }
+    
+    toStream(next: Date => Date): Stream[Date] {
+        mutable date = self
+        Stream.new {
+            let current = date
+            date = next(date)
+            Some(current)
+        }
+    }
+    
+}
+
+extend self: DateGap {
+
+    toIso8601(
+        smallestUnit: Option[String] = None
+        fractionalSecondDigits: Option[Int] = None
+        roundingMode: String = "trunc"
+    ): String {
+        let duration = Js->Temporal->Duration->from(Js->(
+            years = self.years
+            months = self.months
+            weeks = self.weeks
+            days = self.days
+            hours = self.hours
+            minutes = self.minutes
+            seconds = self.seconds
+            milliseconds = self.milliseconds
+            microseconds = self.microseconds
+            nanoseconds = self.nanoseconds
+        ))
+        duration->toString(Js->(
+            smallestUnit = smallestUnit.map {_!}.else {Js.undefined()}
+            fractionalSecondDigits = fractionalSecondDigits.map {_!}.else {"auto"!}
+            roundingMode = roundingMode
+        ))?
+    }
+    
+}
+
+utcTimeZoneId: String = "UTC"
+isoCalendarId: String = "iso8601"
+
+monday: Int = 1
+tuesday: Int = 2
+wednesday: Int = 3
+thursday: Int = 4
+friday: Int = 5
+saturday: Int = 6
+sunday: Int = 7
+
+january: Int = 1
+february: Int = 2
+march: Int = 3
+april: Int = 4
+may: Int = 5
+june: Int = 6
+july: Int = 7
+august: Int = 8
+september: Int = 9
+october: Int = 10
+november: Int = 11
+december: Int = 12
+
+internalDisambiguation(earlier: Bool, later: Bool): JsValue {
+    Js->(
+        disambiguation = if(earlier && later) {
+            "compatible"
+        } elseIf {earlier} {
+            "earlier"
+        } elseIf {later} {
+            "later"
+        } else {
+            "reject"
+        }
+    )    
+}

package/experimental/date/Main.ff

@@ -0,0 +1,51 @@
+dependency ff:webserver:0.0.0
+import WebServer from ff:webserver
+import Date
+
+browserMain(system: BrowserSystem) {
+    let now = Date.new("Europe/Copenhagen", 2025, 2, 1, 18, 0, 0)
+    let firstTuesday = now.toStream {_.add(days = 1)}.find {_.dayOfWeek() == Date.tuesday}
+    let tuesdays = firstTuesday.grab().toStream {_.add(weeks = 1)}
+    let meetups = tuesdays.filter {d => d.add(weeks = 1).month() > d.month()}
+    meetups.takeWhile {_.year() == 2025}.each {meetup =>
+        Log.debug("Meetup: " + meetup.toRfc9557())
+    }
+}
+
+buildMain(system: BuildSystem) {
+    let jsAssets = system.compileForBrowser(["Main.ff"])
+    Log.debug(jsAssets.list("/").join(" "))
+    let assets = AssetSystem.create().addAssets("/js", jsAssets)
+    Log.debug(assets.files.keys().toList().join(" "))
+    system.setAssets(assets)
+}
+
+nodeMain(system: NodeSystem) {
+    let host = system.arguments().grab(0)
+    let port = system.arguments().grab(1).grabInt()
+    WebServer.new(system, host, port).listen {request =>
+        let path = request.readPath()
+        let segments = path.split('/').filter {s => s != "" && s != "." && s != ".."}
+        segments.{
+            | ["js", ...] => 
+                request.writeHeader("Content-Type", "text/javascript; charset=UTF-8")
+                request.writeStream(system.assets().readStream(path))
+            | [] =>
+                request.writeHeader("Content-Type", "text/html; charset=UTF-8")
+                request.writeText("<!doctype html>")
+                request.writeText("<html lang='en' style='background-color: #ffffff; color: #333333; width: 100%; height: 100%; color-scheme: light;'>")
+                request.writeText("<head>")
+                request.writeText("<title>Date</title>")
+                request.writeText("<meta name='viewport' content='width=device-width, initial-scale=1.0'>")
+                request.writeText("<meta name='theme-color' content='#ecc45e'>")
+                request.writeText("<script src='https://cdn.jsdelivr.net/npm/temporal-polyfill@0.2.5/global.min.js'></script>")
+                request.writeText("<script type='module' src='" + "/js/script/script/Main.mjs" + "'></script>")
+                request.writeText("</head>")
+                request.writeText("<body style='margin: 0; padding: 0; width: 100%; height: 100%; touch-action: manipulation;'>")
+                request.writeText("</body>")
+                request.writeText("</html>")
+            | _ =>
+                request.writeStatus("404 Not Found")
+        }
+    }
+}

package/experimental/random/AsciiBuffer.ff

@@ -0,0 +1,15 @@
+nodeMain(system: NodeSystem) {
+    let random = Random.newFromInt(42)
+    let buffer = Buffer.new(10000)
+    random.nextBytes(buffer, 0, buffer.size())
+    //0.until(buffer.size()).each {i => buffer.setUint8(i, buffer.grabUint8(i).bitAnd(0x1f))}
+    Log.debug(Buffer.fromByteList(buffer.toByteList().sort()).toLetter16())
+    let x = Buffer.fromByteList([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 100, 101, 102, 103, 104, 105])
+    let a = x.toLetter16()
+    let b = Buffer.fromLetter16(a.upper())
+    Log.debug(x.toByteList().map {Show.show(_)}.join(" "))
+    Log.debug(a)
+    Log.debug(b.toByteList().map {Show.show(_)}.join(" "))
+    Log.debug(Show.show((16.bitAnd(0x0f) + 0x68)))
+    Log.debug(Show.show((16.bitRightUnsigned(4).bitAnd(0x0f) + 0x68).bitLeft(8)))
+}

package/experimental/rhymeapp/Main.ff

@@ -52,11 +52,10 @@ nodeMain(system: NodeSystem): Unit {
 }
 
 buildMain(system: BuildSystem) {
-    let browser: BrowserCode = system.compileForBrowser("Main.ff")
     let browserAssets = if(system.buildMode()) {
-        browser.bundle().assets()
+        system.bundleForBrowser(["Main.ff"])
     } else {
-        browser.assets()
+        system.compileForBrowser(["Main.ff"])
     }
     let indexAssets = if(system.buildMode()) {
         let html = system.packageAssets().readText("/index.html")

package/experimental/site/Main.ff

@@ -33,8 +33,8 @@ nodeMain(system: NodeSystem): Unit {
 buildMain(system: BuildSystem) {
     mutable assets = AssetSystem.create()
     Routes.routes.each {route =>
-        let browser = system.compileForBrowser(route.page + ".ff") // .bundle()
-        assets = assets.addAssets("/js/", browser.assets())
+        let browser = system.compileForBrowser([route.page + ".ff"])
+        assets = assets.addAssets("/js/", browser)
     }
     system.setAssets(assets)
 }

package/experimental/site2/Main.ff

@@ -30,8 +30,8 @@ nodeMain(system: NodeSystem): Unit {
 buildMain(system: BuildSystem) {
     mutable assets = AssetSystem.create()
     Router.modulesWithBrowserMain.each {moduleName =>
-        let browser = system.compileForBrowser(moduleName + ".ff") // .bundle()
-        assets = assets.addAssets("/js/", browser.assets())
+        let browser = system.compileForBrowser([moduleName + ".ff"])
+        assets = assets.addAssets("/js/", browser)
     }
     system.setAssets(assets)
 }