@startinblox/core 2.0.5-beta.3 → 2.0.5-beta.5

package/dist/{store-BCbgTvQh.js → store-BJtCXbgT.js}

@@ -1,8 +1,8 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { l as isUrlOrRelativePath, m as jsonldContextParserExports, o as getRawContext, n as normalizeContext, q as mergeContexts, a as doesResourceContainList, r as requireJsonldContextParser, v as requireErrorCoded, w as requireLink } from "./helpers-Bew5Yvdt.js";
-let StoreService, formatAttributesToServerSearchOptions, base_context, hasQueryIndex, sibStore, formatAttributesToServerPaginationOptions, getDefaultExportFromCjs, hasSetLocalData, mergeServerSearchOptions, semantizer;
+import { l as isUrlOrRelativePath, m as jsonldContextParserExports, o as getRawContext, n as normalizeContext, q as mergeContexts, c as doesResourceContainList, r as requireJsonldContextParser, v as requireErrorCoded, w as requireLink } from "./helpers-vZrb1UDN.js";
+let StoreService, formatAttributesToServerSearchOptions, base_context, StoreType, StoreFactory, hasQueryIndex, formatAttributesToServerPaginationOptions, getDefaultExportFromCjs, hasSetLocalData, sibStore, mergeServerSearchOptions, semantizer;
 let __tla = (async () => {
   var _a;
   getDefaultExportFromCjs = function(x) {
@@ -86,6 +86,952 @@ let __tla = (async () => {
     const method = encodeURIComponent(options.method ?? "ibasic");
     return `${iri}${first}search-fields=${fields}&search-terms=${value}&search-method=${method}`;
   }
+  class InMemoryCacheManager {
+    constructor() {
+      __publicField(this, "resourceCache", /* @__PURE__ */ new Map());
+      __publicField(this, "urlToIdMap", /* @__PURE__ */ new Map());
+    }
+    async getByUrl(url2) {
+      const id = this.urlToIdMap.get(url2);
+      if (!id) return void 0;
+      return this.resourceCache.get(id);
+    }
+    hasUrlMatch(url2) {
+      if (!this.urlToIdMap.get(url2)) return false;
+      return true;
+    }
+    async getById(id) {
+      return this.resourceCache.get(id);
+    }
+    async get(ref) {
+      if (this.resourceCache.has(ref)) {
+        return this.resourceCache.get(ref);
+      }
+      const id = this.urlToIdMap.get(ref);
+      if (id) {
+        return this.resourceCache.get(id);
+      }
+      return void 0;
+    }
+    async length() {
+      return this.resourceCache.size;
+    }
+    async set(url2, resource) {
+      const id = resource == null ? void 0 : resource["@id"];
+      if (!id) {
+        console.warn("[CacheManager] Resource has no @id", resource);
+        return;
+      }
+      this.resourceCache.set(id, resource);
+      this.urlToIdMap.set(url2, id);
+    }
+    async linkUrlWithId(url2, emptyResource) {
+      if (!isUrlOrRelativePath(url2)) return;
+      if (this.hasUrlMatch(url2)) return;
+      await this.set(url2, emptyResource);
+    }
+    async has(urlOrId) {
+      if (this.resourceCache.has(urlOrId)) return true;
+      const id = this.urlToIdMap.get(urlOrId);
+      return id ? this.resourceCache.has(id) : false;
+    }
+    async getIdByUrl(url2) {
+      return this.urlToIdMap.get(url2);
+    }
+    async clear() {
+      this.resourceCache.clear();
+      this.urlToIdMap.clear();
+    }
+    async delete(idOrUrl) {
+      if (this.resourceCache.has(idOrUrl)) {
+        this.resourceCache.delete(idOrUrl);
+        for (const [url2, id2] of this.urlToIdMap.entries()) {
+          if (id2 === idOrUrl) {
+            this.urlToIdMap.delete(url2);
+            break;
+          }
+        }
+        return true;
+      }
+      const id = this.urlToIdMap.get(idOrUrl);
+      if (id && this.resourceCache.has(id)) {
+        this.resourceCache.delete(id);
+        this.urlToIdMap.delete(idOrUrl);
+        return true;
+      }
+      return false;
+    }
+  }
+  class DataspaceConnectorStore {
+    constructor(config) {
+      __publicField(this, "cache");
+      __publicField(this, "session");
+      __publicField(this, "headers");
+      __publicField(this, "config");
+      __publicField(this, "authToken", null);
+      __publicField(this, "contractNegotiations", /* @__PURE__ */ new Map());
+      __publicField(this, "transferProcesses", /* @__PURE__ */ new Map());
+      var _a2, _b;
+      this.validateConfig(config);
+      this.config = config;
+      this.cache = ((_a2 = config.options) == null ? void 0 : _a2.cacheManager) ?? new InMemoryCacheManager();
+      this.session = (_b = config.options) == null ? void 0 : _b.session;
+      this.headers = {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      };
+    }
+    validateConfig(config) {
+      const required = [
+        "catalogEndpoint",
+        "contractNegotiationEndpoint",
+        "transferProcessEndpoint",
+        "authMethod"
+      ];
+      const missing = required.filter((field) => !config[field]);
+      if (missing.length > 0) {
+        throw new Error(`Missing required configuration: ${missing.join(", ")}`);
+      }
+    }
+    async getData(args) {
+      if ("targetType" in args) {
+        return await this.getCatalog(args.targetType);
+      }
+      return await this.get(args.id, args.serverPagination, args.serverSearch);
+    }
+    async get(id, _serverPagination, _serverSearch) {
+      const cached = await this.cache.get(id);
+      if (cached) return cached;
+      try {
+        const resource = await this.fetchThroughDataspace(id);
+        if (resource) {
+          await this.cacheResource(id, resource);
+        }
+        return resource;
+      } catch (error2) {
+        console.error(`Failed to fetch resource ${id}:`, error2);
+        return null;
+      }
+    }
+    async getCatalog(counterPartyAddress) {
+      await this.ensureAuthenticated();
+      const catalogRequest = this.buildV3CatalogRequest(counterPartyAddress);
+      console.log("Sending v3 catalog request:", JSON.stringify(catalogRequest, null, 2));
+      const response = await this.fetchAuthn(this.config.catalogEndpoint, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify(catalogRequest)
+      });
+      if (!response.ok) {
+        console.error(`Catalog request failed: ${response.status} ${response.statusText}`);
+        const errorText = await response.text();
+        console.error("Error response:", errorText);
+        return null;
+      }
+      const catalog = await response.json();
+      if (catalog["@id"]) {
+        await this.cache.set(catalog["@id"], catalog);
+      }
+      if (catalog["dcat:dataset"] && Array.isArray(catalog["dcat:dataset"])) {
+        for (const dataset2 of catalog["dcat:dataset"]) {
+          if (dataset2["@id"]) {
+            await this.cache.set(dataset2["@id"], dataset2);
+          }
+        }
+      }
+      return catalog;
+    }
+    async negotiateContract(counterPartyAddress, _offerId, policy, counterPartyId) {
+      await this.ensureAuthenticated();
+      const negotiationRequest = {
+        "@context": {
+          "@vocab": "https://w3id.org/edc/v0.0.1/ns/"
+        },
+        "@type": "ContractRequest",
+        counterPartyAddress,
+        counterPartyId,
+        protocol: "dataspace-protocol-http",
+        policy: {
+          "@context": "http://www.w3.org/ns/odrl.jsonld",
+          "@id": policy["@id"],
+          "@type": "Offer",
+          assigner: counterPartyId || "provider",
+          target: policy.target
+        }
+      };
+      const response = await this.fetchAuthn(this.config.contractNegotiationEndpoint, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify(negotiationRequest)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error(`Contract negotiation failed: ${response.status} ${response.statusText}`, errorText);
+        throw new Error(`Contract negotiation failed: ${response.status} ${response.statusText} - ${errorText}`);
+      }
+      const negotiation = await response.json();
+      const negotiationId = negotiation["@id"];
+      this.contractNegotiations.set(negotiationId, negotiation);
+      return negotiationId;
+    }
+    initiateNegotiation(counterPartyAddress, assetId, policy, counterPartyId) {
+      return this.negotiateContract(counterPartyAddress, assetId, policy, counterPartyId);
+    }
+    getNegotiationStatus(negotiationId) {
+      return this._getNegotiationStatus(negotiationId);
+    }
+    async initiateTransfer(counterPartyAddress, contractId, dataDestination) {
+      await this.ensureAuthenticated();
+      const transferRequest = {
+        "@context": [
+          "https://w3id.org/edc/v0.0.1/ns/",
+          "https://w3id.org/dspace/2024/1/context.json"
+        ],
+        "@type": "https://w3id.org/edc/v0.0.1/ns/TransferRequestMessage",
+        counterPartyAddress,
+        contractId,
+        dataDestination
+      };
+      const response = await this.fetchAuthn(this.config.transferProcessEndpoint, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify(transferRequest)
+      });
+      if (!response.ok) {
+        throw new Error(`Transfer initiation failed: ${response.status} ${response.statusText}`);
+      }
+      const transfer = await response.json();
+      const transferId = transfer["@id"];
+      this.transferProcesses.set(transferId, transfer);
+      return transferId;
+    }
+    async fetchThroughDataspace(resourceId) {
+      try {
+        console.log(`Fetching resource through dataspace: ${resourceId}`);
+        const catalog = await this.getCatalog();
+        if (!catalog) {
+          console.error("No catalog available");
+          return null;
+        }
+        console.log("Catalog received:", catalog);
+        const dataset2 = this.findDatasetInCatalog(catalog, resourceId);
+        if (!dataset2) {
+          console.error(`Dataset ${resourceId} not found in catalog`);
+          return null;
+        }
+        console.log("Dataset found:", dataset2);
+        return catalog;
+      } catch (error2) {
+        console.error("Dataspace fetch failed:", error2);
+        return null;
+      }
+    }
+    findDatasetInCatalog(catalog, resourceId) {
+      const datasets = catalog["dcat:dataset"] || [];
+      return datasets.find((dataset2) => {
+        var _a2;
+        return dataset2["@id"] === resourceId || ((_a2 = dataset2["dcat:distribution"]) == null ? void 0 : _a2.some((dist) => dist["@id"] === resourceId));
+      }) || null;
+    }
+    async _getNegotiationStatus(negotiationId) {
+      const response = await this.fetchAuthn(`${this.config.contractNegotiationEndpoint}/${negotiationId}`, {
+        method: "GET",
+        headers: this.headers
+      });
+      return response.json();
+    }
+    async ensureAuthenticated() {
+      if (this.authToken && this.headers) return;
+      switch (this.config.authMethod) {
+        case "edc-api-key":
+          if (!this.config.edcApiKey) {
+            throw new Error("EDC API key required but not provided. Set edcApiKey in configuration.");
+          }
+          this.authToken = this.config.edcApiKey;
+          this.headers = {
+            ...this.headers,
+            "X-Api-Key": this.authToken
+          };
+          break;
+        case "bearer":
+          if (!this.config.bearerToken) {
+            throw new Error("Bearer token required but not provided");
+          }
+          this.authToken = this.config.bearerToken;
+          this.headers = {
+            ...this.headers,
+            Authorization: `Bearer ${this.authToken}`
+          };
+          break;
+        case "oauth2":
+          this.authToken = await this.getOAuth2Token();
+          this.headers = {
+            ...this.headers,
+            Authorization: `Bearer ${this.authToken}`
+          };
+          break;
+        case "delegated":
+          if (!this.config.delegatedAuthConfig) {
+            throw new Error("Delegated auth config required but not provided");
+          }
+          this.authToken = await this.getDelegatedAuthToken();
+          this.headers = {
+            ...this.headers,
+            Authorization: `Bearer ${this.authToken}`
+          };
+          break;
+      }
+    }
+    async getOAuth2Token() {
+      if (!this.config.oauth2Config) {
+        throw new Error("OAuth2 config required");
+      }
+      const { tokenEndpoint, clientId, clientSecret, scope } = this.config.oauth2Config;
+      const body = new URLSearchParams({
+        grant_type: "client_credentials",
+        client_id: clientId,
+        client_secret: clientSecret
+      });
+      if (scope) {
+        body.append("scope", scope);
+      }
+      const response = await fetch(tokenEndpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body
+      });
+      if (!response.ok) {
+        throw new Error(`OAuth2 token request failed: ${response.status}`);
+      }
+      const data = await response.json();
+      return data.access_token;
+    }
+    async getDelegatedAuthToken() {
+      if (!this.config.delegatedAuthConfig) {
+        throw new Error("Delegated auth config required");
+      }
+      const { identityProviderEndpoint, clientId, clientSecret } = this.config.delegatedAuthConfig;
+      if (!clientId || !clientSecret) {
+        throw new Error("Client ID and secret required for delegated authentication");
+      }
+      const body = new URLSearchParams({
+        grant_type: "client_credentials",
+        client_id: clientId,
+        client_secret: clientSecret
+      });
+      const response = await fetch(identityProviderEndpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body
+      });
+      if (!response.ok) {
+        throw new Error(`Delegated auth token request failed: ${response.status}`);
+      }
+      const data = await response.json();
+      return data.access_token;
+    }
+    buildV3CatalogRequest(counterPartyAddress) {
+      const apiVersion = this.config.apiVersion || "v3";
+      if (apiVersion === "v3") {
+        return {
+          "@context": {
+            "@vocab": "https://w3id.org/edc/v0.0.1/ns/",
+            edc: "https://w3id.org/edc/v0.0.1/ns/",
+            dcat: "https://www.w3.org/ns/dcat#",
+            dct: "https://purl.org/dc/terms/",
+            odrl: "http://www.w3.org/ns/odrl/2/"
+          },
+          "@type": "CatalogRequestMessage",
+          counterPartyAddress: counterPartyAddress || this.getProtocolEndpoint(),
+          protocol: "dataspace-protocol-http"
+        };
+      }
+      return {
+        "@context": [
+          "https://w3id.org/edc/v0.0.1/ns/",
+          "https://w3id.org/dspace/2024/1/context.json"
+        ],
+        "@type": "https://w3id.org/edc/v0.0.1/ns/CatalogRequestMessage",
+        counterPartyAddress: counterPartyAddress || this.config.endpoint || "",
+        protocol: "dataspace-protocol-http"
+      };
+    }
+    getProtocolEndpoint() {
+      if (this.config.endpoint) {
+        const baseUrl = this.config.endpoint.replace("/management", "");
+        return `${baseUrl}/protocol`;
+      }
+      return this.config.endpoint || "";
+    }
+    async getAssets(querySpec) {
+      await this.ensureAuthenticated();
+      const apiVersion = this.config.apiVersion || "v3";
+      const assetsEndpoint = this.config.assetsEndpoint || this.config.catalogEndpoint.replace("/catalog/request", apiVersion === "v3" ? "/assets/request" : "/assets");
+      const requestBody = querySpec || this.buildV3QuerySpec();
+      const method = apiVersion === "v3" ? "POST" : "GET";
+      const requestOptions = {
+        method,
+        headers: this.headers
+      };
+      if (method === "POST") {
+        requestOptions.body = JSON.stringify(requestBody);
+      }
+      const response = await this.fetchAuthn(assetsEndpoint, requestOptions);
+      if (!response.ok) {
+        console.error(`Assets request failed: ${response.status} ${response.statusText}`);
+        const errorText = await response.text();
+        console.error("Error response:", errorText);
+        return [];
+      }
+      const assets = await response.json();
+      const assetsArray = Array.isArray(assets) ? assets : [];
+      for (const asset of assetsArray) {
+        if (asset["@id"]) {
+          await this.cache.set(asset["@id"], asset);
+        }
+      }
+      return assetsArray;
+    }
+    async getPolicyDefinitions(querySpec) {
+      await this.ensureAuthenticated();
+      const apiVersion = this.config.apiVersion || "v3";
+      const policiesEndpoint = this.config.policiesEndpoint || this.config.catalogEndpoint.replace("/catalog/request", apiVersion === "v3" ? "/policydefinitions/request" : "/policydefinitions");
+      const requestBody = querySpec || this.buildV3QuerySpec();
+      const method = apiVersion === "v3" ? "POST" : "GET";
+      const requestOptions = {
+        method,
+        headers: this.headers
+      };
+      if (method === "POST") {
+        requestOptions.body = JSON.stringify(requestBody);
+      }
+      const response = await this.fetchAuthn(policiesEndpoint, requestOptions);
+      if (!response.ok) {
+        console.error(`Policy definitions request failed: ${response.status} ${response.statusText}`);
+        const errorText = await response.text();
+        console.error("Error response:", errorText);
+        return [];
+      }
+      const policies = await response.json();
+      const policiesArray = Array.isArray(policies) ? policies : [];
+      for (const policy of policiesArray) {
+        if (policy["@id"]) {
+          await this.cache.set(policy["@id"], policy);
+        }
+      }
+      return policiesArray;
+    }
+    async getContractDefinitions(querySpec) {
+      await this.ensureAuthenticated();
+      const apiVersion = this.config.apiVersion || "v3";
+      const contractDefsEndpoint = this.config.contractDefinitionsEndpoint || this.config.catalogEndpoint.replace("/catalog/request", apiVersion === "v3" ? "/contractdefinitions/request" : "/contractdefinitions");
+      const requestBody = querySpec || this.buildV3QuerySpec();
+      const method = apiVersion === "v3" ? "POST" : "GET";
+      const requestOptions = {
+        method,
+        headers: this.headers
+      };
+      if (method === "POST") {
+        requestOptions.body = JSON.stringify(requestBody);
+      }
+      const response = await this.fetchAuthn(contractDefsEndpoint, requestOptions);
+      if (!response.ok) {
+        console.error(`Contract definitions request failed: ${response.status} ${response.statusText}`);
+        const errorText = await response.text();
+        console.error("Error response:", errorText);
+        return [];
+      }
+      const contracts = await response.json();
+      const contractsArray = Array.isArray(contracts) ? contracts : [];
+      for (const contract of contractsArray) {
+        if (contract["@id"]) {
+          await this.cache.set(contract["@id"], contract);
+        }
+      }
+      return contractsArray;
+    }
+    buildV3QuerySpec(offset = 0, limit = 50) {
+      return {
+        "@context": {
+          "@vocab": "https://w3id.org/edc/v0.0.1/ns/",
+          edc: "https://w3id.org/edc/v0.0.1/ns/"
+        },
+        "@type": "QuerySpec",
+        offset,
+        limit,
+        filterExpression: [],
+        sortField: null,
+        sortOrder: "ASC"
+      };
+    }
+    async fetchAuthn(iri, options) {
+      await this.ensureAuthenticated();
+      return fetch(iri, {
+        ...options,
+        headers: {
+          ...this.headers,
+          ...options.headers
+        },
+        mode: "cors"
+      });
+    }
+    async post(_resource, _id, _skipFetch) {
+      await Promise.resolve();
+      throw new Error("POST not implemented for DataspaceConnectorStore");
+    }
+    async put(_resource, _id, _skipFetch) {
+      await Promise.resolve();
+      throw new Error("PUT not implemented for DataspaceConnectorStore");
+    }
+    async patch(_resource, _id, _skipFetch) {
+      await Promise.resolve();
+      throw new Error("PATCH not implemented for DataspaceConnectorStore");
+    }
+    delete(_id, _context) {
+      throw new Error("DELETE not implemented for DataspaceConnectorStore");
+    }
+    async clearCache(id) {
+      await this.cache.delete(id);
+    }
+    async cacheResource(key, resourceProxy) {
+      await this.cache.set(key, resourceProxy);
+    }
+    _getLanguage() {
+      return localStorage.getItem("language") || "en";
+    }
+    selectLanguage(selectedLanguageCode) {
+      localStorage.setItem("language", selectedLanguageCode);
+    }
+    subscribeResourceTo(_resourceId, _nestedResourceId) {
+    }
+    getExpandedPredicate(property, _context) {
+      return property;
+    }
+  }
+  const _DataspaceConnectorStoreAdapter = class _DataspaceConnectorStoreAdapter {
+    constructor() {
+    }
+    static getStoreInstance(cfg) {
+      if (!_DataspaceConnectorStoreAdapter.store) {
+        if (!cfg) {
+          throw new Error("DataspaceConnectorStore configuration is required");
+        }
+        _DataspaceConnectorStoreAdapter.store = new DataspaceConnectorStore(cfg);
+      }
+      return _DataspaceConnectorStoreAdapter.store;
+    }
+  };
+  __publicField(_DataspaceConnectorStoreAdapter, "store");
+  let DataspaceConnectorStoreAdapter = _DataspaceConnectorStoreAdapter;
+  class FederatedCatalogueAPIWrapper {
+    constructor(options, fcBaseUrl) {
+      __publicField(this, "fcBaseUrl");
+      __publicField(this, "connect");
+      this.fcBaseUrl = fcBaseUrl;
+      const connection = this.firstConnect(options);
+      this.connect = () => connection;
+    }
+    async firstConnect(options) {
+      const body = new URLSearchParams({
+        grant_type: options.kc_grant_type,
+        client_id: options.kc_client_id,
+        client_secret: options.kc_client_secret,
+        scope: options.kc_scope,
+        username: options.kc_username,
+        password: options.kc_password
+      });
+      const headers = new Headers({
+        "Content-Type": "application/x-www-form-urlencoded"
+      });
+      const response = await fetch(options.kc_url, {
+        method: "POST",
+        headers,
+        body
+      });
+      const data = await response.json();
+      const token = data.access_token;
+      if (token == null) {
+        throw new Error("connexion fails", {
+          cause: data
+        });
+      }
+      return token;
+    }
+    async getAllSelfDescriptions() {
+      console.log("Fetching all self-descriptions from Federated Catalogue...", this.fcBaseUrl);
+      const token = await this.connect();
+      console.log("Token received:", token);
+      const url2 = `${this.fcBaseUrl}/self-descriptions`;
+      const headers = new Headers({
+        Authorization: `Bearer ${token}`
+      });
+      const response = await fetch(url2, {
+        headers
+      });
+      console.log("Response status:", response.status);
+      return await response.json();
+    }
+    async getSelfDescriptionByHash(sdHash) {
+      const token = await this.connect();
+      const url2 = `${this.fcBaseUrl}/self-descriptions/${sdHash}`;
+      const headers = new Headers({
+        Authorization: `Bearer ${token}`
+      });
+      const response = await fetch(url2, {
+        method: "GET",
+        headers
+      });
+      if (!response.ok) throw new Error(`GET /self-descriptions/${sdHash} failed: ${response.status} ${response.statusText}`, {
+        cause: response
+      });
+      return await response.json();
+    }
+    async postQuery(statement, parameters = {}) {
+      const token = await this.connect();
+      const url2 = `${this.fcBaseUrl}/query`;
+      const headers = new Headers({
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      });
+      const body = JSON.stringify({
+        statement,
+        parameters
+      });
+      const response = await fetch(url2, {
+        method: "POST",
+        headers,
+        body
+      });
+      if (!response.ok) {
+        throw new Error(`[ERROR] POST /query failed: ${response.status} ${response.statusText}`, {
+          cause: response
+        });
+      }
+      return await response.json();
+    }
+    async postQuerySearch(statement, parameters = {}, queryLanguage = "OPENCYPHER", annotations) {
+      const token = await this.connect();
+      const url2 = `${this.fcBaseUrl}/query/search`;
+      const headers = new Headers({
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      });
+      const body = JSON.stringify({
+        statement,
+        parameters,
+        annotations: annotations || {
+          queryLanguage
+        }
+      });
+      const response = await fetch(url2, {
+        method: "POST",
+        headers,
+        body
+      });
+      if (!response.ok) {
+        throw new Error(`[ERROR] POST /query/search failed: ${response.status} ${response.statusText}`, {
+          cause: response
+        });
+      }
+      return await response.json();
+    }
+  }
+  function getFederatedCatalogueAPIWrapper(baseUrl, optionLogin, optionsServer) {
+    const options = Object.assign({}, optionsServer, optionLogin);
+    return new FederatedCatalogueAPIWrapper(options, baseUrl);
+  }
+  class FederatedCatalogueStore {
+    constructor(cfg) {
+      __publicField(this, "cache");
+      __publicField(this, "session");
+      __publicField(this, "fcApi");
+      this.cfg = cfg;
+      if (!this.cfg.login) {
+        throw new Error("Login must be provided for FederatedCatalogueStore");
+      }
+      if (!this.cfg.endpoint) {
+        throw new Error("Missing required `endpoint` in StoreConfig for FederatedCatalogueStore");
+      }
+      if (!this.cfg.optionsServer) {
+        throw new Error("Missing required `optionsServer` in StoreConfig for FederatedCatalogueStore");
+      }
+      this.fcApi = getFederatedCatalogueAPIWrapper(this.cfg.endpoint, this.cfg.login, this.cfg.optionsServer);
+      this.cache = new InMemoryCacheManager();
+    }
+    async getData(args) {
+      const targetType = "targetType" in args ? args.targetType : args.id;
+      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();
+        for (const item in dataset2.items) {
+          const sd = await this.fcApi.getSelfDescriptionByHash(dataset2.items[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);
+          }
+        }
+        this.setLocalData(resource, targetType);
+      }
+      document.dispatchEvent(new CustomEvent("save", {
+        detail: {
+          resource: {
+            "@id": resource["@id"]
+          }
+        },
+        bubbles: true
+      }));
+      return resource;
+    }
+    async initLocalDataSourceContainer(dataSrc = "", containerType = "default") {
+      var _a2;
+      const endpointHash = ((_a2 = this.cfg.endpoint) == null ? void 0 : _a2.replace(/[^a-zA-Z0-9]/g, "")) || "unknown";
+      const idField = `fc-${endpointHash}-${containerType}`;
+      if (!dataSrc) {
+        dataSrc = `store://local.${idField}/`;
+      }
+      const localContainer = {
+        "@context": "https://cdn.startinblox.com/owl/context.jsonld",
+        "@type": "ldp:Container",
+        "@id": dataSrc,
+        "ldp:contains": new Array(),
+        permissions: [
+          "view"
+        ]
+      };
+      await this.setLocalData(localContainer, dataSrc);
+      return localContainer;
+    }
+    async get(id, _serverPagination, _serverSearch) {
+      try {
+        const resource = await this.cache.get(id);
+        return resource || null;
+      } catch (error2) {
+        console.error(`[FederatedCatalogueStore] Error getting resource ${id}:`, error2);
+        return null;
+      }
+    }
+    post(_resource, _id, _skipFetch) {
+      return Promise.resolve(null);
+    }
+    put(_resource, _id, _skipFetch) {
+      return Promise.resolve(null);
+    }
+    patch(_resource, _id, _skipFetch) {
+      return Promise.resolve(null);
+    }
+    delete(_id, _context) {
+      return Promise.resolve(null);
+    }
+    async clearCache(id) {
+      try {
+        if (await this.cache.has(id)) {
+          await this.cache.delete(id);
+          console.log(`[FederatedCatalogueStore] Cleared cache for ${id}`);
+        }
+      } catch (error2) {
+        console.error(`[FederatedCatalogueStore] Error clearing cache for ${id}:`, error2);
+      }
+    }
+    async cacheResource(key, resourceProxy) {
+      try {
+        await this.cache.set(key, resourceProxy);
+        console.log(`[FederatedCatalogueStore] Cached resource ${key}`);
+      } catch (error2) {
+        console.error(`[FederatedCatalogueStore] Error caching resource ${key}:`, error2);
+      }
+    }
+    _getLanguage() {
+      return "";
+    }
+    selectLanguage(_selectedLanguageCode) {
+    }
+    getExpandedPredicate(_property, _context) {
+      return null;
+    }
+    subscribeResourceTo(_resourceId, _nestedResourceId) {
+    }
+    fetchAuthn(_iri, _options) {
+      return Promise.resolve({});
+    }
+    async setLocalData(resource, id, _skipFetch) {
+      try {
+        const resourceWithId = {
+          ...resource,
+          "@id": id
+        };
+        await this.cache.set(id, resourceWithId);
+        console.log(`[FederatedCatalogueStore] Stored local data for ${id}`);
+        this.notifyComponents(id, resourceWithId);
+        return id;
+      } catch (error2) {
+        console.error(`[FederatedCatalogueStore] Error storing local data for ${id}:`, error2);
+        return null;
+      }
+    }
+    notifyComponents(id, resource) {
+      document.dispatchEvent(new CustomEvent("resoureReady", {
+        detail: {
+          id,
+          resource,
+          fetchedResource: resource
+        },
+        bubbles: true
+      }));
+    }
+    mapSourceToDestination(src, opts) {
+      var _a2, _b, _c, _d, _e, _f, _g, _h;
+      const vc = src.verifiableCredential;
+      const cs = vc.credentialSubject;
+      let catInfo;
+      let usedKey;
+      let type;
+      if (cs["dcat:service"]) {
+        catInfo = cs["dcat:service"];
+        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";
+      } else {
+        throw new Error("Expected either credentialSubject['dcat:service'] or a non-empty array in ['dcat:dataset']");
+      }
+      const resourceId = cs["@id"];
+      const slug = resourceId.split("/").pop() || "unknown";
+      const serviceId = `${opts.temsServiceBase}${encodeURIComponent(slug)}/`;
+      const creation_date = vc.issuanceDate;
+      const update_date = vc.expirationDate;
+      const name = catInfo["dcterms:title"];
+      const description = catInfo["rdfs:comment"];
+      const keywords = catInfo["dcat:keyword"] || [];
+      const long_description = keywords.length > 0 ? `Keywords: ${keywords.join(", ")}` : "";
+      const categories = {
+        "@id": `${serviceId}categories/`,
+        "@type": "ldp:Container",
+        "ldp:contains": keywords.map((kw) => ({
+          "@id": `${opts.temsCategoryBase}${encodeURIComponent(kw)}/`,
+          "@type": "tems:Category",
+          name: kw
+        }))
+      };
+      const endpointURL = catInfo["dcat:endpointURL"] || "";
+      const hasEndpoint = endpointURL.trim().length > 0;
+      const activation_status = hasEndpoint;
+      const is_in_app = hasEndpoint;
+      const is_external = hasEndpoint;
+      const is_api = hasEndpoint;
+      const imageUrls = [];
+      if ((_a2 = catInfo["foaf:thumbnail"]) == null ? void 0 : _a2["rdf:resource"]) {
+        imageUrls.push(catInfo["foaf:thumbnail"]["rdf:resource"]);
+      }
+      if ((_c = (_b = catInfo["dcterms:creator"]) == null ? void 0 : _b["foaf:thumbnail"]) == null ? void 0 : _c["rdf:resource"]) {
+        imageUrls.push(catInfo["dcterms:creator"]["foaf:thumbnail"]["rdf:resource"]);
+      }
+      const images = {
+        "@id": `${serviceId}images/`,
+        "@type": "ldp:Container",
+        "ldp:contains": imageUrls.map((url2) => ({
+          "@id": `${opts.temsImageBase}${encodeURIComponent(url2.split("/").pop() || "0")}/`,
+          url: url2,
+          iframe: false,
+          name: url2.split("/").pop() || "image",
+          "@type": "tems:Image"
+        }))
+      };
+      const contact_url = catInfo["dcat:endpointDescription"] || "";
+      const documentation_url = contact_url || "";
+      let service_url = catInfo["dcat:endpointURL"] || "";
+      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 {
+        providerRef = ((_e = cs["gax-core:offeredBy"]) == null ? void 0 : _e["@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 provider = {
+        "@id": `${opts.temsProviderBase}${encodeURIComponent(providerSlug)}/`,
+        "@type": "tems:Provider",
+        name: ((_h = catInfo["dcterms:creator"]) == null ? void 0 : _h["foaf:name"]) || "",
+        image: {
+          "@id": `${opts.temsImageBase}${encodeURIComponent(providerLogo.split("/").pop() || "0")}/`,
+          "@type": "tems:Image",
+          iframe: false,
+          url: providerLogo,
+          name: providerLogo.split("/").pop() || "provider-logo"
+        }
+      };
+      const data_offers = [];
+      const dest = {
+        "@id": serviceId,
+        creation_date,
+        update_date,
+        name,
+        description,
+        long_description,
+        categories,
+        activation_status,
+        activation_date: null,
+        licence: null,
+        is_in_app,
+        is_external,
+        is_api,
+        images,
+        release_date: null,
+        last_update: null,
+        developper: null,
+        contact_url,
+        documentation_url,
+        url: service_url,
+        provider,
+        data_offers,
+        "@type": type
+      };
+      return dest;
+    }
+  }
+  const _FederatedCatalogueStoreAdapter = class _FederatedCatalogueStoreAdapter {
+    constructor() {
+    }
+    static validateConfiguration(cfg) {
+      const requiredFields = [
+        "temsServiceBase",
+        "temsCategoryBase",
+        "temsImageBase",
+        "temsProviderBase"
+      ];
+      const missingFields = requiredFields.filter((field) => !cfg[field]);
+      if (missingFields.length > 0) {
+        throw new Error(`[FederatedCatalogueStoreAdapter] Missing required configuration fields: ${missingFields.join(", ")}`);
+      }
+    }
+    static getStoreInstance(cfg) {
+      if (!_FederatedCatalogueStoreAdapter.store) {
+        if (!cfg) {
+          throw new Error("[FederatedCatalogueStoreAdapter] configuration is required");
+        }
+        _FederatedCatalogueStoreAdapter.validateConfiguration(cfg);
+        _FederatedCatalogueStoreAdapter.store = new FederatedCatalogueStore(cfg);
+      }
+      return _FederatedCatalogueStoreAdapter.store;
+    }
+  };
+  __publicField(_FederatedCatalogueStoreAdapter, "store");
+  let FederatedCatalogueStoreAdapter = _FederatedCatalogueStoreAdapter;
   var lib = {};
   var IdentifierIssuer_1;
   var hasRequiredIdentifierIssuer;
@@ -8449,105 +9395,29 @@ let __tla = (async () => {
           for (m in messages) {
             if (Object.prototype.hasOwnProperty.call(messages, m)) {
               message = messages[m];
-              if (isToken && message[value]) {
-                delete message[value];
-                result = value;
-                break;
-              }
-              if (isFunction) {
-                for (t in message) {
-                  if (Object.prototype.hasOwnProperty.call(message, t) && message[t] === value) {
-                    delete message[t];
-                    result = true;
-                  }
-                }
-              }
-            }
-          }
-          return result;
-        };
-      });
-    })(pubsub$1, pubsub$1.exports);
-    return pubsub$1.exports;
-  }
-  var pubsubExports = requirePubsub();
-  const PubSub = getDefaultExportFromCjs(pubsubExports);
-  class InMemoryCacheManager {
-    constructor() {
-      __publicField(this, "resourceCache", /* @__PURE__ */ new Map());
-      __publicField(this, "urlToIdMap", /* @__PURE__ */ new Map());
-    }
-    async getByUrl(url2) {
-      const id = this.urlToIdMap.get(url2);
-      if (!id) return void 0;
-      return this.resourceCache.get(id);
-    }
-    hasUrlMatch(url2) {
-      if (!this.urlToIdMap.get(url2)) return false;
-      return true;
-    }
-    async getById(id) {
-      return this.resourceCache.get(id);
-    }
-    async get(ref) {
-      if (this.resourceCache.has(ref)) {
-        return this.resourceCache.get(ref);
-      }
-      const id = this.urlToIdMap.get(ref);
-      if (id) {
-        return this.resourceCache.get(id);
-      }
-      return void 0;
-    }
-    async length() {
-      return this.resourceCache.size;
-    }
-    async set(url2, resource) {
-      const id = resource == null ? void 0 : resource["@id"];
-      if (!id) {
-        console.warn("[CacheManager] Resource has no @id", resource);
-        return;
-      }
-      this.resourceCache.set(id, resource);
-      this.urlToIdMap.set(url2, id);
-    }
-    async linkUrlWithId(url2, emptyResource) {
-      if (!isUrlOrRelativePath(url2)) return;
-      if (this.hasUrlMatch(url2)) return;
-      await this.set(url2, emptyResource);
-    }
-    async has(urlOrId) {
-      if (this.resourceCache.has(urlOrId)) return true;
-      const id = this.urlToIdMap.get(urlOrId);
-      return id ? this.resourceCache.has(id) : false;
-    }
-    async getIdByUrl(url2) {
-      return this.urlToIdMap.get(url2);
-    }
-    async clear() {
-      this.resourceCache.clear();
-      this.urlToIdMap.clear();
-    }
-    async delete(idOrUrl) {
-      if (this.resourceCache.has(idOrUrl)) {
-        this.resourceCache.delete(idOrUrl);
-        for (const [url2, id2] of this.urlToIdMap.entries()) {
-          if (id2 === idOrUrl) {
-            this.urlToIdMap.delete(url2);
-            break;
+              if (isToken && message[value]) {
+                delete message[value];
+                result = value;
+                break;
+              }
+              if (isFunction) {
+                for (t in message) {
+                  if (Object.prototype.hasOwnProperty.call(message, t) && message[t] === value) {
+                    delete message[t];
+                    result = true;
+                  }
+                }
+              }
+            }
           }
-        }
-        return true;
-      }
-      const id = this.urlToIdMap.get(idOrUrl);
-      if (id && this.resourceCache.has(id)) {
-        this.resourceCache.delete(id);
-        this.urlToIdMap.delete(idOrUrl);
-        return true;
-      }
-      return false;
-    }
+          return result;
+        };
+      });
+    })(pubsub$1, pubsub$1.exports);
+    return pubsub$1.exports;
   }
+  var pubsubExports = requirePubsub();
+  const PubSub = getDefaultExportFromCjs(pubsubExports);
   var events = {
     exports: {}
   };
@@ -27093,7 +27963,7 @@ sh:property [
       this.searchProvider = new SolidIndexingSearchProvider(this.getData.bind(this));
     }
     async initGetter() {
-      const { CustomGetter } = await import("./custom-getter-BvGSkLWj.js");
+      const { CustomGetter } = await import("./custom-getter-FYE7WERU.js");
       return CustomGetter;
     }
     async getData(id, context2, parentId, localData, forceFetch, serverPagination, serverSearch, headers, bypassLoadingList) {
@@ -27347,8 +28217,8 @@ sh:property [
         await this.cache.delete(id);
       }
     }
-    setLocalData(resource, id, skipFetch = false, bypassLoadingList = false) {
-      return this._updateResource("_LOCAL", resource, id, skipFetch, bypassLoadingList);
+    setLocalData(resource, id, skipFetch = false) {
+      return this._updateResource("_LOCAL", resource, id, skipFetch);
     }
     post(resource, id, skipFetch = false) {
       return this._updateResource("POST", resource, id, skipFetch);
@@ -27466,373 +28336,12 @@ sh:property [
   hasSetLocalData = function(store2) {
     return "setLocalData" in store2 && typeof store2.setLocalData === "function";
   };
-  var StoreType = ((StoreType2) => {
+  StoreType = ((StoreType2) => {
     StoreType2["LDP"] = "ldp";
     StoreType2["FederatedCatalogue"] = "federatedCatalogue";
+    StoreType2["DataspaceConnector"] = "dataspaceConnector";
     return StoreType2;
   })(StoreType || {});
-  class FederatedCatalogueAPIWrapper {
-    constructor(options, fcBaseUrl) {
-      __publicField(this, "fcBaseUrl");
-      __publicField(this, "connect");
-      this.fcBaseUrl = fcBaseUrl;
-      const connection = this.firstConnect(options);
-      this.connect = () => connection;
-    }
-    async firstConnect(options) {
-      const body = new URLSearchParams({
-        grant_type: options.kc_grant_type,
-        client_id: options.kc_client_id,
-        client_secret: options.kc_client_secret,
-        scope: options.kc_scope,
-        username: options.kc_username,
-        password: options.kc_password
-      });
-      const headers = new Headers({
-        "Content-Type": "application/x-www-form-urlencoded"
-      });
-      const response = await fetch(options.kc_url, {
-        method: "POST",
-        headers,
-        body
-      });
-      const data = await response.json();
-      const token = data.access_token;
-      if (token == null) {
-        throw new Error("connexion fails", {
-          cause: data
-        });
-      }
-      return token;
-    }
-    async getAllSelfDescriptions() {
-      console.log("Fetching all self-descriptions from Federated Catalogue...", this.fcBaseUrl);
-      const token = await this.connect();
-      console.log("Token received:", token);
-      const url2 = `${this.fcBaseUrl}/self-descriptions`;
-      const headers = new Headers({
-        Authorization: `Bearer ${token}`
-      });
-      const response = await fetch(url2, {
-        headers
-      });
-      console.log("Response status:", response.status);
-      return await response.json();
-    }
-    async getSelfDescriptionByHash(sdHash) {
-      const token = await this.connect();
-      const url2 = `${this.fcBaseUrl}/self-descriptions/${sdHash}`;
-      const headers = new Headers({
-        Authorization: `Bearer ${token}`
-      });
-      const response = await fetch(url2, {
-        method: "GET",
-        headers
-      });
-      if (!response.ok) throw new Error(`GET /self-descriptions/${sdHash} failed: ${response.status} ${response.statusText}`, {
-        cause: response
-      });
-      return await response.json();
-    }
-    async postQuery(statement, parameters = {}) {
-      const token = await this.connect();
-      const url2 = `${this.fcBaseUrl}/query`;
-      const headers = new Headers({
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json"
-      });
-      const body = JSON.stringify({
-        statement,
-        parameters
-      });
-      const response = await fetch(url2, {
-        method: "POST",
-        headers,
-        body
-      });
-      if (!response.ok) {
-        throw new Error(`[ERROR] POST /query failed: ${response.status} ${response.statusText}`, {
-          cause: response
-        });
-      }
-      return await response.json();
-    }
-    async postQuerySearch(statement, parameters = {}, queryLanguage = "OPENCYPHER", annotations) {
-      const token = await this.connect();
-      const url2 = `${this.fcBaseUrl}/query/search`;
-      const headers = new Headers({
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json"
-      });
-      const body = JSON.stringify({
-        statement,
-        parameters,
-        annotations: annotations || {
-          queryLanguage
-        }
-      });
-      const response = await fetch(url2, {
-        method: "POST",
-        headers,
-        body
-      });
-      if (!response.ok) {
-        throw new Error(`[ERROR] POST /query/search failed: ${response.status} ${response.statusText}`, {
-          cause: response
-        });
-      }
-      return await response.json();
-    }
-  }
-  function getFederatedCatalogueAPIWrapper(baseUrl, optionLogin, optionsServer) {
-    const options = Object.assign({}, optionsServer, optionLogin);
-    return new FederatedCatalogueAPIWrapper(options, baseUrl);
-  }
-  function mapSourceToDestination(src, opts) {
-    var _a2, _b, _c, _d, _e, _f, _g, _h;
-    const vc = src.verifiableCredential;
-    const cs = vc.credentialSubject;
-    let catInfo;
-    let usedKey;
-    let type;
-    if (cs["dcat:service"]) {
-      catInfo = cs["dcat:service"];
-      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";
-    } else {
-      throw new Error("Expected either credentialSubject['dcat:service'] or a non-empty array in ['dcat:dataset']");
-    }
-    const resourceId = cs["@id"];
-    const slug = resourceId.split("/").pop() || "unknown";
-    const serviceId = `${opts.temsServiceBase}${encodeURIComponent(slug)}/`;
-    const creation_date = vc.issuanceDate;
-    const update_date = vc.expirationDate;
-    const name = catInfo["dcterms:title"];
-    const description = catInfo["rdfs:comment"];
-    const keywords = catInfo["dcat:keyword"] || [];
-    const long_description = keywords.length > 0 ? `Keywords: ${keywords.join(", ")}` : "";
-    const categories = {
-      "@id": `${serviceId}categories/`,
-      "@type": "ldp:Container",
-      "ldp:contains": keywords.map((kw) => ({
-        "@id": `${opts.temsCategoryBase}${encodeURIComponent(kw)}/`,
-        "@type": "tems:Category",
-        name: kw
-      }))
-    };
-    const endpointURL = catInfo["dcat:endpointURL"] || "";
-    const hasEndpoint = endpointURL.trim().length > 0;
-    const activation_status = hasEndpoint;
-    const is_in_app = hasEndpoint;
-    const is_external = hasEndpoint;
-    const is_api = hasEndpoint;
-    const imageUrls = [];
-    if ((_a2 = catInfo["foaf:thumbnail"]) == null ? void 0 : _a2["rdf:resource"]) {
-      imageUrls.push(catInfo["foaf:thumbnail"]["rdf:resource"]);
-    }
-    if ((_c = (_b = catInfo["dcterms:creator"]) == null ? void 0 : _b["foaf:thumbnail"]) == null ? void 0 : _c["rdf:resource"]) {
-      imageUrls.push(catInfo["dcterms:creator"]["foaf:thumbnail"]["rdf:resource"]);
-    }
-    const images = {
-      "@id": `${serviceId}images/`,
-      "@type": "ldp:Container",
-      "ldp:contains": imageUrls.map((url2) => ({
-        "@id": `${opts.temsImageBase}${encodeURIComponent(url2.split("/").pop() || "0")}/`,
-        url: url2,
-        iframe: false,
-        name: url2.split("/").pop() || "image",
-        "@type": "tems:Image"
-      }))
-    };
-    const contact_url = catInfo["dcat:endpointDescription"] || "";
-    const documentation_url = contact_url || "";
-    let service_url = catInfo["dcat:endpointURL"] || "";
-    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 {
-      providerRef = ((_e = cs["gax-core:offeredBy"]) == null ? void 0 : _e["@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 provider = {
-      "@id": `${opts.temsProviderBase}${encodeURIComponent(providerSlug)}/`,
-      "@type": "tems:Provider",
-      name: ((_h = catInfo["dcterms:creator"]) == null ? void 0 : _h["foaf:name"]) || "",
-      image: {
-        "@id": `${opts.temsImageBase}${encodeURIComponent(providerLogo.split("/").pop() || "0")}/`,
-        "@type": "tems:Image",
-        iframe: false,
-        url: providerLogo,
-        name: providerLogo.split("/").pop() || "provider-logo"
-      }
-    };
-    const data_offers = [];
-    const dest = {
-      "@id": serviceId,
-      creation_date,
-      update_date,
-      name,
-      description,
-      long_description,
-      categories,
-      activation_status,
-      activation_date: null,
-      licence: null,
-      is_in_app,
-      is_external,
-      is_api,
-      images,
-      release_date: null,
-      last_update: null,
-      developper: null,
-      contact_url,
-      documentation_url,
-      url: service_url,
-      provider,
-      data_offers,
-      "@type": type
-    };
-    return dest;
-  }
-  async function initLocalDataSourceContainer() {
-    const idField = Array.from(Array(20), () => Math.floor(Math.random() * 36).toString(36)).join("");
-    const dataSrc = `store://local.${idField}/`;
-    const localContainer = {
-      "@context": "https://cdn.startinblox.com/owl/context.jsonld",
-      "@type": "ldp:Container",
-      "@id": dataSrc,
-      "ldp:contains": new Array(),
-      permissions: [
-        "view"
-      ]
-    };
-    return localContainer;
-  }
-  class FederatedCatalogueStore {
-    constructor(cfg) {
-      __publicField(this, "cache");
-      __publicField(this, "session");
-      __publicField(this, "fcApi");
-      __publicField(this, "fcContainer");
-      this.cfg = cfg;
-      if (!this.cfg.login) {
-        throw new Error("Login must be provided for FederatedCatalogueStore");
-      }
-      if (!this.cfg.endpoint) {
-        throw new Error("Missing required `endpoint` in StoreConfig for FederatedCatalogueStore");
-      }
-      if (!this.cfg.optionsServer) {
-        throw new Error("Missing required `optionsServer` in StoreConfig for FederatedCatalogueStore");
-      }
-      this.fcApi = getFederatedCatalogueAPIWrapper(this.cfg.endpoint, this.cfg.login, this.cfg.optionsServer);
-      this.fcContainer = void 0;
-      this.cache = new InMemoryCacheManager();
-    }
-    async getData(args) {
-      const targetType = "targetType" in args ? args.targetType : args.id;
-      if (!this.fcApi) {
-        throw new Error("Federated API not initialized, returning empty data.");
-      }
-      if (!this.fcContainer || this.fcContainer["ldp:contains"].length === 0) {
-        this.fcContainer = await initLocalDataSourceContainer();
-        const dataset2 = await this.fcApi.getAllSelfDescriptions();
-        for (const item in dataset2.items) {
-          const sd = await this.fcApi.getSelfDescriptionByHash(dataset2.items[item].meta.sdHash);
-          if (sd) {
-            const resource = mapSourceToDestination(sd, {
-              temsServiceBase: this.cfg.temsServiceBase,
-              temsCategoryBase: this.cfg.temsCategoryBase,
-              temsImageBase: this.cfg.temsImageBase,
-              temsProviderBase: this.cfg.temsProviderBase
-            });
-            if (!this.fcContainer["ldp:contains"].some((r) => r["@id"] === resource["@id"])) {
-              this.fcContainer["ldp:contains"].push(resource);
-            }
-          }
-        }
-      }
-      const localContainer = await initLocalDataSourceContainer();
-      localContainer["ldp:contains"] = this.fcContainer["ldp:contains"].filter((item) => item["@type"] === targetType);
-      document.dispatchEvent(new CustomEvent("save", {
-        detail: {
-          resource: {
-            "@id": this.fcContainer["@id"]
-          }
-        },
-        bubbles: true
-      }));
-      return localContainer;
-    }
-    get(_id, _serverPagination, _serverSearch) {
-      return Promise.resolve(null);
-    }
-    post(_resource, _id, _skipFetch) {
-      return Promise.resolve(null);
-    }
-    put(_resource, _id, _skipFetch) {
-      return Promise.resolve(null);
-    }
-    patch(_resource, _id, _skipFetch) {
-      return Promise.resolve(null);
-    }
-    delete(_id, _context) {
-      return Promise.resolve(null);
-    }
-    clearCache(_id) {
-      return Promise.resolve();
-    }
-    cacheResource(_key, _resourceProxy) {
-      return Promise.resolve();
-    }
-    _getLanguage() {
-      return "";
-    }
-    selectLanguage(_selectedLanguageCode) {
-    }
-    getExpandedPredicate(_property, _context) {
-      return null;
-    }
-    subscribeResourceTo(_resourceId, _nestedResourceId) {
-    }
-    fetchAuthn(_iri, _options) {
-      return Promise.resolve({});
-    }
-  }
-  const _FederatedCatalogueStoreAdapter = class _FederatedCatalogueStoreAdapter {
-    constructor() {
-    }
-    static validateConfiguration(cfg) {
-      const requiredFields = [
-        "temsServiceBase",
-        "temsCategoryBase",
-        "temsImageBase",
-        "temsProviderBase"
-      ];
-      const missingFields = requiredFields.filter((field) => !cfg[field]);
-      if (missingFields.length > 0) {
-        throw new Error(`[FederatedCatalogueStoreAdapter] Missing required configuration fields: ${missingFields.join(", ")}`);
-      }
-    }
-    static getStoreInstance(cfg) {
-      if (!_FederatedCatalogueStoreAdapter.store) {
-        if (!cfg) {
-          throw new Error("[FederatedCatalogueStoreAdapter] configuration is required");
-        }
-        _FederatedCatalogueStoreAdapter.validateConfiguration(cfg);
-        _FederatedCatalogueStoreAdapter.store = new FederatedCatalogueStore(cfg);
-      }
-      return _FederatedCatalogueStoreAdapter.store;
-    }
-  };
-  __publicField(_FederatedCatalogueStoreAdapter, "store");
-  let FederatedCatalogueStoreAdapter = _FederatedCatalogueStoreAdapter;
-  var StoreFactory;
   ((StoreFactory2) => {
     const registry = /* @__PURE__ */ new Map();
     function register(name, adapter) {
@@ -27848,6 +28357,7 @@ sh:property [
   })(StoreFactory || (StoreFactory = {}));
   StoreFactory.register(StoreType.LDP, LdpStoreAdapter);
   StoreFactory.register(StoreType.FederatedCatalogue, FederatedCatalogueStoreAdapter);
+  StoreFactory.register(StoreType.DataspaceConnector, DataspaceConnectorStoreAdapter);
   StoreService = (_a = class {
     static init(config) {
       if (StoreService.currentStore) {
@@ -31929,11 +32439,13 @@ export {
   __tla,
   formatAttributesToServerSearchOptions as a,
   base_context as b,
-  hasQueryIndex as c,
-  sibStore as d,
+  StoreType as c,
+  StoreFactory as d,
+  hasQueryIndex as e,
   formatAttributesToServerPaginationOptions as f,
   getDefaultExportFromCjs as g,
   hasSetLocalData as h,
+  sibStore as i,
   mergeServerSearchOptions as m,
   semantizer as s
 };