vhad/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/gosticks/DefinitelyTyped.git synced 2025-10-16 12:05:41 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

fix: align callback functions of dataset with spec (#40989)

Browse Source 
* fix: align callback functions of dataset with spec

* reduce clutter in rdf-js tests
This commit is contained in:
Tomasz Pluskiewicz 2019-12-23 17:26:29 +01:00 committed by Andrew Branch
parent 7b2a852371
commit cc23ed1761
2 changed files with 36 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
types/rdf-js/index.d.ts vendored
View File

@ -23,6 +23,8 @@ import { EventEmitter } from "events";
*/
export type Term = NamedNode | BlankNode | Literal | Variable | DefaultGraph;
type PropType<TObj, TProp extends keyof TObj> = TObj[TProp];
/**
* Contains an IRI.
*/
@ -529,21 +531,21 @@ export interface Dataset<Q extends BaseQuad = Quad> extends DatasetCore<Q> {
*
* This method is aligned with `Array.prototype.every()` in ECMAScript-262.
*/
every(iteratee: QuadFilterIteratee<Q>): boolean;
every(iteratee: PropType<QuadFilterIteratee<Q>, 'test'>): boolean;
/**
* Creates a new dataset with all the quads that pass the test implemented by the provided `iteratee`.
*
* This method is aligned with Array.prototype.filter() in ECMAScript-262.
*/
filter(iteratee: QuadFilterIteratee<Q>): this;
filter(iteratee: PropType<QuadFilterIteratee<Q>, 'test'>): this;
/**
* Executes the provided `iteratee` once on each quad in the dataset.
*
* This method is aligned with `Array.prototype.forEach()` in ECMAScript-262.
*/
forEach(iteratee: QuadRunIteratee<Q>): void;
forEach(iteratee: PropType<QuadRunIteratee<Q>, 'run'>): void;
/**
* Imports all quads from the given stream into the dataset.
@ -560,7 +562,7 @@ export interface Dataset<Q extends BaseQuad = Quad> extends DatasetCore<Q> {
/**
* Returns a new dataset containing all quads returned by applying `iteratee` to each quad in the current dataset.
*/
map(iteratee: QuadMapIteratee<Q>): this;
map(iteratee: PropType<QuadMapIteratee<Q>, 'map'>): this;
/**
* This method calls the `iteratee` on each `quad` of the `Dataset`. The first time the `iteratee` is called, the
@ -571,7 +573,7 @@ export interface Dataset<Q extends BaseQuad = Quad> extends DatasetCore<Q> {
*
* This method is aligned with `Array.prototype.reduce()` in ECMAScript-262.
*/
reduce<A = any>(iteratee: QuadReduceIteratee<A, Q>, initialValue?: A): A;
reduce<A = any>(iteratee: PropType<QuadReduceIteratee<A, Q>, 'run'>, initialValue?: A): A;
/**
* Existential quantification method, tests whether some quads in the dataset pass the test implemented by the
@ -581,7 +583,7 @@ export interface Dataset<Q extends BaseQuad = Quad> extends DatasetCore<Q> {
*
* This method is aligned with `Array.prototype.some()` in ECMAScript-262.
*/
some(iteratee: QuadFilterIteratee<Q>): boolean;
some(iteratee: PropType<QuadFilterIteratee<Q>, 'test'>): boolean;
/**
* Returns the set of quads within the dataset as a host language native sequence, for example an `Array` in
@ -652,3 +654,5 @@ export interface QuadRunIteratee<Q extends BaseQuad = Quad> {
*/
run(quad: Q, dataset: Dataset<Q>): void;
}
export {};

63
types/rdf-js/rdf-js-tests.ts
View File

@ -1,8 +1,9 @@
import { BlankNode, DataFactory, Dataset, DatasetCore, DatasetCoreFactory, DatasetFactory, DefaultGraph, Literal,
NamedNode, Quad, BaseQuad, Sink, Source, Store, Stream, Triple, Term, Variable, Quad_Graph, QuadFilterIteratee,
QuadMapIteratee, QuadReduceIteratee, QuadRunIteratee } from "rdf-js";
NamedNode, Quad, BaseQuad, Sink, Source, Store, Stream, Triple, Term, Variable, Quad_Graph } from "rdf-js";
import { EventEmitter } from "events";
const factory: DataFactory = <any> {};
function test_terms() {
// Only types are checked in this tests,
// so this does not have to be functional.
@ -190,19 +191,11 @@ function test_dataset() {
const stream1: Stream = <any> {};
const stream2: Stream<QuadBnode> = <any> {};
const quadFilterIteratee1: QuadFilterIteratee = <any> {};
const quadFilterIteratee2: QuadFilterIteratee<QuadBnode> = <any> {};
const quadMapIteratee1: QuadMapIteratee = <any> {};
const quadMapIteratee2: QuadMapIteratee<QuadBnode> = <any> {};
const quadReduceIteratee1: QuadReduceIteratee = <any> {};
const quadReduceIteratee2: QuadReduceIteratee<string> = <any> {};
const quadReduceIteratee3: QuadReduceIteratee<any, QuadBnode> = <any> {};
const quadReduceIteratee4: QuadReduceIteratee<string, QuadBnode> = <any> {};
const quadRunIteratee1: QuadRunIteratee = <any> {};
const quadRunIteratee2: QuadRunIteratee<QuadBnode> = <any> {};
const quadFilterIteratee: (quad: Quad, dataset: Dataset) => boolean = <any> {};
const quadMapIteratee: (quad: Quad, dataset: Dataset) => Quad = <any> {};
const quadReduceToStringIteratee: (reduced: string, quad: Quad) => string = <any> {};
const quadReduceToArrayIteratee: (arr: boolean[], quad: Quad, dataset: Dataset) => boolean[] = <any> {};
const quadForEachIteratee: (quad: Quad, dataset: Dataset) => void = <any> {};
const datasetFactory1: DatasetFactory = <any> {};
const datasetFactory2: DatasetFactory<QuadBnode> = <any> {};
@ -228,25 +221,22 @@ function test_dataset() {
const dataset2DeleteMatches5: Dataset = dataset2.deleteMatches(term, term, term, term);
const dataset2Difference: Dataset = dataset2.difference(dataset1);
const dataset2Equals: boolean = dataset2.equals(dataset1);
const dataset2Every: boolean = dataset2.every(quadFilterIteratee1);
const dataset2Filter: Dataset = dataset2.filter(quadFilterIteratee1);
// tslint:disable-next-line:no-void-expression void-return
const dataset2Foreach: void = dataset2.forEach(quadRunIteratee1);
const dataset2Every: boolean = dataset2.every(quadFilterIteratee);
const dataset2Filter: Dataset = dataset2.filter(quadFilterIteratee);
dataset2.forEach(quadForEachIteratee);
const dataset2Has: boolean = dataset2.has(quad);
const dataset2Import: Promise<Dataset> = dataset2.import(stream1);
const dataset2Intersection: Dataset = dataset2.intersection(dataset1);
const dataset2Map: Dataset = dataset2.map(quadMapIteratee1);
const dataset2Map: Dataset = dataset2.map(quadMapIteratee);
const dataset2Match1: Dataset = dataset2.match();
const dataset2Match2: Dataset = dataset2.match(term);
const dataset2Match3: Dataset = dataset2.match(term, term);
const dataset2Match4: Dataset = dataset2.match(term, term, term);
const dataset2Match5: Dataset = dataset2.match(term, term, term, term);
const dataset2Reduce1: object = dataset2.reduce(quadReduceIteratee1);
const dataset2Reduce2: object = dataset2.reduce(quadReduceIteratee1, []);
const dataset2Reduce3: object = dataset2.reduce(quadReduceIteratee1, '');
const dataset2Reduce4: string = dataset2.reduce(quadReduceIteratee2);
const dataset2Reduce5: string = dataset2.reduce(quadReduceIteratee2, '');
const dataset2Some: boolean = dataset2.some(quadFilterIteratee1);
const dataset2Reduce1: string = dataset2.reduce(quadReduceToStringIteratee);
const dataset2Reduce2: boolean[] = dataset2.reduce(quadReduceToArrayIteratee, []);
const dataset2Reduce3: string = dataset2.reduce(quadReduceToStringIteratee, '');
const dataset2Some: boolean = dataset2.some(quadFilterIteratee);
const dataset2ToArray: Quad[] = dataset2.toArray();
const dataset2ToCanonical: string = dataset2.toCanonical();
const dataset2ToStream: Stream = dataset2.toStream();
@ -268,25 +258,24 @@ function test_dataset() {
const dataset4DeleteMatches5: Dataset<QuadBnode> = dataset4.deleteMatches(term, term, term, term);
const dataset4Difference: Dataset<QuadBnode> = dataset4.difference(dataset3);
const dataset4Equals: boolean = dataset4.equals(dataset3);
const dataset4Every: boolean = dataset4.every(quadFilterIteratee2);
const dataset4Filter: Dataset<QuadBnode> = dataset4.filter(quadFilterIteratee2);
// tslint:disable-next-line:no-void-expression void-return
const dataset4Foreach: void = dataset4.forEach(quadRunIteratee2);
const dataset4Every: boolean = dataset4.every(quadFilterIteratee);
const dataset4Filter: Dataset<QuadBnode> = dataset4.filter(quadFilterIteratee);
dataset4.forEach(quadForEachIteratee);
const dataset4Has: boolean = dataset4.has(quadBnode);
const dataset4Import: Promise<Dataset<QuadBnode>> = dataset4.import(stream2);
const dataset4Intersection: Dataset<QuadBnode> = dataset4.intersection(dataset3);
const dataset4Map: Dataset<QuadBnode> = dataset4.map(quadMapIteratee2);
const dataset4Map: Dataset<QuadBnode> = dataset4.map(quadMapIteratee);
const dataset4Match1: Dataset<QuadBnode> = dataset4.match();
const dataset4Match2: Dataset<QuadBnode> = dataset4.match(term);
const dataset4Match3: Dataset<QuadBnode> = dataset4.match(term, term);
const dataset4Match4: Dataset<QuadBnode> = dataset4.match(term, term, term);
const dataset4Match5: Dataset<QuadBnode> = dataset4.match(term, term, term, term);
const dataset4Reduce1: object = dataset4.reduce(quadReduceIteratee3);
const dataset4Reduce2: object = dataset4.reduce(quadReduceIteratee3, []);
const dataset4Reduce3: object = dataset4.reduce(quadReduceIteratee3, '');
const dataset4Reduce4: string = dataset4.reduce(quadReduceIteratee4);
const dataset4Reduce5: string = dataset4.reduce(quadReduceIteratee4, '');
const dataset4Some: boolean = dataset4.some(quadFilterIteratee1);
const dataset4Reduce1: string = dataset4.reduce(quadReduceToStringIteratee);
const dataset4Reduce2: boolean[] = dataset4.reduce(quadReduceToArrayIteratee, []);
const dataset4Reduce3: string = dataset4.reduce(quadReduceToStringIteratee, '');
const dataset4Reduce4: string = dataset4.reduce(quadReduceToStringIteratee);
const dataset4Reduce5: string = dataset4.reduce(quadReduceToStringIteratee, '');
const dataset4Some: boolean = dataset4.some(quadFilterIteratee);
const dataset4ToArray: QuadBnode[] = dataset4.toArray();
const dataset4ToCanonical: string = dataset4.toCanonical();
const dataset4ToStream: Stream<QuadBnode> = dataset4.toStream();