@opennetwork/rdf-data-model/esnext/data-factory.js

import { isNamedNode, isNamedNodeLike, NamedNode } from "./named-node.js";
import { isBlankNodeLike, BlankNode, isBlankNode } from "./blank-node.js";
import { isLiteral, isLiteralLike, Literal } from "./literal.js";
import { isVariable, isVariableLike, Variable } from "./variable.js";
import { isDefaultGraphLike, DefaultGraph, isDefaultGraph } from "./default-graph.js";
import { isQuadLike, Quad } from "./quad.js";
import { isTermLike } from "./term.js";
import UUID from "pure-uuid";
export class DataFactory {
    constructor() {
        this.blankNode = (value) => {
            return new BlankNode((value || `blank-${new UUID(4).format()}`).replace(/^_:/, ""));
        };
        this.literal = (value, languageOrDataType) => {
            const getLiteral = (value, languageOrDataType) => {
                if (typeof languageOrDataType === "string") {
                    return new Literal(value, languageOrDataType, this.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#langString"));
                }
                else if (isNamedNodeLike(languageOrDataType)) {
                    return new Literal(value, "", this.fromTerm(languageOrDataType));
                }
                else {
                    return new Literal(value, "", this.namedNode("http://www.w3.org/2001/XMLSchema#string"));
                }
            };
            // "value"@en
            // "value"^^xsd:string
            // "value"@<language uri>
            const firstIndex = value.indexOf('"'), lastIndex = value.lastIndexOf('"');
            if (firstIndex === -1 || lastIndex === firstIndex) {
                return getLiteral(value, languageOrDataType);
            }
            const newValue = value.substr(firstIndex + 1, lastIndex - firstIndex - 1), rest = value.substr(lastIndex + 1);
            if (rest.startsWith("^^")) {
                return getLiteral(newValue, this.namedNode(rest.substr(2)));
            }
            if (rest.startsWith("@")) {
                const language = rest.substr(1);
                // If no language, its a normal string
                return getLiteral(newValue, language === "" ? undefined : language);
            }
            if (rest.startsWith("<") && rest.endsWith(">")) {
                return getLiteral(newValue, rest.substr(1, rest.length - 2));
            }
            return getLiteral(value, languageOrDataType);
        };
        this.variable = (value) => {
            return new Variable(value.replace(/^\?/, ""));
        };
        this.defaultGraph = () => {
            return new DefaultGraph();
        };
        this.quad = (subject, predicate, object, graph) => {
            return new Quad(this.fromTerm(subject), this.fromTerm(predicate), this.fromTerm(object), this.fromTerm(graph));
        };
        this.fromTerm = (term) => {
            if (!isTermLike(term)) {
                throw new Error("Provided value is not a Term");
            }
            if (isNamedNode(term)) {
                return term;
            }
            else if (isNamedNodeLike(term)) {
                return this.namedNode(term.value);
            }
            else if (isBlankNode(term)) {
                return term;
            }
            else if (isBlankNodeLike(term)) {
                return this.blankNode(term.value);
            }
            else if (isLiteral(term)) {
                return term;
            }
            else if (isLiteralLike(term)) {
                // Use direct map as the way `literal` is defined it may drop language or datatype
                // This allows _both_ language and datatype
                return new Literal(term.value, term.language, this.namedNode(term.datatype.value));
            }
            else if (isVariable(term)) {
                return term;
            }
            else if (isVariableLike(term)) {
                return this.variable(term.value);
            }
            else if (isDefaultGraph(term)) {
                return term;
            }
            else if (isDefaultGraphLike(term)) {
                return this.defaultGraph();
            }
            // Unknown
            throw new Error("Invalid term type, expected one of NamedNode | BlankNode | Literal | Variable | DefaultGraph");
        };
        this.fromQuad = (quad) => {
            if (!isQuadLike(quad)) {
                throw new Error("Provided value is not a Quad");
            }
            return this.quad(quad.subject, quad.predicate, quad.object, quad.graph);
        };
        this.namedNode = this.namedNode.bind(this);
    }
    namedNode(value) {
        return new NamedNode(value);
    }
}
export const DefaultDataFactory = new DataFactory();
//# sourceMappingURL=data-factory.js.map