Update tests

types/d3-dsv/d3-dsv-tests.ts

@@ -21,6 +21,9 @@ const csvTestStringWithHeader = `Year,Make,Model,Length\n${csvTestString}`;
 const tsvTestStringWithHeader = `Year\tMake\tModel\tLength\n${tsvTestString}`;
 const pipedTestStringWithHeader = `Year|Make|Model|Length\n${pipedTestString}`;
 
+type Headers = "Year" | "Make" | "Model" | "Length";
+type ParsedHeaders = "year" | "make" | "model" | "length";
+
 interface ParsedTestObject {
     year: Date | null;
     make: string;
@@ -28,17 +31,56 @@ interface ParsedTestObject {
     length: number;
 }
 
-let parseArray: d3Dsv.DSVParsedArray<d3Dsv.DSVRowString>;
-let parseMappedArray: d3Dsv.DSVParsedArray<ParsedTestObject>;
-
 let parseRowsArray: string[][];
 let parseRowsMappedArray: ParsedTestObject[];
-
 let parsedTestObject: ParsedTestObject;
-let columns: string[];
+
+let num: number;
 let str: string;
 let strMaybe: string | undefined;
 
+let columns: string[];
+let headers: Headers[];
+let parsedHeaders: ParsedHeaders[];
+
+// ------------------------------------------------------------------------------------------
+// Test Shared Types and Interfaces
+// ------------------------------------------------------------------------------------------
+
+declare let row: d3Dsv.DSVRowString;
+strMaybe = row.property;
+
+declare let row2: d3Dsv.DSVRowString<Headers>;
+strMaybe = row2.Make;
+strMaybe = row2.Property; // $ExpectError
+
+declare let raw: d3Dsv.DSVRaw<ParsedTestObject>;
+strMaybe = raw.make;
+strMaybe = raw.property; // $ExpectError
+
+declare let rowArray: d3Dsv.DSVRowArray;
+strMaybe = rowArray[0].property;
+columns = rowArray.columns;
+num = rowArray.length;
+
+declare let rowArrayHeader: d3Dsv.DSVRowArray<Headers>;
+strMaybe = rowArrayHeader[0].Make;
+strMaybe = rowArrayHeader[0].Property; // $ExpectError
+headers = rowArrayHeader.columns;
+num = rowArrayHeader.length;
+
+declare let parseMappedArray: d3Dsv.DSVParsedArray<ParsedTestObject>;
+strMaybe = parseMappedArray[0].make;
+strMaybe = parseMappedArray[0].property; // $ExpectError
+parsedTestObject = parseMappedArray[0];
+parsedHeaders = parseMappedArray.columns;
+num = parseMappedArray.length;
+
+declare let parseArray: d3Dsv.DSVParsedArray<d3Dsv.DSVRowString>;
+strMaybe = parseArray[0].property;
+columns = parseArray.columns;
+num = parseArray.length;
+
 // ------------------------------------------------------------------------------------------
 // Test CSV
 // ------------------------------------------------------------------------------------------
@@ -48,8 +90,7 @@ let strMaybe: string | undefined;
 // without row mapper -----------------------------------------------------------------------
 
 parseArray = d3Dsv.csvParse(csvTestStringWithHeader);
-columns = parseArray.columns;
-strMaybe = parseArray[0].Year;
+rowArrayHeader = d3Dsv.csvParse<Headers>(csvTestStringWithHeader);
 
 // with row mapper ---------------------------------------------------------------------------
 
@@ -73,8 +114,12 @@ parseMappedArray = d3Dsv.csvParse(csvTestStringWithHeader, (rawRow, index, colum
     return pr;
 });
 
-columns = parseMappedArray.columns;
-parsedTestObject = parseMappedArray[0];
+parseMappedArray = d3Dsv.csvParse<ParsedTestObject, Headers>(csvTestStringWithHeader, (rawRow, index, columns) => {
+    const rr: d3Dsv.DSVRowString<Headers> = rawRow;
+    const i: number = index;
+    const c: Headers[] = columns;
+    return parsedTestObject;
+});
 
 // csvParseRows(...) ============================================================================
 
@@ -108,12 +153,11 @@ parseRowsMappedArray = d3Dsv.csvParseRows(csvTestString, (rawRow, index) => {
 
 str = d3Dsv.csvFormat(parseRowsMappedArray);
 str = d3Dsv.csvFormat(parseRowsMappedArray, ["year", "length"]);
-// $ExpectError
-str = d3Dsv.csvFormat(parseRowsMappedArray, ["year", "unknown"]);
+str = d3Dsv.csvFormat(parseRowsMappedArray, ["year", "unknown"]); // $ExpectError
 
 // csvFormatRows(...) ========================================================================
 
-str = d3Dsv.csvFormatRows(parseRowsMappedArray.map((d, i) => [
+str = d3Dsv.csvFormatRows(parseRowsMappedArray.map((d) => [
     d.year ? d.year.getFullYear().toString() : '',
     d.make,
     d.model,
@@ -129,8 +173,7 @@ str = d3Dsv.csvFormatRows(parseRowsMappedArray.map((d, i) => [
 // without row mapper -----------------------------------------------------------------------
 
 parseArray = d3Dsv.tsvParse(tsvTestStringWithHeader);
-columns = parseArray.columns;
-strMaybe = parseArray[0].Year;
+rowArrayHeader = d3Dsv.tsvParse<Headers>(csvTestStringWithHeader);
 
 // with row mapper ---------------------------------------------------------------------------
 
@@ -154,8 +197,12 @@ parseMappedArray = d3Dsv.tsvParse(tsvTestStringWithHeader, (rawRow, index, colum
     return pr;
 });
 
-columns = parseMappedArray.columns;
-parsedTestObject = parseMappedArray[0];
+parseMappedArray = d3Dsv.tsvParse<ParsedTestObject, Headers>(tsvTestStringWithHeader, (rawRow, index, columns) => {
+    const rr: d3Dsv.DSVRowString<Headers> = rawRow;
+    const i: number = index;
+    const c: Headers[] = columns;
+    return parsedTestObject;
+});
 
 // tsvParseRows(...) ============================================================================
 
@@ -189,12 +236,11 @@ parseRowsMappedArray = d3Dsv.tsvParseRows(tsvTestString, (rawRow, index) => {
 
 str = d3Dsv.tsvFormat(parseRowsMappedArray);
 str = d3Dsv.tsvFormat(parseRowsMappedArray, ["year", "length"]);
-// $ExpectError
-str = d3Dsv.tsvFormat(parseRowsMappedArray, ["year", "unknown"]);
+str = d3Dsv.tsvFormat(parseRowsMappedArray, ["year", "unknown"]); // $ExpectError
 
 // tsvFormatRows(...) ========================================================================
 
-str = d3Dsv.tsvFormatRows(parseRowsMappedArray.map((d, i) => [
+str = d3Dsv.tsvFormatRows(parseRowsMappedArray.map((d) => [
     d.year ? d.year.getFullYear().toString() : '',
     d.make,
     d.model,
@@ -215,8 +261,7 @@ dsv = d3Dsv.dsvFormat('|');
 // without row mapper -----------------------------------------------------------------------
 
 parseArray = dsv.parse(pipedTestStringWithHeader);
-columns = parseArray.columns;
-strMaybe = parseArray[0].Year;
+rowArrayHeader = dsv.parse<Headers>(csvTestStringWithHeader);
 
 // with row mapper ---------------------------------------------------------------------------
 
@@ -240,8 +285,12 @@ parseMappedArray = dsv.parse(pipedTestStringWithHeader, (rawRow, index, columns)
     return pr;
 });
 
-columns = parseMappedArray.columns;
-parsedTestObject = parseMappedArray[0];
+parseMappedArray = dsv.parse<ParsedTestObject, Headers>(pipedTestStringWithHeader, (rawRow, index, columns) => {
+    const rr: d3Dsv.DSVRowString<Headers> = rawRow;
+    const i: number = index;
+    const c: Headers[] = columns;
+    return parsedTestObject;
+});
 
 // parseRows(...) ============================================================================
 
@@ -275,12 +324,11 @@ parseRowsMappedArray = dsv.parseRows(pipedTestString, (rawRow, index) => {
 
 str = dsv.format(parseRowsMappedArray);
 str = dsv.format(parseRowsMappedArray, ["year", "length"]);
-// $ExpectError
-str = dsv.format(parseRowsMappedArray, ["year", "unknown"]);
+str = dsv.format(parseRowsMappedArray, ["year", "unknown"]); // $ExpectError
 
 // formatRows(...) ========================================================================
 
-str = dsv.formatRows(parseRowsMappedArray.map((d, i) => [
+str = dsv.formatRows(parseRowsMappedArray.map((d) => [
     d.year ? d.year.getFullYear().toString() : '',
     d.make,
     d.model,

types/d3-fetch/d3-fetch-tests.ts

@@ -1,66 +1,158 @@
 import * as d3Fetch from 'd3-fetch';
-import { DSVParsedArray, DSVRowString } from 'd3-dsv';
+import { DSVParsedArray, DSVRaw, DSVRowString } from 'd3-dsv';
 
-interface MyType {
-    foo: string;
+// ----------------------------------------------------------------------------
+// Preparatory Steps
+// ----------------------------------------------------------------------------
+
+type Headers = "Year" | "Make" | "Model" | "Length";
+
+interface Car {
+    year: Date;
+    make: string;
+    model: string;
+    length: number;
 }
 
-const url = 'foo.bar';
-
-const init: RequestInit = {};
-
-let p1: Promise<Blob> = d3Fetch.blob(url);
-p1 = d3Fetch.blob(url, init);
-
-let p2: Promise<ArrayBuffer> = d3Fetch.buffer(url);
-p2 = d3Fetch.buffer(url, init);
-
-let p3: Promise<HTMLImageElement> = d3Fetch.image(url);
-const imageProperties = {
-    width: '300px',
-    height: '500px'
-};
-p3 = d3Fetch.image(url, imageProperties);
-
-let p4: Promise<any> = d3Fetch.json(url);
-p4 = d3Fetch.json(url, init);
-let p5: Promise<MyType> = d3Fetch.json<MyType>(url);
-p5 = d3Fetch.json<MyType>(url, init);
-
-let myString: Promise<string>;
-myString = d3Fetch.text(url);
-myString = d3Fetch.text(url, init);
-
-const parseRow = (rawRow: DSVRowString, index: number, columns: string[]): (MyType | undefined | null) => {
-    const myType: MyType | null = rawRow['foo'] ? { foo: rawRow['foo'] + '+ bar' } : null;
-    return myType;
-};
-
-let promise1: Promise<DSVParsedArray<DSVRowString>>;
-let promise2: Promise<DSVParsedArray<MyType>>;
-
-promise1 = d3Fetch.csv(url);
-promise1 = d3Fetch.csv(url, init);
-promise2 = d3Fetch.csv<MyType>(url, parseRow);
-promise2 = d3Fetch.csv<MyType>(url, init, parseRow);
-
-promise1 = d3Fetch.dsv(';', url);
-promise1 = d3Fetch.dsv(';', url, init);
-promise2 = d3Fetch.dsv<MyType>(';', url, parseRow);
-promise2 = d3Fetch.dsv<MyType>(';', url, init, parseRow);
-
-promise1 = d3Fetch.tsv(url);
-promise1 = d3Fetch.tsv(url, init);
-promise2 = d3Fetch.tsv<MyType>(url, parseRow);
-promise2 = d3Fetch.tsv<MyType>(url, init, parseRow);
-
+let anyPromise: Promise<any>;
+let arrayPromise: Promise<ArrayBuffer>;
+let blobPromise: Promise<Blob>;
 let docPromise: Promise<Document>;
+let imagePromise: Promise<HTMLImageElement>;
+let carPromise: Promise<Car>;
+let stringPromise: Promise<string>;
+let xmlDocPromise: Promise<XMLDocument>;
+
+const url = 'example.org';
+const init: RequestInit = {};
+const map = new Map<string, number>();
+
+const imageProperties = {
+    width: 300,
+    height: 500,
+    crossOrigin: "anonymous",
+};
+
+// ----------------------------------------------------------------------------
+// Non DSV file format
+// ----------------------------------------------------------------------------
+
+blobPromise = d3Fetch.blob(url);
+blobPromise = d3Fetch.blob(url, init);
+
+arrayPromise = d3Fetch.buffer(url);
+arrayPromise = d3Fetch.buffer(url, init);
+
+imagePromise = d3Fetch.image(url);
+imagePromise = d3Fetch.image(url, imageProperties);
+// $ExpectError
+imagePromise = d3Fetch.image(url, {width: "500px"}); // fails, string not assignable to number | undefined
+
+anyPromise = d3Fetch.json(url);
+anyPromise = d3Fetch.json(url, init);
+
+carPromise = d3Fetch.json<Car>(url);
+carPromise = d3Fetch.json<Car>(url, init);
+
+stringPromise = d3Fetch.text(url);
+stringPromise = d3Fetch.text(url, init);
+
 docPromise = d3Fetch.html(url);
 docPromise = d3Fetch.html(url, init);
 
 docPromise = d3Fetch.svg(url);
 docPromise = d3Fetch.svg(url, init);
 
-let xmlDocPromise: Promise<XMLDocument>;
 xmlDocPromise = d3Fetch.xml(url);
 xmlDocPromise = d3Fetch.xml(url, init);
+
+// ----------------------------------------------------------------------------
+// DSV file format
+// ----------------------------------------------------------------------------
+
+let rawPromise: Promise<DSVParsedArray<DSVRowString>>;
+let rawPromiseHeader: Promise<DSVParsedArray<DSVRowString<Headers>>>;
+let parsedPromise: Promise<DSVParsedArray<Car>>;
+
+declare const parseRowString: (rawRow: DSVRowString, index: number, columns: string[]) => Car | undefined | null;
+
+const parseRow = (d: DSVRowString<Headers>, index: number, columns: Headers[]): Car | undefined | null => {
+    const item: string | undefined = d[columns[0]];
+    const car = d.Make === 'Ford' ? null :
+        {
+            year: new Date(+d.Make!, 0, 1),
+            make: d.Make!,
+            model: d.Model!,
+            length: +d.Length!,
+        };
+    return index % 2 === 0 ? undefined : car;
+};
+
+const parseRowSimple = (d: DSVRaw<Car>) => {
+    return {
+        year: new Date(+d.make!, 0, 1),
+        make: d.make!,
+        model: d.model!,
+        length: +d.length!,
+    };
+};
+
+// CSV
+
+rawPromise = d3Fetch.csv(url);
+rawPromise = d3Fetch.csv(url, init);
+
+rawPromiseHeader = d3Fetch.csv<Headers>(url);
+rawPromiseHeader = d3Fetch.csv<Headers>(url, init);
+
+parsedPromise = d3Fetch.csv<Car>(url, parseRowString);
+parsedPromise = d3Fetch.csv<Car>(url, init, parseRowString);
+
+parsedPromise = d3Fetch.csv<Car, Headers>(url, parseRow);
+parsedPromise = d3Fetch.csv<Car, Headers>(url, init, parseRow);
+
+parsedPromise = d3Fetch.csv(url, parseRow);
+parsedPromise = d3Fetch.csv(url, init, parseRow);
+parsedPromise = d3Fetch.csv(url, parseRowSimple);
+
+anyPromise = d3Fetch.csv(url, (d: DSVRaw<Car>) => map.set(d.model!, +d.year!));
+
+// DSV
+
+rawPromise = d3Fetch.dsv("|", url);
+rawPromise = d3Fetch.dsv("|", url, init);
+
+rawPromiseHeader = d3Fetch.dsv<Headers>("|", url);
+rawPromiseHeader = d3Fetch.dsv<Headers>("|", url, init);
+
+parsedPromise = d3Fetch.dsv<Car>("|", url, parseRowString);
+parsedPromise = d3Fetch.dsv<Car>("|", url, init, parseRowString);
+
+parsedPromise = d3Fetch.dsv<Car, Headers>("|", url, parseRow);
+parsedPromise = d3Fetch.dsv<Car, Headers>("|", url, init, parseRow);
+
+parsedPromise = d3Fetch.dsv("|", url, parseRow);
+parsedPromise = d3Fetch.dsv("|", url, init, parseRow);
+parsedPromise = d3Fetch.dsv("|", url, parseRowSimple);
+
+anyPromise = d3Fetch.dsv("|", url, (d: DSVRaw<Car>) => map.set(d.model!, +d.year!));
+
+// TSV
+
+rawPromise = d3Fetch.tsv(url);
+rawPromise = d3Fetch.tsv(url, init);
+
+rawPromiseHeader = d3Fetch.tsv<Headers>(url);
+rawPromiseHeader = d3Fetch.tsv<Headers>(url, init);
+
+parsedPromise = d3Fetch.tsv<Car>(url, parseRowString);
+parsedPromise = d3Fetch.tsv<Car>(url, init, parseRowString);
+
+parsedPromise = d3Fetch.tsv<Car, Headers>(url, parseRow);
+parsedPromise = d3Fetch.tsv<Car, Headers>(url, init, parseRow);
+
+parsedPromise = d3Fetch.tsv(url, parseRow);
+parsedPromise = d3Fetch.tsv(url, init, parseRow);
+parsedPromise = d3Fetch.tsv(url, parseRowSimple);
+
+anyPromise = d3Fetch.csv(url, (d: DSVRaw<Car>) => map.set(d.model!, +d.year!));

types/d3-fetch/index.d.ts

@@ -173,7 +173,7 @@ export function html(url: string, init?: RequestInit): Promise<Document>;
  * @param url A valid URL string.
  * @param init An optional object of image properties to set.
  */
-export function image(url: string, init?: {[key: string]: any}): Promise<HTMLImageElement>;
+export function image(url: string, init?: Partial<HTMLImageElement>): Promise<HTMLImageElement>;
 
 /**
  * Fetches the json file at the specified input URL and returns it as a Promise of a parsed JSON object.