gdc-common-utils-ts 1.0.4 → 1.0.7

package/{src/utils/normalize.ts → dist/utils/normalize.js}

@@ -1,21 +1,19 @@
 // Copyright 2025 Antifraud Services Inc. under the Apache License, Version 2.0.
 // File: crypto-ts/utils/normalize.ts
-
 /**
  * Creates a stable, serialized JSON string from an object by sorting its keys alphabetically.
  * This is the core function for achieving canonical serialization.
  * @param obj The object to serialize.
  * @returns A stable JSON string.
  */
-function stableStringify(obj: object): string {
-  const sortedKeys = Object.keys(obj).sort();
-  const sortedObject: { [key: string]: any } = {};
-  for (const key of sortedKeys) {
-    sortedObject[key] = (obj as any)[key];
-  }
-  return JSON.stringify(sortedObject);
+function stableStringify(obj) {
+    const sortedKeys = Object.keys(obj).sort();
+    const sortedObject = {};
+    for (const key of sortedKeys) {
+        sortedObject[key] = obj[key];
+    }
+    return JSON.stringify(sortedObject);
 }
-
 /**
  * Normalizes an object for hashing by excluding a standard set of volatile properties.
  * This function is based on the original `normalizeAndSerializeObject` from the backend utils.
@@ -23,13 +21,12 @@ function stableStringify(obj: object): string {
  * @param obj The object to normalize.
  * @returns A stable, canonical JSON string of the object's core properties.
  */
-export function normalizeObject(obj: object): string {
-  // Exclude properties that are often volatile or client-specific
-  // and should not be part of the core content hash.
-  const { id, meta, text, contained, ...coreContent } = obj as any;
-  return stableStringify(coreContent);
+export function normalizeObject(obj) {
+    // Exclude properties that are often volatile or client-specific
+    // and should not be part of the core content hash.
+    const { id, meta, text, contained, ...coreContent } = obj;
+    return stableStringify(coreContent);
 }
-
 /**
  * Normalizes a DIDComm payload specifically for generating the `payload.id` (version hash).
  * According to the defined architecture, this specifically excludes `id` and `meta`.
@@ -37,7 +34,7 @@ export function normalizeObject(obj: object): string {
  * @param payload The DIDComm payload object.
  * @returns A stable JSON string representation of the payload's core content.
  */
-export function normalizeDidcommPayloadForId(payload: object): string {
-  const { id, meta, ...coreContent } = payload as any;
-  return stableStringify(coreContent);
+export function normalizeDidcommPayloadForId(payload) {
+    const { id, meta, ...coreContent } = payload;
+    return stableStringify(coreContent);
 }

package/dist/utils/object-convert.d.ts

@@ -0,0 +1,20 @@
+/** Compares two arrays and returns true if they are the same, false otherwise. */
+export declare function arrayCompare(a: any[], b: any[]): boolean;
+/** Merges two Uint8Arrays into a single Uint8Array. */
+export declare function arrayMerge(a: Uint8Array, b: Uint8Array): Uint8Array;
+/**
+ * Serializes a JavaScript object to a Uint8Array of UTF-8 bytes.
+ * NOTE: This does not perform canonicalization (sorting keys).
+ */
+export declare function objectToBytes(data: object): Uint8Array;
+/**
+ * Serializes a JavaScript object to a raw Base64URL string.
+ * NOTE: This does not perform canonicalization (sorting keys).
+ */
+export declare function objectToRawBase64UrlSafe(data: object): string;
+/**
+ * Deserializes a Base64URL string back into a JavaScript object.
+ * @param base64UrlSafe The Base64URL encoded JSON string.
+ * @returns A JavaScript object.
+ */
+export declare function base64UrlSafeToJSON(base64UrlSafe: string | undefined): object;

package/{src/utils/object-convert.ts → dist/utils/object-convert.js}

@@ -1,11 +1,9 @@
 // crypto-ts/utils/object-convert.ts
-
 import { decodeURLSafe } from "@stablelib/base64";
-import { bytesToStringUTF8, stringToBytesUTF8 } from './string-convert';
-import { bytesToRawBase64UrlSafe } from './base-convert';
-
+import { bytesToStringUTF8, stringToBytesUTF8 } from './string-convert.js';
+import { bytesToRawBase64UrlSafe } from './base-convert.js';
 /** Compares two arrays and returns true if they are the same, false otherwise. */
-export function arrayCompare(a: any[], b: any[]): boolean {
+export function arrayCompare(a, b) {
     if (a.length !== b.length) {
         return false;
     }
@@ -16,42 +14,38 @@ export function arrayCompare(a: any[], b: any[]): boolean {
     }
     return true;
 }
-
 /** Merges two Uint8Arrays into a single Uint8Array. */
-export function arrayMerge(a: Uint8Array, b: Uint8Array): Uint8Array {
+export function arrayMerge(a, b) {
     const mergedArray = new Uint8Array(a.length + b.length);
     mergedArray.set(a);
     mergedArray.set(b, a.length);
     return mergedArray;
 }
-
 /**
  * Serializes a JavaScript object to a Uint8Array of UTF-8 bytes.
  * NOTE: This does not perform canonicalization (sorting keys).
  */
-export function objectToBytes(data: object): Uint8Array {
+export function objectToBytes(data) {
     return stringToBytesUTF8(JSON.stringify(data));
-};
-
+}
+;
 /**
  * Serializes a JavaScript object to a raw Base64URL string.
  * NOTE: This does not perform canonicalization (sorting keys).
  */
-export function objectToRawBase64UrlSafe(data: object): string {
+export function objectToRawBase64UrlSafe(data) {
     const dataBytes = objectToBytes(data);
     return bytesToRawBase64UrlSafe(dataBytes);
 }
-
 /**
  * Deserializes a Base64URL string back into a JavaScript object.
  * @param base64UrlSafe The Base64URL encoded JSON string.
  * @returns A JavaScript object.
  */
-export function base64UrlSafeToJSON(base64UrlSafe: string | undefined): object {
+export function base64UrlSafeToJSON(base64UrlSafe) {
     if (!base64UrlSafe) {
         throw new Error("Input string is undefined.");
     }
-    const dataBytes: Uint8Array = decodeURLSafe(base64UrlSafe);
+    const dataBytes = decodeURLSafe(base64UrlSafe);
     return JSON.parse(bytesToStringUTF8(dataBytes));
 }
-

package/dist/utils/string-convert.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Encodes a standard JavaScript string into a Uint8Array of strictly-validated UTF-8 bytes.
+ * This is the standard and safest method for serializing text data.
+ * @param str The string to convert.
+ * @returns A Uint8Array.
+ */
+export declare function stringToBytesUTF8(str: string): Uint8Array;
+/**
+ * Decodes a Uint8Array of strictly-validated UTF-8 bytes back into a string.
+ * This will fail if the byte array does not represent valid UTF-8.
+ * Use this for standard text and JSON.
+ * @param array The UTF-8 byte array to convert.
+ * @returns A string.
+ */
+export declare function bytesToStringUTF8(array: Uint8Array): string;
+/**
+ * Decodes a Uint8Array containing binary data into a string by processing
+ * each byte individually. This is more permissive than `bytesToStringUTF8` and is
+ * specifically required for handling payloads from libraries (e.g., pako) that
+ * may not be strictly UTF-8. Use this for decoding JWT payloads.
+ * @param array The binary/ASCII byte array to convert.
+ * @returns A string.
+ */
+export declare function bytesToStringASCII(array: Uint8Array): string;

package/{src/utils/string-convert.ts → dist/utils/string-convert.js}

@@ -1,17 +1,14 @@
 // crypto-ts/utils/string-convert.ts
-
 import { encode as encodeUTF8, decode as decodeUTF8 } from "@stablelib/utf8";
-
 /**
  * Encodes a standard JavaScript string into a Uint8Array of strictly-validated UTF-8 bytes.
  * This is the standard and safest method for serializing text data.
  * @param str The string to convert.
  * @returns A Uint8Array.
  */
-export function stringToBytesUTF8(str: string): Uint8Array {
+export function stringToBytesUTF8(str) {
     return encodeUTF8(str);
 }
-
 /**
  * Decodes a Uint8Array of strictly-validated UTF-8 bytes back into a string.
  * This will fail if the byte array does not represent valid UTF-8.
@@ -19,10 +16,9 @@ export function stringToBytesUTF8(str: string): Uint8Array {
  * @param array The UTF-8 byte array to convert.
  * @returns A string.
  */
-export function bytesToStringUTF8(array: Uint8Array): string {
+export function bytesToStringUTF8(array) {
     return decodeUTF8(array);
 }
-
 /**
  * Decodes a Uint8Array containing binary data into a string by processing
  * each byte individually. This is more permissive than `bytesToStringUTF8` and is
@@ -31,18 +27,15 @@ export function bytesToStringUTF8(array: Uint8Array): string {
  * @param array The binary/ASCII byte array to convert.
  * @returns A string.
  */
-export function bytesToStringASCII(array: Uint8Array): string {
+export function bytesToStringASCII(array) {
     var out, i, len, c;
     var char2, char3;
-
     out = "";
     len = array.length;
     i = 0;
     while (i < len) {
         c = array[i++];
-        switch (
-        c >> 4
-        ) {
+        switch (c >> 4) {
             case 0:
             case 1:
             case 2:
@@ -61,9 +54,7 @@ export function bytesToStringASCII(array: Uint8Array): string {
             case 14:
                 char2 = array[i++];
                 char3 = array[i++];
-                out += String.fromCharCode(
-                    ((c & 0x0f) << 12) | ((char2 & 0x3f) << 6) | ((char3 & 0x3f) << 0)
-                );
+                out += String.fromCharCode(((c & 0x0f) << 12) | ((char2 & 0x3f) << 6) | ((char3 & 0x3f) << 0));
                 break;
         }
     }

package/dist/utils/string-utils.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Capitalizes the first letter of a string.
+ * @param s The input string.
+ * @returns The capitalized string.
+ */
+export declare function capitalize(s: string): string;
+/**
+ * A simple string sanitizer that removes characters that are not alphanumeric or common punctuation.
+ * @param str The string to sanitize.
+ * @returns The sanitized string.
+ */
+export declare function sanitizeString(str: string): string;
+/**
+ * Converts a string to a string of its ASCII character codes.
+ * @param text The input string.
+ * @returns A string of character codes.
+ */
+export declare function stringToASCII(text: any): string;
+/**
+ * Converts a string to an array of numbers representing its byte values.
+ * From google closure library: https://github.com/google/closure-library/blob/8598d87242af59aac233270742c8984e2b2bdbe0/closure/goog/crypt/crypt.js#L117-L143
+ * @param str The input string.
+ * @returns An array of numbers.
+ */
+export declare function stringToBytesArrayOfNumbers(str: string): number[];

package/{src/utils/string-utils.ts → dist/utils/string-utils.js}

@@ -1,66 +1,62 @@
 // crypto-ts/utils/string-utils.ts
-
 /**
  * Capitalizes the first letter of a string.
  * @param s The input string.
  * @returns The capitalized string.
  */
-export function capitalize(s: string): string {
+export function capitalize(s) {
     return s.charAt(0).toUpperCase() + s.slice(1);
 }
-
 /**
  * A simple string sanitizer that removes characters that are not alphanumeric or common punctuation.
  * @param str The string to sanitize.
  * @returns The sanitized string.
  */
-export function sanitizeString(str: string): string {
+export function sanitizeString(str) {
     str = str.replace(/[^a-z0-9áéíóúñü \.,_-]/gim, "");
     return str.trim();
 }
-
 /**
  * Converts a string to a string of its ASCII character codes.
  * @param text The input string.
  * @returns A string of character codes.
  */
 /* tslint:disable:forin */
-export function stringToASCII(text: any): string {
+export function stringToASCII(text) {
     let ascii = "";
     for (const f in text) {
         ascii = ascii + text.charCodeAt(f);
     }
     return ascii;
 }
-
 /**
  * Converts a string to an array of numbers representing its byte values.
  * From google closure library: https://github.com/google/closure-library/blob/8598d87242af59aac233270742c8984e2b2bdbe0/closure/goog/crypt/crypt.js#L117-L143
  * @param str The input string.
  * @returns An array of numbers.
  */
-export function stringToBytesArrayOfNumbers(str: string): number[] {
-    let out = [],
-        p = 0;
+export function stringToBytesArrayOfNumbers(str) {
+    let out = [], p = 0;
     for (var i = 0; i < str.length; i++) {
         var c = str.charCodeAt(i);
         if (c < 128) {
             out[p++] = c;
-        } else if (c < 2048) {
+        }
+        else if (c < 2048) {
             out[p++] = (c >> 6) | 192;
             out[p++] = (c & 63) | 128;
-        } else if (
-            (c & 0xfc00) == 0xd800 &&
+        }
+        else if ((c & 0xfc00) == 0xd800 &&
             i + 1 < str.length &&
-            (str.charCodeAt(i + 1) & 0xfc00) == 0xdc00
-        ) {
+            (str.charCodeAt(i + 1) & 0xfc00) == 0xdc00) {
             // Surrogate Pair
             c = 0x10000 + ((c & 0x03ff) << 10) + (str.charCodeAt(++i) & 0x03ff);
             out[p++] = (c >> 18) | 240;
             out[p++] = ((c >> 12) & 63) | 128;
             out[p++] = ((c >> 6) & 63) | 128;
             out[p++] = (c & 63) | 128;
-        } else {
+        }
+        else {
             out[p++] = (c >> 12) | 224;
             out[p++] = ((c >> 6) & 63) | 128;
             out[p++] = (c & 63) | 128;

package/dist/utils/url.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Join the base_url and path without adding extra slashes.
+ *
+ * @param base_url - The base URL.
+ * @param path - The path to be appended to the base URL.
+ * @returns The safely joined URL.
+ */
+export declare function safelyJoinUrl(base_url: string, path: string): string;
+/**
+ * Splits a given URL into its domain and path components.
+ *
+ * @param {string} urlString - The full URL string to be split.
+ * @returns {{ domain: string; path: string }} An object containing the `domain` and `path` of the URL.
+ * If the URL is not valid it returns empty domain and path.
+ *
+ * @example
+ * Returns { domain: 'www.example.com', path: '/some/path' }
+ * const result = splitUrl('https://www.example.com/some/path?query=string');
+ *
+ * @example
+ * Returns null for invalid URLs
+ * const result = splitUrl('invalid-url');
+ */
+export declare function splitUrl(urlString: string): {
+    domain: string;
+    path: string;
+} | null;

package/{src/utils/url.ts → dist/utils/url.js}

@@ -1,14 +1,13 @@
 // crypto-ts/utils/url.ts
 // Copyright 2025 Antifraud Services Inc. under the Apache License, Version 2.0.
-
 /**
  * Join the base_url and path without adding extra slashes.
- * 
+ *
  * @param base_url - The base URL.
  * @param path - The path to be appended to the base URL.
  * @returns The safely joined URL.
  */
-export function safelyJoinUrl(base_url: string, path: string): string {
+export function safelyJoinUrl(base_url, path) {
     // Remove trailing slash from base_url if it exists
     if (base_url.endsWith('/')) {
         base_url = base_url.substring(0, base_url.length - 1);
@@ -19,7 +18,6 @@ export function safelyJoinUrl(base_url: string, path: string): string {
     }
     return `${base_url}/${path}`;
 }
-
 /**
  * Splits a given URL into its domain and path components.
  *
@@ -35,12 +33,13 @@ export function safelyJoinUrl(base_url: string, path: string): string {
  * Returns null for invalid URLs
  * const result = splitUrl('invalid-url');
  */
-export function splitUrl(urlString: string): { domain: string; path: string } | null {
+export function splitUrl(urlString) {
     try {
         const url = new URL(urlString);
         return { domain: url.hostname, path: url.pathname };
-    } catch (error) {
-        console.error("Invalid URL provided:", (error as any).message);
+    }
+    catch (error) {
+        console.error("Invalid URL provided:", error.message);
     }
     return null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-common-utils-ts",
-  "version": "1.0.4",
+  "version": "1.0.7",
   "publishConfig": {
     "access": "public"
   },
@@ -16,22 +16,64 @@
     "test": "jest",
     "test:coverage": "jest --coverage",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "prepublishOnly": "npm run typecheck && npm test -- --watchman=false"
+    "build": "tsc -p tsconfig.build.json && node patch-esm-imports.mjs",
+    "prepublishOnly": "npm run typecheck && npm test -- --watchman=false && npm run build"
   },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts",
-    "./AesManager": "./src/AesManager.ts",
-    "./CryptographyService": "./src/CryptographyService.ts",
-    "./hmac": "./src/hmac.ts",
-    "./constants/*": "./src/constants/*.ts",
-    "./models/*": "./src/models/*.ts",
-    "./utils/*": "./src/utils/*.ts",
-    "./interfaces/*": "./src/interfaces/*.ts",
-    "./constants": "./src/constants/index.ts",
-    "./models": "./src/models/index.ts",
-    "./utils": "./src/utils/index.ts",
-    "./interfaces": "./src/interfaces/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./AesManager": {
+      "types": "./dist/AesManager.d.ts",
+      "default": "./dist/AesManager.js"
+    },
+    "./CryptographyService": {
+      "types": "./dist/CryptographyService.d.ts",
+      "default": "./dist/CryptographyService.js"
+    },
+    "./hmac": {
+      "types": "./dist/hmac.d.ts",
+      "default": "./dist/hmac.js"
+    },
+    "./constants/*": {
+      "types": "./dist/constants/*.d.ts",
+      "default": "./dist/constants/*.js"
+    },
+    "./models/*": {
+      "types": "./dist/models/*.d.ts",
+      "default": "./dist/models/*.js"
+    },
+    "./utils/*": {
+      "types": "./dist/utils/*.d.ts",
+      "default": "./dist/utils/*.js"
+    },
+    "./interfaces/*": {
+      "types": "./dist/interfaces/*.d.ts",
+      "default": "./dist/interfaces/*.js"
+    },
+    "./constants": {
+      "types": "./dist/constants/index.d.ts",
+      "default": "./dist/constants/index.js"
+    },
+    "./models": {
+      "types": "./dist/models/index.d.ts",
+      "default": "./dist/models/index.js"
+    },
+    "./utils": {
+      "types": "./dist/utils/index.d.ts",
+      "default": "./dist/utils/index.js"
+    },
+    "./interfaces": {
+      "types": "./dist/interfaces/index.d.ts",
+      "default": "./dist/interfaces/index.js"
+    }
   },
+  "files": [
+    "dist"
+  ],
   "devDependencies": {
     "@babel/preset-env": "^7.24.0",
     "@types/jest": "^29.5.12",

package/PUBLISHING.md

@@ -1,33 +0,0 @@
-# Publishing
-
-This package is published as a public, unscoped package (`gdc-common-utils-ts`).
-
-## NPM token
-
-When creating a token in npmjs.com:
-- `Packages and scopes` must be **Read and write**.
-- `Organizations` permissions are **not required** for unscoped packages. Enable only if publishing under an org scope (`@org/`).
-
-## Configure the token
-
-```bash
-npm config set //registry.npmjs.org/:_authToken=YOUR_TOKEN
-```
-
-Verify:
-
-```bash
-npm whoami
-```
-
-## Publish
-
-```bash
-npm publish --access public
-```
-
-If 2FA for publish is enabled, add an OTP:
-
-```bash
-NPM_CONFIG_OTP=123456 npm publish --access public
-```

package/__tests__/AesManager.test.ts

@@ -1,53 +0,0 @@
-// src/__tests__/unit/security/AesManager.test.ts
-// Copyright 2025 Antifraud Services Inc. under the Apache License, Version 2.0.
-
-import { jest } from '@jest/globals';
-import { randomBytes } from 'crypto'; // Use Node.js native crypto module
-import { ProtectedDataAES } from '../src/models/aes.js';
-import { AesManager } from '../src/AesManager.js';
-
-describe('AesManager', () => {
-  let aesManager: AesManager;
-
-  beforeEach(() => {
-    aesManager = new AesManager();
-  });
-
-  it('should perform a round-trip (encrypt/decrypt) using base64url strings', async () => {
-    // --- 1. Arrange ---
-    const payload = { message: 'This is a secret message.', timestamp: Date.now() };
-    const plaintext = JSON.stringify(payload);
-    const cekBytes = randomBytes(32); // 256-bit Content Encryption Key
-    const aad = 'integrity-protected-data';
-    // --- 2. Act ---
-    // The public interface works with base64url strings, as required by JWE.
-    const encryptedData: ProtectedDataAES = await aesManager.encrypt(plaintext, cekBytes, aad);
-
-    // The result is then passed back to the decryption method.
-    const decryptedText = await aesManager.decrypt(encryptedData, cekBytes, aad);
-    const decryptedPayload = JSON.parse(decryptedText);
-    // --- 3. Assert ---
-    // The output of encrypt should be correctly formatted strings.
-    expect(typeof encryptedData.ciphertext).toBe('string');
-    expect(typeof encryptedData.iv).toBe('string');
-    expect(typeof encryptedData.tag).toBe('string');
-
-    // The final decrypted object must match the original payload.
-    expect(decryptedPayload).toEqual(payload);
-  });
-
-  it('should fail decryption if the AAD is tampered with', async () => {
-    // --- 1. Arrange ---
-    const plaintext = JSON.stringify({ data: 'secret' });
-    const cekBytes = randomBytes(32);
-    const originalAad = 'original_aad';
-    const tamperedAad = 'tampered_aad';
-
-    const encryptedData = await aesManager.encrypt(plaintext, cekBytes, originalAad);
-    // --- 2. Assert ---
-    // Expect decryption to fail when using the wrong AAD.
-    await expect(
-      aesManager.decrypt(encryptedData, cekBytes, tamperedAad)
-    ).rejects.toThrow();
-  });
-});