gdc-sdk-front-ts 0.6.2 → 0.6.6

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

@@ -0,0 +1,66 @@
+// 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) {
+    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) {
+    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) {
+    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) {
+    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) {
+            out[p++] = (c >> 6) | 192;
+            out[p++] = (c & 63) | 128;
+        }
+        else if ((c & 0xfc00) == 0xd800 &&
+            i + 1 < str.length &&
+            (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 {
+            out[p++] = (c >> 12) | 224;
+            out[p++] = ((c >> 6) & 63) | 128;
+            out[p++] = (c & 63) | 128;
+        }
+    }
+    return out;
+}

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

@@ -0,0 +1,26 @@
+/**
+ * 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 urlString The full URL string to be split.
+ * @returns An object containing the `domain` and `path` of the URL, or `null` when invalid.
+ *
+ * @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/dist/gdc-common-utils-ts/src/utils/url.js

@@ -0,0 +1,44 @@
+// 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, path) {
+    // Remove trailing slash from base_url if it exists
+    if (base_url.endsWith('/')) {
+        base_url = base_url.substring(0, base_url.length - 1);
+    }
+    // Remove leading slash from path if it exists
+    if (path.startsWith('/')) {
+        path = path.substring(1);
+    }
+    return `${base_url}/${path}`;
+}
+/**
+ * Splits a given URL into its domain and path components.
+ *
+ * @param urlString The full URL string to be split.
+ * @returns An object containing the `domain` and `path` of the URL, or `null` when invalid.
+ *
+ * @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 function splitUrl(urlString) {
+    try {
+        const url = new URL(urlString);
+        return { domain: url.hostname, path: url.pathname };
+    }
+    catch (error) {
+        console.error("Invalid URL provided:", error.message);
+    }
+    return null;
+}

package/dist/gdc-common-utils-ts/src/utils/vp-token.d.ts

@@ -0,0 +1,139 @@
+import { JoseSignatureAlgorithm } from '../constants/cryptography';
+/**
+ * Protected JOSE header used when assembling a compact VP JWT.
+ *
+ * The `alg` field is intentionally typed as a shared JOSE signature algorithm
+ * instead of a free-form string so docs/tests can show the supported values
+ * explicitly, including `ES256K` for secp256k1-based signers.
+ */
+export type VpTokenHeader = {
+    alg: JoseSignatureAlgorithm;
+    typ?: string;
+    kid?: string;
+    [key: string]: unknown;
+};
+export type VpTokenPayload = {
+    iss: string;
+    sub?: string;
+    aud?: string;
+    jti?: string;
+    iat?: number;
+    exp?: number;
+    nonce?: string;
+    vp: {
+        '@context'?: unknown;
+        type?: unknown;
+        holder?: string;
+        verifiableCredential: Array<string | Record<string, unknown>>;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+};
+export type VpCredential = Record<string, unknown>;
+export type VpCredentialInput = string | Record<string, unknown>;
+export declare function generateUuidLike(): string;
+export declare function buildEpochWindow(ttlSeconds?: number): {
+    iat: number;
+    exp: number;
+};
+export declare function createVP(input?: Partial<VpTokenPayload>): VpTokenPayload;
+/**
+ * Appends one VC entry to the VP payload.
+ *
+ * Accepted input forms:
+ *
+ * - compact VC JWT/JWS string
+ * - raw JSON VC string
+ * - direct VC JSON object
+ *
+ * Storage rule:
+ *
+ * - string inputs are stored as strings
+ * - object inputs are stored as objects
+ *
+ * This keeps the builder compatible with existing compact-token flows while
+ * also supporting app/runtime code that already holds the VC as parsed JSON.
+ */
+export declare function addVC(vpPayload: VpTokenPayload, vcInput: VpCredentialInput): VpTokenPayload;
+/**
+ * Appends many VC entries to the VP payload.
+ *
+ * Each entry may be:
+ *
+ * - compact VC JWT/JWS string
+ * - raw JSON VC string
+ * - direct VC JSON object
+ */
+export declare function addVCs(vpPayload: VpTokenPayload, vcs: VpCredentialInput[]): VpTokenPayload;
+/**
+ * Decodes a compact VP token payload into a JSON object.
+ *
+ * Supports either a raw JSON string payload or a compact JWT/JWS token.
+ *
+ * @param vpToken Compact VP token or raw JSON string.
+ */
+export declare function decodeVpTokenPayload(vpToken: string): VpTokenPayload | undefined;
+/**
+ * Extracts decoded VC objects from a VP token.
+ *
+ * VCs may be embedded as compact JWT/JWS strings, raw JSON strings, or direct
+ * objects inside `vp.verifiableCredential`.
+ *
+ * @param vpToken Compact VP token or raw JSON string.
+ */
+export declare function getVpCredentials(vpToken: string): VpCredential[];
+/**
+ * Returns the first decoded VC in a VP token whose `type` includes any of the
+ * accepted credential types.
+ *
+ * @param vpToken Compact VP token or raw JSON string.
+ * @param acceptedTypes Accepted VC types such as `OrganizationCredential`.
+ */
+export declare function getVpCredentialByAnyType(vpToken: string, acceptedTypes: string[]): VpCredential | undefined;
+/**
+ * Extracts the organization credential from a VP token when present.
+ *
+ * @param vpToken Compact VP token or raw JSON string.
+ */
+export declare function getOrganizationCredentialFromVpToken(vpToken: string): VpCredential | undefined;
+/**
+ * Extracts the legal representative credential from a VP token when present.
+ *
+ * @param vpToken Compact VP token or raw JSON string.
+ */
+export declare function getLegalRepresentativeCredentialFromVpToken(vpToken: string): VpCredential | undefined;
+/**
+ * Appends an organization activation credential after validating its VC type.
+ *
+ * Accepts compact VC strings, raw JSON VC strings, or VC JSON objects.
+ */
+export declare function addOrganizationCredential(vpPayload: VpTokenPayload, vc: VpCredentialInput): VpTokenPayload;
+/**
+ * Appends a legal-representative activation credential after validating its VC
+ * type.
+ *
+ * Accepts compact VC strings, raw JSON VC strings, or VC JSON objects.
+ */
+export declare function addLegalRepresentativeCredential(vpPayload: VpTokenPayload, vc: VpCredentialInput): VpTokenPayload;
+export declare function prepareForSignature(header: VpTokenHeader, payload: VpTokenPayload): {
+    encodedHeader: string;
+    encodedPayload: string;
+    signingInput: string;
+};
+/**
+ * Returns the UTF-8 bytes of the canonical `base64url(header).base64url(payload)`
+ * signing input.
+ *
+ * This is the exact byte sequence an external wallet, HSM, or KMS must sign
+ * before the caller assembles the final compact VP JWT with
+ * `buildVpTokenCompact(...)`.
+ */
+export declare function prepareBytesForSignature(header: VpTokenHeader, payload: VpTokenPayload): Uint8Array;
+/**
+ * Assembles the final compact VP JWT once the caller already has:
+ *
+ * - the base64url-encoded protected header
+ * - the base64url-encoded VP payload
+ * - the detached signature returned by the external signer, also base64url-encoded
+ */
+export declare function buildVpTokenCompact(encodedHeader: string, encodedPayload: string, signatureBase64Url: string): string;

package/dist/gdc-common-utils-ts/src/utils/vp-token.js

@@ -0,0 +1,256 @@
+// Always create JSDoc, do not use strings inline in keys nor values, use types instead, and reuse the data test examples.
+import { Content } from './content';
+import { ORGANIZATION_ACTIVATION_VC_TYPES, REPRESENTATIVE_ACTIVATION_VC_TYPES, W3cCredentialContexts, W3cCredentialTypes, } from '../constants/verifiable-credentials';
+function fallbackId() {
+    const rand = Math.random().toString(36).slice(2, 10);
+    return `id-${Date.now()}-${rand}`;
+}
+export function generateUuidLike() {
+    const fn = globalThis?.crypto?.randomUUID;
+    if (typeof fn === 'function')
+        return fn.call(globalThis.crypto);
+    return fallbackId();
+}
+export function buildEpochWindow(ttlSeconds = 300) {
+    const iat = Math.floor(Date.now() / 1000);
+    return { iat, exp: iat + Math.max(1, Math.floor(ttlSeconds)) };
+}
+export function createVP(input) {
+    const ttl = input?.exp && input?.iat ? undefined : buildEpochWindow(300);
+    const jti = input?.jti || generateUuidLike();
+    const nonce = input?.nonce || generateUuidLike();
+    const base = {
+        iss: String(input?.iss || ''),
+        sub: input?.sub,
+        aud: input?.aud,
+        jti,
+        iat: input?.iat ?? ttl?.iat,
+        exp: input?.exp ?? ttl?.exp,
+        nonce,
+        vp: {
+            '@context': [W3cCredentialContexts.V1],
+            type: [W3cCredentialTypes.VerifiablePresentation],
+            holder: input?.vp?.holder || input?.iss || '',
+            verifiableCredential: [],
+            ...(input?.vp || {}),
+        },
+    };
+    return base;
+}
+/**
+ * Appends one VC entry to the VP payload.
+ *
+ * Accepted input forms:
+ *
+ * - compact VC JWT/JWS string
+ * - raw JSON VC string
+ * - direct VC JSON object
+ *
+ * Storage rule:
+ *
+ * - string inputs are stored as strings
+ * - object inputs are stored as objects
+ *
+ * This keeps the builder compatible with existing compact-token flows while
+ * also supporting app/runtime code that already holds the VC as parsed JSON.
+ */
+export function addVC(vpPayload, vcInput) {
+    if (vcInput && typeof vcInput === 'object') {
+        vpPayload.vp.verifiableCredential.push({ ...vcInput });
+        return vpPayload;
+    }
+    const v = String(vcInput || '').trim();
+    if (!v)
+        return vpPayload;
+    vpPayload.vp.verifiableCredential.push(v);
+    return vpPayload;
+}
+/**
+ * Appends many VC entries to the VP payload.
+ *
+ * Each entry may be:
+ *
+ * - compact VC JWT/JWS string
+ * - raw JSON VC string
+ * - direct VC JSON object
+ */
+export function addVCs(vpPayload, vcs) {
+    for (const vc of vcs || [])
+        addVC(vpPayload, vc);
+    return vpPayload;
+}
+function decodeVcPayload(vc) {
+    if (vc && typeof vc === 'object') {
+        return vc;
+    }
+    const raw = String(vc || '').trim();
+    if (!raw)
+        return undefined;
+    if (raw.startsWith('{')) {
+        try {
+            const parsed = JSON.parse(raw);
+            return parsed && typeof parsed === 'object' ? parsed : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const parts = raw.split('.');
+    if (parts.length !== 3 || !parts[1])
+        return undefined;
+    try {
+        const payloadJson = Buffer.from(parts[1], 'base64url').toString('utf8');
+        const parsed = JSON.parse(payloadJson);
+        return parsed && typeof parsed === 'object' ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Decodes a compact VP token payload into a JSON object.
+ *
+ * Supports either a raw JSON string payload or a compact JWT/JWS token.
+ *
+ * @param vpToken Compact VP token or raw JSON string.
+ */
+export function decodeVpTokenPayload(vpToken) {
+    const raw = String(vpToken || '').trim();
+    if (!raw)
+        return undefined;
+    if (raw.startsWith('{')) {
+        try {
+            const parsed = JSON.parse(raw);
+            return parsed && typeof parsed === 'object' ? parsed : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const parts = raw.split('.');
+    if (parts.length !== 3 || !parts[1])
+        return undefined;
+    try {
+        const payloadJson = Buffer.from(parts[1], 'base64url').toString('utf8');
+        const parsed = JSON.parse(payloadJson);
+        return parsed && typeof parsed === 'object' ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Extracts decoded VC objects from a VP token.
+ *
+ * VCs may be embedded as compact JWT/JWS strings, raw JSON strings, or direct
+ * objects inside `vp.verifiableCredential`.
+ *
+ * @param vpToken Compact VP token or raw JSON string.
+ */
+export function getVpCredentials(vpToken) {
+    const payload = decodeVpTokenPayload(vpToken);
+    const vcs = payload?.vp?.verifiableCredential;
+    if (!Array.isArray(vcs))
+        return [];
+    return vcs
+        .map((candidate) => {
+        if (candidate && typeof candidate === 'object') {
+            return candidate;
+        }
+        if (typeof candidate === 'string') {
+            return decodeVcPayload(candidate);
+        }
+        return undefined;
+    })
+        .filter((candidate) => Boolean(candidate && typeof candidate === 'object'));
+}
+/**
+ * Returns the first decoded VC in a VP token whose `type` includes any of the
+ * accepted credential types.
+ *
+ * @param vpToken Compact VP token or raw JSON string.
+ * @param acceptedTypes Accepted VC types such as `OrganizationCredential`.
+ */
+export function getVpCredentialByAnyType(vpToken, acceptedTypes) {
+    return getVpCredentials(vpToken).find((credential) => vcHasAnyType(credential, acceptedTypes));
+}
+/**
+ * Extracts the organization credential from a VP token when present.
+ *
+ * @param vpToken Compact VP token or raw JSON string.
+ */
+export function getOrganizationCredentialFromVpToken(vpToken) {
+    return getVpCredentialByAnyType(vpToken, [...ORGANIZATION_ACTIVATION_VC_TYPES]);
+}
+/**
+ * Extracts the legal representative credential from a VP token when present.
+ *
+ * @param vpToken Compact VP token or raw JSON string.
+ */
+export function getLegalRepresentativeCredentialFromVpToken(vpToken) {
+    return getVpCredentialByAnyType(vpToken, [...REPRESENTATIVE_ACTIVATION_VC_TYPES]);
+}
+function vcHasAnyType(vcPayload, acceptedTypes) {
+    if (!vcPayload)
+        return false;
+    const typeRaw = vcPayload?.type
+        ?? vcPayload?.vc?.type
+        ?? vcPayload?.credential?.type;
+    const types = Array.isArray(typeRaw) ? typeRaw.map(String) : [String(typeRaw || '')];
+    return acceptedTypes.some((t) => types.includes(t));
+}
+function addTypedVC(vpPayload, vc, acceptedTypes, label) {
+    const payload = decodeVcPayload(vc);
+    if (!vcHasAnyType(payload, acceptedTypes)) {
+        throw new Error(`${label} VC must include one of types: ${acceptedTypes.join(', ')}`);
+    }
+    return addVC(vpPayload, vc);
+}
+/**
+ * Appends an organization activation credential after validating its VC type.
+ *
+ * Accepts compact VC strings, raw JSON VC strings, or VC JSON objects.
+ */
+export function addOrganizationCredential(vpPayload, vc) {
+    return addTypedVC(vpPayload, vc, [...ORGANIZATION_ACTIVATION_VC_TYPES], 'Organization');
+}
+/**
+ * Appends a legal-representative activation credential after validating its VC
+ * type.
+ *
+ * Accepts compact VC strings, raw JSON VC strings, or VC JSON objects.
+ */
+export function addLegalRepresentativeCredential(vpPayload, vc) {
+    return addTypedVC(vpPayload, vc, [...REPRESENTATIVE_ACTIVATION_VC_TYPES], 'LegalRepresentative');
+}
+export function prepareForSignature(header, payload) {
+    const encodedHeader = Content.objectToRawBase64UrlSafe(header);
+    const encodedPayload = Content.objectToRawBase64UrlSafe(payload);
+    return {
+        encodedHeader,
+        encodedPayload,
+        signingInput: `${encodedHeader}.${encodedPayload}`,
+    };
+}
+/**
+ * Returns the UTF-8 bytes of the canonical `base64url(header).base64url(payload)`
+ * signing input.
+ *
+ * This is the exact byte sequence an external wallet, HSM, or KMS must sign
+ * before the caller assembles the final compact VP JWT with
+ * `buildVpTokenCompact(...)`.
+ */
+export function prepareBytesForSignature(header, payload) {
+    const { signingInput } = prepareForSignature(header, payload);
+    return new TextEncoder().encode(signingInput);
+}
+/**
+ * Assembles the final compact VP JWT once the caller already has:
+ *
+ * - the base64url-encoded protected header
+ * - the base64url-encoded VP payload
+ * - the detached signature returned by the external signer, also base64url-encoded
+ */
+export function buildVpTokenCompact(encodedHeader, encodedPayload, signatureBase64Url) {
+    return `${encodedHeader}.${encodedPayload}.${String(signatureBase64Url || '').trim()}`;
+}

package/dist/gdc-sdk-core-ts/src/actor-model.d.ts

@@ -0,0 +1,56 @@
+import { ActorCapabilities, ActorKinds } from 'gdc-common-utils-ts/constants/actor-session';
+import type { ActorKind, Capability } from 'gdc-common-utils-ts/models/actor-session';
+export { ActorCapabilities, ActorKinds };
+export type { ActorKind, Capability };
+export type ActorSessionDescriptor = {
+    actorKinds: ActorKind[];
+    capabilities: Capability[];
+    appType: 'Organization' | 'Family';
+    profileId: string;
+    profileDid?: string;
+    role?: string;
+};
+export type ActorFacadeDescriptor = {
+    actorKind: ActorKind;
+    capabilities: Capability[];
+    appType: 'Organization' | 'Family';
+    profileId: string;
+    profileDid?: string;
+    role?: string;
+};
+export type ActorFlags = {
+    organizationController?: boolean;
+    organizationEmployee?: boolean;
+    individualController?: boolean;
+    individualMember?: boolean;
+    professionalPhysician?: boolean;
+    professionalParamedic?: boolean;
+};
+export type ActorSessionDescriptorInput = {
+    appType: 'Organization' | 'Family';
+    profileId: string;
+    profileDid?: string;
+    role?: string;
+    actorFlags: ActorFlags;
+};
+/**
+ * Filters a capability list so that only capabilities valid for the given actor remain.
+ *
+ * @param actorKind Actor role to evaluate against the capability matrix.
+ * @param capabilities Candidate capabilities to filter.
+ */
+export declare function filterCapabilitiesForActor(actorKind: ActorKind, capabilities: Capability[]): Capability[];
+/**
+ * Expands a composite actor session descriptor into one facade descriptor per actor kind.
+ *
+ * Each resulting facade keeps only the capabilities that belong to its actor kind.
+ *
+ * @param descriptor Composite descriptor that may contain multiple actor kinds.
+ */
+export declare function expandActorSessionDescriptorToFacades(descriptor: ActorSessionDescriptor): ActorFacadeDescriptor[];
+/**
+ * Builds a normalized actor session descriptor from boolean actor flags.
+ *
+ * @param input Session metadata plus actor flags used to derive actor kinds and capabilities.
+ */
+export declare function buildActorSessionDescriptorFromActorFlags(input: ActorSessionDescriptorInput): ActorSessionDescriptor;