@oslo-flanders/core 0.0.3-alpha.0 → 0.0.5-alpha.0

package/lib/utils/N3StoreFunctions.d.ts

@@ -1,136 +0,0 @@
-import type * as RDF from '@rdfjs/types';
-import * as N3 from 'n3';
-/**
- * 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 declare function createN3Store(file: string): Promise<N3.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 declare function getTargetStatementId(statementSubject: RDF.Term, statementPredicate: RDF.Term, statementObject: RDF.Term, store: N3.Store): RDF.Term | undefined;
-/**
- * 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 declare function getAssignedUri(subject: RDF.Term, store: N3.Store): RDF.Term | undefined;
-/**
- * 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 declare function getAssignedUriViaStatements(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term, store: N3.Store): RDF.Term | undefined;
-/**
- * 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 declare function getLabels(subject: RDF.Term, store: N3.Store): RDF.Literal[];
-/**
- * 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 declare function getLabel(subject: RDF.Term, store: N3.Store, language?: string): RDF.Literal | undefined;
-/**
- * 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 declare function getLabelViaStatements(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term, store: N3.Store, language: string): RDF.Literal | undefined;
-/**
- * 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 declare function getDefinitions(subject: RDF.Term, store: N3.Store): RDF.Literal[];
-/**
- * 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 declare function getDefinition(subject: RDF.Term, store: N3.Store, language?: string): RDF.Literal | undefined;
-/**
- * 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 declare function getDefinitionViaStatements(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term, store: N3.Store, language: string): RDF.Literal | undefined;
-/**
- * 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 declare function getParentsOfClass(subject: RDF.Term, store: N3.Store): RDF.Term[];
-/**
- * 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 declare function getParentOfProperty(subject: RDF.Term, store: N3.Store): RDF.Term | undefined;
-/**
- * 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 declare function getRange(subject: RDF.Term, store: N3.Store): RDF.Term | undefined;
-/**
- * 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 declare function getDomain(subject: RDF.Term, store: N3.Store): RDF.Term | undefined;
-/**
- * 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 declare function getUsageNotes(subject: RDF.Term, store: N3.Store): RDF.Literal[];
-/**
- * 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 declare function getUsageNote(subject: RDF.Term, store: N3.Store, language?: string): RDF.Literal | undefined;
-/**
- * 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 declare function getUsageNoteViaStatements(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term, store: N3.Store, language: string): RDF.Literal | undefined;

package/lib/utils/N3StoreFunctions.js

@@ -1,257 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUsageNoteViaStatements = exports.getUsageNote = exports.getUsageNotes = exports.getDomain = exports.getRange = exports.getParentOfProperty = exports.getParentsOfClass = exports.getDefinitionViaStatements = exports.getDefinition = exports.getDefinitions = exports.getLabelViaStatements = exports.getLabel = exports.getLabels = exports.getAssignedUriViaStatements = exports.getAssignedUri = exports.getTargetStatementId = exports.createN3Store = void 0;
-const N3 = __importStar(require("n3"));
-const rdf_parse_1 = __importDefault(require("rdf-parse"));
-const fetchFileOrUrl_1 = require("./fetchFileOrUrl");
-const namespaces_1 = require("./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
- */
-async function createN3Store(file) {
-    const store = new N3.Store();
-    const buffer = await (0, fetchFileOrUrl_1.fetchFileOrUrl)(file);
-    const textStream = require('streamify-string')(buffer.toString());
-    return new Promise((resolve, reject) => {
-        rdf_parse_1.default.parse(textStream, { path: file })
-            .on('data', (quad) => store.addQuad(quad))
-            .on('error', (error) => reject(error))
-            .on('end', () => resolve(store));
-    });
-}
-exports.createN3Store = createN3Store;
-/**
- * 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
- */
-function getTargetStatementId(statementSubject, statementPredicate, statementObject, store) {
-    const statementIds = store.getSubjects(namespaces_1.ns.rdf('type'), namespaces_1.ns.rdf('Statement'), null);
-    const statementSubjectPredicateSubjects = store.getSubjects(namespaces_1.ns.rdf('subject'), statementSubject, null);
-    const statementPredicatePredicateSubjects = store.getSubjects(namespaces_1.ns.rdf('predicate'), statementPredicate, null);
-    const statementObjectPredicateSubjects = store.getSubjects(namespaces_1.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();
-}
-exports.getTargetStatementId = getTargetStatementId;
-/**
- * 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
- */
-function getAssignedUri(subject, store) {
-    return store.getObjects(subject, namespaces_1.ns.example('assignedUri'), null).shift();
-}
-exports.getAssignedUri = getAssignedUri;
-/**
- * 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
- */
-function getAssignedUriViaStatements(subject, predicate, object, store) {
-    const statementId = getTargetStatementId(subject, predicate, object, store);
-    if (!statementId) {
-        return undefined;
-    }
-    return getAssignedUri(statementId, store);
-}
-exports.getAssignedUriViaStatements = getAssignedUriViaStatements;
-/**
- * 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
- */
-function getLabels(subject, store) {
-    return store.getObjects(subject, namespaces_1.ns.rdfs('label'), null);
-}
-exports.getLabels = getLabels;
-/**
- * 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
- */
-function getLabel(subject, store, language) {
-    return getLabels(subject, store).find(x => x.language === (language || ''));
-}
-exports.getLabel = getLabel;
-/**
- * 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
- */
-function getLabelViaStatements(subject, predicate, object, store, language) {
-    const statementId = getTargetStatementId(subject, predicate, object, store);
-    if (!statementId) {
-        return undefined;
-    }
-    const label = getLabel(statementId, store, language);
-    return label || getLabel(statementId, store);
-}
-exports.getLabelViaStatements = getLabelViaStatements;
-/**
- * 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
- */
-function getDefinitions(subject, store) {
-    return store.getObjects(subject, namespaces_1.ns.rdfs('comment'), null);
-}
-exports.getDefinitions = getDefinitions;
-/**
- * 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
- */
-function getDefinition(subject, store, language) {
-    return getDefinitions(subject, store).find(x => x.language === (language || ''));
-}
-exports.getDefinition = getDefinition;
-/**
- * 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
- */
-function getDefinitionViaStatements(subject, predicate, object, store, language) {
-    const statementId = getTargetStatementId(subject, predicate, object, store);
-    if (!statementId) {
-        return undefined;
-    }
-    const definition = getDefinition(statementId, store, language);
-    return definition || getDefinition(statementId, store);
-}
-exports.getDefinitionViaStatements = getDefinitionViaStatements;
-/**
- * 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
- */
-function getParentsOfClass(subject, store) {
-    return store.getObjects(subject, namespaces_1.ns.rdfs('subClassOf'), null);
-}
-exports.getParentsOfClass = getParentsOfClass;
-/**
- * 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
- */
-function getParentOfProperty(subject, store) {
-    return store.getObjects(subject, namespaces_1.ns.rdfs('subPropertyOf'), null).shift();
-}
-exports.getParentOfProperty = getParentOfProperty;
-/**
- * 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
- */
-function getRange(subject, store) {
-    return store.getObjects(subject, namespaces_1.ns.rdfs('range'), null).shift();
-}
-exports.getRange = getRange;
-/**
- * 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
- */
-function getDomain(subject, store) {
-    return store.getObjects(subject, namespaces_1.ns.rdfs('domain'), null).shift();
-}
-exports.getDomain = getDomain;
-/**
- * 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
- */
-function getUsageNotes(subject, store) {
-    return store.getObjects(subject, namespaces_1.ns.vann('usageNote'), null);
-}
-exports.getUsageNotes = getUsageNotes;
-/**
- * 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
- */
-function getUsageNote(subject, store, language) {
-    return getUsageNotes(subject, store).find(x => x.language === (language || ''));
-}
-exports.getUsageNote = getUsageNote;
-/**
- * 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
- */
-function getUsageNoteViaStatements(subject, predicate, object, store, language) {
-    const statementId = getTargetStatementId(subject, predicate, object, store);
-    if (!statementId) {
-        return undefined;
-    }
-    const usageNote = getUsageNote(statementId, store, language);
-    return usageNote || getUsageNote(statementId, store);
-}
-exports.getUsageNoteViaStatements = getUsageNoteViaStatements;
-//# sourceMappingURL=N3StoreFunctions.js.map