@lightsparkdev/core 1.0.4 → 1.0.5

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @lightsparkdev/core
 
+## 1.0.5
+
+### Patch Changes
+
+- ca58c08: Update createSha256Hash with option to return as hex string and accept string data
+
 ## 1.0.4
 
 ### Patch Changes

package/dist/{chunk-J6VQYCQJ.js → chunk-5P2KZ44N.js}

@@ -46,16 +46,40 @@ var isBrowser = typeof window !== "undefined" && typeof window.document !== "und
 var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
 var isTest = isNode && process.env.NODE_ENV === "test";
 
+// 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);
+};
+
 // src/utils/createHash.ts
-var createSha256Hash = async (data) => {
+async function createSha256Hash(data, asHex) {
   if (isBrowser) {
-    return new Uint8Array(await window.crypto.subtle.digest("SHA-256", data));
+    const source = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    const buffer = await window.crypto.subtle.digest("SHA-256", source);
+    const arr = new Uint8Array(buffer);
+    if (asHex) {
+      return bytesToHex(arr);
+    }
+    return arr;
   } else {
     const { createHash } = await import("crypto");
+    if (asHex) {
+      const hexStr = createHash("sha256").update(data).digest("hex");
+      return hexStr;
+    }
     const buffer = createHash("sha256").update(data).digest();
     return new Uint8Array(buffer);
   }
-};
+}
 
 // src/LightsparkException.ts
 var LightsparkException = class extends Error {
@@ -162,20 +186,6 @@ var isErrorMsg = (e, 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;
@@ -311,14 +321,14 @@ export {
   isBrowser,
   isNode,
   isTest,
+  bytesToHex,
+  hexToBytes,
   createSha256Hash,
   convertCurrencyAmount,
   isError,
   isErrorWithMessage,
   getErrorMsg,
   isErrorMsg,
-  bytesToHex,
-  hexToBytes,
   sleep,
   pollUntil,
   isType

package/dist/index.cjs

@@ -372,16 +372,40 @@ var isBrowser = typeof window !== "undefined" && typeof window.document !== "und
 var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
 var isTest = isNode && process.env.NODE_ENV === "test";
 
+// 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);
+};
+
 // src/utils/createHash.ts
-var createSha256Hash = async (data) => {
+async function createSha256Hash(data, asHex) {
   if (isBrowser) {
-    return new Uint8Array(await window.crypto.subtle.digest("SHA-256", data));
+    const source = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    const buffer = await window.crypto.subtle.digest("SHA-256", source);
+    const arr = new Uint8Array(buffer);
+    if (asHex) {
+      return bytesToHex(arr);
+    }
+    return arr;
   } else {
     const { createHash } = await import("crypto");
+    if (asHex) {
+      const hexStr = createHash("sha256").update(data).digest("hex");
+      return hexStr;
+    }
     const buffer = createHash("sha256").update(data).digest();
     return new Uint8Array(buffer);
   }
-};
+}
 
 // src/utils/currency.ts
 var CONVERSION_MAP = {
@@ -474,20 +498,6 @@ var isErrorMsg = (e, 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;

package/dist/index.js

@@ -17,7 +17,7 @@ import {
   pollUntil,
   sleep,
   urlsafe_b64decode
-} from "./chunk-J6VQYCQJ.js";
+} from "./chunk-5P2KZ44N.js";
 
 // src/auth/LightsparkAuthException.ts
 var LightsparkAuthException = class extends LightsparkException_default {

package/dist/utils/index.cjs

@@ -98,16 +98,40 @@ var isBrowser = typeof window !== "undefined" && typeof window.document !== "und
 var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
 var isTest = isNode && process.env.NODE_ENV === "test";
 
+// 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);
+};
+
 // src/utils/createHash.ts
-var createSha256Hash = async (data) => {
+async function createSha256Hash(data, asHex) {
   if (isBrowser) {
-    return new Uint8Array(await window.crypto.subtle.digest("SHA-256", data));
+    const source = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    const buffer = await window.crypto.subtle.digest("SHA-256", source);
+    const arr = new Uint8Array(buffer);
+    if (asHex) {
+      return bytesToHex(arr);
+    }
+    return arr;
   } else {
     const { createHash } = await import("crypto");
+    if (asHex) {
+      const hexStr = createHash("sha256").update(data).digest("hex");
+      return hexStr;
+    }
     const buffer = createHash("sha256").update(data).digest();
     return new Uint8Array(buffer);
   }
-};
+}
 
 // src/LightsparkException.ts
 var LightsparkException = class extends Error {
@@ -214,20 +238,6 @@ var isErrorMsg = (e, 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;

package/dist/utils/index.d.ts

@@ -2,7 +2,9 @@ declare const b64decode: (encoded: string) => Uint8Array;
 declare const urlsafe_b64decode: (encoded: string) => Uint8Array;
 declare const b64encode: (data: ArrayBuffer) => string;
 
-declare const createSha256Hash: (data: Uint8Array) => Promise<Uint8Array>;
+type SourceData = Uint8Array | string;
+declare function createSha256Hash(data: SourceData): Promise<Uint8Array>;
+declare function createSha256Hash(data: SourceData, asHex: true): Promise<string>;
 
 /** Represents the value and unit for an amount of currency. **/
 type CurrencyAmount = {

package/dist/utils/index.js

@@ -16,7 +16,7 @@ import {
   pollUntil,
   sleep,
   urlsafe_b64decode
-} from "../chunk-J6VQYCQJ.js";
+} from "../chunk-5P2KZ44N.js";
 export {
   b64decode,
   b64encode,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightsparkdev/core",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Lightspark JS SDK",
   "author": "Lightspark Inc.",
   "keywords": [

package/src/utils/createHash.ts

@@ -1,13 +1,34 @@
 import { isBrowser } from "./environment.js";
+import { bytesToHex } from "./hex.js";
 
-export const createSha256Hash = async (
-  data: Uint8Array,
-): Promise<Uint8Array> => {
+type SourceData = Uint8Array | string;
+
+export async function createSha256Hash(data: SourceData): Promise<Uint8Array>;
+export async function createSha256Hash(
+  data: SourceData,
+  asHex: true,
+): Promise<string>;
+
+export async function createSha256Hash(
+  data: SourceData,
+  asHex?: boolean,
+): Promise<Uint8Array | string> {
   if (isBrowser) {
-    return new Uint8Array(await window.crypto.subtle.digest("SHA-256", data));
+    const source =
+      typeof data === "string" ? new TextEncoder().encode(data) : data;
+    const buffer = await window.crypto.subtle.digest("SHA-256", source);
+    const arr = new Uint8Array(buffer);
+    if (asHex) {
+      return bytesToHex(arr);
+    }
+    return arr;
   } else {
     const { createHash } = await import("crypto");
+    if (asHex) {
+      const hexStr = createHash("sha256").update(data).digest("hex");
+      return hexStr;
+    }
     const buffer = createHash("sha256").update(data).digest();
     return new Uint8Array(buffer);
   }
-};
+}