@oslo-flanders/core 0.0.1-alpha.0

package/lib/utils/N3StoreFunctions.ts

@@ -0,0 +1,268 @@
+import type * as RDF from '@rdfjs/types';
+import * as N3 from 'n3';
+import rdfParser from 'rdf-parse';
+import { fetchFileOrUrl } from './fetchFileOrUrl';
+import { ns } from './namespaces';
+
+/**
+ * Given a local file, it is parsed and added to an in-memory quad store
+ * @param fileOrUrl Local path of the input file
+ * @returns A N3 quad store
+ */
+export async function createN3Store(file: string): Promise<N3.Store> {
+  const store = new N3.Store();
+  const buffer = await fetchFileOrUrl(file);
+  const textStream = require('streamify-string')(buffer.toString());
+
+  return new Promise<N3.Store>((resolve, reject) => {
+    rdfParser.parse(textStream, { path: file })
+      .on('data', (quad: RDF.Quad) => store.addQuad(quad))
+      .on('error', (error: unknown) => reject(error))
+      .on('end', () => resolve(store));
+  });
+}
+
+/**
+ * Find the subject of the statement that matches the given subject, predicate and object
+ * @param statementSubject The subject to match the statement subject
+ * @param statementPredicate The predicate to match the statement predicate
+ * @param statementObject The object to match the statement object
+ * @param store An N3 quad store
+ * @returns an RDF.Term or undefined if none found
+ */
+export function getTargetStatementId(
+  statementSubject: RDF.Term,
+  statementPredicate: RDF.Term,
+  statementObject: RDF.Term,
+  store: N3.Store,
+): RDF.Term | undefined {
+  const statementIds = store.getSubjects(ns.rdf('type'), ns.rdf('Statement'), null);
+  const statementSubjectPredicateSubjects = store.getSubjects(ns.rdf('subject'), statementSubject, null);
+  const statementPredicatePredicateSubjects = store.getSubjects(ns.rdf('predicate'), statementPredicate, null);
+  const statementObjectPredicateSubjects = store.getSubjects(ns.rdf('object'), statementObject, null);
+
+  const targetIds = statementIds
+    .filter(x => statementSubjectPredicateSubjects.some(y => y.value === x.value))
+    .filter(x => statementPredicatePredicateSubjects.some(y => y.value === x.value))
+    .filter(x => statementObjectPredicateSubjects.some(y => y.value === x.value));
+
+  if (targetIds.length > 1) {
+    throw new Error(`Found multiple statements with subject "${statementSubject.value}", predicate "${statementPredicate.value}" and object "${statementObject.value}".`);
+  }
+
+  return targetIds.shift();
+}
+
+/**
+ * For a given subject, the quad store is queried to find the assigned URI
+ * @param subject The subject for which the assigned URI is to be retrieved
+ * @param store The quad store
+ * @returns An RDF.NamedNode or undefined if not found
+ */
+export function getAssignedUri(subject: RDF.Term, store: N3.Store): RDF.Term | undefined {
+  return store.getObjects(subject, ns.example('assignedUri'), null).shift();
+}
+
+/**
+ * Finds the assigned URI in rdf:Statements
+ * @param subject The statement subject
+ * @param predicate The statement predicate
+ * @param object The statement object for which the assigned URI must be found
+ * @param store A N3 quad store
+ * @returns An RDF.Term or undefined if not found
+ */
+export function getAssignedUriViaStatements(
+  subject: RDF.Term,
+  predicate: RDF.Term,
+  object: RDF.Term,
+  store: N3.Store,
+): RDF.Term | undefined {
+  const statementId = getTargetStatementId(subject, predicate, object, store);
+
+  if (!statementId) {
+    return undefined;
+  }
+
+  return getAssignedUri(statementId, store);
+}
+
+/**
+ * Find all rdfs:labels for a given subject
+ * @param subject The RDF.Term to find the rdfs:labels for
+ * @param store A N3 quad store
+ * @returns An array of RDF.Literals
+ */
+export function getLabels(subject: RDF.Term, store: N3.Store): RDF.Literal[] {
+  return <RDF.Literal[]>store.getObjects(subject, ns.rdfs('label'), null);
+}
+
+/**
+ * Finds the rdfs:label whose language tag matches the given language
+ * @param subject The RDF.Term to find the rdfs:label for
+ * @param store A N3 quad store
+ * @param language A language tag
+ * @returns An RDF.Literal or undefined if not found
+ */
+export function getLabel(subject: RDF.Term, store: N3.Store, language?: string): RDF.Literal | undefined {
+  return getLabels(subject, store).find(x => x.language === (language || ''));
+}
+
+/**
+ * Finds the rdfs:label for an RDF.Term in rdf:Statements
+ * @param subject The statement subject
+ * @param predicate The statement predicate
+ * @param object The statement object for which the label must be found
+ * @param store A N3 quad store
+ * @param language A language tag
+ * @returns An RDF.Literal or undefined if not found
+ */
+export function getLabelViaStatements(
+  subject: RDF.Term,
+  predicate: RDF.Term,
+  object: RDF.Term,
+  store: N3.Store,
+  language: string,
+): RDF.Literal | undefined {
+  const statementId = getTargetStatementId(subject, predicate, object, store);
+
+  if (!statementId) {
+    return undefined;
+  }
+
+  const label = getLabel(statementId, store, language);
+  return label || getLabel(statementId, store);
+}
+
+/**
+ * Find all rdfs:comments for a given subject
+ * @param subject The RDF.Term to find the rdfs:comments for
+ * @param store A N3 quad store
+ * @returns An array of RDF.Literals
+ */
+export function getDefinitions(subject: RDF.Term, store: N3.Store): RDF.Literal[] {
+  return <RDF.Literal[]>store.getObjects(subject, ns.rdfs('comment'), null);
+}
+
+/**
+ * Finds the rdfs:comment whose language tag matches the given language
+ * @param subject The RDF.Term to find the rdfs:comment for
+ * @param store A N3 quad store
+ * @param language A language tag
+ * @returns An RDF.Literal or undefined if not found
+ */
+export function getDefinition(subject: RDF.Term, store: N3.Store, language?: string): RDF.Literal | undefined {
+  return getDefinitions(subject, store).find(x => x.language === (language || ''));
+}
+
+/**
+ * Finds the rdfs:comment for an RDF.Term in rdf:Statements
+ * @param subject The statement subject
+ * @param predicate The statement predicate
+ * @param object The statement object for which the definition must be found
+ * @param store A N3 quad store
+ * @param language A language tag
+ * @returns An RDF.Literal or undefined if not found
+ */
+export function getDefinitionViaStatements(
+  subject: RDF.Term,
+  predicate: RDF.Term,
+  object: RDF.Term,
+  store: N3.Store,
+  language: string,
+): RDF.Literal | undefined {
+  const statementId = getTargetStatementId(subject, predicate, object, store);
+
+  if (!statementId) {
+    return undefined;
+  }
+
+  const definition = getDefinition(statementId, store, language);
+  return definition || getDefinition(statementId, store);
+}
+
+/**
+ * Finds all the rdfs:subClassOf of a given RDF.Term
+ * @param subject the RDF.Term to find the parents of
+ * @param store A N3 quad store
+ * @returns An array of RDF.Terms
+ */
+export function getParentsOfClass(subject: RDF.Term, store: N3.Store): RDF.Term[] {
+  return store.getObjects(subject, ns.rdfs('subClassOf'), null);
+}
+
+/**
+ * Finds the rdfs:subPropertyOf of a given RDF.Term
+ * @param subject The RDF.Term to find the parent of
+ * @param store A N3 quad store
+ * @returns An RDF.Term or undefined if not found
+ */
+export function getParentOfProperty(subject: RDF.Term, store: N3.Store): RDF.Term | undefined {
+  return store.getObjects(subject, ns.rdfs('subPropertyOf'), null).shift();
+}
+
+/**
+ * Finds the rdfs:range of a given RDF.Term
+ * @param subject The RDF.Term to find the range of
+ * @param store A N3 quad store
+ * @returns An RDF.Term or undefined if not found
+ */
+export function getRange(subject: RDF.Term, store: N3.Store): RDF.Term | undefined {
+  return store.getObjects(subject, ns.rdfs('range'), null).shift();
+}
+
+/**
+ * Finds the rdfs:domain of a given RDF.Term
+ * @param subject The RDF.Term to find the domain of
+ * @param store A N3 quad store
+ * @returns An RDF.Term or undefined if not found
+ */
+export function getDomain(subject: RDF.Term, store: N3.Store): RDF.Term | undefined {
+  return store.getObjects(subject, ns.rdfs('domain'), null).shift();
+}
+
+/**
+ * Finds all the vann:usageNotes of a given RDF.Term
+ * @param subject The RDF.Term to find the usage notes for
+ * @param store A N3 quad store
+ * @returns An array of RDF.Literals
+ */
+export function getUsageNotes(subject: RDF.Term, store: N3.Store): RDF.Literal[] {
+  return <RDF.Literal[]>store.getObjects(subject, ns.vann('usageNote'), null);
+}
+
+/**
+ * Finds the vann:usageNote of which the language tag matches the given language
+ * @param subject The RDF.Term to find the usage note for
+ * @param store A N3 quad store
+ * @param language A language tag
+ * @returns An RDF.Literal or undefined if not found
+ */
+export function getUsageNote(subject: RDF.Term, store: N3.Store, language?: string): RDF.Literal | undefined {
+  return getUsageNotes(subject, store).find(x => x.language === (language || ''));
+}
+
+/**
+ * Finds the vann:usageNote for an RDF.Term in rdf:Statements
+ * @param subject The statement subject
+ * @param predicate The statement predicate
+ * @param object The statement object for which the usage note must be found
+ * @param store A N3 quad store
+ * @param language A language tag
+ * @returns An RDF.Literal or undefined if not found
+ */
+export function getUsageNoteViaStatements(
+  subject: RDF.Term,
+  predicate: RDF.Term,
+  object: RDF.Term,
+  store: N3.Store,
+  language: string,
+): RDF.Literal | undefined {
+  const statementId = getTargetStatementId(subject, predicate, object, store);
+
+  if (!statementId) {
+    return undefined;
+  }
+
+  const usageNote = getUsageNote(statementId, store, language);
+  return usageNote || getUsageNote(statementId, store);
+}

package/lib/utils/fetchFileOrUrl.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare function fetchFileOrUrl(file: string): Promise<Buffer>;

package/lib/utils/fetchFileOrUrl.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchFileOrUrl = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+async function fetchFileOrUrl(file) {
+    if (file.startsWith('http://') || file.startsWith('https://')) {
+        return (await (0, node_fetch_1.default)(file)).buffer();
+    }
+    if (file.startsWith('file://')) {
+        file = file.slice(7);
+    }
+    if (!(0, fs_1.existsSync)(file) || !(await (0, promises_1.stat)(file)).isFile()) {
+        throw new Error(`Path does not refer to a valid file: ${file}`);
+    }
+    return (0, promises_1.readFile)(file);
+}
+exports.fetchFileOrUrl = fetchFileOrUrl;
+//# sourceMappingURL=fetchFileOrUrl.js.map

package/lib/utils/fetchFileOrUrl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchFileOrUrl.js","sourceRoot":"","sources":["fetchFileOrUrl.ts"],"names":[],"mappings":";;;;;;AAAA,2BAAgC;AAChC,0CAA6C;AAC7C,4DAA+B;AAExB,KAAK,UAAU,cAAc,CAAC,IAAY;IAC/C,IAAI,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE;QAC7D,OAAO,CAAC,MAAM,IAAA,oBAAK,EAAC,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;KACrC;IAED,IAAI,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE;QAC9B,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;KACtB;IAED,IAAI,CAAC,IAAA,eAAU,EAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,IAAA,eAAI,EAAC,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE;QACrD,MAAM,IAAI,KAAK,CAAC,wCAAwC,IAAI,EAAE,CAAC,CAAC;KACjE;IAED,OAAO,IAAA,mBAAQ,EAAC,IAAI,CAAC,CAAC;AACxB,CAAC;AAdD,wCAcC","sourcesContent":["import { existsSync } from 'fs';\r\nimport { readFile, stat } from 'fs/promises';\r\nimport fetch from 'node-fetch';\r\n\r\nexport async function fetchFileOrUrl(file: string): Promise<Buffer> {\r\n  if (file.startsWith('http://') || file.startsWith('https://')) {\r\n    return (await fetch(file)).buffer();\r\n  }\r\n\r\n  if (file.startsWith('file://')) {\r\n    file = file.slice(7);\r\n  }\r\n\r\n  if (!existsSync(file) || !(await stat(file)).isFile()) {\r\n    throw new Error(`Path does not refer to a valid file: ${file}`);\r\n  }\r\n\r\n  return readFile(file);\r\n}\r\n"]}

package/lib/utils/fetchFileOrUrl.ts

@@ -0,0 +1,19 @@
+import { existsSync } from 'fs';
+import { readFile, stat } from 'fs/promises';
+import fetch from 'node-fetch';
+
+export async function fetchFileOrUrl(file: string): Promise<Buffer> {
+  if (file.startsWith('http://') || file.startsWith('https://')) {
+    return (await fetch(file)).buffer();
+  }
+
+  if (file.startsWith('file://')) {
+    file = file.slice(7);
+  }
+
+  if (!existsSync(file) || !(await stat(file)).isFile()) {
+    throw new Error(`Path does not refer to a valid file: ${file}`);
+  }
+
+  return readFile(file);
+}

package/lib/utils/namespaces.d.ts

@@ -0,0 +1,24 @@
+declare enum Prefixes {
+    example = "http://example.org/",
+    adms = "http://www.w3.org/ns/adms#",
+    dcat = "http://www.w3.org/ns/dcat#",
+    dcterms = "http://purl.org/dc/terms/",
+    foaf = "http://xmlns.com/foaf/0.1/",
+    owl = "http://www.w3.org/2002/07/owl#",
+    vlaanderen = "https://data.vlaanderen.be/ns/",
+    void = "http://rdfs.org/ns/void#",
+    rdf = "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+    rdfs = "http://www.w3.org/2000/01/rdf-schema#",
+    qb = "http://purl.org/linked-data/cube#",
+    skos = "http://www.w3.org/2004/02/skos/core#",
+    xsd = "http://www.w3.org/2001/XMLSchema#",
+    person = "http://www.w3.org/ns/person#",
+    vann = "http://purl.org/vocab/vann/",
+    shacl = "http://w3.org/ns/shacl#",
+    prov = "http://www.w3.org/ns/prov#"
+}
+export declare type Namespace = {
+    [T in keyof typeof Prefixes]: Function;
+};
+export declare const ns: Namespace;
+export {};

package/lib/utils/namespaces.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ns = void 0;
+const rdf_data_factory_1 = require("rdf-data-factory");
+const factory = new rdf_data_factory_1.DataFactory();
+// TODO: remove example.org from prefixes
+var Prefixes;
+(function (Prefixes) {
+    Prefixes["example"] = "http://example.org/";
+    Prefixes["adms"] = "http://www.w3.org/ns/adms#";
+    Prefixes["dcat"] = "http://www.w3.org/ns/dcat#";
+    Prefixes["dcterms"] = "http://purl.org/dc/terms/";
+    Prefixes["foaf"] = "http://xmlns.com/foaf/0.1/";
+    Prefixes["owl"] = "http://www.w3.org/2002/07/owl#";
+    Prefixes["vlaanderen"] = "https://data.vlaanderen.be/ns/";
+    Prefixes["void"] = "http://rdfs.org/ns/void#";
+    Prefixes["rdf"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+    Prefixes["rdfs"] = "http://www.w3.org/2000/01/rdf-schema#";
+    Prefixes["qb"] = "http://purl.org/linked-data/cube#";
+    Prefixes["skos"] = "http://www.w3.org/2004/02/skos/core#";
+    Prefixes["xsd"] = "http://www.w3.org/2001/XMLSchema#";
+    Prefixes["person"] = "http://www.w3.org/ns/person#";
+    Prefixes["vann"] = "http://purl.org/vocab/vann/";
+    Prefixes["shacl"] = "http://w3.org/ns/shacl#";
+    Prefixes["prov"] = "http://www.w3.org/ns/prov#";
+})(Prefixes || (Prefixes = {}));
+const vocab = () => {
+    const namespaces = {};
+    for (const prefix in Prefixes) {
+        const expansion = Prefixes[prefix];
+        namespaces[prefix] = (localName = '') => factory.namedNode(expansion + localName);
+    }
+    return namespaces;
+};
+exports.ns = vocab();
+//# sourceMappingURL=namespaces.js.map

package/lib/utils/namespaces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespaces.js","sourceRoot":"","sources":["namespaces.ts"],"names":[],"mappings":";;;AAAA,uDAA+C;AAE/C,MAAM,OAAO,GAAG,IAAI,8BAAW,EAAE,CAAC;AAElC,yCAAyC;AACzC,IAAK,QAkBJ;AAlBD,WAAK,QAAQ;IACX,2CAA+B,CAAA;IAC/B,+CAAmC,CAAA;IACnC,+CAAmC,CAAA;IACnC,iDAAqC,CAAA;IACrC,+CAAmC,CAAA;IACnC,kDAAsC,CAAA;IACtC,yDAA6C,CAAA;IAC7C,6CAAiC,CAAA;IACjC,+DAAmD,CAAA;IACnD,0DAA8C,CAAA;IAC9C,oDAAwC,CAAA;IACxC,yDAA6C,CAAA;IAC7C,qDAAyC,CAAA;IACzC,mDAAuC,CAAA;IACvC,gDAAoC,CAAA;IACpC,6CAAiC,CAAA;IACjC,+CAAmC,CAAA;AACrC,CAAC,EAlBI,QAAQ,KAAR,QAAQ,QAkBZ;AAOD,MAAM,KAAK,GAAG,GAAc,EAAE;IAC5B,MAAM,UAAU,GAAQ,EAAE,CAAC;IAC3B,KAAK,MAAM,MAAM,IAAI,QAAQ,EAAE;QAC7B,MAAM,SAAS,GAAiB,QAAS,CAAC,MAAM,CAAC,CAAC;QAClD,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,GAAG,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC;KACnF;IAED,OAAkB,UAAU,CAAC;AAC/B,CAAC,CAAC;AAEW,QAAA,EAAE,GAAG,KAAK,EAAE,CAAC","sourcesContent":["import { DataFactory } from 'rdf-data-factory';\r\n\r\nconst factory = new DataFactory();\r\n\r\n// TODO: remove example.org from prefixes\r\nenum Prefixes {\r\n  example = 'http://example.org/',\r\n  adms = 'http://www.w3.org/ns/adms#',\r\n  dcat = 'http://www.w3.org/ns/dcat#',\r\n  dcterms = 'http://purl.org/dc/terms/',\r\n  foaf = 'http://xmlns.com/foaf/0.1/',\r\n  owl = 'http://www.w3.org/2002/07/owl#',\r\n  vlaanderen = 'https://data.vlaanderen.be/ns/',\r\n  void = 'http://rdfs.org/ns/void#',\r\n  rdf = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',\r\n  rdfs = 'http://www.w3.org/2000/01/rdf-schema#',\r\n  qb = 'http://purl.org/linked-data/cube#',\r\n  skos = 'http://www.w3.org/2004/02/skos/core#',\r\n  xsd = 'http://www.w3.org/2001/XMLSchema#',\r\n  person = 'http://www.w3.org/ns/person#',\r\n  vann = 'http://purl.org/vocab/vann/',\r\n  shacl = 'http://w3.org/ns/shacl#',\r\n  prov = 'http://www.w3.org/ns/prov#'\r\n}\r\n\r\nexport type Namespace = {\r\n  // eslint-disable-next-line @typescript-eslint/ban-types\r\n  [T in keyof typeof Prefixes]: Function;\r\n};\r\n\r\nconst vocab = (): Namespace => {\r\n  const namespaces: any = {};\r\n  for (const prefix in Prefixes) {\r\n    const expansion = <string>(<any>Prefixes)[prefix];\r\n    namespaces[prefix] = (localName = '') => factory.namedNode(expansion + localName);\r\n  }\r\n\r\n  return <Namespace>namespaces;\r\n};\r\n\r\nexport const ns = vocab();\r\n"]}

package/lib/utils/namespaces.ts

@@ -0,0 +1,41 @@
+import { DataFactory } from 'rdf-data-factory';
+
+const factory = new DataFactory();
+
+// TODO: remove example.org from prefixes
+enum Prefixes {
+  example = 'http://example.org/',
+  adms = 'http://www.w3.org/ns/adms#',
+  dcat = 'http://www.w3.org/ns/dcat#',
+  dcterms = 'http://purl.org/dc/terms/',
+  foaf = 'http://xmlns.com/foaf/0.1/',
+  owl = 'http://www.w3.org/2002/07/owl#',
+  vlaanderen = 'https://data.vlaanderen.be/ns/',
+  void = 'http://rdfs.org/ns/void#',
+  rdf = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+  rdfs = 'http://www.w3.org/2000/01/rdf-schema#',
+  qb = 'http://purl.org/linked-data/cube#',
+  skos = 'http://www.w3.org/2004/02/skos/core#',
+  xsd = 'http://www.w3.org/2001/XMLSchema#',
+  person = 'http://www.w3.org/ns/person#',
+  vann = 'http://purl.org/vocab/vann/',
+  shacl = 'http://w3.org/ns/shacl#',
+  prov = 'http://www.w3.org/ns/prov#'
+}
+
+export type Namespace = {
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  [T in keyof typeof Prefixes]: Function;
+};
+
+const vocab = (): Namespace => {
+  const namespaces: any = {};
+  for (const prefix in Prefixes) {
+    const expansion = <string>(<any>Prefixes)[prefix];
+    namespaces[prefix] = (localName = '') => factory.namedNode(expansion + localName);
+  }
+
+  return <Namespace>namespaces;
+};
+
+export const ns = vocab();

package/lib/utils/uniqueId.d.ts

@@ -0,0 +1 @@
+export declare function uniqueId(guid: string, label: string, id: number): string;

package/lib/utils/uniqueId.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniqueId = void 0;
+const crypto_js_1 = require("crypto-js");
+function uniqueId(guid, label, id) {
+    const object = {
+        guid,
+        label,
+        id,
+    };
+    return (0, crypto_js_1.SHA256)(JSON.stringify(object)).toString();
+}
+exports.uniqueId = uniqueId;
+//# sourceMappingURL=uniqueId.js.map

package/lib/utils/uniqueId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniqueId.js","sourceRoot":"","sources":["uniqueId.ts"],"names":[],"mappings":";;;AAAA,yCAAmC;AAEnC,SAAgB,QAAQ,CAAC,IAAY,EAAE,KAAa,EAAE,EAAU;IAC9D,MAAM,MAAM,GAAG;QACb,IAAI;QACJ,KAAK;QACL,EAAE;KACH,CAAC;IAEF,OAAO,IAAA,kBAAM,EAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;AACnD,CAAC;AARD,4BAQC","sourcesContent":["import { SHA256 } from 'crypto-js';\r\n\r\nexport function uniqueId(guid: string, label: string, id: number): string {\r\n  const object = {\r\n    guid,\r\n    label,\r\n    id,\r\n  };\r\n\r\n  return SHA256(JSON.stringify(object)).toString();\r\n}\r\n"]}

package/lib/utils/uniqueId.ts

@@ -0,0 +1,11 @@
+import { SHA256 } from 'crypto-js';
+
+export function uniqueId(guid: string, label: string, id: number): string {
+  const object = {
+    guid,
+    label,
+    id,
+  };
+
+  return SHA256(JSON.stringify(object)).toString();
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@oslo-flanders/core",
+  "version": "0.0.1-alpha.0",
+  "description": "Core interfaces and utilities",
+  "author": "Digitaal Vlaanderen <https://data.vlaanderen.be/id/organisatie/OVO002949>",
+  "homepage": "https://github.com/informatievlaanderen/OSLO-UML-Transformer/tree/main/packages/oslo-core#readme",
+  "license": "MIT",
+  "main": "index.js",
+  "directories": {
+    "lib": "lib"
+  },
+  "files": [
+    "lib"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Informatievlaanderen/OSLO-UML-Transformer.git"
+  },
+  "jest": {
+    "runner": "groups",
+    "transform": {
+      "^.+\\.ts$": "ts-jest"
+    },
+    "testRegex": "/test/.*.test.ts$",
+    "moduleFileExtensions": [
+      "ts",
+      "js"
+    ],
+    "collectCoverage": true,
+    "coveragePathIgnorePatterns": [
+      "/node_modules/",
+      "index.js",
+      "test/data/*",
+      "lib/utils/namespaces.ts"
+    ],
+    "testEnvironment": "node"
+  },
+  "scripts": {
+    "build": "npm run build:ts",
+    "build:ts": "tsc",
+    "test:unit": "node \"../../node_modules/jest/bin/jest.js\" --group=unit"
+  },
+  "bugs": {
+    "url": "https://github.com/Informatievlaanderen/OSLO-UML-Transformer/issues"
+  },
+  "dependencies": {
+    "rdf-parse": "^2.1.1",
+    "streamify-string": "^1.0.1",
+    "winston": "^3.8.2"
+  },
+  "devDependencies": {
+    "@types/node-fetch": "^2.6.2",
+    "@types/streamify-string": "^1.0.0",
+    "@types/tmp": "^0.2.3"
+  }
+}