@choksheak/ts-utils 0.1.6 → 0.1.8

package/arrayBuffer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Encode an input ArrayBuffer into a hex string.
+ */
+export declare function arrayBufferToHex(buffer: ArrayBuffer): string;
+/**
+ * Encode an input ArrayBuffer into a base64 string.
+ */
+export declare function arrayBufferToBase64(buffer: ArrayBuffer): string;

package/arrayBuffer.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/arrayBuffer.ts
+var arrayBuffer_exports = {};
+__export(arrayBuffer_exports, {
+  arrayBufferToBase64: () => arrayBufferToBase64,
+  arrayBufferToHex: () => arrayBufferToHex
+});
+module.exports = __toCommonJS(arrayBuffer_exports);
+function arrayBufferToHex(buffer) {
+  const byteArray = new Uint8Array(buffer);
+  return Array.from(byteArray).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function arrayBufferToBase64(buffer) {
+  const byteArray = new Uint8Array(buffer);
+  const binaryString = Array.from(byteArray).map((byte) => String.fromCodePoint(byte)).join("");
+  return btoa(binaryString);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  arrayBufferToBase64,
+  arrayBufferToHex
+});
+//# sourceMappingURL=arrayBuffer.js.map

package/arrayBuffer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/arrayBuffer.ts"],"sourcesContent":["/**\n * Encode an input ArrayBuffer into a hex string.\n */\nexport function arrayBufferToHex(buffer: ArrayBuffer): string {\n  // Create a Uint8Array view of the ArrayBuffer\n  const byteArray = new Uint8Array(buffer);\n\n  // Convert each byte to a two-character hexadecimal string\n  return Array.from(byteArray)\n    .map((byte) => byte.toString(16).padStart(2, \"0\"))\n    .join(\"\");\n}\n\n/**\n * Encode an input ArrayBuffer into a base64 string.\n */\nexport function arrayBufferToBase64(buffer: ArrayBuffer): string {\n  // Convert the ArrayBuffer to a Uint8Array\n  const byteArray = new Uint8Array(buffer);\n\n  // Create a binary string from the byte array\n  const binaryString = Array.from(byteArray)\n    .map((byte) => String.fromCodePoint(byte))\n    .join(\"\");\n\n  // Encode the binary string to base64. No need to use safeBtoa because we\n  // already simplified the binary input above.\n  return btoa(binaryString);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGO,SAAS,iBAAiB,QAA6B;AAE5D,QAAM,YAAY,IAAI,WAAW,MAAM;AAGvC,SAAO,MAAM,KAAK,SAAS,EACxB,IAAI,CAAC,SAAS,KAAK,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAChD,KAAK,EAAE;AACZ;AAKO,SAAS,oBAAoB,QAA6B;AAE/D,QAAM,YAAY,IAAI,WAAW,MAAM;AAGvC,QAAM,eAAe,MAAM,KAAK,SAAS,EACtC,IAAI,CAAC,SAAS,OAAO,cAAc,IAAI,CAAC,EACxC,KAAK,EAAE;AAIV,SAAO,KAAK,YAAY;AAC1B;","names":[]}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@choksheak/ts-utils",
   "license": "The Unlicense",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Random Typescript utilities with support for full tree-shaking",
   "private": false,
   "scripts": {
     "lint": "eslint src/**",
-    "format": "prettier --write \"**/*.{ts}\"",
+    "format": "prettier --write \"**/*.ts\"",
     "test": "npm run clean && jest",
     "test:watch": "npm run clean && jest --watch",
     "clean": "rm -rf dist",

package/safeBtoa.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Base 64 encode the given input string, but safely.
+ */
+export declare function safeBtoa(input: string): string;

package/safeBtoa.js

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/safeBtoa.ts
+var safeBtoa_exports = {};
+__export(safeBtoa_exports, {
+  safeBtoa: () => safeBtoa
+});
+module.exports = __toCommonJS(safeBtoa_exports);
+function safeBtoa(input) {
+  const utf8Bytes = new TextEncoder().encode(input);
+  const binaryString = Array.from(utf8Bytes).map((byte) => String.fromCodePoint(byte)).join("");
+  return btoa(binaryString);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  safeBtoa
+});
+//# sourceMappingURL=safeBtoa.js.map

package/safeBtoa.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/safeBtoa.ts"],"sourcesContent":["/**\n * Base 64 encode the given input string, but safely.\n */\nexport function safeBtoa(input: string): string {\n  // Convert the string to a UTF-8 encoded binary-safe string\n  const utf8Bytes = new TextEncoder().encode(input);\n\n  // Convert the binary data to a string for btoa\n  const binaryString = Array.from(utf8Bytes)\n    .map((byte) => String.fromCodePoint(byte))\n    .join(\"\");\n\n  // Use btoa to encode the binary-safe string\n  return btoa(binaryString);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGO,SAAS,SAAS,OAAuB;AAE9C,QAAM,YAAY,IAAI,YAAY,EAAE,OAAO,KAAK;AAGhD,QAAM,eAAe,MAAM,KAAK,SAAS,EACtC,IAAI,CAAC,SAAS,OAAO,cAAc,IAAI,CAAC,EACxC,KAAK,EAAE;AAGV,SAAO,KAAK,YAAY;AAC1B;","names":[]}

package/sha256.d.ts

@@ -0,0 +1,4 @@
+/**
+ * SHA-256 hash an input string into an ArrayBuffer.
+ */
+export declare function sha256(input: string): Promise<ArrayBuffer>;

package/sha256.js

@@ -0,0 +1,58 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/sha256.ts
+var sha256_exports = {};
+__export(sha256_exports, {
+  sha256: () => sha256
+});
+module.exports = __toCommonJS(sha256_exports);
+function sha256(input) {
+  return __async(this, null, function* () {
+    const encoder = new TextEncoder();
+    const uint8Array = encoder.encode(input);
+    const arrayBuffer = yield crypto.subtle.digest("SHA-256", uint8Array);
+    return arrayBuffer;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sha256
+});
+//# sourceMappingURL=sha256.js.map

package/sha256.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/sha256.ts"],"sourcesContent":["/**\n * SHA-256 hash an input string into an ArrayBuffer.\n */\nexport async function sha256(input: string): Promise<ArrayBuffer> {\n  // Encode the input string as a Uint8Array\n  const encoder = new TextEncoder();\n  const uint8Array = encoder.encode(input);\n\n  // Compute the SHA-256 hash using the SubtleCrypto API\n  const arrayBuffer = await crypto.subtle.digest(\"SHA-256\", uint8Array);\n\n  return arrayBuffer;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,SAAsB,OAAO,OAAqC;AAAA;AAEhE,UAAM,UAAU,IAAI,YAAY;AAChC,UAAM,aAAa,QAAQ,OAAO,KAAK;AAGvC,UAAM,cAAc,MAAM,OAAO,OAAO,OAAO,WAAW,UAAU;AAEpE,WAAO;AAAA,EACT;AAAA;","names":[]}

package/sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(ms: number): Promise<void>;

package/sleep.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/sleep.ts
+var sleep_exports = {};
+__export(sleep_exports, {
+  sleep: () => sleep
+});
+module.exports = __toCommonJS(sleep_exports);
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sleep
+});
+//# sourceMappingURL=sleep.js.map

package/sleep.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/sleep.ts"],"sourcesContent":["export function sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,SAAS,MAAM,IAA2B;AAC/C,SAAO,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,EAAE,CAAC;AACzD;","names":[]}

package/src/arrayBuffer.ts

@@ -0,0 +1,29 @@
+/**
+ * Encode an input ArrayBuffer into a hex string.
+ */
+export function arrayBufferToHex(buffer: ArrayBuffer): string {
+  // Create a Uint8Array view of the ArrayBuffer
+  const byteArray = new Uint8Array(buffer);
+
+  // Convert each byte to a two-character hexadecimal string
+  return Array.from(byteArray)
+    .map((byte) => byte.toString(16).padStart(2, "0"))
+    .join("");
+}
+
+/**
+ * Encode an input ArrayBuffer into a base64 string.
+ */
+export function arrayBufferToBase64(buffer: ArrayBuffer): string {
+  // Convert the ArrayBuffer to a Uint8Array
+  const byteArray = new Uint8Array(buffer);
+
+  // Create a binary string from the byte array
+  const binaryString = Array.from(byteArray)
+    .map((byte) => String.fromCodePoint(byte))
+    .join("");
+
+  // Encode the binary string to base64. No need to use safeBtoa because we
+  // already simplified the binary input above.
+  return btoa(binaryString);
+}

package/src/safeBtoa.ts

@@ -0,0 +1,15 @@
+/**
+ * Base 64 encode the given input string, but safely.
+ */
+export function safeBtoa(input: string): string {
+  // Convert the string to a UTF-8 encoded binary-safe string
+  const utf8Bytes = new TextEncoder().encode(input);
+
+  // Convert the binary data to a string for btoa
+  const binaryString = Array.from(utf8Bytes)
+    .map((byte) => String.fromCodePoint(byte))
+    .join("");
+
+  // Use btoa to encode the binary-safe string
+  return btoa(binaryString);
+}

package/src/sha256.ts

@@ -0,0 +1,13 @@
+/**
+ * SHA-256 hash an input string into an ArrayBuffer.
+ */
+export async function sha256(input: string): Promise<ArrayBuffer> {
+  // Encode the input string as a Uint8Array
+  const encoder = new TextEncoder();
+  const uint8Array = encoder.encode(input);
+
+  // Compute the SHA-256 hash using the SubtleCrypto API
+  const arrayBuffer = await crypto.subtle.digest("SHA-256", uint8Array);
+
+  return arrayBuffer;
+}

package/src/sleep.ts

@@ -0,0 +1,3 @@
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}