gdc-sdk-front-ts 0.6.2 → 0.6.6

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

@@ -0,0 +1,60 @@
+// 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';
+/**
+ * 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 class Content {
+}
+// --- String Conversions (from string-convert.ts) ---
+/** Encodes a string into a Uint8Array of strictly-validated UTF-8 bytes. */
+Content.stringToBytesUTF8 = stringConvert.stringToBytesUTF8;
+/** Decodes a Uint8Array of strictly-validated UTF-8 bytes back into a string. */
+Content.bytesToStringUTF8 = stringConvert.bytesToStringUTF8;
+/** Decodes a Uint8Array containing binary/ASCII data into a string. */
+Content.bytesToStringASCII = stringConvert.bytesToStringASCII;
+// --- String Utilities (from string-utils.ts) ---
+/** Capitalizes the first letter of a string. */
+Content.capitalize = stringUtils.capitalize;
+/** A simple string sanitizer. */
+Content.sanitizeString = stringUtils.sanitizeString;
+/** Converts a string to a string of its ASCII character codes. */
+Content.stringToASCII = stringUtils.stringToASCII;
+/** Converts a string to an array of numbers representing its byte values. */
+Content.stringToBytesArrayOfNumbers = stringUtils.stringToBytesArrayOfNumbers;
+// --- Base Conversions (from base-convert.ts) ---
+/** Converts a Uint8Array to a hexadecimal string. */
+Content.bytesToHexString = baseConvert.bytesToHexString;
+/** Encodes a Uint8Array into a Base58 string. */
+Content.bytesToBase58 = baseConvert.bytesToBase58;
+/** Decodes a Base58 string into a Uint8Array. */
+Content.base58ToBytes = baseConvert.base58ToBytes;
+/** Encodes a string into a standard Base64 string (with padding). */
+Content.stringToStdBase64 = baseConvert.stringToStdBase64;
+/** Converts a standard Base64 string to a Base64URL string. */
+Content.base64ToBase64Url = baseConvert.base64ToBase64Url;
+/** Encodes a string into a Base64URL string. */
+Content.stringToBase64Url = baseConvert.stringToBase64Url;
+/** Converts a Base64URL string to a standard Base64 string. */
+Content.base64UrlToBase64 = baseConvert.base64UrlToBase64;
+/** Decodes a string that is either Base64 or Base64URL into a Uint8Array. */
+Content.base64ToBytes = baseConvert.base64OrUrlSafeToBytes;
+/** Encodes a Uint8Array into a standard Base64 string (with padding). */
+Content.bytesToBase64 = baseConvert.bytesToBase64;
+/** Encodes a Uint8Array into a raw Base64URL string (no padding). */
+Content.bytesToRawBase64UrlSafe = baseConvert.bytesToRawBase64UrlSafe;
+// --- Object & Array Conversions (from object-convert.ts) ---
+/** Compares two arrays and returns true if they are the same, false otherwise. */
+Content.arrayCompare = objectConvert.arrayCompare;
+/** Merges two Uint8Arrays into a single Uint8Array. */
+Content.arrayMerge = objectConvert.arrayMerge;
+/** Serializes a JavaScript object to a Uint8Array of UTF-8 bytes. */
+Content.objectToBytes = objectConvert.objectToBytes;
+/** Serializes a JavaScript object to a raw Base64URL string. */
+Content.objectToRawBase64UrlSafe = objectConvert.objectToRawBase64UrlSafe;
+/** Deserializes a Base64URL string back into a JavaScript object. */
+Content.base64UrlSafeToJSON = objectConvert.base64UrlSafeToJSON;

package/dist/gdc-common-utils-ts/src/utils/dataspace-discovery-defaults.d.ts

@@ -0,0 +1,130 @@
+import type { DataspaceDiscoveryBootstrapInput, DataspaceDiscoveryBootstrapPlan, DataspaceDiscoveryDefaultHostingFilter, DataspaceDiscoveryDefaultIcaFilter, DataspaceDiscoveryDefaultsRegistrySeed, DefaultHostingOperatorRegistration, DefaultIcaRegistration } from '../models/dataspace-discovery-defaults';
+import type { PublishedProviderCatalogRecord } from '../models/dataspace-discovery';
+export type BuildDefaultIcaRegistrationFromAuthorityInput = Readonly<{
+    authority: string;
+    jurisdiction: string;
+    version: string;
+    networkType: string;
+    title?: string;
+}>;
+export type BuildDefaultHostingOperatorRegistrationFromAuthorityInput = Readonly<{
+    authority: string;
+    jurisdiction: string;
+    version: string;
+    networkType: string;
+    sector: string;
+    serviceTypes: readonly string[];
+    title?: string;
+    areaServed?: readonly string[];
+    addressCountry?: string;
+    coverageScope?: string;
+}>;
+export type BuildDefaultPublishedProviderRecordFromTenantInput = Readonly<{
+    hostAuthority: string;
+    tenantId: string;
+    jurisdiction: string;
+    version: string;
+    sector: string;
+    providerCapability: string;
+    areaServed?: readonly string[];
+    /**
+     * Optional public domain for a future externally visible provider surface.
+     *
+     * For now most deployments will not use it, so the helper falls back to the
+     * hosted/internal tenant route under the hosting operator domain.
+     */
+    externalDomain?: string;
+}>;
+/**
+ * Builds one ICA default seed from a domain/IP authority.
+ *
+ * This helper exists so integrators do not have to handcraft:
+ * - the `did:web`
+ * - the well-known ICA URL
+ * - the repeated host/network context fields
+ */
+export declare function buildDefaultIcaRegistrationFromAuthority(input: BuildDefaultIcaRegistrationFromAuthorityInput): DefaultIcaRegistration;
+/**
+ * Builds one hosting-operator default seed from a domain/IP authority.
+ *
+ * This helper exists so integrators do not have to handcraft:
+ * - the `did:web`
+ * - the host-scoped DSP discovery URL
+ * - the semantic host record shape
+ */
+export declare function buildDefaultHostingOperatorRegistrationFromAuthority(input: BuildDefaultHostingOperatorRegistrationFromAuthorityInput): DefaultHostingOperatorRegistration;
+/**
+ * Builds one published-provider default entry from a tenant id under a given
+ * hosting operator authority.
+ *
+ * Integrator-friendly rule:
+ * - the backend usually knows `tenantId`
+ * - it usually does not want to handcraft the hosted/internal `did:web`
+ * - this helper derives the hosted provider DID and tenant-scoped DSP URLs
+ */
+export declare function buildDefaultPublishedProviderRecordFromTenant(input: BuildDefaultPublishedProviderRecordFromTenantInput): PublishedProviderCatalogRecord;
+/**
+ * Mutable in-memory registry for discovery defaults used by portal/backend
+ * bootstrap code.
+ *
+ * Scope:
+ * - ICA defaults are indexed by `jurisdiction + version + networkType`
+ * - hosting defaults are indexed by `jurisdiction + version + networkType`
+ * - sector filtering is applied only when listing hosting operators, because
+ *   sectors belong to tenant/provider discovery rather than to the host network
+ *
+ * This registry is intentionally simple and synchronous so backend code can
+ * preload defaults during startup and immediately serve the frontend in
+ * `defaults-only` or `default-first` mode.
+ */
+export declare class DataspaceDiscoveryDefaultsRegistry {
+    private readonly icas;
+    private readonly hostingOperators;
+    constructor(seed?: DataspaceDiscoveryDefaultsRegistrySeed);
+    /**
+     * Adds one ICA default for a concrete host/network context.
+     *
+     * @example
+     * ```ts
+     * registry.addIca({
+     *   jurisdiction: 'ES',
+     *   version: 'v1',
+     *   networkType: 'test',
+     *   icaUrl: 'https://ica.example.org',
+     * });
+     * ```
+     */
+    addIca(input: DefaultIcaRegistration): this;
+    /**
+     * Adds one hosting-operator default for a concrete host/network context.
+     *
+     * The record itself may later serve multiple sectors depending on the
+     * semantic categories and capabilities published in `record`.
+     */
+    addHostingOperator(input: DefaultHostingOperatorRegistration): this;
+    /**
+     * Lists configured ICA defaults for a host/network context.
+     */
+    listIcas(filter?: DataspaceDiscoveryDefaultIcaFilter): DefaultIcaRegistration[];
+    /**
+     * Lists configured hosting-operator defaults for a frontend/backend discovery
+     * request.
+     *
+     * Sector and capability filtering are applied against the semantic host
+     * record because those dimensions belong to the provider/tenant side.
+     */
+    listHostingOperators(filter?: DataspaceDiscoveryDefaultHostingFilter): DefaultHostingOperatorRegistration[];
+    /**
+     * Builds the backend bootstrap plan for one provider-discovery request.
+     *
+     * Current default-first policy:
+     * - use configured hosting defaults immediately when they exist
+     * - only try live ICA/internet when no host defaults match the request and at
+     *   least one ICA default is configured for the same host/network context
+     */
+    buildBootstrapPlan(input: DataspaceDiscoveryBootstrapInput): DataspaceDiscoveryBootstrapPlan;
+}
+/**
+ * Convenience factory for the in-memory defaults registry.
+ */
+export declare function createDataspaceDiscoveryDefaultsRegistry(seed?: DataspaceDiscoveryDefaultsRegistrySeed): DataspaceDiscoveryDefaultsRegistry;

package/dist/gdc-common-utils-ts/src/utils/dataspace-discovery-defaults.js

@@ -0,0 +1,307 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { DataspaceDiscoverySourceMode, } from '../constants/dataspace-discovery';
+import { normalizeCountryCode } from '../constants/eu-countries';
+import { buildOrganizationDidWeb, getBaseUrlFromDidWeb } from './did';
+import { matchesHostingOperatorDiscoveryFilter } from './dataspace-discovery';
+function normalizeString(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function normalizeAuthority(value) {
+    const raw = normalizeString(value).replace(/\/+$/, '');
+    if (!raw)
+        return '';
+    if (/^https?:\/\//i.test(raw)) {
+        try {
+            return new URL(raw).host;
+        }
+        catch {
+            return raw.replace(/^https?:\/\//i, '');
+        }
+    }
+    return raw;
+}
+function getProtocolForAuthority(authority) {
+    const normalized = authority.trim().toLowerCase();
+    return normalized.startsWith('localhost')
+        || normalized.startsWith('127.0.0.1')
+        || normalized.startsWith('[::1]')
+        ? 'http'
+        : 'https';
+}
+function encodeDidWebAuthority(authority) {
+    return authority.replace(/:/g, '%3A').toLowerCase();
+}
+function buildDidWebFromAuthority(authority) {
+    return `did:web:${encodeDidWebAuthority(authority)}`;
+}
+function normalizeCapabilities(values) {
+    return Array.from(new Set((values || []).map((value) => normalizeString(value)).filter(Boolean)));
+}
+function normalizePublishedProvider(input) {
+    return {
+        providerDid: normalizeString(input.providerDid),
+        serviceType: normalizeString(input.serviceType),
+        category: normalizeString(input.category),
+        areaServed: normalizeCapabilities(Array.isArray(input.areaServed)
+            ? input.areaServed
+            : normalizeString(input.areaServed)
+                ? normalizeString(input.areaServed).split(',')
+                : undefined).join(',') || undefined,
+        endpointUrl: normalizeString(input.endpointUrl) || undefined,
+        discoveryUrl: normalizeString(input.discoveryUrl) || undefined,
+        catalogUrl: normalizeString(input.catalogUrl) || undefined,
+    };
+}
+function normalizeIcaRegistration(input) {
+    return {
+        jurisdiction: normalizeString(input.jurisdiction),
+        version: normalizeString(input.version),
+        networkType: normalizeString(input.networkType),
+        icaUrl: normalizeString(input.icaUrl),
+        icaDid: normalizeString(input.icaDid) || undefined,
+        title: normalizeString(input.title) || undefined,
+    };
+}
+function normalizeHostingOperatorRegistration(input) {
+    return {
+        jurisdiction: normalizeString(input.jurisdiction),
+        version: normalizeString(input.version),
+        networkType: normalizeString(input.networkType),
+        operatorDid: normalizeString(input.operatorDid),
+        discoveryUrl: normalizeString(input.discoveryUrl) || undefined,
+        catalogUrl: normalizeString(input.catalogUrl) || undefined,
+        record: {
+            ...input.record,
+            subjectId: normalizeString(input.record.subjectId) || undefined,
+            serviceTypes: normalizeCapabilities(input.record.serviceTypes),
+            categories: Array.from(new Set((input.record.categories || []).map((value) => normalizeString(value)).filter(Boolean))),
+            areaServed: Array.from(new Set((input.record.areaServed || []).map((value) => normalizeString(value)).filter(Boolean))),
+            addressCountry: normalizeString(input.record.addressCountry) || undefined,
+            coverageScope: normalizeString(input.record.coverageScope) || undefined,
+        },
+        publishedProviders: (input.publishedProviders || []).map((provider) => normalizePublishedProvider(provider)),
+        title: normalizeString(input.title) || undefined,
+    };
+}
+function matchesNetworkContext(left, right) {
+    if (right.jurisdiction && normalizeString(right.jurisdiction) !== left.jurisdiction)
+        return false;
+    if (right.version && normalizeString(right.version) !== left.version)
+        return false;
+    if (right.networkType && normalizeString(right.networkType) !== left.networkType)
+        return false;
+    return true;
+}
+/**
+ * Builds one ICA default seed from a domain/IP authority.
+ *
+ * This helper exists so integrators do not have to handcraft:
+ * - the `did:web`
+ * - the well-known ICA URL
+ * - the repeated host/network context fields
+ */
+export function buildDefaultIcaRegistrationFromAuthority(input) {
+    const authority = normalizeAuthority(input.authority);
+    const protocol = getProtocolForAuthority(authority);
+    return normalizeIcaRegistration({
+        jurisdiction: input.jurisdiction,
+        version: input.version,
+        networkType: input.networkType,
+        title: input.title,
+        icaUrl: `${protocol}://${authority}/.well-known/ica-configuration`,
+        icaDid: buildDidWebFromAuthority(authority),
+    });
+}
+/**
+ * Builds one hosting-operator default seed from a domain/IP authority.
+ *
+ * This helper exists so integrators do not have to handcraft:
+ * - the `did:web`
+ * - the host-scoped DSP discovery URL
+ * - the semantic host record shape
+ */
+export function buildDefaultHostingOperatorRegistrationFromAuthority(input) {
+    const authority = normalizeAuthority(input.authority);
+    const protocol = getProtocolForAuthority(authority);
+    const addressCountry = normalizeCountryCode(input.addressCountry) || normalizeCountryCode(input.jurisdiction);
+    const coverageScope = normalizeString(input.coverageScope) || undefined;
+    const areaServed = Array.from(new Set((input.areaServed || [input.jurisdiction])
+        .map((value) => normalizeString(value))
+        .filter(Boolean)));
+    return normalizeHostingOperatorRegistration({
+        jurisdiction: input.jurisdiction,
+        version: input.version,
+        networkType: input.networkType,
+        title: input.title,
+        operatorDid: buildDidWebFromAuthority(authority),
+        discoveryUrl: `${protocol}://${authority}/host/cds-${input.jurisdiction}/${input.version}/${input.networkType}/.well-known/dspace-version`,
+        record: {
+            subjectId: buildDidWebFromAuthority(authority),
+            serviceTypes: [...input.serviceTypes],
+            categories: [normalizeString(input.sector)],
+            areaServed,
+            addressCountry: addressCountry || undefined,
+            coverageScope,
+        },
+    });
+}
+/**
+ * Builds one published-provider default entry from a tenant id under a given
+ * hosting operator authority.
+ *
+ * Integrator-friendly rule:
+ * - the backend usually knows `tenantId`
+ * - it usually does not want to handcraft the hosted/internal `did:web`
+ * - this helper derives the hosted provider DID and tenant-scoped DSP URLs
+ */
+export function buildDefaultPublishedProviderRecordFromTenant(input) {
+    const hostAuthority = normalizeAuthority(input.hostAuthority);
+    const hostDidWeb = buildDidWebFromAuthority(hostAuthority);
+    const providerDid = buildOrganizationDidWeb({
+        hostDidWeb,
+        tenantId: input.tenantId,
+        jurisdiction: input.jurisdiction,
+        version: input.version,
+        sector: input.sector,
+    });
+    const providerBaseUrl = normalizeAuthority(input.externalDomain)
+        ? `${getProtocolForAuthority(normalizeAuthority(input.externalDomain))}://${normalizeAuthority(input.externalDomain)}/`
+        : getBaseUrlFromDidWeb(providerDid);
+    const areaServed = normalizeCapabilities((input.areaServed || [input.jurisdiction]).map((value) => normalizeString(value))).join(',') || undefined;
+    return normalizePublishedProvider({
+        providerDid,
+        serviceType: input.providerCapability,
+        category: input.sector,
+        areaServed,
+        endpointUrl: providerBaseUrl,
+        discoveryUrl: new URL('.well-known/dspace-version', providerBaseUrl).toString(),
+        catalogUrl: new URL('dsp/catalog/dcat.json', providerBaseUrl).toString(),
+    });
+}
+/**
+ * Mutable in-memory registry for discovery defaults used by portal/backend
+ * bootstrap code.
+ *
+ * Scope:
+ * - ICA defaults are indexed by `jurisdiction + version + networkType`
+ * - hosting defaults are indexed by `jurisdiction + version + networkType`
+ * - sector filtering is applied only when listing hosting operators, because
+ *   sectors belong to tenant/provider discovery rather than to the host network
+ *
+ * This registry is intentionally simple and synchronous so backend code can
+ * preload defaults during startup and immediately serve the frontend in
+ * `defaults-only` or `default-first` mode.
+ */
+export class DataspaceDiscoveryDefaultsRegistry {
+    constructor(seed = {}) {
+        this.icas = [];
+        this.hostingOperators = [];
+        for (const registration of seed.icas || []) {
+            this.addIca(registration);
+        }
+        for (const registration of seed.hostingOperators || []) {
+            this.addHostingOperator(registration);
+        }
+    }
+    /**
+     * Adds one ICA default for a concrete host/network context.
+     *
+     * @example
+     * ```ts
+     * registry.addIca({
+     *   jurisdiction: 'ES',
+     *   version: 'v1',
+     *   networkType: 'test',
+     *   icaUrl: 'https://ica.example.org',
+     * });
+     * ```
+     */
+    addIca(input) {
+        this.icas.push(normalizeIcaRegistration(input));
+        return this;
+    }
+    /**
+     * Adds one hosting-operator default for a concrete host/network context.
+     *
+     * The record itself may later serve multiple sectors depending on the
+     * semantic categories and capabilities published in `record`.
+     */
+    addHostingOperator(input) {
+        this.hostingOperators.push(normalizeHostingOperatorRegistration(input));
+        return this;
+    }
+    /**
+     * Lists configured ICA defaults for a host/network context.
+     */
+    listIcas(filter = {}) {
+        return this.icas
+            .filter((registration) => matchesNetworkContext(registration, filter))
+            .map((registration) => ({ ...registration }));
+    }
+    /**
+     * Lists configured hosting-operator defaults for a frontend/backend discovery
+     * request.
+     *
+     * Sector and capability filtering are applied against the semantic host
+     * record because those dimensions belong to the provider/tenant side.
+     */
+    listHostingOperators(filter = {}) {
+        return this.hostingOperators
+            .filter((registration) => matchesNetworkContext(registration, filter))
+            .filter((registration) => {
+            if (!filter.sector)
+                return true;
+            return matchesHostingOperatorDiscoveryFilter(registration.record, {
+                sector: normalizeString(filter.sector),
+                coverageScope: normalizeString(filter.coverageScope) || undefined,
+                requiredCapabilities: normalizeCapabilities(filter.requiredCapabilities),
+            });
+        })
+            .map((registration) => ({
+            ...registration,
+            record: {
+                ...registration.record,
+                serviceTypes: [...registration.record.serviceTypes],
+                categories: [...registration.record.categories],
+                areaServed: [...registration.record.areaServed],
+            },
+            publishedProviders: (registration.publishedProviders || []).map((provider) => ({
+                ...provider,
+            })),
+        }));
+    }
+    /**
+     * Builds the backend bootstrap plan for one provider-discovery request.
+     *
+     * Current default-first policy:
+     * - use configured hosting defaults immediately when they exist
+     * - only try live ICA/internet when no host defaults match the request and at
+     *   least one ICA default is configured for the same host/network context
+     */
+    buildBootstrapPlan(input) {
+        const sourceMode = normalizeString(input.sourceMode)
+            || DataspaceDiscoverySourceMode.DefaultFirst;
+        const icas = this.listIcas(input);
+        const hostingOperators = this.listHostingOperators(input);
+        const hasDefaults = Boolean(icas.length || hostingOperators.length);
+        const shouldUseDefaultsFirst = sourceMode !== DataspaceDiscoverySourceMode.InternetFirst;
+        const shouldTryInternet = sourceMode !== DataspaceDiscoverySourceMode.DefaultsOnly
+            && icas.length > 0
+            && (sourceMode === DataspaceDiscoverySourceMode.InternetFirst
+                || hostingOperators.length === 0);
+        return {
+            sourceMode,
+            icas,
+            hostingOperators,
+            hasDefaults,
+            shouldUseDefaultsFirst,
+            shouldTryInternet,
+        };
+    }
+}
+/**
+ * Convenience factory for the in-memory defaults registry.
+ */
+export function createDataspaceDiscoveryDefaultsRegistry(seed = {}) {
+    return new DataspaceDiscoveryDefaultsRegistry(seed);
+}