mirror of
https://github.com/denoland/deno.git
synced 2024-12-25 00:29:09 -05:00
Update to TypeScript 3.7 (#3275)
and update to prettier 1.19 Also, update `assert()` and remove not null assertions where possibly in `cli`. Closes #3273
This commit is contained in:
parent
279191ad94
commit
9837d324a7
80 changed files with 980 additions and 1153 deletions
|
@ -72,16 +72,14 @@ function concatenate(...arrays: Uint8Array[]): ArrayBuffer {
|
|||
}
|
||||
|
||||
function bufferFromStream(stream: ReadableStreamReader): Promise<ArrayBuffer> {
|
||||
return new Promise(
|
||||
(resolve, reject): void => {
|
||||
return new Promise((resolve, reject): void => {
|
||||
const parts: Uint8Array[] = [];
|
||||
const encoder = new TextEncoder();
|
||||
// recurse
|
||||
(function pump(): void {
|
||||
stream
|
||||
.read()
|
||||
.then(
|
||||
({ done, value }): void => {
|
||||
.then(({ done, value }): void => {
|
||||
if (done) {
|
||||
return resolve(concatenate(...parts));
|
||||
}
|
||||
|
@ -97,16 +95,12 @@ function bufferFromStream(stream: ReadableStreamReader): Promise<ArrayBuffer> {
|
|||
}
|
||||
|
||||
return pump();
|
||||
}
|
||||
)
|
||||
.catch(
|
||||
(err): void => {
|
||||
})
|
||||
.catch((err): void => {
|
||||
reject(err);
|
||||
}
|
||||
);
|
||||
});
|
||||
})();
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
function getHeaderValueParams(value: string): Map<string, string> {
|
||||
|
@ -275,8 +269,7 @@ export class Body implements domTypes.Body {
|
|||
body
|
||||
.trim()
|
||||
.split("&")
|
||||
.forEach(
|
||||
(bytes): void => {
|
||||
.forEach((bytes): void => {
|
||||
if (bytes) {
|
||||
const split = bytes.split("=");
|
||||
const name = split.shift()!.replace(/\+/g, " ");
|
||||
|
@ -286,8 +279,7 @@ export class Body implements domTypes.Body {
|
|||
decodeURIComponent(value)
|
||||
);
|
||||
}
|
||||
}
|
||||
);
|
||||
});
|
||||
} catch (e) {
|
||||
throw new TypeError("Invalid form urlencoded format");
|
||||
}
|
||||
|
|
|
@ -67,7 +67,8 @@ type CompilerRequest = {
|
|||
| {
|
||||
type: CompilerRequestType.Bundle;
|
||||
outFile?: string;
|
||||
});
|
||||
}
|
||||
);
|
||||
|
||||
interface ConfigureResponse {
|
||||
ignoredOptions?: string[];
|
||||
|
@ -186,11 +187,7 @@ class SourceFile {
|
|||
throw new Error("SourceFile has already been processed.");
|
||||
}
|
||||
assert(this.sourceCode != null);
|
||||
const preProcessedFileInfo = ts.preProcessFile(
|
||||
this.sourceCode!,
|
||||
true,
|
||||
true
|
||||
);
|
||||
const preProcessedFileInfo = ts.preProcessFile(this.sourceCode, true, true);
|
||||
this.processed = true;
|
||||
const files = (this.importedFiles = [] as Array<[string, string]>);
|
||||
|
||||
|
@ -511,10 +508,10 @@ class Host implements ts.CompilerHost {
|
|||
? this._getAsset(fileName)
|
||||
: SourceFile.get(fileName);
|
||||
assert(sourceFile != null);
|
||||
if (!sourceFile!.tsSourceFile) {
|
||||
sourceFile!.tsSourceFile = ts.createSourceFile(
|
||||
if (!sourceFile.tsSourceFile) {
|
||||
sourceFile.tsSourceFile = ts.createSourceFile(
|
||||
fileName,
|
||||
sourceFile!.sourceCode,
|
||||
sourceFile.sourceCode,
|
||||
languageVersion
|
||||
);
|
||||
}
|
||||
|
@ -577,7 +574,7 @@ class Host implements ts.CompilerHost {
|
|||
emitBundle(this._rootNames, this._outFile, data, sourceFiles!);
|
||||
} else {
|
||||
assert(sourceFiles.length == 1);
|
||||
const url = sourceFiles![0].fileName;
|
||||
const url = sourceFiles[0].fileName;
|
||||
const sourceFile = SourceFile.get(url);
|
||||
|
||||
if (sourceFile) {
|
||||
|
@ -635,9 +632,9 @@ window.compilerMain = function compilerMain(): void {
|
|||
// This will recursively analyse all the code for other imports, requesting
|
||||
// those from the privileged side, populating the in memory cache which
|
||||
// will be used by the host, before resolving.
|
||||
const resolvedRootModules = (await processImports(
|
||||
rootNames.map(rootName => [rootName, rootName])
|
||||
)).map(info => info.url);
|
||||
const resolvedRootModules = (
|
||||
await processImports(rootNames.map(rootName => [rootName, rootName]))
|
||||
).map(info => info.url);
|
||||
|
||||
const host = new Host(
|
||||
request.type,
|
||||
|
@ -669,8 +666,9 @@ window.compilerMain = function compilerMain(): void {
|
|||
const options = host.getCompilationSettings();
|
||||
const program = ts.createProgram(rootNames, options, host);
|
||||
|
||||
diagnostics = ts.getPreEmitDiagnostics(program).filter(
|
||||
({ code }): boolean => {
|
||||
diagnostics = ts
|
||||
.getPreEmitDiagnostics(program)
|
||||
.filter(({ code }): boolean => {
|
||||
// TS1103: 'for-await-of' statement is only allowed within an async
|
||||
// function or async generator.
|
||||
if (code === 1103) return false;
|
||||
|
@ -692,8 +690,7 @@ window.compilerMain = function compilerMain(): void {
|
|||
// so we will ignore complaints about this compiler setting.
|
||||
if (code === 5070) return false;
|
||||
return true;
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
// We will only proceed with the emit if there are no diagnostics.
|
||||
if (diagnostics && diagnostics.length === 0) {
|
||||
|
|
|
@ -292,8 +292,7 @@ function createRawObjectString(
|
|||
shouldShowClassName = true;
|
||||
}
|
||||
const keys = Object.keys(value);
|
||||
const entries: string[] = keys.map(
|
||||
(key): string => {
|
||||
const entries: string[] = keys.map((key): string => {
|
||||
if (keys.length > OBJ_ABBREVIATE_SIZE) {
|
||||
return key;
|
||||
} else {
|
||||
|
@ -304,8 +303,7 @@ function createRawObjectString(
|
|||
maxLevel
|
||||
)}`;
|
||||
}
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
ctx.delete(value);
|
||||
|
||||
|
@ -640,18 +638,15 @@ export class Console {
|
|||
let idx = 0;
|
||||
resultData = {};
|
||||
|
||||
data.forEach(
|
||||
(v: unknown, k: unknown): void => {
|
||||
data.forEach((v: unknown, k: unknown): void => {
|
||||
resultData[idx] = { Key: k, Values: v };
|
||||
idx++;
|
||||
}
|
||||
);
|
||||
});
|
||||
} else {
|
||||
resultData = data!;
|
||||
}
|
||||
|
||||
Object.keys(resultData).forEach(
|
||||
(k, idx): void => {
|
||||
Object.keys(resultData).forEach((k, idx): void => {
|
||||
const value: unknown = resultData[k]!;
|
||||
|
||||
if (value !== null && typeof value === "object") {
|
||||
|
@ -675,8 +670,7 @@ export class Console {
|
|||
}
|
||||
|
||||
indexKeys.push(k);
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
const headerKeys = Object.keys(objectValues);
|
||||
const bodyValues = Object.values(objectValues);
|
||||
|
|
|
@ -72,8 +72,8 @@ export function cliTable(head: string[], columns: string[][]): string {
|
|||
}
|
||||
}
|
||||
|
||||
const divider = columnWidths.map(
|
||||
(i: number): string => tableChars.middleMiddle.repeat(i + 2)
|
||||
const divider = columnWidths.map((i: number): string =>
|
||||
tableChars.middleMiddle.repeat(i + 2)
|
||||
);
|
||||
|
||||
let result =
|
||||
|
|
|
@ -121,7 +121,12 @@ test(function consoleTestStringifyCircular(): void {
|
|||
);
|
||||
assertEquals(stringify(new Set([1, 2, 3])), "Set { 1, 2, 3 }");
|
||||
assertEquals(
|
||||
stringify(new Map([[1, "one"], [2, "two"]])),
|
||||
stringify(
|
||||
new Map([
|
||||
[1, "one"],
|
||||
[2, "two"]
|
||||
])
|
||||
),
|
||||
`Map { 1 => "one", 2 => "two" }`
|
||||
);
|
||||
assertEquals(stringify(new WeakSet()), "WeakSet { [items unknown] }");
|
||||
|
@ -130,12 +135,18 @@ test(function consoleTestStringifyCircular(): void {
|
|||
assertEquals(stringify(null), "null");
|
||||
assertEquals(stringify(undefined), "undefined");
|
||||
assertEquals(stringify(new Extended()), "Extended { a: 1, b: 2 }");
|
||||
assertEquals(stringify(function f(): void {}), "[Function: f]");
|
||||
assertEquals(
|
||||
stringify(function f(): void {}),
|
||||
"[Function: f]"
|
||||
);
|
||||
assertEquals(
|
||||
stringify(async function af(): Promise<void> {}),
|
||||
"[AsyncFunction: af]"
|
||||
);
|
||||
assertEquals(stringify(function* gf() {}), "[GeneratorFunction: gf]");
|
||||
assertEquals(
|
||||
stringify(function* gf() {}),
|
||||
"[GeneratorFunction: gf]"
|
||||
);
|
||||
assertEquals(
|
||||
stringify(async function* agf() {}),
|
||||
"[AsyncGeneratorFunction: agf]"
|
||||
|
@ -410,8 +421,7 @@ function mockConsole(f: ConsoleExamineFunc): void {
|
|||
|
||||
// console.group test
|
||||
test(function consoleGroup(): void {
|
||||
mockConsole(
|
||||
(console, out): void => {
|
||||
mockConsole((console, out): void => {
|
||||
console.group("1");
|
||||
console.log("2");
|
||||
console.group("3");
|
||||
|
@ -431,14 +441,12 @@ test(function consoleGroup(): void {
|
|||
6
|
||||
`
|
||||
);
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// console.group with console.warn test
|
||||
test(function consoleGroupWarn(): void {
|
||||
mockConsole(
|
||||
(console, _out, _err, both): void => {
|
||||
mockConsole((console, _out, _err, both): void => {
|
||||
console.warn("1");
|
||||
console.group();
|
||||
console.warn("2");
|
||||
|
@ -462,14 +470,12 @@ test(function consoleGroupWarn(): void {
|
|||
7
|
||||
`
|
||||
);
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// console.table test
|
||||
test(function consoleTable(): void {
|
||||
mockConsole(
|
||||
(console, out): void => {
|
||||
mockConsole((console, out): void => {
|
||||
console.table({ a: "test", b: 1 });
|
||||
assertEquals(
|
||||
out.toString(),
|
||||
|
@ -481,10 +487,8 @@ test(function consoleTable(): void {
|
|||
└─────────┴────────┘
|
||||
`
|
||||
);
|
||||
}
|
||||
);
|
||||
mockConsole(
|
||||
(console, out): void => {
|
||||
});
|
||||
mockConsole((console, out): void => {
|
||||
console.table({ a: { b: 10 }, b: { b: 20, c: 30 } }, ["c"]);
|
||||
assertEquals(
|
||||
out.toString(),
|
||||
|
@ -496,10 +500,8 @@ test(function consoleTable(): void {
|
|||
└─────────┴────┘
|
||||
`
|
||||
);
|
||||
}
|
||||
);
|
||||
mockConsole(
|
||||
(console, out): void => {
|
||||
});
|
||||
mockConsole((console, out): void => {
|
||||
console.table([1, 2, [3, [4]], [5, 6], [[7], [8]]]);
|
||||
assertEquals(
|
||||
out.toString(),
|
||||
|
@ -514,10 +516,8 @@ test(function consoleTable(): void {
|
|||
└─────────┴───────┴───────┴────────┘
|
||||
`
|
||||
);
|
||||
}
|
||||
);
|
||||
mockConsole(
|
||||
(console, out): void => {
|
||||
});
|
||||
mockConsole((console, out): void => {
|
||||
console.table(new Set([1, 2, 3, "test"]));
|
||||
assertEquals(
|
||||
out.toString(),
|
||||
|
@ -531,11 +531,14 @@ test(function consoleTable(): void {
|
|||
└───────────────────┴────────┘
|
||||
`
|
||||
);
|
||||
}
|
||||
});
|
||||
mockConsole((console, out): void => {
|
||||
console.table(
|
||||
new Map([
|
||||
[1, "one"],
|
||||
[2, "two"]
|
||||
])
|
||||
);
|
||||
mockConsole(
|
||||
(console, out): void => {
|
||||
console.table(new Map([[1, "one"], [2, "two"]]));
|
||||
assertEquals(
|
||||
out.toString(),
|
||||
`┌───────────────────┬─────┬────────┐
|
||||
|
@ -546,10 +549,8 @@ test(function consoleTable(): void {
|
|||
└───────────────────┴─────┴────────┘
|
||||
`
|
||||
);
|
||||
}
|
||||
);
|
||||
mockConsole(
|
||||
(console, out): void => {
|
||||
});
|
||||
mockConsole((console, out): void => {
|
||||
console.table({
|
||||
a: true,
|
||||
b: { c: { d: 10 }, e: [1, 2, [5, 6]] },
|
||||
|
@ -570,10 +571,8 @@ test(function consoleTable(): void {
|
|||
└─────────┴───────────┴───────────────────┴────────┘
|
||||
`
|
||||
);
|
||||
}
|
||||
);
|
||||
mockConsole(
|
||||
(console, out): void => {
|
||||
});
|
||||
mockConsole((console, out): void => {
|
||||
console.table([
|
||||
1,
|
||||
"test",
|
||||
|
@ -594,10 +593,8 @@ test(function consoleTable(): void {
|
|||
└─────────┴────────┴──────────────────────┴────┴────────┘
|
||||
`
|
||||
);
|
||||
}
|
||||
);
|
||||
mockConsole(
|
||||
(console, out): void => {
|
||||
});
|
||||
mockConsole((console, out): void => {
|
||||
console.table([]);
|
||||
assertEquals(
|
||||
out.toString(),
|
||||
|
@ -607,10 +604,8 @@ test(function consoleTable(): void {
|
|||
└─────────┘
|
||||
`
|
||||
);
|
||||
}
|
||||
);
|
||||
mockConsole(
|
||||
(console, out): void => {
|
||||
});
|
||||
mockConsole((console, out): void => {
|
||||
console.table({});
|
||||
assertEquals(
|
||||
out.toString(),
|
||||
|
@ -620,10 +615,8 @@ test(function consoleTable(): void {
|
|||
└─────────┘
|
||||
`
|
||||
);
|
||||
}
|
||||
);
|
||||
mockConsole(
|
||||
(console, out): void => {
|
||||
});
|
||||
mockConsole((console, out): void => {
|
||||
console.table(new Set());
|
||||
assertEquals(
|
||||
out.toString(),
|
||||
|
@ -633,10 +626,8 @@ test(function consoleTable(): void {
|
|||
└───────────────────┘
|
||||
`
|
||||
);
|
||||
}
|
||||
);
|
||||
mockConsole(
|
||||
(console, out): void => {
|
||||
});
|
||||
mockConsole((console, out): void => {
|
||||
console.table(new Map());
|
||||
assertEquals(
|
||||
out.toString(),
|
||||
|
@ -646,14 +637,11 @@ test(function consoleTable(): void {
|
|||
└───────────────────┘
|
||||
`
|
||||
);
|
||||
}
|
||||
);
|
||||
mockConsole(
|
||||
(console, out): void => {
|
||||
});
|
||||
mockConsole((console, out): void => {
|
||||
console.table("test");
|
||||
assertEquals(out.toString(), "test\n");
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// console.log(Error) test
|
||||
|
@ -668,52 +656,40 @@ test(function consoleLogShouldNotThrowError(): void {
|
|||
assertEquals(result, 1);
|
||||
|
||||
// output errors to the console should not include "Uncaught"
|
||||
mockConsole(
|
||||
(console, out): void => {
|
||||
mockConsole((console, out): void => {
|
||||
console.log(new Error("foo"));
|
||||
assertEquals(out.toString().includes("Uncaught"), false);
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// console.dir test
|
||||
test(function consoleDir(): void {
|
||||
mockConsole(
|
||||
(console, out): void => {
|
||||
mockConsole((console, out): void => {
|
||||
console.dir("DIR");
|
||||
assertEquals(out.toString(), "DIR\n");
|
||||
}
|
||||
);
|
||||
mockConsole(
|
||||
(console, out): void => {
|
||||
});
|
||||
mockConsole((console, out): void => {
|
||||
console.dir("DIR", { indentLevel: 2 });
|
||||
assertEquals(out.toString(), " DIR\n");
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// console.dir test
|
||||
test(function consoleDirXml(): void {
|
||||
mockConsole(
|
||||
(console, out): void => {
|
||||
mockConsole((console, out): void => {
|
||||
console.dirxml("DIRXML");
|
||||
assertEquals(out.toString(), "DIRXML\n");
|
||||
}
|
||||
);
|
||||
mockConsole(
|
||||
(console, out): void => {
|
||||
});
|
||||
mockConsole((console, out): void => {
|
||||
console.dirxml("DIRXML", { indentLevel: 2 });
|
||||
assertEquals(out.toString(), " DIRXML\n");
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// console.trace test
|
||||
test(function consoleTrace(): void {
|
||||
mockConsole(
|
||||
(console, _out, err): void => {
|
||||
mockConsole((console, _out, err): void => {
|
||||
console.trace("%s", "custom message");
|
||||
assert(err.toString().includes("Trace: custom message"));
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
|
|
|
@ -87,9 +87,7 @@ function fromDiagnosticCategory(
|
|||
return DiagnosticCategory.Warning;
|
||||
default:
|
||||
throw new Error(
|
||||
`Unexpected DiagnosticCategory: "${category}"/"${
|
||||
ts.DiagnosticCategory[category]
|
||||
}"`
|
||||
`Unexpected DiagnosticCategory: "${category}"/"${ts.DiagnosticCategory[category]}"`
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -40,7 +40,7 @@ function unwrapResponse(res: JsonResponse): Ok {
|
|||
throw new DenoError(res.err!.kind, res.err!.message);
|
||||
}
|
||||
util.assert(res.ok != null);
|
||||
return res.ok!;
|
||||
return res.ok;
|
||||
}
|
||||
|
||||
export function asyncMsgFromRust(opId: number, resUi8: Uint8Array): void {
|
||||
|
@ -50,7 +50,7 @@ export function asyncMsgFromRust(opId: number, resUi8: Uint8Array): void {
|
|||
const promise = promiseTable.get(res.promiseId!);
|
||||
util.assert(promise != null);
|
||||
promiseTable.delete(res.promiseId!);
|
||||
promise!.resolve(res);
|
||||
promise.resolve(res);
|
||||
}
|
||||
|
||||
export function sendSync(
|
||||
|
|
|
@ -18,11 +18,9 @@ const openErrorStackPattern = new RegExp(
|
|||
testPerm({ read: true }, async function sendAsyncStackTrace(): Promise<void> {
|
||||
await Deno.open("nonexistent.txt")
|
||||
.then(unreachable)
|
||||
.catch(
|
||||
(error): void => {
|
||||
.catch((error): void => {
|
||||
assertMatch(error.stack, openErrorStackPattern);
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
test(async function malformedJsonControlBuffer(): Promise<void> {
|
||||
|
|
|
@ -79,7 +79,8 @@ export function asyncMsgFromRust(opId: number, ui8: Uint8Array): void {
|
|||
const { promiseId } = record;
|
||||
const promise = promiseTableMin.get(promiseId);
|
||||
promiseTableMin.delete(promiseId);
|
||||
promise!.resolve(record);
|
||||
util.assert(promise);
|
||||
promise.resolve(record);
|
||||
}
|
||||
|
||||
export async function sendAsyncMinimal(
|
||||
|
|
|
@ -18,11 +18,9 @@ test(async function sendAsyncStackTrace(): Promise<void> {
|
|||
const buf = new Uint8Array(10);
|
||||
await Deno.read(10, "nonexistent.txt", buf)
|
||||
.then(unreachable)
|
||||
.catch(
|
||||
(error): void => {
|
||||
.catch((error): void => {
|
||||
assertMatch(error.stack, readErrorStackPattern);
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
test(async function malformedMinimalControlBuffer(): Promise<void> {
|
||||
// @ts-ignore
|
||||
|
|
|
@ -27,7 +27,7 @@ export const eventTargetHasActivationBehavior: unique symbol = Symbol();
|
|||
export class EventTarget implements domTypes.EventTarget {
|
||||
public [domTypes.eventTargetHost]: domTypes.EventTarget | null = null;
|
||||
public [domTypes.eventTargetListeners]: {
|
||||
[type in string]: domTypes.EventListener[]
|
||||
[type in string]: domTypes.EventListener[];
|
||||
} = {};
|
||||
public [domTypes.eventTargetMode] = "";
|
||||
public [domTypes.eventTargetNodeType]: domTypes.NodeType =
|
||||
|
@ -417,9 +417,7 @@ const eventTargetHelpers = {
|
|||
}
|
||||
|
||||
try {
|
||||
if (listener.callback) {
|
||||
listener.handleEvent(eventImpl);
|
||||
}
|
||||
} catch (error) {
|
||||
throw new DenoError(ErrorKind.Interrupted, error.message);
|
||||
}
|
||||
|
|
|
@ -188,8 +188,7 @@ class Body implements domTypes.Body, domTypes.ReadableStream, io.ReadCloser {
|
|||
body
|
||||
.trim()
|
||||
.split("&")
|
||||
.forEach(
|
||||
(bytes): void => {
|
||||
.forEach((bytes): void => {
|
||||
if (bytes) {
|
||||
const split = bytes.split("=");
|
||||
const name = split.shift()!.replace(/\+/g, " ");
|
||||
|
@ -199,8 +198,7 @@ class Body implements domTypes.Body, domTypes.ReadableStream, io.ReadCloser {
|
|||
decodeURIComponent(value)
|
||||
);
|
||||
}
|
||||
}
|
||||
);
|
||||
});
|
||||
} catch (e) {
|
||||
throw new TypeError("Invalid form urlencoded format");
|
||||
}
|
||||
|
|
|
@ -60,12 +60,10 @@ testPerm({ net: true }, async function fetchBlob(): Promise<void> {
|
|||
testPerm({ net: true }, async function fetchBodyUsed(): Promise<void> {
|
||||
const response = await fetch("http://localhost:4545/cli/tests/fixture.json");
|
||||
assertEquals(response.bodyUsed, false);
|
||||
assertThrows(
|
||||
(): void => {
|
||||
assertThrows((): void => {
|
||||
// Assigning to read-only property throws in the strict mode.
|
||||
response.bodyUsed = true;
|
||||
}
|
||||
);
|
||||
});
|
||||
await response.blob();
|
||||
assertEquals(response.bodyUsed, true);
|
||||
});
|
||||
|
|
|
@ -82,20 +82,21 @@ test(function formDataSetEmptyBlobSuccess(): void {
|
|||
});
|
||||
|
||||
test(function formDataParamsForEachSuccess(): void {
|
||||
const init = [["a", "54"], ["b", "true"]];
|
||||
const init = [
|
||||
["a", "54"],
|
||||
["b", "true"]
|
||||
];
|
||||
const formData = new FormData();
|
||||
for (const [name, value] of init) {
|
||||
formData.append(name, value);
|
||||
}
|
||||
let callNum = 0;
|
||||
formData.forEach(
|
||||
(value, key, parent): void => {
|
||||
formData.forEach((value, key, parent): void => {
|
||||
assertEquals(formData, parent);
|
||||
assertEquals(value, init[callNum][1]);
|
||||
assertEquals(key, init[callNum][0]);
|
||||
callNum++;
|
||||
}
|
||||
);
|
||||
});
|
||||
assertEquals(callNum, init.length);
|
||||
});
|
||||
|
||||
|
@ -104,8 +105,7 @@ test(function formDataParamsArgumentsCheck(): void {
|
|||
|
||||
const methodRequireTwoParams = ["append", "set"];
|
||||
|
||||
methodRequireOneParam.forEach(
|
||||
(method): void => {
|
||||
methodRequireOneParam.forEach((method): void => {
|
||||
const formData = new FormData();
|
||||
let hasThrown = 0;
|
||||
let errMsg = "";
|
||||
|
@ -125,11 +125,9 @@ test(function formDataParamsArgumentsCheck(): void {
|
|||
errMsg,
|
||||
`FormData.${method} requires at least 1 argument, but only 0 present`
|
||||
);
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
methodRequireTwoParams.forEach(
|
||||
(method: string): void => {
|
||||
methodRequireTwoParams.forEach((method: string): void => {
|
||||
const formData = new FormData();
|
||||
let hasThrown = 0;
|
||||
let errMsg = "";
|
||||
|
@ -169,8 +167,7 @@ test(function formDataParamsArgumentsCheck(): void {
|
|||
errMsg,
|
||||
`FormData.${method} requires at least 2 arguments, but only 1 present`
|
||||
);
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
test(function toStringShouldBeWebCompatibility(): void {
|
||||
|
|
|
@ -162,25 +162,19 @@ window.removeEventListener =
|
|||
eventTarget.EventTarget.prototype.removeEventListener;
|
||||
|
||||
// Registers the handler for window.onload function.
|
||||
window.addEventListener(
|
||||
"load",
|
||||
(e: domTypes.Event): void => {
|
||||
window.addEventListener("load", (e: domTypes.Event): void => {
|
||||
const onload = window.onload;
|
||||
if (typeof onload === "function") {
|
||||
onload(e);
|
||||
}
|
||||
}
|
||||
);
|
||||
});
|
||||
// Registers the handler for window.onunload function.
|
||||
window.addEventListener(
|
||||
"unload",
|
||||
(e: domTypes.Event): void => {
|
||||
window.addEventListener("unload", (e: domTypes.Event): void => {
|
||||
const onunload = window.onunload;
|
||||
if (typeof onunload === "function") {
|
||||
onunload(e);
|
||||
}
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
// below are interfaces that are available in TypeScript but
|
||||
// have different signatures
|
||||
|
|
|
@ -81,22 +81,18 @@ test(async function windowQueueMicrotask(): Promise<void> {
|
|||
let resolve1: () => void | undefined;
|
||||
let resolve2: () => void | undefined;
|
||||
let microtaskDone = false;
|
||||
const p1 = new Promise(
|
||||
(res): void => {
|
||||
const p1 = new Promise((res): void => {
|
||||
resolve1 = (): void => {
|
||||
microtaskDone = true;
|
||||
res();
|
||||
};
|
||||
}
|
||||
);
|
||||
const p2 = new Promise(
|
||||
(res): void => {
|
||||
});
|
||||
const p2 = new Promise((res): void => {
|
||||
resolve2 = (): void => {
|
||||
assert(microtaskDone);
|
||||
res();
|
||||
};
|
||||
}
|
||||
);
|
||||
});
|
||||
window.queueMicrotask(resolve1!);
|
||||
setTimeout(resolve2!, 0);
|
||||
await p1;
|
||||
|
|
|
@ -145,21 +145,17 @@ const headerEntriesDict = {
|
|||
test(function headerForEachSuccess(): void {
|
||||
const headers = new Headers(headerEntriesDict);
|
||||
const keys = Object.keys(headerEntriesDict);
|
||||
keys.forEach(
|
||||
(key): void => {
|
||||
keys.forEach((key): void => {
|
||||
const value = headerEntriesDict[key];
|
||||
const newkey = key.toLowerCase();
|
||||
headerEntriesDict[newkey] = value;
|
||||
}
|
||||
);
|
||||
});
|
||||
let callNum = 0;
|
||||
headers.forEach(
|
||||
(value, key, container): void => {
|
||||
headers.forEach((value, key, container): void => {
|
||||
assertEquals(headers, container);
|
||||
assertEquals(value, headerEntriesDict[key]);
|
||||
callNum++;
|
||||
}
|
||||
);
|
||||
});
|
||||
assertEquals(callNum, keys.length);
|
||||
});
|
||||
|
||||
|
@ -260,8 +256,7 @@ test(function headerParamsArgumentsCheck(): void {
|
|||
|
||||
const methodRequireTwoParams = ["append", "set"];
|
||||
|
||||
methodRequireOneParam.forEach(
|
||||
(method): void => {
|
||||
methodRequireOneParam.forEach((method): void => {
|
||||
const headers = new Headers();
|
||||
let hasThrown = 0;
|
||||
let errMsg = "";
|
||||
|
@ -281,11 +276,9 @@ test(function headerParamsArgumentsCheck(): void {
|
|||
errMsg,
|
||||
`Headers.${method} requires at least 1 argument, but only 0 present`
|
||||
);
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
methodRequireTwoParams.forEach(
|
||||
(method): void => {
|
||||
methodRequireTwoParams.forEach((method): void => {
|
||||
const headers = new Headers();
|
||||
let hasThrown = 0;
|
||||
let errMsg = "";
|
||||
|
@ -325,8 +318,7 @@ test(function headerParamsArgumentsCheck(): void {
|
|||
errMsg,
|
||||
`Headers.${method} requires at least 2 arguments, but only 1 present`
|
||||
);
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
test(function toStringShouldBeWebCompatibility(): void {
|
||||
|
|
2
cli/js/lib.deno_runtime.d.ts
vendored
2
cli/js/lib.deno_runtime.d.ts
vendored
|
@ -2268,7 +2268,7 @@ declare namespace eventTarget {
|
|||
export class EventTarget implements domTypes.EventTarget {
|
||||
[domTypes.eventTargetHost]: domTypes.EventTarget | null;
|
||||
[domTypes.eventTargetListeners]: {
|
||||
[type in string]: domTypes.EventListener[]
|
||||
[type in string]: domTypes.EventListener[];
|
||||
};
|
||||
[domTypes.eventTargetMode]: string;
|
||||
[domTypes.eventTargetNodeType]: domTypes.NodeType;
|
||||
|
|
|
@ -28,7 +28,10 @@ function setup() {
|
|||
test(function testDomIterable(): void {
|
||||
const { DomIterable, Base } = setup();
|
||||
|
||||
const fixture: Array<[string, number]> = [["foo", 1], ["bar", 2]];
|
||||
const fixture: Array<[string, number]> = [
|
||||
["foo", 1],
|
||||
["bar", 2]
|
||||
];
|
||||
|
||||
const domIterable = new DomIterable(fixture);
|
||||
|
||||
|
|
|
@ -39,10 +39,8 @@ testPerm({ read: true }, async function resourcesFile(): Promise<void> {
|
|||
Object.keys(resourcesAfter).length,
|
||||
Object.keys(resourcesBefore).length + 1
|
||||
);
|
||||
const newRid = Object.keys(resourcesAfter).find(
|
||||
(rid): boolean => {
|
||||
const newRid = Object.keys(resourcesAfter).find((rid): boolean => {
|
||||
return !resourcesBefore.hasOwnProperty(rid);
|
||||
}
|
||||
);
|
||||
});
|
||||
assertEquals(resourcesAfter[newRid], "fsFile");
|
||||
});
|
||||
|
|
|
@ -295,14 +295,18 @@ export function readableStreamTee<OutputType>(
|
|||
.then(({ value, done }) => {
|
||||
if (done && !closedOrErrored) {
|
||||
if (!canceled1) {
|
||||
rs.readableStreamDefaultControllerClose(branch1![
|
||||
rs.readableStreamDefaultControllerClose(
|
||||
branch1![
|
||||
rs.readableStreamController_
|
||||
] as ReadableStreamDefaultController<OutputType>);
|
||||
] as ReadableStreamDefaultController<OutputType>
|
||||
);
|
||||
}
|
||||
if (!canceled2) {
|
||||
rs.readableStreamDefaultControllerClose(branch2![
|
||||
rs.readableStreamDefaultControllerClose(
|
||||
branch2![
|
||||
rs.readableStreamController_
|
||||
] as ReadableStreamDefaultController<OutputType>);
|
||||
] as ReadableStreamDefaultController<OutputType>
|
||||
);
|
||||
}
|
||||
closedOrErrored = true;
|
||||
}
|
||||
|
|
|
@ -9,12 +9,10 @@ function deferred(): {
|
|||
} {
|
||||
let resolve;
|
||||
let reject;
|
||||
const promise = new Promise(
|
||||
(res, rej): void => {
|
||||
const promise = new Promise((res, rej): void => {
|
||||
resolve = res;
|
||||
reject = rej;
|
||||
}
|
||||
);
|
||||
});
|
||||
return {
|
||||
promise,
|
||||
resolve,
|
||||
|
|
|
@ -185,9 +185,6 @@ testPerm({ read: true, net: true }, async function dialAndListenTLS(): Promise<
|
|||
const tpr = new TextProtoReader(r);
|
||||
const statusLine = await tpr.readLine();
|
||||
assert(statusLine !== Deno.EOF, `line must be read: ${String(statusLine)}`);
|
||||
if (statusLine === Deno.EOF) {
|
||||
return;
|
||||
}
|
||||
const m = statusLine.match(/^(.+?) (.+?) (.+?)$/);
|
||||
assert(m !== null, "must be matched");
|
||||
const [_, proto, status, ok] = m;
|
||||
|
@ -196,9 +193,6 @@ testPerm({ read: true, net: true }, async function dialAndListenTLS(): Promise<
|
|||
assertEquals(ok, "OK");
|
||||
const headers = await tpr.readMIMEHeader();
|
||||
assert(headers !== Deno.EOF);
|
||||
if (headers === Deno.EOF) {
|
||||
return;
|
||||
}
|
||||
const contentLength = parseInt(headers.get("content-length"));
|
||||
const bodyBuf = new Uint8Array(contentLength);
|
||||
await r.readFull(bodyBuf);
|
||||
|
|
|
@ -15,8 +15,7 @@ interface TestResult {
|
|||
|
||||
function permsToCliFlags(perms: Permissions): string[] {
|
||||
return Object.keys(perms)
|
||||
.map(
|
||||
(key): string => {
|
||||
.map((key): string => {
|
||||
if (!perms[key]) return "";
|
||||
|
||||
const cliFlag = key.replace(
|
||||
|
@ -24,8 +23,7 @@ function permsToCliFlags(perms: Permissions): string[] {
|
|||
(x, y): string => `-${y.toLowerCase()}`
|
||||
);
|
||||
return `--allow-${cliFlag}`;
|
||||
}
|
||||
)
|
||||
})
|
||||
.filter((e): boolean => e.length > 0);
|
||||
}
|
||||
|
||||
|
|
|
@ -29,9 +29,7 @@ const patterns = {
|
|||
};
|
||||
|
||||
const urlRegExp = new RegExp(
|
||||
`^${patterns.protocol}?${patterns.authority}?${patterns.path}${
|
||||
patterns.query
|
||||
}?${patterns.hash}?`
|
||||
`^${patterns.protocol}?${patterns.authority}?${patterns.path}${patterns.query}?${patterns.hash}?`
|
||||
);
|
||||
|
||||
const authorityRegExp = new RegExp(
|
||||
|
@ -70,9 +68,7 @@ function parse(url: string): URLParts | undefined {
|
|||
// Based on https://github.com/kelektiv/node-uuid
|
||||
// TODO(kevinkassimo): Use deno_std version once possible.
|
||||
function generateUUID(): string {
|
||||
return "00000000-0000-4000-8000-000000000000".replace(
|
||||
/[0]/g,
|
||||
(): string =>
|
||||
return "00000000-0000-4000-8000-000000000000".replace(/[0]/g, (): string =>
|
||||
// random integer from 0 to 15 as a hex digit.
|
||||
(getRandomValues(new Uint8Array(1))[0] % 16).toString(16)
|
||||
);
|
||||
|
@ -232,9 +228,7 @@ export class URL {
|
|||
if (this.host || this.protocol === "file:") {
|
||||
slash = "//";
|
||||
}
|
||||
return `${this.protocol}${slash}${authentication}${this.host}${
|
||||
this.pathname
|
||||
}${this.search}${this.hash}`;
|
||||
return `${this.protocol}${slash}${authentication}${this.host}${this.pathname}${this.search}${this.hash}`;
|
||||
}
|
||||
|
||||
set href(value: string) {
|
||||
|
|
|
@ -168,8 +168,8 @@ export class URLSearchParams {
|
|||
* searchParams.sort();
|
||||
*/
|
||||
sort(): void {
|
||||
this.params = this.params.sort(
|
||||
(a, b): number => (a[0] === b[0] ? 0 : a[0] > b[0] ? 1 : -1)
|
||||
this.params = this.params.sort((a, b): number =>
|
||||
a[0] === b[0] ? 0 : a[0] > b[0] ? 1 : -1
|
||||
);
|
||||
this.updateSteps();
|
||||
}
|
||||
|
|
|
@ -11,7 +11,10 @@ test(function urlSearchParamsInitString(): void {
|
|||
});
|
||||
|
||||
test(function urlSearchParamsInitIterable(): void {
|
||||
const init = [["a", "54"], ["b", "true"]];
|
||||
const init = [
|
||||
["a", "54"],
|
||||
["b", "true"]
|
||||
];
|
||||
const searchParams = new URLSearchParams(init);
|
||||
assertEquals(searchParams.toString(), "a=54&b=true");
|
||||
});
|
||||
|
@ -89,17 +92,18 @@ test(function urlSearchParamsSortSuccess(): void {
|
|||
});
|
||||
|
||||
test(function urlSearchParamsForEachSuccess(): void {
|
||||
const init = [["a", "54"], ["b", "true"]];
|
||||
const init = [
|
||||
["a", "54"],
|
||||
["b", "true"]
|
||||
];
|
||||
const searchParams = new URLSearchParams(init);
|
||||
let callNum = 0;
|
||||
searchParams.forEach(
|
||||
(value, key, parent): void => {
|
||||
searchParams.forEach((value, key, parent): void => {
|
||||
assertEquals(searchParams, parent);
|
||||
assertEquals(value, init[callNum][1]);
|
||||
assertEquals(key, init[callNum][0]);
|
||||
callNum++;
|
||||
}
|
||||
);
|
||||
});
|
||||
assertEquals(callNum, init.length);
|
||||
});
|
||||
|
||||
|
@ -167,8 +171,9 @@ test(function urlSearchParamsAppendArgumentsCheck(): void {
|
|||
|
||||
const methodRequireTwoParams = ["append", "set"];
|
||||
|
||||
methodRequireOneParam.concat(methodRequireTwoParams).forEach(
|
||||
(method: string): void => {
|
||||
methodRequireOneParam
|
||||
.concat(methodRequireTwoParams)
|
||||
.forEach((method: string): void => {
|
||||
const searchParams = new URLSearchParams();
|
||||
let hasThrown = 0;
|
||||
try {
|
||||
|
@ -182,11 +187,9 @@ test(function urlSearchParamsAppendArgumentsCheck(): void {
|
|||
}
|
||||
}
|
||||
assertEquals(hasThrown, 2);
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
methodRequireTwoParams.forEach(
|
||||
(method: string): void => {
|
||||
methodRequireTwoParams.forEach((method: string): void => {
|
||||
const searchParams = new URLSearchParams();
|
||||
let hasThrown = 0;
|
||||
try {
|
||||
|
@ -200,8 +203,7 @@ test(function urlSearchParamsAppendArgumentsCheck(): void {
|
|||
}
|
||||
}
|
||||
assertEquals(hasThrown, 2);
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// ref: https://github.com/web-platform-tests/wpt/blob/master/url/urlsearchparams-delete.any.js
|
||||
|
|
|
@ -26,7 +26,7 @@ export function log(...args: unknown[]): void {
|
|||
}
|
||||
|
||||
// @internal
|
||||
export function assert(cond: boolean, msg = "assert"): void {
|
||||
export function assert(cond: unknown, msg = "assert"): asserts cond {
|
||||
if (!cond) {
|
||||
throw Error(msg);
|
||||
}
|
||||
|
@ -74,11 +74,9 @@ export type Resolvable<T> = Promise<T> & ResolvableMethods<T>;
|
|||
// @internal
|
||||
export function createResolvable<T>(): Resolvable<T> {
|
||||
let methods: ResolvableMethods<T>;
|
||||
const promise = new Promise<T>(
|
||||
(resolve, reject): void => {
|
||||
const promise = new Promise<T>((resolve, reject): void => {
|
||||
methods = { resolve, reject };
|
||||
}
|
||||
);
|
||||
});
|
||||
// TypeScript doesn't know that the Promise callback occurs synchronously
|
||||
// therefore use of not null assertion (`!`)
|
||||
return Object.assign(promise, methods!) as Resolvable<T>;
|
||||
|
@ -97,12 +95,9 @@ export function unreachable(): never {
|
|||
// @internal
|
||||
export function hexdump(u8: Uint8Array): string {
|
||||
return Array.prototype.map
|
||||
.call(
|
||||
u8,
|
||||
(x: number): string => {
|
||||
.call(u8, (x: number): string => {
|
||||
return ("00" + x.toString(16)).slice(-2);
|
||||
}
|
||||
)
|
||||
})
|
||||
.join(" ");
|
||||
}
|
||||
|
||||
|
|
|
@ -160,11 +160,9 @@ export class WorkerImpl implements Worker {
|
|||
);
|
||||
this.run();
|
||||
this.isClosedPromise = hostGetWorkerClosed(this.id);
|
||||
this.isClosedPromise.then(
|
||||
(): void => {
|
||||
this.isClosedPromise.then((): void => {
|
||||
this.isClosing = true;
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
get closed(): Promise<void> {
|
||||
|
|
|
@ -1,11 +1,9 @@
|
|||
// Check that we can use the async keyword.
|
||||
async function main(): Promise<void> {
|
||||
await new Promise(
|
||||
(resolve): void => {
|
||||
await new Promise((resolve): void => {
|
||||
console.log("2");
|
||||
setTimeout(resolve, 100);
|
||||
}
|
||||
);
|
||||
});
|
||||
console.log("3");
|
||||
}
|
||||
|
||||
|
|
|
@ -1,5 +1,3 @@
|
|||
Deno.args.forEach(
|
||||
(arg): void => {
|
||||
Deno.args.forEach((arg): void => {
|
||||
console.log(arg);
|
||||
}
|
||||
);
|
||||
});
|
||||
|
|
|
@ -1,12 +1,5 @@
|
|||
[WILDCARD]error TS2322: Type '{ a: { b: { c(): { d: number; }; }; }; }' is not assignable to type '{ a: { b: { c(): { d: string; }; }; }; }'.
|
||||
Types of property 'a' are incompatible.
|
||||
Type '{ b: { c(): { d: number; }; }; }' is not assignable to type '{ b: { c(): { d: string; }; }; }'.
|
||||
Types of property 'b' are incompatible.
|
||||
Type '{ c(): { d: number; }; }' is not assignable to type '{ c(): { d: string; }; }'.
|
||||
Types of property 'c' are incompatible.
|
||||
Type '() => { d: number; }' is not assignable to type '() => { d: string; }'.
|
||||
Type '{ d: number; }' is not assignable to type '{ d: string; }'.
|
||||
Types of property 'd' are incompatible.
|
||||
The types of 'a.b.c().d' are incompatible between these types.
|
||||
Type 'number' is not assignable to type 'string'.
|
||||
|
||||
[WILDCARD]/tests/error_003_typescript.ts:20:1
|
||||
|
|
|
@ -362,13 +362,11 @@ itest!(lock_check_ok {
|
|||
http_server: true,
|
||||
});
|
||||
|
||||
/* TODO(ry) Re-enable this test. It is flaky and only fails occasionally.
|
||||
itest!(lock_check_ok2 {
|
||||
args: "run 019_media_types.ts --lock=lock_check_ok2.json",
|
||||
output: "019_media_types.ts.out",
|
||||
http_server: true,
|
||||
});
|
||||
*/
|
||||
|
||||
itest!(lock_check_err {
|
||||
args: "run --lock=lock_check_err.json http://127.0.0.1:4545/cli/tests/003_relative_import.ts",
|
||||
|
|
|
@ -15,11 +15,9 @@ export type Resolvable<T> = Promise<T> & ResolvableMethods<T>;
|
|||
|
||||
export function createResolvable<T>(): Resolvable<T> {
|
||||
let methods: ResolvableMethods<T>;
|
||||
const promise = new Promise<T>(
|
||||
(resolve, reject): void => {
|
||||
const promise = new Promise<T>((resolve, reject): void => {
|
||||
methods = { resolve, reject };
|
||||
}
|
||||
);
|
||||
});
|
||||
// TypeScript doesn't know that the Promise callback occurs synchronously
|
||||
// therefore use of not null assertion (`!`)
|
||||
return Object.assign(promise, methods!) as Resolvable<T>;
|
||||
|
@ -40,13 +38,11 @@ async function main(): Promise<void> {
|
|||
const workers: Array<[Map<number, Resolvable<string>>, Worker]> = [];
|
||||
for (let i = 1; i <= workerCount; ++i) {
|
||||
const worker = new Worker("./subdir/bench_worker.ts");
|
||||
const promise = new Promise(
|
||||
(resolve): void => {
|
||||
const promise = new Promise((resolve): void => {
|
||||
worker.onmessage = (e): void => {
|
||||
if (e.data.cmdId === 0) resolve();
|
||||
};
|
||||
}
|
||||
);
|
||||
});
|
||||
worker.postMessage({ cmdId: 0, action: 2 });
|
||||
await promise;
|
||||
workers.push([new Map(), worker]);
|
||||
|
|
|
@ -5,13 +5,11 @@ async function bench(): Promise<void> {
|
|||
const workers: Worker[] = [];
|
||||
for (let i = 1; i <= workerCount; ++i) {
|
||||
const worker = new Worker("./subdir/bench_worker.ts");
|
||||
const promise = new Promise(
|
||||
(resolve): void => {
|
||||
const promise = new Promise((resolve): void => {
|
||||
worker.onmessage = (e): void => {
|
||||
if (e.data.cmdId === 0) resolve();
|
||||
};
|
||||
}
|
||||
);
|
||||
});
|
||||
worker.postMessage({ cmdId: 0, action: 2 });
|
||||
await promise;
|
||||
workers.push(worker);
|
||||
|
|
|
@ -1 +1 @@
|
|||
Subproject commit b3fe5cb48e9399765ec103ca0c14057f77cf9fc3
|
||||
Subproject commit 6af664c48ed657b89e99a9a8692dc15d7f7a6d9c
|
|
@ -67,6 +67,7 @@ function unreachable() {
|
|||
|
||||
/**
|
||||
* @param {unknown} cond
|
||||
* @returns {asserts cond}
|
||||
*/
|
||||
function assert(cond) {
|
||||
if (!cond) {
|
||||
|
|
|
@ -257,6 +257,7 @@ pub fn get_asset(name: &str) -> Option<&'static str> {
|
|||
"lib.deno_core.d.ts" => Some(include_str!("lib.deno_core.d.ts")),
|
||||
"typescript.d.ts" => inc!("typescript.d.ts"),
|
||||
"lib.esnext.d.ts" => inc!("lib.esnext.d.ts"),
|
||||
"lib.es2020.d.ts" => inc!("lib.es2020.d.ts"),
|
||||
"lib.es2019.d.ts" => inc!("lib.es2019.d.ts"),
|
||||
"lib.es2018.d.ts" => inc!("lib.es2018.d.ts"),
|
||||
"lib.es2017.d.ts" => inc!("lib.es2017.d.ts"),
|
||||
|
@ -289,8 +290,15 @@ pub fn get_asset(name: &str) -> Option<&'static str> {
|
|||
"lib.es2019.object.d.ts" => inc!("lib.es2019.object.d.ts"),
|
||||
"lib.es2019.string.d.ts" => inc!("lib.es2019.string.d.ts"),
|
||||
"lib.es2019.symbol.d.ts" => inc!("lib.es2019.symbol.d.ts"),
|
||||
"lib.es2020.string.d.ts" => inc!("lib.es2020.string.d.ts"),
|
||||
"lib.es2020.symbol.wellknown.d.ts" => {
|
||||
inc!("lib.es2020.symbol.wellknown.d.ts")
|
||||
}
|
||||
"lib.esnext.array.d.ts" => inc!("lib.esnext.array.d.ts"),
|
||||
"lib.esnext.asynciterable.d.ts" => inc!("lib.esnext.asynciterable.d.ts"),
|
||||
"lib.esnext.bigint.d.ts" => inc!("lib.esnext.bigint.d.ts"),
|
||||
"lib.esnext.intl.d.ts" => inc!("lib.esnext.intl.d.ts"),
|
||||
"lib.esnext.symbol.d.ts" => inc!("lib.esnext.symbol.d.ts"),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1 +1 @@
|
|||
Subproject commit 26655db1dd04d93217002ac87f950aba812c53eb
|
||||
Subproject commit 7cf6c70d90b60e962db417d80290288eb786b5fd
|
|
@ -384,8 +384,7 @@ export class Tar {
|
|||
*/
|
||||
getReader(): Deno.Reader {
|
||||
const readers: Deno.Reader[] = [];
|
||||
this.data.forEach(
|
||||
(tarData): void => {
|
||||
this.data.forEach((tarData): void => {
|
||||
let { reader } = tarData;
|
||||
const { filePath } = tarData;
|
||||
const headerArr = formatHeader(tarData);
|
||||
|
@ -404,8 +403,7 @@ export class Tar {
|
|||
)
|
||||
)
|
||||
);
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
// append 2 empty records
|
||||
readers.push(new Deno.Buffer(clean(recordSize * 2)));
|
||||
|
@ -462,22 +460,18 @@ export class Untar {
|
|||
"mtime",
|
||||
"uid",
|
||||
"gid"
|
||||
]).forEach(
|
||||
(key): void => {
|
||||
]).forEach((key): void => {
|
||||
const arr = trim(header[key]);
|
||||
if (arr.byteLength > 0) {
|
||||
meta[key] = parseInt(decoder.decode(arr), 8);
|
||||
}
|
||||
}
|
||||
);
|
||||
(["owner", "group"] as ["owner", "group"]).forEach(
|
||||
(key): void => {
|
||||
});
|
||||
(["owner", "group"] as ["owner", "group"]).forEach((key): void => {
|
||||
const arr = trim(header[key]);
|
||||
if (arr.byteLength > 0) {
|
||||
meta[key] = decoder.decode(arr);
|
||||
}
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
// read the file content
|
||||
const len = parseInt(decoder.decode(header.fileSize), 8);
|
||||
|
|
|
@ -84,8 +84,7 @@ async function read(
|
|||
result = line.split(opt.comma!);
|
||||
|
||||
let quoteError = false;
|
||||
result = result.map(
|
||||
(r): string => {
|
||||
result = result.map((r): string => {
|
||||
if (opt.trimLeadingSpace) {
|
||||
r = r.trimLeft();
|
||||
}
|
||||
|
@ -101,8 +100,7 @@ async function read(
|
|||
}
|
||||
}
|
||||
return r;
|
||||
}
|
||||
);
|
||||
});
|
||||
if (quoteError) {
|
||||
throw new ParseError(Startline, lineIndex, 'bare " in non-quoted-field');
|
||||
}
|
||||
|
@ -226,8 +224,7 @@ export async function parse(
|
|||
);
|
||||
i++;
|
||||
}
|
||||
return r.map(
|
||||
(e): unknown => {
|
||||
return r.map((e): unknown => {
|
||||
if (e.length !== headers.length) {
|
||||
throw `Error number of fields line:${i}`;
|
||||
}
|
||||
|
@ -245,8 +242,7 @@ export async function parse(
|
|||
return opt.parse(out);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
if (opt.parse) {
|
||||
return r.map((e: string[]): unknown => opt.parse!(e));
|
||||
|
|
|
@ -20,7 +20,10 @@ const testCases = [
|
|||
{
|
||||
Name: "CRLF",
|
||||
Input: "a,b\r\nc,d\r\n",
|
||||
Output: [["a", "b"], ["c", "d"]]
|
||||
Output: [
|
||||
["a", "b"],
|
||||
["c", "d"]
|
||||
]
|
||||
},
|
||||
{
|
||||
Name: "BareCR",
|
||||
|
@ -64,12 +67,18 @@ const testCases = [
|
|||
{
|
||||
Name: "BlankLine",
|
||||
Input: "a,b,c\n\nd,e,f\n\n",
|
||||
Output: [["a", "b", "c"], ["d", "e", "f"]]
|
||||
Output: [
|
||||
["a", "b", "c"],
|
||||
["d", "e", "f"]
|
||||
]
|
||||
},
|
||||
{
|
||||
Name: "BlankLineFieldCount",
|
||||
Input: "a,b,c\n\nd,e,f\n\n",
|
||||
Output: [["a", "b", "c"], ["d", "e", "f"]],
|
||||
Output: [
|
||||
["a", "b", "c"],
|
||||
["d", "e", "f"]
|
||||
],
|
||||
UseFieldsPerRecord: true,
|
||||
FieldsPerRecord: 0
|
||||
},
|
||||
|
@ -93,7 +102,10 @@ const testCases = [
|
|||
{
|
||||
Name: "NoComment",
|
||||
Input: "#1,2,3\na,b,c",
|
||||
Output: [["#1", "2", "3"], ["a", "b", "c"]]
|
||||
Output: [
|
||||
["#1", "2", "3"],
|
||||
["a", "b", "c"]
|
||||
]
|
||||
},
|
||||
{
|
||||
Name: "LazyQuotes",
|
||||
|
@ -159,7 +171,10 @@ const testCases = [
|
|||
{
|
||||
Name: "FieldCount",
|
||||
Input: "a,b,c\nd,e",
|
||||
Output: [["a", "b", "c"], ["d", "e"]]
|
||||
Output: [
|
||||
["a", "b", "c"],
|
||||
["d", "e"]
|
||||
]
|
||||
},
|
||||
{
|
||||
Name: "TrailingCommaEOF",
|
||||
|
@ -186,7 +201,11 @@ const testCases = [
|
|||
{
|
||||
Name: "TrailingCommaLine3",
|
||||
Input: "a,b,c\nd,e,f\ng,hi,",
|
||||
Output: [["a", "b", "c"], ["d", "e", "f"], ["g", "hi", ""]],
|
||||
Output: [
|
||||
["a", "b", "c"],
|
||||
["d", "e", "f"],
|
||||
["g", "hi", ""]
|
||||
],
|
||||
TrimLeadingSpace: true
|
||||
},
|
||||
{
|
||||
|
@ -223,13 +242,19 @@ x,,,
|
|||
{
|
||||
Name: "TrailingCommaIneffective1",
|
||||
Input: "a,b,\nc,d,e",
|
||||
Output: [["a", "b", ""], ["c", "d", "e"]],
|
||||
Output: [
|
||||
["a", "b", ""],
|
||||
["c", "d", "e"]
|
||||
],
|
||||
TrimLeadingSpace: true
|
||||
},
|
||||
{
|
||||
Name: "ReadAllReuseRecord",
|
||||
Input: "a,b\nc,d",
|
||||
Output: [["a", "b"], ["c", "d"]],
|
||||
Output: [
|
||||
["a", "b"],
|
||||
["c", "d"]
|
||||
],
|
||||
ReuseRecord: true
|
||||
},
|
||||
// {
|
||||
|
@ -496,7 +521,10 @@ const parseTestCases = [
|
|||
name: "multiline",
|
||||
in: "a,b,c\ne,f,g\n",
|
||||
header: false,
|
||||
result: [["a", "b", "c"], ["e", "f", "g"]]
|
||||
result: [
|
||||
["a", "b", "c"],
|
||||
["e", "f", "g"]
|
||||
]
|
||||
},
|
||||
{
|
||||
name: "header mapping boolean",
|
||||
|
|
|
@ -393,11 +393,9 @@ function joinKeys(keys: string[]): string {
|
|||
// Dotted keys are a sequence of bare or quoted keys joined with a dot.
|
||||
// This allows for grouping similar properties together:
|
||||
return keys
|
||||
.map(
|
||||
(str: string): string => {
|
||||
.map((str: string): string => {
|
||||
return str.match(/[^A-Za-z0-9_-]/) ? `"${str}"` : str;
|
||||
}
|
||||
)
|
||||
})
|
||||
.join(".");
|
||||
}
|
||||
|
||||
|
@ -417,24 +415,20 @@ class Dumper {
|
|||
_parse(obj: Record<string, unknown>, keys: string[] = []): string[] {
|
||||
const out = [];
|
||||
const props = Object.keys(obj);
|
||||
const propObj = props.filter(
|
||||
(e: string): boolean => {
|
||||
const propObj = props.filter((e: string): boolean => {
|
||||
if (obj[e] instanceof Array) {
|
||||
const d: unknown[] = obj[e] as unknown[];
|
||||
return !this._isSimplySerializable(d[0]);
|
||||
}
|
||||
return !this._isSimplySerializable(obj[e]);
|
||||
}
|
||||
);
|
||||
const propPrim = props.filter(
|
||||
(e: string): boolean => {
|
||||
});
|
||||
const propPrim = props.filter((e: string): boolean => {
|
||||
if (obj[e] instanceof Array) {
|
||||
const d: unknown[] = obj[e] as unknown[];
|
||||
return this._isSimplySerializable(d[0]);
|
||||
}
|
||||
return this._isSimplySerializable(obj[e]);
|
||||
}
|
||||
);
|
||||
});
|
||||
const k = propPrim.concat(propObj);
|
||||
for (let i = 0; i < k.length; i++) {
|
||||
const prop = k[i];
|
||||
|
|
|
@ -112,7 +112,10 @@ test({
|
|||
fn(): void {
|
||||
const expected = {
|
||||
arrays: {
|
||||
data: [["gamma", "delta"], [1, 2]],
|
||||
data: [
|
||||
["gamma", "delta"],
|
||||
[1, 2]
|
||||
],
|
||||
hosts: ["alpha", "omega"]
|
||||
}
|
||||
};
|
||||
|
@ -344,7 +347,10 @@ test({
|
|||
sf4: NaN,
|
||||
sf5: NaN,
|
||||
sf6: NaN,
|
||||
data: [["gamma", "delta"], [1, 2]],
|
||||
data: [
|
||||
["gamma", "delta"],
|
||||
[1, 2]
|
||||
],
|
||||
hosts: ["alpha", "omega"]
|
||||
};
|
||||
const expected = `deno = "is"
|
||||
|
|
|
@ -79,11 +79,9 @@ export function parse(
|
|||
? [options.boolean]
|
||||
: options.boolean;
|
||||
|
||||
booleanArgs.filter(Boolean).forEach(
|
||||
(key: string): void => {
|
||||
booleanArgs.filter(Boolean).forEach((key: string): void => {
|
||||
flags.bools[key] = true;
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -114,11 +112,9 @@ export function parse(
|
|||
flags.strings[key] = true;
|
||||
const alias = get(aliases, key);
|
||||
if (alias) {
|
||||
alias.forEach(
|
||||
(alias: string): void => {
|
||||
alias.forEach((alias: string): void => {
|
||||
flags.strings[alias] = true;
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
|
|
@ -587,8 +587,7 @@ const tests: Array<[string, any, string]> = [
|
|||
];
|
||||
|
||||
test(function testThorough(): void {
|
||||
tests.forEach(
|
||||
(t, i): void => {
|
||||
tests.forEach((t, i): void => {
|
||||
// p(t)
|
||||
const is = S(t[0], t[1]);
|
||||
const should = t[2];
|
||||
|
@ -597,8 +596,7 @@ test(function testThorough(): void {
|
|||
should,
|
||||
`failed case[${i}] : is >${is}< should >${should}<`
|
||||
);
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
test(function testWeirdos(): void {
|
||||
|
|
|
@ -317,11 +317,9 @@ testCopySync(
|
|||
(tempDir: string): void => {
|
||||
const srcFile = path.join(testdataDir, "copy_file_not_exists_sync.txt");
|
||||
const destFile = path.join(tempDir, "copy_file_not_exists_1_sync.txt");
|
||||
assertThrows(
|
||||
(): void => {
|
||||
assertThrows((): void => {
|
||||
copySync(srcFile, destFile);
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
);
|
||||
|
||||
|
@ -367,9 +365,7 @@ testCopySync(
|
|||
}
|
||||
);
|
||||
|
||||
testCopySync(
|
||||
"[fs] copy file synchronously",
|
||||
(tempDir: string): void => {
|
||||
testCopySync("[fs] copy file synchronously", (tempDir: string): void => {
|
||||
const srcFile = path.join(testdataDir, "copy_file.txt");
|
||||
const destFile = path.join(tempDir, "copy_file_copy_sync.txt");
|
||||
|
||||
|
@ -409,8 +405,7 @@ testCopySync(
|
|||
|
||||
// Make sure the file has been overwritten.
|
||||
assertEquals(new TextDecoder().decode(Deno.readFileSync(destFile)), "txt");
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
testCopySync(
|
||||
"[fs] copy directory synchronously to its subdirectory",
|
||||
|
@ -450,9 +445,7 @@ testCopySync(
|
|||
}
|
||||
);
|
||||
|
||||
testCopySync(
|
||||
"[fs] copy directory synchronously",
|
||||
(tempDir: string): void => {
|
||||
testCopySync("[fs] copy directory synchronously", (tempDir: string): void => {
|
||||
const srcDir = path.join(testdataDir, "copy_dir");
|
||||
const destDir = path.join(tempDir, "copy_dir_copy_sync");
|
||||
const srcFile = path.join(srcDir, "0.txt");
|
||||
|
@ -499,8 +492,7 @@ testCopySync(
|
|||
new TextDecoder().decode(Deno.readFileSync(destNestFile)),
|
||||
"nest"
|
||||
);
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
testCopySync(
|
||||
"[fs] copy symlink file synchronously",
|
||||
|
|
|
@ -110,18 +110,14 @@ test(function emptyDirSyncIfItExist(): void {
|
|||
assertEquals(stat.isDirectory(), true);
|
||||
|
||||
// nest directory have been remove
|
||||
assertThrows(
|
||||
(): void => {
|
||||
assertThrows((): void => {
|
||||
Deno.statSync(testNestDir);
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
// test file have been remove
|
||||
assertThrows(
|
||||
(): void => {
|
||||
assertThrows((): void => {
|
||||
Deno.statSync(testDirFile);
|
||||
}
|
||||
);
|
||||
});
|
||||
} finally {
|
||||
// remote test dir
|
||||
Deno.removeSync(testDir, { recursive: true });
|
||||
|
|
|
@ -15,11 +15,9 @@ test(async function ensureDirIfItNotExist(): Promise<void> {
|
|||
|
||||
await assertThrowsAsync(
|
||||
async (): Promise<void> => {
|
||||
await Deno.stat(testDir).then(
|
||||
(): void => {
|
||||
await Deno.stat(testDir).then((): void => {
|
||||
throw new Error("test dir should exists.");
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
);
|
||||
|
||||
|
@ -48,11 +46,9 @@ test(async function ensureDirIfItExist(): Promise<void> {
|
|||
|
||||
await assertThrowsAsync(
|
||||
async (): Promise<void> => {
|
||||
await Deno.stat(testDir).then(
|
||||
(): void => {
|
||||
await Deno.stat(testDir).then((): void => {
|
||||
throw new Error("test dir should still exists.");
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
);
|
||||
|
||||
|
@ -68,12 +64,10 @@ test(function ensureDirSyncIfItExist(): void {
|
|||
|
||||
ensureDirSync(testDir);
|
||||
|
||||
assertThrows(
|
||||
(): void => {
|
||||
assertThrows((): void => {
|
||||
Deno.statSync(testDir);
|
||||
throw new Error("test dir should still exists.");
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
Deno.removeSync(baseDir, { recursive: true });
|
||||
});
|
||||
|
|
|
@ -14,11 +14,9 @@ test(async function ensureFileIfItNotExist(): Promise<void> {
|
|||
|
||||
await assertThrowsAsync(
|
||||
async (): Promise<void> => {
|
||||
await Deno.stat(testFile).then(
|
||||
(): void => {
|
||||
await Deno.stat(testFile).then((): void => {
|
||||
throw new Error("test file should exists.");
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
);
|
||||
|
||||
|
@ -31,12 +29,10 @@ test(function ensureFileSyncIfItNotExist(): void {
|
|||
|
||||
ensureFileSync(testFile);
|
||||
|
||||
assertThrows(
|
||||
(): void => {
|
||||
assertThrows((): void => {
|
||||
Deno.statSync(testFile);
|
||||
throw new Error("test file should exists.");
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
Deno.removeSync(testDir, { recursive: true });
|
||||
});
|
||||
|
@ -52,11 +48,9 @@ test(async function ensureFileIfItExist(): Promise<void> {
|
|||
|
||||
await assertThrowsAsync(
|
||||
async (): Promise<void> => {
|
||||
await Deno.stat(testFile).then(
|
||||
(): void => {
|
||||
await Deno.stat(testFile).then((): void => {
|
||||
throw new Error("test file should exists.");
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
);
|
||||
|
||||
|
@ -72,12 +66,10 @@ test(function ensureFileSyncIfItExist(): void {
|
|||
|
||||
ensureFileSync(testFile);
|
||||
|
||||
assertThrows(
|
||||
(): void => {
|
||||
assertThrows((): void => {
|
||||
Deno.statSync(testFile);
|
||||
throw new Error("test file should exists.");
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
Deno.removeSync(testDir, { recursive: true });
|
||||
});
|
||||
|
|
|
@ -31,11 +31,9 @@ test(function ensureLinkSyncIfItNotExist(): void {
|
|||
const testFile = path.join(testDir, "test.txt");
|
||||
const linkFile = path.join(testDir, "link.txt");
|
||||
|
||||
assertThrows(
|
||||
(): void => {
|
||||
assertThrows((): void => {
|
||||
ensureLinkSync(testFile, linkFile);
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
Deno.removeSync(testDir, { recursive: true });
|
||||
});
|
||||
|
|
|
@ -24,11 +24,9 @@ test(async function ensureSymlinkIfItNotExist(): Promise<void> {
|
|||
|
||||
assertThrowsAsync(
|
||||
async (): Promise<void> => {
|
||||
await Deno.stat(testFile).then(
|
||||
(): void => {
|
||||
await Deno.stat(testFile).then((): void => {
|
||||
throw new Error("test file should exists.");
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
);
|
||||
});
|
||||
|
@ -37,18 +35,14 @@ test(function ensureSymlinkSyncIfItNotExist(): void {
|
|||
const testDir = path.join(testdataDir, "link_file_2");
|
||||
const testFile = path.join(testDir, "test.txt");
|
||||
|
||||
assertThrows(
|
||||
(): void => {
|
||||
assertThrows((): void => {
|
||||
ensureSymlinkSync(testFile, path.join(testDir, "test1.txt"));
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
assertThrows(
|
||||
(): void => {
|
||||
assertThrows((): void => {
|
||||
Deno.statSync(testFile);
|
||||
throw new Error("test file should exists.");
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
test(async function ensureSymlinkIfItExist(): Promise<void> {
|
||||
|
|
|
@ -136,8 +136,8 @@ export async function* expandGlob(
|
|||
);
|
||||
}
|
||||
if (hasTrailingSep) {
|
||||
currentMatches = currentMatches.filter(
|
||||
({ info }): boolean => info.isDirectory()
|
||||
currentMatches = currentMatches.filter(({ info }): boolean =>
|
||||
info.isDirectory()
|
||||
);
|
||||
}
|
||||
if (!includeDirs) {
|
||||
|
@ -238,8 +238,8 @@ export function* expandGlobSync(
|
|||
);
|
||||
}
|
||||
if (hasTrailingSep) {
|
||||
currentMatches = currentMatches.filter(
|
||||
({ info }): boolean => info.isDirectory()
|
||||
currentMatches = currentMatches.filter(({ info }): boolean =>
|
||||
info.isDirectory()
|
||||
);
|
||||
}
|
||||
if (!includeDirs) {
|
||||
|
|
|
@ -182,11 +182,9 @@ test(function moveSyncDirectoryIfSrcNotExists(): void {
|
|||
const srcDir = path.join(testdataDir, "move_sync_test_src_1");
|
||||
const destDir = path.join(testdataDir, "move_sync_test_dest_1");
|
||||
// if src directory not exist
|
||||
assertThrows(
|
||||
(): void => {
|
||||
assertThrows((): void => {
|
||||
moveSync(srcDir, destDir);
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
test(function moveSyncDirectoryIfDestNotExists(): void {
|
||||
|
@ -213,11 +211,9 @@ test(function moveSyncFileIfSrcNotExists(): void {
|
|||
const destFile = path.join(testdataDir, "move_sync_test_dest_3", "test.txt");
|
||||
|
||||
// if src directory not exist
|
||||
assertThrows(
|
||||
(): void => {
|
||||
assertThrows((): void => {
|
||||
moveSync(srcFile, destFile);
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
test(function moveSyncFileIfDestExists(): void {
|
||||
|
|
|
@ -65,31 +65,25 @@ test(async function readValidObjJsonFileWithRelativePath(): Promise<void> {
|
|||
test(function readJsonFileNotExistsSync(): void {
|
||||
const emptyJsonFile = path.join(testdataDir, "json_not_exists.json");
|
||||
|
||||
assertThrows(
|
||||
(): void => {
|
||||
assertThrows((): void => {
|
||||
readJsonSync(emptyJsonFile);
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
test(function readEmptyJsonFileSync(): void {
|
||||
const emptyJsonFile = path.join(testdataDir, "json_empty.json");
|
||||
|
||||
assertThrows(
|
||||
(): void => {
|
||||
assertThrows((): void => {
|
||||
readJsonSync(emptyJsonFile);
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
test(function readInvalidJsonFile(): void {
|
||||
const invalidJsonFile = path.join(testdataDir, "json_invalid.json");
|
||||
|
||||
assertThrows(
|
||||
(): void => {
|
||||
assertThrows((): void => {
|
||||
readJsonSync(invalidJsonFile);
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
test(function readValidArrayJsonFileSync(): void {
|
||||
|
|
|
@ -21,13 +21,11 @@ function patternTest(patterns: RegExp[], path: string): boolean {
|
|||
// Forced to reset last index on regex while iterating for have
|
||||
// consistent results.
|
||||
// See: https://stackoverflow.com/a/1520853
|
||||
return patterns.some(
|
||||
(pattern): boolean => {
|
||||
return patterns.some((pattern): boolean => {
|
||||
const r = pattern.test(path);
|
||||
pattern.lastIndex = 0;
|
||||
return r;
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
function include(filename: string, options: WalkOptions): boolean {
|
||||
|
|
|
@ -75,11 +75,9 @@ function modeToString(isDir: boolean, maybeMode: number | null): string {
|
|||
.split("")
|
||||
.reverse()
|
||||
.slice(0, 3)
|
||||
.forEach(
|
||||
(v): void => {
|
||||
.forEach((v): void => {
|
||||
output = modeMap[+v] + output;
|
||||
}
|
||||
);
|
||||
});
|
||||
output = `(${isDir ? "d" : "-"}${output})`;
|
||||
return output;
|
||||
}
|
||||
|
@ -179,8 +177,7 @@ async function serveDir(
|
|||
dirViewerTemplate.replace("<%DIRNAME%>", formattedDirUrl).replace(
|
||||
"<%CONTENTS%>",
|
||||
listEntry
|
||||
.sort(
|
||||
(a, b): number =>
|
||||
.sort((a, b): number =>
|
||||
a.name.toLowerCase() > b.name.toLowerCase() ? 1 : -1
|
||||
)
|
||||
.map((v): string => v.template)
|
||||
|
|
|
@ -505,11 +505,9 @@ test({
|
|||
|
||||
let serverIsRunning = true;
|
||||
p.status()
|
||||
.then(
|
||||
(): void => {
|
||||
.then((): void => {
|
||||
serverIsRunning = false;
|
||||
}
|
||||
)
|
||||
})
|
||||
.catch((_): void => {}); // Ignores the error when closing the process.
|
||||
|
||||
await delay(100);
|
||||
|
@ -551,11 +549,9 @@ test({
|
|||
|
||||
let serverIsRunning = true;
|
||||
p.status()
|
||||
.then(
|
||||
(): void => {
|
||||
.then((): void => {
|
||||
serverIsRunning = false;
|
||||
}
|
||||
)
|
||||
})
|
||||
.catch((_): void => {}); // Ignores the error when closing the process.
|
||||
|
||||
// Requests to the server and immediately closes the connection
|
||||
|
|
|
@ -23,6 +23,7 @@ export class BufferFullError extends Error {
|
|||
|
||||
export class UnexpectedEOFError extends Error {
|
||||
name = "UnexpectedEOFError";
|
||||
partial?: Uint8Array;
|
||||
constructor() {
|
||||
super("Unexpected EOF");
|
||||
}
|
||||
|
|
|
@ -37,9 +37,7 @@ export class BaseHandler {
|
|||
return this.formatter(logRecord);
|
||||
}
|
||||
|
||||
return this.formatter.replace(
|
||||
/{(\S+)}/g,
|
||||
(match, p1): string => {
|
||||
return this.formatter.replace(/{(\S+)}/g, (match, p1): string => {
|
||||
const value = logRecord[p1 as keyof LogRecord];
|
||||
|
||||
// do not interpolate missing values
|
||||
|
@ -48,8 +46,7 @@ export class BaseHandler {
|
|||
}
|
||||
|
||||
return String(value);
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
log(_msg: string): void {}
|
||||
|
|
|
@ -36,11 +36,9 @@ export class Logger {
|
|||
level: level,
|
||||
levelName: getLevelName(level)
|
||||
};
|
||||
this.handlers.forEach(
|
||||
(handler): void => {
|
||||
this.handlers.forEach((handler): void => {
|
||||
handler.handle(record);
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
debug(msg: string, ...args: unknown[]): void {
|
||||
|
|
|
@ -80,11 +80,9 @@ export async function setup(config: LogConfig): Promise<void> {
|
|||
};
|
||||
|
||||
// tear down existing handlers
|
||||
state.handlers.forEach(
|
||||
(handler): void => {
|
||||
state.handlers.forEach((handler): void => {
|
||||
handler.destroy();
|
||||
}
|
||||
);
|
||||
});
|
||||
state.handlers.clear();
|
||||
|
||||
// setup handlers
|
||||
|
@ -106,13 +104,11 @@ export async function setup(config: LogConfig): Promise<void> {
|
|||
const handlerNames = loggerConfig.handlers || [];
|
||||
const handlers: BaseHandler[] = [];
|
||||
|
||||
handlerNames.forEach(
|
||||
(handlerName): void => {
|
||||
handlerNames.forEach((handlerName): void => {
|
||||
if (state.handlers.has(handlerName)) {
|
||||
handlers.push(state.handlers.get(handlerName)!);
|
||||
}
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
const levelName = loggerConfig.level || DEFAULT_LEVEL;
|
||||
const logger = new Logger(levelName, handlers);
|
||||
|
|
|
@ -188,8 +188,7 @@ class PartReader implements Reader, Closer {
|
|||
comps
|
||||
.slice(1)
|
||||
.map((v: string): string => v.trim())
|
||||
.map(
|
||||
(kv: string): void => {
|
||||
.map((kv: string): void => {
|
||||
const [k, v] = kv.split("=");
|
||||
if (v) {
|
||||
const s = v.charAt(0);
|
||||
|
@ -200,8 +199,7 @@ class PartReader implements Reader, Closer {
|
|||
params[k] = v;
|
||||
}
|
||||
}
|
||||
}
|
||||
);
|
||||
});
|
||||
return (this.contentDispositionParams = params);
|
||||
}
|
||||
|
||||
|
|
|
@ -92,11 +92,9 @@ Using `assertThrows()`:
|
|||
|
||||
```ts
|
||||
test(function doesThrow(): void {
|
||||
assertThrows(
|
||||
(): void => {
|
||||
assertThrows((): void => {
|
||||
throw new TypeError("hello world!");
|
||||
}
|
||||
);
|
||||
});
|
||||
assertThrows((): void => {
|
||||
throw new TypeError("hello world!");
|
||||
}, TypeError);
|
||||
|
@ -111,11 +109,9 @@ test(function doesThrow(): void {
|
|||
|
||||
// This test will not pass
|
||||
test(function fails(): void {
|
||||
assertThrows(
|
||||
(): void => {
|
||||
assertThrows((): void => {
|
||||
console.log("Hello world");
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
```
|
||||
|
||||
|
|
|
@ -56,12 +56,10 @@ function buildMessage(diffResult: ReadonlyArray<DiffResult<string>>): string[] {
|
|||
);
|
||||
messages.push("");
|
||||
messages.push("");
|
||||
diffResult.forEach(
|
||||
(result: DiffResult<string>): void => {
|
||||
diffResult.forEach((result: DiffResult<string>): void => {
|
||||
const c = createColor(result.type);
|
||||
messages.push(c(`${createSign(result.type)}${result.value}`));
|
||||
}
|
||||
);
|
||||
});
|
||||
messages.push("");
|
||||
|
||||
return messages;
|
||||
|
@ -131,7 +129,7 @@ export function equal(c: unknown, d: unknown): boolean {
|
|||
}
|
||||
|
||||
/** Make an assertion, if not `true`, then throw. */
|
||||
export function assert(expr: boolean, msg = ""): void {
|
||||
export function assert(expr: unknown, msg = ""): asserts expr {
|
||||
if (!expr) {
|
||||
throw new AssertionError(msg);
|
||||
}
|
||||
|
|
|
@ -51,8 +51,14 @@ test(function testingEqual(): void {
|
|||
assert(equal(new Map(), new Map()));
|
||||
assert(
|
||||
equal(
|
||||
new Map([["foo", "bar"], ["baz", "baz"]]),
|
||||
new Map([["foo", "bar"], ["baz", "baz"]])
|
||||
new Map([
|
||||
["foo", "bar"],
|
||||
["baz", "baz"]
|
||||
]),
|
||||
new Map([
|
||||
["foo", "bar"],
|
||||
["baz", "baz"]
|
||||
])
|
||||
)
|
||||
);
|
||||
assert(
|
||||
|
@ -69,14 +75,26 @@ test(function testingEqual(): void {
|
|||
);
|
||||
assert(
|
||||
equal(
|
||||
new Map([["foo", "bar"], ["baz", "qux"]]),
|
||||
new Map([["baz", "qux"], ["foo", "bar"]])
|
||||
new Map([
|
||||
["foo", "bar"],
|
||||
["baz", "qux"]
|
||||
]),
|
||||
new Map([
|
||||
["baz", "qux"],
|
||||
["foo", "bar"]
|
||||
])
|
||||
)
|
||||
);
|
||||
assert(equal(new Map([["foo", ["bar"]]]), new Map([["foo", ["bar"]]])));
|
||||
assert(!equal(new Map([["foo", "bar"]]), new Map([["bar", "baz"]])));
|
||||
assert(
|
||||
!equal(new Map([["foo", "bar"]]), new Map([["foo", "bar"], ["bar", "baz"]]))
|
||||
!equal(
|
||||
new Map([["foo", "bar"]]),
|
||||
new Map([
|
||||
["foo", "bar"],
|
||||
["bar", "baz"]
|
||||
])
|
||||
)
|
||||
);
|
||||
assert(
|
||||
!equal(
|
||||
|
|
|
@ -133,7 +133,7 @@ export default function diff<T>(A: T[], B: T[]): Array<DiffResult<T>> {
|
|||
k: number,
|
||||
M: number
|
||||
): FarthestPoint {
|
||||
if (slide && slide.y === -1 && (down && down.y === -1))
|
||||
if (slide && slide.y === -1 && down && down.y === -1)
|
||||
return { y: 0, id: 0 };
|
||||
if (
|
||||
(down && down.y === -1) ||
|
||||
|
|
|
@ -360,13 +360,11 @@ const getKeysOfEnumerableProperties = (object: {}): Array<string | symbol> => {
|
|||
const keys: Array<string | symbol> = Object.keys(object).sort();
|
||||
|
||||
if (Object.getOwnPropertySymbols) {
|
||||
Object.getOwnPropertySymbols(object).forEach(
|
||||
(symbol): void => {
|
||||
Object.getOwnPropertySymbols(object).forEach((symbol): void => {
|
||||
if (Object.getOwnPropertyDescriptor(object, symbol)!.enumerable) {
|
||||
keys.push(symbol);
|
||||
}
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
return keys;
|
||||
|
|
|
@ -203,14 +203,12 @@ function report(result: TestResult): void {
|
|||
}
|
||||
|
||||
function printFailedSummary(results: TestResults): void {
|
||||
results.cases.forEach(
|
||||
(v): void => {
|
||||
results.cases.forEach((v): void => {
|
||||
if (!v.ok) {
|
||||
console.error(`${RED_BG_FAIL} ${red(v.name)}`);
|
||||
console.error(v.error);
|
||||
}
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
function printResults(
|
||||
|
@ -321,14 +319,12 @@ async function runTestsSerial(
|
|||
print(
|
||||
GREEN_OK + " " + name + " " + promptTestTime(end - start, true)
|
||||
);
|
||||
results.cases.forEach(
|
||||
(v): void => {
|
||||
results.cases.forEach((v): void => {
|
||||
if (v.name === name) {
|
||||
v.ok = true;
|
||||
v.printed = true;
|
||||
}
|
||||
}
|
||||
);
|
||||
});
|
||||
} catch (err) {
|
||||
if (disableLog) {
|
||||
print(CLEAR_LINE, false);
|
||||
|
@ -336,15 +332,13 @@ async function runTestsSerial(
|
|||
print(`${RED_FAILED} ${name}`);
|
||||
print(err.stack);
|
||||
stats.failed++;
|
||||
results.cases.forEach(
|
||||
(v): void => {
|
||||
results.cases.forEach((v): void => {
|
||||
if (v.name === name) {
|
||||
v.error = err;
|
||||
v.ok = false;
|
||||
v.printed = true;
|
||||
}
|
||||
}
|
||||
);
|
||||
});
|
||||
if (exitOnFail) {
|
||||
break;
|
||||
}
|
||||
|
|
|
@ -204,8 +204,8 @@ async function main(): Promise<void> {
|
|||
|
||||
const include =
|
||||
parsedArgs._.length > 0
|
||||
? (parsedArgs._ as string[]).flatMap(
|
||||
(fileGlob: string): string[] => fileGlob.split(",")
|
||||
? (parsedArgs._ as string[]).flatMap((fileGlob: string): string[] =>
|
||||
fileGlob.split(",")
|
||||
)
|
||||
: ["."];
|
||||
const exclude =
|
||||
|
|
|
@ -51,12 +51,10 @@ test(function testingAssertNotStrictEqual(): void {
|
|||
|
||||
test(function testingDoesThrow(): void {
|
||||
let count = 0;
|
||||
assertThrows(
|
||||
(): void => {
|
||||
assertThrows((): void => {
|
||||
count++;
|
||||
throw new Error();
|
||||
}
|
||||
);
|
||||
});
|
||||
assert(count === 1);
|
||||
});
|
||||
|
||||
|
@ -64,12 +62,10 @@ test(function testingDoesNotThrow(): void {
|
|||
let count = 0;
|
||||
let didThrow = false;
|
||||
try {
|
||||
assertThrows(
|
||||
(): void => {
|
||||
assertThrows((): void => {
|
||||
count++;
|
||||
console.log("Hello world");
|
||||
}
|
||||
);
|
||||
});
|
||||
} catch (e) {
|
||||
assert(e.message === "Expected function to throw.");
|
||||
didThrow = true;
|
||||
|
|
|
@ -114,11 +114,9 @@ test({
|
|||
assertEquals(m.get("SID"), "0");
|
||||
assertEquals(m.get("Privilege"), "127");
|
||||
// Not a legal http header
|
||||
assertThrows(
|
||||
(): void => {
|
||||
assertThrows((): void => {
|
||||
assertEquals(m.get("Audio Mode"), "None");
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
|
|
|
@ -20,11 +20,9 @@ export interface Deferred<T> extends Promise<T> {
|
|||
*/
|
||||
export function deferred<T>(): Deferred<T> {
|
||||
let methods;
|
||||
const promise = new Promise<T>(
|
||||
(resolve, reject): void => {
|
||||
const promise = new Promise<T>((resolve, reject): void => {
|
||||
methods = { resolve, reject };
|
||||
}
|
||||
);
|
||||
});
|
||||
return Object.assign(promise, methods)! as Deferred<T>;
|
||||
}
|
||||
|
||||
|
@ -111,8 +109,7 @@ export async function collectUint8Arrays(
|
|||
|
||||
// Delays the given milliseconds and resolves.
|
||||
export function delay(ms: number): Promise<void> {
|
||||
return new Promise(
|
||||
(res): number =>
|
||||
return new Promise((res): number =>
|
||||
setTimeout((): void => {
|
||||
res();
|
||||
}, ms)
|
||||
|
|
|
@ -8,8 +8,7 @@ export function deepAssign(
|
|||
if (!source || typeof source !== `object`) {
|
||||
return;
|
||||
}
|
||||
Object.entries(source).forEach(
|
||||
([key, value]: [string, unknown]): void => {
|
||||
Object.entries(source).forEach(([key, value]: [string, unknown]): void => {
|
||||
if (value instanceof Date) {
|
||||
target[key] = new Date(value);
|
||||
return;
|
||||
|
@ -26,8 +25,7 @@ export function deepAssign(
|
|||
target[key] = {};
|
||||
}
|
||||
deepAssign(target[key] as Record<string, unknown>, value!);
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
return target;
|
||||
}
|
||||
|
|
|
@ -15,12 +15,10 @@ export default function generate(): string {
|
|||
rnds[6] = (rnds[6] & 0x0f) | 0x40; // Version 4
|
||||
rnds[8] = (rnds[8] & 0x3f) | 0x80; // Variant 10
|
||||
|
||||
const bits: string[] = [...rnds].map(
|
||||
(bit): string => {
|
||||
const bits: string[] = [...rnds].map((bit): string => {
|
||||
const s: string = bit.toString(16);
|
||||
return bit < 0x10 ? "0" + s : s;
|
||||
}
|
||||
);
|
||||
});
|
||||
return [
|
||||
...bits.slice(0, 4),
|
||||
"-",
|
||||
|
|
|
@ -60,11 +60,9 @@ for await (const req of serve(`:${port}`)) {
|
|||
}
|
||||
}
|
||||
)
|
||||
.catch(
|
||||
(err: Error): void => {
|
||||
.catch((err: Error): void => {
|
||||
console.error(`failed to accept websocket: ${err}`);
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
```
|
||||
|
||||
|
@ -117,11 +115,9 @@ while (true) {
|
|||
}
|
||||
// FIXME: Without this,
|
||||
// sock.receive() won't resolved though it is readable...
|
||||
await new Promise(
|
||||
(resolve): void => {
|
||||
await new Promise((resolve): void => {
|
||||
setTimeout(resolve, 0);
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
await sock.close(1000);
|
||||
// FIXME: conn.close() won't shutdown process...
|
||||
|
|
|
@ -44,11 +44,9 @@ while (true) {
|
|||
}
|
||||
// FIXME: Without this,
|
||||
// sock.receive() won't resolved though it is readable...
|
||||
await new Promise(
|
||||
(resolve): void => {
|
||||
await new Promise((resolve): void => {
|
||||
setTimeout(resolve, 0);
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
await sock.close(1000);
|
||||
// FIXME: conn.close() won't shutdown process...
|
||||
|
|
|
@ -52,9 +52,7 @@ for await (const req of serve(`:${port}`)) {
|
|||
}
|
||||
}
|
||||
)
|
||||
.catch(
|
||||
(err: Error): void => {
|
||||
.catch((err: Error): void => {
|
||||
console.error(`failed to accept websocket: ${err}`);
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
|
|
|
@ -1 +1 @@
|
|||
Subproject commit 140d1666ad04fb5ddfd5fc0d55181a9c7c067327
|
||||
Subproject commit 8132faa910c498d4b52cb87fe7141058445a60b3
|
|
@ -14,15 +14,9 @@ http
|
|||
|
||||
const proxy = http.request(options, proxyRes => {
|
||||
res.writeHead(proxyRes.statusCode, proxyRes.headers);
|
||||
proxyRes.pipe(
|
||||
res,
|
||||
{ end: true }
|
||||
);
|
||||
proxyRes.pipe(res, { end: true });
|
||||
});
|
||||
|
||||
req.pipe(
|
||||
proxy,
|
||||
{ end: true }
|
||||
);
|
||||
req.pipe(proxy, { end: true });
|
||||
})
|
||||
.listen(port);
|
||||
|
|
Loading…
Reference in a new issue