envio 2.22.0 → 2.22.1

package/src/Utils.res.js

@@ -0,0 +1,527 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var $$Array = require("rescript/lib/js/array.js");
+var Js_exn = require("rescript/lib/js/js_exn.js");
+var Caml_obj = require("rescript/lib/js/caml_obj.js");
+var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var Caml_array = require("rescript/lib/js/caml_array.js");
+var Belt_Option = require("rescript/lib/js/belt_Option.js");
+var Caml_option = require("rescript/lib/js/caml_option.js");
+var Caml_splice_call = require("rescript/lib/js/caml_splice_call.js");
+var S$RescriptSchema = require("rescript-schema/src/S.res.js");
+
+function delay(milliseconds) {
+  return new Promise((function (resolve, param) {
+                setTimeout((function () {
+                        resolve();
+                      }), milliseconds);
+              }));
+}
+
+var $$Object = {};
+
+var $$Error = {};
+
+function mapNone(opt, val) {
+  if (opt !== undefined) {
+    return ;
+  } else {
+    return Caml_option.some(val);
+  }
+}
+
+function catchToNone(unsafeFunc) {
+  try {
+    return Caml_option.some(unsafeFunc());
+  }
+  catch (exn){
+    return ;
+  }
+}
+
+function flatten(opt) {
+  if (opt !== undefined) {
+    return Caml_option.valFromOption(opt);
+  }
+  
+}
+
+function getExn(opt, message) {
+  if (opt !== undefined) {
+    return Caml_option.valFromOption(opt);
+  } else {
+    return Js_exn.raiseError(message);
+  }
+}
+
+var $$Option = {
+  mapNone: mapNone,
+  catchToNone: catchToNone,
+  flatten: flatten,
+  getExn: getExn
+};
+
+function get(tuple, index) {
+  return (tuple[index]);
+}
+
+var Tuple = {
+  get: get
+};
+
+var has = ((dict, key) => key in dict);
+
+function push(dict, key, value) {
+  var arr = dict[key];
+  if (arr !== undefined) {
+    arr.push(value);
+  } else {
+    dict[key] = [value];
+  }
+}
+
+function pushMany(dict, key, values) {
+  var arr = dict[key];
+  if (arr !== undefined) {
+    Caml_splice_call.spliceObjApply(arr, "push", [values]);
+  } else {
+    dict[key] = values;
+  }
+}
+
+var merge = ((dictA, dictB) => ({...dictA, ...dictB}));
+
+function map(dict, fn) {
+  var newDict = {};
+  var keys = Object.keys(dict);
+  for(var idx = 0 ,idx_finish = keys.length; idx < idx_finish; ++idx){
+    var key = keys[idx];
+    newDict[key] = fn(dict[key]);
+  }
+  return newDict;
+}
+
+function forEach(dict, fn) {
+  var keys = Object.keys(dict);
+  for(var idx = 0 ,idx_finish = keys.length; idx < idx_finish; ++idx){
+    fn(dict[keys[idx]]);
+  }
+}
+
+function forEachWithKey(dict, fn) {
+  var keys = Object.keys(dict);
+  for(var idx = 0 ,idx_finish = keys.length; idx < idx_finish; ++idx){
+    var key = keys[idx];
+    fn(key, dict[key]);
+  }
+}
+
+var deleteInPlace = ((dict, key) => {
+      delete dict[key];
+    });
+
+var updateImmutable = ((dict, key, value) => ({...dict, [key]: value}));
+
+var shallowCopy = ((dict) => ({...dict}));
+
+function size(dict) {
+  return Object.keys(dict).length;
+}
+
+var Dict = {
+  has: has,
+  push: push,
+  pushMany: pushMany,
+  merge: merge,
+  map: map,
+  forEach: forEach,
+  forEachWithKey: forEachWithKey,
+  deleteInPlace: deleteInPlace,
+  updateImmutable: updateImmutable,
+  shallowCopy: shallowCopy,
+  size: size
+};
+
+function minOptInt(a, b) {
+  if (a === undefined) {
+    if (b !== undefined) {
+      return Caml_option.some(Caml_option.valFromOption(b));
+    } else {
+      return ;
+    }
+  }
+  var a$1 = Caml_option.valFromOption(a);
+  if (b !== undefined) {
+    return Caml_option.some(Caml_obj.min(a$1, Caml_option.valFromOption(b)));
+  } else {
+    return Caml_option.some(a$1);
+  }
+}
+
+var $$Math = {
+  minOptInt: minOptInt
+};
+
+function mergeSorted(f, xs, ys) {
+  if (xs.length === 0) {
+    return ys;
+  }
+  if (ys.length === 0) {
+    return xs;
+  }
+  var n = xs.length + ys.length | 0;
+  var result = Array(n);
+  var loop = function (_i, _j, _k) {
+    while(true) {
+      var k = _k;
+      var j = _j;
+      var i = _i;
+      if (i < xs.length && j < ys.length) {
+        if (f(Caml_array.get(xs, i), Caml_array.get(ys, j))) {
+          Caml_array.set(result, k, Caml_array.get(xs, i));
+          _k = k + 1 | 0;
+          _i = i + 1 | 0;
+          continue ;
+        }
+        Caml_array.set(result, k, Caml_array.get(ys, j));
+        _k = k + 1 | 0;
+        _j = j + 1 | 0;
+        continue ;
+      }
+      if (i < xs.length) {
+        Caml_array.set(result, k, Caml_array.get(xs, i));
+        _k = k + 1 | 0;
+        _i = i + 1 | 0;
+        continue ;
+      }
+      if (j >= ys.length) {
+        return ;
+      }
+      Caml_array.set(result, k, Caml_array.get(ys, j));
+      _k = k + 1 | 0;
+      _j = j + 1 | 0;
+      continue ;
+    };
+  };
+  loop(0, 0, 0);
+  return result;
+}
+
+function setIndexImmutable(arr, index, value) {
+  var shallowCopy = arr.slice(0);
+  shallowCopy[index] = value;
+  return shallowCopy;
+}
+
+function transposeResults(results) {
+  var _index = 0;
+  var output = new Array(results.length);
+  while(true) {
+    var index = _index;
+    if (index >= results.length) {
+      return {
+              TAG: "Ok",
+              _0: output
+            };
+    }
+    var value = results[index];
+    if (value.TAG !== "Ok") {
+      return value;
+    }
+    Caml_array.set(output, index, value._0);
+    _index = index + 1 | 0;
+    continue ;
+  };
+}
+
+function includes(arr, val) {
+  return Belt_Option.isSome(Caml_option.undefined_to_opt(arr.find(function (item) {
+                      return Caml_obj.equal(item, val);
+                    })));
+}
+
+function isEmpty(arr) {
+  return arr.length === 0;
+}
+
+function notEmpty(arr) {
+  return arr.length !== 0;
+}
+
+async function awaitEach(arr, fn) {
+  for(var i = 0 ,i_finish = arr.length; i < i_finish; ++i){
+    var item = Caml_array.get(arr, i);
+    await fn(item);
+  }
+}
+
+function removeAtIndex(array, index) {
+  if (index < 0) {
+    return $$Array.copy(array);
+  } else {
+    return array.slice(0, index).concat(array.slice(index + 1 | 0));
+  }
+}
+
+function last(arr) {
+  return Belt_Array.get(arr, arr.length - 1 | 0);
+}
+
+function findReverseWithIndex(arr, fn) {
+  var _index = arr.length - 1 | 0;
+  while(true) {
+    var index = _index;
+    if (index < 0) {
+      return ;
+    }
+    var item = Caml_array.get(arr, index);
+    if (fn(item)) {
+      return [
+              item,
+              index
+            ];
+    }
+    _index = index - 1 | 0;
+    continue ;
+  };
+}
+
+function interleave(arr, separator) {
+  var interleaved = [];
+  arr.forEach(function (v, i) {
+        interleaved.push(v);
+        if (i < (arr.length - 1 | 0)) {
+          interleaved.push(separator);
+          return ;
+        }
+        
+      });
+  return interleaved;
+}
+
+var $$Array$1 = {
+  mergeSorted: mergeSorted,
+  setIndexImmutable: setIndexImmutable,
+  transposeResults: transposeResults,
+  includes: includes,
+  isEmpty: isEmpty,
+  notEmpty: notEmpty,
+  awaitEach: awaitEach,
+  removeAtIndex: removeAtIndex,
+  last: last,
+  findReverseWithIndex: findReverseWithIndex,
+  interleave: interleave
+};
+
+function capitalize(str) {
+  return str.slice(0, 1).toUpperCase() + str.slice(1);
+}
+
+var $$String = {
+  capitalize: capitalize
+};
+
+function forEach$1(result, fn) {
+  if (result.TAG === "Ok") {
+    fn(result._0);
+  }
+  return result;
+}
+
+var Result = {
+  forEach: forEach$1
+};
+
+function unwrapResultExn(res) {
+  if (res.TAG === "Ok") {
+    return res._0;
+  }
+  throw res._0;
+}
+
+var variantTag = S$RescriptSchema.union([
+      S$RescriptSchema.string,
+      S$RescriptSchema.object(function (s) {
+            return s.f("TAG", S$RescriptSchema.string);
+          })
+    ]);
+
+function getNonOptionalFieldNames(schema) {
+  var acc = [];
+  var match = schema.t;
+  if (typeof match === "object" && match.TAG === "object") {
+    match.items.forEach(function (item) {
+          var match = item.schema.t;
+          if (typeof match !== "object") {
+            acc.push(item.location);
+            return ;
+          }
+          switch (match.TAG) {
+            case "option" :
+            case "null" :
+                return ;
+            default:
+              acc.push(item.location);
+              return ;
+          }
+        });
+  }
+  return acc;
+}
+
+function getCapitalizedFieldNames(schema) {
+  var match = schema.t;
+  if (typeof match !== "object") {
+    return [];
+  } else if (match.TAG === "object") {
+    return match.items.map(function (item) {
+                return capitalize(item.location);
+              });
+  } else {
+    return [];
+  }
+}
+
+var dbDate = S$RescriptSchema.preprocess(S$RescriptSchema.json(false), (function (param) {
+        return {
+                s: (function (date) {
+                    return date.toISOString();
+                  })
+              };
+      }));
+
+function coerceToJsonPgType(schema) {
+  return S$RescriptSchema.preprocess(schema, (function (s) {
+                var match = s.schema.t;
+                if (typeof match === "object") {
+                  return {};
+                }
+                switch (match) {
+                  case "unknown" :
+                      return {
+                              s: (function (param) {
+                                  return "null";
+                                })
+                            };
+                  case "boolean" :
+                      return {
+                              s: (function (unknown) {
+                                  if (unknown === false) {
+                                    return "false";
+                                  } else if (unknown === true) {
+                                    return "true";
+                                  } else {
+                                    return unknown;
+                                  }
+                                })
+                            };
+                  default:
+                    return {};
+                }
+              }));
+}
+
+var Schema = {
+  variantTag: variantTag,
+  getNonOptionalFieldNames: getNonOptionalFieldNames,
+  getCapitalizedFieldNames: getCapitalizedFieldNames,
+  dbDate: dbDate,
+  coerceToJsonPgType: coerceToJsonPgType
+};
+
+function getVariantsTags(variants) {
+  return variants.map(function (variant) {
+              return S$RescriptSchema.parseOrThrow(variant, variantTag);
+            });
+}
+
+function addMany(set, values) {
+  values.forEach(function (value) {
+        set.add(value);
+      });
+}
+
+var $$Set = {
+  addMany: addMany
+};
+
+var $$WeakMap = {};
+
+var $$Map = {};
+
+var $$Proxy = {};
+
+function makeOrThrow(any) {
+  var $$typeof = typeof any;
+  switch ($$typeof) {
+    case "boolean" :
+        if (any) {
+          return "true";
+        } else {
+          return "false";
+        }
+    case "bigint" :
+    case "number" :
+        return any.toString();
+    case "object" :
+        if (any === null) {
+          return "null";
+        }
+        if (Array.isArray(any)) {
+          var hash = "[";
+          for(var i = 0 ,i_finish = any.length; i < i_finish; ++i){
+            hash = hash + makeOrThrow(any[i]) + ",";
+          }
+          return hash + "]";
+        }
+        var constructor = any["constructor"];
+        if (constructor !== Object) {
+          if (constructor.name === "BigNumber") {
+            return any.toString();
+          } else {
+            return Js_exn.raiseError("Don't know how to serialize " + constructor.name);
+          }
+        }
+        var hash$1 = "{";
+        var keys = Object.keys(any).sort();
+        for(var i$1 = 0 ,i_finish$1 = keys.length; i$1 < i_finish$1; ++i$1){
+          var key = keys[i$1];
+          hash$1 = hash$1 + key + ":" + makeOrThrow(any[key]) + ",";
+        }
+        return hash$1 + "}";
+    case "string" :
+        return any;
+    case "function" :
+    case "symbol" :
+        return any.toString();
+    case "undefined" :
+        return "undefined";
+    default:
+      return Js_exn.raiseError("Don't know how to serialize " + $$typeof);
+  }
+}
+
+var Hash = {
+  makeOrThrow: makeOrThrow
+};
+
+exports.delay = delay;
+exports.$$Object = $$Object;
+exports.$$Error = $$Error;
+exports.$$Option = $$Option;
+exports.Tuple = Tuple;
+exports.Dict = Dict;
+exports.$$Math = $$Math;
+exports.$$Array = $$Array$1;
+exports.$$String = $$String;
+exports.Result = Result;
+exports.unwrapResultExn = unwrapResultExn;
+exports.Schema = Schema;
+exports.getVariantsTags = getVariantsTags;
+exports.$$Set = $$Set;
+exports.$$WeakMap = $$WeakMap;
+exports.$$Map = $$Map;
+exports.$$Proxy = $$Proxy;
+exports.Hash = Hash;
+/* variantTag Not a pure module */

package/src/bindings/BigDecimal.res.js

@@ -0,0 +1,41 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Belt_Int = require("rescript/lib/js/belt_Int.js");
+var BignumberJs = require("bignumber.js");
+var S$RescriptSchema = require("rescript-schema/src/S.res.js");
+
+function toInt(b) {
+  return Belt_Int.fromString(b.toString());
+}
+
+function notEquals(a, b) {
+  return !a.isEqualTo(b);
+}
+
+var zero = new BignumberJs(0);
+
+var one = new BignumberJs(1);
+
+var schema = S$RescriptSchema.transform(S$RescriptSchema.setName(S$RescriptSchema.string, "BigDecimal"), (function (s) {
+        return {
+                p: (function (string) {
+                    var bigDecimal = new BignumberJs(string);
+                    if (bigDecimal !== undefined) {
+                      return bigDecimal;
+                    } else {
+                      return s.fail("The string is not valid BigDecimal", undefined);
+                    }
+                  }),
+                s: (function (bigDecimal) {
+                    return bigDecimal.toString();
+                  })
+              };
+      }));
+
+exports.toInt = toInt;
+exports.notEquals = notEquals;
+exports.zero = zero;
+exports.one = one;
+exports.schema = schema;
+/* zero Not a pure module */

package/src/bindings/BigInt.res.js

@@ -0,0 +1,138 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Js_exn = require("rescript/lib/js/js_exn.js");
+var Belt_Int = require("rescript/lib/js/belt_Int.js");
+var Caml_option = require("rescript/lib/js/caml_option.js");
+var S$RescriptSchema = require("rescript-schema/src/S.res.js");
+var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
+
+function fromString(str) {
+  try {
+    return Caml_option.some((function () {
+                    return BigInt(str);
+                  })());
+  }
+  catch (raw__obj){
+    var _obj = Caml_js_exceptions.internalToOCamlException(raw__obj);
+    if (_obj.RE_EXN_ID === Js_exn.$$Error) {
+      return ;
+    }
+    throw _obj;
+  }
+}
+
+function toInt(b) {
+  return Belt_Int.fromString(b.toString());
+}
+
+function add(a, b) {
+  return (a + b);
+}
+
+function sub(a, b) {
+  return (a - b);
+}
+
+function mul(a, b) {
+  return (a * b);
+}
+
+function div(a, b) {
+  return (b > 0n ? a / b : 0n);
+}
+
+function pow(a, b) {
+  return (a ** b);
+}
+
+function mod(a, b) {
+  return (b > 0n ? a % b : 0n);
+}
+
+function eq(a, b) {
+  return (a === b);
+}
+
+function neq(a, b) {
+  return (a !== b);
+}
+
+function gt(a, b) {
+  return (a > b);
+}
+
+function gte(a, b) {
+  return (a >= b);
+}
+
+function lt(a, b) {
+  return (a < b);
+}
+
+function lte(a, b) {
+  return (a <= b);
+}
+
+function shift_left(a, b) {
+  return (a << b);
+}
+
+function shift_right(a, b) {
+  return (a >> b);
+}
+
+function logor(a, b) {
+  return (a | b);
+}
+
+function logand(a, b) {
+  return (a & b);
+}
+
+var Bitwise = {
+  shift_left: shift_left,
+  shift_right: shift_right,
+  logor: logor,
+  logand: logand
+};
+
+var zero = BigInt(0);
+
+var schema = S$RescriptSchema.transform(S$RescriptSchema.setName(S$RescriptSchema.string, "BigInt"), (function (s) {
+        return {
+                p: (function (string) {
+                    var bigInt = fromString(string);
+                    if (bigInt !== undefined) {
+                      return bigInt;
+                    } else {
+                      return s.fail("The string is not valid BigInt", undefined);
+                    }
+                  }),
+                s: (function (bigint) {
+                    return bigint.toString();
+                  })
+              };
+      }));
+
+var nativeSchema = S$RescriptSchema.bigint;
+
+exports.fromString = fromString;
+exports.toInt = toInt;
+exports.add = add;
+exports.sub = sub;
+exports.mul = mul;
+exports.div = div;
+exports.pow = pow;
+exports.mod = mod;
+exports.eq = eq;
+exports.neq = neq;
+exports.gt = gt;
+exports.gte = gte;
+exports.lt = lt;
+exports.lte = lte;
+exports.Bitwise = Bitwise;
+exports.zero = zero;
+exports.schema = schema;
+exports.nativeSchema = nativeSchema;
+/* zero Not a pure module */