firefly-compiler 0.5.35 → 0.5.37

package/output/js/ff/core/Try.mjs

@@ -42,6 +42,8 @@ import * as ff_core_Int from "../../ff/core/Int.mjs"
 
 import * as ff_core_IntMap from "../../ff/core/IntMap.mjs"
 
+import * as ff_core_Js from "../../ff/core/Js.mjs"
+
 import * as ff_core_JsSystem from "../../ff/core/JsSystem.mjs"
 
 import * as ff_core_JsValue from "../../ff/core/JsValue.mjs"
@@ -68,6 +70,8 @@ import * as ff_core_Pair from "../../ff/core/Pair.mjs"
 
 import * as ff_core_Path from "../../ff/core/Path.mjs"
 
+import * as ff_core_Queue from "../../ff/core/Queue.mjs"
+
 import * as ff_core_Random from "../../ff/core/Random.mjs"
 
 import * as ff_core_Serializable from "../../ff/core/Serializable.mjs"
@@ -90,8 +94,6 @@ import * as ff_core_Try from "../../ff/core/Try.mjs"
 
 import * as ff_core_Unit from "../../ff/core/Unit.mjs"
 
-import * as ff_core_UnsafeJs from "../../ff/core/UnsafeJs.mjs"
-
 // type Try
 export function Success(value_) {
 return {Success: true, value_};
@@ -120,7 +122,7 @@ return body_(value_)
 }))
 return
 }
-if(_1.Failure) {
+{
 const error_ = _1.error_;
 return ff_core_Try.Failure(error_)
 }
@@ -171,7 +173,7 @@ const value_ = _1.value_;
 body_();
 return value_
 }
-if(_1.Failure) {
+{
 body_();
 return ff_core_Try.Try_grab(self_)
 }
@@ -227,7 +229,7 @@ return value_
 }))
 return
 }
-if(_1.Failure) {
+{
 {
 const _1 = ff_core_Core.try_((() => {
 return body_()
@@ -235,7 +237,7 @@ return body_()
 if(_1.Success) {
 return self_
 }
-if(_1.Failure) {
+{
 const error_ = _1.error_;
 return ff_core_Try.Failure(error_)
 }
@@ -252,7 +254,7 @@ if(_1.Success) {
 const value_ = _1.value_;
 return value_
 }
-if(_1.Failure) {
+{
 return body_()
 }
 }
@@ -265,7 +267,7 @@ if(_1.Success) {
 const value_ = _1.value_;
 return value_
 }
-if(_1.Failure) {
+{
 const error_ = _1.error_;
 return ff_core_Error.Error_rethrow(error_)
 }
@@ -279,7 +281,7 @@ if(_1.Success) {
 const value_ = _1.value_;
 return ff_core_Option.Some(value_)
 }
-if(_1.Failure) {
+{
 return ff_core_Option.None()
 }
 }
@@ -295,7 +297,7 @@ return (await body_(value_, $task))
 }), $task))
 return
 }
-if(_1.Failure) {
+{
 const error_ = _1.error_;
 return ff_core_Try.Failure(error_)
 }
@@ -346,7 +348,7 @@ const value_ = _1.value_;
 (await body_($task));
 return value_
 }
-if(_1.Failure) {
+{
 (await body_($task));
 return ff_core_Try.Try_grab(self_)
 }
@@ -402,7 +404,7 @@ return value_
 }), $task))
 return
 }
-if(_1.Failure) {
+{
 {
 const _1 = (await ff_core_Core.try_$((async ($task) => {
 return (await body_($task))
@@ -410,7 +412,7 @@ return (await body_($task))
 if(_1.Success) {
 return self_
 }
-if(_1.Failure) {
+{
 const error_ = _1.error_;
 return ff_core_Try.Failure(error_)
 }
@@ -427,7 +429,7 @@ if(_1.Success) {
 const value_ = _1.value_;
 return value_
 }
-if(_1.Failure) {
+{
 return (await body_($task))
 }
 }
@@ -440,7 +442,7 @@ if(_1.Success) {
 const value_ = _1.value_;
 return value_
 }
-if(_1.Failure) {
+{
 const error_ = _1.error_;
 return ff_core_Error.Error_rethrow(error_)
 }
@@ -454,7 +456,7 @@ if(_1.Success) {
 const value_ = _1.value_;
 return ff_core_Option.Some(value_)
 }
-if(_1.Failure) {
+{
 return ff_core_Option.None()
 }
 }
@@ -471,7 +473,7 @@ if(_1.Success && _1.value_.Failure) {
 const t_ = _1.value_;
 return t_
 }
-if(_1.Failure) {
+{
 const error_ = _1.error_;
 return ff_core_Try.Failure(error_)
 }
@@ -489,7 +491,7 @@ if(_1.Success && _1.value_.Failure) {
 const t_ = _1.value_;
 return t_
 }
-if(_1.Failure) {
+{
 const error_ = _1.error_;
 return ff_core_Try.Failure(error_)
 }

package/output/js/ff/core/Unit.mjs

@@ -42,6 +42,8 @@ import * as ff_core_Int from "../../ff/core/Int.mjs"
 
 import * as ff_core_IntMap from "../../ff/core/IntMap.mjs"
 
+import * as ff_core_Js from "../../ff/core/Js.mjs"
+
 import * as ff_core_JsSystem from "../../ff/core/JsSystem.mjs"
 
 import * as ff_core_JsValue from "../../ff/core/JsValue.mjs"
@@ -68,6 +70,8 @@ import * as ff_core_Pair from "../../ff/core/Pair.mjs"
 
 import * as ff_core_Path from "../../ff/core/Path.mjs"
 
+import * as ff_core_Queue from "../../ff/core/Queue.mjs"
+
 import * as ff_core_Random from "../../ff/core/Random.mjs"
 
 import * as ff_core_Serializable from "../../ff/core/Serializable.mjs"
@@ -90,8 +94,6 @@ import * as ff_core_Try from "../../ff/core/Try.mjs"
 
 import * as ff_core_Unit from "../../ff/core/Unit.mjs"
 
-import * as ff_core_UnsafeJs from "../../ff/core/UnsafeJs.mjs"
-
 // type Unit
 const Unit$ = {Unit: true};
 export function Unit() {

package/package.json

@@ -4,7 +4,7 @@
     "description": "Firefly compiler",
     "author": "Firefly team",
     "license": "MIT",
-    "version": "0.5.35",
+    "version": "0.5.37",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"

package/postgresql/Pg.ff

@@ -20,14 +20,13 @@ newPool(
     maxConnections: Int = 10
     allowExitOnIdle: Bool = True
 ): PgPool {
-    UnsafeJs.throwIfCancelled()
-    let js = UnsafeJs.jsSystem()
-    let pg = UnsafeJs.import("pg").get("default")
-    PgPool(pg.get("Pool").new1(js.object()
+    Js.throwIfCancelled()
+    let pg = Js.import("pg").get("default")
+    PgPool(pg.get("Pool").new1(Js.object()
         .with("user", user)
         .with("host", host)
         .with("database", database)
-        .with("password", js.function0(password))
+        .with("password", Js.function0(password))
         .with("port", port)
         .with("connectionTimeoutMillis", connectionTimeout.seconds * 1000)
         .with("idleTimeoutMillis", idleTimeout.seconds * 1000)
@@ -44,10 +43,9 @@ newPoolFromConnectionString(
     maxConnections: Int = 10
     allowExitOnIdle: Bool = True
 ): PgPool {
-    UnsafeJs.throwIfCancelled()
-    let js = UnsafeJs.jsSystem()
-    let pg = UnsafeJs.import("pg").get("default")
-    PgPool(pg.get("Pool").new1(js.object()
+    Js.throwIfCancelled()
+    let pg = Js.import("pg").get("default")
+    PgPool(pg.get("Pool").new1(Js.object()
         .with("connectionString", connectionString)
         .with("connectionTimeoutMillis", connectionTimeout.seconds * 1000)
         .with("idleTimeoutMillis", idleTimeout.seconds * 1000)
@@ -59,24 +57,24 @@ newPoolFromConnectionString(
 extend self: PgPool {
 
     connect(): PgConnection {
-        UnsafeJs.throwIfCancelled()
-        PgConnection(UnsafeJs.await {self.jsValue.call0("connect")})
+        Js.throwIfCancelled()
+        PgConnection(Js.await(self.jsValue->connect()))
     }
 
     close(): Unit {
-        UnsafeJs.await {self.jsValue.call0("end")}
+        Js.await(self.jsValue->end())
     }
 
     connectionCount(): Int {
-        self.jsValue.get("totalCount").grabInt()
+        self.jsValue->totalCount.grabInt()
     }
 
     idleCount(): Int {
-        self.jsValue.get("idleCount").grabInt()
+        self.jsValue->idleCount.grabInt()
     }
 
     waitingCount(): Int {
-        self.jsValue.get("waitingCount").grabInt()
+        self.jsValue->waitingCount.grabInt()
     }
 
     transaction[T](body: PgConnection => T, level: PgLevel = PgReadCommitted): T {
@@ -104,10 +102,10 @@ extend self: PgPool {
 extend self: PgConnection {
 
     release(): Unit {
-        if(UnsafeJs.cancelled()) {
-            self.jsValue.call1("release", True)
+        if(Js.cancelled()) {
+            self.jsValue->release(True)
         } else {
-            self.jsValue.call0("release")
+            self.jsValue->release()
         }
     }
 
@@ -148,138 +146,134 @@ extend self: PgConnection {
 extend self: PgStatement {
 
     withBool(name: String, value: Bool): PgStatement {
-        let p = UnsafeJs.jsSystem().value(value)
+        let p = Js.jsSystem().value(value)
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withNullableBool(name: String, value: Option[Bool]): PgStatement {
-        let p = value.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        let p = value.map(Js.jsSystem().value).else {Js.null()}
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withInt(name: String, value: Int): PgStatement {
-        let p = UnsafeJs.jsSystem().value(value)
+        let p = Js.jsSystem().value(value)
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withNullableInt(name: String, value: Option[Int]): PgStatement {
-        let p = value.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        let p = value.map(Js.jsSystem().value).else {Js.null()}
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withFloat(name: String, value: Float): PgStatement {
-        let p = UnsafeJs.jsSystem().value(value)
+        let p = Js.jsSystem().value(value)
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withNullableFloat(name: String, value: Option[Float]): PgStatement {
-        let p = value.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        let p = value.map(Js.jsSystem().value).else {Js.null()}
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withString(name: String, value: String): PgStatement {
-        let p = UnsafeJs.jsSystem().value(value)
+        let p = Js.jsSystem().value(value)
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withNullableString(name: String, value: Option[String]): PgStatement {
-        let p = value.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        let p = value.map(Js.jsSystem().value).else {Js.null()}
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withInstant(name: String, value: Instant): PgStatement {
-        let jsDate = UnsafeJs.jsSystem().globalThis().get("Date")
         function toJsDate(instant: Instant): JsValue {
-            jsDate.new1(instant.since1970.seconds * 1000.0)
+            Js->Date->(instant.since1970.seconds * 1000.0)
         }
         let p = toJsDate(value)
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withNullableInstant(name: String, value: Option[Instant]): PgStatement {
-        let jsDate = UnsafeJs.jsSystem().globalThis().get("Date")
         function toJsDate(instant: Instant): JsValue {
-            jsDate.new1(instant.since1970.seconds * 1000.0)
+            Js->Date->(instant.since1970.seconds * 1000.0)
         }
-        let p = value.map(toJsDate).else {UnsafeJs.jsSystem().null()}
+        let p = value.map(toJsDate).else {Js.null()}
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withBuffer(name: String, value: Buffer): PgStatement {
-        let p = UnsafeJs.jsSystem().value(value)
+        let p = Js.jsSystem().value(value)
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withNullableBuffer(name: String, value: Option[Buffer]): PgStatement {
-        let p = value.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        let p = value.map(Js.jsSystem().value).else {Js.null()}
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withBoolArray(name: String, value: List[Bool]): PgStatement {
-        let p = UnsafeJs.jsSystem().value(value)
+        let p = Js.jsSystem().value(value)
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withNullableBoolArray(name: String, value: Option[List[Bool]]): PgStatement {
-        let p = value.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        let p = value.map(Js.jsSystem().value).else {Js.null()}
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withIntArray(name: String, value: List[Int]): PgStatement {
-        let p = UnsafeJs.jsSystem().value(value)
+        let p = Js.jsSystem().value(value)
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withNullableIntArray(name: String, value: Option[List[Int]]): PgStatement {
-        let p = value.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        let p = value.map(Js.jsSystem().value).else {Js.null()}
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withFloatArray(name: String, value: List[Float]): PgStatement {
-        let p = UnsafeJs.jsSystem().value(value)
+        let p = Js.jsSystem().value(value)
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withNullableFloatArray(name: String, value: Option[List[Float]]): PgStatement {
-        let p = value.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        let p = value.map(Js.jsSystem().value).else {Js.null()}
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withStringArray(name: String, value: List[String]): PgStatement {
-        let p = UnsafeJs.jsSystem().value(value)
+        let p = Js.jsSystem().value(value)
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withNullableStringArray(name: String, value: Option[List[String]]): PgStatement {
-        let p = value.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        let p = value.map(Js.jsSystem().value).else {Js.null()}
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withInstantArray(name: String, value: List[Instant]): PgStatement {
-        let jsDate = UnsafeJs.jsSystem().globalThis().get("Date")
         function toJsDate(instant: Instant): JsValue {
-            jsDate.new1(instant.since1970.seconds * 1000.0)
+            Js->Date->(instant.since1970.seconds * 1000.0)
         }
-        let p = UnsafeJs.jsSystem().value(value.map(toJsDate))
+        let p = Js.jsSystem().value(value.map(toJsDate))
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withNullableInstantArray(name: String, value: Option[List[Instant]]): PgStatement {
-        let jsDate = UnsafeJs.jsSystem().globalThis().get("Date")
         function toJsDate(instant: Instant): JsValue {
-            jsDate.new1(instant.since1970.seconds * 1000.0)
+            Js->Date->(instant.since1970.seconds * 1000.0)
         }
-        let p = value.map {_.map(toJsDate)}.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        let p = value.map {_.map(toJsDate)}.map(Js.jsSystem().value).else {Js.null()}
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withBufferArray(name: String, value: List[Buffer]): PgStatement {
-        let p = UnsafeJs.jsSystem().value(value)
+        let p = Js.jsSystem().value(value)
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
     withNullableBufferArray(name: String, value: Option[List[Buffer]]): PgStatement {
-        let p = value.map(UnsafeJs.jsSystem().value).else {UnsafeJs.jsSystem().null()}
+        let p = value.map(Js.jsSystem().value).else {Js.null()}
         self.PgStatement(parameters = self.parameters.add(name, p))
     }
 
@@ -292,7 +286,7 @@ extend self: PgStatement {
     }
 
     any(body: PgRow => Bool): Bool {
-        !self.all { row =>
+        !self.all {row =>
             !body(row)
         }
     }
@@ -374,10 +368,10 @@ internalGet[T](row: PgRow, name: String, lower: Bool, body: JsValue => T): Optio
 }
 
 internalRunStatement(statement: PgStatement, body: Option[PgRow => Bool]): Int {
-    UnsafeJs.throwIfCancelled()
+    Js.throwIfCancelled()
     let pair = internalParseParameters(statement.sql)
     let parameters = internalCheckParameters(pair.second, statement.parameters)
-    let result = UnsafeJs.await {statement.connection.grab().jsValue.call2("query", pair.first, parameters)}
+    let result = Js.await(statement.connection.grab().jsValue->query(pair.first, parameters))
     body.{
         | None =>
             result.get("rowCount").grabInt()
@@ -398,7 +392,7 @@ internalBatchStatements(
     let sqlCache = statements.map {s => Pair(s.sql, s.sql)}.group().map {sql, list =>
         let pair = internalParseParameters(sql)
         let prepared = if(list.size() >= 10) {
-            let hash = UnsafeJs.import("crypto")
+            let hash = Js.import("crypto")
                 .call1("createHash", "md5")
                 .call1("update", pair.first)
                 .call1("update", "ffpgps")
@@ -408,18 +402,18 @@ internalBatchStatements(
         Pair(sql, (newSql = pair.first, parameterNames = pair.second, prepared = prepared))
     }
     let promises = statements.map {statement =>
-        UnsafeJs.throwIfCancelled()
+        Js.throwIfCancelled()
         let record = sqlCache.grab(statement.sql)
         let parameters = internalCheckParameters(record.parameterNames, statement.parameters)
-        let query = UnsafeJs.jsSystem().object()
+        let query = Js.object()
             .with("text", record.newSql)
             .with("values", parameters)
-        connection.jsValue.call1("query", record.prepared.map {query.with("name", _)}.else {query})
+        connection.jsValue->query(record.prepared.map {query.with("name", _)}.else {query})
     }
     let results = promises.map {promise =>
-        UnsafeJs.throwIfCancelled()
-        let result = UnsafeJs.await {promise }
-        UnsafeJs.throwIfCancelled()
+        Js.throwIfCancelled()
+        let result = Js.await(promise)
+        Js.throwIfCancelled()
         body.{
             | None =>
                 result.get("rowCount").grabInt()

package/rpc/.firefly/package.ff

@@ -1 +1 @@
-package ff:rpc:0.0.0
+package ff:rpc:0.0.0

package/rpc/Rpc.ff

@@ -1,70 +1,70 @@
-trait I: Rpc[O] {}
-
-capability RpcServer[I, O, C](
-    handlers: StringMap[(C, I) => O]
-)
-
-newServer[I, O, C](): RpcServer[I, O, C] {
-    RpcServer(StringMap.new())
-}
-
-extend self[I, O, C]: RpcServer[I, O, C] {
-    handle(name: String, context: C, input: I): Option[O] {
-        self.handlers.get(name).map {handler =>
-            handler(context, input)
-        }
-    }
-    
-    addCustom(
-        handler: (C, I) => O
-    ): Unit {
-        let name = "TODO"
-        self.handlers.set(name) {context, input =>
-            handler(context, input)
-        }
-    }
-}
-
-extend self[C]: RpcServer[Buffer, Buffer, C] {
-    add[I: Rpc[O]: HasAnyTag: Serializable, O: Serializable](
-        handler: (C, I) => O
-    ): Unit {
-        let name = Any.anyTag[I]().show()
-        self.handlers.set(name) {context, message =>
-            let input = Serializable.deserialize(message)
-            let output = handler(context, input)
-            Serializable.serialize(output)
-        }
-    }
-}
-
-capability RpcClient(
-    binaryCall: (String, Buffer) => Buffer
-)
-
-extend self: RpcClient {
-    call[I: Rpc[O]: HasAnyTag: Serializable, O: Serializable](
-        message: I
-    ): O {
-        let name = Any.anyTag[I]().show()
-        let input = Serializable.serialize(message)
-        let response = self.binaryCall(name, input)
-        Serializable.deserialize(response)
-    }
-}
-
-newClient(
-    httpClient: HttpClient
-    prefix: String
-    method: String = "POST"
-): RpcClient {
-    RpcClient {name, buffer =>
-        httpClient.fetch(
-            method = method
-            url = prefix + name
-            headers = []
-            payload = Some(buffer)
-            options = FetchOptions()
-        ) {_.readBuffer()}
-    }
-}
+trait I: Rpc[O] {}
+
+capability RpcServer[I, O, C](
+    handlers: StringMap[(C, I) => O]
+)
+
+newServer[I, O, C](): RpcServer[I, O, C] {
+    RpcServer(StringMap.new())
+}
+
+extend self[I, O, C]: RpcServer[I, O, C] {
+    handle(name: String, context: C, input: I): Option[O] {
+        self.handlers.get(name).map {handler =>
+            handler(context, input)
+        }
+    }
+    
+    addCustom(
+        handler: (C, I) => O
+    ): Unit {
+        let name = "TODO"
+        self.handlers.set(name) {context, input =>
+            handler(context, input)
+        }
+    }
+}
+
+extend self[C]: RpcServer[Buffer, Buffer, C] {
+    add[I: Rpc[O]: HasAnyTag: Serializable, O: Serializable](
+        handler: (C, I) => O
+    ): Unit {
+        let name = Any.anyTag[I]().show()
+        self.handlers.set(name) {context, message =>
+            let input = Serializable.deserialize(message)
+            let output = handler(context, input)
+            Serializable.serialize(output)
+        }
+    }
+}
+
+capability RpcClient(
+    binaryCall: (String, Buffer) => Buffer
+)
+
+extend self: RpcClient {
+    call[I: Rpc[O]: HasAnyTag: Serializable, O: Serializable](
+        message: I
+    ): O {
+        let name = Any.anyTag[I]().show()
+        let input = Serializable.serialize(message)
+        let response = self.binaryCall(name, input)
+        Serializable.deserialize(response)
+    }
+}
+
+newClient(
+    httpClient: HttpClient
+    prefix: String
+    method: String = "POST"
+): RpcClient {
+    RpcClient {name, buffer =>
+        httpClient.fetch(
+            method = method
+            url = prefix + name
+            headers = []
+            payload = Some(buffer)
+            options = FetchOptions()
+        ) {_.readBuffer()}
+    }
+}

package/s3/.firefly/package.ff

@@ -1 +1 @@
-package ff:s3:0.0.0
+package ff:s3:0.0.0