@lightsparkdev/core 1.0.3 → 1.0.4

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @lightsparkdev/core
 
+## 1.0.4
+
+### Patch Changes
+
+- 545fe1f: Switch listenToPaymentStatus to polling. Closes LIG-3588
+- 545fe1f: Always enable logging in test environments
+
 ## 1.0.3
 
 ### Patch Changes

package/dist/chunk-J6VQYCQJ.js

@@ -0,0 +1,338 @@
+// src/utils/base64.ts
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+var Base64 = {
+  btoa: (input = "") => {
+    const str = input;
+    let output = "";
+    for (let block = 0, charCode, i = 0, map = chars; str.charAt(i | 0) || (map = "=", i % 1); output += map.charAt(63 & block >> 8 - i % 1 * 8)) {
+      charCode = str.charCodeAt(i += 3 / 4);
+      if (charCode > 255) {
+        throw new Error(
+          "'btoa' failed: The string to be encoded contains characters outside of the Latin1 range."
+        );
+      }
+      block = block << 8 | charCode;
+    }
+    return output;
+  },
+  atob: (input = "") => {
+    const str = input.replace(/=+$/, "");
+    let output = "";
+    if (str.length % 4 == 1) {
+      throw new Error(
+        "'atob' failed: The string to be decoded is not correctly encoded."
+      );
+    }
+    for (let bc = 0, bs = 0, buffer, i = 0; buffer = str.charAt(i++); ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer, bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0) {
+      buffer = chars.indexOf(buffer);
+    }
+    return output;
+  }
+};
+var b64decode = (encoded) => {
+  return Uint8Array.from(Base64.atob(encoded), (c) => c.charCodeAt(0));
+};
+var urlsafe_b64decode = (encoded) => {
+  return b64decode(encoded.replace(/_/g, "/").replace(/-/g, "+"));
+};
+var b64encode = (data) => {
+  return Base64.btoa(
+    String.fromCharCode.apply(null, Array.from(new Uint8Array(data)))
+  );
+};
+
+// src/utils/environment.ts
+var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+var isTest = isNode && process.env.NODE_ENV === "test";
+
+// src/utils/createHash.ts
+var createSha256Hash = async (data) => {
+  if (isBrowser) {
+    return new Uint8Array(await window.crypto.subtle.digest("SHA-256", data));
+  } else {
+    const { createHash } = await import("crypto");
+    const buffer = createHash("sha256").update(data).digest();
+    return new Uint8Array(buffer);
+  }
+};
+
+// src/LightsparkException.ts
+var LightsparkException = class extends Error {
+  code;
+  message;
+  extraInfo;
+  constructor(code, message, extraInfo) {
+    super(message);
+    this.code = code;
+    this.message = message;
+    this.extraInfo = extraInfo;
+  }
+};
+var LightsparkException_default = LightsparkException;
+
+// src/utils/currency.ts
+var CONVERSION_MAP = {
+  ["BITCOIN" /* BITCOIN */]: {
+    ["BITCOIN" /* BITCOIN */]: (v) => v,
+    ["MICROBITCOIN" /* MICROBITCOIN */]: (v) => v * 1e6,
+    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => v * 1e3,
+    ["MILLISATOSHI" /* MILLISATOSHI */]: (v) => v * 1e11,
+    ["NANOBITCOIN" /* NANOBITCOIN */]: (v) => v * 1e9,
+    ["SATOSHI" /* SATOSHI */]: (v) => v * 1e8
+  },
+  ["MICROBITCOIN" /* MICROBITCOIN */]: {
+    ["BITCOIN" /* BITCOIN */]: (v) => Math.round(v / 1e6),
+    ["MICROBITCOIN" /* MICROBITCOIN */]: (v) => v,
+    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => Math.round(v / 1e3),
+    ["MILLISATOSHI" /* MILLISATOSHI */]: (v) => v * 1e5,
+    ["NANOBITCOIN" /* NANOBITCOIN */]: (v) => v * 1e3,
+    ["SATOSHI" /* SATOSHI */]: (v) => v * 100
+  },
+  ["MILLIBITCOIN" /* MILLIBITCOIN */]: {
+    ["BITCOIN" /* BITCOIN */]: (v) => Math.round(v / 1e3),
+    ["MICROBITCOIN" /* MICROBITCOIN */]: (v) => v * 1e3,
+    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => v,
+    ["MILLISATOSHI" /* MILLISATOSHI */]: (v) => v * 1e8,
+    ["NANOBITCOIN" /* NANOBITCOIN */]: (v) => v * 1e6,
+    ["SATOSHI" /* SATOSHI */]: (v) => v * 1e5
+  },
+  ["MILLISATOSHI" /* MILLISATOSHI */]: {
+    ["BITCOIN" /* BITCOIN */]: (v) => Math.round(v / 1e11),
+    ["MICROBITCOIN" /* MICROBITCOIN */]: (v) => Math.round(v / 1e5),
+    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => Math.round(v / 1e8),
+    ["MILLISATOSHI" /* MILLISATOSHI */]: (v) => v,
+    ["NANOBITCOIN" /* NANOBITCOIN */]: (v) => Math.round(v / 100),
+    ["SATOSHI" /* SATOSHI */]: (v) => Math.round(v / 1e3)
+  },
+  ["NANOBITCOIN" /* NANOBITCOIN */]: {
+    ["BITCOIN" /* BITCOIN */]: (v) => Math.round(v / 1e9),
+    ["MICROBITCOIN" /* MICROBITCOIN */]: (v) => Math.round(v / 1e3),
+    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => Math.round(v / 1e6),
+    ["MILLISATOSHI" /* MILLISATOSHI */]: (v) => v * 100,
+    ["NANOBITCOIN" /* NANOBITCOIN */]: (v) => v,
+    ["SATOSHI" /* SATOSHI */]: (v) => Math.round(v / 10)
+  },
+  ["SATOSHI" /* SATOSHI */]: {
+    ["BITCOIN" /* BITCOIN */]: (v) => Math.round(v / 1e8),
+    ["MICROBITCOIN" /* MICROBITCOIN */]: (v) => Math.round(v / 100),
+    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => Math.round(v / 1e5),
+    ["MILLISATOSHI" /* MILLISATOSHI */]: (v) => v * 1e3,
+    ["NANOBITCOIN" /* NANOBITCOIN */]: (v) => v * 10,
+    ["SATOSHI" /* SATOSHI */]: (v) => v
+  }
+};
+var convertCurrencyAmount = (from, toUnit) => {
+  if (from.originalUnit === "FUTURE_VALUE" /* FUTURE_VALUE */ || from.originalUnit === "USD" /* USD */ || toUnit === "FUTURE_VALUE" /* FUTURE_VALUE */ || toUnit === "USD" /* USD */) {
+    throw new LightsparkException_default("CurrencyError", `Unsupported CurrencyUnit.`);
+  }
+  const conversionFn = CONVERSION_MAP[from.originalUnit][toUnit];
+  if (!conversionFn) {
+    throw new LightsparkException_default(
+      "CurrencyError",
+      `Cannot convert from ${from.originalUnit} to ${toUnit}`
+    );
+  }
+  return {
+    ...from,
+    preferredCurrencyUnit: toUnit,
+    preferredCurrencyValueApprox: conversionFn(from.originalValue),
+    preferredCurrencyValueRounded: conversionFn(from.originalValue)
+  };
+};
+
+// src/utils/errors.ts
+var isError = (e) => {
+  return Boolean(
+    typeof e === "object" && e !== null && "name" in e && typeof e.name === "string" && "message" in e && typeof e.message === "string" && "stack" in e && (!e.stack || typeof e.stack === "string")
+  );
+};
+var isErrorWithMessage = (e) => {
+  return Boolean(
+    typeof e === "object" && e !== null && "message" in e && typeof e.message === "string"
+  );
+};
+var getErrorMsg = (e) => {
+  return isErrorWithMessage(e) ? e.message : "Unknown error";
+};
+var isErrorMsg = (e, msg) => {
+  if (isError(e)) {
+    return e.message === msg;
+  }
+  return false;
+};
+
+// src/utils/hex.ts
+var bytesToHex = (bytes) => {
+  return bytes.reduce((acc, byte) => {
+    return acc += ("0" + byte.toString(16)).slice(-2);
+  }, "");
+};
+var hexToBytes = (hex) => {
+  const bytes = [];
+  for (let c = 0; c < hex.length; c += 2) {
+    bytes.push(parseInt(hex.substr(c, 2), 16));
+  }
+  return Uint8Array.from(bytes);
+};
+
+// ../../node_modules/lodash-es/_freeGlobal.js
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeGlobal_default = freeGlobal;
+
+// ../../node_modules/lodash-es/_root.js
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal_default || freeSelf || Function("return this")();
+var root_default = root;
+
+// ../../node_modules/lodash-es/_Symbol.js
+var Symbol = root_default.Symbol;
+var Symbol_default = Symbol;
+
+// ../../node_modules/lodash-es/_getRawTag.js
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var nativeObjectToString = objectProto.toString;
+var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  try {
+    value[symToStringTag] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+var getRawTag_default = getRawTag;
+
+// ../../node_modules/lodash-es/_objectToString.js
+var objectProto2 = Object.prototype;
+var nativeObjectToString2 = objectProto2.toString;
+function objectToString(value) {
+  return nativeObjectToString2.call(value);
+}
+var objectToString_default = objectToString;
+
+// ../../node_modules/lodash-es/_baseGetTag.js
+var nullTag = "[object Null]";
+var undefinedTag = "[object Undefined]";
+var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
+}
+var baseGetTag_default = baseGetTag;
+
+// ../../node_modules/lodash-es/isObject.js
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var isObject_default = isObject;
+
+// ../../node_modules/lodash-es/isFunction.js
+var asyncTag = "[object AsyncFunction]";
+var funcTag = "[object Function]";
+var genTag = "[object GeneratorFunction]";
+var proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject_default(value)) {
+    return false;
+  }
+  var tag = baseGetTag_default(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_default = isFunction;
+
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/utils/pollUntil.ts
+function getDefaultMaxPollsError() {
+  return new Error("pollUntil: Max polls reached");
+}
+function pollUntil(asyncFn, getValue, maxPolls = 60, pollIntervalMs = 500, ignoreErrors = false, getMaxPollsError = getDefaultMaxPollsError) {
+  return new Promise((resolve, reject) => {
+    let polls = 0;
+    let stopPolling = false;
+    (async function() {
+      while (!stopPolling) {
+        polls += 1;
+        if (polls > maxPolls) {
+          stopPolling = true;
+          const maxPollsError = getMaxPollsError(maxPolls);
+          reject(maxPollsError);
+          break;
+        }
+        try {
+          const asyncResult = await asyncFn();
+          const result = getValue(asyncResult, {
+            stopPolling: false,
+            value: null
+          });
+          if (result.stopPolling) {
+            stopPolling = true;
+            resolve(result.value);
+          }
+        } catch (e) {
+          if (!ignoreErrors || isFunction_default(ignoreErrors) && !ignoreErrors(e)) {
+            stopPolling = true;
+            reject(e);
+          }
+        }
+        await sleep(pollIntervalMs);
+      }
+    })();
+  });
+}
+
+// src/utils/types.ts
+var isType = (typename) => (node) => {
+  return node?.__typename === typename;
+};
+
+export {
+  LightsparkException_default,
+  b64decode,
+  urlsafe_b64decode,
+  b64encode,
+  isBrowser,
+  isNode,
+  isTest,
+  createSha256Hash,
+  convertCurrencyAmount,
+  isError,
+  isErrorWithMessage,
+  getErrorMsg,
+  isErrorMsg,
+  bytesToHex,
+  hexToBytes,
+  sleep,
+  pollUntil,
+  isType
+};
+/*! Bundled license information:
+
+lodash-es/lodash.js:
+  (**
+   * @license
+   * Lodash (Custom Build) <https://lodash.com/>
+   * Build: `lodash modularize exports="es" -o ./`
+   * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+   * Released under MIT license <https://lodash.com/license>
+   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+   *)
+*/