cocoda-sdk 3.2.3 → 3.3.0

package/dist/esm/index.js

@@ -1,5 +1,6 @@
 import CocodaSDK from "./lib/CocodaSDK.js";
 import * as errors from "./errors/index.js";
+import * as utils from "./utils/index.js";
 export * from "./providers/index.js";
 const cdk = new CocodaSDK();
 import * as providers from "./providers/index.js";
@@ -10,5 +11,6 @@ export {
   CocodaSDK,
   addAllProviders,
   cdk,
-  errors
+  errors,
+  utils
 };

package/dist/esm/providers/base-provider.js

@@ -298,7 +298,7 @@ class BaseProvider {
       return (await this.getConcepts({ ...config, concepts: [concept] }))[0];
     };
     for (let type of ["broader", "narrower", "ancestors"]) {
-      if (Array.isArray(concept[type]) && !concept[type].includes(null)) {
+      if (Array.isArray(concept[type]) && concept[type].length && !concept[type].includes(null)) {
         concept[type] = this.adjustConcepts(concept[type]);
       }
     }

package/dist/esm/providers/index.js

@@ -8,6 +8,7 @@ import LabelSearchSuggestionProvider from "./label-search-suggestion-provider.js
 import SkosmosApiProvider from "./skosmos-api-provider.js";
 import LocApiProvider from "./loc-api-provider.js";
 import SkohubProvider from "./skohub-provider.js";
+import MyCoReProvider from "./mycore-provider.js";
 export {
   BaseProvider,
   ConceptApiProvider,
@@ -15,6 +16,7 @@ export {
   LocApiProvider,
   LocalMappingsProvider,
   MappingsApiProvider,
+  MyCoReProvider,
   OccurrencesApiProvider,
   ReconciliationApiProvider,
   SkohubProvider,

package/dist/esm/providers/mycore-provider.js

@@ -0,0 +1,216 @@
+import BaseProvider from "./base-provider.js";
+import * as _ from "../utils/lodash.js";
+import * as errors from "../errors/index.js";
+import { listOfCapabilities } from "../utils/index.js";
+import jskos from "jskos-tools";
+import FlexSearch from "flexsearch";
+const data = {};
+class MyCoReProvider 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._scheme = null;
+  }
+  static _registryConfigForBartocApiConfig({ url, scheme } = {}) {
+    if (!url || !scheme) {
+      return null;
+    }
+    return {
+      api: url
+    };
+  }
+  _schemeInfoToJSKOS(schemeInfo) {
+    const uri = schemeInfo.labels.find((l) => l.lang === "x-uri").text;
+    const prefLabel = {};
+    schemeInfo.labels.filter((l) => !l.lang.startsWith("x-")).forEach((l) => {
+      prefLabel[l.lang] = l.text;
+    });
+    const scheme = {
+      uri,
+      prefLabel
+    };
+    if (schemeInfo.categories && schemeInfo.categories.length) {
+      scheme.topConcepts = [null];
+    }
+    if (schemeInfo.category && schemeInfo.category.length) {
+      scheme.concepts = [null];
+    }
+    return scheme;
+  }
+  _categoryToJSKOS(category, { scheme, broader = [] }) {
+    if (!category || !scheme) {
+      return null;
+    }
+    const id = category.ID;
+    const uri = `${scheme.uri}/${id}`;
+    if (data[scheme.uri].concepts[uri]) {
+      return data[scheme.uri].concepts[uri];
+    }
+    const prefLabel = {};
+    category.labels.filter((l) => !l.lang.startsWith("x-") && l.text).forEach((l) => {
+      prefLabel[l.lang] = l.text.replace(`${id} `, "");
+      data[scheme.uri].searchIndex.add(uri, prefLabel[l.lang]);
+    });
+    const scopeNote = {};
+    category.labels.filter((l) => !l.lang.startsWith("x-") && l.description).forEach((l) => {
+      if (!scopeNote[l.lang]) {
+        scopeNote[l.lang] = [];
+      }
+      scopeNote[l.lang].push(l.description);
+    });
+    data[scheme.uri].concepts[uri] = {
+      uri,
+      notation: [id],
+      prefLabel,
+      scopeNote,
+      inScheme: [{ uri: scheme.uri }],
+      narrower: (category.categories || []).map((c) => ({ uri: `${scheme.uri}/${c.ID}` })),
+      broader
+    };
+    return data[scheme.uri].concepts[uri];
+  }
+  _removeNarrower(concept) {
+    if (!concept)
+      return concept;
+    return Object.assign({}, concept, { narrower: concept.narrower && concept.narrower.length ? [null] : [] });
+  }
+  async _loadSchemeData(config) {
+    const schemeInfo = await this.axios({
+      ...config,
+      method: "get",
+      url: this._api.api,
+      _skipAdditionalParameters: true
+    });
+    this._scheme = this._schemeInfoToJSKOS(schemeInfo);
+    const uri = this._scheme.uri;
+    data[uri] = {
+      schemeInfo,
+      searchIndex: FlexSearch.create({
+        tokenize: "full"
+      }),
+      concepts: {}
+    };
+    const dealWithCategory = (category, { broader = [] } = {}) => {
+      const concept = this._categoryToJSKOS(category, { scheme: this._scheme, broader });
+      (category.categories || []).forEach((c) => dealWithCategory(c, { broader: [{ uri: concept.uri }] }));
+    };
+    schemeInfo.categories.forEach((category) => dealWithCategory(category));
+    data[uri].topConcepts = schemeInfo.categories.map((category) => this._categoryToJSKOS(category, { scheme: this._scheme }));
+  }
+  async getSchemes(config = {}) {
+    if (!this._api.api) {
+      throw new errors.MissingApiUrlError();
+    }
+    if (!this._scheme) {
+      if (!this._loadSchemeDataPromise) {
+        this._loadSchemeDataPromise = this._loadSchemeData(config);
+      }
+      await this._loadSchemeDataPromise;
+    }
+    return [this._scheme];
+  }
+  async getTop({ scheme, ...config }) {
+    if (!scheme || !scheme.uri) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "scheme", message: "Missing scheme URI" });
+    }
+    if (!this._scheme) {
+      await this.getSchemes(config);
+    }
+    if (!jskos.compare(scheme, this._scheme)) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "scheme", message: "Requested vocabulary seems to be unsupported by this API." });
+    }
+    return data[this._scheme.uri].topConcepts.map(this._removeNarrower);
+  }
+  async getConcepts({ concepts, ...config }) {
+    if (!_.isArray(concepts)) {
+      concepts = [concepts];
+    }
+    if (!this._scheme) {
+      await this.getSchemes(config);
+    }
+    return concepts.map((c) => data[this._scheme.uri].concepts[c.uri]).map(this._removeNarrower);
+  }
+  async getAncestors({ concept, ...config }) {
+    if (!concept || !concept.uri) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "concept" });
+    }
+    if (concept.ancestors && concept.ancestors[0] !== null) {
+      return concept.ancestors;
+    }
+    if (!this._scheme) {
+      await this.getSchemes(config);
+    }
+    concept = data[this._scheme.uri].concepts[concept.uri];
+    const broader = concept && concept.broader && concept.broader[0];
+    if (!broader) {
+      return [];
+    }
+    return [broader].concat(await this.getAncestors({ concept: broader, ...config }));
+  }
+  async getNarrower({ concept, ...config }) {
+    if (!concept || !concept.uri) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "concept" });
+    }
+    if (concept.narrower && concept.narrower[0] !== null) {
+      return concept.narrower;
+    }
+    if (!this._scheme) {
+      await this.getSchemes(config);
+    }
+    concept = data[this._scheme.uri].concepts[concept.uri];
+    return (concept && concept.narrower || []).map((c) => data[this._scheme.uri].concepts[c.uri]).map(this._removeNarrower);
+  }
+  async search({ search, scheme, limit = 100 }) {
+    if (!scheme || !scheme.uri) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "scheme" });
+    }
+    if (!search) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "search" });
+    }
+    if (!scheme || !scheme.uri) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "scheme", message: "Missing scheme URI" });
+    }
+    if (!this._scheme) {
+      await this.getSchemes();
+    }
+    if (!jskos.compare(scheme, this._scheme)) {
+      throw new errors.InvalidOrMissingParameterError({ parameter: "scheme", message: "Requested vocabulary seems to be unsupported by this API." });
+    }
+    const result = await data[this._scheme.uri].searchIndex.search(search);
+    return result.map((uri) => data[this._scheme.uri].concepts[uri]).map(this._removeNarrower).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 = jskos.notation(concept);
+      const label = jskos.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;
+  }
+}
+MyCoReProvider.providerName = "MyCoRe";
+MyCoReProvider.providerType = "http://bartoc.org/api-type/mycore";
+export {
+  MyCoReProvider as default
+};

package/dist/esm/providers/occurrences-api-provider.js

@@ -3,9 +3,13 @@ import jskos from "jskos-tools";
 import * as _ from "../utils/lodash.js";
 import * as errors from "../errors/index.js";
 import * as utils from "../utils/index.js";
+const cache = {};
 class OccurrencesApiProvider extends BaseProvider {
+  get _cache() {
+    return cache[this.uri];
+  }
   _prepare() {
-    this._cache = [];
+    cache[this.uri] = [];
     this._occurrencesSupportedSchemes = [];
     this.has.occurrences = true;
     this.has.mappings = true;
@@ -146,7 +150,7 @@ class OccurrencesApiProvider extends BaseProvider {
       data
     });
     if (this._cache.length > 20) {
-      this._cache = this._cache.slice(this._cache.length - 20);
+      cache[this.uri] = this._cache.slice(this._cache.length - 20);
     }
     return data;
   }

package/dist/esm/providers/reconciliation-api-provider.js

@@ -3,9 +3,13 @@ import jskos from "jskos-tools";
 import * as _ from "../utils/lodash.js";
 import * as errors from "../errors/index.js";
 import { listOfCapabilities } from "../utils/index.js";
+const cache = {};
 class ReconciliationApiProvider extends BaseProvider {
+  get _cache() {
+    return cache[this.uri];
+  }
   _prepare() {
-    this._cache = [];
+    cache[this.uri] = [];
     this.has.mappings = true;
     listOfCapabilities.filter((c) => !this.has[c]).forEach((c) => {
       this.has[c] = false;
@@ -132,7 +136,7 @@ class ReconciliationApiProvider extends BaseProvider {
     };
     this._cache.push(newCacheEntry);
     if (this._cache.length > 20) {
-      this._cache = this._cache.slice(this._cache.length - 20);
+      cache[this.uri] = this._cache.slice(this._cache.length - 20);
     }
     return newCacheEntry;
   }

package/dist/esm/providers/skohub-provider.js

@@ -12,6 +12,7 @@ function decodeUnicode(text) {
     }
   );
 }
+const data = {};
 class SkohubProvider extends BaseProvider {
   _prepare() {
     this.has.schemes = true;
@@ -25,11 +26,20 @@ class SkohubProvider extends BaseProvider {
     listOfCapabilities.filter((c) => !this.has[c]).forEach((c) => {
       this.has[c] = false;
     });
+    data[this.uri] = {
+      index: {},
+      conceptCache: {},
+      schemeCache: {}
+    };
   }
-  _setup() {
-    this._index = {};
-    this._conceptCache = {};
-    this._schemeCache = {};
+  get _index() {
+    return data[this.uri] && data[this.uri].index;
+  }
+  get _conceptCache() {
+    return data[this.uri] && data[this.uri].conceptCache;
+  }
+  get _schemeCache() {
+    return data[this.uri] && data[this.uri].schemeCache;
   }
   static _registryConfigForBartocApiConfig({ url, scheme } = {}) {
     if (!url || !scheme) {
@@ -55,11 +65,11 @@ class SkohubProvider extends BaseProvider {
     if (uri.endsWith("/")) {
       postfix = "index.json";
     }
-    const data = await this.axios({ ...config, url: `${uri}${postfix}`, _skipAdditionalParameters: true });
-    if (data.id !== uri) {
+    const data2 = await this.axios({ ...config, url: `${uri}${postfix}`, _skipAdditionalParameters: true });
+    if (data2.id !== uri) {
       throw new errors.InvalidRequestError({ message: "Skohub URL did not return expected concept scheme" });
     }
-    const { title, preferredNamespaceUri, hasTopConcept, description } = data;
+    const { title, preferredNamespaceUri, hasTopConcept, description } = data2;
     scheme = { uri, identifier: uris.filter((u) => u !== uri) };
     scheme.prefLabel = title;
     Object.keys(scheme.prefLabel || {}).forEach((key) => {
@@ -87,33 +97,33 @@ class SkohubProvider extends BaseProvider {
       return this._conceptCache[uri];
     }
     try {
-      const data = await this.axios({ ...config, url: `${uri}.json`, _skipAdditionalParameters: true });
-      if (data.id !== uri) {
+      const data2 = await this.axios({ ...config, url: `${uri}.json`, _skipAdditionalParameters: true });
+      if (data2.id !== uri) {
         throw new errors.InvalidRequestError({ message: "Skohub URL did not return expected concept URI" });
       }
-      const concept = this._toJskosConcept(data);
+      const concept = this._toJskosConcept(data2);
       this._conceptCache[uri] = concept;
       return concept;
     } catch (error) {
       return null;
     }
   }
-  _toJskosConcept(data) {
-    const concept = { uri: data.id };
-    concept.prefLabel = data.prefLabel;
+  _toJskosConcept(data2) {
+    const concept = { uri: data2.id };
+    concept.prefLabel = data2.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 }];
+    concept.narrower = (data2.narrower || []).map((c) => this._toJskosConcept(c));
+    concept.notation = data2.notation || [];
+    if (data2.broader && data2.broader.id) {
+      concept.broader = [{ uri: data2.broader.id }];
     }
-    if (data.inScheme && data.inScheme.id) {
-      concept.inScheme = [{ uri: data.inScheme.id }];
+    if (data2.inScheme && data2.inScheme.id) {
+      concept.inScheme = [{ uri: data2.inScheme.id }];
     }
-    if (data.scopeNote) {
-      concept.scopeNote = data.scopeNote;
+    if (data2.scopeNote) {
+      concept.scopeNote = data2.scopeNote;
       Object.keys(concept.scopeNote).forEach((key) => {
         concept.scopeNote[key] = [decodeUnicode(concept.scopeNote[key])];
       });
@@ -185,13 +195,13 @@ class SkohubProvider extends BaseProvider {
         if (scheme.uri.endsWith("/")) {
           postfix = `index${postfix}`;
         }
-        const data = await this.axios({ url: `${scheme.uri}${postfix}`, _skipAdditionalParameters: true });
-        if (data.length < 100) {
+        const data2 = await this.axios({ url: `${scheme.uri}${postfix}`, _skipAdditionalParameters: true });
+        if (data2.length < 100) {
           this._index[scheme.uri][lang] = null;
           continue;
         }
         index = FlexSearch.create();
-        index.import(data);
+        index.import(data2);
         this._index[scheme.uri][lang] = index;
         break;
       } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cocoda-sdk",
-  "version": "3.2.3",
+  "version": "3.3.0",
   "description": "SDK for Cocoda",
   "main": "dist/cjs/index.cjs",
   "module": "dist/esm/index.js",
@@ -27,7 +27,7 @@
     "release:patch": "SEMVER=patch npm run release",
     "release:minor": "SEMVER=minor npm run release",
     "release:major": "SEMVER=major npm run release",
-    "postinstall": "[ -d './dist' ] || npm run build"
+    "prepare": "[ -d './dist' ] || npm run build"
   },
   "lint-staged": {
     "**/*.js": [