gdc-common-utils-ts 1.0.4 → 1.0.7

package/dist/utils/actor.d.ts

@@ -0,0 +1,18 @@
+export type ParsedActor = {
+    /**
+     * The token subject / authenticated actor identifier (as provided in the token request).
+     * Examples:
+     * - did:web:api.acme.org:employee:doctor1@acme.org:ISCO-08|2211
+     * - did:web:api.acme.org:employee:doctor1@acme.org:ISCO-08|2211:<device-uuid>
+     * - did:web:api.acme.org:family:<id>:v3-RoleCode|ONESELF
+     * - did:web:api.acme.org:family:<id>:v3-RoleCode|CHILD:<device-uuid>
+     */
+    sub: string;
+    /** The actor identifier (employee email, familyId, or raw email). */
+    identifier?: string;
+    /** The employee role code if present (e.g. "ISCO-08|2211"). */
+    role?: string;
+    /** The base organization did:web if `sub` is did:web (e.g. "did:web:api.acme.org"). */
+    organization?: string;
+};
+export declare function parseActorFromSub(sub: string): ParsedActor;

package/dist/utils/actor.js

@@ -0,0 +1,36 @@
+// src/utils/actor.ts
+export function parseActorFromSub(sub) {
+    const trimmed = (sub || '').trim();
+    const parsed = { sub: trimmed };
+    if (!trimmed)
+        return parsed;
+    if (trimmed.startsWith('did:web:')) {
+        // Base org DID is always the first component after did:web:
+        // did:web:<host>[:...]
+        const after = trimmed.replace(/^did:web:/, '');
+        const host = after.split(':')[0];
+        if (host)
+            parsed.organization = `did:web:${host}`;
+        // Extract email and role from endpoint-style DID shapes:
+        // did:web:<host>:(employee|family):<id>:<roleSystem>|<roleCode>[:<uuid>]
+        const parts = after.split(':');
+        const employeeIdx = parts.indexOf('employee');
+        const familyIdx = parts.indexOf('family');
+        const idIdx = employeeIdx >= 0 ? employeeIdx + 1 : familyIdx >= 0 ? familyIdx + 1 : -1;
+        const identifier = idIdx >= 0 ? parts[idIdx] : undefined;
+        if (identifier) {
+            parsed.identifier = identifier.includes('@') ? identifier.toLowerCase() : identifier;
+        }
+        if (idIdx >= 0 && parts.length > idIdx + 1) {
+            const roleCandidate = parts[idIdx + 1];
+            if (roleCandidate && roleCandidate.includes('|'))
+                parsed.role = roleCandidate;
+        }
+        return parsed;
+    }
+    // Raw email actor identifier
+    if (trimmed.includes('@') && !/\s/.test(trimmed)) {
+        parsed.identifier = trimmed.toLowerCase();
+    }
+    return parsed;
+}

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

@@ -0,0 +1,20 @@
+/** Converts a Uint8Array to a hexadecimal string. */
+export declare function bytesToHexString(bytes: Uint8Array): string;
+/** Encodes a Uint8Array into a Base58 string. */
+export declare function bytesToBase58(bytes: Uint8Array): string;
+/** Decodes a Base58 string into a Uint8Array. */
+export declare function base58ToBytes(base58str: string): Uint8Array;
+/** Encodes a string into a standard Base64 string (with padding). */
+export declare function stringToStdBase64(str: string): string;
+/** Converts a standard Base64 string to a Base64URL string. */
+export declare function base64ToBase64Url(encodedData: string): string;
+/** Encodes a string into a Base64URL string. */
+export declare function stringToBase64Url(stringifiedData: string): string;
+/** Converts a Base64URL string to a standard Base64 string. */
+export declare function base64UrlToBase64(encodedData: string): string;
+/** Decodes a string that is either Base64 or Base64URL into a Uint8Array. */
+export declare function base64OrUrlSafeToBytes(base64OrUrlSafe: string): Uint8Array;
+/** Encodes a Uint8Array into a standard Base64 string (with padding). */
+export declare function bytesToBase64(bytes: Uint8Array): string;
+/** Encodes a Uint8Array into a raw Base64URL string (no padding). */
+export declare function bytesToRawBase64UrlSafe(bytes: Uint8Array): string;

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

@@ -1,77 +1,64 @@
 // crypto-ts/utils/base-convert.ts
-
-import {
-    encode as encodeBase64,
-    decode as decodeBase64,
-    decodeURLSafe,
-    encodeURLSafe,
-} from "@stablelib/base64";
-import { alphabetBase58, decodeN, encodeN } from './baseN';
-import { stringToBytesUTF8 } from './string-convert';
-
+import { encode as encodeBase64, decode as decodeBase64, decodeURLSafe, encodeURLSafe, } from "@stablelib/base64";
+import { alphabetBase58, decodeN, encodeN } from './baseN.js';
+import { stringToBytesUTF8 } from './string-convert.js';
 /** Converts a Uint8Array to a hexadecimal string. */
-export function bytesToHexString(bytes: Uint8Array): string {
+export function bytesToHexString(bytes) {
     return Array.from(bytes, (byte) => {
         return ('0' + (byte & 0xff).toString(16)).slice(-2);
     }).join('');
-};
-
+}
+;
 /** Encodes a Uint8Array into a Base58 string. */
-export function bytesToBase58(bytes: Uint8Array): string {
+export function bytesToBase58(bytes) {
     return encodeN(bytes, alphabetBase58, undefined);
 }
-
 /** Decodes a Base58 string into a Uint8Array. */
-export function base58ToBytes(base58str: string): Uint8Array {
+export function base58ToBytes(base58str) {
     return decodeN(base58str, alphabetBase58);
 }
-
 /** Encodes a string into a standard Base64 string (with padding). */
-export function stringToStdBase64(str: string): string {
-    const dataBytes: Uint8Array = stringToBytesUTF8(str);
+export function stringToStdBase64(str) {
+    const dataBytes = stringToBytesUTF8(str);
     return encodeBase64(dataBytes);
 }
-
 /** Converts a standard Base64 string to a Base64URL string. */
-export function base64ToBase64Url(encodedData: string): string {
+export function base64ToBase64Url(encodedData) {
     if (encodedData && (encodedData.indexOf("+") !== -1 || encodedData.indexOf("/") !== -1)) {
         return encodedData.split("+").join("-").split("/").join("_");
-    } else {
+    }
+    else {
         return encodedData;
     }
 }
-
 /** Encodes a string into a Base64URL string. */
-export function stringToBase64Url(stringifiedData: string): string {
+export function stringToBase64Url(stringifiedData) {
     const encodedData = stringToStdBase64(stringifiedData);
     return base64ToBase64Url(encodedData);
 }
-
 /** Converts a Base64URL string to a standard Base64 string. */
-export function base64UrlToBase64(encodedData: string): string {
+export function base64UrlToBase64(encodedData) {
     if (encodedData && (encodedData.indexOf("-") !== -1 || encodedData.indexOf("_") !== -1)) {
         return encodedData.split("-").join("+").split("_").join("/");
-    } else {
+    }
+    else {
         return encodedData;
     }
 }
-
 /** Decodes a string that is either Base64 or Base64URL into a Uint8Array. */
-export function base64OrUrlSafeToBytes(base64OrUrlSafe: string): Uint8Array {
+export function base64OrUrlSafeToBytes(base64OrUrlSafe) {
     if (String(base64OrUrlSafe).includes("+") || String(base64OrUrlSafe).includes("/")) {
-        return  new Uint8Array(decodeBase64(base64OrUrlSafe));
-    } else {
+        return new Uint8Array(decodeBase64(base64OrUrlSafe));
+    }
+    else {
         return new Uint8Array(decodeURLSafe(base64OrUrlSafe));
     }
 }
-
 /** Encodes a Uint8Array into a standard Base64 string (with padding). */
-export function bytesToBase64(bytes: Uint8Array): string {
+export function bytesToBase64(bytes) {
     return encodeBase64(bytes);
 }
-
 /** Encodes a Uint8Array into a raw Base64URL string (no padding). */
-export function bytesToRawBase64UrlSafe(bytes: Uint8Array): string {
+export function bytesToRawBase64UrlSafe(bytes) {
     return encodeURLSafe(bytes).replace(/=/g, "");
 }
-

package/dist/utils/baseN.d.ts

@@ -0,0 +1,35 @@
+export declare const alphabetBase58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+export declare class BaseN {
+    constructor();
+    /** BaseN-encodes a Uint8Array using the given alphabet */
+    static encodeN(input: Uint8Array, alphabet: string, maxline: string | undefined): string;
+    /** Decodes a baseN-encoded (using the given alphabet) string to a Uint8Array. */
+    static decodeN(input: string, alphabet: string): Uint8Array;
+    /** Base58-encodes a Uint8Array using the Bitcoin alphabet '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz' */
+    static encodeBytesToBase58(inputBytes: Uint8Array): string;
+    /** Base58-encodes a Uint8Array using the Bitcoin alphabet '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz' */
+    static encodeStrToBase58(inputStr: string): string;
+    /** Decodes a base58-encoded string to a Uint8Array (using the Bitcoin alphabet '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz') */
+    static decodeBytesFromBase58(base58Str: string): Uint8Array;
+    /** Decodes a base58-encoded string to a Uint8Array (using the Bitcoin alphabet '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz') */
+    static decodeStrFromBase58(base58Str: string): string;
+}
+/**
+  * BaseN-encodes a Uint8Array using the given alphabet.
+  *
+  * @param {Uint8Array} input the bytes to encode in a Uint8Array.
+  * @param {number} maxline the maximum number of encoded characters per line to
+  *          use, defaults to none.
+  *
+  * @return {string} the baseN-encoded output string.
+  */
+export declare function encodeN(input: Uint8Array, alphabet: string, maxline: string | undefined): string;
+/**
+  * Decodes a baseN-encoded (using the given alphabet) string to a
+  * Uint8Array.
+  *
+  * @param {string} input the baseN-encoded input string.
+  *
+  * @return {Uint8Array} the decoded bytes in a Uint8Array.
+  */
+export declare function decodeN(input: string, alphabet: string): Uint8Array;

package/dist/utils/baseN.js

@@ -0,0 +1,174 @@
+/**
+ * From https://raw.githubusercontent.com/digitalbazaar/base58-universal/master/baseN.js
+ * Base-N/Base-X encoding/decoding functions.
+ *
+ * Original implementation from base-x:
+ * https://github.com/cryptocoinjs/base-x
+ *
+ * Which is MIT licensed:
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright base-x contributors (c) 2016
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+'use strict';
+import { bytesToStringUTF8, stringToBytesUTF8 } from './string-convert.js';
+// baseN alphabet indexes
+const _reverseAlphabets = [];
+// base58 characters (Bitcoin alphabet)
+export const alphabetBase58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+export class BaseN {
+    constructor() { }
+    /** BaseN-encodes a Uint8Array using the given alphabet */
+    static encodeN(input, alphabet, maxline) {
+        return encodeN(input, alphabet, maxline);
+    }
+    /** Decodes a baseN-encoded (using the given alphabet) string to a Uint8Array. */
+    static decodeN(input, alphabet) {
+        return decodeN(input, alphabet);
+    }
+    /** Base58-encodes a Uint8Array using the Bitcoin alphabet '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz' */
+    static encodeBytesToBase58(inputBytes) {
+        return encodeN(inputBytes, alphabetBase58, undefined);
+    }
+    /** Base58-encodes a Uint8Array using the Bitcoin alphabet '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz' */
+    static encodeStrToBase58(inputStr) {
+        const inputBytes = stringToBytesUTF8(inputStr);
+        return this.encodeBytesToBase58(inputBytes);
+    }
+    /** Decodes a base58-encoded string to a Uint8Array (using the Bitcoin alphabet '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz') */
+    static decodeBytesFromBase58(base58Str) {
+        return decodeN(base58Str, alphabetBase58);
+    }
+    /** Decodes a base58-encoded string to a Uint8Array (using the Bitcoin alphabet '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz') */
+    static decodeStrFromBase58(base58Str) {
+        const inputBytes = this.decodeBytesFromBase58(base58Str);
+        return bytesToStringUTF8(inputBytes);
+    }
+}
+/**
+  * BaseN-encodes a Uint8Array using the given alphabet.
+  *
+  * @param {Uint8Array} input the bytes to encode in a Uint8Array.
+  * @param {number} maxline the maximum number of encoded characters per line to
+  *          use, defaults to none.
+  *
+  * @return {string} the baseN-encoded output string.
+  */
+export function encodeN(input, alphabet, maxline) {
+    if (!(input instanceof Uint8Array)) {
+        throw new TypeError('"input" must be a Uint8Array.');
+    }
+    if (typeof alphabet !== 'string') {
+        throw new TypeError('"alphabet" must be a string.');
+    }
+    if (maxline !== undefined && typeof maxline !== 'number') {
+        throw new TypeError('"maxline" must be a number.');
+    }
+    if (input.length === 0) {
+        return '';
+    }
+    let output = '';
+    let i = 0;
+    const base = alphabet.length;
+    const first = alphabet.charAt(0);
+    const digits = [0];
+    for (i = 0; i < input.length; ++i) {
+        let carry = input[i];
+        for (let j = 0; j < digits.length; ++j) {
+            carry += digits[j] << 8;
+            digits[j] = carry % base;
+            carry = (carry / base) | 0;
+        }
+        while (carry > 0) {
+            digits.push(carry % base);
+            carry = (carry / base) | 0;
+        }
+    }
+    // deal with leading zeros
+    for (i = 0; input[i] === 0 && i < input.length - 1; ++i) {
+        output += first;
+    }
+    // convert digits to a string
+    for (i = digits.length - 1; i >= 0; --i) {
+        output += alphabet[digits[i]];
+    }
+    if (maxline) {
+        const match = output.match(new RegExp('.{1,' + maxline + '}', 'g'));
+        if (match) {
+            output = match.join('\r\n');
+        }
+    }
+    return output;
+}
+/**
+  * Decodes a baseN-encoded (using the given alphabet) string to a
+  * Uint8Array.
+  *
+  * @param {string} input the baseN-encoded input string.
+  *
+  * @return {Uint8Array} the decoded bytes in a Uint8Array.
+  */
+export function decodeN(input, alphabet) {
+    if (typeof input !== 'string') {
+        throw new TypeError('"input" must be a string.');
+    }
+    if (typeof alphabet !== 'string') {
+        throw new TypeError('"alphabet" must be a string.');
+    }
+    if (input.length === 0) {
+        return new Uint8Array(0);
+    }
+    let table = _reverseAlphabets[alphabet];
+    if (!table) {
+        // compute reverse alphabet
+        table = _reverseAlphabets[alphabet] = [];
+        for (let i = 0; i < alphabet.length; ++i) {
+            table[alphabet.charCodeAt(i)] = i;
+        }
+    }
+    // remove whitespace characters
+    input = input.replace(/\s/g, '');
+    const base = alphabet.length;
+    const first = alphabet.charAt(0);
+    const bytes = [0];
+    for (let i = 0; i < input.length; i++) {
+        const value = table[input.charCodeAt(i)];
+        if (value === undefined) {
+            return new Uint8Array(0); // empty
+        }
+        let carry = value;
+        for (let j = 0; j < bytes.length; ++j) {
+            carry += bytes[j] * base;
+            bytes[j] = carry & 0xff;
+            carry >>= 8;
+        }
+        while (carry > 0) {
+            bytes.push(carry & 0xff);
+            carry >>= 8;
+        }
+    }
+    // deal with leading zeros
+    for (let k = 0; input[k] === first && k < input.length - 1; ++k) {
+        bytes.push(0);
+    }
+    return new Uint8Array(bytes.reverse());
+}

package/dist/utils/bundle.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Normalizes either FHIR Bundle (entry[]) or JSON:API bundle (data[])
+ * into an array of resources.
+ */
+export declare function extractResources(bundle: any): any[];
+export declare function getNextLink(bundle: any): string | null;

package/dist/utils/bundle.js

@@ -0,0 +1,32 @@
+// Copyright 2025 Antifraud Services Inc. under the Apache License, Version 2.0.
+/**
+ * Normalizes either FHIR Bundle (entry[]) or JSON:API bundle (data[])
+ * into an array of resources.
+ */
+export function extractResources(bundle) {
+    if (!bundle)
+        return [];
+    if (Array.isArray(bundle.entry)) {
+        return bundle.entry
+            .map((e) => e && (e.resource || e))
+            .filter(Boolean);
+    }
+    if (Array.isArray(bundle.data)) {
+        return bundle.data
+            .map((d) => d && (d.resource || d))
+            .filter(Boolean);
+    }
+    if (bundle.resourceType)
+        return [bundle];
+    return [];
+}
+export function getNextLink(bundle) {
+    if (Array.isArray(bundle?.link)) {
+        const next = bundle.link.find((l) => l.relation === 'next');
+        if (next?.url)
+            return next.url;
+    }
+    if (bundle?.links?.next)
+        return bundle.links.next;
+    return null;
+}

package/dist/utils/content.d.ts

@@ -0,0 +1,55 @@
+import * as baseConvert from './base-convert';
+import * as objectConvert from './object-convert';
+import * as stringConvert from './string-convert';
+import * as stringUtils from './string-utils';
+/**
+ * A unified facade class for all data conversion and utility functions.
+ * This class encapsulates functionality from the various utility modules
+ * (base-convert, object-convert, etc.) into a single, consistent interface.
+ */
+export declare class Content {
+    /** Encodes a string into a Uint8Array of strictly-validated UTF-8 bytes. */
+    static stringToBytesUTF8: typeof stringConvert.stringToBytesUTF8;
+    /** Decodes a Uint8Array of strictly-validated UTF-8 bytes back into a string. */
+    static bytesToStringUTF8: typeof stringConvert.bytesToStringUTF8;
+    /** Decodes a Uint8Array containing binary/ASCII data into a string. */
+    static bytesToStringASCII: typeof stringConvert.bytesToStringASCII;
+    /** Capitalizes the first letter of a string. */
+    static capitalize: typeof stringUtils.capitalize;
+    /** A simple string sanitizer. */
+    static sanitizeString: typeof stringUtils.sanitizeString;
+    /** Converts a string to a string of its ASCII character codes. */
+    static stringToASCII: typeof stringUtils.stringToASCII;
+    /** Converts a string to an array of numbers representing its byte values. */
+    static stringToBytesArrayOfNumbers: typeof stringUtils.stringToBytesArrayOfNumbers;
+    /** Converts a Uint8Array to a hexadecimal string. */
+    static bytesToHexString: typeof baseConvert.bytesToHexString;
+    /** Encodes a Uint8Array into a Base58 string. */
+    static bytesToBase58: typeof baseConvert.bytesToBase58;
+    /** Decodes a Base58 string into a Uint8Array. */
+    static base58ToBytes: typeof baseConvert.base58ToBytes;
+    /** Encodes a string into a standard Base64 string (with padding). */
+    static stringToStdBase64: typeof baseConvert.stringToStdBase64;
+    /** Converts a standard Base64 string to a Base64URL string. */
+    static base64ToBase64Url: typeof baseConvert.base64ToBase64Url;
+    /** Encodes a string into a Base64URL string. */
+    static stringToBase64Url: typeof baseConvert.stringToBase64Url;
+    /** Converts a Base64URL string to a standard Base64 string. */
+    static base64UrlToBase64: typeof baseConvert.base64UrlToBase64;
+    /** Decodes a string that is either Base64 or Base64URL into a Uint8Array. */
+    static base64ToBytes: typeof baseConvert.base64OrUrlSafeToBytes;
+    /** Encodes a Uint8Array into a standard Base64 string (with padding). */
+    static bytesToBase64: typeof baseConvert.bytesToBase64;
+    /** Encodes a Uint8Array into a raw Base64URL string (no padding). */
+    static bytesToRawBase64UrlSafe: typeof baseConvert.bytesToRawBase64UrlSafe;
+    /** Compares two arrays and returns true if they are the same, false otherwise. */
+    static arrayCompare: typeof objectConvert.arrayCompare;
+    /** Merges two Uint8Arrays into a single Uint8Array. */
+    static arrayMerge: typeof objectConvert.arrayMerge;
+    /** Serializes a JavaScript object to a Uint8Array of UTF-8 bytes. */
+    static objectToBytes: typeof objectConvert.objectToBytes;
+    /** Serializes a JavaScript object to a raw Base64URL string. */
+    static objectToRawBase64UrlSafe: typeof objectConvert.objectToRawBase64UrlSafe;
+    /** Deserializes a Base64URL string back into a JavaScript object. */
+    static base64UrlSafeToJSON: typeof objectConvert.base64UrlSafeToJSON;
+}

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

@@ -1,10 +1,8 @@
 // crypto-ts/utils/convert.ts
-
-import * as baseConvert from './base-convert';
-import * as objectConvert from './object-convert';
-import * as stringConvert from './string-convert';
-import * as stringUtils from './string-utils';
-
+import * as baseConvert from './base-convert.js';
+import * as objectConvert from './object-convert.js';
+import * as stringConvert from './string-convert.js';
+import * as stringUtils from './string-utils.js';
 /**
  * A unified facade class for all data conversion and utility functions.
  * This class encapsulates functionality from the various utility modules
@@ -18,7 +16,6 @@ export class Content {
     static bytesToStringUTF8 = stringConvert.bytesToStringUTF8;
     /** Decodes a Uint8Array containing binary/ASCII data into a string. */
     static bytesToStringASCII = stringConvert.bytesToStringASCII;
-
     // --- String Utilities (from string-utils.ts) ---
     /** Capitalizes the first letter of a string. */
     static capitalize = stringUtils.capitalize;
@@ -28,7 +25,6 @@ export class Content {
     static stringToASCII = stringUtils.stringToASCII;
     /** Converts a string to an array of numbers representing its byte values. */
     static stringToBytesArrayOfNumbers = stringUtils.stringToBytesArrayOfNumbers;
-
     // --- Base Conversions (from base-convert.ts) ---
     /** Converts a Uint8Array to a hexadecimal string. */
     static bytesToHexString = baseConvert.bytesToHexString;
@@ -50,7 +46,6 @@ export class Content {
     static bytesToBase64 = baseConvert.bytesToBase64;
     /** Encodes a Uint8Array into a raw Base64URL string (no padding). */
     static bytesToRawBase64UrlSafe = baseConvert.bytesToRawBase64UrlSafe;
-
     // --- Object & Array Conversions (from object-convert.ts) ---
     /** Compares two arrays and returns true if they are the same, false otherwise. */
     static arrayCompare = objectConvert.arrayCompare;
@@ -63,4 +58,3 @@ export class Content {
     /** Deserializes a Base64URL string back into a JavaScript object. */
     static base64UrlSafeToJSON = objectConvert.base64UrlSafeToJSON;
 }
-

package/dist/utils/did.d.ts

@@ -0,0 +1,67 @@
+import { ServiceEndpointSelector } from "../models/did";
+/**
+ * Generates a DID Service ID fragment from a selector object.
+ * The format is always `#<section>:<format>:<resourceType>:<action>`.
+ *
+ * This utility's only job is to correctly assemble the string. It contains no
+ * conditional logic about DID types, as that is handled by the data layer.
+ *
+ * @param selector The structured object containing the endpoint parts.
+ * @returns The formatted service ID fragment string.
+ */
+export declare function generateServiceId(selector: ServiceEndpointSelector): string;
+/**
+ * Normalizes a did:web string to a canonical format to prevent resolution errors
+ * due to case sensitivity in the path component of the underlying URL.
+ *
+ * The rule is:
+ * - All segments are lowercased, EXCEPT the final segment.
+ * - If the final segment represents a `system|code` pair (e.g., for a role),
+ *   the `system` part is lowercased, but the `code` is preserved as-is.
+ * - If the final segment is a unique identifier (like a Tax ID), it is preserved as-is.
+ *
+ * @param did The did:web string to normalize.
+ * @returns The canonicalized did:web string.
+ */
+export declare function normalizeDidWeb(did: string): string;
+/**
+* Creates the deterministic "hosted" did:web for a tenant (Organization).
+*
+* @param hostDidWeb The DID of the host (e.g., 'did:web:host.example.com').
+* @param tenantAlternateName The alternate name of the tenant (e.g., 'acme').
+* @param context An object containing jurisdiction, version, and sector.
+* @returns The tenant's full, correctly formatted hosted did:web.
+*          Example: 'did:web:host.example.com:acme:cds-es:v1:health-care'
+*/
+export declare function createHostedDidWeb(hostDidWeb: string, tenantAlternateName: string, context: {
+    jurisdiction: string;
+    version: string;
+    sector: string;
+}): string;
+/**
+ * Builds the canonical details (URL and did:web URN) for a hosted DID.
+ * This is the single source of truth for constructing hosted identifiers in the app.
+ *
+ * @param options An object with the components of the DID.
+ * @param options.host The provider's domain (e.g., 'provider.com').
+ * @param options.alternateName The tenant's identifier (e.g., 'acme').
+ * @param options.jurisdiction The legal jurisdiction (defaults to 'ES').
+ * @param options.sector The business sector (defaults to 'health-care').
+ * @returns An object with the full URL (with trailing /) and the canonical did:web.
+ */
+export declare function buildHostedDidDetails({ host, alternateName, jurisdiction, sector, }: {
+    host: string;
+    alternateName: string;
+    jurisdiction?: string;
+    sector?: string;
+}): {
+    did: string;
+    url: string;
+};
+/**
+* Converts a did:web identifier into a full HTTPS or HTTP base URL with a trailing slash.
+* It correctly decodes percent-encoded ports for local development.
+* @param did The did:web string (e.g., 'did:web:example.com' or 'did:web:localhost%3A3000:acme:cds-es:v1:health-care').
+* @returns The full base URL (e.g., 'https://example.com/acme/cds-es/v1/health-care/').
+*/
+export declare function getBaseUrlFromDidWeb(did: string): string;