Add rdf-data-model typings (#20539)

types/rdf-data-model/index.d.ts

@@ -0,0 +1,66 @@
+// Type definitions for rdf-data-model 1.0
+// Project: https://github.com/rdf-ext/rdf-data-model
+// Definitions by: Ruben Taelman <https://github.com/rubensworks>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+import * as RDF from "rdf-js";
+
+export class NamedNode implements RDF.NamedNode {
+    termType: "NamedNode";
+    value: string;
+    constructor(iri: string);
+    equals(other: RDF.Term): boolean;
+}
+
+export class BlankNode implements RDF.BlankNode {
+    static nextId: number;
+    termType: "BlankNode";
+    value: string;
+    constructor(id?: string);
+    equals(other: RDF.Term): boolean;
+}
+
+export class Literal implements RDF.Literal {
+    static readonly langStringDatatype: NamedNode;
+    termType: "Literal";
+    value: string;
+    language: string;
+    datatype: RDF.NamedNode;
+    constructor(value: string, language?: string, datatype?: RDF.NamedNode);
+    equals(other: RDF.Term): boolean;
+}
+
+export class Variable implements RDF.Variable {
+    termType: "Variable";
+    value: string;
+    constructor(name: string);
+    equals(other: RDF.Term): boolean;
+}
+
+export class DefaultGraph implements RDF.DefaultGraph {
+    termType: "DefaultGraph";
+    value: "";
+    constructor();
+    equals(other: RDF.Term): boolean;
+}
+
+export class Quad implements RDF.Quad {
+    subject: RDF.Term;
+    predicate: RDF.Term;
+    object: RDF.Term;
+    graph: RDF.Term;
+    constructor(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term, graph?: RDF.Term);
+    equals(other: RDF.Quad): boolean;
+}
+
+export class DataFactory implements RDF.DataFactory {
+    static defaultGraphInstance: RDF.DefaultGraph;
+    constructor();
+    namedNode(value: string): NamedNode;
+    blankNode(value?: string): BlankNode;
+    literal(value: string, languageOrDatatype?: string | RDF.NamedNode): Literal;
+    variable(value: string): Variable;
+    defaultGraph(): DefaultGraph;
+    triple(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term): Quad;
+    quad(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term, graph?: RDF.Term): Quad;
+}

types/rdf-data-model/rdf-data-model-tests.ts

@@ -0,0 +1,65 @@
+import * as RDF from "rdf-js";
+import { BlankNode, DataFactory, DefaultGraph, Literal, NamedNode, Quad, Variable } from "rdf-data-model";
+import { EventEmitter } from "events";
+
+function test_terms() {
+    // Only types are checked in this tests,
+    // so this does not have to be functional.
+    const someTerm: RDF.Term = <any> {};
+
+    const namedNode: RDF.NamedNode = new NamedNode('http://example.org');
+    const tt1: string = namedNode.termType;
+    const v1: string = namedNode.value;
+    const b1: boolean = namedNode.equals(someTerm);
+
+    const blankNode1: RDF.BlankNode = new BlankNode();
+    const blankNode2: RDF.BlankNode = new BlankNode('b100');
+    const tt2: string = blankNode1.termType;
+    const v2: string = blankNode1.value;
+    const b2: boolean = blankNode1.equals(someTerm);
+
+    const literal1: RDF.Literal = new Literal('abc', 'en-us');
+    const literal2: RDF.Literal = new Literal('abc', 'en-us', namedNode);
+    const literal3: RDF.Literal = new Literal('abc', undefined, namedNode);
+    const tt3: string = literal1.termType;
+    const v3: string = literal1.value;
+    const lang: string = literal1.language;
+    const datatype: RDF.NamedNode = literal1.datatype;
+    const b3: boolean = literal1.equals(someTerm);
+
+    const variable: RDF.Variable = new Variable('myvar');
+    const tt4: string = variable.termType;
+    const v4: string = variable.value;
+    const b4: boolean = variable.equals(someTerm);
+
+    const defaultGraph: RDF.DefaultGraph = new DefaultGraph();
+    const tt5: string = defaultGraph.termType;
+    const v5: string = defaultGraph.value;
+    const b5: boolean = defaultGraph.equals(someTerm);
+
+    const quad: RDF.Quad = new Quad(namedNode, namedNode, namedNode, namedNode);
+    const s: RDF.Term = quad.subject;
+    const p: RDF.Term = quad.predicate;
+    const o: RDF.Term = quad.object;
+    const g: RDF.Term = quad.graph;
+    const b: boolean = quad.equals(new Quad(namedNode, namedNode, namedNode));
+}
+
+function test_datafactory() {
+    const dataFactory: RDF.DataFactory = new DataFactory();
+
+    const namedNode: RDF.NamedNode = dataFactory.namedNode('http://example.org');
+
+    const blankNode1: RDF.BlankNode = dataFactory.blankNode('b1');
+    const blankNode2: RDF.BlankNode = dataFactory.blankNode();
+
+    const literal1: RDF.Literal = dataFactory.literal('abc');
+    const literal2: RDF.Literal = dataFactory.literal('abc', 'en-us');
+    const literal3: RDF.Literal = dataFactory.literal('abc', namedNode);
+
+    const variable: RDF.Variable = dataFactory.variable ? dataFactory.variable('v1') : new Variable('myvar');
+
+    const term: RDF.Term = <any> {};
+    const triple: RDF.Quad = dataFactory.triple(term, term, term);
+    const quad: RDF.Quad = dataFactory.quad(term, term, term, term);
+}

types/rdf-data-model/tsconfig.json

@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "rdf-data-model-tests.ts"
+    ]
+}

types/rdf-data-model/tslint.json

@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }