gdc-sdk-front-ts 0.6.2 → 0.6.6

package/dist/gdc-common-utils-ts/src/utils/manager-error.js

@@ -0,0 +1,21 @@
+// src/utils/manager-error.ts
+// Copyright 2025 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { IssueTypeToHttpStatus } from "../models/issue";
+/**
+ * A custom error class used to propagate specific operational failures from deep
+ * within the manager's logic to the central error handler.
+ * It carries the necessary information to build a well-formed ErrorEntry.
+ */
+export class ManagerError extends Error {
+    /**
+     * @param message The diagnostic message for the error.
+     * @param code The classification of the error, from which the HTTP status will be derived.
+     */
+    constructor(message, code) {
+        super(message);
+        this.name = 'ManagerError';
+        this.code = code;
+        // Automatically derive the HTTP status string from the issue code.
+        this.status = IssueTypeToHttpStatus[code] || '500';
+    }
+}

package/dist/gdc-common-utils-ts/src/utils/medication-claim-helpers.d.ts

@@ -0,0 +1,56 @@
+export type MedicationInteroperableClaims = Record<string, unknown>;
+/**
+ * Returns tokenized values from a medication claim key stored as CSV.
+ */
+export declare function getMedicationClaimList(claims: MedicationInteroperableClaims, claimKey: string): string[];
+/**
+ * Replaces a medication claim list from array/string input and stores canonical CSV.
+ */
+export declare function setMedicationClaimList(claims: MedicationInteroperableClaims, claimKey: string, values: string | readonly string[]): MedicationInteroperableClaims;
+/**
+ * Adds values to a medication claim list preserving uniqueness.
+ */
+export declare function addMedicationClaimList(claims: MedicationInteroperableClaims, claimKey: string, values: string | readonly string[]): MedicationInteroperableClaims;
+/**
+ * Removes values from a medication claim list while preserving uniqueness.
+ */
+export declare function removeMedicationClaimList(claims: MedicationInteroperableClaims, claimKey: string, values: string | readonly string[]): MedicationInteroperableClaims;
+/**
+ * Medication category list getter/setter/add.
+ */
+export declare function getMedicationCategoryList(claims: MedicationInteroperableClaims): string[];
+export declare function setMedicationCategoryList(claims: MedicationInteroperableClaims, values: string | readonly string[]): MedicationInteroperableClaims;
+export declare function addMedicationCategoryList(claims: MedicationInteroperableClaims, values: string | readonly string[]): MedicationInteroperableClaims;
+export declare function removeMedicationCategoryList(claims: MedicationInteroperableClaims, values: string | readonly string[]): MedicationInteroperableClaims;
+/**
+ * Medication part-of list getter/setter/add.
+ */
+export declare function getMedicationPartOfList(claims: MedicationInteroperableClaims): string[];
+export declare function setMedicationPartOfList(claims: MedicationInteroperableClaims, values: string | readonly string[]): MedicationInteroperableClaims;
+export declare function addMedicationPartOfList(claims: MedicationInteroperableClaims, values: string | readonly string[]): MedicationInteroperableClaims;
+export declare function removeMedicationPartOfList(claims: MedicationInteroperableClaims, values: string | readonly string[]): MedicationInteroperableClaims;
+/**
+ * Medication code list getter/setter/add.
+ *
+ * Note:
+ * - many flows use a single code, but CSV list is supported for UI preview/edit
+ *   where multiple coded values can be staged before normalization.
+ */
+export declare function getMedicationCodeList(claims: MedicationInteroperableClaims): string[];
+export declare function setMedicationCodeList(claims: MedicationInteroperableClaims, values: string | readonly string[]): MedicationInteroperableClaims;
+export declare function addMedicationCodeList(claims: MedicationInteroperableClaims, values: string | readonly string[]): MedicationInteroperableClaims;
+export declare function removeMedicationCodeList(claims: MedicationInteroperableClaims, values: string | readonly string[]): MedicationInteroperableClaims;
+/**
+ * Medication source list getter/setter/add.
+ */
+export declare function getMedicationSourceList(claims: MedicationInteroperableClaims): string[];
+export declare function setMedicationSourceList(claims: MedicationInteroperableClaims, values: string | readonly string[]): MedicationInteroperableClaims;
+export declare function addMedicationSourceList(claims: MedicationInteroperableClaims, values: string | readonly string[]): MedicationInteroperableClaims;
+export declare function removeMedicationSourceList(claims: MedicationInteroperableClaims, values: string | readonly string[]): MedicationInteroperableClaims;
+/**
+ * Medication subject list getter/setter/add.
+ */
+export declare function getMedicationSubjectList(claims: MedicationInteroperableClaims): string[];
+export declare function setMedicationSubjectList(claims: MedicationInteroperableClaims, values: string | readonly string[]): MedicationInteroperableClaims;
+export declare function addMedicationSubjectList(claims: MedicationInteroperableClaims, values: string | readonly string[]): MedicationInteroperableClaims;
+export declare function removeMedicationSubjectList(claims: MedicationInteroperableClaims, values: string | readonly string[]): MedicationInteroperableClaims;

package/dist/gdc-common-utils-ts/src/utils/medication-claim-helpers.js

@@ -0,0 +1,127 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { MedicationStatementClaim } from '../models/interoperable-claims/medication-statement-claims.js';
+function splitCsv(value) {
+    return String(value || '')
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function normalizeTokens(values) {
+    return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))];
+}
+function normalizeInput(values) {
+    return Array.isArray(values)
+        ? normalizeTokens(values)
+        : normalizeTokens(splitCsv(values));
+}
+/**
+ * Returns tokenized values from a medication claim key stored as CSV.
+ */
+export function getMedicationClaimList(claims, claimKey) {
+    return normalizeTokens(splitCsv(claims[claimKey]));
+}
+/**
+ * Replaces a medication claim list from array/string input and stores canonical CSV.
+ */
+export function setMedicationClaimList(claims, claimKey, values) {
+    const nextValues = normalizeInput(values);
+    return {
+        ...claims,
+        [claimKey]: nextValues.join(','),
+    };
+}
+/**
+ * Adds values to a medication claim list preserving uniqueness.
+ */
+export function addMedicationClaimList(claims, claimKey, values) {
+    const current = getMedicationClaimList(claims, claimKey);
+    const additions = normalizeInput(values);
+    return setMedicationClaimList(claims, claimKey, [...current, ...additions]);
+}
+/**
+ * Removes values from a medication claim list while preserving uniqueness.
+ */
+export function removeMedicationClaimList(claims, claimKey, values) {
+    const removals = new Set(normalizeInput(values));
+    const nextValues = getMedicationClaimList(claims, claimKey).filter((value) => !removals.has(value));
+    return setMedicationClaimList(claims, claimKey, nextValues);
+}
+/**
+ * Medication category list getter/setter/add.
+ */
+export function getMedicationCategoryList(claims) {
+    return getMedicationClaimList(claims, MedicationStatementClaim.Category);
+}
+export function setMedicationCategoryList(claims, values) {
+    return setMedicationClaimList(claims, MedicationStatementClaim.Category, values);
+}
+export function addMedicationCategoryList(claims, values) {
+    return addMedicationClaimList(claims, MedicationStatementClaim.Category, values);
+}
+export function removeMedicationCategoryList(claims, values) {
+    return removeMedicationClaimList(claims, MedicationStatementClaim.Category, values);
+}
+/**
+ * Medication part-of list getter/setter/add.
+ */
+export function getMedicationPartOfList(claims) {
+    return getMedicationClaimList(claims, MedicationStatementClaim.PartOf);
+}
+export function setMedicationPartOfList(claims, values) {
+    return setMedicationClaimList(claims, MedicationStatementClaim.PartOf, values);
+}
+export function addMedicationPartOfList(claims, values) {
+    return addMedicationClaimList(claims, MedicationStatementClaim.PartOf, values);
+}
+export function removeMedicationPartOfList(claims, values) {
+    return removeMedicationClaimList(claims, MedicationStatementClaim.PartOf, values);
+}
+/**
+ * Medication code list getter/setter/add.
+ *
+ * Note:
+ * - many flows use a single code, but CSV list is supported for UI preview/edit
+ *   where multiple coded values can be staged before normalization.
+ */
+export function getMedicationCodeList(claims) {
+    return getMedicationClaimList(claims, MedicationStatementClaim.Code);
+}
+export function setMedicationCodeList(claims, values) {
+    return setMedicationClaimList(claims, MedicationStatementClaim.Code, values);
+}
+export function addMedicationCodeList(claims, values) {
+    return addMedicationClaimList(claims, MedicationStatementClaim.Code, values);
+}
+export function removeMedicationCodeList(claims, values) {
+    return removeMedicationClaimList(claims, MedicationStatementClaim.Code, values);
+}
+/**
+ * Medication source list getter/setter/add.
+ */
+export function getMedicationSourceList(claims) {
+    return getMedicationClaimList(claims, MedicationStatementClaim.Source);
+}
+export function setMedicationSourceList(claims, values) {
+    return setMedicationClaimList(claims, MedicationStatementClaim.Source, values);
+}
+export function addMedicationSourceList(claims, values) {
+    return addMedicationClaimList(claims, MedicationStatementClaim.Source, values);
+}
+export function removeMedicationSourceList(claims, values) {
+    return removeMedicationClaimList(claims, MedicationStatementClaim.Source, values);
+}
+/**
+ * Medication subject list getter/setter/add.
+ */
+export function getMedicationSubjectList(claims) {
+    return getMedicationClaimList(claims, MedicationStatementClaim.Subject);
+}
+export function setMedicationSubjectList(claims, values) {
+    return setMedicationClaimList(claims, MedicationStatementClaim.Subject, values);
+}
+export function addMedicationSubjectList(claims, values) {
+    return addMedicationClaimList(claims, MedicationStatementClaim.Subject, values);
+}
+export function removeMedicationSubjectList(claims, values) {
+    return removeMedicationClaimList(claims, MedicationStatementClaim.Subject, values);
+}

package/dist/gdc-common-utils-ts/src/utils/multibase58.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Encode bytes into multibase base58btc string (prefixed with 'z').
+ * Equivalent to multiformats base58btc.encode.
+ */
+export declare function encodeMultibase58btc(data: Uint8Array): string;
+/**
+ * Decode a multibase base58btc string (must start with 'z').
+ * Equivalent to multiformats base58btc.decode.
+ */
+export declare function decodeMultibase58btc(multibaseStr: string): Uint8Array;
+export declare function encodeHexToMultibase58btc(hexStr: string): string;
+export declare function decodeMultibase58btcToHex(b58str: string): string;
+export declare function decodeMultibase58btcToUUID(b58str: string): string;

package/dist/gdc-common-utils-ts/src/utils/multibase58.js

@@ -0,0 +1,40 @@
+// crypto-ts/crypto-ts/utils/multibase58.ts
+// Copyright 2025 Antifraud Services Inc. under the Apache License, Version 2.0.
+import baseX from "base-x";
+const BASE58_BTC_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const base58btc = baseX(BASE58_BTC_ALPHABET);
+/**
+ * Encode bytes into multibase base58btc string (prefixed with 'z').
+ * Equivalent to multiformats base58btc.encode.
+ */
+export function encodeMultibase58btc(data) {
+    return "z" + base58btc.encode(Buffer.from(data));
+}
+/**
+ * Decode a multibase base58btc string (must start with 'z').
+ * Equivalent to multiformats base58btc.decode.
+ */
+export function decodeMultibase58btc(multibaseStr) {
+    if (!multibaseStr.startsWith("z")) {
+        throw new Error("Invalid multibase58btc string: missing 'z' prefix");
+    }
+    return new Uint8Array(base58btc.decode(multibaseStr.slice(1)));
+}
+// HEX ➜ multibase base58btc (quita guiones si los hay)
+export function encodeHexToMultibase58btc(hexStr) {
+    const hexClean = hexStr.replace(/-/g, "").toLowerCase();
+    if (!/^[0-9a-f]{32}$/i.test(hexClean))
+        throw new Error("Invalid 16-byte hex string");
+    const bytes = new Uint8Array(hexClean.match(/.{1,2}/g).map(b => parseInt(b, 16)));
+    return encodeMultibase58btc(bytes);
+}
+// multibase base58btc ➜ hex (no hyppens)
+export function decodeMultibase58btcToHex(b58str) {
+    const bytes = decodeMultibase58btc(b58str);
+    return Array.from(bytes).map(b => b.toString(16).padStart(2, "0")).join("");
+}
+// multibase base58btc ➜ UUID (with hyppens)
+export function decodeMultibase58btcToUUID(b58str) {
+    const hex = decodeMultibase58btcToHex(b58str);
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}

package/dist/gdc-common-utils-ts/src/utils/multibasehash.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Encodes input into multibase(base58btc(multihash(sha384))).
+ * - Multihash prefix: 0x15 0x30
+ *   - 0x15: code for SHA-384
+ *   - 0x30: length of SHA-384 = 48 bytes
+ * - Multibase prefix: 'z'
+ */
+export declare function encodeMultibaseSha384(input: string | Uint8Array): string;

package/dist/gdc-common-utils-ts/src/utils/multibasehash.js

@@ -0,0 +1,23 @@
+// Copyright 2025 Antifraud Services Inc. under the Apache License, Version 2.0.
+// Use explicit .js subpaths to satisfy package exports in Metro/Node ESM.
+import { sha384 } from '@noble/hashes/sha2.js';
+import { utf8ToBytes } from '@noble/hashes/utils.js';
+import baseX from 'base-x';
+const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+const base58btc = baseX(BASE58_ALPHABET);
+/**
+ * Encodes input into multibase(base58btc(multihash(sha384))).
+ * - Multihash prefix: 0x15 0x30
+ *   - 0x15: code for SHA-384
+ *   - 0x30: length of SHA-384 = 48 bytes
+ * - Multibase prefix: 'z'
+ */
+export function encodeMultibaseSha384(input) {
+    const bytes = typeof input === 'string' ? utf8ToBytes(input) : input;
+    const hashBytes = sha384(bytes);
+    const multihashBytes = new Uint8Array(2 + hashBytes.length);
+    multihashBytes[0] = 0x15; // SHA-384 code
+    multihashBytes[1] = 0x30; // length = 48
+    multihashBytes.set(hashBytes, 2);
+    return 'z' + base58btc.encode(multihashBytes);
+}

package/dist/gdc-common-utils-ts/src/utils/normalize-uuid.d.ts

@@ -0,0 +1 @@
+export declare function normalizeUuid(input: string | undefined): string | undefined;

package/dist/gdc-common-utils-ts/src/utils/normalize-uuid.js

@@ -0,0 +1,35 @@
+// Normalizes a subject identifier to a canonical UUID (hexadecimal, lowercase, no dashes)
+// Accepts: urn:uuid:<uuid>, <ResourceType>/<uuid>, <uuid> (with or without dashes), base58 (optional)
+// Returns: canonical hex string (no dashes, lowercase) or undefined if not valid
+import { decodeMultibase58btcToHex } from './multibase58';
+export function normalizeUuid(input) {
+    if (!input)
+        return undefined;
+    let s = String(input).trim();
+    // urn:uuid:<...>
+    if (s.startsWith('urn:uuid:'))
+        s = s.slice(9);
+    // <ResourceType>/<...>
+    const slashIdx = s.indexOf('/');
+    if (slashIdx >= 0)
+        s = s.slice(slashIdx + 1);
+    // Si es multibase58btc (z...)
+    if (s.startsWith('z')) {
+        try {
+            const hex = decodeMultibase58btcToHex(s);
+            if (/^[0-9a-f]{32}$/.test(hex))
+                return hex;
+        }
+        catch (e) {
+            // no válido, ignorar
+        }
+    }
+    // Remove dashes
+    s = s.replace(/-/g, '');
+    // Lowercase
+    s = s.toLowerCase();
+    // Validate: must be 32 hex chars
+    if (/^[0-9a-f]{32}$/.test(s))
+        return s;
+    return undefined;
+}

package/dist/gdc-common-utils-ts/src/utils/normalize.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ *
+ * @param obj The object to normalize.
+ * @returns A stable, canonical JSON string of the object's core properties.
+ */
+export declare function normalizeObject(obj: object): string;
+/**
+ * Normalizes a DIDComm payload specifically for generating the `payload.id` (version hash).
+ * According to the defined architecture, this specifically excludes `id` and `meta`.
+ *
+ * @param payload The DIDComm payload object.
+ * @returns A stable JSON string representation of the payload's core content.
+ */
+export declare function normalizeDidcommPayloadForId(payload: object): string;

package/dist/gdc-common-utils-ts/src/utils/normalize.js

@@ -0,0 +1,40 @@
+// 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) {
+    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.
+ *
+ * @param obj The object to normalize.
+ * @returns A stable, canonical JSON string of the object's core properties.
+ */
+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`.
+ *
+ * @param payload The DIDComm payload object.
+ * @returns A stable JSON string representation of the payload's core content.
+ */
+export function normalizeDidcommPayloadForId(payload) {
+    const { id, meta, ...coreContent } = payload;
+    return stableStringify(coreContent);
+}

package/dist/gdc-common-utils-ts/src/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/dist/gdc-common-utils-ts/src/utils/object-convert.js

@@ -0,0 +1,51 @@
+// crypto-ts/utils/object-convert.ts
+import { decodeURLSafe } from "@stablelib/base64";
+import { bytesToStringUTF8, stringToBytesUTF8 } from './string-convert';
+import { bytesToRawBase64UrlSafe } from './base-convert';
+/** Compares two arrays and returns true if they are the same, false otherwise. */
+export function arrayCompare(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+/** Merges two Uint8Arrays into a single 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) {
+    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) {
+    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) {
+    if (!base64UrlSafe) {
+        throw new Error("Input string is undefined.");
+    }
+    const dataBytes = decodeURLSafe(base64UrlSafe);
+    return JSON.parse(bytesToStringUTF8(dataBytes));
+}

package/dist/gdc-common-utils-ts/src/utils/smart-scope.d.ts

@@ -0,0 +1,28 @@
+export type SmartCompositionReadScopeOptions = {
+    /**
+     * Subject DID pinned by the current CORE GW root scope contract.
+     */
+    subjectDid: string;
+    /**
+     * One or more section claims such as `LOINC|60591-5`.
+     *
+     * When omitted, the helper defaults to the IPS patient summary document.
+     */
+    sections?: string | string[];
+    /**
+     * Read verb suffix used in the current GW SMART root scope contract.
+     *
+     * Defaults to `rs`.
+     */
+    accessVerb?: 'r' | 'rs' | 'cruds';
+};
+/**
+ * Builds the gateway-pinned SMART root scope required by the current CORE GW
+ * token contract:
+ *
+ * `organization/Composition.<verb>?subject=<did:web:...>&section=<code>[,<code>...]`
+ *
+ * This is intentionally a gateway-contract helper, not a generic SMART/FHIR
+ * scope builder.
+ */
+export declare function buildSmartCompositionReadScope(options: SmartCompositionReadScopeOptions): string;

package/dist/gdc-common-utils-ts/src/utils/smart-scope.js

@@ -0,0 +1,29 @@
+import { HealthcareBasicSections } from '../constants/healthcare';
+/**
+ * Builds the gateway-pinned SMART root scope required by the current CORE GW
+ * token contract:
+ *
+ * `organization/Composition.<verb>?subject=<did:web:...>&section=<code>[,<code>...]`
+ *
+ * This is intentionally a gateway-contract helper, not a generic SMART/FHIR
+ * scope builder.
+ */
+export function buildSmartCompositionReadScope(options) {
+    const subjectDid = String(options.subjectDid || '').trim();
+    if (!subjectDid) {
+        throw new Error('buildSmartCompositionReadScope requires subjectDid.');
+    }
+    const sections = Array.isArray(options.sections)
+        ? options.sections
+        : options.sections
+            ? [options.sections]
+            : [HealthcareBasicSections.PatientSummaryDocument.claim];
+    const normalizedSections = sections
+        .map((section) => String(section || '').trim())
+        .filter(Boolean);
+    const query = new URLSearchParams({ subject: subjectDid });
+    if (normalizedSections.length > 0) {
+        query.set('section', normalizedSections.join(','));
+    }
+    return `organization/Composition.${options.accessVerb || 'rs'}?${query.toString()}`;
+}

package/dist/gdc-common-utils-ts/src/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/dist/gdc-common-utils-ts/src/utils/string-convert.js

@@ -0,0 +1,62 @@
+// 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) {
+    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.
+ * Use this for standard text and JSON.
+ * @param array The UTF-8 byte array to convert.
+ * @returns A 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
+ * 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 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) {
+            case 0:
+            case 1:
+            case 2:
+            case 3:
+            case 4:
+            case 5:
+            case 6:
+            case 7:
+                out += String.fromCharCode(c);
+                break;
+            case 12:
+            case 13:
+                char2 = array[i++];
+                out += String.fromCharCode(((c & 0x1f) << 6) | (char2 & 0x3f));
+                break;
+            case 14:
+                char2 = array[i++];
+                char3 = array[i++];
+                out += String.fromCharCode(((c & 0x0f) << 12) | ((char2 & 0x3f) << 6) | ((char3 & 0x3f) << 0));
+                break;
+        }
+    }
+    return out;
+}

package/dist/gdc-common-utils-ts/src/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[];