firefly-compiler 0.5.35 → 0.5.36

package/output/js/ff/core/HttpClient.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 HttpClient
 
 
@@ -123,18 +125,21 @@ return {redirect_, referrer_, integrity_, mode_, credentials_, cache_};
 
 
 export function internalCheck_(fetchResponse_) {
-
-        if(fetchResponse_.response === null) {
-            throw new Error("Response closed");
-        }
-        if(!fetchResponse_.statusChecked && !fetchResponse_.response.ok) {
-            throw new Error("Unchecked HTTP status code: " + fetchResponse_.response.status);
-        }
-    
+if(ff_core_JsValue.JsValue_isNull(fetchResponse_.response)) {
+throw (new Error("Response closed"))
+};
+if(((!fetchResponse_.statusChecked) && (!fetchResponse_.response.ok))) {
+throw (new Error(("Unchecked HTTP status code: " + fetchResponse_.response.status)))
+}
 }
 
 export async function internalCheck_$(fetchResponse_, $task) {
-throw new Error('Function internalCheck is missing on this target in async context.');
+if(ff_core_JsValue.JsValue_isNull(fetchResponse_.response)) {
+throw (new Error("Response closed"))
+};
+if(((!fetchResponse_.statusChecked) && (!fetchResponse_.response.ok))) {
+throw (new Error(("Unchecked HTTP status code: " + fetchResponse_.response.status)))
+}
 }
 
 export function HttpClient_get(self_, url_, headers_, body_) {
@@ -154,7 +159,82 @@ return ff_core_HttpClient.HttpClient_fetch(self_, "DELETE", url_, headers_, ff_c
 }
 
 export function HttpClient_fetch(self_, method_, url_, headers_ = [], payload_ = ff_core_Option.None(), options_ = ff_core_HttpClient.FetchOptions(), body_) {
-throw new Error('Function HttpClient_fetch is missing on this target in sync context.');
+const fetchResponse_ = {response: null, statusChecked: false};
+return ff_core_Js.withSignal_(((signal_) => {
+try {
+const fetchOptions_ = {headers: {}, signal: signal_, method: method_};
+ff_core_List.List_each(headers_, ((_1) => {
+{
+const k_ = _1.first_;
+const v_ = _1.second_;
+fetchOptions_.headers[k_] = v_
+return
+}
+}));
+{
+const if_o = payload_
+if(if_o.Some) {
+const v_ = if_o.value_;
+fetchOptions_.body = v_
+}
+};
+do {
+const _1 = options_.redirect_;
+if(_1.RedirectError) {
+fetchOptions_.redirect = "error"
+break
+}
+if(_1.RedirectFollow) {
+
+break
+}
+{
+fetchOptions_.redirect = "manual"
+}
+} while(false);
+{
+const if_o = options_.referrer_
+if(if_o.Some) {
+const v_ = if_o.value_;
+fetchOptions_.referrer = v_
+}
+};
+{
+const if_o = options_.integrity_
+if(if_o.Some) {
+const v_ = if_o.value_;
+fetchOptions_.integrity = v_
+}
+};
+{
+const if_o = options_.mode_
+if(if_o.Some) {
+const v_ = if_o.value_;
+fetchOptions_.mode = v_
+}
+};
+{
+const if_o = options_.credentials_
+if(if_o.Some) {
+const v_ = if_o.value_;
+fetchOptions_.credentials = v_
+}
+};
+{
+const if_o = options_.cache_
+if(if_o.Some) {
+const v_ = if_o.value_;
+fetchOptions_.cache = v_
+}
+};
+fetchResponse_.response = self_.fetch(url_, fetchOptions_);
+const result_ = body_(fetchResponse_);
+ff_core_HttpClient.internalCheck_(fetchResponse_);
+return result_
+} finally {
+fetchResponse_.response = null
+}
+}))
 }
 
 export async function HttpClient_get$(self_, url_, headers_, body_, $task) {
@@ -174,112 +254,164 @@ return (await ff_core_HttpClient.HttpClient_fetch$(self_, "DELETE", url_, header
 }
 
 export async function HttpClient_fetch$(self_, method_, url_, headers_ = [], payload_ = ff_core_Option.None(), options_ = ff_core_HttpClient.FetchOptions(), body_, $task) {
-
-            const fetchResponse = {response: null, statusChecked: false};
-            try {
-                const options = {headers: {}, signal: $task.controller.signal};
-                options.method = method_;
-                headers_.forEach(pair => {options.headers[pair.first_] = pair.second_});
-                if(payload_.value_) options.body = payload_.value_;
-                if(options_.redirect_.RedirectError) options.redirect = "error";
-                else if(options_.redirect_.RedirectManual) options.redirect = "manual";
-                if(options_.referrer_.value_) options.referrer = options_.referrer_.value_;
-                if(options_.integrity_.value_) options.integrity = options_.integrity_.value_;
-                if(options_.mode_.value_) options.mode = options_.mode_.value_;
-                if(options_.credentials_.value_) options.credentials = options_.credentials_.value_;
-                if(options_.cache_.value_) options.cache = options_.cache_.value_;
-                fetchResponse.response = await self_.fetch(url_, options);
-                const result = await body_(fetchResponse, $task);
-                internalCheck_(fetchResponse);
-                return result;
-            } finally {
-                fetchResponse.response = null;
-                if($task.controller.signal.aborted) $task.controller = new AbortController()
-            }
-        
+const fetchResponse_ = {response: null, statusChecked: false};
+return (await ff_core_Js.withSignal_$((async (signal_, $task) => {
+try {
+const fetchOptions_ = {headers: {}, signal: signal_, method: method_};
+ff_core_List.List_each(headers_, ((_1) => {
+{
+const k_ = _1.first_;
+const v_ = _1.second_;
+fetchOptions_.headers[k_] = v_
+return
+}
+}));
+{
+const if_o = payload_
+if(if_o.Some) {
+const v_ = if_o.value_;
+fetchOptions_.body = v_
+}
+};
+do {
+const _1 = options_.redirect_;
+if(_1.RedirectError) {
+fetchOptions_.redirect = "error"
+break
+}
+if(_1.RedirectFollow) {
+
+break
+}
+{
+fetchOptions_.redirect = "manual"
+}
+} while(false);
+{
+const if_o = options_.referrer_
+if(if_o.Some) {
+const v_ = if_o.value_;
+fetchOptions_.referrer = v_
+}
+};
+{
+const if_o = options_.integrity_
+if(if_o.Some) {
+const v_ = if_o.value_;
+fetchOptions_.integrity = v_
+}
+};
+{
+const if_o = options_.mode_
+if(if_o.Some) {
+const v_ = if_o.value_;
+fetchOptions_.mode = v_
+}
+};
+{
+const if_o = options_.credentials_
+if(if_o.Some) {
+const v_ = if_o.value_;
+fetchOptions_.credentials = v_
+}
+};
+{
+const if_o = options_.cache_
+if(if_o.Some) {
+const v_ = if_o.value_;
+fetchOptions_.cache = v_
+}
+};
+fetchResponse_.response = (await self_.fetch(url_, fetchOptions_));
+const result_ = (await (await body_(fetchResponse_, $task)));
+ff_core_HttpClient.internalCheck_(fetchResponse_);
+return result_
+} finally {
+fetchResponse_.response = null
+}
+}), $task))
 }
 
 export function FetchResponse_ok(self_) {
-throw new Error('Function FetchResponse_ok is missing on this target in sync context.');
+self_.statusChecked = true;
+ff_core_HttpClient.internalCheck_(self_);
+return self_.response.ok
 }
 
 export function FetchResponse_status(self_) {
-throw new Error('Function FetchResponse_status is missing on this target in sync context.');
+self_.statusChecked = true;
+ff_core_HttpClient.internalCheck_(self_);
+return self_.response.status
 }
 
 export function FetchResponse_statusText(self_) {
-throw new Error('Function FetchResponse_statusText is missing on this target in sync context.');
+self_.statusChecked = true;
+ff_core_HttpClient.internalCheck_(self_);
+return self_.response.statusText
 }
 
 export function FetchResponse_header(self_, name_) {
-throw new Error('Function FetchResponse_header is missing on this target in sync context.');
+ff_core_HttpClient.internalCheck_(self_);
+const header_ = self_.response.headers.get(name_);
+if((!ff_core_JsValue.JsValue_isNullOrUndefined(header_))) {
+return ff_core_Option.Some(header_)
+} else return ff_core_Option.None()
 }
 
 export function FetchResponse_readText(self_) {
-throw new Error('Function FetchResponse_readText is missing on this target in sync context.');
+ff_core_HttpClient.internalCheck_(self_);
+return self_.response.text()
 }
 
 export function FetchResponse_readJson(self_) {
-throw new Error('Function FetchResponse_readJson is missing on this target in sync context.');
+ff_core_HttpClient.internalCheck_(self_);
+return self_.response.json()
 }
 
 export function FetchResponse_readBuffer(self_) {
-throw new Error('Function FetchResponse_readBuffer is missing on this target in sync context.');
+ff_core_HttpClient.internalCheck_(self_);
+return (new DataView(self_.response.arrayBuffer()))
 }
 
 export async function FetchResponse_ok$(self_, $task) {
-
-            self_.statusChecked = true;
-            internalCheck_(self_);
-            return self_.response.ok;
-        
+self_.statusChecked = true;
+(await ff_core_HttpClient.internalCheck_$(self_, $task));
+return self_.response.ok
 }
 
 export async function FetchResponse_status$(self_, $task) {
-
-            self_.statusChecked = true;
-            internalCheck_(self_);
-            return self_.response.status;
-        
+self_.statusChecked = true;
+(await ff_core_HttpClient.internalCheck_$(self_, $task));
+return self_.response.status
 }
 
 export async function FetchResponse_statusText$(self_, $task) {
-
-            self_.statusChecked = true;
-            internalCheck_(self_);
-            return self_.response.statusText;
-        
+self_.statusChecked = true;
+(await ff_core_HttpClient.internalCheck_$(self_, $task));
+return self_.response.statusText
 }
 
 export async function FetchResponse_header$(self_, name_, $task) {
-
-            internalCheck_(self_);
-            const header = self_.response.headers.get(name_);
-            return header != null
-                ? ff_core_Option.Some(header)
-                : ff_core_Option.None();
-        
+(await ff_core_HttpClient.internalCheck_$(self_, $task));
+const header_ = self_.response.headers.get(name_);
+if((!ff_core_JsValue.JsValue_isNullOrUndefined(header_))) {
+return ff_core_Option.Some(header_)
+} else return ff_core_Option.None()
 }
 
 export async function FetchResponse_readText$(self_, $task) {
-
-            internalCheck_(self_);
-            return await self_.response.text();
-        
+(await ff_core_HttpClient.internalCheck_$(self_, $task));
+return (await self_.response.text())
 }
 
 export async function FetchResponse_readJson$(self_, $task) {
-
-            internalCheck_(self_);
-            return await self_.response.json();
-        
+(await ff_core_HttpClient.internalCheck_$(self_, $task));
+return (await self_.response.json())
 }
 
 export async function FetchResponse_readBuffer$(self_, $task) {
-
-            internalCheck_(self_);
-            return new DataView(await self_.response.arrayBuffer());
-        
+(await ff_core_HttpClient.internalCheck_$(self_, $task));
+return (new DataView((await self_.response.arrayBuffer())))
 }
 
 

package/output/js/ff/core/Instant.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"
-
 // newtype Instant
 
 
@@ -108,9 +110,7 @@ return ff_core_Option.Some(ff_core_Instant.internalParseDate_(date_))
 }
 
 export function internalParseDate_(date_) {
-
-        return Date.parse(date_) * 0.001;
-    
+return (Date.parse(date_) * 0.001)
 }
 
 export async function fromIso_$(date_, $task) {
@@ -125,7 +125,7 @@ return ff_core_Option.Some(ff_core_Instant.internalParseDate_(date_))
 }
 
 export async function internalParseDate_$(date_, $task) {
-throw new Error('Function internalParseDate is missing on this target in async context.');
+return (Date.parse(date_) * 0.001)
 }
 
 export function Instant_add(self_, duration_) {
@@ -133,9 +133,7 @@ return (self_ + duration_)
 }
 
 export function Instant_toIso(self_) {
-
-            return new Date(self_ * 1000).toISOString();
-        
+return (new Date((self_ * 1000.0))).toISOString()
 }
 
 export async function Instant_add$(self_, duration_, $task) {
@@ -143,7 +141,7 @@ return (self_ + duration_)
 }
 
 export async function Instant_toIso$(self_, $task) {
-throw new Error('Function Instant_toIso is missing on this target in async context.');
+return (new Date((self_ * 1000.0))).toISOString()
 }
 
 

package/output/js/ff/core/Int.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 Int
 
 
@@ -110,31 +112,35 @@ return self_
 }
 
 export function Int_bitNot(self_) {
-return ~self_;
+return (~self_)
 }
 
 export function Int_bitOr(self_, that_) {
-return self_ | that_;
+return (self_ | that_)
 }
 
 export function Int_bitAnd(self_, that_) {
-return self_ & that_;
+return (self_ & that_)
 }
 
 export function Int_bitXor(self_, that_) {
-return self_ ^ that_;
+return (self_ ^ that_)
 }
 
 export function Int_bitLeft(self_, bits_) {
-return self_ << bits_;
+return (self_ << bits_)
 }
 
-export function Int_bitRight(self_, bits_, signed_ = true) {
-return signed_ ? self_ >> bits_ : self_ >>> bits_;
+export function Int_bitRight(self_, bits_) {
+return (self_ >> bits_)
+}
+
+export function Int_bitRightUnsigned(self_, bits_) {
+return (self_ >>> bits_)
 }
 
 export function Int_bitLeadingZeros(self_) {
-return Math.clz32(self_);
+return Math.clz32(self_)
 }
 
 export function Int_to(self_, inclusiveEnd_) {
@@ -166,11 +172,11 @@ return Math.max(self_, that_)
 }
 
 export function Int_clamp(self_, from_, to_) {
-return Math.min(Math.max(self_, from_), to_)
+return ff_core_Int.Int_min(ff_core_Int.Int_max(self_, from_), to_)
 }
 
 export function Int_pad(self_, padding_) {
-return ff_core_String.String_padStart(("" + self_), ff_core_String.String_size(padding_), padding_)
+return ff_core_String.String_padStart(("" + self_), padding_.length, padding_)
 }
 
 export function Int_div(self_, divisor_) {
@@ -182,39 +188,43 @@ return ff_core_Float.Float_toInt((self_ % divisor_))
 }
 
 export async function Int_abs$(self_, $task) {
-throw new Error('Function Int_abs is missing on this target in async context.');
+return Math.abs(self_)
 }
 
 export async function Int_toFloat$(self_, $task) {
-throw new Error('Function Int_toFloat is missing on this target in async context.');
+return self_
 }
 
 export async function Int_bitNot$(self_, $task) {
-throw new Error('Function Int_bitNot is missing on this target in async context.');
+return (~self_)
 }
 
 export async function Int_bitOr$(self_, that_, $task) {
-throw new Error('Function Int_bitOr is missing on this target in async context.');
+return (self_ | that_)
 }
 
 export async function Int_bitAnd$(self_, that_, $task) {
-throw new Error('Function Int_bitAnd is missing on this target in async context.');
+return (self_ & that_)
 }
 
 export async function Int_bitXor$(self_, that_, $task) {
-throw new Error('Function Int_bitXor is missing on this target in async context.');
+return (self_ ^ that_)
 }
 
 export async function Int_bitLeft$(self_, bits_, $task) {
-throw new Error('Function Int_bitLeft is missing on this target in async context.');
+return (self_ << bits_)
+}
+
+export async function Int_bitRight$(self_, bits_, $task) {
+return (self_ >> bits_)
 }
 
-export async function Int_bitRight$(self_, bits_, signed_ = true, $task) {
-throw new Error('Function Int_bitRight is missing on this target in async context.');
+export async function Int_bitRightUnsigned$(self_, bits_, $task) {
+return (self_ >>> bits_)
 }
 
 export async function Int_bitLeadingZeros$(self_, $task) {
-throw new Error('Function Int_bitLeadingZeros is missing on this target in async context.');
+return Math.clz32(self_)
 }
 
 export async function Int_to$(self_, inclusiveEnd_, $task) {
@@ -238,19 +248,19 @@ return ff_core_Array.Array_drain(result_)
 }
 
 export async function Int_min$(self_, that_, $task) {
-throw new Error('Function Int_min is missing on this target in async context.');
+return Math.min(self_, that_)
 }
 
 export async function Int_max$(self_, that_, $task) {
-throw new Error('Function Int_max is missing on this target in async context.');
+return Math.max(self_, that_)
 }
 
 export async function Int_clamp$(self_, from_, to_, $task) {
-throw new Error('Function Int_clamp is missing on this target in async context.');
+return ff_core_Int.Int_min(ff_core_Int.Int_max(self_, from_), to_)
 }
 
 export async function Int_pad$(self_, padding_, $task) {
-return ff_core_String.String_padStart(("" + self_), ff_core_String.String_size(padding_), padding_)
+return ff_core_String.String_padStart(("" + self_), padding_.length, padding_)
 }
 
 export async function Int_div$(self_, divisor_, $task) {