cocoda-sdk 3.4.13 → 3.6.0

package/dist/cjs/index.cjs

@@ -27,8 +27,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.js
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   BaseProvider: () => BaseProvider,
   CocodaSDK: () => CocodaSDK,
   ConceptApiProvider: () => ConceptApiProvider,
@@ -37,9 +37,11 @@ __export(src_exports, {
   LocApiProvider: () => LocApiProvider,
   LocalMappingsProvider: () => LocalMappingsProvider,
   MappingsApiProvider: () => MappingsApiProvider,
+  ModApiProvider: () => ModApiProvider,
   MyCoReProvider: () => MyCoReProvider,
   NoTApiProvider: () => NoTApiProvider,
   OccurrencesApiProvider: () => OccurrencesApiProvider,
+  OlsApiProvider: () => OlsApiProvider,
   ReconciliationApiProvider: () => ReconciliationApiProvider,
   SkohubProvider: () => SkohubProvider,
   SkosmosApiProvider: () => SkosmosApiProvider,
@@ -48,7 +50,7 @@ __export(src_exports, {
   errors: () => errors_exports,
   utils: () => utils_exports
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
 // src/errors/index.js
 var errors_exports = {};
@@ -154,9 +156,11 @@ __export(providers_exports, {
   LocApiProvider: () => LocApiProvider,
   LocalMappingsProvider: () => LocalMappingsProvider,
   MappingsApiProvider: () => MappingsApiProvider,
+  ModApiProvider: () => ModApiProvider,
   MyCoReProvider: () => MyCoReProvider,
   NoTApiProvider: () => NoTApiProvider,
   OccurrencesApiProvider: () => OccurrencesApiProvider,
+  OlsApiProvider: () => OlsApiProvider,
   ReconciliationApiProvider: () => ReconciliationApiProvider,
   SkohubProvider: () => SkohubProvider,
   SkosmosApiProvider: () => SkosmosApiProvider
@@ -355,7 +359,7 @@ var BaseProvider = class {
     this._jskos = registry;
     this.axios = import_axios.default.create({
       // TODO: Decide on timeout value
-      timeout: 2e4
+      timeout: 2e5
     });
     this._path = typeof window !== "undefined" && window.location.pathname;
     this.has = {};
@@ -500,6 +504,7 @@ var BaseProvider = class {
               }
               throw new NetworkError({ relatedError: error });
             } else {
+              console.error(error);
               throw new CDKError({ relatedError: error });
             }
           }
@@ -633,6 +638,34 @@ var BaseProvider = class {
       }
     }, config);
   }
+  /**
+   * Returns suggestion result in OpenSearch Suggest Format.
+   *
+   * @param {Object} config
+   * @param {string} config.search search string
+   * @param {Object} [config.scheme] concept scheme to search in
+   * @param {number} [config.limit=100] maximum number of search results (default might be overridden by registry)
+   * @param {string[]} [config.types=[]] list of type URIs
+   * @returns {Array} result in OpenSearch Suggest Format
+   */
+  async suggest(config) {
+    config._raw = true;
+    const concepts = await this.search(config);
+    const result = [config.search, [], [], []];
+    for (let concept of concepts) {
+      const notation = import_jskos_tools.default.notation(concept);
+      const label = import_jskos_tools.default.prefLabel(concept);
+      result[1].push((notation ? notation + " " : "") + label);
+      result[2].push("");
+      result[3].push(concept.uri);
+    }
+    if (concepts._totalCount != void 0) {
+      result._totalCount = concepts._totalCount;
+    } else {
+      result._totalCount = concepts.length;
+    }
+    return result;
+  }
   /**
    * Returns whether a user is authorized for a certain request.
    *
@@ -1894,6 +1927,8 @@ OccurrencesApiProvider.stored = false;
 // src/providers/concept-api-provider.js
 var import_jskos_tools5 = __toESM(require("jskos-tools"), 1);
 var ConceptApiProvider = class extends BaseProvider {
+  static providerName = "ConceptApi";
+  static providerType = "http://bartoc.org/api-type/jskos";
   static supports = {
     schemes: true,
     top: true,
@@ -2075,7 +2110,8 @@ var ConceptApiProvider = class extends BaseProvider {
    * @returns {Object[]} array of JSKOS concept objects
    */
   async getConcepts({ concepts, ...config }) {
-    if (this.has.data === false) {
+    const url = this._api.concepts || this._api.data;
+    if (!url) {
       throw new MissingApiUrlError();
     }
     if (!concepts) {
@@ -2088,7 +2124,7 @@ var ConceptApiProvider = class extends BaseProvider {
     return this.axios({
       ...config,
       method: "get",
-      url: this._api.data,
+      url,
       params: {
         ...this._defaultParams,
         // ? What should the default limit be?
@@ -2106,24 +2142,29 @@ var ConceptApiProvider = class extends BaseProvider {
    * @returns {Object[]} array of JSKOS concept objects
    */
   async getNarrower({ concept, ...config }) {
-    if (!this._api.narrower) {
-      throw new MissingApiUrlError();
-    }
     if (!concept || !concept.uri) {
       throw new InvalidOrMissingParameterError({ parameter: "concept" });
     }
-    return this.axios({
-      ...config,
-      method: "get",
-      url: this._api.narrower,
-      params: {
-        ...this._defaultParams,
-        // ? What should the default limit be?
-        limit: 1e4,
-        ...config.params || {},
-        uri: concept.uri
-      }
-    });
+    if (this._api.narrower) {
+      return this.axios({
+        ...config,
+        method: "get",
+        url: this._api.narrower,
+        params: {
+          ...this._defaultParams,
+          // ? What should the default limit be?
+          limit: 1e4,
+          ...config.params || {},
+          uri: concept.uri
+        }
+      });
+    } else {
+      const conf2 = { params: {}, ...config };
+      conf2.params.properties = "narrower";
+      const response = await this.getConcepts({ concepts: [concept], ...conf2 });
+      const narrower = response[0]?.narrower || [];
+      return narrower.length ? this.getConcepts({ concepts: narrower, ...config }) : [];
+    }
   }
   /**
    * Returns ancestor concepts for a concept.
@@ -2133,24 +2174,29 @@ var ConceptApiProvider = class extends BaseProvider {
    * @returns {Object[]} array of JSKOS concept objects
    */
   async getAncestors({ concept, ...config }) {
-    if (!this._api.ancestors) {
-      throw new MissingApiUrlError();
-    }
     if (!concept || !concept.uri) {
       throw new InvalidOrMissingParameterError({ parameter: "concept" });
     }
-    return this.axios({
-      ...config,
-      method: "get",
-      url: this._api.ancestors,
-      params: {
-        ...this._defaultParams,
-        // ? What should the default limit be?
-        limit: 1e4,
-        ...config.params || {},
-        uri: concept.uri
-      }
-    });
+    if (this._api.ancestors) {
+      return this.axios({
+        ...config,
+        method: "get",
+        url: this._api.ancestors,
+        params: {
+          ...this._defaultParams,
+          // ? What should the default limit be?
+          limit: 1e4,
+          ...config.params || {},
+          uri: concept.uri
+        }
+      });
+    } else {
+      const conf2 = { params: {}, ...config };
+      conf2.params.properties = "ancestors";
+      const response = await this.getConcepts({ concepts: [concept], ...conf2 });
+      const ancestors = response[0]?.ancestors || [];
+      return ancestors.length ? this.getConcepts({ concepts: ancestors, ...config }) : [];
+    }
   }
   /**
    * Returns suggestion result in OpenSearch Suggest Format.
@@ -2291,8 +2337,6 @@ var ConceptApiProvider = class extends BaseProvider {
     return types;
   }
 };
-ConceptApiProvider.providerName = "ConceptApi";
-ConceptApiProvider.providerType = "http://bartoc.org/api-type/jskos";
 
 // src/providers/reconciliation-api-provider.js
 var import_jskos_tools6 = __toESM(require("jskos-tools"), 1);
@@ -2954,34 +2998,6 @@ var SkosmosApiProvider = class extends BaseProvider {
     const concepts = ancestors.map((c) => this._toJskosConcept(c, { scheme })).filter((c) => c.uri != concept.uri);
     return concepts;
   }
-  /**
-   * Returns suggestion result in OpenSearch Suggest Format.
-   *
-   * @param {Object} config
-   * @param {string} config.search search string
-   * @param {Object} [config.scheme] concept scheme to search in
-   * @param {number} [config.limit=100] maximum number of search results (default might be overridden by registry)
-   * @param {string[]} [config.types=[]] list of type URIs
-   * @returns {Array} result in OpenSearch Suggest Format
-   */
-  async suggest(config) {
-    config._raw = true;
-    const concepts = await this.search(config);
-    const result = [config.search, [], [], []];
-    for (let concept of concepts) {
-      const notation = import_jskos_tools8.default.notation(concept);
-      const label = import_jskos_tools8.default.prefLabel(concept);
-      result[1].push((notation ? notation + " " : "") + label);
-      result[2].push("");
-      result[3].push(concept.uri);
-    }
-    if (concepts._totalCount != void 0) {
-      result._totalCount = concepts._totalCount;
-    } else {
-      result._totalCount = concepts.length;
-    }
-    return result;
-  }
   /**
    * Returns concept search results.
    *
@@ -3886,6 +3902,779 @@ var LobidApiProvider = class extends BaseProvider {
 LobidApiProvider.providerName = "LobidApi";
 LobidApiProvider.providerType = "http://bartoc.org/api-type/lobid-gnd";
 
+// src/providers/mod-api-provider.js
+var ModApiProvider = class extends BaseProvider {
+  // #### PROPERTIES ####
+  // - providerName (This is how a provider is identified in a "registry" object in field `provider`.)
+  static providerName = "ModApi";
+  // - providerType (Optional BARTOC API type URI. Supported types: https://github.com/gbv/bartoc.org/blob/main/data/bartoc-api-types.concepts.csv, the URI prefix is "http://bartoc.org/api-type/".)
+  static providerType = "http://bartoc.org/en/node/20333";
+  // - supports (Optional object of supported capabilities. The keys should be values from this list: https://github.com/gbv/cocoda-sdk/blob/9145952398d6828004beb395c1d392a4d24e9288/src/utils/index.js#L159-L174; values should be a boolean. `false` values can be left out. They will be used to initialize `this.has` (see below). Alternatively, `this.has` can be filled in `_prepare` or `_setup`.)
+  static supports = {
+    schemes: true,
+    top: false,
+    data: false,
+    concepts: true,
+    narrower: false,
+    ancestors: false,
+    types: false,
+    suggest: false,
+    search: false,
+    auth: false,
+    mappings: false,
+    concordances: false,
+    annotations: false,
+    occurrences: false
+  };
+  // #### CUSTOM METHODS ####
+  /**
+   * Constructs the full API URL for a given endpoint.
+   * @param {Array} parts - Array of api parts (e.g., "[artifacts, <schemeShort>]")
+   * @param {Object} params - An object containing query parameters as key-value pairs.
+   * @returns {string} The full URL. Returns undefined if any part is undefined.
+   * @private
+   */
+  _getApiUrl(parts, params) {
+    let result = this.uri || "";
+    if (result.endsWith("/")) {
+      result = result.slice(0, -1);
+    }
+    for (const part of parts) {
+      if (part) {
+        result += "/" + part;
+      } else {
+        return;
+      }
+    }
+    if (params) {
+      const paramString = Object.keys(params).map((k) => `${k}=${encodeURIComponent(params[k])}`).join("&");
+      result += (result.includes("?") ? "&" : "?") + paramString;
+    }
+    return result;
+  }
+  /*
+    _artefactToJSKOS(artefact) {
+      switch (this._jskos.transformation) {
+        //case "jsonld":
+        //  return this._modToJskosJsonLD(artefact)
+        case "manual":
+          return this._modToJskosManual(artefact)
+        default:
+          // If no specific transformation is set, default to JSON-LD conversion
+          return this._modToJskosJsonLD(artefact)
+      }
+    }
+  
+    _modToJskosJsonLD(artefact) {
+      if (artefact["@id"]) {
+        delete artefact["@id"]
+      }
+  
+      artefact["@context"] = context_mod["@context"]
+  
+      return jsonld
+        .expand(artefact)
+        .then((expanded) => jsonld.compact(expanded, context_jskos))
+        .then((compacted) => {
+          jskos.clean(compacted)
+          delete compacted["@context"]
+          for (const key in compacted) {
+            if (compacted[key]?.["@none"]) {
+              compacted[key][this._language] = compacted[key]["@none"]
+              delete compacted[key]["@none"]
+            }
+          }
+          compacted = jskos.clean(compacted)
+          compacted = this._repairJsonLD(compacted)
+  
+          return compacted
+        })
+    }
+  
+    _repairJsonLD(json){
+      // This function is used to repair the JSON-LD context, translating erroneous keys
+      const map = {
+        narrower: "http://www.w3.org/2004/02/skos/core#narrower",
+        altLabel: "http://www.w3.org/2004/02/skos/core#altLabel",
+        definition: "http://www.w3.org/2004/02/skos/core#definition",
+      }
+  
+      for (const key in map) {
+        if (json[map[key]]) {
+          json[key] = json[map[key]]
+          delete json[map[key]]
+        }
+      }
+      return json
+    }
+    */
+  // _modToJskosManual(artefact) {
+  _artefactToJSKOS(artefact) {
+    const lan = artefact.language || this._language || "en";
+    const concept = {};
+    if (artefact.subject) {
+      concept.subject = [artefact.subject];
+    }
+    if (artefact.includedInDataCatalog) {
+      concept.api = [artefact.includedInDataCatalog];
+    }
+    if (artefact["@type"]) {
+      concept["@type"] = artefact["@type"];
+    }
+    if (artefact.type) {
+      concept.type = [artefact.type];
+    }
+    if (artefact.source_name) {
+      concept.notation = [artefact.source_name];
+    }
+    if (artefact.short_form) {
+      if (!concept.notation) {
+        concept.notation = [artefact.short_form];
+      } else {
+        concept.notation.push(artefact.short_form);
+      }
+    }
+    if (artefact.label) {
+      concept.prefLabel = {};
+      concept.prefLabel[lan] = [];
+      concept.prefLabel[lan].push(artefact.label);
+    }
+    if (artefact.synonyms) {
+      concept.altLabel = {};
+      concept.altLabel[lan] = artefact.synonyms;
+    }
+    if (artefact.descriptions) {
+      concept.definition = {};
+      concept.definition[lan] = artefact.descriptions;
+    }
+    if (artefact.language) {
+      concept.languages = artefact.language;
+    }
+    if (artefact["@id"]) {
+      concept.uri = artefact["@id"];
+    }
+    if (artefact.iri) {
+      concept.iri = artefact.iri;
+    }
+    if (artefact.identifier) {
+      concept.identifier = [artefact.identifier];
+    }
+    if (artefact.source) {
+      concept.source = [artefact.source];
+    }
+    if (artefact.source_url) {
+      concept.namespace = artefact.source_url;
+    }
+    if (artefact.landingPage) {
+      concept.url = artefact.landingPage;
+    }
+    if (artefact.version) {
+      concept.version = artefact.version;
+    }
+    if (artefact.modified) {
+      concept.modified = artefact.modified;
+    }
+    if (artefact.created) {
+      concept.created = artefact.created;
+    }
+    if (artefact.hasFormat) {
+      concept.format = artefact.hasFormat;
+    }
+    if (artefact.license) {
+      concept.license = [artefact.license];
+    }
+    if (artefact.creator) {
+      concept.creator = artefact.creator;
+    }
+    if (artefact.contributor) {
+      concept.contributor = {};
+      concept.contributor.prefLabel = {};
+      concept.contributor.prefLabel[lan] = artefact.contributor;
+    }
+    if (artefact.publisher) {
+      concept.publisher = {};
+      concept.publisher[lan] = artefact.publisher;
+    }
+    if (artefact.released) {
+      concept.issued = artefact.released;
+    }
+    if (artefact.children) {
+      concept.narrower = {};
+      concept.narrower[lan] = artefact.children;
+    }
+    return concept;
+  }
+  // #### API REQUESTS ####
+  async _request(url, ..._config) {
+    if (!url) {
+      return;
+    }
+    const result = await this.axios({
+      method: "get",
+      url,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      ..._config
+    });
+    if (!result?._url || Object.keys(result).length != 1) {
+      return result;
+    }
+  }
+  // API REQUESTS SCHEMES
+  async _getSchemesMod() {
+    const url = this._getApiUrl(["artefacts"], null);
+    return await this._request(url);
+  }
+  async _getSchemesModLimit(limit) {
+    const artifacts = await this._getSchemesMod();
+    if (limit && limit > 0) {
+      return artifacts.slice(0, limit);
+    }
+    return artifacts;
+  }
+  async _getSchemeMod(schemeParam) {
+    if (schemeParam.short) {
+      return await this._getSchemeFromShort(schemeParam.short);
+    } else if (schemeParam.uri) {
+      return await this._getSchemeFromUri(schemeParam.uri);
+    }
+  }
+  async _getSchemeFromShort(short) {
+    const url = this._getApiUrl(["artefacts", short], null);
+    return await this._request(url);
+  }
+  async _getSchemeFromUri(uri) {
+    const schemesMod = await this._getSchemesMod();
+    if (!schemesMod) {
+      return;
+    }
+    for (const scheme of await schemesMod) {
+      if (scheme.source == uri || scheme.source_url == uri || scheme.source_name == uri || scheme["@id"] == uri || scheme.iri == uri || scheme.includedInDataCatalog && scheme.includedInDataCatalog.includes(uri)) {
+        return await scheme;
+      }
+    }
+  }
+  // API REQUESTS CONCEPTS
+  async _getConceptsMod(scheme) {
+    let schemeShort = await this._schemeShortFromObj(scheme);
+    if (!schemeShort) {
+      return [];
+    }
+    const url = this._getApiUrl(["artefacts", schemeShort, "resources", "concepts"], null);
+    const pageOne = await this._request(url);
+    if (!pageOne) {
+      return [];
+    }
+    const { page, totalPages, member: conceptsOne } = pageOne;
+    let concepts = [];
+    for (const concept of conceptsOne) {
+      if (concept) {
+        concepts.push(concept);
+      }
+    }
+    for (let p = page + 1; p <= totalPages; p++) {
+      const urlPage = this._getApiUrl(["artefacts", schemeShort, "resources", "concepts"], { page: p });
+      const pageP = await this._request(urlPage);
+      if (!pageP) {
+        break;
+      }
+      const { member: conceptsNew } = pageP;
+      for (const concept of conceptsNew) {
+        if (concept) {
+          concepts.push(concept);
+        }
+      }
+    }
+    return concepts;
+  }
+  async _getConceptsModLimit(scheme, limit) {
+    let concepts = await this._getConceptsMod(scheme);
+    if (limit && limit > 0) {
+      return concepts.slice(0, limit);
+    }
+    return concepts;
+  }
+  async _getConceptMod(concept) {
+    const { conceptNotation, schemeShort } = await this._conceptNotationFromObj(concept);
+    const url = this._getApiUrl(["artefacts", schemeShort, "resources", "concepts", conceptNotation], null);
+    return await this._request(url);
+  }
+  // UTILITIES
+  _containsString(obj, searchString) {
+    for (const key in obj) {
+      const value = obj[key];
+      if (typeof value === "string" && value.includes(searchString)) {
+        return true;
+      }
+      if (typeof value === "object" && value !== null) {
+        if (this.containsString(value, searchString)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  async _getSchemesContaining(partstring) {
+    let schemes = [];
+    const schemesMod = await this._getSchemesMod();
+    for (const scheme of schemesMod) {
+      if (this.containsString(scheme, partstring)) {
+        schemes.push(scheme);
+      }
+    }
+    return schemes;
+  }
+  async _getSchemeShort(uri) {
+    const schemeMod = await this._getSchemeFromUri(uri);
+    if (schemeMod) {
+      return await schemeMod.short_form.toLowerCase();
+    }
+  }
+  _getconceptNotation(uri) {
+    return uri.split("/").pop();
+  }
+  async _schemeShortFromObj(scheme) {
+    if (scheme.short) {
+      return scheme.short;
+    } else if (scheme.uri) {
+      return await this._getSchemeShort(scheme.uri);
+    }
+  }
+  async _conceptNotationFromObj(concept) {
+    if (!concept.inScheme || !concept.inScheme[0]) {
+      return;
+    }
+    let schemeShort = await this._schemeShortFromObj(concept.inScheme[0]);
+    let conceptNotation = concept.notation;
+    if (!conceptNotation) {
+      conceptNotation = await this._getconceptNotation(concept.uri);
+    }
+    return { conceptNotation, schemeShort };
+  }
+  // #### OVERRIDE METHODS ####
+  /**
+   * will be called before the registry is initialized (i.e. it's `/status` endpoint is queries if necessasry)
+   * @private
+   */
+  _prepare() {
+  }
+  /**
+   * Sets up provider-specific properties.
+   * Enables support for mappings in this provider.
+   * will be called after registry is initialized (i.e. it's `/status` endpoint is queries if necessary), should be used to set properties on this.has and custom preparations
+   * @private
+   */
+  _setup() {
+  }
+  /**
+   * Retrieves all concept schemes from the MOD API.
+   *
+   * @param {Object} [params={}] - Optional parameters for the request.
+   * @returns {Promise<Array>} An array of JSKOS concept schemes.
+   * @async
+   */
+  async getSchemes({ schemes, limit, ..._config }) {
+    let schemes_results = [];
+    let artefacts = [];
+    if (schemes) {
+      for (const s of schemes) {
+        let sc = await this._getSchemeMod(s);
+        if (sc) {
+          artefacts.push(sc);
+        }
+      }
+    } else {
+      artefacts = await this._getSchemesModLimit(limit);
+    }
+    for (const artefact of artefacts) {
+      let scheme = await this._artefactToJSKOS(artefact);
+      if (scheme) {
+        schemes_results.push(scheme);
+      } else {
+        console.warn("JSKOS transformation failed for artefact: ", artefact);
+      }
+    }
+    return schemes_results;
+  }
+  /**
+  * Retrieves all concepts from the MOD API.
+  *
+  * @param {Object} params - The options object.
+  * @param {string[]} params.concepts - List of concept objects to request specific concepts.
+  * @param {string} params.scheme - A scheme object to request concepts from a specific scheme.
+  * @param {number} [params.limit] - Optional limit for results when requesting concepts from a scheme.
+  * @param {Object} [params._config] - Additional config options.
+  * @returns {Promise<Array>} An array of JSKOS concepts.
+  * @async
+  */
+  async getConcepts({ concepts, scheme, limit, ..._config }) {
+    let concept_results = [];
+    if (concepts) {
+      for (const concept of concepts) {
+        let conceptMod = await this._getConceptMod(concept);
+        if (conceptMod) {
+          const concept2 = await this._artefactToJSKOS(conceptMod);
+          if (concept2) {
+            concept_results.push(concept2);
+          } else {
+            console.warn("JSKOS transformation failed for concept: ", conceptMod);
+          }
+        }
+      }
+    } else if (scheme) {
+      const conceptsMod = await this._getConceptsModLimit(scheme, limit);
+      for (const conceptMod of conceptsMod) {
+        const conceptJ = await this._artefactToJSKOS(conceptMod);
+        if (conceptJ) {
+          concept_results.push(conceptJ);
+        } else {
+          console.warn("JSKOS transformation failed for concept: ", conceptMod);
+        }
+      }
+    }
+    return concept_results;
+  }
+  /**
+   * @private
+   */
+  get _language() {
+    return this._jskos.language || this.languages[0] || this._defaultLanguages[0] || "en";
+  }
+  /**
+   * Retrieves an array of mappings.
+   * @returns {Array} An array containing mapping objects.
+   */
+  getMappings() {
+    const mappings = [];
+    return mappings;
+  }
+};
+
+// src/providers/ols-api-provider.js
+var OlsApiProvider = class extends BaseProvider {
+  static providerName = "OlsApi";
+  static providerType = "http://bartoc.org/api-type/ols";
+  static supports = {
+    schemes: true,
+    top: true,
+    data: false,
+    // TODO
+    concepts: true,
+    narrower: true,
+    ancestors: true,
+    types: true,
+    suggest: true,
+    search: true
+  };
+  constructor(config) {
+    super(config);
+    this.endpoint = config.endpoint;
+  }
+  /**
+   * Used by `registryForScheme` (see src/lib/CocodaSDK.js) to determine a provider config for a concept schceme.
+   * TODO: make this obsolete
+   */
+  static _registryConfigForBartocApiConfig({ url } = {}) {
+    if (url) {
+      return { endpoint: url };
+    }
+  }
+  /**
+   * Constructs the full API URL for a given endpoint.
+   */
+  _getApiUrl(parts, params = {}) {
+    const url = this.endpoint + parts.join("/");
+    params = Object.fromEntries(Object.entries(params).filter(([_, v]) => v != null));
+    params = new URLSearchParams(params);
+    return params.size ? `${url}?${params}` : url;
+  }
+  _ontologyToJSKOS(ontology) {
+    const lan = ontology.lang || this._language || "en";
+    const scheme = {};
+    if (ontology.iri) {
+      scheme.uri = ontology.iri;
+    }
+    scheme.type = [
+      "http://www.w3.org/2004/02/skos/core#ConceptScheme"
+    ];
+    if (ontology["http://www.w3.org/1999/02/22-rdf-syntax-ns#type"]) {
+      scheme.type = scheme.type.concat(ontology["http://www.w3.org/1999/02/22-rdf-syntax-ns#type"]);
+    }
+    if (ontology.title) {
+      scheme.prefLabel = {};
+      scheme.prefLabel[lan] = ontology.title;
+    }
+    if (ontology.description) {
+      scheme.definition = {};
+      scheme.definition[lan] = [ontology.description];
+    }
+    if (ontology.homepage) {
+      scheme.url = ontology.homepage;
+    }
+    if (ontology.tracker) {
+      scheme.issueTracker = [{ url: ontology.tracker }];
+    }
+    if (ontology.language) {
+      scheme.languages = ontology.language;
+    }
+    if (ontology.ontologyId) {
+      scheme.VOCID = ontology.ontologyId;
+      scheme.notation = [ontology.ontologyId];
+    }
+    if (ontology.license?.url) {
+      scheme.license = [{ uri: ontology.license.url }];
+    }
+    return scheme;
+  }
+  _termToJSKOS(term) {
+    const lan = term.language || this._language || "en";
+    const concept = {};
+    if (term.curie) {
+      concept.notation = [term.curie];
+    }
+    if (term.hasDirectChildren) {
+      concept.narrower = [null];
+    } else {
+      concept.narrower = [];
+    }
+    if (term.hasDirectParents) {
+      concept.broader = [null];
+    } else {
+      concept.broader = [];
+    }
+    if (term.iri) {
+      concept.uri = term.iri;
+    }
+    if (term["http://www.w3.org/2000/01/rdf-schema#label"]) {
+      concept.prefLabel = {};
+      concept.prefLabel[lan] = term["http://www.w3.org/2000/01/rdf-schema#label"];
+    }
+    concept.type = [
+      "http://www.w3.org/2004/02/skos/core#Concept",
+      // FIXME: properties are no classes
+      "http://www.w3.org/2002/07/owl#Class"
+    ];
+    if (term.ontologyIri) {
+      concept.inScheme = [{ uri: term.ontologyIri }];
+    }
+    return concept;
+  }
+  // #### API REQUESTS ####
+  // TODO: rename _skipAdditionalParameters
+  async _request(url, config = { _skipAdditionalParameters: true }) {
+    if (url) {
+      url = new URL(url);
+      const given = Object.fromEntries(url.searchParams.entries());
+      return this.axios({
+        method: "get",
+        url: url.origin + url.pathname,
+        params: {
+          ...given,
+          ...config.params
+          // explicit params win
+        },
+        ...config
+      });
+    }
+  }
+  // API REQUESTS SCHEMES
+  async _paginate(base, query, limit) {
+    const size = limit > 0 ? limit : null;
+    let url = this._getApiUrl(base, { ...query, size });
+    let page = await this._request(url);
+    let items = page?.elements || [];
+    if (!size) {
+      const totalPages = page?.totalPages || 0;
+      for (let n = 1; n < totalPages; n++) {
+        url = this._getApiUrl(base, { ...query, page: n });
+        page = await this._request(url);
+        items = items.concat(page?.elements || []);
+      }
+    }
+    return items;
+  }
+  // API REQUESTS CONCEPTS
+  async _getConceptOls(concept) {
+    const VOCID = await this._getSchemeVOCID(concept?.inScheme?.[0]);
+    if (VOCID) {
+      let url = null;
+      if (concept.notation) {
+        url = this._getApiUrl(["ontologies", VOCID, "classes"], { curie: concept.notation });
+      } else if (concept.uri) {
+        url = this._getApiUrl(["ontologies", VOCID, "classes"], { iri: concept.uri });
+      }
+      let response = await this._request(url);
+      return response?.elements?.[0] || null;
+    }
+  }
+  async _searchOls(search, scheme, limit, types) {
+    let items = [];
+    const knownTypes = {
+      "http://www.w3.org/2002/07/owl#Class": "classes",
+      "http://www.w3.org/1999/02/22-rdf-syntax-ns#Property": "properties"
+    };
+    if (!types?.length) {
+      types = Object.keys(knownTypes);
+    }
+    for (const type of types) {
+      if (type in knownTypes) {
+        const VOCID = scheme ? await this._getSchemeVOCID(scheme) : null;
+        const query = { search, ontology: VOCID };
+        if (!scheme || VOCID) {
+          const found = await this._paginate([knownTypes[type]], query, limit);
+          items.push(...found);
+        }
+      }
+    }
+    return items;
+  }
+  // UTILITIES
+  async _conceptIriFromObj(VOCID, conceptNotation) {
+    let url = this._getApiUrl(["ontologies", VOCID, "classes"], { curie: conceptNotation });
+    let response = await this._request(url);
+    if (response && response.elements && response.elements.length > 0) {
+      return response.elements[0].iri;
+    }
+  }
+  get _language() {
+    return this._jskos.language || this.languages[0] || this._defaultLanguages[0] || "en";
+  }
+  async _getSchemeVOCID(scheme) {
+    return scheme?.VOCID ? scheme.VOCID : this._getScheme(scheme).then((s) => s?.ontologyId);
+  }
+  async _getScheme(scheme) {
+    if (scheme) {
+      const { VOCID, uri, notation, identifier } = scheme;
+      if (VOCID) {
+        return this._request(this._getApiUrl(["ontologies", VOCID]));
+      }
+      if (uri) {
+        scheme = await this._getSchemeFromUri(uri);
+        if (scheme) {
+          return scheme;
+        }
+      }
+      if (notation?.[0] && (uri || identifier?.length)) {
+        scheme = await this._request(this._getApiUrl(["ontologies", notation[0]]));
+        if (scheme.iri === uri || identifier?.includes(scheme.iri)) {
+          return scheme;
+        }
+      }
+      for (let id of identifier || []) {
+        const found = await this._getSchemeFromUri(id);
+        if (found) {
+          return found;
+        }
+      }
+    }
+  }
+  async _getSchemeFromUri(uri) {
+    if (uri) {
+      const url = this._getApiUrl(["ontologies"], { searchFields: "iri", search: uri });
+      const response = await this._request(url);
+      const schemes = response?.elements || [];
+      return schemes.reduce((short, cur) => cur.ontologyId.length < short.ontologyId.length ? cur : short, schemes[0]);
+    }
+    return null;
+  }
+  // MAIN FUNCTIONS
+  // TODO: query parameter are different: schemes are in "params.uri"?
+  async getSchemes({ schemes, limit }) {
+    let ontologies = [];
+    if (schemes) {
+      ontologies = (await Promise.all(schemes.map((s) => this._getScheme(s)))).filter(Boolean);
+    } else if (limit > 0) {
+      const url = this._getApiUrl(["ontologies"], { size: limit });
+      const response = await this._request(url);
+      ontologies = response.elements || [];
+    } else {
+      ontologies = await this._paginate(["ontologies"], {});
+    }
+    return Promise.all(ontologies.map((scheme) => this._ontologyToJSKOS(scheme)));
+  }
+  async getConcepts({ concepts, scheme, limit }) {
+    let result = [];
+    if (concepts) {
+      for (const concept of concepts) {
+        let item = await this._getConceptOls(concept);
+        if (item) {
+          result.push(await this._termToJSKOS(item));
+        }
+      }
+    } else if (scheme) {
+      const VOCID = await this._getSchemeVOCID(scheme);
+      if (VOCID) {
+        const items = await this._paginate(["ontologies", VOCID, "classes"], {}, limit);
+        result = Promise.all(items.map((item) => this._termToJSKOS(item)));
+      }
+    }
+    return result;
+  }
+  async getTop({ scheme }) {
+    const VOCID = await this._getSchemeVOCID(scheme);
+    if (VOCID) {
+      let url = this._getApiUrl(["ontologies", VOCID, "classes"], { hasDirectParents: "false" });
+      let response = await this._request(url);
+      if (response?.elements) {
+        return Promise.all(response.elements.map((item) => this._termToJSKOS(item)));
+      }
+    }
+    return [];
+  }
+  async _splitConcept(concept) {
+    const obj = {};
+    if (concept) {
+      obj.VOCID = await this._getSchemeVOCID(concept?.inScheme?.[0]);
+      obj.iri = concept.uri || await this._conceptIriFromObj(obj.VOCID, concept.notation);
+      obj.iri = encodeURIComponent(encodeURIComponent(obj.iri));
+    }
+    return obj;
+  }
+  async getNarrower({ concept }) {
+    const { VOCID, iri } = await this._splitConcept(concept);
+    if (VOCID && iri) {
+      let url = this._getApiUrl(["ontologies", VOCID, "classes", iri, "children"]);
+      let response = await this._request(url);
+      if (response?.elements) {
+        return Promise.all(response.elements.map((item) => this._termToJSKOS(item)));
+      }
+    }
+    return [];
+  }
+  async getAncestors({ concept }) {
+    const { VOCID, iri } = await this._splitConcept(concept);
+    if (VOCID && iri) {
+      let url = this._getApiUrl(["ontologies", VOCID, "classes", iri, "ancestors"]);
+      let response = await this._request(url);
+      if (response?.elements) {
+        return Promise.all(response.elements.map((item) => this._termToJSKOS(item)));
+      }
+    }
+    return [];
+  }
+  async getTypes() {
+    return [{
+      uri: "http://www.w3.org/2002/07/owl#Class",
+      prefLabel: {
+        en: "Class",
+        de: "Klasse"
+      }
+    }, {
+      uri: "http://www.w3.org/1999/02/22-rdf-syntax-ns#Property",
+      prefLabel: {
+        en: "Property",
+        de: "Eigenschaft"
+      }
+    }];
+  }
+  async search({ search, scheme = null, limit = 0, types = ["http://www.w3.org/2002/07/owl#Class"] }) {
+    let items = await this._searchOls(search, scheme, limit, types);
+    return Promise.all(items.map((item) => this._termToJSKOS(item)));
+  }
+};
+
 // src/providers/mycore-provider.js
 var import_jskos_tools12 = __toESM(require("jskos-tools"), 1);
 var import_flexsearch2 = __toESM(require("flexsearch"), 1);
@@ -4688,9 +5477,11 @@ function addAllProviders(_cdk) {
   LocApiProvider,
   LocalMappingsProvider,
   MappingsApiProvider,
+  ModApiProvider,
   MyCoReProvider,
   NoTApiProvider,
   OccurrencesApiProvider,
+  OlsApiProvider,
   ReconciliationApiProvider,
   SkohubProvider,
   SkosmosApiProvider,