diff --git a/types/rdf-dataset-ext/addAll.d.ts b/types/rdf-dataset-ext/addAll.d.ts new file mode 100644 index 0000000000..a9eb8067da --- /dev/null +++ b/types/rdf-dataset-ext/addAll.d.ts @@ -0,0 +1,3 @@ +import { addAll } from '.'; + +export = addAll; diff --git a/types/rdf-dataset-ext/deleteMatch.d.ts b/types/rdf-dataset-ext/deleteMatch.d.ts new file mode 100644 index 0000000000..52b03579f8 --- /dev/null +++ b/types/rdf-dataset-ext/deleteMatch.d.ts @@ -0,0 +1,3 @@ +import { deleteMatch } from '.'; + +export = deleteMatch; diff --git a/types/rdf-dataset-ext/equals.d.ts b/types/rdf-dataset-ext/equals.d.ts new file mode 100644 index 0000000000..07d9379b31 --- /dev/null +++ b/types/rdf-dataset-ext/equals.d.ts @@ -0,0 +1,3 @@ +import { equals } from '.'; + +export = equals; diff --git a/types/rdf-dataset-ext/fromStream.d.ts b/types/rdf-dataset-ext/fromStream.d.ts new file mode 100644 index 0000000000..5a55ad7e21 --- /dev/null +++ b/types/rdf-dataset-ext/fromStream.d.ts @@ -0,0 +1,3 @@ +import { fromStream } from '.'; + +export = fromStream; diff --git a/types/rdf-dataset-ext/index.d.ts b/types/rdf-dataset-ext/index.d.ts new file mode 100644 index 0000000000..f662be1402 --- /dev/null +++ b/types/rdf-dataset-ext/index.d.ts @@ -0,0 +1,47 @@ +// Type definitions for rdf-dataset-ext 1.0 +// Project: https://github.com/rdf-ext/rdf-dataset-ext +// Definitions by: Chris Wilkinson +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped + +import { EventEmitter } from 'events'; +import { BaseQuad, DatasetCore, Quad, Stream, Term } from 'rdf-js'; + +/** + * Iterates over iterable and adds all quads to dataset by calling `.add` for each quad. + * + * Returns the given dataset. + */ +export function addAll = DatasetCore>(dataset: D, iterable: Iterable): D; + +/** + * Deletes all quads in the given dataset which match the given subject, predicate, object, graph pattern. + * + * `.match` of dataset is used to find the matches and .delete to delete all matches. Returns the given dataset. + */ +export function deleteMatch = DatasetCore>(dataset: D, subject?: Term, predicate?: Term, object?: Term, graph?: Term): D; + +/** + * Tests if the datasets a and b contain the same quads without doing a normalization step beforehand. + * + * That means Blank Node labels must also match. The comparison is done by testing `.size` of both dataset for + * equality and by looping over all quads of a and check if b contains it using the `.has` method. Returns `true` if + * both datasets are equal. Otherwise `false `is returned. + */ +export function equals(a: DatasetCore, b: DatasetCore): boolean; + +/** + * Adds all quads from stream till the stream is finished. + * + * Errors emitted by the stream are forwarded as Promise rejects. Returns the given dataset. + */ +export function fromStream = DatasetCore>(dataset: D, stream: EventEmitter): Promise; + +/** + * Returns the canonical representation of the dataset as string. + */ +export function toCanonical(dataset: DatasetCore): string; + +/** + * Creates a `Stream` which emits all quads of the given dataset. Returns the created stream. + */ +export function toStream(dataset: DatasetCore): Stream; diff --git a/types/rdf-dataset-ext/rdf-dataset-ext-tests.ts b/types/rdf-dataset-ext/rdf-dataset-ext-tests.ts new file mode 100644 index 0000000000..f1d5b086f2 --- /dev/null +++ b/types/rdf-dataset-ext/rdf-dataset-ext-tests.ts @@ -0,0 +1,86 @@ +import { EventEmitter } from 'events'; +import { BaseQuad, DatasetCore, Quad, Stream, Term } from 'rdf-js'; +import grouped = require('rdf-dataset-ext'); +import addAll = require('rdf-dataset-ext/addAll'); +import deleteMatch = require('rdf-dataset-ext/deleteMatch'); +import equals = require('rdf-dataset-ext/equals'); +import fromStream = require('rdf-dataset-ext/fromStream'); +import toCanonical = require('rdf-dataset-ext/toCanonical'); +import toStream = require('rdf-dataset-ext/toStream'); + +const dataset1: DatasetCore = {} as any; +const dataset2: DatasetCore = {} as any; +const iterable1: Iterable = [] as any; +const iterable2: Iterable = [] as any; +const term: Term = undefined as any; +const eventEmitter: EventEmitter = {} as any; + +// addAll + +const dataset1addAll1: DatasetCore = addAll(dataset1, iterable1); +const dataset1addAll2: DatasetCore = grouped.addAll(dataset1, iterable1); + +const dataset2addAll1: DatasetCore = addAll(dataset2, iterable2); +const dataset2addAll2: DatasetCore = addAll>(dataset2, iterable2); +const dataset2addAll3: DatasetCore = grouped.addAll(dataset2, iterable2); +const dataset2addAll4: DatasetCore = grouped.addAll>(dataset2, iterable2); + +// deleteMatch + +const dataset1deleteMatch1: DatasetCore = deleteMatch(dataset1); +const dataset1deleteMatch2: DatasetCore = deleteMatch(dataset1, term); +const dataset1deleteMatch3: DatasetCore = deleteMatch(dataset1, term, term); +const dataset1deleteMatch4: DatasetCore = deleteMatch(dataset1, term, term, term); +const dataset1deleteMatch5: DatasetCore = deleteMatch(dataset1, term, term, term, term); +const dataset1deleteMatch6: DatasetCore = grouped.deleteMatch(dataset1); +const dataset1deleteMatch7: DatasetCore = grouped.deleteMatch(dataset1, term); +const dataset1deleteMatch8: DatasetCore = grouped.deleteMatch(dataset1, term, term); +const dataset1deleteMatch9: DatasetCore = grouped.deleteMatch(dataset1, term, term, term); +const dataset1deleteMatch10: DatasetCore = grouped.deleteMatch(dataset1, term, term, term, term); + +const dataset2deleteMatch1: DatasetCore = deleteMatch(dataset2); +const dataset2deleteMatch2: DatasetCore = deleteMatch>(dataset2); +const dataset2deleteMatch3: DatasetCore = deleteMatch(dataset2, term); +const dataset2deleteMatch4: DatasetCore = deleteMatch(dataset2, term, term); +const dataset2deleteMatch5: DatasetCore = deleteMatch(dataset2, term, term, term); +const dataset2deleteMatch6: DatasetCore = deleteMatch(dataset2, term, term, term, term); +const dataset2deleteMatch7: DatasetCore = grouped.deleteMatch(dataset2); +const dataset2deleteMatch8: DatasetCore = grouped.deleteMatch>(dataset2); +const dataset2deleteMatch9: DatasetCore = grouped.deleteMatch(dataset2, term); +const dataset2deleteMatch10: DatasetCore = grouped.deleteMatch(dataset2, term, term); +const dataset2deleteMatch11: DatasetCore = grouped.deleteMatch(dataset2, term, term, term); +const dataset2deleteMatch12: DatasetCore = grouped.deleteMatch(dataset2, term, term, term, term); + +// equals + +const equals1: boolean = equals(dataset1, dataset1); +const equals2: boolean = equals(dataset1, dataset2); +const equals3: boolean = equals(dataset2, dataset1); +const equals4: boolean = grouped.equals(dataset1, dataset1); +const equals5: boolean = grouped.equals(dataset1, dataset2); +const equals6: boolean = grouped.equals(dataset2, dataset1); + +// fromStream + +const fromStream1: Promise = fromStream(dataset1, eventEmitter); +const fromStream2: Promise> = fromStream(dataset2, eventEmitter); +const fromStream3: Promise> = fromStream>(dataset2, eventEmitter); +const fromStream4: Promise = grouped.fromStream(dataset1, eventEmitter); +const fromStream5: Promise> = grouped.fromStream(dataset2, eventEmitter); +const fromStream6: Promise> = grouped.fromStream>(dataset2, eventEmitter); + +// toCanonical + +const toCanonical1: string = toCanonical(dataset1); +const toCanonical2: string = toCanonical(dataset2); +const toCanonical3: string = grouped.toCanonical(dataset1); +const toCanonical4: string = grouped.toCanonical(dataset2); + +// toStream + +const toStream1: Stream = toStream(dataset1); +const toStream2: Stream = toStream(dataset2); +const toStream3: Stream = toStream(dataset2); +const toStream4: Stream = grouped.toStream(dataset1); +const toStream5: Stream = grouped.toStream(dataset2); +const toStream6: Stream = grouped.toStream(dataset2); diff --git a/types/rdf-dataset-ext/toCanonical.d.ts b/types/rdf-dataset-ext/toCanonical.d.ts new file mode 100644 index 0000000000..edf74a455b --- /dev/null +++ b/types/rdf-dataset-ext/toCanonical.d.ts @@ -0,0 +1,3 @@ +import { toCanonical } from '.'; + +export = toCanonical; diff --git a/types/rdf-dataset-ext/toStream.d.ts b/types/rdf-dataset-ext/toStream.d.ts new file mode 100644 index 0000000000..6b32c35db2 --- /dev/null +++ b/types/rdf-dataset-ext/toStream.d.ts @@ -0,0 +1,3 @@ +import { toStream } from '.'; + +export = toStream; diff --git a/types/rdf-dataset-ext/tsconfig.json b/types/rdf-dataset-ext/tsconfig.json new file mode 100644 index 0000000000..e718d8d4c8 --- /dev/null +++ b/types/rdf-dataset-ext/tsconfig.json @@ -0,0 +1,23 @@ +{ + "compilerOptions": { + "module": "commonjs", + "lib": [ + "es6" + ], + "noImplicitAny": true, + "noImplicitThis": true, + "strictFunctionTypes": true, + "strictNullChecks": true, + "baseUrl": "../", + "typeRoots": [ + "../" + ], + "types": [], + "noEmit": true, + "forceConsistentCasingInFileNames": true + }, + "files": [ + "index.d.ts", + "rdf-dataset-ext-tests.ts" + ] +} diff --git a/types/rdf-dataset-ext/tslint.json b/types/rdf-dataset-ext/tslint.json new file mode 100644 index 0000000000..3db14f85ea --- /dev/null +++ b/types/rdf-dataset-ext/tslint.json @@ -0,0 +1 @@ +{ "extends": "dtslint/dt.json" }