gdc-sdk-front-ts 2.2.1 → 2.3.0

package/dist/gdc-common-utils-ts/src/utils/activation-request.js

@@ -1,99 +0,0 @@
-// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
-function pushIssue(issues, severity, code, message, path) {
-    issues.push({ severity, code, message, ...(path ? { path } : {}) });
-}
-function normalizeJwkSet(publicKeys) {
-    if (!publicKeys) {
-        return undefined;
-    }
-    if (Array.isArray(publicKeys)) {
-        return { keys: publicKeys };
-    }
-    return publicKeys;
-}
-/**
- * Builds the canonical controller/person binding from semantic variables.
- *
- * Use this when your integration starts from variables such as:
- * - `controllerDid`
- * - `controllerEmail` converted to `sameAs`
- * - `publicSignKey`
- * - `publicKeys`
- *
- * so the caller does not have to manually shape `controller.publicKeyJwk` and
- * `controller.jwks`.
- */
-export function buildControllerBindingInput(input) {
-    const jwks = normalizeJwkSet(input.publicKeys);
-    return {
-        ...(input.did ? { did: input.did } : {}),
-        ...(input.sameAs ? { sameAs: input.sameAs } : {}),
-        ...(input.publicSignKey ? { publicKeyJwk: input.publicSignKey } : {}),
-        ...(jwks ? { jwks } : {}),
-    };
-}
-/**
- * Builds the canonical organization/provider binding from semantic variables.
- */
-export function buildOrganizationBindingInput(input) {
-    const jwks = normalizeJwkSet(input.publicKeys);
-    return {
-        ...(input.did ? { did: input.did } : {}),
-        ...(input.url ? { url: input.url } : {}),
-        ...(input.publicSignKey ? { publicKeyJwk: input.publicSignKey } : {}),
-        ...(jwks ? { jwks } : {}),
-    };
-}
-/**
- * Builds the canonical `_activate` request payload shared by SDK and GW helpers.
- *
- * The resulting object intentionally preserves deprecated compatibility fields
- * when supplied, so callers can keep legacy flows alive while validators and
- * runtime layers flag that debt explicitly.
- */
-export function buildOrganizationActivationRequest(input) {
-    return {
-        vp_token: input.vpToken,
-        ...(input.presentationSubmission ? { presentation_submission: input.presentationSubmission } : {}),
-        ...(input.controller ? { controller: input.controller } : {}),
-        ...(input.organization ? { organization: input.organization } : {}),
-        ...(input.data ? { data: input.data } : {}),
-        ...(input.organizationCredential !== undefined ? { organizationCredential: input.organizationCredential } : {}),
-        ...(input.representativeCredential !== undefined ? { representativeCredential: input.representativeCredential } : {}),
-    };
-}
-/**
- * Validates the canonical activation request contract.
- *
- * Priority rules:
- * 1. `vp_token` is mandatory as the canonical activation proof.
- * 2. `controller.*` is optional, but if a controller DID/alias is provided then
- *    matching public key material must also be present so a DID Document can be published.
- * 3. Legacy `organizationCredential` and `representativeCredential` are tolerated
- *    only as deprecated compatibility inputs and therefore produce warnings.
- */
-export function validateOrganizationActivationRequest(request) {
-    const issues = [];
-    if (!String(request.vp_token || '').trim()) {
-        pushIssue(issues, 'error', 'missing-vp-token', 'Canonical activation proof must be carried in vp_token.', 'vp_token');
-    }
-    if (request.organizationCredential !== undefined) {
-        pushIssue(issues, 'warning', 'deprecated-organization-credential', 'organizationCredential is deprecated compatibility input. Canonical proof must be carried in vp_token.', 'organizationCredential');
-    }
-    if (request.representativeCredential !== undefined) {
-        pushIssue(issues, 'warning', 'deprecated-representative-credential', 'representativeCredential is deprecated compatibility input. Canonical proof must be carried in vp_token.', 'representativeCredential');
-    }
-    const controller = request.controller;
-    if (controller) {
-        const hasPublicKeyJwk = !!controller.publicKeyJwk;
-        const hasJwks = !!controller.jwks?.keys?.length;
-        if ((controller.did || controller.sameAs) && !(hasPublicKeyJwk || hasJwks)) {
-            pushIssue(issues, 'error', 'incomplete-controller-binding', 'controller.did/controller.sameAs requires controller.publicKeyJwk or controller.jwks for DID bootstrap.', 'controller');
-        }
-    }
-    return {
-        ok: !issues.some((issue) => issue.severity === 'error'),
-        errors: issues.filter((issue) => issue.severity === 'error'),
-        warnings: issues.filter((issue) => issue.severity === 'warning'),
-    };
-}

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

@@ -1,18 +0,0 @@
-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/gdc-common-utils-ts/src/utils/actor.js

@@ -1,36 +0,0 @@
-// 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/gdc-common-utils-ts/src/utils/base-convert.d.ts

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

package/dist/gdc-common-utils-ts/src/utils/base-convert.js

@@ -1,104 +0,0 @@
-// 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';
-/**
- * Converts a `Uint8Array` into a hexadecimal string.
- *
- * @param bytes Raw bytes to encode.
- */
-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.
- *
- * @param bytes Raw bytes to encode.
- */
-export function bytesToBase58(bytes) {
-    return encodeN(bytes, alphabetBase58, undefined);
-}
-/**
- * Decodes a Base58 string into a `Uint8Array`.
- *
- * @param base58str Base58 string to decode.
- */
-export function base58ToBytes(base58str) {
-    return decodeN(base58str, alphabetBase58);
-}
-/**
- * Encodes a string into a standard Base64 string with padding.
- *
- * @param str UTF-8 string to encode.
- */
-export function stringToStdBase64(str) {
-    const dataBytes = stringToBytesUTF8(str);
-    return encodeBase64(dataBytes);
-}
-/**
- * Converts a standard Base64 string into a Base64URL string.
- *
- * @param encodedData Standard Base64 string.
- */
-export function base64ToBase64Url(encodedData) {
-    if (encodedData && (encodedData.indexOf("+") !== -1 || encodedData.indexOf("/") !== -1)) {
-        return encodedData.split("+").join("-").split("/").join("_");
-    }
-    else {
-        return encodedData;
-    }
-}
-/**
- * Encodes a string into a Base64URL string.
- *
- * @param stringifiedData UTF-8 string to encode.
- */
-export function stringToBase64Url(stringifiedData) {
-    const encodedData = stringToStdBase64(stringifiedData);
-    return base64ToBase64Url(encodedData);
-}
-/**
- * Converts a Base64URL string into a standard Base64 string.
- *
- * @param encodedData Base64URL string.
- */
-export function base64UrlToBase64(encodedData) {
-    if (encodedData && (encodedData.indexOf("-") !== -1 || encodedData.indexOf("_") !== -1)) {
-        return encodedData.split("-").join("+").split("_").join("/");
-    }
-    else {
-        return encodedData;
-    }
-}
-/**
- * Decodes a string that is either Base64 or Base64URL into a `Uint8Array`.
- *
- * @param base64OrUrlSafe Base64 or Base64URL string.
- */
-export function base64OrUrlSafeToBytes(base64OrUrlSafe) {
-    if (String(base64OrUrlSafe).includes("+") || String(base64OrUrlSafe).includes("/")) {
-        return new Uint8Array(decodeBase64(base64OrUrlSafe));
-    }
-    else {
-        return new Uint8Array(decodeURLSafe(base64OrUrlSafe));
-    }
-}
-/**
- * Encodes a `Uint8Array` into a standard Base64 string with padding.
- *
- * @param bytes Raw bytes to encode.
- */
-export function bytesToBase64(bytes) {
-    return encodeBase64(bytes);
-}
-/**
- * Encodes a `Uint8Array` into a raw Base64URL string without padding.
- *
- * @param bytes Raw bytes to encode.
- */
-export function bytesToRawBase64UrlSafe(bytes) {
-    return encodeURLSafe(bytes).replace(/=/g, "");
-}

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

@@ -1,35 +0,0 @@
-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/gdc-common-utils-ts/src/utils/baseN.js

@@ -1,174 +0,0 @@
-/**
- * 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';
-// 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/gdc-common-utils-ts/src/utils/bundle-query.d.ts

@@ -1,35 +0,0 @@
-import type { BundleEntry, BundleJsonApi } from '../models/bundle.js';
-export type BundleResourceIdFilters = Readonly<{
-    sections?: string | readonly string[];
-    resourceTypes?: string | readonly string[];
-    dateFrom?: string;
-    dateTo?: string;
-}>;
-/**
- * Generic bundle query helper for reusable entry filtering and lookup.
- *
- * This utility is intentionally communication-agnostic and can be reused by
- * any package that works with BundleJsonApi payloads.
- */
-export declare class BundleQuery {
-    private readonly bundle;
-    constructor(bundle: BundleJsonApi<BundleEntry>);
-    /**
-     * Returns stable resource IDs from bundle entries with optional filters.
-     */
-    getResourceIds(filters?: BundleResourceIdFilters): string[];
-    /**
-     * Returns bundle entries matching resource IDs produced by `getResourceIds`.
-     */
-    getResourceEntriesByIds(resourceIds: readonly string[]): BundleEntry[];
-    /**
-     * Resolves the entry URL (`fullUrl`) for a given entry/resource identifier.
-     */
-    getEntryUrl(entryId: string): string | undefined;
-    private resolveBundleEntryId;
-    private resolveIdentifierFromClaims;
-    private matchesResourceFilters;
-    private matchesSections;
-    private resolveEntryDate;
-    private matchesDateRange;
-}