cocoda-sdk 3.0.2 → 3.2.0

package/README.md

@@ -21,6 +21,7 @@
   - [Registry Methods - General](#registry-methods---general)
   - [Registry Methods - Concept Schemes](#registry-methods---concept-schemes)
   - [Registry Methods - Concepts](#registry-methods---concepts)
+  - [Registry Methods - Concordances](#registry-methods---concordances)
   - [Registry Methods - Mappings](#registry-methods---mappings)
   - [Registry Methods - Annotations](#registry-methods---annotations)
   - [Registry Methods - Various](#registry-methods---various)
@@ -164,6 +165,8 @@ The following providers are also exported, but have to be added via `cdk.addProv
 - `SkosmosApi` - access to concept schemes and concepts via a [Skosmos](https://github.com/NatLibFi/Skosmos) API
 - `LocApi` - access to concept schemes and concepts via the [Library of Congress Linked Data Service](https://id.loc.gov/)
   - **This integration is currently experimental and only supports LCSH and LCNAF.**
+- `Skohub` - access to concept schemes and concepts via a [SkoHub Vocabs](https://blog.lobid.org/2019/09/27/presenting-skohub-vocabs.html)
+  - **This integration is currently experimental. Only vocabularies that use a [slash namespace pattern]([hash](https://www.w3.org/2001/sw/BestPractices/VM/http-examples/2006-01-18/#slash)) with dereferenceable URIs are supported.**
 - `ReconciliationApi` - access to mapping suggestions via a [OpenRefine Reconciliation API](https://github.com/OpenRefine/OpenRefine/wiki/Reconciliation-Service-API)
 - `OccurrencesApi` - access to concept occurrences via [occurrences-api](https://github.com/gbv/occurrences-api) (will be changed to [occurrences-server](https://github.com/gbv/occurrences-server) in the future)
 - `LabelSearchSuggestion` - access to mapping suggestions using other registries' search endpoints (using [jskos-server])
@@ -348,6 +351,23 @@ Please refer to the [documentation](https://gbv.github.io/cocoda-sdk/CocodaSDK.h
 - [ConceptApiProvider - suggest](https://gbv.github.io/cocoda-sdk/ConceptApiProvider.html#suggest)
 - [SkosmosApiProvider - suggest](https://gbv.github.io/cocoda-sdk/SkosmosApiProvider.html#suggest)
 
+### Registry Methods - Concordances
+
+#### `registry.getConcordances`
+- [MappingsApiProvider - getConcordances](https://gbv.github.io/cocoda-sdk/MappingsApiProvider.html#getConcordances)
+
+#### `registry.postConcordance`
+- [MappingsApiProvider - postConcordance](https://gbv.github.io/cocoda-sdk/MappingsApiProvider.html#postConcordance)
+
+#### `registry.putConcordance`
+- [MappingsApiProvider - putConcordance](https://gbv.github.io/cocoda-sdk/MappingsApiProvider.html#putConcordance)
+
+#### `registry.patchConcordance`
+- [MappingsApiProvider - patchConcordance](https://gbv.github.io/cocoda-sdk/MappingsApiProvider.html#patchConcordance)
+
+#### `registry.deleteConcordance`
+- [MappingsApiProvider - deleteConcordance](https://gbv.github.io/cocoda-sdk/MappingsApiProvider.html#deleteConcordance)
+
 ### Registry Methods - Mappings
 
 #### `registry.getMappings`

package/dist/cjs/index.cjs

@@ -4,27 +4,20 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __reExport = (target, module2, copyDefault, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
-        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return target;
+  return to;
 };
-var __toESM = (module2, isNodeMode) => {
-  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
-};
-var __toCommonJS = /* @__PURE__ */ ((cache) => {
-  return (module2, temp) => {
-    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
-  };
-})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.js
 var src_exports = {};
@@ -38,11 +31,13 @@ __export(src_exports, {
   MappingsApiProvider: () => MappingsApiProvider,
   OccurrencesApiProvider: () => OccurrencesApiProvider,
   ReconciliationApiProvider: () => ReconciliationApiProvider,
+  SkohubProvider: () => SkohubProvider,
   SkosmosApiProvider: () => SkosmosApiProvider,
   addAllProviders: () => addAllProviders,
   cdk: () => cdk,
   errors: () => errors_exports
 });
+module.exports = __toCommonJS(src_exports);
 
 // src/errors/index.js
 var errors_exports = {};
@@ -114,7 +109,7 @@ var import_omit = __toESM(require("lodash/omit.js"), 1);
 var import_concat = __toESM(require("lodash/concat.js"), 1);
 
 // src/lib/CocodaSDK.js
-var import_jskos_tools10 = __toESM(require("jskos-tools"), 1);
+var import_jskos_tools11 = __toESM(require("jskos-tools"), 1);
 
 // src/providers/index.js
 var providers_exports = {};
@@ -127,6 +122,7 @@ __export(providers_exports, {
   MappingsApiProvider: () => MappingsApiProvider,
   OccurrencesApiProvider: () => OccurrencesApiProvider,
   ReconciliationApiProvider: () => ReconciliationApiProvider,
+  SkohubProvider: () => SkohubProvider,
   SkosmosApiProvider: () => SkosmosApiProvider
 });
 
@@ -336,10 +332,12 @@ var BaseProvider = class {
     this._config = {};
     this.setRetryConfig();
     this.axios.interceptors.request.use((config) => {
-      const language = import_uniq.default([].concat(import_get.default(config, "params.language", "").split(","), this.languages, this._defaultLanguages).filter((lang) => lang != "")).join(",");
-      import_set.default(config, "params.language", language);
-      if (this.has.auth && this._auth.bearerToken && !import_get.default(config, "headers.Authorization")) {
-        import_set.default(config, "headers.Authorization", `Bearer ${this._auth.bearerToken}`);
+      if (!config._skipAdditionalParameters) {
+        const language = import_uniq.default([].concat(import_get.default(config, "params.language", "").split(","), this.languages, this._defaultLanguages).filter((lang) => lang != "")).join(",");
+        import_set.default(config, "params.language", language);
+        if (this.has.auth && this._auth.bearerToken && !import_get.default(config, "headers.Authorization")) {
+          import_set.default(config, "headers.Authorization", `Bearer ${this._auth.bearerToken}`);
+        }
       }
       if (config.url.startsWith("http:") && typeof window !== "undefined" && window.location.protocol == "https:") {
         throw new import_axios.default.Cancel("Can't call http API from https.");
@@ -610,7 +608,7 @@ var BaseProvider = class {
     }
     const previousRegistry = scheme._registry;
     scheme._registry = this.cdk && this.cdk.registryForScheme(scheme);
-    if (!scheme._registry || previousRegistry === scheme._registry) {
+    if (!scheme._registry || previousRegistry === scheme._registry || scheme._registry._api.api === this._api.api) {
       scheme._registry = previousRegistry || this;
     } else {
       ["concepts", "topConcepts"].forEach((key) => {
@@ -1072,7 +1070,13 @@ var MappingsApiProvider = class extends BaseProvider {
       this.has.mappings.delete = !!import_get.default(this._config, "mappings.delete");
       this.has.mappings.anonymous = !!import_get.default(this._config, "mappings.anonymous");
     }
-    this.has.concordances = !!this._api.concordances;
+    this.has.concordances = this._api.concordances ? {} : false;
+    if (this.has.concordances) {
+      this.has.concordances.read = !!import_get.default(this._config, "concordances.read");
+      this.has.concordances.create = !!import_get.default(this._config, "concordances.create");
+      this.has.concordances.update = !!import_get.default(this._config, "concordances.update");
+      this.has.concordances.delete = !!import_get.default(this._config, "concordances.delete");
+    }
     this.has.annotations = this._api.annotations ? {} : false;
     if (this.has.annotations) {
       this.has.annotations.read = !!import_get.default(this._config, "annotations.read");
@@ -1108,7 +1112,7 @@ var MappingsApiProvider = class extends BaseProvider {
       throw error;
     }
   }
-  async getMappings({ from, fromScheme, to, toScheme, creator, type, partOf, offset, limit, direction, mode, identifier, sort, order, ...config }) {
+  async getMappings({ from, fromScheme, to, toScheme, creator, type, partOf, offset, limit, direction, mode, identifier, cardinality, annotatedBy, annotatedFor, annotatedWith, sort, order, ...config }) {
     let params = {}, url = this._api.mappings;
     if (from) {
       params.from = import_isString.default(from) ? from : from.uri;
@@ -1140,6 +1144,18 @@ var MappingsApiProvider = class extends BaseProvider {
     if (direction) {
       params.direction = direction;
     }
+    if (cardinality) {
+      params.cardinality = cardinality;
+    }
+    if (annotatedBy) {
+      params.annotatedBy = annotatedBy;
+    }
+    if (annotatedFor) {
+      params.annotatedFor = annotatedFor;
+    }
+    if (annotatedWith) {
+      params.annotatedWith = annotatedWith;
+    }
     if (mode) {
       params.mode = mode;
     }
@@ -1205,8 +1221,6 @@ var MappingsApiProvider = class extends BaseProvider {
     if (!mapping) {
       throw new InvalidOrMissingParameterError({ parameter: "mapping" });
     }
-    mapping = import_jskos_tools3.default.minifyMapping(mapping);
-    mapping = import_jskos_tools3.default.addMappingIdentifiers(mapping);
     const uri = mapping.uri;
     if (!uri || !uri.startsWith(this._api.mappings)) {
       throw new InvalidOrMissingParameterError({ parameter: "mapping", message: "URI doesn't seem to be part of this registry." });
@@ -1215,7 +1229,7 @@ var MappingsApiProvider = class extends BaseProvider {
       ...config,
       method: "patch",
       url: uri,
-      data: mapping,
+      data: import_omit.default(mapping, "uri"),
       params: {
         ...this._defaultParams,
         ...config.params || {}
@@ -1298,6 +1312,74 @@ var MappingsApiProvider = class extends BaseProvider {
       url: this._api.concordances
     });
   }
+  async postConcordance({ concordance, ...config }) {
+    if (!concordance) {
+      throw new InvalidOrMissingParameterError({ parameter: "concordance" });
+    }
+    return this.axios({
+      ...config,
+      method: "post",
+      url: this._api.concordances,
+      data: concordance,
+      params: {
+        ...this._defaultParams,
+        ...config.params || {}
+      }
+    });
+  }
+  async putConcordance({ concordance, ...config }) {
+    if (!concordance) {
+      throw new InvalidOrMissingParameterError({ parameter: "concordance" });
+    }
+    const uri = concordance.uri;
+    if (!uri || !uri.startsWith(this._api.concordances)) {
+      throw new InvalidOrMissingParameterError({ parameter: "concordance", message: "URI doesn't seem to be part of this registry." });
+    }
+    return this.axios({
+      ...config,
+      method: "put",
+      url: uri,
+      data: concordance,
+      params: {
+        ...this._defaultParams,
+        ...config.params || {}
+      }
+    });
+  }
+  async patchConcordance({ concordance, ...config }) {
+    if (!concordance) {
+      throw new InvalidOrMissingParameterError({ parameter: "concordance" });
+    }
+    const uri = concordance.uri;
+    if (!uri || !uri.startsWith(this._api.concordances)) {
+      throw new InvalidOrMissingParameterError({ parameter: "concordance", message: "URI doesn't seem to be part of this registry." });
+    }
+    return this.axios({
+      ...config,
+      method: "patch",
+      url: uri,
+      data: import_omit.default(concordance, "uri"),
+      params: {
+        ...this._defaultParams,
+        ...config.params || {}
+      }
+    });
+  }
+  async deleteConcordance({ concordance, ...config }) {
+    if (!concordance) {
+      throw new InvalidOrMissingParameterError({ parameter: "concordance" });
+    }
+    const uri = concordance.uri;
+    if (!uri || !uri.startsWith(this._api.concordances)) {
+      throw new InvalidOrMissingParameterError({ parameter: "concordance", message: "URI doesn't seem to be part of this registry." });
+    }
+    await this.axios({
+      ...config,
+      method: "delete",
+      url: uri
+    });
+    return true;
+  }
 };
 MappingsApiProvider.providerName = "MappingsApi";
 MappingsApiProvider.stored = true;
@@ -2517,6 +2599,228 @@ var LocApiProvider = class extends BaseProvider {
 LocApiProvider.providerName = "LocApi";
 LocApiProvider.providerType = "http://bartoc.org/api-type/loc";
 
+// src/providers/skohub-provider.js
+var import_jskos_tools10 = __toESM(require("jskos-tools"), 1);
+var import_flexsearch = __toESM(require("flexsearch"), 1);
+function decodeUnicode(text) {
+  return text.replace(/\\u[\dA-F]{4}/gi, function(match) {
+    return String.fromCharCode(parseInt(match.replace(/\\u/g, ""), 16));
+  });
+}
+var SkohubProvider = class extends BaseProvider {
+  _prepare() {
+    this.has.schemes = true;
+    this.has.top = true;
+    this.has.data = true;
+    this.has.concepts = true;
+    this.has.narrower = true;
+    this.has.ancestors = true;
+    this.has.suggest = true;
+    this.has.search = true;
+    listOfCapabilities.filter((c) => !this.has[c]).forEach((c) => {
+      this.has[c] = false;
+    });
+  }
+  _setup() {
+    this._index = {};
+    this._conceptCache = {};
+    this._schemeCache = {};
+  }
+  static _registryConfigForBartocApiConfig({ url, scheme } = {}) {
+    if (!url || !scheme) {
+      return null;
+    }
+    const newScheme = { uri: url, identifier: import_jskos_tools10.default.getAllUris(scheme).filter((uri) => uri !== url) };
+    return { schemes: [newScheme] };
+  }
+  async _loadScheme({ scheme, ...config }) {
+    let uris = import_jskos_tools10.default.getAllUris(scheme);
+    for (let uri2 of uris) {
+      if (this._schemeCache[uri2]) {
+        return this._schemeCache[uri2];
+      }
+    }
+    const schemeFromList = this.schemes.find((s) => import_jskos_tools10.default.compare(s, scheme));
+    if (!schemeFromList || !schemeFromList.uri) {
+      throw new InvalidRequestError({ message: `Tried to load unsupported scheme (${scheme && scheme.uri})` });
+    }
+    const uri = schemeFromList.uri;
+    uris = import_uniq.default(uris.concat(import_jskos_tools10.default.getAllUris(schemeFromList)));
+    let postfix = ".json";
+    if (uri.endsWith("/")) {
+      postfix = "index.json";
+    }
+    const data = await this.axios({ ...config, url: `${uri}${postfix}`, _skipAdditionalParameters: true });
+    if (data.id !== uri) {
+      throw new InvalidRequestError({ message: "Skohub URL did not return expected concept scheme" });
+    }
+    const { title, preferredNamespaceUri, hasTopConcept, description } = data;
+    scheme = { uri, identifier: uris.filter((u) => u !== uri) };
+    scheme.prefLabel = title;
+    Object.keys(scheme.prefLabel || {}).forEach((key) => {
+      scheme.prefLabel[key] = decodeUnicode(scheme.prefLabel[key]);
+    });
+    scheme.namespace = preferredNamespaceUri;
+    scheme.topConcepts = (hasTopConcept || []).map((c) => this._toJskosConcept(c));
+    scheme.concepts = [null];
+    if (description) {
+      scheme.definition = description;
+      Object.keys(scheme.definition).forEach((key) => {
+        scheme.definition[key] = [decodeUnicode(scheme.definition[key])];
+      });
+    }
+    for (let key of Object.keys(scheme).filter((key2) => !scheme[key2])) {
+      delete scheme[key];
+    }
+    for (let uri2 of uris) {
+      this._schemeCache[uri2] = scheme;
+    }
+    return scheme;
+  }
+  async _loadConcept({ uri, ...config }) {
+    if (this._conceptCache[uri]) {
+      return this._conceptCache[uri];
+    }
+    try {
+      const data = await this.axios({ ...config, url: `${uri}.json`, _skipAdditionalParameters: true });
+      if (data.id !== uri) {
+        throw new InvalidRequestError({ message: "Skohub URL did not return expected concept URI" });
+      }
+      const concept = this._toJskosConcept(data);
+      this._conceptCache[uri] = concept;
+      return concept;
+    } catch (error) {
+      return null;
+    }
+  }
+  _toJskosConcept(data) {
+    const concept = { uri: data.id };
+    concept.prefLabel = data.prefLabel;
+    Object.keys(concept.prefLabel || {}).forEach((key) => {
+      concept.prefLabel[key] = decodeUnicode(concept.prefLabel[key]);
+    });
+    concept.narrower = (data.narrower || []).map((c) => this._toJskosConcept(c));
+    concept.notation = data.notation || [];
+    if (data.broader && data.broader.id) {
+      concept.broader = [{ uri: data.broader.id }];
+    }
+    if (data.inScheme && data.inScheme.id) {
+      concept.inScheme = [{ uri: data.inScheme.id }];
+    }
+    if (data.scopeNote) {
+      concept.scopeNote = data.scopeNote;
+      Object.keys(concept.scopeNote).forEach((key) => {
+        concept.scopeNote[key] = [decodeUnicode(concept.scopeNote[key])];
+      });
+    }
+    return concept;
+  }
+  async getSchemes({ ...config }) {
+    return Promise.all(this.schemes.map((scheme) => this._loadScheme({ ...config, scheme })));
+  }
+  async getTop({ scheme, ...config }) {
+    if (!scheme || !scheme.uri) {
+      throw new InvalidOrMissingParameterError({ parameter: "scheme", message: "Missing scheme URI" });
+    }
+    scheme = await this._loadScheme({ scheme, ...config });
+    return scheme.topConcepts || [];
+  }
+  async getConcepts({ concepts, ...config }) {
+    if (!import_isArray.default(concepts)) {
+      concepts = [concepts];
+    }
+    return (await Promise.all(concepts.map(({ uri }) => this._loadConcept({ ...config, uri })))).filter(Boolean);
+  }
+  async getAncestors({ concept, ...config }) {
+    if (!concept || !concept.uri) {
+      throw new InvalidOrMissingParameterError({ parameter: "concept" });
+    }
+    if (concept.ancestors && concept.ancestors[0] !== null) {
+      return concept.ancestors;
+    }
+    concept = await this._loadConcept({ ...config, uri: concept.uri });
+    if (!concept || !concept.broader || !concept.broader.length) {
+      return [];
+    }
+    const broader = concept.broader[0];
+    return [broader].concat(await this.getAncestors({ concept: broader, ...config })).map((c) => ({ uri: c.uri }));
+  }
+  async getNarrower({ concept, ...config }) {
+    if (!concept || !concept.uri) {
+      throw new InvalidOrMissingParameterError({ parameter: "concept" });
+    }
+    if (concept.narrower && concept.narrower[0] !== null) {
+      return concept.narrower;
+    }
+    concept = await this._loadConcept({ ...config, uri: concept.uri });
+    return concept.narrower;
+  }
+  async search({ search, scheme, limit = 100 }) {
+    if (!scheme || !scheme.uri) {
+      throw new InvalidOrMissingParameterError({ parameter: "scheme" });
+    }
+    if (!search) {
+      throw new InvalidOrMissingParameterError({ parameter: "search" });
+    }
+    let index;
+    if (!this._index[scheme.uri]) {
+      this._index[scheme.uri] = {};
+    }
+    for (const lang of [""].concat(this.languages)) {
+      if (this._index[scheme.uri][lang]) {
+        index = this._index[scheme.uri][lang];
+        break;
+      }
+      if (this._index[scheme.uri][lang] === null) {
+        continue;
+      }
+      try {
+        let postfix = lang ? `.${lang}.index` : ".index";
+        if (scheme.uri.endsWith("/")) {
+          postfix = `index${postfix}`;
+        }
+        const data = await this.axios({ url: `${scheme.uri}${postfix}`, _skipAdditionalParameters: true });
+        if (data.length < 100) {
+          this._index[scheme.uri][lang] = null;
+          continue;
+        }
+        index = import_flexsearch.default.create();
+        index.import(data);
+        this._index[scheme.uri][lang] = index;
+        break;
+      } catch (error) {
+        this._index[scheme.uri][lang] = null;
+      }
+    }
+    if (!index) {
+      throw new InvalidRequestError({ message: "Could not find search index for any of the available languages " + this.languages.join(",") });
+    }
+    const result = index.search(search);
+    const concepts = await this.getConcepts({ concepts: result.map((uri) => ({ uri })) });
+    return concepts.slice(0, limit);
+  }
+  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_tools10.default.notation(concept);
+      const label = import_jskos_tools10.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;
+  }
+};
+SkohubProvider.providerName = "Skohub";
+SkohubProvider.providerType = "http://bartoc.org/api-type/skohub";
+
 // src/lib/CocodaSDK.js
 var providers = {
   [BaseProvider.providerName]: BaseProvider,
@@ -2629,7 +2933,8 @@ var CocodaSDK = class {
       timer: null,
       result: null,
       error: null,
-      isPaused: false
+      isPaused: false,
+      interval
     };
     const handleResult = (result) => {
       const previousResult = repeat.result;
@@ -2649,7 +2954,7 @@ var CocodaSDK = class {
       }
       repeat.timer = setTimeout(() => {
         toCall();
-      }, interval);
+      }, repeat.interval);
     };
     const call = () => asyncFunc().then(handleResult).catch(handleError).then(() => repeatIfNecessary(call));
     const setup = (_callImmediately = callImmediately) => {
@@ -2672,7 +2977,7 @@ var CocodaSDK = class {
         } else {
           setTimeout(() => {
             repeat.timer && clearTimeout(repeat.timer);
-          }, interval);
+          }, repeat.interval);
         }
       },
       get isPaused() {
@@ -2683,6 +2988,12 @@ var CocodaSDK = class {
       },
       get hasErrored() {
         return !!repeat.error;
+      },
+      get interval() {
+        return repeat.interval;
+      },
+      set interval(value) {
+        repeat.interval = value;
       }
     };
   }
@@ -2692,10 +3003,10 @@ var CocodaSDK = class {
       if (registry.has.schemes !== false) {
         let promise = registry.getSchemes(config).then((results) => {
           for (let scheme of results) {
-            const currentSchemeRegistry = scheme._registry;
+            scheme._registry = registry;
             scheme.__DETAILSLOADED__ = 1;
             scheme.type = scheme.type || ["http://www.w3.org/2004/02/skos/core#ConceptScheme"];
-            let otherScheme = schemes.find((s) => import_jskos_tools10.default.compare(s, scheme)), prio, otherPrio, override = false;
+            let otherScheme = schemes.find((s) => import_jskos_tools11.default.compare(s, scheme)), prio, otherPrio, override = false;
             if (otherScheme) {
               prio = this.config.registries.indexOf(registry);
               if (prio != -1) {
@@ -2717,19 +3028,19 @@ var CocodaSDK = class {
             }
             if (!otherScheme || override) {
               if (override) {
-                let otherSchemeIndex = schemes.findIndex((s) => import_jskos_tools10.default.compare(s, otherScheme));
+                let otherSchemeIndex = schemes.findIndex((s) => import_jskos_tools11.default.compare(s, otherScheme));
                 if (otherSchemeIndex != -1) {
                   schemes.splice(otherSchemeIndex, 1);
                 }
-                scheme = import_jskos_tools10.default.merge(scheme, import_omit.default(otherScheme, ["concepts", "topConcepts"]), { mergeUris: true, skipPaths: ["_registry"] });
+                scheme = import_jskos_tools11.default.merge(scheme, import_omit.default(otherScheme, ["concepts", "topConcepts"]), { mergeUris: true, skipPaths: ["_registry"] });
               }
-              scheme._registry = currentSchemeRegistry;
+              scheme._registry = registry;
               schemes.push(scheme);
             } else {
-              const index = schemes.findIndex((s) => import_jskos_tools10.default.compare(s, scheme));
+              const index = schemes.findIndex((s) => import_jskos_tools11.default.compare(s, scheme));
               if (index != -1) {
                 const otherSchemeRegistry = schemes[index]._registry;
-                schemes[index] = import_jskos_tools10.default.merge(schemes[index], import_omit.default(scheme, ["concepts", "topConcepts"]), { mergeUris: true, skipPaths: ["_registry"] });
+                schemes[index] = import_jskos_tools11.default.merge(schemes[index], import_omit.default(scheme, ["concepts", "topConcepts"]), { mergeUris: true, skipPaths: ["_registry"] });
                 schemes[index]._registry = otherSchemeRegistry;
               }
             }
@@ -2741,7 +3052,17 @@ var CocodaSDK = class {
       }
     }
     await Promise.all(promises);
-    return import_jskos_tools10.default.sortSchemes(schemes.filter(Boolean));
+    schemes.forEach((scheme) => {
+      const previousRegistry = scheme._registry;
+      delete scheme._registry;
+      const newRegistry = this.registryForScheme(scheme);
+      if (!newRegistry || newRegistry._api.api === previousRegistry._api.api) {
+        scheme._registry = previousRegistry;
+      } else {
+        scheme._registry = newRegistry;
+      }
+    });
+    return import_jskos_tools11.default.sortSchemes(schemes.filter(Boolean));
   }
   registryForScheme(scheme) {
     let registry = scheme._registry;
@@ -2752,7 +3073,7 @@ var CocodaSDK = class {
       const url = config.url;
       if (registryCache[url]) {
         const registry2 = registryCache[url];
-        if (Array.isArray(registry2._jskos.schemes) && !import_jskos_tools10.default.isContainedIn(scheme, registry2._jskos.schemes)) {
+        if (Array.isArray(registry2._jskos.schemes) && !import_jskos_tools11.default.isContainedIn(scheme, registry2._jskos.schemes)) {
           registry2._jskos.schemes.push(scheme);
         }
         return registry2;
@@ -2788,7 +3109,6 @@ var cdk = new CocodaSDK();
 function addAllProviders(_cdk) {
   Object.values(providers_exports).forEach((provider) => (_cdk || cdk).addProvider(provider));
 }
-module.exports = __toCommonJS(src_exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BaseProvider,
@@ -2800,6 +3120,7 @@ module.exports = __toCommonJS(src_exports);
   MappingsApiProvider,
   OccurrencesApiProvider,
   ReconciliationApiProvider,
+  SkohubProvider,
   SkosmosApiProvider,
   addAllProviders,
   cdk,