robojerk/codeql-action

Update checked-in dependencies

Browse source
This commit is contained in:
github-actions[bot] 2023-10-23 18:03:04 +00:00
parent 79817eb679
commit 9c3b394d7f
402 changed files with 12598 additions and 2912 deletions
Download patch file Download diff file Expand all files Collapse all files

67
node_modules/sinon/lib/sinon.js generated vendored
View file

@ -9,40 +9,53 @@ const Sandbox = require("./sinon/sandbox");
const stub = require("./sinon/stub");
const promise = require("./sinon/promise");
const apiMethods = {
createSandbox: createSandbox,
assert: require("./sinon/assert"),
match: require("@sinonjs/samsam").createMatcher,
restoreObject: require("./sinon/restore-object"),
/**
* @param {object} opts injection point to override the default XHR lib in testing
* @param {object} opts.sinonXhrLib
* @returns {object} a configured sandbox
*/
function createApi({ sinonXhrLib }) {
const apiMethods = {
createSandbox: createSandbox,
assert: require("./sinon/assert"),
match: require("@sinonjs/samsam").createMatcher,
restoreObject: require("./sinon/restore-object"),
expectation: require("./sinon/mock-expectation"),
defaultConfig: require("./sinon/util/core/default-config"),
expectation: require("./sinon/mock-expectation"),
defaultConfig: require("./sinon/util/core/default-config"),
// fake timers
timers: fakeTimers.timers,
// fake timers
timers: fakeTimers.timers,
// fake XHR
xhr: nise.fakeXhr.xhr,
FakeXMLHttpRequest: nise.fakeXhr.FakeXMLHttpRequest,
// fake XHR
xhr: sinonXhrLib.fakeXhr.xhr,
FakeXMLHttpRequest: sinonXhrLib.fakeXhr.FakeXMLHttpRequest,
// fake server
fakeServer: nise.fakeServer,
fakeServerWithClock: nise.fakeServerWithClock,
createFakeServer: nise.fakeServer.create.bind(nise.fakeServer),
createFakeServerWithClock: nise.fakeServerWithClock.create.bind(
nise.fakeServerWithClock
),
// fake server
fakeServer: sinonXhrLib.fakeServer,
fakeServerWithClock: sinonXhrLib.fakeServerWithClock,
createFakeServer: sinonXhrLib.fakeServer.create.bind(
sinonXhrLib.fakeServer,
),
createFakeServerWithClock: sinonXhrLib.fakeServerWithClock.create.bind(
sinonXhrLib.fakeServerWithClock,
),
addBehavior: function (name, fn) {
behavior.addBehavior(stub, name, fn);
},
addBehavior: function (name, fn) {
behavior.addBehavior(stub, name, fn);
},
// fake promise
promise: promise,
};
// fake promise
promise: promise,
};
const sandbox = new Sandbox();
const sandbox = new Sandbox();
return extend(sandbox, apiMethods);
}
const api = extend(sandbox, apiMethods);
const api = createApi({ sinonXhrLib: nise });
module.exports = api;
// solely exposed for easier testing
module.exports.createApi = createApi;

44
node_modules/sinon/lib/sinon/assert.js generated vendored
View file

@ -52,7 +52,7 @@ function createAssertObject() {
failAssertion(
this,
`expected ${expected} to be called in order but were called as ${actual}`
`expected ${expected} to be called in order but were called as ${actual}`,
);
} else {
assert.pass("callOrder");
@ -151,7 +151,7 @@ function createAssertObject() {
assert.fail(
`${assertionMethod} takes 1 argument but was called with ${
assertionArgs.length + 1
} arguments`
} arguments`,
);
}
break;
@ -196,8 +196,8 @@ function createAssertObject() {
this,
(fake.printf || fake.proxy.printf).apply(
fake,
concat([msg], args)
)
concat([msg], args),
),
);
} else {
assert.pass(name);
@ -215,79 +215,79 @@ function createAssertObject() {
mirrorPropAsAssertion(
"called",
"expected %n to have been called at least once but was never called"
"expected %n to have been called at least once but was never called",
);
mirrorPropAsAssertion(
"notCalled",
function (spy) {
return !spy.called;
},
"expected %n to not have been called but was called %c%C"
"expected %n to not have been called but was called %c%C",
);
mirrorPropAsAssertion(
"calledOnce",
"expected %n to be called once but was called %c%C"
"expected %n to be called once but was called %c%C",
);
mirrorPropAsAssertion(
"calledTwice",
"expected %n to be called twice but was called %c%C"
"expected %n to be called twice but was called %c%C",
);
mirrorPropAsAssertion(
"calledThrice",
"expected %n to be called thrice but was called %c%C"
"expected %n to be called thrice but was called %c%C",
);
mirrorPropAsAssertion(
"calledOn",
"expected %n to be called with %1 as this but was called with %t"
"expected %n to be called with %1 as this but was called with %t",
);
mirrorPropAsAssertion(
"alwaysCalledOn",
"expected %n to always be called with %1 as this but was called with %t"
"expected %n to always be called with %1 as this but was called with %t",
);
mirrorPropAsAssertion("calledWithNew", "expected %n to be called with new");
mirrorPropAsAssertion(
"alwaysCalledWithNew",
"expected %n to always be called with new"
"expected %n to always be called with new",
);
mirrorPropAsAssertion(
"calledWith",
"expected %n to be called with arguments %D"
"expected %n to be called with arguments %D",
);
mirrorPropAsAssertion(
"calledWithMatch",
"expected %n to be called with match %D"
"expected %n to be called with match %D",
);
mirrorPropAsAssertion(
"alwaysCalledWith",
"expected %n to always be called with arguments %D"
"expected %n to always be called with arguments %D",
);
mirrorPropAsAssertion(
"alwaysCalledWithMatch",
"expected %n to always be called with match %D"
"expected %n to always be called with match %D",
);
mirrorPropAsAssertion(
"calledWithExactly",
"expected %n to be called with exact arguments %D"
"expected %n to be called with exact arguments %D",
);
mirrorPropAsAssertion(
"calledOnceWithExactly",
"expected %n to be called once and with exact arguments %D"
"expected %n to be called once and with exact arguments %D",
);
mirrorPropAsAssertion(
"calledOnceWithMatch",
"expected %n to be called once and with match %D"
"expected %n to be called once and with match %D",
);
mirrorPropAsAssertion(
"alwaysCalledWithExactly",
"expected %n to always be called with exact arguments %D"
"expected %n to always be called with exact arguments %D",
);
mirrorPropAsAssertion(
"neverCalledWith",
"expected %n to never be called with arguments %*%C"
"expected %n to never be called with arguments %*%C",
);
mirrorPropAsAssertion(
"neverCalledWithMatch",
"expected %n to never be called with match %*%C"
"expected %n to never be called with match %*%C",
);
mirrorPropAsAssertion("threw", "%n did not throw exception%C");
mirrorPropAsAssertion("alwaysThrew", "%n did not always throw exception%C");

20
node_modules/sinon/lib/sinon/behavior.js generated vendored
View file

@ -57,13 +57,13 @@ function getCallbackError(behavior, func, args) {
if (behavior.callArgProp) {
msg = `${functionName(
behavior.stub
behavior.stub,
)} expected to yield to '${valueToString(
behavior.callArgProp
behavior.callArgProp,
)}', but no object with such a property was passed.`;
} else {
msg = `${functionName(
behavior.stub
behavior.stub,
)} expected to yield, but no callback was passed.`;
}
@ -87,7 +87,7 @@ function ensureArgs(name, behavior, args) {
throw new TypeError(
`${name} failed: ${index + 1} arguments required but only ${
args.length
} present`
} present`,
);
}
}
@ -105,13 +105,13 @@ function callCallback(behavior, args) {
nextTick(function () {
func.apply(
behavior.callbackContext,
behavior.callbackArguments
behavior.callbackArguments,
);
});
} else {
return func.apply(
behavior.callbackContext,
behavior.callbackArguments
behavior.callbackArguments,
);
}
}
@ -178,7 +178,7 @@ const proto = {
} else if (typeof this.resolveArgAt === "number") {
ensureArgs("resolvesArg", this, args);
return (this.promiseLibrary || Promise).resolve(
args[this.resolveArgAt]
args[this.resolveArgAt],
);
} else if (this.resolveThis) {
return (this.promiseLibrary || Promise).resolve(context);
@ -198,7 +198,7 @@ const proto = {
// Call the constructor
const F = WrappedClass.bind.apply(
WrappedClass,
concat([null], argsArray)
concat([null], argsArray),
);
return new F();
} else if (typeof this.returnValue !== "undefined") {
@ -239,7 +239,7 @@ const proto = {
throw new Error(
'Defining a stub by invoking "stub.onCall(...).withArgs(...)" ' +
'is not supported. Use "stub.withArgs(...).onCall(...)" ' +
"to define sequential behavior for calls with certain arguments."
"to define sequential behavior for calls with certain arguments.",
);
},
};
@ -249,7 +249,7 @@ function createBehavior(behaviorMethod) {
this.defaultBehavior = this.defaultBehavior || proto.create(this);
this.defaultBehavior[behaviorMethod].apply(
this.defaultBehavior,
arguments
arguments,
);
return this;
};

46
node_modules/sinon/lib/sinon/color.js generated vendored
View file

@ -1,31 +1,35 @@
"use strict";
const supportsColor = require("supports-color");
function colorize(str, color) {
if (supportsColor.stdout === false) {
return str;
module.exports = class Colorizer {
constructor(supportsColor = require("supports-color")) {
this.supportsColor = supportsColor;
}
return `\x1b[${color}m${str}\x1b[0m`;
}
colorize(str, color) {
if (this.supportsColor.stdout === false) {
return str;
}
exports.red = function (str) {
return colorize(str, 31);
};
return `\x1b[${color}m${str}\x1b[0m`;
}
exports.green = function (str) {
return colorize(str, 32);
};
red(str) {
return this.colorize(str, 31);
}
exports.cyan = function (str) {
return colorize(str, 96);
};
green(str) {
return this.colorize(str, 32);
}
exports.white = function (str) {
return colorize(str, 39);
};
cyan(str) {
return this.colorize(str, 96);
}
exports.bold = function (str) {
return colorize(str, 1);
white(str) {
return this.colorize(str, 39);
}
bold(str) {
return this.colorize(str, 1);
}
};

2
node_modules/sinon/lib/sinon/create-stub-instance.js generated vendored
View file

@ -28,7 +28,7 @@ module.exports = function createStubInstance(constructor, overrides) {
}
} else {
throw new Error(
`Cannot stub ${propertyName}. Property does not exist!`
`Cannot stub ${propertyName}. Property does not exist!`,
);
}
});

8
node_modules/sinon/lib/sinon/default-behaviors.js generated vendored
View file

@ -16,7 +16,7 @@ function throwsException(fake, error, message) {
} else if (typeof error === "string") {
fake.exceptionCreator = function () {
const newException = new Error(
message || `Sinon-provided ${error}`
message || `Sinon-provided ${error}`,
);
newException.name = error;
return newException;
@ -241,7 +241,7 @@ const defaultBehaviors = {
get: getterFunction,
configurable: isPropertyConfigurable(
rootStub.rootObj,
rootStub.propName
rootStub.propName,
),
});
@ -259,9 +259,9 @@ const defaultBehaviors = {
set: setterFunction,
configurable: isPropertyConfigurable(
rootStub.rootObj,
rootStub.propName
rootStub.propName,
),
}
},
);
return fake;

30
node_modules/sinon/lib/sinon/mock-expectation.js generated vendored
View file

@ -148,15 +148,15 @@ const mockExpectation = {
if (receivedMaxCalls(this)) {
this.failed = true;
mockExpectation.fail(
`${this.method} already called ${timesInWords(this.maxCalls)}`
`${this.method} already called ${timesInWords(this.maxCalls)}`,
);
}
if ("expectedThis" in this && this.expectedThis !== thisValue) {
mockExpectation.fail(
`${this.method} called with ${valueToString(
thisValue
)} as thisValue, expected ${valueToString(this.expectedThis)}`
thisValue,
)} as thisValue, expected ${valueToString(this.expectedThis)}`,
);
}
@ -167,16 +167,16 @@ const mockExpectation = {
if (!args) {
mockExpectation.fail(
`${this.method} received no arguments, expected ${inspect(
expectedArguments
)}`
expectedArguments,
)}`,
);
}
if (args.length < expectedArguments.length) {
mockExpectation.fail(
`${this.method} received too few arguments (${inspect(
args
)}), expected ${inspect(expectedArguments)}`
args,
)}), expected ${inspect(expectedArguments)}`,
);
}
@ -186,8 +186,8 @@ const mockExpectation = {
) {
mockExpectation.fail(
`${this.method} received too many arguments (${inspect(
args
)}), expected ${inspect(expectedArguments)}`
args,
)}), expected ${inspect(expectedArguments)}`,
);
}
@ -197,20 +197,20 @@ const mockExpectation = {
if (!verifyMatcher(expectedArgument, args[i])) {
mockExpectation.fail(
`${this.method} received wrong arguments ${inspect(
args
)}, didn't match ${String(expectedArguments)}`
args,
)}, didn't match ${String(expectedArguments)}`,
);
}
if (!deepEqual(args[i], expectedArgument)) {
mockExpectation.fail(
`${this.method} received wrong arguments ${inspect(
args
)}, expected ${inspect(expectedArguments)}`
args,
)}, expected ${inspect(expectedArguments)}`,
);
}
},
this
this,
);
},
@ -286,7 +286,7 @@ const mockExpectation = {
const message = `${callStr.replace(
", [...",
"[, ..."
"[, ...",
)} ${expectedCallCountInWords(this)}`;
if (this.met()) {

10
node_modules/sinon/lib/sinon/mock.js generated vendored
View file

@ -143,9 +143,9 @@ extend(mock, {
return arrayEquals(
expectedArgs,
currentArgs,
expectation.expectsExactArgCount
expectation.expectsExactArgCount,
);
}
},
);
const expectationsToApply = filter(
@ -155,7 +155,7 @@ extend(mock, {
!expectation.met() &&
expectation.allowsCall(thisValue, args)
);
}
},
);
if (expectationsToApply.length > 0) {
@ -186,7 +186,7 @@ extend(mock, {
`Unexpected call: ${proxyCallToString.call({
proxy: method,
args: args,
})}`
})}`,
);
const err = new Error();
@ -204,7 +204,7 @@ extend(mock, {
proxy: method,
args: args,
stack: err.stack,
})}`
})}`,
);
mockExpectation.fail(join(messages, "\n"));

4
node_modules/sinon/lib/sinon/proxy-call-util.js generated vendored
View file

@ -25,7 +25,7 @@ exports.delegateToCalls = function delegateToCalls(
actual,
returnsValues,
notCalled,
totalCallCount
totalCallCount,
) {
proxy[method] = function () {
if (!this.called) {
@ -47,7 +47,7 @@ exports.delegateToCalls = function delegateToCalls(
currentCall = this.getCall(i);
const returnValue = currentCall[actual || method].apply(
currentCall,
arguments
arguments,
);
push(returnValues, returnValue);
if (returnValue) {

24
node_modules/sinon/lib/sinon/proxy-call.js generated vendored
View file

@ -48,7 +48,7 @@ const callProto = {
function (prev, arg, i) {
return prev && deepEqual(self.args[i], arg);
},
true
true,
);
},
@ -67,7 +67,7 @@ const callProto = {
return prev && match(expectation).test(actual);
},
true
true,
);
},
@ -131,7 +131,7 @@ const callProto = {
callArgWith: function (pos) {
return this.callArgOnWith.apply(
this,
concat([pos, null], slice(arguments, 1))
concat([pos, null], slice(arguments, 1)),
);
},
@ -144,7 +144,7 @@ const callProto = {
throwArg: function (pos) {
if (pos > this.args.length) {
throw new TypeError(
`Not enough arguments: ${pos} required but only ${this.args.length} present`
`Not enough arguments: ${pos} required but only ${this.args.length} present`,
);
}
@ -165,7 +165,7 @@ const callProto = {
throwYieldError(
this.proxy,
" cannot yield since no callback was passed.",
args
args,
);
}
@ -175,7 +175,7 @@ const callProto = {
yieldTo: function (prop) {
return this.yieldToOn.apply(
this,
concat([prop, null], slice(arguments, 1))
concat([prop, null], slice(arguments, 1)),
);
},
@ -190,9 +190,9 @@ const callProto = {
throwYieldError(
this.proxy,
` cannot yield to '${valueToString(
prop
prop,
)}' since no callback was passed.`,
args
args,
);
}
@ -227,7 +227,7 @@ const callProto = {
// Skip the first two frames because they will refer to Sinon code
callStr += (this.stack.split("\n")[3] || "unknown").replace(
/^\s*(?:at\s+|@)?/,
" at "
" at ",
);
}
@ -238,7 +238,7 @@ const callProto = {
if (typeof this.args[pos] !== "function") {
throw new TypeError(
`Expected argument at position ${pos} to be a Function, but was ${typeof this
.args[pos]}`
.args[pos]}`,
);
}
},
@ -261,6 +261,8 @@ callProto.invokeCallback = callProto.yield;
* @param exception
* @param id
* @param errorWithCallStack
*
* @returns {object} proxyCall
*/
function createProxyCall(
proxy,
@ -269,7 +271,7 @@ function createProxyCall(
returnValue,
exception,
id,
errorWithCallStack
errorWithCallStack,
) {
if (typeof id !== "number") {
throw new TypeError("Call id is not a number");

2
node_modules/sinon/lib/sinon/proxy-invoke.js generated vendored
View file

@ -40,7 +40,7 @@ module.exports = function invoke(func, thisValue, args) {
// Call through with `new`
returnValue = new (bind.apply(
this.func || func,
concat([thisValue], args)
concat([thisValue], args),
))();
if (

18
node_modules/sinon/lib/sinon/proxy.js generated vendored
View file

@ -57,7 +57,7 @@ const proxyApi = {
this.returnValues[i],
this.exceptions[i],
this.callIds[i],
this.errorsWithCallStack[i]
this.errorsWithCallStack[i],
);
},
@ -137,7 +137,7 @@ const proxyApi = {
if (this.invoking) {
const err = new Error(
"Cannot reset Sinon function while invoking it. " +
"Move the call to .resetHistory outside of the callback."
"Move the call to .resetHistory outside of the callback.",
);
err.name = "InvalidResetException";
throw err;
@ -183,7 +183,7 @@ delegateToCalls(
"calledWith",
false,
undefined,
1
1,
);
delegateToCalls(proxyApi, "calledWithMatch", true);
delegateToCalls(proxyApi, "alwaysCalledWith", false, "calledWith");
@ -196,7 +196,7 @@ delegateToCalls(
"calledWithExactly",
false,
undefined,
1
1,
);
delegateToCalls(
proxyApi,
@ -205,13 +205,13 @@ delegateToCalls(
"calledWithMatch",
false,
undefined,
1
1,
);
delegateToCalls(
proxyApi,
"alwaysCalledWithExactly",
false,
"calledWithExactly"
"calledWithExactly",
);
delegateToCalls(
proxyApi,
@ -221,7 +221,7 @@ delegateToCalls(
false,
function () {
return true;
}
},
);
delegateToCalls(
proxyApi,
@ -231,7 +231,7 @@ delegateToCalls(
false,
function () {
return true;
}
},
);
delegateToCalls(proxyApi, "threw", true);
delegateToCalls(proxyApi, "alwaysThrew", false, "threw");
@ -334,7 +334,7 @@ function wrapFunction(func, originalFunc) {
}
const nameDescriptor = Object.getOwnPropertyDescriptor(
originalFunc,
"name"
"name",
);
if (nameDescriptor && nameDescriptor.configurable) {
// IE 11 functions don't have a name.

34
node_modules/sinon/lib/sinon/sandbox.js generated vendored
View file

@ -50,7 +50,7 @@ function verifySameType(object, property, replacement) {
throw new TypeError(
`Cannot replace ${typeof object[
property
]} with ${typeof replacement}`
]} with ${typeof replacement}`,
);
}
}
@ -59,8 +59,8 @@ function checkForValidArguments(descriptor, property, replacement) {
if (typeof descriptor === "undefined") {
throw new TypeError(
`Cannot replace non-existent property ${valueToString(
property
)}. Perhaps you meant sandbox.define()?`
property,
)}. Perhaps you meant sandbox.define()?`,
);
}
@ -85,7 +85,7 @@ function Sandbox() {
) {
// eslint-disable-next-line no-console
logger.printWarning(
"Potential memory leak detected; be sure to call restore() to clean up your sandbox. To suppress this warning, modify the leakThreshold property of your sandbox."
"Potential memory leak detected; be sure to call restore() to clean up your sandbox. To suppress this warning, modify the leakThreshold property of your sandbox.",
);
loggedLeakWarning = true;
}
@ -197,7 +197,7 @@ function Sandbox() {
sandbox.restore = function restore() {
if (arguments.length) {
throw new Error(
"sandbox.restore() does not take any parameters. Perhaps you meant stub.restore()"
"sandbox.restore() does not take any parameters. Perhaps you meant stub.restore()",
);
}
@ -259,7 +259,7 @@ function Sandbox() {
fakeRestorer.property === property
) {
throw new TypeError(
`Attempted to replace ${property} which is already replaced`
`Attempted to replace ${property} which is already replaced`,
);
}
});
@ -292,7 +292,7 @@ function Sandbox() {
sandbox.replace.usingAccessor = function replaceUsingAccessor(
object,
property,
replacement
replacement,
) {
const descriptor = getPropertyDescriptor(object, property);
checkForValidArguments(descriptor, property, replacement);
@ -314,8 +314,8 @@ function Sandbox() {
if (descriptor) {
throw new TypeError(
`Cannot define the already existing property ${valueToString(
property
)}. Perhaps you meant sandbox.replace()?`
property,
)}. Perhaps you meant sandbox.replace()?`,
);
}
@ -336,21 +336,21 @@ function Sandbox() {
sandbox.replaceGetter = function replaceGetter(
object,
property,
replacement
replacement,
) {
const descriptor = getPropertyDescriptor(object, property);
if (typeof descriptor === "undefined") {
throw new TypeError(
`Cannot replace non-existent property ${valueToString(
property
)}`
property,
)}`,
);
}
if (typeof replacement !== "function") {
throw new TypeError(
"Expected replacement argument to be a function"
"Expected replacement argument to be a function",
);
}
@ -374,21 +374,21 @@ function Sandbox() {
sandbox.replaceSetter = function replaceSetter(
object,
property,
replacement
replacement,
) {
const descriptor = getPropertyDescriptor(object, property);
if (typeof descriptor === "undefined") {
throw new TypeError(
`Cannot replace non-existent property ${valueToString(
property
)}`
property,
)}`,
);
}
if (typeof replacement !== "function") {
throw new TypeError(
"Expected replacement argument to be a function"
"Expected replacement argument to be a function",
);
}

27
node_modules/sinon/lib/sinon/spy-formatters.js generated vendored
View file

@ -1,7 +1,8 @@
"use strict";
const arrayProto = require("@sinonjs/commons").prototypes.array;
const color = require("./color");
const Colorizer = require("./color");
const color = new Colorizer();
const match = require("@sinonjs/samsam").createMatcher;
const timesInWords = require("./util/core/times-in-words");
const inspect = require("util").inspect;
@ -12,6 +13,14 @@ const map = arrayProto.map;
const push = arrayProto.push;
const slice = arrayProto.slice;
/**
*
* @param matcher
* @param calledArg
* @param calledArgMessage
*
* @returns {string} the colored text
*/
function colorSinonMatchText(matcher, calledArg, calledArgMessage) {
let calledArgumentMessage = calledArgMessage;
let matcherMessage = matcher.message;
@ -24,6 +33,11 @@ function colorSinonMatchText(matcher, calledArg, calledArgMessage) {
return `${calledArgumentMessage} ${matcherMessage}`;
}
/**
* @param diff
*
* @returns {string} the colored diff
*/
function colorDiffText(diff) {
const objects = map(diff, function (part) {
let text = part.value;
@ -40,6 +54,11 @@ function colorDiffText(diff) {
return join(objects, "");
}
/**
*
* @param value
* @returns {string} a quoted string
*/
function quoteStringValue(value) {
if (typeof value === "string") {
return JSON.stringify(value);
@ -91,14 +110,14 @@ module.exports = {
message += colorSinonMatchText(
expectedArg,
calledArg,
calledArgMessage
calledArgMessage,
);
} else {
const expectedArgMessage =
j < expectedArgs.length ? inspect(expectedArg) : "";
const diff = jsDiff.diffJson(
calledArgMessage,
expectedArgMessage
expectedArgMessage,
);
message += colorDiffText(diff);
}
@ -138,7 +157,7 @@ module.exports = {
map(args, function (arg) {
return inspect(arg);
}),
", "
", ",
);
},
};

20
node_modules/sinon/lib/sinon/spy.js generated vendored
View file

@ -81,38 +81,38 @@ const spyApi = {
const delegateToCalls = proxyCallUtil.delegateToCalls;
delegateToCalls(spyApi, "callArg", false, "callArgWith", true, function () {
throw new Error(
`${this.toString()} cannot call arg since it was not yet invoked.`
`${this.toString()} cannot call arg since it was not yet invoked.`,
);
});
spyApi.callArgWith = spyApi.callArg;
delegateToCalls(spyApi, "callArgOn", false, "callArgOnWith", true, function () {
throw new Error(
`${this.toString()} cannot call arg since it was not yet invoked.`
`${this.toString()} cannot call arg since it was not yet invoked.`,
);
});
spyApi.callArgOnWith = spyApi.callArgOn;
delegateToCalls(spyApi, "throwArg", false, "throwArg", false, function () {
throw new Error(
`${this.toString()} cannot throw arg since it was not yet invoked.`
`${this.toString()} cannot throw arg since it was not yet invoked.`,
);
});
delegateToCalls(spyApi, "yield", false, "yield", true, function () {
throw new Error(
`${this.toString()} cannot yield since it was not yet invoked.`
`${this.toString()} cannot yield since it was not yet invoked.`,
);
});
// "invokeCallback" is an alias for "yield" since "yield" is invalid in strict mode.
spyApi.invokeCallback = spyApi.yield;
delegateToCalls(spyApi, "yieldOn", false, "yieldOn", true, function () {
throw new Error(
`${this.toString()} cannot yield since it was not yet invoked.`
`${this.toString()} cannot yield since it was not yet invoked.`,
);
});
delegateToCalls(spyApi, "yieldTo", false, "yieldTo", true, function (property) {
throw new Error(
`${this.toString()} cannot yield to '${valueToString(
property
)}' since it was not yet invoked.`
property,
)}' since it was not yet invoked.`,
);
});
delegateToCalls(
@ -124,10 +124,10 @@ delegateToCalls(
function (property) {
throw new Error(
`${this.toString()} cannot yield to '${valueToString(
property
)}' since it was not yet invoked.`
property,
)}' since it was not yet invoked.`,
);
}
},
);
function createSpy(func) {

12
node_modules/sinon/lib/sinon/stub.js generated vendored
View file

@ -39,7 +39,7 @@ function createStub(originalFunc) {
return (
a.matchingArguments.length - b.matchingArguments.length
);
})
}),
) || proxy;
return getCurrentBehavior(fnStub).invoke(this, arguments);
}
@ -68,7 +68,7 @@ function createStub(originalFunc) {
function stub(object, property) {
if (arguments.length > 2) {
throw new TypeError(
"stub(obj, 'meth', fn) has been removed, see documentation"
"stub(obj, 'meth', fn) has been removed, see documentation",
);
}
@ -80,7 +80,7 @@ function stub(object, property) {
if (isNonExistentProperty(object, property)) {
throw new TypeError(
`Cannot stub non-existent property ${valueToString(property)}`
`Cannot stub non-existent property ${valueToString(property)}`,
);
}
@ -136,17 +136,17 @@ function assertValidPropertyDescriptor(descriptor, property) {
}
if (descriptor.isOwn && !descriptor.configurable && !descriptor.writable) {
throw new TypeError(
`Descriptor for property ${property} is non-configurable and non-writable`
`Descriptor for property ${property} is non-configurable and non-writable`,
);
}
if ((descriptor.get || descriptor.set) && !descriptor.configurable) {
throw new TypeError(
`Descriptor for accessor property ${property} is non-configurable`
`Descriptor for accessor property ${property} is non-configurable`,
);
}
if (isDataDescriptor(descriptor) && !descriptor.writable) {
throw new TypeError(
`Descriptor for data property ${property} is non-writable`
`Descriptor for data property ${property} is non-writable`,
);
}
}

2
node_modules/sinon/lib/sinon/throw-on-falsy-object.js generated vendored
View file

@ -5,7 +5,7 @@ function throwOnFalsyObject(object, property) {
if (property && !object) {
const type = object === null ? "null" : "undefined";
throw new Error(
`Trying to stub property '${valueToString(property)}' of ${type}`
`Trying to stub property '${valueToString(property)}' of ${type}`,
);
}
}

4
node_modules/sinon/lib/sinon/util/core/export-async-behaviors.js generated vendored
View file

@ -12,7 +12,7 @@ module.exports = function exportAsyncBehaviors(behaviorMethods) {
acc[`${method}Async`] = function () {
const result = behaviorMethods[method].apply(
this,
arguments
arguments,
);
this.callbackAsync = true;
return result;
@ -20,6 +20,6 @@ module.exports = function exportAsyncBehaviors(behaviorMethods) {
}
return acc;
},
{}
{},
);
};

8
node_modules/sinon/lib/sinon/util/core/extend.js generated vendored
View file

@ -99,11 +99,11 @@ module.exports = function extend(target, ...sources) {
function copyValue(dest, source, prop) {
const destOwnPropertyDescriptor = Object.getOwnPropertyDescriptor(
dest,
prop
prop,
);
const sourceOwnPropertyDescriptor = Object.getOwnPropertyDescriptor(
source,
prop
prop,
);
if (prop === "name" && !destOwnPropertyDescriptor.writable) {
@ -133,7 +133,7 @@ module.exports = function extend(target, ...sources) {
}
}
Object.defineProperty(dest, prop, descriptors);
}
},
);
};
@ -156,6 +156,6 @@ module.exports.nonEnum = function extendNonEnum(target, ...sources) {
configurable: true,
writable: true,
});
}
},
);
};

2
node_modules/sinon/lib/sinon/util/core/get-property-descriptor.js generated vendored
View file

@ -26,7 +26,7 @@ function getPropertyDescriptor(object, property) {
let proto = object;
let descriptor;
const isOwn = Boolean(
object && Object.getOwnPropertyDescriptor(object, property)
object && Object.getOwnPropertyDescriptor(object, property),
);
while (

2
node_modules/sinon/lib/sinon/util/core/is-non-existent-property.js generated vendored
View file

@ -7,7 +7,7 @@
*/
function isNonExistentProperty(object, property) {
return Boolean(
object && typeof property !== "undefined" && !(property in object)
object && typeof property !== "undefined" && !(property in object),
);
}

4
node_modules/sinon/lib/sinon/util/core/walk-object.js generated vendored
View file

@ -19,7 +19,7 @@ function walkObject(mutator, object, filter) {
if (!object) {
throw new Error(
`Trying to ${name} object but received ${String(object)}`
`Trying to ${name} object but received ${String(object)}`,
);
}
@ -45,7 +45,7 @@ function walkObject(mutator, object, filter) {
if (!called) {
throw new Error(
`Found no methods on object to which we could apply mutations`
`Found no methods on object to which we could apply mutations`,
);
}

18
node_modules/sinon/lib/sinon/util/core/wrap-method.js generated vendored
View file

@ -50,7 +50,7 @@ module.exports = function wrapMethod(object, property, method) {
if (typeof method !== "function" && typeof method !== "object") {
throw new TypeError(
"Method wrapper should be a function or a property descriptor"
"Method wrapper should be a function or a property descriptor",
);
}
@ -60,21 +60,21 @@ module.exports = function wrapMethod(object, property, method) {
if (!isFunction(wrappedMethod)) {
error = new TypeError(
`Attempted to wrap ${typeof wrappedMethod} property ${valueToString(
property
)} as function`
property,
)} as function`,
);
} else if (wrappedMethod.restore && wrappedMethod.restore.sinon) {
error = new TypeError(
`Attempted to wrap ${valueToString(
property
)} which is already wrapped`
property,
)} which is already wrapped`,
);
} else if (wrappedMethod.calledBefore) {
const verb = wrappedMethod.returns ? "stubbed" : "spied on";
error = new TypeError(
`Attempted to wrap ${valueToString(
property
)} which is already ${verb}`
property,
)} which is already ${verb}`,
);
}
@ -109,14 +109,14 @@ module.exports = function wrapMethod(object, property, method) {
if (!wrappedMethodDesc) {
error = new TypeError(
`Attempted to wrap ${typeof wrappedMethod} property ${property} as function`
`Attempted to wrap ${typeof wrappedMethod} property ${property} as function`,
);
} else if (
wrappedMethodDesc.restore &&
wrappedMethodDesc.restore.sinon
) {
error = new TypeError(
`Attempted to wrap ${property} which is already wrapped`
`Attempted to wrap ${property} which is already wrapped`,
);
}
if (error) {

4
node_modules/sinon/lib/sinon/util/fake-timers.js generated vendored
View file

@ -8,6 +8,8 @@ const globalObject = require("@sinonjs/commons").global;
*
* @param config
* @param globalCtx
*
* @returns {object} the clock, after installing it on the global context, if given
*/
function createClock(config, globalCtx) {
let FakeTimersCtx = FakeTimers;
@ -65,7 +67,7 @@ exports.useFakeTimers = function (dateOrConfig) {
}
throw new TypeError(
"useFakeTimers expected epoch or config object. See https://github.com/sinonjs/sinon"
"useFakeTimers expected epoch or config object. See https://github.com/sinonjs/sinon",
);
};

29
node_modules/sinon/node_modules/@sinonjs/commons/LICENSE generated vendored
View file

@ -1,29 +0,0 @@
BSD 3-Clause License
Copyright (c) 2018, Sinon.JS
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

16
node_modules/sinon/node_modules/@sinonjs/commons/README.md generated vendored
View file

@ -1,16 +0,0 @@
# commons
[![CircleCI](https://circleci.com/gh/sinonjs/commons.svg?style=svg)](https://circleci.com/gh/sinonjs/commons)
[![codecov](https://codecov.io/gh/sinonjs/commons/branch/master/graph/badge.svg)](https://codecov.io/gh/sinonjs/commons)
<a href="CODE_OF_CONDUCT.md"><img src="https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg" alt="Contributor Covenant" /></a>
Simple functions shared among the sinon end user libraries
## Rules
- Follows the [Sinon.JS compatibility](https://github.com/sinonjs/sinon/blob/master/CONTRIBUTING.md#compatibility)
- 100% test coverage
- Code formatted using [Prettier](https://prettier.io)
- No side effects welcome! (only pure functions)
- No platform specific functions
- One export per file (any bundler can do tree shaking)

57
node_modules/sinon/node_modules/@sinonjs/commons/lib/called-in-order.js generated vendored
View file

@ -1,57 +0,0 @@
"use strict";
var every = require("./prototypes/array").every;
/**
* @private
*/
function hasCallsLeft(callMap, spy) {
if (callMap[spy.id] === undefined) {
callMap[spy.id] = 0;
}
return callMap[spy.id] < spy.callCount;
}
/**
* @private
*/
function checkAdjacentCalls(callMap, spy, index, spies) {
var calledBeforeNext = true;
if (index !== spies.length - 1) {
calledBeforeNext = spy.calledBefore(spies[index + 1]);
}
if (hasCallsLeft(callMap, spy) && calledBeforeNext) {
callMap[spy.id] += 1;
return true;
}
return false;
}
/**
* A Sinon proxy object (fake, spy, stub)
*
* @typedef {object} SinonProxy
* @property {Function} calledBefore - A method that determines if this proxy was called before another one
* @property {string} id - Some id
* @property {number} callCount - Number of times this proxy has been called
*/
/**
* Returns true when the spies have been called in the order they were supplied in
*
* @param {SinonProxy[] | SinonProxy} spies An array of proxies, or several proxies as arguments
* @returns {boolean} true when spies are called in order, false otherwise
*/
function calledInOrder(spies) {
var callMap = {};
// eslint-disable-next-line no-underscore-dangle
var _spies = arguments.length > 1 ? arguments : spies;
return every(_spies, checkAdjacentCalls.bind(null, callMap));
}
module.exports = calledInOrder;

121
node_modules/sinon/node_modules/@sinonjs/commons/lib/called-in-order.test.js generated vendored
View file

@ -1,121 +0,0 @@
"use strict";
var assert = require("@sinonjs/referee-sinon").assert;
var calledInOrder = require("./called-in-order");
var sinon = require("@sinonjs/referee-sinon").sinon;
var testObject1 = {
someFunction: function () {
return;
},
};
var testObject2 = {
otherFunction: function () {
return;
},
};
var testObject3 = {
thirdFunction: function () {
return;
},
};
function testMethod() {
testObject1.someFunction();
testObject2.otherFunction();
testObject2.otherFunction();
testObject2.otherFunction();
testObject3.thirdFunction();
}
describe("calledInOrder", function () {
beforeEach(function () {
sinon.stub(testObject1, "someFunction");
sinon.stub(testObject2, "otherFunction");
sinon.stub(testObject3, "thirdFunction");
testMethod();
});
afterEach(function () {
testObject1.someFunction.restore();
testObject2.otherFunction.restore();
testObject3.thirdFunction.restore();
});
describe("given single array argument", function () {
describe("when stubs were called in expected order", function () {
it("returns true", function () {
assert.isTrue(
calledInOrder([
testObject1.someFunction,
testObject2.otherFunction,
])
);
assert.isTrue(
calledInOrder([
testObject1.someFunction,
testObject2.otherFunction,
testObject2.otherFunction,
testObject3.thirdFunction,
])
);
});
});
describe("when stubs were called in unexpected order", function () {
it("returns false", function () {
assert.isFalse(
calledInOrder([
testObject2.otherFunction,
testObject1.someFunction,
])
);
assert.isFalse(
calledInOrder([
testObject2.otherFunction,
testObject1.someFunction,
testObject1.someFunction,
testObject3.thirdFunction,
])
);
});
});
});
describe("given multiple arguments", function () {
describe("when stubs were called in expected order", function () {
it("returns true", function () {
assert.isTrue(
calledInOrder(
testObject1.someFunction,
testObject2.otherFunction
)
);
assert.isTrue(
calledInOrder(
testObject1.someFunction,
testObject2.otherFunction,
testObject3.thirdFunction
)
);
});
});
describe("when stubs were called in unexpected order", function () {
it("returns false", function () {
assert.isFalse(
calledInOrder(
testObject2.otherFunction,
testObject1.someFunction
)
);
assert.isFalse(
calledInOrder(
testObject2.otherFunction,
testObject1.someFunction,
testObject3.thirdFunction
)
);
});
});
});
});

27
node_modules/sinon/node_modules/@sinonjs/commons/lib/class-name.js generated vendored
View file

@ -1,27 +0,0 @@
"use strict";
var functionName = require("./function-name");
/**
* Returns a display name for a value from a constructor
*
* @param {object} value A value to examine
* @returns {(string|null)} A string or null
*/
function className(value) {
return (
(value.constructor && value.constructor.name) ||
// The next branch is for IE11 support only:
// Because the name property is not set on the prototype
// of the Function object, we finally try to grab the
// name from its definition. This will never be reached
// in node, so we are not able to test this properly.
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name
(typeof value.constructor === "function" &&
/* istanbul ignore next */
functionName(value.constructor)) ||
null
);
}
module.exports = className;

37
node_modules/sinon/node_modules/@sinonjs/commons/lib/class-name.test.js generated vendored
View file

@ -1,37 +0,0 @@
"use strict";
/* eslint-disable no-empty-function */
var assert = require("@sinonjs/referee").assert;
var className = require("./class-name");
describe("className", function () {
it("returns the class name of an instance", function () {
// Because eslint-config-sinon disables es6, we can't
// use a class definition here
// https://github.com/sinonjs/eslint-config-sinon/blob/master/index.js
// var instance = new (class TestClass {})();
var instance = new (function TestClass() {})();
var name = className(instance);
assert.equals(name, "TestClass");
});
it("returns 'Object' for {}", function () {
var name = className({});
assert.equals(name, "Object");
});
it("returns null for an object that has no prototype", function () {
var obj = Object.create(null);
var name = className(obj);
assert.equals(name, null);
});
it("returns null for an object whose prototype was mangled", function () {
// This is what Node v6 and v7 do for objects returned by querystring.parse()
function MangledObject() {}
MangledObject.prototype = Object.create(null);
var obj = new MangledObject();
var name = className(obj);
assert.equals(name, null);
});
});

51
node_modules/sinon/node_modules/@sinonjs/commons/lib/deprecated.js generated vendored
View file

@ -1,51 +0,0 @@
/* eslint-disable no-console */
"use strict";
/**
* Returns a function that will invoke the supplied function and print a
* deprecation warning to the console each time it is called.
*
* @param {Function} func
* @param {string} msg
* @returns {Function}
*/
exports.wrap = function (func, msg) {
var wrapped = function () {
exports.printWarning(msg);
return func.apply(this, arguments);
};
if (func.prototype) {
wrapped.prototype = func.prototype;
}
return wrapped;
};
/**
* Returns a string which can be supplied to `wrap()` to notify the user that a
* particular part of the sinon API has been deprecated.
*
* @param {string} packageName
* @param {string} funcName
* @returns {string}
*/
exports.defaultMsg = function (packageName, funcName) {
return `${packageName}.${funcName} is deprecated and will be removed from the public API in a future version of ${packageName}.`;
};
/**
* Prints a warning on the console, when it exists
*
* @param {string} msg
* @returns {undefined}
*/
exports.printWarning = function (msg) {
/* istanbul ignore next */
if (typeof process === "object" && process.emitWarning) {
// Emit Warnings in Node
process.emitWarning(msg);
} else if (console.info) {
console.info(msg);
} else {
console.log(msg);
}
};

101
node_modules/sinon/node_modules/@sinonjs/commons/lib/deprecated.test.js generated vendored
View file

@ -1,101 +0,0 @@
/* eslint-disable no-console */
"use strict";
var assert = require("@sinonjs/referee-sinon").assert;
var sinon = require("@sinonjs/referee-sinon").sinon;
var deprecated = require("./deprecated");
var msg = "test";
describe("deprecated", function () {
describe("defaultMsg", function () {
it("should return a string", function () {
assert.equals(
deprecated.defaultMsg("sinon", "someFunc"),
"sinon.someFunc is deprecated and will be removed from the public API in a future version of sinon."
);
});
});
describe("printWarning", function () {
beforeEach(function () {
sinon.replace(process, "emitWarning", sinon.fake());
});
afterEach(sinon.restore);
describe("when `process.emitWarning` is defined", function () {
it("should call process.emitWarning with a msg", function () {
deprecated.printWarning(msg);
assert.calledOnceWith(process.emitWarning, msg);
});
});
describe("when `process.emitWarning` is undefined", function () {
beforeEach(function () {
sinon.replace(console, "info", sinon.fake());
sinon.replace(console, "log", sinon.fake());
process.emitWarning = undefined;
});
afterEach(sinon.restore);
describe("when `console.info` is defined", function () {
it("should call `console.info` with a message", function () {
deprecated.printWarning(msg);
assert.calledOnceWith(console.info, msg);
});
});
describe("when `console.info` is undefined", function () {
it("should call `console.log` with a message", function () {
console.info = undefined;
deprecated.printWarning(msg);
assert.calledOnceWith(console.log, msg);
});
});
});
});
describe("wrap", function () {
// eslint-disable-next-line mocha/no-setup-in-describe
var method = sinon.fake();
var wrapped;
beforeEach(function () {
wrapped = deprecated.wrap(method, msg);
});
it("should return a wrapper function", function () {
assert.match(wrapped, sinon.match.func);
});
it("should assign the prototype of the passed method", function () {
assert.equals(method.prototype, wrapped.prototype);
});
context("when the passed method has falsy prototype", function () {
it("should not be assigned to the wrapped method", function () {
method.prototype = null;
wrapped = deprecated.wrap(method, msg);
assert.match(wrapped.prototype, sinon.match.object);
});
});
context("when invoking the wrapped function", function () {
before(function () {
sinon.replace(deprecated, "printWarning", sinon.fake());
wrapped({});
});
it("should call `printWarning` before invoking", function () {
assert.calledOnceWith(deprecated.printWarning, msg);
});
it("should invoke the passed method with the given arguments", function () {
assert.calledOnceWith(method, {});
});
});
});
});

27
node_modules/sinon/node_modules/@sinonjs/commons/lib/every.js generated vendored
View file

@ -1,27 +0,0 @@
"use strict";
/**
* Returns true when fn returns true for all members of obj.
* This is an every implementation that works for all iterables
*
* @param {object} obj
* @param {Function} fn
* @returns {boolean}
*/
module.exports = function every(obj, fn) {
var pass = true;
try {
// eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods
obj.forEach(function () {
if (!fn.apply(this, arguments)) {
// Throwing an error is the only way to break `forEach`
throw new Error();
}
});
} catch (e) {
pass = false;
}
return pass;
};

41
node_modules/sinon/node_modules/@sinonjs/commons/lib/every.test.js generated vendored
View file

@ -1,41 +0,0 @@
"use strict";
var assert = require("@sinonjs/referee-sinon").assert;
var sinon = require("@sinonjs/referee-sinon").sinon;
var every = require("./every");
describe("util/core/every", function () {
it("returns true when the callback function returns true for every element in an iterable", function () {
var obj = [true, true, true, true];
var allTrue = every(obj, function (val) {
return val;
});
assert(allTrue);
});
it("returns false when the callback function returns false for any element in an iterable", function () {
var obj = [true, true, true, false];
var result = every(obj, function (val) {
return val;
});
assert.isFalse(result);
});
it("calls the given callback once for each item in an iterable until it returns false", function () {
var iterableOne = [true, true, true, true];
var iterableTwo = [true, true, false, true];
var callback = sinon.spy(function (val) {
return val;
});
every(iterableOne, callback);
assert.equals(callback.callCount, 4);
callback.resetHistory();
every(iterableTwo, callback);
assert.equals(callback.callCount, 3);
});
});

29
node_modules/sinon/node_modules/@sinonjs/commons/lib/function-name.js generated vendored
View file

@ -1,29 +0,0 @@
"use strict";
/**
* Returns a display name for a function
*
* @param {Function} func
* @returns {string}
*/
module.exports = function functionName(func) {
if (!func) {
return "";
}
try {
return (
func.displayName ||
func.name ||
// Use function decomposition as a last resort to get function
// name. Does not rely on function decomposition to work - if it
// doesn't debugging will be slightly less informative
// (i.e. toString will say 'spy' rather than 'myFunc').
(String(func).match(/function ([^\s(]+)/) || [])[1]
);
} catch (e) {
// Stringify may fail and we might get an exception, as a last-last
// resort fall back to empty string.
return "";
}
};

76
node_modules/sinon/node_modules/@sinonjs/commons/lib/function-name.test.js generated vendored
View file

@ -1,76 +0,0 @@
"use strict";
var jsc = require("jsverify");
var refute = require("@sinonjs/referee-sinon").refute;
var functionName = require("./function-name");
describe("function-name", function () {
it("should return empty string if func is falsy", function () {
jsc.assertForall("falsy", function (fn) {
return functionName(fn) === "";
});
});
it("should use displayName by default", function () {
jsc.assertForall("nestring", function (displayName) {
var fn = { displayName: displayName };
return functionName(fn) === fn.displayName;
});
});
it("should use name if displayName is not available", function () {
jsc.assertForall("nestring", function (name) {
var fn = { name: name };
return functionName(fn) === fn.name;
});
});
it("should fallback to string parsing", function () {
jsc.assertForall("nat", function (naturalNumber) {
var name = `fn${naturalNumber}`;
var fn = {
toString: function () {
return `\nfunction ${name}`;
},
};
return functionName(fn) === name;
});
});
it("should not fail when a name cannot be found", function () {
refute.exception(function () {
var fn = {
toString: function () {
return "\nfunction (";
},
};
functionName(fn);
});
});
it("should not fail when toString is undefined", function () {
refute.exception(function () {
functionName(Object.create(null));
});
});
it("should not fail when toString throws", function () {
refute.exception(function () {
var fn;
try {
// eslint-disable-next-line no-eval
fn = eval("(function*() {})")().constructor;
} catch (e) {
// env doesn't support generators
return;
}
functionName(fn);
});
});
});

22
node_modules/sinon/node_modules/@sinonjs/commons/lib/global.js generated vendored
View file

@ -1,22 +0,0 @@
"use strict";
/**
* A reference to the global object
*
* @type {object} globalObject
*/
var globalObject;
/* istanbul ignore else */
if (typeof global !== "undefined") {
// Node
globalObject = global;
} else if (typeof window !== "undefined") {
// Browser
globalObject = window;
} else {
// WebWorker
globalObject = self;
}
module.exports = globalObject;

16
node_modules/sinon/node_modules/@sinonjs/commons/lib/global.test.js generated vendored
View file

@ -1,16 +0,0 @@
"use strict";
var assert = require("@sinonjs/referee-sinon").assert;
var globalObject = require("./global");
describe("global", function () {
before(function () {
if (typeof global === "undefined") {
this.skip();
}
});
it("is same as global", function () {
assert.same(globalObject, global);
});
});

14
node_modules/sinon/node_modules/@sinonjs/commons/lib/index.js generated vendored
View file

@ -1,14 +0,0 @@
"use strict";
module.exports = {
global: require("./global"),
calledInOrder: require("./called-in-order"),
className: require("./class-name"),
deprecated: require("./deprecated"),
every: require("./every"),
functionName: require("./function-name"),
orderByFirstCall: require("./order-by-first-call"),
prototypes: require("./prototypes"),
typeOf: require("./type-of"),
valueToString: require("./value-to-string"),
};

31
node_modules/sinon/node_modules/@sinonjs/commons/lib/index.test.js generated vendored
View file

@ -1,31 +0,0 @@
"use strict";
var assert = require("@sinonjs/referee-sinon").assert;
var index = require("./index");
var expectedMethods = [
"calledInOrder",
"className",
"every",
"functionName",
"orderByFirstCall",
"typeOf",
"valueToString",
];
var expectedObjectProperties = ["deprecated", "prototypes"];
describe("package", function () {
// eslint-disable-next-line mocha/no-setup-in-describe
expectedMethods.forEach(function (name) {
it(`should export a method named ${name}`, function () {
assert.isFunction(index[name]);
});
});
// eslint-disable-next-line mocha/no-setup-in-describe
expectedObjectProperties.forEach(function (name) {
it(`should export an object property named ${name}`, function () {
assert.isObject(index[name]);
});
});
});

36
node_modules/sinon/node_modules/@sinonjs/commons/lib/order-by-first-call.js generated vendored
View file

@ -1,36 +0,0 @@
"use strict";
var sort = require("./prototypes/array").sort;
var slice = require("./prototypes/array").slice;
/**
* @private
*/
function comparator(a, b) {
// uuid, won't ever be equal
var aCall = a.getCall(0);
var bCall = b.getCall(0);
var aId = (aCall && aCall.callId) || -1;
var bId = (bCall && bCall.callId) || -1;
return aId < bId ? -1 : 1;
}
/**
* A Sinon proxy object (fake, spy, stub)
*
* @typedef {object} SinonProxy
* @property {Function} getCall - A method that can return the first call
*/
/**
* Sorts an array of SinonProxy instances (fake, spy, stub) by their first call
*
* @param {SinonProxy[] | SinonProxy} spies
* @returns {SinonProxy[]}
*/
function orderByFirstCall(spies) {
return sort(slice(spies), comparator);
}
module.exports = orderByFirstCall;

52
node_modules/sinon/node_modules/@sinonjs/commons/lib/order-by-first-call.test.js generated vendored
View file

@ -1,52 +0,0 @@
"use strict";
var assert = require("@sinonjs/referee-sinon").assert;
var knuthShuffle = require("knuth-shuffle").knuthShuffle;
var sinon = require("@sinonjs/referee-sinon").sinon;
var orderByFirstCall = require("./order-by-first-call");
describe("orderByFirstCall", function () {
it("should order an Array of spies by the callId of the first call, ascending", function () {
// create an array of spies
var spies = [
sinon.spy(),
sinon.spy(),
sinon.spy(),
sinon.spy(),
sinon.spy(),
sinon.spy(),
];
// call all the spies
spies.forEach(function (spy) {
spy();
});
// add a few uncalled spies
spies.push(sinon.spy());
spies.push(sinon.spy());
// randomise the order of the spies
knuthShuffle(spies);
var sortedSpies = orderByFirstCall(spies);
assert.equals(sortedSpies.length, spies.length);
var orderedByFirstCall = sortedSpies.every(function (spy, index) {
if (index + 1 === sortedSpies.length) {
return true;
}
var nextSpy = sortedSpies[index + 1];
// uncalled spies should be ordered first
if (!spy.called) {
return true;
}
return spy.calledImmediatelyBefore(nextSpy);
});
assert.isTrue(orderedByFirstCall);
});
});

43
node_modules/sinon/node_modules/@sinonjs/commons/lib/prototypes/README.md generated vendored
View file

@ -1,43 +0,0 @@
# Prototypes
The functions in this folder are to be use for keeping cached references to the built-in prototypes, so that people can't inadvertently break the library by making mistakes in userland.
See https://github.com/sinonjs/sinon/pull/1523
## Without cached references
```js
// in userland, the library user needs to replace the filter method on
// Array.prototype
var array = [1, 2, 3];
sinon.replace(array, "filter", sinon.fake.returns(2));
// in a sinon module, the library author needs to use the filter method
var someArray = ["a", "b", 42, "c"];
var answer = filter(someArray, function (v) {
return v === 42;
});
console.log(answer);
// => 2
```
## With cached references
```js
// in userland, the library user needs to replace the filter method on
// Array.prototype
var array = [1, 2, 3];
sinon.replace(array, "filter", sinon.fake.returns(2));
// in a sinon module, the library author needs to use the filter method
// get a reference to the original Array.prototype.filter
var filter = require("@sinonjs/commons").prototypes.array.filter;
var someArray = ["a", "b", 42, "c"];
var answer = filter(someArray, function (v) {
return v === 42;
});
console.log(answer);
// => 42
```

5
node_modules/sinon/node_modules/@sinonjs/commons/lib/prototypes/array.js generated vendored
View file

@ -1,5 +0,0 @@
"use strict";
var copyPrototype = require("./copy-prototype-methods");
module.exports = copyPrototype(Array.prototype);

40
node_modules/sinon/node_modules/@sinonjs/commons/lib/prototypes/copy-prototype-methods.js generated vendored
View file

@ -1,40 +0,0 @@
"use strict";
var call = Function.call;
var throwsOnProto = require("./throws-on-proto");
var disallowedProperties = [
// ignore size because it throws from Map
"size",
"caller",
"callee",
"arguments",
];
// This branch is covered when tests are run with `--disable-proto=throw`,
// however we can test both branches at the same time, so this is ignored
/* istanbul ignore next */
if (throwsOnProto) {
disallowedProperties.push("__proto__");
}
module.exports = function copyPrototypeMethods(prototype) {
// eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods
return Object.getOwnPropertyNames(prototype).reduce(function (
result,
name
) {
if (disallowedProperties.includes(name)) {
return result;
}
if (typeof prototype[name] !== "function") {
return result;
}
result[name] = call.bind(prototype[name]);
return result;
},
Object.create(null));
};

12
node_modules/sinon/node_modules/@sinonjs/commons/lib/prototypes/copy-prototype-methods.test.js generated vendored
View file

@ -1,12 +0,0 @@
"use strict";
var refute = require("@sinonjs/referee-sinon").refute;
var copyPrototypeMethods = require("./copy-prototype-methods");
describe("copyPrototypeMethods", function () {
it("does not throw for Map", function () {
refute.exception(function () {
copyPrototypeMethods(Map.prototype);
});
});
});

5
node_modules/sinon/node_modules/@sinonjs/commons/lib/prototypes/function.js generated vendored
View file

@ -1,5 +0,0 @@
"use strict";
var copyPrototype = require("./copy-prototype-methods");
module.exports = copyPrototype(Function.prototype);

10
node_modules/sinon/node_modules/@sinonjs/commons/lib/prototypes/index.js generated vendored
View file

@ -1,10 +0,0 @@
"use strict";
module.exports = {
array: require("./array"),
function: require("./function"),
map: require("./map"),
object: require("./object"),
set: require("./set"),
string: require("./string"),
};

61
node_modules/sinon/node_modules/@sinonjs/commons/lib/prototypes/index.test.js generated vendored
View file

@ -1,61 +0,0 @@
"use strict";
var assert = require("@sinonjs/referee-sinon").assert;
var arrayProto = require("./index").array;
var functionProto = require("./index").function;
var mapProto = require("./index").map;
var objectProto = require("./index").object;
var setProto = require("./index").set;
var stringProto = require("./index").string;
var throwsOnProto = require("./throws-on-proto");
describe("prototypes", function () {
describe(".array", function () {
// eslint-disable-next-line mocha/no-setup-in-describe
verifyProperties(arrayProto, Array);
});
describe(".function", function () {
// eslint-disable-next-line mocha/no-setup-in-describe
verifyProperties(functionProto, Function);
});
describe(".map", function () {
// eslint-disable-next-line mocha/no-setup-in-describe
verifyProperties(mapProto, Map);
});
describe(".object", function () {
// eslint-disable-next-line mocha/no-setup-in-describe
verifyProperties(objectProto, Object);
});
describe(".set", function () {
// eslint-disable-next-line mocha/no-setup-in-describe
verifyProperties(setProto, Set);
});
describe(".string", function () {
// eslint-disable-next-line mocha/no-setup-in-describe
verifyProperties(stringProto, String);
});
});
function verifyProperties(p, origin) {
var disallowedProperties = ["size", "caller", "callee", "arguments"];
if (throwsOnProto) {
disallowedProperties.push("__proto__");
}
it("should have all the methods of the origin prototype", function () {
var methodNames = Object.getOwnPropertyNames(origin.prototype).filter(
function (name) {
if (disallowedProperties.includes(name)) {
return false;
}
return typeof origin.prototype[name] === "function";
}
);
methodNames.forEach(function (name) {
assert.isTrue(Object.prototype.hasOwnProperty.call(p, name), name);
});
});
}

5
node_modules/sinon/node_modules/@sinonjs/commons/lib/prototypes/map.js generated vendored
View file

@ -1,5 +0,0 @@
"use strict";
var copyPrototype = require("./copy-prototype-methods");
module.exports = copyPrototype(Map.prototype);

5
node_modules/sinon/node_modules/@sinonjs/commons/lib/prototypes/object.js generated vendored
View file

@ -1,5 +0,0 @@
"use strict";
var copyPrototype = require("./copy-prototype-methods");
module.exports = copyPrototype(Object.prototype);

5
node_modules/sinon/node_modules/@sinonjs/commons/lib/prototypes/set.js generated vendored
View file

@ -1,5 +0,0 @@
"use strict";
var copyPrototype = require("./copy-prototype-methods");
module.exports = copyPrototype(Set.prototype);

5
node_modules/sinon/node_modules/@sinonjs/commons/lib/prototypes/string.js generated vendored
View file

@ -1,5 +0,0 @@
"use strict";
var copyPrototype = require("./copy-prototype-methods");
module.exports = copyPrototype(String.prototype);

26
node_modules/sinon/node_modules/@sinonjs/commons/lib/prototypes/throws-on-proto.js generated vendored
View file

@ -1,26 +0,0 @@
"use strict";
/**
* Is true when the environment causes an error to be thrown for accessing the
* __proto__ property.
*
* This is necessary in order to support `node --disable-proto=throw`.
*
* See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/proto
*
* @type {boolean}
*/
let throwsOnProto;
try {
const object = {};
// eslint-disable-next-line no-proto, no-unused-expressions
object.__proto__;
throwsOnProto = false;
} catch (_) {
// This branch is covered when tests are run with `--disable-proto=throw`,
// however we can test both branches at the same time, so this is ignored
/* istanbul ignore next */
throwsOnProto = true;
}
module.exports = throwsOnProto;

13
node_modules/sinon/node_modules/@sinonjs/commons/lib/type-of.js generated vendored
View file

@ -1,13 +0,0 @@
"use strict";
var type = require("type-detect");
/**
* Returns the lower-case result of running type from type-detect on the value
*
* @param {*} value
* @returns {string}
*/
module.exports = function typeOf(value) {
return type(value).toLowerCase();
};

51
node_modules/sinon/node_modules/@sinonjs/commons/lib/type-of.test.js generated vendored
View file

@ -1,51 +0,0 @@
"use strict";
var assert = require("@sinonjs/referee-sinon").assert;
var typeOf = require("./type-of");
describe("typeOf", function () {
it("returns boolean", function () {
assert.equals(typeOf(false), "boolean");
});
it("returns string", function () {
assert.equals(typeOf("Sinon.JS"), "string");
});
it("returns number", function () {
assert.equals(typeOf(123), "number");
});
it("returns object", function () {
assert.equals(typeOf({}), "object");
});
it("returns function", function () {
assert.equals(
typeOf(function () {
return undefined;
}),
"function"
);
});
it("returns undefined", function () {
assert.equals(typeOf(undefined), "undefined");
});
it("returns null", function () {
assert.equals(typeOf(null), "null");
});
it("returns array", function () {
assert.equals(typeOf([]), "array");
});
it("returns regexp", function () {
assert.equals(typeOf(/.*/), "regexp");
});
it("returns date", function () {
assert.equals(typeOf(new Date()), "date");
});
});

17
node_modules/sinon/node_modules/@sinonjs/commons/lib/value-to-string.js generated vendored
View file

@ -1,17 +0,0 @@
"use strict";
/**
* Returns a string representation of the value
*
* @param {*} value
* @returns {string}
*/
function valueToString(value) {
if (value && value.toString) {
// eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods
return value.toString();
}
return String(value);
}
module.exports = valueToString;

20
node_modules/sinon/node_modules/@sinonjs/commons/lib/value-to-string.test.js generated vendored
View file

@ -1,20 +0,0 @@
"use strict";
var assert = require("@sinonjs/referee-sinon").assert;
var valueToString = require("./value-to-string");
describe("util/core/valueToString", function () {
it("returns string representation of an object", function () {
var obj = {};
assert.equals(valueToString(obj), obj.toString());
});
it("returns 'null' for literal null'", function () {
assert.equals(valueToString(null), "null");
});
it("returns 'undefined' for literal undefined", function () {
assert.equals(valueToString(undefined), "undefined");
});
});

57
node_modules/sinon/node_modules/@sinonjs/commons/package.json generated vendored
View file

@ -1,57 +0,0 @@
{
"name": "@sinonjs/commons",
"version": "3.0.0",
"description": "Simple functions shared among the sinon end user libraries",
"main": "lib/index.js",
"types": "./types/index.d.ts",
"scripts": {
"build": "rm -rf types && tsc",
"lint": "eslint .",
"precommit": "lint-staged",
"test": "mocha --recursive -R dot \"lib/**/*.test.js\"",
"test-check-coverage": "npm run test-coverage && nyc check-coverage --branches 100 --functions 100 --lines 100",
"test-coverage": "nyc --reporter text --reporter html --reporter lcovonly npm run test",
"prepublishOnly": "npm run build",
"prettier:check": "prettier --check '**/*.{js,css,md}'",
"prettier:write": "prettier --write '**/*.{js,css,md}'",
"preversion": "npm run test-check-coverage",
"version": "changes --commits --footer",
"postversion": "git push --follow-tags && npm publish",
"prepare": "husky install"
},
"repository": {
"type": "git",
"url": "git+https://github.com/sinonjs/commons.git"
},
"files": [
"lib",
"types"
],
"author": "",
"license": "BSD-3-Clause",
"bugs": {
"url": "https://github.com/sinonjs/commons/issues"
},
"homepage": "https://github.com/sinonjs/commons#readme",
"lint-staged": {
"*.{js,css,md}": "prettier --check",
"*.js": "eslint"
},
"devDependencies": {
"@sinonjs/eslint-config": "^4.0.6",
"@sinonjs/eslint-plugin-no-prototype-methods": "^0.1.0",
"@sinonjs/referee-sinon": "^10.1.0",
"@studio/changes": "^2.2.0",
"husky": "^6.0.0",
"jsverify": "0.8.4",
"knuth-shuffle": "^1.0.8",
"lint-staged": "^13.0.3",
"mocha": "^10.1.0",
"nyc": "^15.1.0",
"prettier": "^2.7.1",
"typescript": "^4.8.4"
},
"dependencies": {
"type-detect": "4.0.8"
}
}

36
node_modules/sinon/node_modules/@sinonjs/commons/types/called-in-order.d.ts generated vendored
View file

@ -1,36 +0,0 @@
export = calledInOrder;
/**
* A Sinon proxy object (fake, spy, stub)
*
* @typedef {object} SinonProxy
* @property {Function} calledBefore - A method that determines if this proxy was called before another one
* @property {string} id - Some id
* @property {number} callCount - Number of times this proxy has been called
*/
/**
* Returns true when the spies have been called in the order they were supplied in
*
* @param {SinonProxy[] | SinonProxy} spies An array of proxies, or several proxies as arguments
* @returns {boolean} true when spies are called in order, false otherwise
*/
declare function calledInOrder(spies: SinonProxy[] | SinonProxy, ...args: any[]): boolean;
declare namespace calledInOrder {
export { SinonProxy };
}
/**
* A Sinon proxy object (fake, spy, stub)
*/
type SinonProxy = {
/**
* - A method that determines if this proxy was called before another one
*/
calledBefore: Function;
/**
* - Some id
*/
id: string;
/**
* - Number of times this proxy has been called
*/
callCount: number;
};

8
node_modules/sinon/node_modules/@sinonjs/commons/types/class-name.d.ts generated vendored
View file

@ -1,8 +0,0 @@
export = className;
/**
* Returns a display name for a value from a constructor
*
* @param {object} value A value to examine
* @returns {(string|null)} A string or null
*/
declare function className(value: object): (string | null);

3
node_modules/sinon/node_modules/@sinonjs/commons/types/deprecated.d.ts generated vendored
View file

@ -1,3 +0,0 @@
export function wrap(func: Function, msg: string): Function;
export function defaultMsg(packageName: string, funcName: string): string;
export function printWarning(msg: string): undefined;

2
node_modules/sinon/node_modules/@sinonjs/commons/types/every.d.ts generated vendored
View file

@ -1,2 +0,0 @@
declare function _exports(obj: object, fn: Function): boolean;
export = _exports;

2
node_modules/sinon/node_modules/@sinonjs/commons/types/function-name.d.ts generated vendored
View file

@ -1,2 +0,0 @@
declare function _exports(func: Function): string;
export = _exports;

7
node_modules/sinon/node_modules/@sinonjs/commons/types/global.d.ts generated vendored
View file

@ -1,7 +0,0 @@
export = globalObject;
/**
* A reference to the global object
*
* @type {object} globalObject
*/
declare var globalObject: object;

17
node_modules/sinon/node_modules/@sinonjs/commons/types/index.d.ts generated vendored
View file

@ -1,17 +0,0 @@
export const global: any;
export const calledInOrder: typeof import("./called-in-order");
export const className: typeof import("./class-name");
export const deprecated: typeof import("./deprecated");
export const every: (obj: any, fn: Function) => boolean;
export const functionName: (func: Function) => string;
export const orderByFirstCall: typeof import("./order-by-first-call");
export const prototypes: {
array: any;
function: any;
map: any;
object: any;
set: any;
string: any;
};
export const typeOf: (value: any) => string;
export const valueToString: typeof import("./value-to-string");

26
node_modules/sinon/node_modules/@sinonjs/commons/types/order-by-first-call.d.ts generated vendored
View file

@ -1,26 +0,0 @@
export = orderByFirstCall;
/**
* A Sinon proxy object (fake, spy, stub)
*
* @typedef {object} SinonProxy
* @property {Function} getCall - A method that can return the first call
*/
/**
* Sorts an array of SinonProxy instances (fake, spy, stub) by their first call
*
* @param {SinonProxy[] | SinonProxy} spies
* @returns {SinonProxy[]}
*/
declare function orderByFirstCall(spies: SinonProxy[] | SinonProxy): SinonProxy[];
declare namespace orderByFirstCall {
export { SinonProxy };
}
/**
* A Sinon proxy object (fake, spy, stub)
*/
type SinonProxy = {
/**
* - A method that can return the first call
*/
getCall: Function;
};

2
node_modules/sinon/node_modules/@sinonjs/commons/types/prototypes/array.d.ts generated vendored
View file

@ -1,2 +0,0 @@
declare const _exports: any;
export = _exports;

2
node_modules/sinon/node_modules/@sinonjs/commons/types/prototypes/copy-prototype-methods.d.ts generated vendored
View file

@ -1,2 +0,0 @@
declare function _exports(prototype: any): any;
export = _exports;

2
node_modules/sinon/node_modules/@sinonjs/commons/types/prototypes/function.d.ts generated vendored
View file

@ -1,2 +0,0 @@
declare const _exports: any;
export = _exports;

7
node_modules/sinon/node_modules/@sinonjs/commons/types/prototypes/index.d.ts generated vendored
View file

@ -1,7 +0,0 @@
export declare const array: any;
declare const _function: any;
export { _function as function };
export declare const map: any;
export declare const object: any;
export declare const set: any;
export declare const string: any;

2
node_modules/sinon/node_modules/@sinonjs/commons/types/prototypes/map.d.ts generated vendored
View file

@ -1,2 +0,0 @@
declare const _exports: any;
export = _exports;

2
node_modules/sinon/node_modules/@sinonjs/commons/types/prototypes/object.d.ts generated vendored
View file

@ -1,2 +0,0 @@
declare const _exports: any;
export = _exports;

2
node_modules/sinon/node_modules/@sinonjs/commons/types/prototypes/set.d.ts generated vendored
View file

@ -1,2 +0,0 @@
declare const _exports: any;
export = _exports;

2
node_modules/sinon/node_modules/@sinonjs/commons/types/prototypes/string.d.ts generated vendored
View file

@ -1,2 +0,0 @@
declare const _exports: any;
export = _exports;

12
node_modules/sinon/node_modules/@sinonjs/commons/types/prototypes/throws-on-proto.d.ts generated vendored
View file

@ -1,12 +0,0 @@
export = throwsOnProto;
/**
* Is true when the environment causes an error to be thrown for accessing the
* __proto__ property.
*
* This is necessary in order to support `node --disable-proto=throw`.
*
* See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/proto
*
* @type {boolean}
*/
declare let throwsOnProto: boolean;

2
node_modules/sinon/node_modules/@sinonjs/commons/types/type-of.d.ts generated vendored
View file

@ -1,2 +0,0 @@
declare function _exports(value: any): string;
export = _exports;

8
node_modules/sinon/node_modules/@sinonjs/commons/types/value-to-string.d.ts generated vendored
View file

@ -1,8 +0,0 @@
export = valueToString;
/**
* Returns a string representation of the value
*
* @param {*} value
* @returns {string}
*/
declare function valueToString(value: any): string;

11
node_modules/sinon/node_modules/@sinonjs/fake-timers/LICENSE generated vendored
View file

@ -1,11 +0,0 @@
Copyright (c) 2010-2014, Christian Johansen, christian@cjohansen.no. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

358
node_modules/sinon/node_modules/@sinonjs/fake-timers/README.md generated vendored
View file

@ -1,358 +0,0 @@
# `@sinonjs/fake-timers`
[![codecov](https://codecov.io/gh/sinonjs/fake-timers/branch/main/graph/badge.svg)](https://codecov.io/gh/sinonjs/fake-timers)
<a href="CODE_OF_CONDUCT.md"><img src="https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg" alt="Contributor Covenant" /></a>
JavaScript implementation of the timer APIs; `setTimeout`, `clearTimeout`, `setImmediate`, `clearImmediate`, `setInterval`, `clearInterval`, `requestAnimationFrame`, `cancelAnimationFrame`, `requestIdleCallback`, and `cancelIdleCallback`, along with a clock instance that controls the flow of time. FakeTimers also provides a `Date` implementation that gets its time from the clock.
In addition in browser environment `@sinonjs/fake-timers` provides a `performance` implementation that gets its time from the clock. In Node environments FakeTimers provides a `nextTick` implementation that is synchronized with the clock - and a `process.hrtime` shim that works with the clock.
`@sinonjs/fake-timers` can be used to simulate passing time in automated tests and other
situations where you want the scheduling semantics, but don't want to actually
wait.
`@sinonjs/fake-timers` is extracted from [Sinon.JS](https://github.com/sinonjs/sinon.js) and targets the [same runtimes](https://sinonjs.org/releases/latest/#supported-runtimes).
## Autocomplete, IntelliSense and TypeScript definitions
Version 7 introduced JSDoc to the codebase. This should provide autocomplete and type suggestions in supporting IDEs. If you need more elaborate type support, TypeScript definitions for the Sinon projects are independently maintained by the Definitely Types community:
```
npm install -D @types/sinonjs__fake-timers
```
## Installation
`@sinonjs/fake-timers` can be used in both Node and browser environments. Installation is as easy as
```sh
npm install @sinonjs/fake-timers
```
If you want to use `@sinonjs/fake-timers` in a browser you can either build your own bundle or use [Skypack](https://www.skypack.dev).
## Usage
To use `@sinonjs/fake-timers`, create a new clock, schedule events on it using the timer
functions and pass time using the `tick` method.
```js
// In the browser distribution, a global `FakeTimers` is already available
var FakeTimers = require("@sinonjs/fake-timers");
var clock = FakeTimers.createClock();
clock.setTimeout(function () {
console.log(
"The poblano is a mild chili pepper originating in the state of Puebla, Mexico."
);
}, 15);
// ...
clock.tick(15);
```
Upon executing the last line, an interesting fact about the
[Poblano](https://en.wikipedia.org/wiki/Poblano) will be printed synchronously to
the screen. If you want to simulate asynchronous behavior, please see the `async` function variants (eg `clock.tick(time)` vs `await clock.tickAsync(time)`).
The `next`, `runAll`, `runToFrame`, and `runToLast` methods are available to advance the clock. See the
API Reference for more details.
### Faking the native timers
When using `@sinonjs/fake-timers` to test timers, you will most likely want to replace the native
timers such that calling `setTimeout` actually schedules a callback with your
clock instance, not the browser's internals.
Calling `install` with no arguments achieves this. You can call `uninstall`
later to restore things as they were again.
```js
// In the browser distribution, a global `FakeTimers` is already available
var FakeTimers = require("@sinonjs/fake-timers");
var clock = FakeTimers.install();
// Equivalent to
// var clock = FakeTimers.install(typeof global !== "undefined" ? global : window);
setTimeout(fn, 15); // Schedules with clock.setTimeout
clock.uninstall();
// setTimeout is restored to the native implementation
```
To hijack timers in another context pass it to the `install` method.
```js
var FakeTimers = require("@sinonjs/fake-timers");
var context = {
setTimeout: setTimeout, // By default context.setTimeout uses the global setTimeout
};
var clock = FakeTimers.withGlobal(context).install();
context.setTimeout(fn, 15); // Schedules with clock.setTimeout
clock.uninstall();
// context.setTimeout is restored to the original implementation
```
Usually you want to install the timers onto the global object, so call `install`
without arguments.
#### Automatically incrementing mocked time
FakeTimers supports the possibility to attach the faked timers to any change
in the real system time. This means that there is no need to `tick()` the
clock in a situation where you won't know **when** to call `tick()`.
Please note that this is achieved using the original setImmediate() API at a certain
configurable interval `config.advanceTimeDelta` (default: 20ms). Meaning time would
be incremented every 20ms, not in real time.
An example would be:
```js
var FakeTimers = require("@sinonjs/fake-timers");
var clock = FakeTimers.install({
shouldAdvanceTime: true,
advanceTimeDelta: 40,
});
setTimeout(() => {
console.log("this just timed out"); //executed after 40ms
}, 30);
setImmediate(() => {
console.log("not so immediate"); //executed after 40ms
});
setTimeout(() => {
console.log("this timed out after"); //executed after 80ms
clock.uninstall();
}, 50);
```
## API Reference
### `var clock = FakeTimers.createClock([now[, loopLimit]])`
Creates a clock. The default
[epoch](https://en.wikipedia.org/wiki/Epoch_%28reference_date%29) is `0`.
The `now` argument may be a number (in milliseconds) or a Date object.
The `loopLimit` argument sets the maximum number of timers that will be run when calling `runAll()` before assuming that we have an infinite loop and throwing an error. The default is `1000`.
### `var clock = FakeTimers.install([config])`
Installs FakeTimers using the specified config (otherwise with epoch `0` on the global scope). The following configuration options are available
| Parameter | Type | Default | Description |
| -------------------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `config.now` | Number/Date | 0 | installs FakeTimers with the specified unix epoch |
| `config.toFake` | String[] | ["setTimeout", "clearTimeout", "setImmediate", "clearImmediate","setInterval", "clearInterval", "Date", "requestAnimationFrame", "cancelAnimationFrame", "requestIdleCallback", "cancelIdleCallback", "hrtime", "performance"] | an array with explicit function names (or objects, in the case of "performance") to hijack. _When not set, FakeTimers will automatically fake all methods **except** `nextTick`_ e.g., `FakeTimers.install({ toFake: ["setTimeout","nextTick"]})` will fake only `setTimeout` and `nextTick` |
| `config.loopLimit` | Number | 1000 | the maximum number of timers that will be run when calling runAll() |
| `config.shouldAdvanceTime` | Boolean | false | tells FakeTimers to increment mocked time automatically based on the real system time shift (e.g. the mocked time will be incremented by 20ms for every 20ms change in the real system time) |
| `config.advanceTimeDelta` | Number | 20 | relevant only when using with `shouldAdvanceTime: true`. increment mocked time by `advanceTimeDelta` ms every `advanceTimeDelta` ms change in the real system time. |
| `config.shouldClearNativeTimers` | Boolean | false | tells FakeTimers to clear 'native' (i.e. not fake) timers by delegating to their respective handlers. These are not cleared by default, leading to potentially unexpected behavior if timers existed prior to installing FakeTimers. |
### `var id = clock.setTimeout(callback, timeout)`
Schedules the callback to be fired once `timeout` milliseconds have ticked by.
In Node.js `setTimeout` returns a timer object. FakeTimers will do the same, however
its `ref()` and `unref()` methods have no effect.
In browsers a timer ID is returned.
### `clock.clearTimeout(id)`
Clears the timer given the ID or timer object, as long as it was created using
`setTimeout`.
### `var id = clock.setInterval(callback, timeout)`
Schedules the callback to be fired every time `timeout` milliseconds have ticked
by.
In Node.js `setInterval` returns a timer object. FakeTimers will do the same, however
its `ref()` and `unref()` methods have no effect.
In browsers a timer ID is returned.
### `clock.clearInterval(id)`
Clears the timer given the ID or timer object, as long as it was created using
`setInterval`.
### `var id = clock.setImmediate(callback)`
Schedules the callback to be fired once `0` milliseconds have ticked by. Note
that you'll still have to call `clock.tick()` for the callback to fire. If
called during a tick the callback won't fire until `1` millisecond has ticked
by.
In Node.js `setImmediate` returns a timer object. FakeTimers will do the same,
however its `ref()` and `unref()` methods have no effect.
In browsers a timer ID is returned.
### `clock.clearImmediate(id)`
Clears the timer given the ID or timer object, as long as it was created using
`setImmediate`.
### `clock.requestAnimationFrame(callback)`
Schedules the callback to be fired on the next animation frame, which runs every
16 ticks. Returns an `id` which can be used to cancel the callback. This is
available in both browser & node environments.
### `clock.cancelAnimationFrame(id)`
Cancels the callback scheduled by the provided id.
### `clock.requestIdleCallback(callback[, timeout])`
Queued the callback to be fired during idle periods to perform background and low priority work on the main event loop. Callbacks which have a timeout option will be fired no later than time in milliseconds. Returns an `id` which can be used to cancel the callback.
### `clock.cancelIdleCallback(id)`
Cancels the callback scheduled by the provided id.
### `clock.countTimers()`
Returns the number of waiting timers. This can be used to assert that a test
finishes without leaking any timers.
### `clock.hrtime(prevTime?)`
Only available in Node.js, mimicks process.hrtime().
### `clock.nextTick(callback)`
Only available in Node.js, mimics `process.nextTick` to enable completely synchronous testing flows.
### `clock.performance.now()`
Only available in browser environments, mimicks performance.now().
### `clock.tick(time)` / `await clock.tickAsync(time)`
Advance the clock, firing callbacks if necessary. `time` may be the number of
milliseconds to advance the clock by or a human-readable string. Valid string
formats are `"08"` for eight seconds, `"01:00"` for one minute and `"02:34:10"`
for two hours, 34 minutes and ten seconds.
The `tickAsync()` will also break the event loop, allowing any scheduled promise
callbacks to execute _before_ running the timers.
### `clock.next()` / `await clock.nextAsync()`
Advances the clock to the the moment of the first scheduled timer, firing it.
The `nextAsync()` will also break the event loop, allowing any scheduled promise
callbacks to execute _before_ running the timers.
### `clock.jump(time)`
Advance the clock by jumping forward in time, firing callbacks at most once.
`time` takes the same formats as [`clock.tick`](#clockticktime--await-clocktickasynctime).
This can be used to simulate the JS engine (such as a browser) being put to sleep and resumed later, skipping intermediary timers.
### `clock.reset()`
Removes all timers and ticks without firing them, and sets `now` to `config.now`
that was provided to `FakeTimers.install` or to `0` if `config.now` was not provided.
Useful to reset the state of the clock without having to `uninstall` and `install` it.
### `clock.runAll()` / `await clock.runAllAsync()`
This runs all pending timers until there are none remaining. If new timers are added while it is executing they will be run as well.
This makes it easier to run asynchronous tests to completion without worrying about the number of timers they use, or the delays in those timers.
It runs a maximum of `loopLimit` times after which it assumes there is an infinite loop of timers and throws an error.
The `runAllAsync()` will also break the event loop, allowing any scheduled promise
callbacks to execute _before_ running the timers.
### `clock.runMicrotasks()`
This runs all pending microtasks scheduled with `nextTick` but none of the timers and is mostly useful for libraries using FakeTimers underneath and for running `nextTick` items without any timers.
### `clock.runToFrame()`
Advances the clock to the next frame, firing all scheduled animation frame callbacks,
if any, for that frame as well as any other timers scheduled along the way.
### `clock.runToLast()` / `await clock.runToLastAsync()`
This takes note of the last scheduled timer when it is run, and advances the
clock to that time firing callbacks as necessary.
If new timers are added while it is executing they will be run only if they
would occur before this time.
This is useful when you want to run a test to completion, but the test recursively
sets timers that would cause `runAll` to trigger an infinite loop warning.
The `runToLastAsync()` will also break the event loop, allowing any scheduled promise
callbacks to execute _before_ running the timers.
### `clock.setSystemTime([now])`
This simulates a user changing the system clock while your program is running.
It affects the current time but it does not in itself cause e.g. timers to fire;
they will fire exactly as they would have done without the call to
setSystemTime().
### `clock.uninstall()`
Restores the original methods of the native timers or the methods on the object
that was passed to `FakeTimers.withGlobal`
### `Date`
Implements the `Date` object but using the clock to provide the correct time.
### `Performance`
Implements the `now` method of the [`Performance`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) object but using the clock to provide the correct time. Only available in environments that support the Performance object (browsers mostly).
### `FakeTimers.withGlobal`
In order to support creating clocks based on separate or sandboxed environments (such as JSDOM), FakeTimers exports a factory method which takes single argument `global`, which it inspects to figure out what to mock and what features to support. When invoking this function with a global, you will get back an object with `timers`, `createClock` and `install` - same as the regular FakeTimers exports only based on the passed in global instead of the global environment.
## Running tests
FakeTimers has a comprehensive test suite. If you're thinking of contributing bug
fixes or suggesting new features, you need to make sure you have not broken any
tests. You are also expected to add tests for any new behavior.
### On node:
```sh
npm test
```
Or, if you prefer more verbose output:
```
$(npm bin)/mocha ./test/fake-timers-test.js
```
### In the browser
[Mochify](https://github.com/mantoni/mochify.js) is used to run the tests in
PhantomJS. Make sure you have `phantomjs` installed. Then:
```sh
npm test-headless
```
## License
BSD 3-clause "New" or "Revised" License (see LICENSE file)

65
node_modules/sinon/node_modules/@sinonjs/fake-timers/package.json generated vendored
View file

@ -1,65 +0,0 @@
{
"name": "@sinonjs/fake-timers",
"description": "Fake JavaScript timers",
"version": "10.3.0",
"homepage": "https://github.com/sinonjs/fake-timers",
"author": "Christian Johansen",
"repository": {
"type": "git",
"url": "https://github.com/sinonjs/fake-timers.git"
},
"bugs": {
"mail": "christian@cjohansen.no",
"url": "https://github.com/sinonjs/fake-timers/issues"
},
"license": "BSD-3-Clause",
"scripts": {
"lint": "eslint .",
"test-node": "mocha --timeout 200 test/ integration-test/ -R dot --check-leaks",
"test-headless": "mochify --no-detect-globals --timeout=10000",
"test-check-coverage": "npm run test-coverage && nyc check-coverage",
"test-cloud": "mochify --wd --no-detect-globals --timeout=10000",
"test-coverage": "nyc --all --reporter text --reporter html --reporter lcovonly npm run test-node",
"test": "npm run test-node && npm run test-headless",
"prettier:check": "prettier --check '**/*.{js,css,md}'",
"prettier:write": "prettier --write '**/*.{js,css,md}'",
"preversion": "./scripts/preversion.sh",
"version": "./scripts/version.sh",
"postversion": "./scripts/postversion.sh",
"prepare": "husky install"
},
"lint-staged": {
"*.{js,css,md}": "prettier --check",
"*.js": "eslint"
},
"files": [
"src/"
],
"devDependencies": {
"@sinonjs/eslint-config": "^4.1.0",
"@sinonjs/referee-sinon": "11.0.0",
"husky": "^8.0.3",
"jsdom": "22.0.0",
"lint-staged": "13.2.2",
"mocha": "10.2.0",
"mochify": "9.2.0",
"nyc": "15.1.0",
"prettier": "2.8.8"
},
"main": "./src/fake-timers-src.js",
"dependencies": {
"@sinonjs/commons": "^3.0.0"
},
"nyc": {
"branches": 85,
"lines": 92,
"functions": 92,
"statements": 92,
"exclude": [
"**/*-test.js",
"coverage/**",
"types/**",
"fake-timers.js"
]
}
}

1787
node_modules/sinon/node_modules/@sinonjs/fake-timers/src/fake-timers-src.js generated vendored
View file

File diff suppressed because it is too large Load diff

41
node_modules/sinon/package.json generated vendored
View file

@ -15,7 +15,7 @@
"xhr",
"assert"
],
"version": "16.1.0",
"version": "17.0.0",
"homepage": "https://sinonjs.org/",
"author": "Christian Johansen",
"repository": {
@ -33,7 +33,7 @@
"scripts": {
"test-node": "mocha --recursive -R dot \"test/**/*-test.js\"",
"test-dev": "npm run test-node -- --watch -R min",
"test-headless": "mochify --no-detect-globals --recursive -R dot --grep WebWorker --invert --plugin [ proxyquire-universal ] \"test/**/*-test.js\"",
"test-headless": "mochify --no-detect-globals --recursive -R dot --grep WebWorker --invert \"test/**/*-test.js\"",
"test-coverage": "nyc npm run test-headless -- --transform [ babelify --ignore [ test ] --plugins [ babel-plugin-istanbul ] ]",
"test-cloud": "npm run test-headless -- --wd",
"test-webworker": "mochify --no-detect-globals --https-server 8080 --no-request-interception test/webworker/webworker-support-assessment.js",
@ -44,10 +44,10 @@
"test": "npm run test-node && npm run test-headless && npm run test-webworker",
"check-dependencies": "dependency-check package.json --no-dev --ignore-module esm",
"build": "node ./build.cjs",
"dev-docs": "cd docs; cp -rl release-source releases/dev; npm run serve-docs",
"dev-docs": "cd docs; rsync -r --delete release-source/ releases/dev; npm run serve-docs",
"build-docs": "cd docs; bundle exec jekyll build",
"serve-docs": "cd docs; bundle exec jekyll serve --incremental --verbose --livereload",
"lint": "eslint --max-warnings 101 '**/*.{js,cjs,mjs}'",
"lint": "eslint --max-warnings 0 '**/*.{js,cjs,mjs}'",
"unimported": "unimported .",
"pretest-webworker": "npm run build",
"prebuild": "rimraf pkg && npm run check-dependencies",
@ -69,43 +69,39 @@
]
},
"lint-staged": {
"*.{js,css,md}": "prettier --check",
"**/*.{js,css,md}": "prettier --write",
"*.js": "eslint --quiet",
"*.mjs": "eslint --quiet --ext mjs --parser-options=sourceType:module"
},
"dependencies": {
"@sinonjs/commons": "^3.0.0",
"@sinonjs/fake-timers": "^10.3.0",
"@sinonjs/fake-timers": "^11.2.2",
"@sinonjs/samsam": "^8.0.0",
"diff": "^5.1.0",
"nise": "^5.1.4",
"nise": "^5.1.5",
"supports-color": "^7.2.0"
},
"devDependencies": {
"@babel/core": "^7.21.0",
"@sinonjs/eslint-config": "^4.0.6",
"@babel/core": "^7.23.2",
"@sinonjs/eslint-config": "^4.1.0",
"@sinonjs/eslint-plugin-no-prototype-methods": "^0.1.1",
"@sinonjs/referee": "^10.0.0",
"@sinonjs/referee": "^10.0.1",
"@studio/changes": "^2.2.0",
"babel-plugin-istanbul": "^6.1.1",
"babelify": "^10.0.0",
"browserify": "^16.5.2",
"debug": "^4.3.4",
"dependency-check": "^4.1.0",
"husky": "^6.0.0",
"lint-staged": "^13.2.0",
"lint-staged": "^15.0.2",
"mocha": "^10.2.0",
"mochify": "^9.2.0",
"nyc": "^15.1.0",
"prettier": "^2.8.4",
"proxyquire": "^2.1.3",
"proxyquire-universal": "^3.0.1",
"proxyquireify": "^3.2.1",
"puppeteer": "^19.7.4",
"rimraf": "^4.4.0",
"semver": "^7.3.8",
"prettier": "^3.0.3",
"puppeteer": "^21.4.0",
"rimraf": "^5.0.5",
"semver": "^7.5.4",
"shelljs": "^0.8.5",
"unimported": "^1.26.0"
"unimported": "^1.30.0"
},
"files": [
"lib",
@ -137,10 +133,5 @@
"cache": true
},
"mode": "auto"
},
"husky": {
"hooks": {
"pre-commit": "lint-staged"
}
}
}

2737
node_modules/sinon/pkg/sinon-esm.js generated vendored
View file

File diff suppressed because it is too large Load diff

2733
node_modules/sinon/pkg/sinon-no-sourcemaps.cjs generated vendored
View file

File diff suppressed because it is too large Load diff

2735
node_modules/sinon/pkg/sinon.js generated vendored
View file

File diff suppressed because one or more lines are too long