bmad-agent-init
Version:
Windsurf integration for BMAD-METHOD - automatic initialization of bmad-agent in projects
1,950 lines • 77.7 kB
JavaScript
/**
* @license React
* eslint-plugin-react-hooks.production.js
*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
"use strict";
function _unsupportedIterableToArray(o, minLen) {
if (o) {
if ("string" === typeof o) return _arrayLikeToArray(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
"Object" === n && o.constructor && (n = o.constructor.name);
if ("Map" === n || "Set" === n) return Array.from(o);
if ("Arguments" === n || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
return _arrayLikeToArray(o, minLen);
}
}
function _arrayLikeToArray(arr, len) {
if (null == len || len > arr.length) len = arr.length;
for (var i = 0, arr2 = Array(len); i < len; i++) arr2[i] = arr[i];
return arr2;
}
function _createForOfIteratorHelper(o, allowArrayLike) {
var it;
if ("undefined" === typeof Symbol || null == o[Symbol.iterator]) {
if (
Array.isArray(o) ||
(it = _unsupportedIterableToArray(o)) ||
(allowArrayLike && o && "number" === typeof o.length)
) {
it && (o = it);
var i = 0;
allowArrayLike = function () {};
return {
s: allowArrayLike,
n: function () {
return i >= o.length ? { done: !0 } : { done: !1, value: o[i++] };
},
e: function (e) {
throw e;
},
f: allowArrayLike
};
}
throw new TypeError(
"Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."
);
}
var normalCompletion = !0,
didErr = !1,
err;
return {
s: function () {
it = o[Symbol.iterator]();
},
n: function () {
var step = it.next();
normalCompletion = step.done;
return step;
},
e: function (e) {
didErr = !0;
err = e;
},
f: function () {
try {
normalCompletion || null == it.return || it.return();
} finally {
if (didErr) throw err;
}
}
};
}
function isHook(node) {
if ("Identifier" === node.type)
return (node = node.name), "use" === node || /^use[A-Z0-9]/.test(node);
if (
"MemberExpression" === node.type &&
!node.computed &&
isHook(node.property)
) {
node = node.object;
var isPascalCaseNameSpace = /^[A-Z].*/;
return "Identifier" === node.type && isPascalCaseNameSpace.test(node.name);
}
return !1;
}
function isComponentName(node) {
return "Identifier" === node.type && /^[A-Z]/.test(node.name);
}
function isReactFunction(node, functionName) {
return (
node.name === functionName ||
("MemberExpression" === node.type &&
"React" === node.object.name &&
node.property.name === functionName)
);
}
function isForwardRefCallback(node) {
return !!(
node.parent &&
node.parent.callee &&
isReactFunction(node.parent.callee, "forwardRef")
);
}
function isMemoCallback(node) {
return !!(
node.parent &&
node.parent.callee &&
isReactFunction(node.parent.callee, "memo")
);
}
function isInsideComponentOrHook(node) {
for (; node; ) {
var functionName = getFunctionName(node);
if (
(functionName &&
(isComponentName(functionName) || isHook(functionName))) ||
isForwardRefCallback(node) ||
isMemoCallback(node)
)
return !0;
node = node.parent;
}
return !1;
}
function getFunctionName(node) {
if (
"FunctionDeclaration" === node.type ||
("FunctionExpression" === node.type && node.id)
)
return node.id;
if (
"FunctionExpression" === node.type ||
"ArrowFunctionExpression" === node.type
)
return "VariableDeclarator" === node.parent.type &&
node.parent.init === node
? node.parent.id
: "AssignmentExpression" === node.parent.type &&
node.parent.right === node &&
"=" === node.parent.operator
? node.parent.left
: "Property" !== node.parent.type ||
node.parent.value !== node ||
node.parent.computed
? "AssignmentPattern" !== node.parent.type ||
node.parent.right !== node ||
node.parent.computed
? void 0
: node.parent.left
: node.parent.key;
}
function collectRecommendations(_ref6) {
function createDepTree() {
return {
isUsed: !1,
isSatisfiedRecursively: !1,
isSubtreeUsed: !1,
children: new Map()
};
}
function getOrCreateNodeByPath(rootNode, path) {
path = path.split(".");
path = _createForOfIteratorHelper(path);
var _step4;
try {
for (path.s(); !(_step4 = path.n()).done; ) {
var key = _step4.value,
child = rootNode.children.get(key);
child || ((child = createDepTree()), rootNode.children.set(key, child));
rootNode = child;
}
} catch (err) {
path.e(err);
} finally {
path.f();
}
return rootNode;
}
function markAllParentsByPath(rootNode, path, fn) {
path = path.split(".");
path = _createForOfIteratorHelper(path);
var _step5;
try {
for (path.s(); !(_step5 = path.n()).done; ) {
var child = rootNode.children.get(_step5.value);
if (!child) break;
fn(child);
rootNode = child;
}
} catch (err) {
path.e(err);
} finally {
path.f();
}
}
function scanTreeRecursively(node, missingPaths, satisfyingPaths, keyToPath) {
node.children.forEach(function (child, key) {
var path = keyToPath(key);
child.isSatisfiedRecursively
? child.isSubtreeUsed && satisfyingPaths.add(path)
: child.isUsed
? missingPaths.add(path)
: scanTreeRecursively(
child,
missingPaths,
satisfyingPaths,
function (childKey) {
return path + "." + childKey;
}
);
});
}
var dependencies = _ref6.dependencies,
declaredDependencies = _ref6.declaredDependencies,
stableDependencies = _ref6.stableDependencies,
externalDependencies = _ref6.externalDependencies,
isEffect = _ref6.isEffect,
depTree = createDepTree();
dependencies.forEach(function (_, key) {
getOrCreateNodeByPath(depTree, key).isUsed = !0;
markAllParentsByPath(depTree, key, function (parent) {
parent.isSubtreeUsed = !0;
});
});
declaredDependencies.forEach(function (_ref7) {
getOrCreateNodeByPath(depTree, _ref7.key).isSatisfiedRecursively = !0;
});
stableDependencies.forEach(function (key) {
getOrCreateNodeByPath(depTree, key).isSatisfiedRecursively = !0;
});
_ref6 = new Set();
var satisfyingDependencies = new Set();
scanTreeRecursively(depTree, _ref6, satisfyingDependencies, function (key) {
return key;
});
var suggestedDependencies = [],
unnecessaryDependencies = new Set(),
duplicateDependencies = new Set();
declaredDependencies.forEach(function (_ref8) {
_ref8 = _ref8.key;
satisfyingDependencies.has(_ref8)
? -1 === suggestedDependencies.indexOf(_ref8)
? suggestedDependencies.push(_ref8)
: duplicateDependencies.add(_ref8)
: !isEffect ||
_ref8.endsWith(".current") ||
externalDependencies.has(_ref8)
? unnecessaryDependencies.add(_ref8)
: -1 === suggestedDependencies.indexOf(_ref8) &&
suggestedDependencies.push(_ref8);
});
_ref6.forEach(function (key) {
suggestedDependencies.push(key);
});
return {
suggestedDependencies: suggestedDependencies,
unnecessaryDependencies: unnecessaryDependencies,
duplicateDependencies: duplicateDependencies,
missingDependencies: _ref6
};
}
function getConstructionExpressionType(node) {
switch (node.type) {
case "ObjectExpression":
return "object";
case "ArrayExpression":
return "array";
case "ArrowFunctionExpression":
case "FunctionExpression":
return "function";
case "ClassExpression":
return "class";
case "ConditionalExpression":
if (
null != getConstructionExpressionType(node.consequent) ||
null != getConstructionExpressionType(node.alternate)
)
return "conditional";
break;
case "LogicalExpression":
if (
null != getConstructionExpressionType(node.left) ||
null != getConstructionExpressionType(node.right)
)
return "logical expression";
break;
case "JSXFragment":
return "JSX fragment";
case "JSXElement":
return "JSX element";
case "AssignmentExpression":
if (null != getConstructionExpressionType(node.right))
return "assignment expression";
break;
case "NewExpression":
return "object construction";
case "Literal":
if (node.value instanceof RegExp) return "regular expression";
break;
case "TypeCastExpression":
case "AsExpression":
case "TSAsExpression":
return getConstructionExpressionType(node.expression);
}
return null;
}
function scanForConstructions(_ref9) {
var declaredDependenciesNode = _ref9.declaredDependenciesNode,
componentScope = _ref9.componentScope,
scope = _ref9.scope;
return _ref9.declaredDependencies
.map(function (_ref10) {
var key = _ref10.key;
_ref10 = componentScope.variables.find(function (v) {
return v.name === key;
});
if (null == _ref10) return null;
var node = _ref10.defs[0];
if (null == node) return null;
if (
"Variable" === node.type &&
"VariableDeclarator" === node.node.type &&
"Identifier" === node.node.id.type &&
null != node.node.init
) {
var constantExpressionType = getConstructionExpressionType(
node.node.init
);
if (null != constantExpressionType)
return [_ref10, constantExpressionType];
}
return "FunctionName" === node.type &&
"FunctionDeclaration" === node.node.type
? [_ref10, "function"]
: "ClassName" === node.type && "ClassDeclaration" === node.node.type
? [_ref10, "class"]
: null;
})
.filter(Boolean)
.map(function (_ref11) {
var ref = _ref11[0];
_ref11 = _ref11[1];
var JSCompiler_temp_const = ref.defs[0];
a: {
for (var foundWriteExpr = !1, i = 0; i < ref.references.length; i++) {
var reference = ref.references[i];
if (reference.writeExpr)
if (foundWriteExpr) {
ref = !0;
break a;
} else {
foundWriteExpr = !0;
continue;
}
for (
var currentScope = reference.from;
currentScope !== scope && null != currentScope;
)
currentScope = currentScope.upper;
if (
currentScope !== scope &&
!isAncestorNodeOf(declaredDependenciesNode, reference.identifier)
) {
ref = !0;
break a;
}
}
ref = !1;
}
return {
construction: JSCompiler_temp_const,
depType: _ref11,
isUsedOutsideOfHook: ref
};
});
}
function getDependency(node) {
return ("MemberExpression" !== node.parent.type &&
"OptionalMemberExpression" !== node.parent.type) ||
node.parent.object !== node ||
"current" === node.parent.property.name ||
node.parent.computed ||
(null != node.parent.parent &&
("CallExpression" === node.parent.parent.type ||
"OptionalCallExpression" === node.parent.parent.type) &&
node.parent.parent.callee === node.parent)
? "MemberExpression" === node.type &&
node.parent &&
"AssignmentExpression" === node.parent.type &&
node.parent.left === node
? node.object
: node
: getDependency(node.parent);
}
function markNode(node, optionalChains, result) {
optionalChains &&
(node.optional
? optionalChains.has(result) || optionalChains.set(result, !0)
: optionalChains.set(result, !1));
}
function analyzePropertyChain(node, optionalChains) {
if ("Identifier" === node.type || "JSXIdentifier" === node.type)
return (
(node = node.name), optionalChains && optionalChains.set(node, !1), node
);
if ("MemberExpression" !== node.type || node.computed) {
if ("OptionalMemberExpression" !== node.type || node.computed) {
if ("ChainExpression" !== node.type || node.computed)
throw Error("Unsupported node type: " + node.type);
node = node.expression;
if ("CallExpression" === node.type)
throw Error("Unsupported node type: " + node.type);
var object$20 = analyzePropertyChain(node.object, optionalChains),
property$21 = analyzePropertyChain(node.property, null);
object$20 = object$20 + "." + property$21;
markNode(node, optionalChains, object$20);
return object$20;
}
object$20 = analyzePropertyChain(node.object, optionalChains);
property$21 = analyzePropertyChain(node.property, null);
object$20 = object$20 + "." + property$21;
markNode(node, optionalChains, object$20);
return object$20;
}
object$20 = analyzePropertyChain(node.object, optionalChains);
property$21 = analyzePropertyChain(node.property, null);
object$20 = object$20 + "." + property$21;
markNode(node, optionalChains, object$20);
return object$20;
}
function getNodeWithoutReactNamespace(node) {
return "MemberExpression" !== node.type ||
"Identifier" !== node.object.type ||
"React" !== node.object.name ||
"Identifier" !== node.property.type ||
node.computed
? node
: node.property;
}
function getReactiveHookCallbackIndex(calleeNode, options) {
var node = getNodeWithoutReactNamespace(calleeNode);
if ("Identifier" !== node.type) return -1;
switch (node.name) {
case "useEffect":
case "useLayoutEffect":
case "useCallback":
case "useMemo":
return 0;
case "useImperativeHandle":
return 1;
default:
if (node === calleeNode && options && options.additionalHooks) {
try {
var name = analyzePropertyChain(node, null);
} catch (error) {
if (/Unsupported node type/.test(error.message)) return 0;
throw error;
}
return options.additionalHooks.test(name) ? 0 : -1;
}
return -1;
}
}
function fastFindReferenceWithParent(start, target) {
for (var queue = [start], item = null; queue.length; ) {
item = queue.shift();
if (
("Identifier" === item.type || "JSXIdentifier" === item.type) &&
item.type === target.type &&
item.name === target.name &&
item.range[0] === target.range[0] &&
item.range[1] === target.range[1]
)
return item;
if (isAncestorNodeOf(item, target)) {
start = 0;
for (
var _Object$entries = Object.entries(item);
start < _Object$entries.length;
start++
) {
var _Object$entries$_i = _Object$entries[start],
value = _Object$entries$_i[1];
"parent" !== _Object$entries$_i[0] &&
(isNodeLike(value)
? ((value.parent = item), queue.push(value))
: Array.isArray(value) &&
value.forEach(function (val) {
isNodeLike(val) && ((val.parent = item), queue.push(val));
}));
}
}
}
return null;
}
function joinEnglish(arr) {
for (var s = "", i = 0; i < arr.length; i++)
(s += arr[i]),
0 === i && 2 === arr.length
? (s += " and ")
: i === arr.length - 2 && 2 < arr.length
? (s += ", and ")
: i < arr.length - 1 && (s += ", ");
return s;
}
function isNodeLike(val) {
return (
"object" === typeof val &&
null !== val &&
!Array.isArray(val) &&
"string" === typeof val.type
);
}
function isAncestorNodeOf(a, b) {
return a.range[0] <= b.range[0] && a.range[1] >= b.range[1];
}
exports.configs = {
recommended: {
plugins: ["react-hooks"],
rules: {
"react-hooks/rules-of-hooks": "error",
"react-hooks/exhaustive-deps": "warn"
}
}
};
exports.rules = {
"rules-of-hooks": {
meta: {
type: "problem",
docs: {
description: "enforces the Rules of Hooks",
recommended: !0,
url: "https://reactjs.org/docs/hooks-rules.html"
}
},
create: function (context) {
function recordAllUseEffectEventFunctions(scope) {
scope = _createForOfIteratorHelper(scope.references);
try {
for (scope.s(); !scope.n().done; );
} catch (err$1) {
scope.e(err$1);
} finally {
scope.f();
}
}
var lastEffect = null,
codePathReactHooksMapStack = [],
codePathSegmentStack = [],
useEffectEventFunctions = new WeakSet(),
getSource =
"function" === typeof context.getSource
? function (node) {
return context.getSource(node);
}
: function (node) {
return context.sourceCode.getText(node);
},
getScope =
"function" === typeof context.getScope
? function () {
return context.getScope();
}
: function (node) {
return context.sourceCode.getScope(node);
},
$jscomp$compprop0 = {};
return (
($jscomp$compprop0.onCodePathSegmentStart = function (segment) {
return codePathSegmentStack.push(segment);
}),
($jscomp$compprop0.onCodePathSegmentEnd = function () {
return codePathSegmentStack.pop();
}),
($jscomp$compprop0.onCodePathStart = function () {
return codePathReactHooksMapStack.push(new Map());
}),
($jscomp$compprop0.onCodePathEnd = function (codePath, codePathNode) {
function countPathsFromStart(segment, pathHistory) {
var cache = countPathsFromStart.cache,
paths = cache.get(segment.id);
pathHistory = new Set(pathHistory);
if (pathHistory.has(segment.id)) {
cache = [].concat(pathHistory);
segment = cache.slice(cache.indexOf(segment.id) + 1);
segment = _createForOfIteratorHelper(segment);
var _step3;
try {
for (segment.s(); !(_step3 = segment.n()).done; )
cyclic.add(_step3.value);
} catch (err) {
segment.e(err);
} finally {
segment.f();
}
return BigInt("0");
}
pathHistory.add(segment.id);
if (void 0 !== paths) return paths;
if (codePath.thrownSegments.includes(segment)) paths = BigInt("0");
else if (0 === segment.prevSegments.length) paths = BigInt("1");
else {
paths = BigInt("0");
_step3 = _createForOfIteratorHelper(segment.prevSegments);
var _step4;
try {
for (_step3.s(); !(_step4 = _step3.n()).done; )
paths += countPathsFromStart(_step4.value, pathHistory);
} catch (err$2) {
_step3.e(err$2);
} finally {
_step3.f();
}
}
segment.reachable && paths === BigInt("0")
? cache.delete(segment.id)
: cache.set(segment.id, paths);
return paths;
}
function countPathsToEnd(segment, pathHistory) {
var cache = countPathsToEnd.cache,
paths = cache.get(segment.id);
pathHistory = new Set(pathHistory);
if (pathHistory.has(segment.id)) {
cache = Array.from(pathHistory);
segment = cache.slice(cache.indexOf(segment.id) + 1);
segment = _createForOfIteratorHelper(segment);
var _step5;
try {
for (segment.s(); !(_step5 = segment.n()).done; )
cyclic.add(_step5.value);
} catch (err) {
segment.e(err);
} finally {
segment.f();
}
return BigInt("0");
}
pathHistory.add(segment.id);
if (void 0 !== paths) return paths;
if (codePath.thrownSegments.includes(segment)) paths = BigInt("0");
else if (0 === segment.nextSegments.length) paths = BigInt("1");
else {
paths = BigInt("0");
_step5 = _createForOfIteratorHelper(segment.nextSegments);
var _step6;
try {
for (_step5.s(); !(_step6 = _step5.n()).done; )
paths += countPathsToEnd(_step6.value, pathHistory);
} catch (err$3) {
_step5.e(err$3);
} finally {
_step5.f();
}
}
cache.set(segment.id, paths);
return paths;
}
function shortestPathLengthToStart(segment) {
var cache = shortestPathLengthToStart.cache,
length = cache.get(segment.id);
if (null === length) return Infinity;
if (void 0 !== length) return length;
cache.set(segment.id, null);
if (0 === segment.prevSegments.length) length = 1;
else {
length = Infinity;
var _iterator7 = _createForOfIteratorHelper(segment.prevSegments),
_step7;
try {
for (_iterator7.s(); !(_step7 = _iterator7.n()).done; ) {
var prevLength = shortestPathLengthToStart(_step7.value);
prevLength < length && (length = prevLength);
}
} catch (err) {
_iterator7.e(err);
} finally {
_iterator7.f();
}
length += 1;
}
cache.set(segment.id, length);
return length;
}
var reactHooksMap = codePathReactHooksMapStack.pop();
if (0 !== reactHooksMap.size) {
var cyclic = new Set();
countPathsFromStart.cache = new Map();
countPathsToEnd.cache = new Map();
shortestPathLengthToStart.cache = new Map();
var allPathsFromStartToEnd = countPathsToEnd(
codePath.initialSegment
),
codePathFunctionName = getFunctionName(codePathNode),
isSomewhereInsideComponentOrHook =
isInsideComponentOrHook(codePathNode),
isDirectlyInsideComponentOrHook = codePathFunctionName
? isComponentName(codePathFunctionName) ||
isHook(codePathFunctionName)
: isForwardRefCallback(codePathNode) ||
isMemoCallback(codePathNode),
shortestFinalPathLength = Infinity,
_iterator8 = _createForOfIteratorHelper(codePath.finalSegments),
_step8;
try {
for (_iterator8.s(); !(_step8 = _iterator8.n()).done; ) {
var finalSegment = _step8.value;
if (finalSegment.reachable) {
var length$jscomp$0 = shortestPathLengthToStart(finalSegment);
length$jscomp$0 < shortestFinalPathLength &&
(shortestFinalPathLength = length$jscomp$0);
}
}
} catch (err) {
_iterator8.e(err);
} finally {
_iterator8.f();
}
reactHooksMap = _createForOfIteratorHelper(reactHooksMap);
var _step9;
try {
for (reactHooksMap.s(); !(_step9 = reactHooksMap.n()).done; ) {
var _step9$value = _step9.value,
segment$jscomp$0 = _step9$value[0],
reactHooks = _step9$value[1];
if (segment$jscomp$0.reachable) {
var possiblyHasEarlyReturn =
0 === segment$jscomp$0.nextSegments.length
? shortestFinalPathLength <=
shortestPathLengthToStart(segment$jscomp$0)
: shortestFinalPathLength <
shortestPathLengthToStart(segment$jscomp$0),
pathsFromStartToEnd =
countPathsFromStart(segment$jscomp$0) *
countPathsToEnd(segment$jscomp$0),
cycled = cyclic.has(segment$jscomp$0.id),
_iterator10 = _createForOfIteratorHelper(reactHooks),
_step10;
try {
for (_iterator10.s(); !(_step10 = _iterator10.n()).done; ) {
var hook = _step10.value;
cycled &&
!isReactFunction(hook, "use") &&
context.report({
node: hook,
message:
'React Hook "' +
getSource(hook) +
'" may be executed more than once. Possibly because it is called in a loop. React Hooks must be called in the exact same order in every component render.'
});
if (isDirectlyInsideComponentOrHook) {
if (
(codePathNode.async &&
context.report({
node: hook,
message:
'React Hook "' +
getSource(hook) +
'" cannot be called in an async function.'
}),
!cycled &&
pathsFromStartToEnd !== allPathsFromStartToEnd &&
!isReactFunction(hook, "use"))
) {
var message =
'React Hook "' +
getSource(hook) +
'" is called conditionally. React Hooks must be called in the exact same order in every component render.' +
(possiblyHasEarlyReturn
? " Did you accidentally call a React Hook after an early return?"
: "");
context.report({ node: hook, message: message });
}
} else if (
codePathNode.parent &&
("MethodDefinition" === codePathNode.parent.type ||
"ClassProperty" === codePathNode.parent.type) &&
codePathNode.parent.value === codePathNode
) {
var message$4 =
'React Hook "' +
getSource(hook) +
'" cannot be called in a class component. React Hooks must be called in a React function component or a custom React Hook function.';
context.report({ node: hook, message: message$4 });
} else if (codePathFunctionName) {
var message$5 =
'React Hook "' +
getSource(hook) +
'" is called in function "' +
(getSource(codePathFunctionName) +
'" that is neither a React function component nor a custom React Hook function. React component names must start with an uppercase letter. React Hook names must start with the word "use".');
context.report({ node: hook, message: message$5 });
} else if ("Program" === codePathNode.type) {
var message$6 =
'React Hook "' +
getSource(hook) +
'" cannot be called at the top level. React Hooks must be called in a React function component or a custom React Hook function.';
context.report({ node: hook, message: message$6 });
} else if (
isSomewhereInsideComponentOrHook &&
!isReactFunction(hook, "use")
) {
var message$7 =
'React Hook "' +
getSource(hook) +
'" cannot be called inside a callback. React Hooks must be called in a React function component or a custom React Hook function.';
context.report({ node: hook, message: message$7 });
}
}
} catch (err$8) {
_iterator10.e(err$8);
} finally {
_iterator10.f();
}
}
}
} catch (err$9) {
reactHooksMap.e(err$9);
} finally {
reactHooksMap.f();
}
}
}),
($jscomp$compprop0.CallExpression = function (node) {
if (isHook(node.callee)) {
var reactHooksMap =
codePathReactHooksMapStack[
codePathReactHooksMapStack.length - 1
],
codePathSegment =
codePathSegmentStack[codePathSegmentStack.length - 1],
reactHooks = reactHooksMap.get(codePathSegment);
reactHooks ||
((reactHooks = []),
reactHooksMap.set(codePathSegment, reactHooks));
reactHooks.push(node.callee);
}
"Identifier" === node.callee.type &&
"useEffect" === node.callee.name &&
0 < node.arguments.length &&
(lastEffect = node);
}),
($jscomp$compprop0.Identifier = function (node) {
null == lastEffect &&
useEffectEventFunctions.has(node) &&
"CallExpression" !== node.parent.type &&
context.report({
node: node,
message:
"`" +
getSource(node) +
'` is a function created with React Hook "useEffectEvent", and can only be called from the same component. They cannot be assigned to variables or passed down.'
});
}),
($jscomp$compprop0["CallExpression:exit"] = function (node) {
node === lastEffect && (lastEffect = null);
}),
($jscomp$compprop0.FunctionDeclaration = function (node) {
isInsideComponentOrHook(node) &&
recordAllUseEffectEventFunctions(getScope(node));
}),
($jscomp$compprop0.ArrowFunctionExpression = function (node) {
isInsideComponentOrHook(node) &&
recordAllUseEffectEventFunctions(getScope(node));
}),
$jscomp$compprop0
);
}
},
"exhaustive-deps": {
meta: {
type: "suggestion",
docs: {
description:
"verifies the list of dependencies for Hooks like useEffect and similar",
recommended: !0,
url: "https://github.com/facebook/react/issues/14920"
},
fixable: "code",
hasSuggestions: !0,
schema: [
{
type: "object",
additionalProperties: !1,
enableDangerousAutofixThisMayCauseInfiniteLoops: !1,
properties: {
additionalHooks: { type: "string" },
enableDangerousAutofixThisMayCauseInfiniteLoops: { type: "boolean" }
}
}
]
},
create: function (context) {
function reportProblem(problem) {
enableDangerousAutofixThisMayCauseInfiniteLoops &&
Array.isArray(problem.suggest) &&
0 < problem.suggest.length &&
(problem.fix = problem.suggest[0].fix);
context.report(problem);
}
function memoizeWithWeakMap(fn, map) {
return function (arg) {
if (map.has(arg)) return map.get(arg);
var result = fn(arg);
map.set(arg, result);
return result;
};
}
function visitFunctionWithDependencies(
node,
declaredDependenciesNode,
reactiveHook,
reactiveHookName,
isEffect
) {
function gatherDependenciesRecursively(currentScope) {
var _iterator2 = _createForOfIteratorHelper(currentScope.references),
_step2;
try {
for (_iterator2.s(); !(_step2 = _iterator2.n()).done; ) {
var reference = _step2.value;
if (
reference.resolved &&
pureScopes.has(reference.resolved.scope)
) {
var referenceNode = fastFindReferenceWithParent(
node,
reference.identifier
),
dependencyNode = getDependency(referenceNode),
dependency = analyzePropertyChain(
dependencyNode,
optionalChains
),
JSCompiler_temp;
if (
(JSCompiler_temp =
isEffect &&
"Identifier" === dependencyNode.type &&
("MemberExpression" === dependencyNode.parent.type ||
"OptionalMemberExpression" ===
dependencyNode.parent.type) &&
!dependencyNode.parent.computed &&
"Identifier" === dependencyNode.parent.property.type &&
"current" === dependencyNode.parent.property.name)
) {
for (
var curScope = reference.from, isInReturnedFunction = !1;
curScope.block !== node;
)
"function" === curScope.type &&
(isInReturnedFunction =
null != curScope.block.parent &&
"ReturnStatement" === curScope.block.parent.type),
(curScope = curScope.upper);
JSCompiler_temp = isInReturnedFunction;
}
JSCompiler_temp &&
currentRefsInEffectCleanup.set(dependency, {
reference: reference,
dependencyNode: dependencyNode
});
if (
"TSTypeQuery" !== dependencyNode.parent.type &&
"TSTypeReference" !== dependencyNode.parent.type
) {
var def = reference.resolved.defs[0];
if (
null != def &&
(null == def.node || def.node.init !== node.parent) &&
"TypeParameter" !== def.type
)
if (dependencies.has(dependency))
dependencies.get(dependency).references.push(reference);
else {
var resolved = reference.resolved,
isStable =
memoizedIsStableKnownHookValue(resolved) ||
memoizedIsFunctionWithoutCapturedValues(resolved);
dependencies.set(dependency, {
isStable: isStable,
references: [reference]
});
}
}
}
}
} catch (err) {
_iterator2.e(err);
} finally {
_iterator2.f();
}
currentScope = _createForOfIteratorHelper(currentScope.childScopes);
var _step3;
try {
for (currentScope.s(); !(_step3 = currentScope.n()).done; )
gatherDependenciesRecursively(_step3.value);
} catch (err$12) {
currentScope.e(err$12);
} finally {
currentScope.f();
}
}
function formatDependency(path) {
path = path.split(".");
for (var finalPath = "", i = 0; i < path.length; i++) {
if (0 !== i) {
var pathSoFar = path.slice(0, i + 1).join(".");
pathSoFar = !0 === optionalChains.get(pathSoFar);
finalPath += pathSoFar ? "?." : ".";
}
finalPath += path[i];
}
return finalPath;
}
function getWarningMessage(deps, singlePrefix, label, fixVerb) {
return 0 === deps.size
? null
: (1 < deps.size ? "" : singlePrefix + " ") +
label +
" " +
(1 < deps.size ? "dependencies" : "dependency") +
": " +
joinEnglish(
Array.from(deps)
.sort()
.map(function (name) {
return "'" + formatDependency(name) + "'";
})
) +
(". Either " +
fixVerb +
" " +
(1 < deps.size ? "them" : "it") +
" or remove the dependency array.");
}
isEffect &&
node.async &&
reportProblem({
node: node,
message:
"Effect callbacks are synchronous to prevent race conditions. Put the async function inside:\n\nuseEffect(() => {\n async function fetchData() {\n // You can await here\n const response = await MyAPI.getData(someId);\n // ...\n }\n fetchData();\n}, [someId]); // Or [] if effect doesn't need props or state\n\nLearn more about data fetching with Hooks: https://react.dev/link/hooks-data-fetching"
});
for (
var scope = scopeManager.acquire(node),
pureScopes = new Set(),
componentScope = null,
currentScope = scope.upper;
currentScope;
) {
pureScopes.add(currentScope);
if ("function" === currentScope.type) break;
currentScope = currentScope.upper;
}
if (currentScope) {
componentScope = currentScope;
var isArray = Array.isArray,
memoizedIsStableKnownHookValue = memoizeWithWeakMap(function (
resolved
) {
if (!isArray(resolved.defs)) return !1;
var def = resolved.defs[0];
if (null == def || "VariableDeclarator" !== def.node.type)
return !1;
var init = def.node.init;
if (null == init) return !1;
for (
;
"TSAsExpression" === init.type || "AsExpression" === init.type;
)
init = init.expression;
var declaration = def.node.parent;
if (
null == declaration &&
(fastFindReferenceWithParent(componentScope.block, def.node.id),
(declaration = def.node.parent),
null == declaration)
)
return !1;
if (
"const" === declaration.kind &&
"Literal" === init.type &&
("string" === typeof init.value ||
"number" === typeof init.value ||
null === init.value)
)
return !0;
if ("CallExpression" !== init.type) return !1;
init = init.callee;
"MemberExpression" !== init.type ||
"React" !== init.object.name ||
null == init.property ||
init.computed ||
(init = init.property);
if ("Identifier" !== init.type) return !1;
def = def.node.id;
init = init.name;
if ("useRef" === init && "Identifier" === def.type) return !0;
if ("useState" === init || "useReducer" === init) {
if (
"ArrayPattern" === def.type &&
2 === def.elements.length &&
isArray(resolved.identifiers)
) {
if (def.elements[1] === resolved.identifiers[0]) {
if ("useState" === init)
for (
resolved = resolved.references, declaration = init = 0;
declaration < resolved.length;
declaration++
) {
resolved[declaration].isWrite() && init++;
if (1 < init) return !1;
setStateCallSites.set(
resolved[declaration].identifier,
def.elements[0]
);
}
return !0;
}
if (
def.elements[0] === resolved.identifiers[0] &&
"useState" === init
)
for (
resolved = resolved.references, def = 0;
def < resolved.length;
def++
)
stateVariables.add(resolved[def].identifier);
}
} else if (
"useTransition" === init &&
"ArrayPattern" === def.type &&
2 === def.elements.length &&
Array.isArray(resolved.identifiers) &&
def.elements[1] === resolved.identifiers[0]
)
return !0;
return !1;
}, stableKnownValueCache),
memoizedIsFunctionWithoutCapturedValues = memoizeWithWeakMap(
function (resolved) {
if (!isArray(resolved.defs)) return !1;
resolved = resolved.defs[0];
if (
null == resolved ||
null == resolved.node ||
null == resolved.node.id
)
return !1;
var fnNode = resolved.node,
childScopes = componentScope.childScopes;
resolved = null;
var i;
for (i = 0; i < childScopes.length; i++) {
var childScope = childScopes[i],
childScopeBlock = childScope.block;
if (
("FunctionDeclaration" === fnNode.type &&
childScopeBlock === fnNode) ||
("VariableDeclarator" === fnNode.type &&
childScopeBlock.parent === fnNode)
) {
resolved = childScope;
break;
}
}
if (null == resolved) return !1;
for (i = 0; i < resolved.through.length; i++)
if (
((fnNode = resolved.through[i]),
null != fnNode.resolved &&
pureScopes.has(fnNode.resolved.scope) &&
!memoizedIsStableKnownHookValue(fnNode.resolved))
)
return !1;
return !0;
},
functionWithoutCapturedValueCache
),
currentRefsInEffectCleanup = new Map(),
dependencies = new Map(),
optionalChains = new Map();
gatherDependenciesRecursively(scope);
currentRefsInEffectCleanup.forEach(function (_ref, dependency) {
var dependencyNode = _ref.dependencyNode;
_ref = _ref.reference.resolved.references;
for (var foundCurrentAssignment = !1, i = 0; i < _ref.length; i++) {
var parent = _ref[i].identifier.parent;
if (
null != parent &&
"MemberExpression" === parent.type &&
!parent.computed &&
"Identifier" === parent.property.type &&
"current" === parent.property.name &&
"AssignmentExpression" === parent.parent.type &&
parent.parent.left === parent
) {
foundCurrentAssignment = !0;
break;
}
}
foundCurrentAssignment ||
reportProblem({
node: dependencyNode.parent.property,
message:
"The ref value '" +
dependency +
".current' will likely have changed by the time this effect cleanup function runs. If this ref points to a node rendered by React, copy '" +
(dependency +
".current' to a variable inside the effect, and use that variable in the cleanup function.")
});
});
var staleAssignments = new Set(),
stableDependencies = new Set();
dependencies.forEach(function (_ref2, key) {
var references = _ref2.references;
_ref2.isStable && stableDependencies.add(key);
references.forEach(function (reference) {
reference.writeExpr &&
((reference = reference.writeExpr),
staleAssignments.has(key) ||
(staleAssignments.add(key),
reportProblem({
node: reference,
message:
"Assignments to the '" +
key +
"' variable from inside React Hook " +
(getSource(reactiveHook) +
" will be lost after each render. To preserve the value over time, store it in a useRef Hook and keep the mutable value in the '.current' property. Otherwise, you can move this variable directly inside ") +
(getSource(reactiveHook) + ".")
})));
});
});
if (!(0 < staleAssignments.size))
if (declaredDependenciesNode) {
var declaredDependencies = [],
externalDependencies = new Set();
currentScope =
"TSAsExpression" === declaredDependenciesNode.type &&
"ArrayExpression" === declaredDependenciesNode.expression.type;
"ArrayExpression" === declaredDependenciesNode.type ||
currentScope
? (currentScope
? declaredDependenciesNode.expression
: declaredDependenciesNode
).elements.forEach(function (declaredDependencyNode) {
if (null !== declaredDependencyNode)
if ("SpreadElement" === declaredDependencyNode.type)
reportProblem({
node: declaredDependencyNode,
message:
"React Hook " +
getSource(reactiveHook) +
" has a spread element in its dependency array. This means we can't statically verify whether you've passed the correct dependencies."
});
else {
useEffectEventVariables.has(declaredDependencyNode) &&
reportProblem({
node: declaredDependencyNode,
message:
"Functions returned from `useEffectEvent` must not be included in the dependency array. Remove `" +
(getSource(declaredDependencyNode) +
"` from the list."),
suggest: [
{
desc:
"Remove the dependency `" +
getSource(declaredDependencyNode) +
"`",
fix: function (fixer) {
return fixer.removeRange(
declaredDependencyNode.range
);
}
}
]
});
try {
var declaredDependency = analyzePropertyChain(
declaredDependencyNode,
null
);
} catch (error) {
if (/Unsupported node type/.test(error.message)) {
"Literal" === declaredDependencyNode.type
? dependencies.has(declaredDependencyNode.value)
? reportProblem({
node: declaredDependencyNode,
message:
"The " +
declaredDependencyNode.raw +
" literal is not a valid dependency because it never changes. Did you mean to include " +
(declaredDependencyNode.value +
" in the array instead?")
})
: reportProblem({
node: declaredDependencyNode,
message:
"The " +
declaredDependencyNode.raw +
" literal is not a valid dependency because it never changes. You can safely remove it."
})
: reportProblem({
node: declaredDependencyNode,
message:
"React Hook " +
getSource(reactiveHook) +
" has a complex expression in the dependency array. Extract it to a separate variable so it can be statically checked."
});
return;
}
throw error;
}
for (
var maybeID = declaredDependencyNode;
"MemberExpression" === maybeID.type ||
"OptionalMemberExpression" === maybeID.type ||
"ChainExpression" === maybeID.type;
)
maybeID = maybeID.object || maybeID.expression.object;
var isDeclaredInComponent =
!componentScope.through.some(function (ref) {
return ref.identifier === maybeID;
});
declaredDependencies.push({
key: declaredDependency,
node: declaredDependencyNode
});
isDeclaredInComponent ||
externalDependencies.add(declaredDependency);
}
})
: reportProblem({
node: declaredDependenciesNode,
message:
"React Hook " +
getSource(reactiveHook) +
" was passed a dependency list that is not an array literal. This means we can't statically verify whether you've passed the correct dependencies."
});
var _collectRecommendatio2 = collectRecommendations({
dependencies: dependencies,
declaredDependencies: declaredDependencies,
stableDependencies: stableDependencies,
externalDependencies: externalDependencies,
isEffect: isEffect
});
currentScope = _collectRecommendatio2.unnecessaryDependencies;
var missingDependencies =
_collectRecommendatio2.missingDependencies,
duplicateDependencies =
_collectRecommendatio2.duplicateDependencies,
suggestedDeps = _collectRecommendatio2.suggestedDependencies;
if (
0 ===
duplicateDependencies.size +
missingDependencies.size +
currentScope.size
)
scanForConstructions({
declaredDependencies: declaredDependencies,
declaredDependenciesNode: declaredDependenciesNode,
componentScope: componentScope,
scope: scope
}).forEach(function (_ref4) {
var construction = _ref4.construction,
isUsedOutsideOfHook = _ref4.isUsedOutsideOfHook;
_ref4 = _ref4.depType;
var wrapperHook =
"function" === _ref4 ? "useCallback" : "useMemo",
constructionType =
"function" === _ref4 ? "definition" : "initialization",
defaultAdvice =
"wrap the " +
constructionType +
" of '" +
construction.name.name +
"' in its own " +
wrapperHook +
"() Hook.";
defaultAdvice =
"The '" +
construction.name.name +
"' " +
_ref4 +
" " +
("conditional" === _ref4 || "logical expression" === _ref4
? "could make"
: "makes") +
" the dependencies of " +
(reactiveHookName +
" Hook (at line " +
declaredDependenciesNode.loc.start.line +
") change on every render. ") +
(isUsedOutsideOfHook
? "To fix this, " + defaultAdvice
: "Move it inside the " +
reactiveHookName +
" callback. Alternatively, " +
defaultAdvice);
var suggest;
isUsedOutsideOfHook &&
"Variable" === construction.type &&
"function" === _ref4 &&
(suggest = [
{
desc:
"Wrap the " +
constructionType +
" of '" +
construction.name.name +
"' in its own " +
wrapperHook +
"() Hook.",
fix: function (fixer) {
var _ref5 =
"useMemo" === wrapperHook
? ["useMemo(() => { return ", "; })"]
: ["useCallback(", ")"],
after = _ref5[1];
return [
fixer.insertTextBefore(
construction.node.init,
_ref5[0]
),
fixer.insertTextAfter(construction.node.init, after)
];
}
}
]);
reportProblem({
node: construction.node,
message: defaultAdvice,
suggest: suggest
});
});
else {
!isEffect &&
0 < missingDependencies.size &&
(suggestedDeps = collectRecommendations({
dependencies: dependencies,
declaredDependencies: [],
stableDependencies: stableDependencies,
externalDependencies: externalDependencies,
isEffect: isEffect
}).suggestedDependencies);
(function () {
if (0 === declaredDependencies.length) return !0;
var declaredDepKeys = declaredDependencies.map(
function (dep) {
return dep.key;
}
),
sortedDeclaredDepKeys = declaredDepKeys.slice().sort();
return (
declaredDepKeys.join(",") ===
sortedDeclaredDepKeys.join(",")
);
})() && suggestedDeps.sort();
_collectRecommendatio2 = "";
if (0 < currentScope.size) {
var badRef = null;
Array.from(currentScope.keys()).forEach(function (key) {
null === badRef &&
key.endsWith(".current") &&
(badRef = key);
});
if (null !== badRef)
_collectRecommendatio2 =
" Mutable values like '" +
badRef +
"' aren't valid dependencies because mutating them doesn't re-render the component.";
else if (0 < externalDependencies.size) {
var dep = Array.from(externalDependencies)[0];
scope.set.has(dep) ||
(_collectRecommendatio2 =
" Outer scope values like '" +
dep +
"' aren't valid dependencies because mutating them doesn't re-render the component.");
}
}
if (
!_collectRecommendatio2 &&
missingDependencies.has("props")
) {
scope = dependencies.get("props");
if (null == scope) return;
scope = scope.references;
if (!Array.isArray(scope)) return;
dep = !0;
for (
var i$jscomp$0 = 0;
i$jscomp$0 < scope.length;
i$jscomp$0++
) {
var id = fastFindReferenceWithParent(
componentScope.block,
scope[i$jscomp$0].identifier
);
if (!id) {
dep = !1;
break;
}
id = id.parent;
if (null == id) {
dep = !1;
break;
}
if (
"MemberExpression" !== id.type &&
"OptionalMemberExpression" !== id.type
) {
dep = !1;
break;
}
}
dep &&
(_collectRecommendatio2 =
" However, 'props' will change when *any* prop changes, so the preferred fix is to destructure the 'props' object outside of the " +
(reactiveHookName +
" call and refer to those specific props inside ") +
(getSource(reactiveHook) + "."));
}
if (!_collectRecommendatio2 && 0 < missingDependencies.size) {
var missingCallbackDep = null;
missingDependencies.forEach(function (missingDep) {
if (!missingCallbackDep) {
var topScopeRef = componentScope.set.get(missingDep),
usedDep = dependencies.get(missingDep);
if (
usedDep.references[0].resolved === topScopeRef &&
((topScopeRef = topScopeRef.defs[0]),
null != topScopeRef &&
null != topScopeRef.name &&
"Parameter" === topScopeRef.type)
) {
topScopeRef = !1;
for (
var id, i$14 = 0;
i$14 < usedDep.references.length;
i$14++
)
if (
((id = usedDep.references[i$14].identifier),
null != id &&
null != id.parent &&
("CallExpression" === id.parent.type ||
"OptionalCallExpression" === id.parent.type) &&
id.parent.callee === id)
) {
topScopeRef = !0;
break;
}
topScopeRef && (missingCallbackDep = missingDep);
}
}
});
null !== missingCallbackDep &&
(_collectRecommendatio2 =
" If '" +
missingCallbackDep +
"' changes too often, find the parent component that defines it and wrap that definition in useCallback.");
}
if (!_collectRecommendatio2 && 0 < missingDependencies.size) {
var setStateRecommendation = null;
missingDependencies.forEach(function (missingDep) {
if (null === setStateRecommendation)
for (
var references =
dependencies.get(missingDep).references,
id,
maybeCall,
i$15 = 0;
i$15 < references.length;
i$15++
) {
id = references[i$15].identifier;
for (
maybeCall = id.parent;
null != maybeCall &&
maybeCall !== componentScope.block;
) {
if ("CallExpression" === maybeCall.type) {
var correspondingStateVariable =
setStateCallSites.get(maybeCall.callee);
if (null != correspondingStateVariable) {
correspondingStateVariable.name === missingDep
? (setStateRecommendation = {
missingDep: missingDep,
setter: maybeCall.callee.name,
form: "updater"
})
: stateVariables.has(id)
? (setStateRecommendation = {
missingDep: missingDep,
setter: maybeCall.callee.name,
form: "reducer"
})
: ((id = references[i$15].resolved),
null != id &&
((id = id.defs[0]),
null != id &&
"Parameter" === id.type &&
(setStateRecommendation = {
missingDep: missingDep,
setter: maybeCall.callee.name,
form: "inlineReducer"
})));
break;
}
}
maybeCall = maybeCall.parent;
}
if (null !== setStateRecommendation) break;
}
});
if (null !== setStateRecommendation)
switch (setStateRecommendation.form) {
case "reducer":
_collectRecommendatio2 =
" You can also replace multiple useState variables with useReducer if '" +
(setStateRecommendation.setter +
"' needs the current value of '") +
(setStateRecommendation.missingDep + "'.");
break;
case "inlineReducer":
_collectRecommendatio2 =
" If '" +
setStateRecommendation.setter +
"' needs the current value of '" +
(setStateRecommendation.missingDep +
"', you can also switch to useReducer instead of useState and read '") +
(setStateRecommendation.missingDep +
"' in the reducer.");
break;
case "updater":
_collectRecommendatio2 =
" You can also do a functional update '" +
setStateRecommendation.setter +
"(" +
setStateRecommendation.missingDep.slice(0, 1) +
" => ...)' if you only need '" +
setStateRecommendation.missingDep +
"' in the '" +
(setStateRecommendation.setter + "' call.");
break;
default:
throw Error("Unknown case.");
}
}
reportProblem({
node: declaredDependenciesNode,
message:
"React Hook " +
getSource(reactiveHook) +
" has " +
(getWarningMessage(
missingDependencies,
"a",
"missing",
"include"
) ||
getWarningMessage(
currentScope,
"an",
"unnecessary",
"exclude"
) ||
getWarningMessage(
duplicateDependencies,
"a",
"duplicate",
"omit"
)) +
_collectRecommendatio2,
suggest: [
{
desc:
"Update the dependencies array to be: [" +
suggestedDeps.map(formatDependency).join(", ") +
"]",
fix: function (fixer) {
return fixer.replaceText(
declaredDependenciesNode,
"[" +
suggestedDeps.map(formatDependency).join(", ") +
"]"
);
}
}
]
});
}
} else {
var setStateInsideEffectWithoutDeps = null;
dependencies.forEach(function (_ref3, key) {
setStateInsideEffectWithoutDeps ||
_ref3.references.forEach(function (reference) {
if (
!setStateInsideEffectWithoutDeps &&
setStateCallSites.has(reference.identifier)
) {
for (
reference = reference.from;
"function" !== reference.type;
)
reference = reference.upper;
reference.block === node &&
(setStateInsideEffectWithoutDeps = key);
}
});
});
if (setStateInsideEffectWithoutDeps) {
var suggestedDependencies$13 = collectRecommendations({
dependencies: dependencies,
declaredDependencies: [],
stableDependencies: stableDependencies,
externalDependencies: new Set(),
isEffect: !0
}).suggestedDependencies;
reportProblem({
node: reactiveHook,
message:
"React Hook " +
reactiveHookName +
" contains a call to '" +
setStateInsideEffectWithoutDeps +
"'. Without a list of dependencies, this can lead to an infinite chain of updates. To fix this, pass [" +
suggestedDependencies$13.join(", ") +
("] as a second argument to the " +
reactiveHookName +
" Hook."),
suggest: [
{
desc:
"Add dependencies array: [" +
suggestedDependencies$13.join(", ") +
"]",
fix: function (fixer) {
return fixer.insertTextAfter(
node,
", [" + suggestedDependencies$13.join(", ") + "]"
);
}
}
]
});
}
}
}
}
var enableDangerousAutofixThisMayCauseInfiniteLoops =
(context.options &&
context.options[0] &&
context.options[0]
.enableDangerousAutofixThisMayCauseInfiniteLoops) ||
!1,
options = {
additionalHooks:
context.options &&
context.options[0] &&
context.options[0].additionalHooks
? new RegExp(context.options[0].additionalHooks)
: void 0,
enableDangerousAutofixThisMayCauseInfiniteLoops:
enableDangerousAutofixThisMayCauseInfiniteLoops
},
getSource =
"function" === typeof context.getSource
? function (node) {
return context.getSource(node);
}
: function (node) {
return context.sourceCode.getText(node);
},
getScope =
"function" === typeof context.getScope
? function () {
return context.getScope();
}
: function (node) {
return context.sourceCode.getScope(node);
},
scopeManager = context.getSourceCode().scopeManager,
setStateCallSites = new WeakMap(),
stateVariables = new WeakSet(),
stableKnownValueCache = new WeakMap(),
functionWithoutCapturedValueCache = new WeakMap(),
useEffectEventVariables = new WeakSet();
return {
CallExpression: function (node) {
var callbackIndex = getReactiveHookCallbackIndex(
node.callee,
options
);
if (-1 !== callbackIndex) {
var callback = node.arguments[callbackIndex],
reactiveHook = node.callee,
reactiveHookName =
getNodeWithoutReactNamespace(reactiveHook).name;
node = node.arguments[callbackIndex + 1];
var declaredDependenciesNode =
!node || ("Identifier" === node.type && "undefined" === node.name)
? void 0
: node;
node = /Effect($|[^a-z])/g.test(reactiveHookName);
if (callback)
if (declaredDependenciesNode || node) {
switch (callback.type) {
case "FunctionExpression":
case "ArrowFunctionExpression":
visitFunctionWithDependencies(
callback,
declaredDependenciesNode,
reactiveHook,
reactiveHookName,
node
);
return;
case "TSAsExpression":
visitFunctionWithDependencies(
callback.expression,
declaredDependenciesNode,
reactiveHook,
reactiveHookName,
node
);
return;
case "Identifier":
if (
!declaredDependenciesNode ||
(declaredDependenciesNode.elements &&
declaredDependenciesNode.elements.some(function (el) {
return (
el &&
"Identifier" === el.type &&
el.name === callback.name
);
}))
)
return;
callbackIndex = getScope(callback).set.get(callback.name);
if (null == callbackIndex || null == callbackIndex.defs)
return;
callbackIndex = callbackIndex.defs[0];
if (!callbackIndex || !callbackIndex.node) break;
if (
"Variable" !== callbackIndex.type &&
"FunctionName" !== callbackIndex.type
)
break;
switch (callbackIndex.node.type) {
case "FunctionDeclaration":
visitFunctionWithDependencies(
callbackIndex.node,
declaredDependenciesNode,
reactiveHook,
reactiveHookName,
node
);
return;
case "VariableDeclarator":
if ((callbackIndex = callbackIndex.node.init))
switch (callbackIndex.type) {
case "ArrowFunctionExpression":
case "FunctionExpression":
visitFunctionWithDependencies(
callbackIndex,
declaredDependenciesNode,
reactiveHook,
reactiveHookName,
node
);
return;
}
}
break;
default:
reportProblem({
node: reactiveHook,
message:
"React Hook " +
reactiveHookName +
" received a function whose dependencies are unknown. Pass an inline function instead."
});
return;
}
reportProblem({
node: reactiveHook,
message:
"React Hook " +
reactiveHookName +
" has a missing dependency: '" +
callback.name +
"'. Either include it or remove the dependency array.",
suggest: [
{
desc:
"Update the dependencies array to be: [" +
callback.name +
"]",
fix: function (fixer) {
return fixer.replaceText(
declaredDependenciesNode,
"[" + callback.name + "]"
);
}
}
]
});
} else
("useMemo" !== reactiveHookName &&
"useCallback" !== reactiveHookName) ||
reportProblem({
node: reactiveHook,
message:
"React Hook " +
reactiveHookName +
" does nothing when called with only one argument. Did you forget to pass an array of dependencies?"
});
else
reportProblem({
node: reactiveHook,
message:
"React Hook " +
reactiveHookName +
" requires an effect callback. Did you forget to pass a callback to the hook?"
});
}
}
};
}
}
};