@rdfx/data-factory 0.0.7

package/README.md

@@ -0,0 +1,5 @@
+# @rdfx/data-factory
+
+[RDF/JS DataFactory](https://rdf.js.org/data-model-spec/#datafactory-interface) implementation.
+
+Adapted from [rdf-data-factory.js](https://github.com/rubensworks/rdf-data-factory.js) (MIT license).

package/dist/BlankNode.d.ts

@@ -0,0 +1,12 @@
+import type * as RDF from "@rdfjs/types";
+import { Term } from "./Term.js";
+/**
+ * A term that represents an RDF blank node with a label.
+ */
+export declare class BlankNode extends Term implements RDF.BlankNode {
+    readonly value: string;
+    readonly termType = "BlankNode";
+    constructor(value: string);
+    equals(other?: RDF.Term | null): boolean;
+}
+//# sourceMappingURL=BlankNode.d.ts.map

package/dist/BlankNode.js

@@ -0,0 +1,15 @@
+import { Term } from "./Term.js";
+/**
+ * A term that represents an RDF blank node with a label.
+ */
+export class BlankNode extends Term {
+    constructor(value) {
+        super();
+        this.value = value;
+        this.termType = "BlankNode";
+    }
+    equals(other) {
+        return (!!other && other.termType === "BlankNode" && other.value === this.value);
+    }
+}
+//# sourceMappingURL=BlankNode.js.map

package/dist/DataFactory.d.ts

@@ -0,0 +1,79 @@
+import type * as RDF from "@rdfjs/types";
+import { BlankNode } from "./BlankNode.js";
+import { DefaultGraph } from "./DefaultGraph.js";
+import { Literal } from "./Literal.js";
+import { NamedNode } from "./NamedNode.js";
+import { Quad } from "./Quad.js";
+import { Variable } from "./Variable.js";
+/**
+ * A factory for instantiating RDF terms and quads.
+ */
+export declare class DataFactory implements RDF.DataFactory<Quad, RDF.Quad> {
+    private static readonly XSD_STRING;
+    private readonly blankNodePrefix;
+    private blankNodeCounter;
+    constructor(options?: {
+        blankNodePrefix?: string;
+    });
+    /**
+     * @param value The optional blank node identifier.
+     * @return A new instance of BlankNode.
+     *         If the `value` parameter is undefined a new identifier
+     *         for the blank node is generated for each call.
+     * @see BlankNode
+     */
+    blankNode(value?: string): BlankNode;
+    /**
+     * @return An instance of DefaultGraph.
+     */
+    defaultGraph(): DefaultGraph;
+    /**
+     * Create a deep copy of the given quad using this data factory.
+     * @param original An RDF quad.
+     * @return A deep copy of the given quad.
+     */
+    fromQuad(original: RDF.Quad): Quad;
+    /**
+     * Create a deep copy of the given term using this data factory.
+     * @param original An RDF term.
+     * @return A deep copy of the given term.
+     */
+    fromTerm<T extends RDF.Term>(original: T): T;
+    /**
+     * @param value              The literal value.
+     * @param languageOrDatatype The optional language, datatype, or directional language.
+     *                           If `languageOrDatatype` is a NamedNode,
+     *                           then it is used for the value of `NamedNode.datatype`.
+     *                           If `languageOrDatatype` is a NamedNode, it is used for the value
+     *                           of `NamedNode.language`.
+     *                           Otherwise, it is used as a directional language,
+     *                           from which the language is set to `languageOrDatatype.language`
+     *                           and the direction to `languageOrDatatype.direction`.
+     * @return A new instance of Literal.
+     * @see Literal
+     */
+    literal(value: string, languageOrDatatype?: string | RDF.NamedNode | RDF.DirectionalLanguage): Literal;
+    /**
+     * @param value The IRI for the named node.
+     * @return A new instance of NamedNode.
+     * @see NamedNode
+     */
+    namedNode<TIri extends string = string>(value: TIri): NamedNode<TIri>;
+    /**
+     * @param subject   The quad subject term.
+     * @param predicate The quad predicate term.
+     * @param object    The quad object term.
+     * @param graph     The quad graph term.
+     * @return A new instance of Quad.
+     * @see Quad
+     */
+    quad(subject: Quad["subject"], predicate: Quad["predicate"], object: Quad["object"], graph?: Quad["graph"]): Quad;
+    /**
+     * This method is optional.
+     * @param value The variable name
+     * @return A new instance of Variable.
+     * @see Variable
+     */
+    variable(value: string): Variable;
+}
+//# sourceMappingURL=DataFactory.d.ts.map

package/dist/DataFactory.js

@@ -0,0 +1,117 @@
+import { BlankNode } from "./BlankNode.js";
+import { DefaultGraph } from "./DefaultGraph.js";
+import { Literal } from "./Literal.js";
+import { NamedNode } from "./NamedNode.js";
+import { Quad } from "./Quad.js";
+import { Variable } from "./Variable.js";
+/**
+ * A factory for instantiating RDF terms and quads.
+ */
+export class DataFactory {
+    constructor(options) {
+        this.blankNodeCounter = 0;
+        options = options ?? {};
+        this.blankNodePrefix =
+            options.blankNodePrefix ?? `df_${dataFactoryCounter++}_`;
+    }
+    /**
+     * @param value The optional blank node identifier.
+     * @return A new instance of BlankNode.
+     *         If the `value` parameter is undefined a new identifier
+     *         for the blank node is generated for each call.
+     * @see BlankNode
+     */
+    blankNode(value) {
+        return new BlankNode(value ?? `${this.blankNodePrefix}${this.blankNodeCounter++}`);
+    }
+    /**
+     * @return An instance of DefaultGraph.
+     */
+    defaultGraph() {
+        return DefaultGraph.INSTANCE;
+    }
+    /**
+     * Create a deep copy of the given quad using this data factory.
+     * @param original An RDF quad.
+     * @return A deep copy of the given quad.
+     */
+    fromQuad(original) {
+        return this.fromTerm(original);
+    }
+    /**
+     * Create a deep copy of the given term using this data factory.
+     * @param original An RDF term.
+     * @return A deep copy of the given term.
+     */
+    fromTerm(original) {
+        // TODO: remove nasty any casts when this TS bug has been fixed:
+        //  https://github.com/microsoft/TypeScript/issues/26933
+        switch (original.termType) {
+            case "NamedNode":
+                return this.namedNode(original.value);
+            case "BlankNode":
+                return this.blankNode(original.value);
+            case "Literal":
+                if (original.language) {
+                    return this.literal(original.value, original.language);
+                }
+                if (!original.datatype.equals(DataFactory.XSD_STRING)) {
+                    return (this.literal(original.value, this.fromTerm(original.datatype)));
+                }
+                return this.literal(original.value);
+            case "Variable":
+                return this.variable(original.value);
+            case "DefaultGraph":
+                return this.defaultGraph();
+            case "Quad":
+                return (this.quad(this.fromTerm(original.subject), (this.fromTerm(original.predicate)), this.fromTerm(original.object), this.fromTerm(original.graph)));
+        }
+    }
+    /**
+     * @param value              The literal value.
+     * @param languageOrDatatype The optional language, datatype, or directional language.
+     *                           If `languageOrDatatype` is a NamedNode,
+     *                           then it is used for the value of `NamedNode.datatype`.
+     *                           If `languageOrDatatype` is a NamedNode, it is used for the value
+     *                           of `NamedNode.language`.
+     *                           Otherwise, it is used as a directional language,
+     *                           from which the language is set to `languageOrDatatype.language`
+     *                           and the direction to `languageOrDatatype.direction`.
+     * @return A new instance of Literal.
+     * @see Literal
+     */
+    literal(value, languageOrDatatype) {
+        return new Literal(value, languageOrDatatype);
+    }
+    /**
+     * @param value The IRI for the named node.
+     * @return A new instance of NamedNode.
+     * @see NamedNode
+     */
+    namedNode(value) {
+        return new NamedNode(value);
+    }
+    /**
+     * @param subject   The quad subject term.
+     * @param predicate The quad predicate term.
+     * @param object    The quad object term.
+     * @param graph     The quad graph term.
+     * @return A new instance of Quad.
+     * @see Quad
+     */
+    quad(subject, predicate, object, graph) {
+        return new Quad(subject, predicate, object, graph ?? this.defaultGraph());
+    }
+    /**
+     * This method is optional.
+     * @param value The variable name
+     * @return A new instance of Variable.
+     * @see Variable
+     */
+    variable(value) {
+        return new Variable(value);
+    }
+}
+DataFactory.XSD_STRING = new NamedNode("http://www.w3.org/2001/XMLSchema#string");
+let dataFactoryCounter = 0;
+//# sourceMappingURL=DataFactory.js.map

package/dist/DefaultGraph.d.ts

@@ -0,0 +1,14 @@
+import type * as RDF from "@rdfjs/types";
+import { Term } from "./Term.js";
+/**
+ * A singleton term instance that represents the default graph.
+ * It's only allowed to assign a DefaultGraph to the .graph property of a Quad.
+ */
+export declare class DefaultGraph extends Term implements RDF.DefaultGraph {
+    static INSTANCE: DefaultGraph;
+    readonly termType = "DefaultGraph";
+    readonly value = "";
+    private constructor();
+    equals(other?: RDF.Term | null): boolean;
+}
+//# sourceMappingURL=DefaultGraph.d.ts.map

package/dist/DefaultGraph.js

@@ -0,0 +1,17 @@
+import { Term } from "./Term.js";
+/**
+ * A singleton term instance that represents the default graph.
+ * It's only allowed to assign a DefaultGraph to the .graph property of a Quad.
+ */
+export class DefaultGraph extends Term {
+    constructor() {
+        super();
+        this.termType = "DefaultGraph";
+        this.value = "";
+    }
+    equals(other) {
+        return !!other && other.termType === "DefaultGraph";
+    }
+}
+DefaultGraph.INSTANCE = new DefaultGraph();
+//# sourceMappingURL=DefaultGraph.js.map

package/dist/Literal.d.ts

@@ -0,0 +1,20 @@
+import type * as RDF from "@rdfjs/types";
+import { Term } from "./Term.js";
+/**
+ * A term that represents an RDF literal,
+ * containing a string with an optional language tag and optional direction
+ * or datatype.
+ */
+export declare class Literal extends Term implements RDF.Literal {
+    readonly value: string;
+    private static readonly RDF_DIRECTIONAL_LANGUAGE_STRING;
+    private static readonly RDF_LANGUAGE_STRING;
+    private static readonly XSD_STRING;
+    readonly datatype: RDF.NamedNode;
+    readonly direction: "ltr" | "rtl" | "";
+    readonly language: string;
+    readonly termType = "Literal";
+    constructor(value: string, languageOrDatatype?: string | RDF.NamedNode | RDF.DirectionalLanguage);
+    equals(other?: RDF.Term | null): boolean;
+}
+//# sourceMappingURL=Literal.d.ts.map

package/dist/Literal.js

@@ -0,0 +1,51 @@
+import { NamedNode } from "./NamedNode.js";
+import { Term } from "./Term.js";
+/**
+ * A term that represents an RDF literal,
+ * containing a string with an optional language tag and optional direction
+ * or datatype.
+ */
+export class Literal extends Term {
+    constructor(value, languageOrDatatype) {
+        super();
+        this.value = value;
+        this.termType = "Literal";
+        if (typeof languageOrDatatype === "string") {
+            this.language = languageOrDatatype;
+            this.datatype = Literal.RDF_LANGUAGE_STRING;
+            this.direction = "";
+        }
+        else if (languageOrDatatype) {
+            if ("termType" in languageOrDatatype) {
+                this.language = "";
+                this.datatype = languageOrDatatype;
+                this.direction = "";
+            }
+            else {
+                this.language = languageOrDatatype.language;
+                this.datatype = languageOrDatatype.direction
+                    ? Literal.RDF_DIRECTIONAL_LANGUAGE_STRING
+                    : Literal.RDF_LANGUAGE_STRING;
+                this.direction = languageOrDatatype.direction ?? "";
+            }
+        }
+        else {
+            this.language = "";
+            this.datatype = Literal.XSD_STRING;
+            this.direction = "";
+        }
+    }
+    equals(other) {
+        return (!!other &&
+            other.termType === "Literal" &&
+            other.value === this.value &&
+            other.language === this.language &&
+            (other.direction === this.direction ||
+                (!other.direction && this.direction === "")) &&
+            this.datatype.equals(other.datatype));
+    }
+}
+Literal.RDF_DIRECTIONAL_LANGUAGE_STRING = new NamedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#dirLangString");
+Literal.RDF_LANGUAGE_STRING = new NamedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#langString");
+Literal.XSD_STRING = new NamedNode("http://www.w3.org/2001/XMLSchema#string");
+//# sourceMappingURL=Literal.js.map

package/dist/NamedNode.d.ts

@@ -0,0 +1,12 @@
+import type * as RDF from "@rdfjs/types";
+import { Term } from "./Term.js";
+/**
+ * A term that contains an IRI.
+ */
+export declare class NamedNode<TIri extends string = string> extends Term implements RDF.NamedNode<TIri> {
+    readonly value: TIri;
+    readonly termType = "NamedNode";
+    constructor(value: TIri);
+    equals(other?: RDF.Term | null): boolean;
+}
+//# sourceMappingURL=NamedNode.d.ts.map

package/dist/NamedNode.js

@@ -0,0 +1,15 @@
+import { Term } from "./Term.js";
+/**
+ * A term that contains an IRI.
+ */
+export class NamedNode extends Term {
+    constructor(value) {
+        super();
+        this.value = value;
+        this.termType = "NamedNode";
+    }
+    equals(other) {
+        return (!!other && other.termType === "NamedNode" && other.value === this.value);
+    }
+}
+//# sourceMappingURL=NamedNode.js.map

package/dist/Quad.d.ts

@@ -0,0 +1,17 @@
+import type * as RDF from "@rdfjs/types";
+import { Term } from "./Term.js";
+/**
+ * An instance of DefaultGraph represents the default graph.
+ * It's only allowed to assign a DefaultGraph to the .graph property of a Quad.
+ */
+export declare class Quad extends Term implements RDF.Quad {
+    readonly subject: RDF.Quad["subject"];
+    readonly predicate: RDF.Quad["predicate"];
+    readonly object: RDF.Quad["object"];
+    readonly graph: RDF.Quad["graph"];
+    readonly termType = "Quad";
+    readonly value = "";
+    constructor(subject: RDF.Quad["subject"], predicate: RDF.Quad["predicate"], object: RDF.Quad["object"], graph: RDF.Quad["graph"]);
+    equals(other?: RDF.Term | null): boolean;
+}
+//# sourceMappingURL=Quad.d.ts.map

package/dist/Quad.js

@@ -0,0 +1,26 @@
+import { Term } from "./Term.js";
+/**
+ * An instance of DefaultGraph represents the default graph.
+ * It's only allowed to assign a DefaultGraph to the .graph property of a Quad.
+ */
+export class Quad extends Term {
+    constructor(subject, predicate, object, graph) {
+        super();
+        this.subject = subject;
+        this.predicate = predicate;
+        this.object = object;
+        this.graph = graph;
+        this.termType = "Quad";
+        this.value = "";
+    }
+    equals(other) {
+        // `|| !other.termType` is for backwards-compatibility with old factories without RDF* support.
+        return (!!other &&
+            (other.termType === "Quad" || !other.termType) &&
+            this.subject.equals(other.subject) &&
+            this.predicate.equals(other.predicate) &&
+            this.object.equals(other.object) &&
+            this.graph.equals(other.graph));
+    }
+}
+//# sourceMappingURL=Quad.js.map

package/dist/Term.d.ts

@@ -0,0 +1,7 @@
+export declare abstract class Term {
+    abstract readonly termType: "BlankNode" | "DefaultGraph" | "Literal" | "NamedNode" | "Quad" | "Variable";
+    abstract readonly value: string;
+    toJSON(): Record<string, unknown>;
+    toString(): string;
+}
+//# sourceMappingURL=Term.d.ts.map

package/dist/Term.js

@@ -0,0 +1,11 @@
+import toNT from "@rdfjs/to-ntriples";
+import { termToJson } from "./termToJson.js";
+export class Term {
+    toJSON() {
+        return termToJson(this);
+    }
+    toString() {
+        return toNT(this);
+    }
+}
+//# sourceMappingURL=Term.js.map

package/dist/Variable.d.ts

@@ -0,0 +1,12 @@
+import type * as RDF from "@rdfjs/types";
+import { Term } from "./Term.js";
+/**
+ * A term that represents a variable.
+ */
+export declare class Variable extends Term implements RDF.Variable {
+    readonly value: string;
+    readonly termType = "Variable";
+    constructor(value: string);
+    equals(other?: RDF.Term | null): boolean;
+}
+//# sourceMappingURL=Variable.d.ts.map

package/dist/Variable.js

@@ -0,0 +1,15 @@
+import { Term } from "./Term.js";
+/**
+ * A term that represents a variable.
+ */
+export class Variable extends Term {
+    constructor(value) {
+        super();
+        this.value = value;
+        this.termType = "Variable";
+    }
+    equals(other) {
+        return (!!other && other.termType === "Variable" && other.value === this.value);
+    }
+}
+//# sourceMappingURL=Variable.js.map

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./DataFactory.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./DataFactory.js";
+//# sourceMappingURL=index.js.map

package/dist/termToJson.d.ts

@@ -0,0 +1,3 @@
+import type * as RDF from "@rdfjs/types";
+export declare function termToJson(term: RDF.Term): Record<string, unknown>;
+//# sourceMappingURL=termToJson.d.ts.map

package/dist/termToJson.js

@@ -0,0 +1,30 @@
+export function termToJson(term) {
+    switch (term.termType) {
+        case "DefaultGraph":
+            return { termType: term.termType };
+        case "Literal":
+            return {
+                termType: term.termType,
+                datatype: term.datatype.value,
+                direction: term.direction,
+                language: term.language,
+                value: term.value,
+            };
+        case "NamedNode":
+        case "BlankNode":
+        case "Variable":
+            return {
+                termType: term.termType,
+                value: term.value,
+            };
+        case "Quad":
+            return {
+                termType: term.termType,
+                subject: termToJson(term.subject),
+                predicate: termToJson(term.predicate),
+                object: termToJson(term.object),
+                graph: termToJson(term.graph),
+            };
+    }
+}
+//# sourceMappingURL=termToJson.js.map

package/package.json

@@ -0,0 +1,35 @@
+{
+  "dependencies": {
+    "@rdfjs/to-ntriples": "~3.0.1",
+    "@rdfjs/types": "~2.0.1"
+  },
+  "devDependencies": {
+    "@rdfx/testing": "0.0.7",
+    "@types/rdfjs__to-ntriples": "~3.0.0"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "dist/*.d.ts",
+    "dist/*.js"
+  ],
+  "license": "Apache-2.0",
+  "main": "./dist/index.js",
+  "name": "@rdfx/data-factory",
+  "packageManager": "npm@11.11.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/minorg/rdfx.git"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "rimraf dist",
+    "depcheck": "depcheck .",
+    "dev": "tsc -w --preserveWatchOutput",
+    "dev:tests": "tsc -p __tests__ -w --preserveWatchOutput",
+    "test": "cd ../.. && vitest run /Users/minor/projects/rdfx/packages/data-factory/__tests__"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "version": "0.0.7"
+}