gdc-sdk-front-ts 2.2.1 → 2.3.1

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

@@ -1,482 +0,0 @@
-// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
-import { ClaimsOrganizationSchemaorg, ClaimsServiceSchemaorg } from '../constants/schemaorg';
-import { isEuCountryCode, normalizeCountryCode } from '../constants/eu-countries';
-import { isProviderServiceCapability } from '../constants/service-capabilities';
-import { DataspaceCoverageScope, } from '../models/dataspace-discovery';
-function asObject(value) {
-    return value && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : undefined;
-}
-function asNonEmptyString(value) {
-    return typeof value === 'string' ? value.trim() : '';
-}
-export const DiscoveryCatalogSource = Object.freeze({
-    Internet: 'internet',
-    Cache: 'cache',
-    Default: 'default',
-});
-function createDiscoveryCatalogFetchResponse(payload, init = {}) {
-    return {
-        ok: init.ok ?? true,
-        status: init.status ?? 200,
-        json: async () => payload,
-        text: async () => JSON.stringify(payload),
-    };
-}
-function toStringList(value) {
-    if (Array.isArray(value)) {
-        return Array.from(new Set(value
-            .flatMap((entry) => toStringList(entry))
-            .map((entry) => entry.trim())
-            .filter(Boolean)));
-    }
-    const raw = asNonEmptyString(value);
-    if (!raw)
-        return [];
-    return Array.from(new Set(raw
-        .split(',')
-        .map((entry) => entry.trim())
-        .filter(Boolean)));
-}
-function normalizeList(values) {
-    return Array.from(new Set(values
-        .map((value) => value.trim())
-        .filter(Boolean)));
-}
-function sameNormalizedList(left, right) {
-    if (left.length !== right.length)
-        return false;
-    const normalizedLeft = [...normalizeList(left)].sort();
-    const normalizedRight = [...normalizeList(right)].sort();
-    return normalizedLeft.every((value, index) => value === normalizedRight[index]);
-}
-function parseAreaServedValue(value) {
-    if (Array.isArray(value)) {
-        return normalizeList(value.flatMap((entry) => parseAreaServedValue(entry)));
-    }
-    if (typeof value === 'string') {
-        return toStringList(value);
-    }
-    const objectValue = asObject(value);
-    if (!objectValue)
-        return [];
-    return normalizeList([
-        asNonEmptyString(objectValue.name),
-        asNonEmptyString(objectValue['@id']),
-        asNonEmptyString(objectValue.id),
-    ].filter(Boolean));
-}
-function getSemanticCredentialSubject(input) {
-    const objectInput = asObject(input);
-    if (!objectInput)
-        return undefined;
-    const credentialSubject = asObject(objectInput.credentialSubject);
-    if (credentialSubject)
-        return credentialSubject;
-    return objectInput;
-}
-function getFlattenedClaims(input) {
-    const objectInput = asObject(input);
-    if (!objectInput)
-        return undefined;
-    const meta = asObject(objectInput.meta);
-    const claims = asObject(meta?.claims);
-    return claims;
-}
-function getSemanticServiceTypes(subject) {
-    return toStringList(subject?.serviceType);
-}
-function getSemanticCategories(subject) {
-    return toStringList(subject?.category);
-}
-function getSemanticAreaServed(subject) {
-    return parseAreaServedValue(subject?.areaServed);
-}
-function getSemanticAddressCountry(subject) {
-    const address = asObject(subject?.address);
-    return normalizeCountryCode(asNonEmptyString(address?.addressCountry));
-}
-function getFlattenedServiceTypes(claims) {
-    return toStringList(claims?.[ClaimsServiceSchemaorg.serviceType]);
-}
-function getFlattenedCategories(claims) {
-    return toStringList(claims?.[ClaimsServiceSchemaorg.category]);
-}
-function getFlattenedAreaServed(claims) {
-    return parseAreaServedValue(claims?.[ClaimsServiceSchemaorg.areaServed]);
-}
-function getFlattenedAddressCountry(claims) {
-    return normalizeCountryCode(asNonEmptyString(claims?.[ClaimsOrganizationSchemaorg.addressCountry]));
-}
-function assertNoMismatch(kind, semantic, flattened) {
-    if (!semantic.length || !flattened.length)
-        return;
-    if (!sameNormalizedList(semantic, flattened)) {
-        throw new Error(`Dataspace discovery mismatch for ${kind}: credentialSubject and meta.claims disagree.`);
-    }
-}
-function assertNoScalarMismatch(kind, semantic, flattened) {
-    if (!semantic || !flattened)
-        return;
-    if (semantic !== flattened) {
-        throw new Error(`Dataspace discovery mismatch for ${kind}: credentialSubject and meta.claims disagree.`);
-    }
-}
-/**
- * Parses the CSV or array representation of `serviceType`.
- *
- * @param value Semantic `credentialSubject.serviceType` or flattened
- * `meta.claims['org.schema.Service.serviceType']`.
- * @returns Normalized unique service capability tokens.
- *
- * @example
- * ```ts
- * parseServiceTypeCsv('indexing.cruds,digitaltwin.rs');
- * // ['indexing.cruds', 'digitaltwin.rs']
- * ```
- */
-export function parseServiceTypeCsv(value) {
-    return toStringList(value);
-}
-/**
- * Parses the Schema.org `category` service dimension used as the dataspace
- * sector vocabulary in the current profile.
- *
- * @param value Semantic `credentialSubject.category` or flattened
- * `meta.claims['org.schema.Service.category']`.
- * @returns Normalized unique sector/category values.
- *
- * @example
- * ```ts
- * parseServiceCategories('animal-care,health-care');
- * // ['animal-care', 'health-care']
- * ```
- */
-export function parseServiceCategories(value) {
-    return toStringList(value);
-}
-/**
- * Parses Schema.org `areaServed` values.
- *
- * Accepts scalar strings, CSV strings, arrays, and simple
- * `AdministrativeArea`-like objects with `name` or `@id`.
- *
- * @param value Semantic `credentialSubject.areaServed` or flattened
- * `meta.claims['org.schema.Service.areaServed']`.
- * @returns Normalized unique coverage values.
- *
- * @example
- * ```ts
- * parseAreaServed([{ '@type': 'AdministrativeArea', name: 'EU' }, 'ES']);
- * // ['EU', 'ES']
- * ```
- */
-export function parseAreaServed(value) {
-    return parseAreaServedValue(value);
-}
-/**
- * Infers a broader coverage scope from an ISO-2 country code.
- *
- * `EU` is returned only as a coverage scope. It must not be treated as a
- * sector.
- *
- * @param countryCode ISO-2 country code, typically from
- * `credentialSubject.address.addressCountry`.
- * @returns `EU` for EU member countries, otherwise the normalized country code.
- *
- * @example
- * ```ts
- * inferCoverageScopeFromCountryCode('ES');
- * // 'EU'
- * ```
- */
-export function inferCoverageScopeFromCountryCode(countryCode) {
-    const normalized = normalizeCountryCode(countryCode);
-    if (!normalized)
-        return undefined;
-    return isEuCountryCode(normalized)
-        ? DataspaceCoverageScope.EuropeanUnion
-        : normalized;
-}
-/**
- * Infers a coverage scope from the semantic `credentialSubject`.
- *
- * @param subject Semantic service object containing `address.addressCountry`.
- * @returns Broader coverage scope such as `EU`, or the normalized country code
- * when the country is outside the EU set.
- */
-export function inferCoverageScopeFromCredentialSubject(subject) {
-    const subjectObject = asObject(subject);
-    const address = asObject(subjectObject?.address);
-    return inferCoverageScopeFromCountryCode(asNonEmptyString(address?.addressCountry));
-}
-/**
- * Extracts the shared dataspace service semantics from a VC-like payload.
- *
- * Source-of-truth rule:
- * - semantic values come from `credentialSubject` first
- * - flattened `meta.claims` is accepted as a compatibility projection/fallback
- * - when both exist they must agree
- *
- * @param input VC-like payload, direct semantic object, or equivalent DTO.
- * @returns Runtime-neutral normalized dataspace discovery semantics.
- *
- * @example
- * ```ts
- * extractDataspaceServiceSemanticRecord({
- *   credentialSubject: {
- *     id: 'did:web:provider.example.org',
- *     serviceType: 'indexing.cruds',
- *     category: 'animal-care',
- *     areaServed: { '@type': 'AdministrativeArea', name: 'EU' },
- *     address: { addressCountry: 'ES' },
- *   },
- *   meta: {
- *     claims: {
- *       'org.schema.Service.serviceType': 'indexing.cruds',
- *       'org.schema.Service.category': 'animal-care',
- *       'org.schema.Service.areaServed': 'EU',
- *       'org.schema.Organization.address.addressCountry': 'ES',
- *     },
- *   },
- * });
- * ```
- */
-export function extractDataspaceServiceSemanticRecord(input) {
-    const subject = getSemanticCredentialSubject(input);
-    const claims = getFlattenedClaims(input);
-    const semanticServiceTypes = getSemanticServiceTypes(subject);
-    const semanticCategories = getSemanticCategories(subject);
-    const semanticAreaServed = getSemanticAreaServed(subject);
-    const semanticAddressCountry = getSemanticAddressCountry(subject);
-    const flattenedServiceTypes = getFlattenedServiceTypes(claims);
-    const flattenedCategories = getFlattenedCategories(claims);
-    const flattenedAreaServed = getFlattenedAreaServed(claims);
-    const flattenedAddressCountry = getFlattenedAddressCountry(claims);
-    assertNoMismatch('serviceType', semanticServiceTypes, flattenedServiceTypes);
-    assertNoMismatch('category', semanticCategories, flattenedCategories);
-    assertNoMismatch('areaServed', semanticAreaServed, flattenedAreaServed);
-    assertNoScalarMismatch('address.addressCountry', semanticAddressCountry, flattenedAddressCountry);
-    const serviceTypes = semanticServiceTypes.length ? semanticServiceTypes : flattenedServiceTypes;
-    const categories = semanticCategories.length ? semanticCategories : flattenedCategories;
-    const areaServed = semanticAreaServed.length ? semanticAreaServed : flattenedAreaServed;
-    const addressCountry = semanticAddressCountry || flattenedAddressCountry || undefined;
-    return {
-        subjectId: asNonEmptyString(subject?.id) || undefined,
-        serviceTypes,
-        categories,
-        areaServed,
-        addressCountry,
-        coverageScope: inferCoverageScopeFromCountryCode(addressCountry),
-    };
-}
-/**
- * Extracts a hosting-operator semantic record from a VC-like payload.
- *
- * @param input VC-like payload or direct semantic object.
- * @returns Hosting-operator semantic record normalized with the common
- * dataspace extraction rules.
- */
-export function extractHostingOperatorSemanticRecord(input) {
-    return extractDataspaceServiceSemanticRecord(input);
-}
-/**
- * Extracts a tenant-service semantic record from a VC-like payload.
- *
- * @param input VC-like payload or direct semantic object.
- * @returns Tenant-service semantic record normalized with the common dataspace
- * extraction rules.
- */
-export function extractTenantServiceSemanticRecord(input) {
-    return extractDataspaceServiceSemanticRecord(input);
-}
-function matchesCoverageFilter(areaServed, jurisdiction, coverageScope) {
-    const normalizedAreaServed = normalizeList([...(areaServed || [])]);
-    if (jurisdiction && !normalizedAreaServed.includes(jurisdiction))
-        return false;
-    if (coverageScope && !normalizedAreaServed.includes(coverageScope))
-        return false;
-    return true;
-}
-/**
- * Returns whether a normalized hosting-operator record satisfies a service
- * autodiscovery filter.
- */
-export function matchesHostingOperatorDiscoveryFilter(record, filter) {
-    if (!record.categories.includes(filter.sector))
-        return false;
-    if (!matchesCoverageFilter(record.areaServed, filter.jurisdiction, filter.coverageScope))
-        return false;
-    if (filter.capability && !record.serviceTypes.includes(filter.capability))
-        return false;
-    if (filter.requiredCapabilities?.length) {
-        return filter.requiredCapabilities.every((capability) => record.serviceTypes.includes(capability));
-    }
-    return true;
-}
-/**
- * Returns whether a published provider catalog entry satisfies a service
- * autodiscovery filter.
- */
-export function matchesPublishedProviderDiscoveryFilter(record, filter) {
-    if (!isProviderServiceCapability(record.serviceType))
-        return false;
-    if (record.category !== filter.sector)
-        return false;
-    if (filter.capability && record.serviceType !== filter.capability)
-        return false;
-    return matchesCoverageFilter(record.areaServed ? [record.areaServed] : [], filter.jurisdiction, filter.coverageScope);
-}
-/**
- * Filters hosting-operator records using the shared service-autodiscovery
- * semantics.
- */
-export function filterHostingOperatorsByDiscoveryFilter(records, filter) {
-    return records.filter((record) => matchesHostingOperatorDiscoveryFilter(record, filter));
-}
-/**
- * Filters published provider entries using the shared service-autodiscovery
- * semantics.
- */
-export function filterPublishedProvidersByDiscoveryFilter(records, filter) {
-    return records.filter((record) => matchesPublishedProviderDiscoveryFilter(record, filter));
-}
-/**
- * Filters a host/operator discovery catalog down to the providers that satisfy
- * the requested service-autodiscovery filter.
- */
-export function filterHostingOperatorDiscoveryCatalog(catalog, filter) {
-    return {
-        ...catalog,
-        providers: filterPublishedProvidersByDiscoveryFilter(catalog.providers, filter),
-    };
-}
-/**
- * Builds a normalized published-provider catalog DTO suitable for:
- *
- * - backend-owned fallback catalogs
- * - default discovery data loaded from configuration
- * - tests that should use the same DTO constructors as production code
- *
- * This helper is intentionally neutral:
- * - no example DIDs
- * - no example URLs
- * - no hidden business defaults
- *
- * @param input Required provider catalog fields plus optional URLs.
- * @returns Normalized published-provider catalog record.
- */
-export function buildDefaultPublishedProviderCatalogRecord(input) {
-    const normalizedAreaServed = Array.isArray(input.areaServed)
-        ? normalizeList(input.areaServed.map((value) => asNonEmptyString(value)).filter(Boolean))
-        : toStringList(input.areaServed);
-    return {
-        providerDid: asNonEmptyString(input.providerDid),
-        serviceType: asNonEmptyString(input.serviceType),
-        category: asNonEmptyString(input.category),
-        areaServed: normalizedAreaServed.length ? normalizedAreaServed.join(',') : undefined,
-        endpointUrl: asNonEmptyString(input.endpointUrl) || undefined,
-        discoveryUrl: asNonEmptyString(input.discoveryUrl) || undefined,
-        catalogUrl: asNonEmptyString(input.catalogUrl) || undefined,
-    };
-}
-/**
- * Builds a normalized hosting-operator discovery catalog DTO suitable for:
- *
- * - backend-owned fallback catalogs
- * - default host catalogs assembled from configuration
- * - tests that should reuse the same constructor as production code
- *
- * @param input Optional host identity fields plus the provider list.
- * @returns Normalized host discovery catalog.
- */
-export function buildDefaultHostingOperatorDiscoveryCatalog(input = {}) {
-    return {
-        hostingOperatorDid: asNonEmptyString(input.hostingOperatorDid) || undefined,
-        discoveryUrl: asNonEmptyString(input.discoveryUrl) || undefined,
-        catalogUrl: asNonEmptyString(input.catalogUrl) || undefined,
-        providers: [...(input.providers || [])],
-    };
-}
-function isHostingOperatorCatalogPayload(value) {
-    const objectValue = asObject(value);
-    return Boolean(objectValue && Array.isArray(objectValue.providers));
-}
-/**
- * Creates a generic host-catalog fetcher with cache and default fallback.
- *
- * Intended use:
- * - docs
- * - SDK integration examples
- * - tests that need to demonstrate the transport boundary around discovery
- *
- * Behavior:
- * - successful network catalog refreshes cache
- * - later network failures reuse cached catalog when available
- * - when both network and cache are unavailable, configured defaults are used
- *
- * Production integrations may follow the same policy while replacing this
- * in-memory harness with real logging, metrics, and storage.
- *
- * @param options Optional initial network and default catalogs keyed by URL.
- * @returns Fetcher plus observable state and mutation helpers.
- */
-export function createDiscoveryCatalogFetcher(options = {}) {
-    const internetResponses = new Map([
-        ...Object.entries(options.internetCatalogs || {}).map(([url, catalog]) => [url, createDiscoveryCatalogFetchResponse(catalog, { ok: true, status: 200 })]),
-        ...Object.entries(options.internetJsonByUrl || {}).map(([url, payload]) => [url, createDiscoveryCatalogFetchResponse(payload, { ok: true, status: 200 })]),
-    ]);
-    const internetPayloads = new Map([
-        ...Object.entries(options.internetCatalogs || {}).map(([url, catalog]) => [String(url), catalog]),
-        ...Object.entries(options.internetJsonByUrl || {}).map(([url, payload]) => [String(url), payload]),
-    ]);
-    const defaultCatalogs = new Map(Object.entries(options.defaultCatalogs || {}));
-    const cache = new Map();
-    const sources = new Map();
-    const calls = [];
-    return {
-        calls,
-        sources,
-        cache,
-        setInternetCatalog(url, catalog) {
-            internetResponses.set(String(url), createDiscoveryCatalogFetchResponse(catalog, { ok: true, status: 200 }));
-            internetPayloads.set(String(url), catalog);
-        },
-        setInternetJson(url, payload) {
-            internetResponses.set(String(url), createDiscoveryCatalogFetchResponse(payload, { ok: true, status: 200 }));
-            internetPayloads.set(String(url), payload);
-        },
-        setInternetFailure(url, status = 503, body = { error: 'temporary failure' }) {
-            internetResponses.set(String(url), createDiscoveryCatalogFetchResponse(body, { ok: false, status }));
-            internetPayloads.delete(String(url));
-        },
-        clearInternetRoute(url) {
-            internetResponses.delete(String(url));
-            internetPayloads.delete(String(url));
-        },
-        async fetcher(input) {
-            const key = String(input);
-            calls.push(key);
-            const internetResponse = internetResponses.get(key);
-            if (internetResponse && internetResponse.ok) {
-                const payload = internetPayloads.get(key);
-                if (isHostingOperatorCatalogPayload(payload)) {
-                    cache.set(key, payload);
-                }
-                sources.set(key, DiscoveryCatalogSource.Internet);
-                return internetResponse;
-            }
-            if (cache.has(key)) {
-                sources.set(key, DiscoveryCatalogSource.Cache);
-                return createDiscoveryCatalogFetchResponse(cache.get(key), { ok: true, status: 200 });
-            }
-            if (defaultCatalogs.has(key)) {
-                sources.set(key, DiscoveryCatalogSource.Default);
-                return createDiscoveryCatalogFetchResponse(defaultCatalogs.get(key), { ok: true, status: 200 });
-            }
-            sources.set(key, DiscoveryCatalogSource.Default);
-            return createDiscoveryCatalogFetchResponse({ error: 'not found' }, { ok: false, status: 404 });
-        },
-    };
-}

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

@@ -1,66 +0,0 @@
-import { type DataspaceProtocolVersionValue } from '../constants/dataspace-protocol';
-import type { DspaceProtocolVersionEntry, DspaceVersionMetadata } from '../models/dataspace-protocol';
-/**
- * Route context used to build tenant-scoped or host-scoped GW CORE DSP paths.
- *
- * Semantic rule:
- * - `tenantId` participants use `businessSector`
- * - `host`/ICA/runtime participants use `hostNetwork`
- */
-export type GwDataspaceRouteContext = Readonly<{
-    participantId?: string;
-    tenantId?: string;
-    jurisdiction?: string;
-    version?: string;
-    hostNetwork?: string;
-    /** @deprecated Use `hostNetwork`. */
-    hostNetworkOrBusinessSector?: string;
-    businessSector?: string;
-    sector?: string;
-}>;
-/**
- * Builds the GW CORE base DSP path.
- *
- * Participant scope:
- * - `/{participantId}/cds-{jurisdiction}/{version}/{hostNetwork|businessSector}/dsp`
- */
-export declare function buildGwDataspaceBasePath(input?: GwDataspaceRouteContext): string;
-/**
- * Builds the canonical DSP version-discovery well-known path for GW CORE.
- *
- * Participant scope:
- * - `/{participantId}/cds-{jurisdiction}/{version}/{hostNetwork|businessSector}/.well-known/dspace-version`
- */
-export declare function buildGwDspaceVersionWellKnownPath(input?: GwDataspaceRouteContext): string;
-/**
- * Builds the project-local GW CORE DSP catalog request endpoint.
- */
-export declare function buildGwCatalogRequestPath(input?: GwDataspaceRouteContext): string;
-/**
- * Builds the GW CORE catalog collection base path.
- */
-export declare function buildGwCatalogCollectionPath(input?: GwDataspaceRouteContext): string;
-/**
- * Builds the project-local GW CORE catalog artifact URL path used for public
- * read-only autodiscovery.
- */
-export declare function buildGwCatalogArtifactPath(input?: GwDataspaceRouteContext): string;
-/**
- * Builds the project-local GW CORE dataset lookup path.
- */
-export declare function buildGwCatalogDatasetPath(input?: GwDataspaceRouteContext, datasetId?: string): string;
-/**
- * Builds a minimal DSP version metadata payload for a given GW CORE DSP base
- * path.
- */
-export declare function buildDspaceVersionMetadata(path: string, version?: DataspaceProtocolVersionValue): DspaceVersionMetadata;
-/**
- * Selects the preferred advertised DSP version entry from a `dspace-version`
- * payload.
- */
-export declare function selectDspaceProtocolVersionEntry(metadata: DspaceVersionMetadata | null | undefined, version?: string): DspaceProtocolVersionEntry | undefined;
-/**
- * Derives the GW CORE catalog artifact URL from a `dspace-version` endpoint URL
- * and its parsed payload.
- */
-export declare function deriveGwCatalogArtifactUrlFromDspaceVersion(dspaceVersionUrl: string, metadata: DspaceVersionMetadata | null | undefined, version?: string): string | undefined;

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

@@ -1,109 +0,0 @@
-// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
-import { DataspaceProtocolVersions, DataspaceWellKnownPaths, GwDataspaceBindingPaths, } from '../constants/dataspace-protocol';
-function resolveParticipantId(input) {
-    return String(input.participantId || input.tenantId || '').trim();
-}
-function resolveSectorLikeSegment(input) {
-    return String(input.hostNetwork
-        || input.hostNetworkOrBusinessSector
-        || input.businessSector
-        || input.sector
-        || '').trim();
-}
-function hasParticipantRouteContext(input) {
-    return Boolean(resolveParticipantId(input)
-        && String(input.jurisdiction || '').trim()
-        && String(input.version || '').trim()
-        && resolveSectorLikeSegment(input));
-}
-/**
- * Builds the GW CORE base DSP path.
- *
- * Participant scope:
- * - `/{participantId}/cds-{jurisdiction}/{version}/{hostNetwork|businessSector}/dsp`
- */
-export function buildGwDataspaceBasePath(input = {}) {
-    if (!hasParticipantRouteContext(input)) {
-        return GwDataspaceBindingPaths.Base;
-    }
-    return `/${resolveParticipantId(input)}`
-        + `/cds-${String(input.jurisdiction).trim()}`
-        + `/${String(input.version).trim()}`
-        + `/${resolveSectorLikeSegment(input)}`
-        + GwDataspaceBindingPaths.Base;
-}
-/**
- * Builds the canonical DSP version-discovery well-known path for GW CORE.
- *
- * Participant scope:
- * - `/{participantId}/cds-{jurisdiction}/{version}/{hostNetwork|businessSector}/.well-known/dspace-version`
- */
-export function buildGwDspaceVersionWellKnownPath(input = {}) {
-    if (!hasParticipantRouteContext(input)) {
-        return DataspaceWellKnownPaths.VersionMetadata;
-    }
-    return `/${resolveParticipantId(input)}`
-        + `/cds-${String(input.jurisdiction).trim()}`
-        + `/${String(input.version).trim()}`
-        + `/${resolveSectorLikeSegment(input)}`
-        + DataspaceWellKnownPaths.VersionMetadata;
-}
-/**
- * Builds the project-local GW CORE DSP catalog request endpoint.
- */
-export function buildGwCatalogRequestPath(input = {}) {
-    return `${buildGwDataspaceBasePath(input)}${GwDataspaceBindingPaths.CatalogRequestSuffix}`;
-}
-/**
- * Builds the GW CORE catalog collection base path.
- */
-export function buildGwCatalogCollectionPath(input = {}) {
-    return `${buildGwDataspaceBasePath(input)}${GwDataspaceBindingPaths.CatalogCollectionSuffix}`;
-}
-/**
- * Builds the project-local GW CORE catalog artifact URL path used for public
- * read-only autodiscovery.
- */
-export function buildGwCatalogArtifactPath(input = {}) {
-    return `${buildGwDataspaceBasePath(input)}${GwDataspaceBindingPaths.CatalogArtifactSuffix}`;
-}
-/**
- * Builds the project-local GW CORE dataset lookup path.
- */
-export function buildGwCatalogDatasetPath(input = {}, datasetId = ':id') {
-    return `${buildGwDataspaceBasePath(input)}${GwDataspaceBindingPaths.CatalogDatasetsPrefix}/${datasetId}`;
-}
-/**
- * Builds a minimal DSP version metadata payload for a given GW CORE DSP base
- * path.
- */
-export function buildDspaceVersionMetadata(path, version = DataspaceProtocolVersions.Current) {
-    return {
-        protocolVersions: [
-            {
-                version,
-                path,
-            },
-        ],
-    };
-}
-/**
- * Selects the preferred advertised DSP version entry from a `dspace-version`
- * payload.
- */
-export function selectDspaceProtocolVersionEntry(metadata, version = DataspaceProtocolVersions.Current) {
-    const entries = metadata?.protocolVersions || [];
-    return entries.find((entry) => String(entry.version || '').trim() === String(version).trim())
-        || entries[0];
-}
-/**
- * Derives the GW CORE catalog artifact URL from a `dspace-version` endpoint URL
- * and its parsed payload.
- */
-export function deriveGwCatalogArtifactUrlFromDspaceVersion(dspaceVersionUrl, metadata, version = DataspaceProtocolVersions.Current) {
-    const entry = selectDspaceProtocolVersionEntry(metadata, version);
-    if (!entry?.path)
-        return undefined;
-    const base = new URL(dspaceVersionUrl);
-    return new URL(`${String(entry.path).trim()}${GwDataspaceBindingPaths.CatalogArtifactSuffix}`, `${base.protocol}//${base.host}`).toString();
-}