diff options
| -rw-r--r-- | util/patches/ajv+8.6.2.patch | 249 | ||||
| -rw-r--r-- | util/patches/test-performance+1.1.3.patch | 381 | ||||
| -rw-r--r-- | util/patches/typescript-json-schema+0.50.1.patch | 14 |
3 files changed, 644 insertions, 0 deletions
diff --git a/util/patches/ajv+8.6.2.patch b/util/patches/ajv+8.6.2.patch new file mode 100644 index 00000000..e7556179 --- /dev/null +++ b/util/patches/ajv+8.6.2.patch @@ -0,0 +1,249 @@ +diff --git a/node_modules/ajv/dist/compile/jtd/parse.js b/node_modules/ajv/dist/compile/jtd/parse.js +index 1eeb1be..7684121 100644 +--- a/node_modules/ajv/dist/compile/jtd/parse.js ++++ b/node_modules/ajv/dist/compile/jtd/parse.js +@@ -239,6 +239,9 @@ function parseType(cxt) { + gen.if(fail, () => parsingError(cxt, codegen_1.str `invalid timestamp`)); + break; + } ++ case "bigint": ++ parseBigInt(cxt); ++ break + case "float32": + case "float64": + parseNumber(cxt); +@@ -284,6 +287,15 @@ function parseNumber(cxt, maxDigits) { + skipWhitespace(cxt); + gen.if(codegen_1._ `"-0123456789".indexOf(${jsonSlice(1)}) < 0`, () => jsonSyntaxError(cxt), () => parseWith(cxt, parseJson_1.parseJsonNumber, maxDigits)); + } ++function parseBigInt(cxt, maxDigits) { ++ const {gen} = cxt ++ skipWhitespace(cxt) ++ gen.if( ++ _`"-0123456789".indexOf(${jsonSlice(1)}) < 0`, ++ () => jsonSyntaxError(cxt), ++ () => parseWith(cxt, parseJson_1.parseJsonBigInt, maxDigits) ++ ) ++} + function parseBooleanToken(bool, fail) { + return (cxt) => { + const { gen, data } = cxt; +diff --git a/node_modules/ajv/dist/compile/rules.js b/node_modules/ajv/dist/compile/rules.js +index 82a591f..1ebd8fe 100644 +--- a/node_modules/ajv/dist/compile/rules.js ++++ b/node_modules/ajv/dist/compile/rules.js +@@ -1,7 +1,7 @@ + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getRules = exports.isJSONType = void 0; +-const _jsonTypes = ["string", "number", "integer", "boolean", "null", "object", "array"]; ++const _jsonTypes = ["string", "number", "integer", "boolean", "null", "object", "array","bigint"]; + const jsonTypes = new Set(_jsonTypes); + function isJSONType(x) { + return typeof x == "string" && jsonTypes.has(x); +@@ -13,10 +13,11 @@ function getRules() { + string: { type: "string", rules: [] }, + array: { type: "array", rules: [] }, + object: { type: "object", rules: [] }, ++ bigint: {type: "bigint", rules: []} + }; + return { +- types: { ...groups, integer: true, boolean: true, null: true }, +- rules: [{ rules: [] }, groups.number, groups.string, groups.array, groups.object], ++ types: { ...groups, integer: true, boolean: true, null: true, bigint: true }, ++ rules: [{ rules: [] }, groups.number, groups.string, groups.array, groups.object, groups.bigint], + post: { rules: [] }, + all: {}, + keywords: {}, +diff --git a/node_modules/ajv/dist/compile/validate/dataType.js b/node_modules/ajv/dist/compile/validate/dataType.js +index 6319e76..8b50b4c 100644 +--- a/node_modules/ajv/dist/compile/validate/dataType.js ++++ b/node_modules/ajv/dist/compile/validate/dataType.js +@@ -52,7 +52,7 @@ function coerceAndCheckDataType(it, types) { + return checkTypes; + } + exports.coerceAndCheckDataType = coerceAndCheckDataType; +-const COERCIBLE = new Set(["string", "number", "integer", "boolean", "null"]); ++const COERCIBLE = new Set(["string", "number", "integer", "boolean", "null","bigint"]); + function coerceToTypes(types, coerceTypes) { + return coerceTypes + ? types.filter((t) => COERCIBLE.has(t) || (coerceTypes === "array" && t === "array")) +@@ -83,6 +83,14 @@ function coerceData(it, types, coerceTo) { + }); + function coerceSpecificType(t) { + switch (t) { ++ case "bigint": ++ gen ++ .elseIf( ++ codegen_1._`${dataType} == "boolean" || ${data} === null ++ || (${dataType} == "string" && ${data} && ${data} == BigInt(${data}))` ++ ) ++ .assign(coerced, codegen_1._`BigInt(${data})`) ++ return + case "string": + gen + .elseIf(codegen_1._ `${dataType} == "number" || ${dataType} == "boolean"`) +@@ -143,6 +151,9 @@ function checkDataType(dataType, data, strictNums, correct = DataType.Correct) { + case "number": + cond = numCond(); + break; ++ case "bigint": ++ cond = codegen_1._`typeof ${data} == "bigint" && isFinite(${data})` ++ break + default: + return codegen_1._ `typeof ${data} ${EQ} ${dataType}`; + } +diff --git a/node_modules/ajv/dist/refs/json-schema-2019-09/meta/validation.json b/node_modules/ajv/dist/refs/json-schema-2019-09/meta/validation.json +index 7027a12..25679c8 100644 +--- a/node_modules/ajv/dist/refs/json-schema-2019-09/meta/validation.json ++++ b/node_modules/ajv/dist/refs/json-schema-2019-09/meta/validation.json +@@ -78,7 +78,7 @@ + "default": 0 + }, + "simpleTypes": { +- "enum": ["array", "boolean", "integer", "null", "number", "object", "string"] ++ "enum": ["array", "boolean", "integer", "null", "number", "object", "string","bigint"] + }, + "stringArray": { + "type": "array", +diff --git a/node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json b/node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json +index e0ae13d..57c9036 100644 +--- a/node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json ++++ b/node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json +@@ -78,7 +78,7 @@ + "default": 0 + }, + "simpleTypes": { +- "enum": ["array", "boolean", "integer", "null", "number", "object", "string"] ++ "enum": ["array", "boolean", "integer", "null", "number", "object", "string","bigint"] + }, + "stringArray": { + "type": "array", +diff --git a/node_modules/ajv/dist/refs/json-schema-draft-06.json b/node_modules/ajv/dist/refs/json-schema-draft-06.json +index 5410064..774435b 100644 +--- a/node_modules/ajv/dist/refs/json-schema-draft-06.json ++++ b/node_modules/ajv/dist/refs/json-schema-draft-06.json +@@ -16,7 +16,7 @@ + "allOf": [{"$ref": "#/definitions/nonNegativeInteger"}, {"default": 0}] + }, + "simpleTypes": { +- "enum": ["array", "boolean", "integer", "null", "number", "object", "string"] ++ "enum": ["array", "boolean", "integer", "null", "number", "object", "string","bigint"] + }, + "stringArray": { + "type": "array", +diff --git a/node_modules/ajv/dist/refs/json-schema-draft-07.json b/node_modules/ajv/dist/refs/json-schema-draft-07.json +index 6a74851..fc6dd7d 100644 +--- a/node_modules/ajv/dist/refs/json-schema-draft-07.json ++++ b/node_modules/ajv/dist/refs/json-schema-draft-07.json +@@ -16,7 +16,7 @@ + "allOf": [{"$ref": "#/definitions/nonNegativeInteger"}, {"default": 0}] + }, + "simpleTypes": { +- "enum": ["array", "boolean", "integer", "null", "number", "object", "string"] ++ "enum": ["array", "boolean", "integer", "null", "number", "object", "string","bigint"] + }, + "stringArray": { + "type": "array", +diff --git a/node_modules/ajv/dist/refs/jtd-schema.js b/node_modules/ajv/dist/refs/jtd-schema.js +index 1ee940a..1148887 100644 +--- a/node_modules/ajv/dist/refs/jtd-schema.js ++++ b/node_modules/ajv/dist/refs/jtd-schema.js +@@ -38,6 +38,7 @@ const typeForm = (root) => ({ + "uint16", + "int32", + "uint32", ++ "bigint", + ], + }, + }, +diff --git a/node_modules/ajv/dist/runtime/parseJson.js b/node_modules/ajv/dist/runtime/parseJson.js +index 2576a6e..e7447b1 100644 +--- a/node_modules/ajv/dist/runtime/parseJson.js ++++ b/node_modules/ajv/dist/runtime/parseJson.js +@@ -97,6 +97,71 @@ exports.parseJsonNumber = parseJsonNumber; + parseJsonNumber.message = undefined; + parseJsonNumber.position = 0; + parseJsonNumber.code = 'require("ajv/dist/runtime/parseJson").parseJsonNumber'; ++ ++function parseJsonBigInt(s, pos, maxDigits) { ++ let numStr = ""; ++ let c; ++ parseJsonBigInt.message = undefined; ++ if (s[pos] === "-") { ++ numStr += "-"; ++ pos++; ++ } ++ if (s[pos] === "0") { ++ numStr += "0"; ++ pos++; ++ } ++ else { ++ if (!parseDigits(maxDigits)) { ++ errorMessage(); ++ return undefined; ++ } ++ } ++ if (maxDigits) { ++ parseJsonBigInt.position = pos; ++ return BigInt(numStr); ++ } ++ if (s[pos] === ".") { ++ numStr += "."; ++ pos++; ++ if (!parseDigits()) { ++ errorMessage(); ++ return undefined; ++ } ++ } ++ if (((c = s[pos]), c === "e" || c === "E")) { ++ numStr += "e"; ++ pos++; ++ if (((c = s[pos]), c === "+" || c === "-")) { ++ numStr += c; ++ pos++; ++ } ++ if (!parseDigits()) { ++ errorMessage(); ++ return undefined; ++ } ++ } ++ parseJsonBigInt.position = pos; ++ return BigInt(numStr); ++ function parseDigits(maxLen) { ++ let digit = false; ++ while (((c = s[pos]), c >= "0" && c <= "9" && (maxLen === undefined || maxLen-- > 0))) { ++ digit = true; ++ numStr += c; ++ pos++; ++ } ++ return digit; ++ } ++ function errorMessage() { ++ parseJsonBigInt.position = pos; ++ parseJsonBigInt.message = pos < s.length ? `unexpected token ${s[pos]}` : "unexpected end"; ++ } ++} ++exports.parseJsonBigInt = parseJsonBigInt; ++parseJsonBigInt.message = undefined; ++parseJsonBigInt.position = 0; ++parseJsonBigInt.code = 'require("ajv/dist/runtime/parseJson").parseJsonBigInt'; ++ ++ + const escapedChars = { + b: "\b", + f: "\f", +diff --git a/node_modules/ajv/dist/vocabularies/jtd/type.js b/node_modules/ajv/dist/vocabularies/jtd/type.js +index 428bddb..fbc3070 100644 +--- a/node_modules/ajv/dist/vocabularies/jtd/type.js ++++ b/node_modules/ajv/dist/vocabularies/jtd/type.js +@@ -45,6 +45,9 @@ const def = { + cond = timestampCode(cxt); + break; + } ++ case "bigint": ++ cond = codegen_1._`typeof ${data} == "bigint" || typeof ${data} == "string"` ++ break + case "float32": + case "float64": + cond = codegen_1._ `typeof ${data} == "number"`; diff --git a/util/patches/test-performance+1.1.3.patch b/util/patches/test-performance+1.1.3.patch new file mode 100644 index 00000000..23b4900b --- /dev/null +++ b/util/patches/test-performance+1.1.3.patch @@ -0,0 +1,381 @@ +diff --git a/node_modules/test-performance/cjs/index.js b/node_modules/test-performance/cjs/index.js +index 65d5904..04638a1 100644 +--- a/node_modules/test-performance/cjs/index.js ++++ b/node_modules/test-performance/cjs/index.js +@@ -1,4 +1,4 @@ +-'use strict'; ++"use strict"; + + /*! ***************************************************************************** + Copyright (c) Microsoft Corporation. +@@ -15,50 +15,139 @@ OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + PERFORMANCE OF THIS SOFTWARE. + ***************************************************************************** */ + ++const { performance } = require("perf_hooks"); ++ + function __awaiter(thisArg, _arguments, P, generator) { +- function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } +- return new (P || (P = Promise))(function (resolve, reject) { +- function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } +- function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } +- function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } +- step((generator = generator.apply(thisArg, _arguments || [])).next()); +- }); ++ function adopt(value) { ++ return value instanceof P ++ ? value ++ : new P(function (resolve) { ++ resolve(value); ++ }); ++ } ++ return new (P || (P = Promise))(function (resolve, reject) { ++ function fulfilled(value) { ++ try { ++ step(generator.next(value)); ++ } catch (e) { ++ reject(e); ++ } ++ } ++ function rejected(value) { ++ try { ++ step(generator["throw"](value)); ++ } catch (e) { ++ reject(e); ++ } ++ } ++ function step(result) { ++ result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); ++ } ++ step((generator = generator.apply(thisArg, _arguments || [])).next()); ++ }); + } + + function __generator(thisArg, body) { +- var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; +- return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; +- function verb(n) { return function (v) { return step([n, v]); }; } +- function step(op) { +- if (f) throw new TypeError("Generator is already executing."); +- while (_) try { +- if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; +- if (y = 0, t) op = [op[0] & 2, t.value]; +- switch (op[0]) { +- case 0: case 1: t = op; break; +- case 4: _.label++; return { value: op[1], done: false }; +- case 5: _.label++; y = op[1]; op = [0]; continue; +- case 7: op = _.ops.pop(); _.trys.pop(); continue; +- default: +- if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } +- if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } +- if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } +- if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } +- if (t[2]) _.ops.pop(); +- _.trys.pop(); continue; +- } +- op = body.call(thisArg, _); +- } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } +- if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; +- } ++ var _ = { ++ label: 0, ++ sent: function () { ++ if (t[0] & 1) throw t[1]; ++ return t[1]; ++ }, ++ trys: [], ++ ops: [], ++ }, ++ f, ++ y, ++ t, ++ g; ++ return ( ++ (g = { next: verb(0), throw: verb(1), return: verb(2) }), ++ typeof Symbol === "function" && ++ (g[Symbol.iterator] = function () { ++ return this; ++ }), ++ g ++ ); ++ function verb(n) { ++ return function (v) { ++ return step([n, v]); ++ }; ++ } ++ function step(op) { ++ if (f) throw new TypeError("Generator is already executing."); ++ while (_) ++ try { ++ if ( ++ ((f = 1), ++ y && ++ (t = ++ op[0] & 2 ++ ? y["return"] ++ : op[0] ++ ? y["throw"] || ((t = y["return"]) && t.call(y), 0) ++ : y.next) && ++ !(t = t.call(y, op[1])).done) ++ ) ++ return t; ++ if (((y = 0), t)) op = [op[0] & 2, t.value]; ++ switch (op[0]) { ++ case 0: ++ case 1: ++ t = op; ++ break; ++ case 4: ++ _.label++; ++ return { value: op[1], done: false }; ++ case 5: ++ _.label++; ++ y = op[1]; ++ op = [0]; ++ continue; ++ case 7: ++ op = _.ops.pop(); ++ _.trys.pop(); ++ continue; ++ default: ++ if (!((t = _.trys), (t = t.length > 0 && t[t.length - 1])) && (op[0] === 6 || op[0] === 2)) { ++ _ = 0; ++ continue; ++ } ++ if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { ++ _.label = op[1]; ++ break; ++ } ++ if (op[0] === 6 && _.label < t[1]) { ++ _.label = t[1]; ++ t = op; ++ break; ++ } ++ if (t && _.label < t[2]) { ++ _.label = t[2]; ++ _.ops.push(op); ++ break; ++ } ++ if (t[2]) _.ops.pop(); ++ _.trys.pop(); ++ continue; ++ } ++ op = body.call(thisArg, _); ++ } catch (e) { ++ op = [6, e]; ++ y = 0; ++ } finally { ++ f = t = 0; ++ } ++ if (op[0] & 5) throw op[1]; ++ return { value: op[0] ? op[1] : void 0, done: true }; ++ } + } + + var baselineFunctions = { +- standard: { +- expectedMsRunTime: 12, +- func: function (dummyParam) { +- }, +- }, ++ standard: { ++ expectedMsRunTime: 12, ++ func: function (dummyParam) {}, ++ }, + }; + + /** +@@ -66,28 +155,28 @@ var baselineFunctions = { + * to a baseline. + */ + function calculateExpectedPerformance(baselineExpected, baselineActual, target) { +- var performanceRatio = baselineActual / baselineExpected; +- return target / performanceRatio; ++ var performanceRatio = baselineActual / baselineExpected; ++ return target / performanceRatio; + } + + /** + * This runs a single performance test of a function + */ + function perfTest(func) { +- return __awaiter(this, void 0, void 0, function () { +- var start, end; +- return __generator(this, function (_a) { +- switch (_a.label) { +- case 0: +- start = performance.now(); +- return [4 /*yield*/, func()]; +- case 1: +- _a.sent(); +- end = performance.now(); +- return [2 /*return*/, end - start]; +- } +- }); +- }); ++ return __awaiter(this, void 0, void 0, function () { ++ var start, end; ++ return __generator(this, function (_a) { ++ switch (_a.label) { ++ case 0: ++ start = performance.now(); ++ return [4 /*yield*/, func()]; ++ case 1: ++ _a.sent(); ++ end = performance.now(); ++ return [2 /*return*/, end - start]; ++ } ++ }); ++ }); + } + + var NUMBER_OF_TESTS = 10000; +@@ -96,22 +185,31 @@ var NUMBER_OF_TESTS = 10000; + * the average in milliseconds. + */ + function getScore(func) { +- return __awaiter(this, void 0, void 0, function () { +- var tests, results; +- var _this = this; +- return __generator(this, function (_a) { +- switch (_a.label) { +- case 0: +- tests = new Array(NUMBER_OF_TESTS).fill(undefined).map(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) { +- return [2 /*return*/, perfTest(func)]; +- }); }); }); +- return [4 /*yield*/, Promise.all(tests)]; +- case 1: +- results = _a.sent(); +- return [2 /*return*/, results.reduce(function (acc, val) { return acc + val; }, 0) / NUMBER_OF_TESTS]; +- } +- }); +- }); ++ return __awaiter(this, void 0, void 0, function () { ++ var tests, results; ++ var _this = this; ++ return __generator(this, function (_a) { ++ switch (_a.label) { ++ case 0: ++ tests = new Array(NUMBER_OF_TESTS).fill(undefined).map(function () { ++ return __awaiter(_this, void 0, void 0, function () { ++ return __generator(this, function (_a) { ++ return [2 /*return*/, perfTest(func)]; ++ }); ++ }); ++ }); ++ return [4 /*yield*/, Promise.all(tests)]; ++ case 1: ++ results = _a.sent(); ++ return [ ++ 2 /*return*/, ++ results.reduce(function (acc, val) { ++ return acc + val; ++ }, 0) / NUMBER_OF_TESTS, ++ ]; ++ } ++ }); ++ }); + } + + /** +@@ -119,31 +217,38 @@ function getScore(func) { + * known baseline function. + */ + function runTests(baselineFunc, targetFunc) { +- return __awaiter(this, void 0, void 0, function () { +- var initialBaselineScore, initialTargetScore, midwayBaselineScore, endTargetScore, endBaselineScore, totalBaselineScore, totalTargetScore; +- return __generator(this, function (_a) { +- switch (_a.label) { +- case 0: return [4 /*yield*/, getScore(baselineFunc)]; +- case 1: +- initialBaselineScore = _a.sent(); +- return [4 /*yield*/, getScore(targetFunc)]; +- case 2: +- initialTargetScore = _a.sent(); +- return [4 /*yield*/, getScore(baselineFunc)]; +- case 3: +- midwayBaselineScore = _a.sent(); +- return [4 /*yield*/, getScore(targetFunc)]; +- case 4: +- endTargetScore = _a.sent(); +- return [4 /*yield*/, getScore(baselineFunc)]; +- case 5: +- endBaselineScore = _a.sent(); +- totalBaselineScore = (initialBaselineScore + midwayBaselineScore + endBaselineScore) / 3; +- totalTargetScore = (initialTargetScore + endTargetScore) / 2; +- return [2 /*return*/, [totalBaselineScore, totalTargetScore]]; +- } +- }); +- }); ++ return __awaiter(this, void 0, void 0, function () { ++ var initialBaselineScore, ++ initialTargetScore, ++ midwayBaselineScore, ++ endTargetScore, ++ endBaselineScore, ++ totalBaselineScore, ++ totalTargetScore; ++ return __generator(this, function (_a) { ++ switch (_a.label) { ++ case 0: ++ return [4 /*yield*/, getScore(baselineFunc)]; ++ case 1: ++ initialBaselineScore = _a.sent(); ++ return [4 /*yield*/, getScore(targetFunc)]; ++ case 2: ++ initialTargetScore = _a.sent(); ++ return [4 /*yield*/, getScore(baselineFunc)]; ++ case 3: ++ midwayBaselineScore = _a.sent(); ++ return [4 /*yield*/, getScore(targetFunc)]; ++ case 4: ++ endTargetScore = _a.sent(); ++ return [4 /*yield*/, getScore(baselineFunc)]; ++ case 5: ++ endBaselineScore = _a.sent(); ++ totalBaselineScore = (initialBaselineScore + midwayBaselineScore + endBaselineScore) / 3; ++ totalTargetScore = (initialTargetScore + endTargetScore) / 2; ++ return [2 /*return*/, [totalBaselineScore, totalTargetScore]]; ++ } ++ }); ++ }); + } + + /** +@@ -152,20 +257,22 @@ function runTests(baselineFunc, targetFunc) { + */ + var BASELINE_FUNCTION = baselineFunctions.standard; + function getPerformanceScore(func) { +- return __awaiter(this, void 0, void 0, function () { +- var _a, baseline, target; +- return __generator(this, function (_b) { +- switch (_b.label) { +- case 0: +- if (typeof func !== 'function') +- throw new Error(func + " is not a function"); +- return [4 /*yield*/, runTests(BASELINE_FUNCTION.func, func)]; +- case 1: +- _a = _b.sent(), baseline = _a[0], target = _a[1]; +- return [2 /*return*/, calculateExpectedPerformance(BASELINE_FUNCTION.expectedMsRunTime, baseline, target)]; +- } +- }); +- }); ++ return __awaiter(this, void 0, void 0, function () { ++ var _a, baseline, target; ++ return __generator(this, function (_b) { ++ switch (_b.label) { ++ case 0: ++ if (typeof func !== "function") throw new Error(func + " is not a function"); ++ return [4 /*yield*/, runTests(BASELINE_FUNCTION.func, func)]; ++ case 1: ++ (_a = _b.sent()), (baseline = _a[0]), (target = _a[1]); ++ return [ ++ 2 /*return*/, ++ calculateExpectedPerformance(BASELINE_FUNCTION.expectedMsRunTime, baseline, target), ++ ]; ++ } ++ }); ++ }); + } + + module.exports = getPerformanceScore; diff --git a/util/patches/typescript-json-schema+0.50.1.patch b/util/patches/typescript-json-schema+0.50.1.patch new file mode 100644 index 00000000..a0d479de --- /dev/null +++ b/util/patches/typescript-json-schema+0.50.1.patch @@ -0,0 +1,14 @@ +diff --git a/node_modules/typescript-json-schema/dist/typescript-json-schema.js b/node_modules/typescript-json-schema/dist/typescript-json-schema.js +index 47e1598..8397b9d 100644 +--- a/node_modules/typescript-json-schema/dist/typescript-json-schema.js ++++ b/node_modules/typescript-json-schema/dist/typescript-json-schema.js +@@ -432,6 +432,9 @@ var JsonSchemaGenerator = (function () { + else if (flags & ts.TypeFlags.Boolean) { + definition.type = "boolean"; + } ++ else if (flags & ts.TypeFlags.BigInt) { ++ definition.type = "bigint"; ++ } + else if (flags & ts.TypeFlags.Null) { + definition.type = "null"; + } |