@startinblox/core 2.0.6-beta.5 → 2.0.6-beta.7

package/dist/{store-BCI532IX.js → store-pxHgUL4R.js}

@@ -278,12 +278,13 @@ let __tla = (async () => {
         protocol: "dataspace-protocol-http",
         policy: {
           "@context": "http://www.w3.org/ns/odrl.jsonld",
-          "@id": policy["@id"],
-          "@type": "Offer",
-          assigner: counterPartyId || "provider",
+          ...policy,
+          "@type": policy["@type"] || "Offer",
+          assigner: policy.assigner || counterPartyId || "provider",
           target: policy.target
         }
       };
+      console.log("[DataspaceConnectorStore] Contract negotiation request:", JSON.stringify(negotiationRequest, null, 2));
       const response = await this.fetchAuthn(this.config.contractNegotiationEndpoint, {
         method: "POST",
         headers: this.headers,
@@ -589,6 +590,86 @@ let __tla = (async () => {
       }
       return await this.fetchWithEDRToken(edrDataAddress, additionalPath);
     }
+    async fetchProtectedResource(resourceUrl, consumerParticipantId, providerConnectorUrl, existingAgreementId, maxNegotiationRetries = 30, negotiationRetryDelay = 2e3) {
+      console.log(`\u{1F510} Requesting protected resource: ${resourceUrl}`);
+      if (existingAgreementId) {
+        console.log(`\u{1F4DC} Using existing agreement: ${existingAgreementId}`);
+        return await this._fetchWithAgreement(resourceUrl, consumerParticipantId, providerConnectorUrl, existingAgreementId);
+      }
+      const initialResponse = await fetch(resourceUrl, {
+        method: "GET",
+        headers: {
+          "DSP-PARTICIPANT-ID": consumerParticipantId,
+          "DSP-CONSUMER-CONNECTORURL": providerConnectorUrl,
+          Accept: "application/json"
+        },
+        mode: "cors"
+      });
+      if (initialResponse.ok) {
+        const data = await initialResponse.json();
+        console.log("\u2705 Resource accessed successfully (no agreement required)");
+        return data;
+      }
+      if (initialResponse.status !== 449) {
+        const errorText = await initialResponse.text();
+        throw new Error(`Unexpected response: ${initialResponse.status} ${initialResponse.statusText} - ${errorText}`);
+      }
+      const agreementId = await this._handlePolicyDiscovery(initialResponse, providerConnectorUrl, maxNegotiationRetries, negotiationRetryDelay);
+      console.log("\u{1F504} Retrying resource request with agreement...");
+      return await this._fetchWithAgreement(resourceUrl, consumerParticipantId, providerConnectorUrl, agreementId);
+    }
+    async _handlePolicyDiscovery(initialResponse, providerConnectorUrl, maxNegotiationRetries, negotiationRetryDelay) {
+      console.log("\u{1F4CB} Contract negotiation required (449 response)");
+      const errorResponse = await initialResponse.json();
+      const suggestedPolicies = errorResponse.suggested_policies;
+      if (!suggestedPolicies || suggestedPolicies.length === 0) {
+        throw new Error("No suggested policies returned in 449 response");
+      }
+      const bestPolicy = suggestedPolicies.reduce((best, current) => {
+        return current.openness_score > best.openness_score ? current : best;
+      });
+      console.log(`\u{1F4DC} Selected policy: ${bestPolicy.policy_id} (openness: ${bestPolicy.openness_score})`);
+      console.log("\u{1F91D} Initiating contract negotiation...");
+      const negotiationId = await this.negotiateContract(providerConnectorUrl, errorResponse.asset_id, bestPolicy.policy, errorResponse.participant_id);
+      console.log(`\u{1F4DD} Negotiation initiated: ${negotiationId}`);
+      for (let attempt = 1; attempt <= maxNegotiationRetries; attempt++) {
+        await new Promise((resolve) => setTimeout(resolve, negotiationRetryDelay));
+        const status = await this._getNegotiationStatus(negotiationId);
+        console.log(`\u23F3 Negotiation status (${attempt}/${maxNegotiationRetries}): ${status.state}`);
+        if (status.state === "FINALIZED") {
+          const agreement = await this.getContractAgreement(negotiationId);
+          if (!agreement) {
+            throw new Error(`Failed to retrieve contract agreement for negotiation ${negotiationId}`);
+          }
+          console.log(`\u2705 Agreement obtained: ${agreement["@id"]}`);
+          return agreement["@id"];
+        }
+        if (status.state === "TERMINATED") {
+          throw new Error(`Negotiation terminated: ${status.errorDetail || "Unknown reason"}`);
+        }
+      }
+      throw new Error(`Negotiation ${negotiationId} failed or timed out after ${maxNegotiationRetries} attempts`);
+    }
+    async _fetchWithAgreement(resourceUrl, consumerParticipantId, providerConnectorUrl, agreementId) {
+      console.log(`\u{1F510} Requesting protected resource: ${resourceUrl} (with agreement)`);
+      const response = await fetch(resourceUrl, {
+        method: "GET",
+        headers: {
+          "DSP-PARTICIPANT-ID": consumerParticipantId,
+          "DSP-CONSUMER-CONNECTORURL": providerConnectorUrl,
+          "DSP-AGREEMENT-ID": agreementId,
+          Accept: "application/json"
+        },
+        mode: "cors"
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to access protected resource: ${response.status} ${response.statusText} - ${errorText}`);
+      }
+      const data = await response.json();
+      console.log("\u2705 Resource accessed successfully");
+      return data;
+    }
     async fetchThroughDataspace(resourceId) {
       try {
         const catalog = await this.getCatalog();
@@ -1273,6 +1354,190 @@ let __tla = (async () => {
   };
   __publicField(_DataspaceConnectorStoreAdapter, "store");
   let DataspaceConnectorStoreAdapter = _DataspaceConnectorStoreAdapter;
+  const _LocalStorageCacheMetadataManager = class _LocalStorageCacheMetadataManager {
+    constructor(endpoint, ttlMs = _LocalStorageCacheMetadataManager.DEFAULT_TTL_MS) {
+      this.endpoint = endpoint;
+      this.ttlMs = ttlMs;
+      this.cleanupOldCacheFormat();
+    }
+    cleanupOldCacheFormat() {
+      try {
+        const endpointHash = this.endpoint.replace(/[^a-zA-Z0-9]/g, "");
+        const oldKey = `fc-cache-meta-${endpointHash}`;
+        if (localStorage.getItem(oldKey)) {
+          localStorage.removeItem(oldKey);
+        }
+      } catch (error2) {
+        console.warn("[LocalStorageCache] Error cleaning up old cache format:", error2);
+      }
+    }
+    getStorageKey() {
+      const endpointHash = this.endpoint.replace(/[^a-zA-Z0-9]/g, "");
+      return `${_LocalStorageCacheMetadataManager.STORAGE_KEY_PREFIX}-${endpointHash}`;
+    }
+    getCacheData() {
+      try {
+        const key = this.getStorageKey();
+        const data = localStorage.getItem(key);
+        if (!data) {
+          return null;
+        }
+        const parsed = JSON.parse(data);
+        const items = /* @__PURE__ */ new Map();
+        if (parsed.items) {
+          for (const [hash, metadata] of Object.entries(parsed.items)) {
+            items.set(hash, metadata);
+          }
+        }
+        return {
+          version: parsed.version,
+          lastFetchTimestamp: parsed.lastFetchTimestamp,
+          cacheExpirationTimestamp: parsed.cacheExpirationTimestamp,
+          resource: parsed.resource,
+          items
+        };
+      } catch (error2) {
+        console.error("[LocalStorageCache] Error reading cache data:", error2);
+        return null;
+      }
+    }
+    getCacheMetadata() {
+      return this.getCacheData();
+    }
+    setCacheData(cacheData) {
+      try {
+        const key = this.getStorageKey();
+        const itemsObj = {};
+        cacheData.items.forEach((value, hash) => {
+          itemsObj[hash] = value;
+        });
+        const data = JSON.stringify({
+          version: cacheData.version,
+          lastFetchTimestamp: cacheData.lastFetchTimestamp,
+          cacheExpirationTimestamp: cacheData.cacheExpirationTimestamp,
+          resource: cacheData.resource,
+          items: itemsObj
+        });
+        localStorage.setItem(key, data);
+        return true;
+      } catch (error2) {
+        console.error("[LocalStorageCache] Error writing cache data:", error2);
+        return false;
+      }
+    }
+    setCacheMetadata(cacheData) {
+      return this.setCacheData(cacheData);
+    }
+    isCacheValid() {
+      const cacheData = this.getCacheData();
+      if (!cacheData) {
+        return false;
+      }
+      if (cacheData.version !== _LocalStorageCacheMetadataManager.CACHE_VERSION) {
+        console.log("[LocalStorageCache] Cache version mismatch, invalidating");
+        return false;
+      }
+      const now = Date.now();
+      if (now > cacheData.cacheExpirationTimestamp) {
+        console.log("[LocalStorageCache] Cache TTL expired");
+        return false;
+      }
+      return true;
+    }
+    getResource() {
+      const cacheData = this.getCacheData();
+      return (cacheData == null ? void 0 : cacheData.resource) || null;
+    }
+    getKnownHashes() {
+      const cacheData = this.getCacheData();
+      if (!cacheData) {
+        return /* @__PURE__ */ new Set();
+      }
+      return new Set(cacheData.items.keys());
+    }
+    getItemMetadata(sdHash) {
+      const cacheData = this.getCacheData();
+      if (!cacheData) {
+        return null;
+      }
+      return cacheData.items.get(sdHash) || null;
+    }
+    updateCache(resource, items) {
+      const now = Date.now();
+      let cacheData = this.getCacheData();
+      if (!cacheData || !this.isCacheValid()) {
+        cacheData = {
+          version: _LocalStorageCacheMetadataManager.CACHE_VERSION,
+          lastFetchTimestamp: now,
+          cacheExpirationTimestamp: now + this.ttlMs,
+          resource,
+          items: /* @__PURE__ */ new Map()
+        };
+      } else {
+        cacheData.resource = resource;
+      }
+      for (const item of items) {
+        cacheData.items.set(item.sdHash, {
+          ...item,
+          cachedAt: now
+        });
+      }
+      cacheData.lastFetchTimestamp = now;
+      return this.setCacheData(cacheData);
+    }
+    removeItems(sdHashes) {
+      var _a2;
+      const cacheData = this.getCacheData();
+      if (!cacheData) {
+        return false;
+      }
+      for (const hash of sdHashes) {
+        cacheData.items.delete(hash);
+      }
+      if ((_a2 = cacheData.resource) == null ? void 0 : _a2["ldp:contains"]) {
+        const resourceIdsToRemove = /* @__PURE__ */ new Set();
+        for (const hash of sdHashes) {
+          const meta = cacheData.items.get(hash);
+          if (meta) {
+            resourceIdsToRemove.add(meta.resourceId);
+          }
+        }
+        cacheData.resource["ldp:contains"] = cacheData.resource["ldp:contains"].filter((item) => !resourceIdsToRemove.has(item["@id"]));
+      }
+      return this.setCacheData(cacheData);
+    }
+    clear() {
+      try {
+        const key = this.getStorageKey();
+        localStorage.removeItem(key);
+        return true;
+      } catch (error2) {
+        console.error("[LocalStorageCache] Error clearing cache data:", error2);
+        return false;
+      }
+    }
+    getCacheStats() {
+      const cacheData = this.getCacheData();
+      if (!cacheData) {
+        return {
+          itemCount: 0,
+          lastFetch: null,
+          expiresAt: null,
+          isValid: false
+        };
+      }
+      return {
+        itemCount: cacheData.items.size,
+        lastFetch: new Date(cacheData.lastFetchTimestamp),
+        expiresAt: new Date(cacheData.cacheExpirationTimestamp),
+        isValid: this.isCacheValid()
+      };
+    }
+  };
+  __publicField(_LocalStorageCacheMetadataManager, "STORAGE_KEY_PREFIX", "fc-cache-data");
+  __publicField(_LocalStorageCacheMetadataManager, "CACHE_VERSION", "2.0.0");
+  __publicField(_LocalStorageCacheMetadataManager, "DEFAULT_TTL_MS", 2 * 60 * 60 * 1e3);
+  let LocalStorageCacheMetadataManager = _LocalStorageCacheMetadataManager;
   class FederatedCatalogueAPIWrapper {
     constructor(options, fcBaseUrl) {
       __publicField(this, "fcBaseUrl");
@@ -1400,6 +1665,8 @@ let __tla = (async () => {
       __publicField(this, "cache");
       __publicField(this, "session");
       __publicField(this, "fcApi");
+      __publicField(this, "metadataManager");
+      __publicField(this, "enableCaching");
       this.cfg = cfg;
       if (!this.cfg.login) {
         throw new Error("Login must be provided for FederatedCatalogueStore");
@@ -1414,6 +1681,31 @@ let __tla = (async () => {
         this.fcApi = null;
       }
       this.cache = new InMemoryCacheManager();
+      this.enableCaching = this.cfg.enableLocalStorageMetadata === true;
+      if (this.enableCaching && this.cfg.endpoint) {
+        const cacheTTL = this.cfg.cacheTTL || 2 * 60 * 60 * 1e3;
+        this.metadataManager = new LocalStorageCacheMetadataManager(this.cfg.endpoint, cacheTTL);
+        this.handlePageReload();
+      } else {
+        this.metadataManager = null;
+      }
+    }
+    handlePageReload() {
+      var _a2, _b;
+      try {
+        const SESSION_KEY = "fc-session-id";
+        let sessionId = sessionStorage.getItem(SESSION_KEY);
+        if (!sessionId) {
+          sessionId = `session-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+          sessionStorage.setItem(SESSION_KEY, sessionId);
+          (_a2 = this.metadataManager) == null ? void 0 : _a2.clear();
+        }
+        const stats = (_b = this.metadataManager) == null ? void 0 : _b.getCacheStats();
+        if (stats) {
+        }
+      } catch (error2) {
+        console.warn("[FederatedCatalogueStore] Error handling page reload:", error2);
+      }
     }
     resolveTargetType(args) {
       if (typeof args === "string") return args;
@@ -1423,27 +1715,178 @@ let __tla = (async () => {
       return "";
     }
     async getData(args) {
+      var _a2;
       const targetType = this.resolveTargetType(args);
       if (!this.fcApi) {
         throw new Error("Federated API not initialized, returning empty data.");
       }
-      let resource = await this.get(targetType);
-      if (!resource || resource["ldp:contains"].length === 0) {
-        resource = await this.initLocalDataSourceContainer(targetType);
-        const dataset2 = await this.fcApi.getAllSelfDescriptions();
-        if (dataset2) for (const item in dataset2.items) {
-          const sd = await this.fcApi.getSelfDescriptionByHash(dataset2.items[item].meta.sdHash);
+      const cacheIsValid = this.enableCaching && ((_a2 = this.metadataManager) == null ? void 0 : _a2.isCacheValid());
+      const hasCached = this.hasCachedData();
+      if (cacheIsValid && hasCached) {
+        return await this.getDeltaUpdatedData(targetType);
+      }
+      if (cacheIsValid && !hasCached && this.metadataManager) {
+        this.metadataManager.clear();
+      }
+      return await this.getFullData(targetType);
+    }
+    hasCachedData() {
+      try {
+        if (!this.metadataManager) {
+          return false;
+        }
+        const resource = this.metadataManager.getResource();
+        const hasResourceData = !!((resource == null ? void 0 : resource["ldp:contains"]) && resource["ldp:contains"].length > 0);
+        const metadataItemCount = this.metadataManager.getCacheStats().itemCount || 0;
+        return hasResourceData && metadataItemCount > 0;
+      } catch (error2) {
+        console.error("[FederatedCatalogueStore] Error checking cached data:", error2);
+        return false;
+      }
+    }
+    async getDeltaUpdatedData(targetType) {
+      if (!this.fcApi || !this.metadataManager) {
+        return await this.getFullData(targetType);
+      }
+      try {
+        const apiList = await this.fcApi.getAllSelfDescriptions();
+        if (!apiList || !apiList.items) {
+          console.warn("[FederatedCatalogueStore] No items returned from API");
+          return await this.getFullData(targetType);
+        }
+        const resource = this.metadataManager.getResource();
+        if (!resource) {
+          return await this.getFullData(targetType);
+        }
+        if (!resource["@id"]) {
+          resource["@id"] = targetType;
+        }
+        if (!resource["ldp:contains"]) {
+          resource["ldp:contains"] = [];
+        }
+        const knownHashes = this.metadataManager.getKnownHashes();
+        const items = (apiList == null ? void 0 : apiList.items) || [];
+        if (!Array.isArray(items)) {
+          console.warn("[FederatedCatalogueStore] apiList.items is not an array");
+          return resource;
+        }
+        const apiHashes = new Set(items.map((item) => item.meta.sdHash));
+        const newHashes = [];
+        const updatedHashes = [];
+        const deletedHashes = [];
+        for (const item of items) {
+          const hash = item.meta.sdHash;
+          if (!knownHashes.has(hash)) {
+            newHashes.push(hash);
+          } else {
+            const cachedMeta = this.metadataManager.getItemMetadata(hash);
+            if (cachedMeta) {
+              if (item.meta.uploadDatetime > cachedMeta.uploadDatetime || item.meta.statusDatetime > cachedMeta.statusDatetime) {
+                updatedHashes.push(hash);
+              }
+            }
+          }
+        }
+        for (const hash of knownHashes) {
+          if (!apiHashes.has(hash)) {
+            deletedHashes.push(hash);
+          }
+        }
+        const toFetch = [
+          ...newHashes,
+          ...updatedHashes
+        ];
+        const newMetadata = [];
+        if (toFetch.length > 0) {
+          for (const hash of toFetch) {
+            try {
+              const sd = await this.fcApi.getSelfDescriptionByHash(hash);
+              if (sd) {
+                const mappedResource = this.mapSourceToDestination(sd, {
+                  temsServiceBase: this.cfg.temsServiceBase,
+                  temsCategoryBase: this.cfg.temsCategoryBase,
+                  temsImageBase: this.cfg.temsImageBase,
+                  temsProviderBase: this.cfg.temsProviderBase
+                });
+                if (updatedHashes.includes(hash)) {
+                  const index = resource["ldp:contains"].findIndex((r) => r["@id"] === mappedResource["@id"]);
+                  if (index !== -1) {
+                    resource["ldp:contains"].splice(index, 1);
+                  }
+                }
+                resource["ldp:contains"].push(mappedResource);
+                const apiItem = apiList.items.find((i) => i.meta.sdHash === hash);
+                if (apiItem) {
+                  newMetadata.push({
+                    sdHash: hash,
+                    uploadDatetime: apiItem.meta.uploadDatetime,
+                    statusDatetime: apiItem.meta.statusDatetime,
+                    cachedAt: Date.now(),
+                    resourceId: mappedResource["@id"]
+                  });
+                }
+              }
+            } catch (error2) {
+              console.error(`[FederatedCatalogueStore] Error fetching hash ${hash}:`, error2);
+            }
+          }
+        }
+        if (deletedHashes.length > 0) {
+          this.metadataManager.removeItems(deletedHashes);
+        }
+        if (newMetadata.length > 0) {
+          this.metadataManager.updateCache(resource, newMetadata);
+        }
+        document.dispatchEvent(new CustomEvent("save", {
+          detail: {
+            resource: {
+              "@id": resource == null ? void 0 : resource["@id"]
+            }
+          },
+          bubbles: true
+        }));
+        return resource;
+      } catch (error2) {
+        console.error("[FederatedCatalogueStore] Delta update failed, falling back to full fetch:", error2);
+        return await this.getFullData(targetType);
+      }
+    }
+    async getFullData(targetType) {
+      if (!this.fcApi) {
+        throw new Error("Federated API not initialized");
+      }
+      const resource = await this.initLocalDataSourceContainer(targetType);
+      const dataset2 = await this.fcApi.getAllSelfDescriptions();
+      const newMetadata = [];
+      if ((dataset2 == null ? void 0 : dataset2.items) && Array.isArray(dataset2.items)) {
+        for (const item of dataset2.items) {
+          const sd = await this.fcApi.getSelfDescriptionByHash(item.meta.sdHash);
           if (sd) {
-            const mappedResource = this.mapSourceToDestination(sd, {
-              temsServiceBase: this.cfg.temsServiceBase,
-              temsCategoryBase: this.cfg.temsCategoryBase,
-              temsImageBase: this.cfg.temsImageBase,
-              temsProviderBase: this.cfg.temsProviderBase
-            });
-            resource["ldp:contains"].push(mappedResource);
+            try {
+              const mappedResource = this.mapSourceToDestination(sd, {
+                temsServiceBase: this.cfg.temsServiceBase,
+                temsCategoryBase: this.cfg.temsCategoryBase,
+                temsImageBase: this.cfg.temsImageBase,
+                temsProviderBase: this.cfg.temsProviderBase
+              });
+              resource["ldp:contains"].push(mappedResource);
+              if (this.enableCaching) {
+                newMetadata.push({
+                  sdHash: item.meta.sdHash,
+                  uploadDatetime: item.meta.uploadDatetime,
+                  statusDatetime: item.meta.statusDatetime,
+                  cachedAt: Date.now(),
+                  resourceId: mappedResource["@id"]
+                });
+              }
+            } catch (error2) {
+              console.error("[FederatedCatalogueStore] Error mapping resource:", error2);
+            }
           }
         }
-        this.setLocalData(resource, targetType);
+      }
+      if (this.enableCaching && this.metadataManager && newMetadata.length > 0) {
+        this.metadataManager.updateCache(resource, newMetadata);
       }
       document.dispatchEvent(new CustomEvent("save", {
         detail: {
@@ -1548,8 +1991,39 @@ let __tla = (async () => {
         bubbles: true
       }));
     }
+    stripUrnPrefix(id, prefix) {
+      if (id == null ? void 0 : id.startsWith(prefix)) {
+        return id.substring(prefix.length);
+      }
+      return id;
+    }
+    stripTemsUrnFromPolicy(obj) {
+      if (obj === null || obj === void 0) {
+        return obj;
+      }
+      if (typeof obj === "string") {
+        return this.stripUrnPrefix(obj, "urn:tems:");
+      }
+      if (Array.isArray(obj)) {
+        return obj.map((item) => this.stripTemsUrnFromPolicy(item));
+      }
+      if (typeof obj === "object") {
+        const result = {};
+        for (const key in obj) {
+          if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            if (key === "@id") {
+              result[key] = this.stripUrnPrefix(obj[key], "urn:tems:");
+            } else {
+              result[key] = this.stripTemsUrnFromPolicy(obj[key]);
+            }
+          }
+        }
+        return result;
+      }
+      return obj;
+    }
     mapSourceToDestination(src, opts) {
-      var _a2, _b, _c, _d, _e, _f, _g, _h;
+      var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j;
       const vc = src.verifiableCredential;
       const cs = vc.credentialSubject;
       let catInfo;
@@ -1560,9 +2034,16 @@ let __tla = (async () => {
         usedKey = "service";
         type = "tems:Service";
       } else if (cs["dcat:dataset"] && cs["dcat:dataset"].length > 0) {
-        catInfo = cs["dcat:dataset"][0];
-        usedKey = "dataset";
-        type = "tems:DataOffer";
+        const dataset2 = cs["dcat:dataset"][0];
+        if (dataset2["dcat:service"]) {
+          catInfo = dataset2["dcat:service"];
+          usedKey = "nested-service";
+          type = "tems:Service";
+        } else {
+          catInfo = dataset2;
+          usedKey = "dataset";
+          type = "tems:DataOffer";
+        }
       } else {
         throw new Error("Expected either credentialSubject['dcat:service'] or a non-empty array in ['dcat:dataset']");
       }
@@ -1571,7 +2052,7 @@ let __tla = (async () => {
       const serviceId = `${opts.temsServiceBase}${encodeURIComponent(slug)}/`;
       const creation_date = vc.issuanceDate;
       const update_date = vc.expirationDate;
-      const name = catInfo["dcterms:title"];
+      const name = catInfo["dcterms:title"] || catInfo["dct:title"];
       const description = catInfo["rdfs:comment"];
       const keywords = catInfo["dcat:keyword"] || [];
       const long_description = keywords.length > 0 ? `Keywords: ${keywords.join(", ")}` : "";
@@ -1611,19 +2092,24 @@ let __tla = (async () => {
       const contact_url = catInfo["dcat:endpointDescription"] || "";
       const documentation_url = contact_url || "";
       let service_url = catInfo["dcat:endpointURL"] || "";
+      if (!service_url) {
+        console.warn("[FederatedCatalogueStore] dcat:endpointURL is missing from dcat:service. Available fields:", Object.keys(catInfo));
+      }
       if (service_url.includes("demo.isan.org")) service_url = new URL(service_url).origin;
       let providerRef;
       if (usedKey === "service") {
         providerRef = ((_d = cs["gax-core:operatedBy"]) == null ? void 0 : _d["@id"]) || "";
+      } else if (usedKey === "nested-service") {
+        providerRef = ((_e = cs["gax-core:operatedBy"]) == null ? void 0 : _e["@id"]) || ((_f = cs["gax-core:offeredBy"]) == null ? void 0 : _f["@id"]) || "";
       } else {
-        providerRef = ((_e = cs["gax-core:offeredBy"]) == null ? void 0 : _e["@id"]) || "";
+        providerRef = ((_g = cs["gax-core:offeredBy"]) == null ? void 0 : _g["@id"]) || "";
       }
       const providerSlug = providerRef.split(":").pop() + String(Math.random()) || "0";
-      const providerLogo = ((_g = (_f = catInfo["dcterms:creator"]) == null ? void 0 : _f["foaf:thumbnail"]) == null ? void 0 : _g["rdf:resource"]) || "";
+      const providerLogo = ((_i = (_h = catInfo["dcterms:creator"]) == null ? void 0 : _h["foaf:thumbnail"]) == null ? void 0 : _i["rdf:resource"]) || "";
       const provider = {
         "@id": `${opts.temsProviderBase}${encodeURIComponent(providerSlug)}/`,
         "@type": "tems:Provider",
-        name: ((_h = catInfo["dcterms:creator"]) == null ? void 0 : _h["foaf:name"]) || "",
+        name: ((_j = catInfo["dcterms:creator"]) == null ? void 0 : _j["foaf:name"]) || "",
         image: {
           "@id": `${opts.temsImageBase}${encodeURIComponent(providerLogo.split("/").pop() || "0")}/`,
           "@type": "tems:Image",
@@ -1633,6 +2119,23 @@ let __tla = (async () => {
         }
       };
       const data_offers = [];
+      const counterPartyAddress = cs["dcat:endpointURL"];
+      const counterPartyId = cs["dspace:participantId"];
+      const assetId = this.stripUrnPrefix(cs["@id"], "urn:uuid:");
+      let datasetId;
+      let policy;
+      if (cs["dcat:dataset"] && cs["dcat:dataset"].length > 0) {
+        const dataset2 = cs["dcat:dataset"][0];
+        if (dataset2["@id"]) {
+          datasetId = this.stripUrnPrefix(dataset2["@id"], "urn:uuid:");
+        }
+        if (dataset2["odrl:hasPolicy"]) {
+          policy = this.stripTemsUrnFromPolicy(JSON.parse(JSON.stringify(dataset2["odrl:hasPolicy"])));
+          if (datasetId) {
+            policy.target = datasetId;
+          }
+        }
+      }
       const dest = {
         "@id": serviceId,
         creation_date,
@@ -1656,7 +2159,22 @@ let __tla = (async () => {
         url: service_url,
         provider,
         data_offers,
-        "@type": type
+        "@type": type,
+        ...counterPartyAddress && {
+          counterPartyAddress
+        },
+        ...counterPartyId && {
+          counterPartyId
+        },
+        ...assetId && {
+          assetId
+        },
+        ...datasetId && {
+          datasetId
+        },
+        ...policy && {
+          policy
+        }
       };
       return dest;
     }
@@ -28570,7 +29088,7 @@ sh:property [
       this.searchProvider = new SolidIndexingSearchProvider(this.getData.bind(this));
     }
     async initGetter() {
-      const { CustomGetter } = await import("./custom-getter-DnswwmYZ.js");
+      const { CustomGetter } = await import("./custom-getter-DFIdqwHu.js");
       return CustomGetter;
     }
     async getData(id, context2, parentId, localData, forceFetch, serverPagination, serverSearch, headers, bypassLoadingList) {
@@ -28921,7 +29439,17 @@ sh:property [
     if (window.sibStore) {
       return window.sibStore;
     }
-    const store2 = new LdpStore((_cfg == null ? void 0 : _cfg.options) || {});
+    const storeOptions = {};
+    const sibAuth = document.querySelector("sib-auth");
+    if (sibAuth) {
+      const sibAuthDefined = customElements.whenDefined(sibAuth.localName);
+      storeOptions.session = sibAuthDefined.then(() => sibAuth.session);
+      storeOptions.fetchMethod = sibAuthDefined.then(() => sibAuth.getFetch());
+    }
+    const store2 = new LdpStore({
+      ..._cfg == null ? void 0 : _cfg.options,
+      ...storeOptions
+    });
     window.sibStore = store2;
     return store2;
   }